npm install @reaatech/llm-router-engine
# or
pnpm add @reaatech/llm-router-engine

import { LLMRouter, parseRouterConfig } from "@reaatech/llm-router-engine";
 
const config = parseRouterConfig(`
models:
  workhorses:
    - id: glm-edge
      provider: zhipu
      cost_per_million_input: 0.30
      cost_per_million_output: 0.60
      max_tokens: 128000
      capabilities: [general]
  judges:
    - id: claude-opus
      provider: anthropic
      cost_per_million_input: 15.00
      cost_per_million_output: 75.00
      max_tokens: 200000
      capabilities: [evaluation, complex-reasoning]
strategies:
  default:
    type: cost-optimized
    workhorse_pool: [glm-edge]
  complex:
    type: judgment-based
    workhorse_pool: [glm-edge]
    judge_pool: [claude-opus]
budgets:
  default:
    daily_limit: 25
    alert_thresholds: [0.5, 0.75, 0.9]
    hard_limit: true
`);
 
const router = LLMRouter.fromConfig(config, {
  executeModel: async (model, request) => {
    const response = await myProviderSDK.complete({
      model: model.id,
      prompt: request.prompt,
      maxTokens: request.maxTokens,
    });
    return { content: response.text, inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens };
  },
});
 
const result = await router.route({
  prompt: "Explain the Observer pattern in TypeScript.",
  strategy: "cost-optimized",
});
 
console.log(result.model.id, result.cost, result.latencyMs);

import { createRouter } from "@reaatech/llm-router-engine";
 
const router = createRouter({ executeModel: myExecutor });

import { ModelRegistry } from "@reaatech/llm-router-engine";
 
const registry = new ModelRegistry();
registry.register({
  id: "gpt-4-turbo",
  provider: "openai",
  costPerMillionInput: 10,
  costPerMillionOutput: 30,
  maxTokens: 128000,
  capabilities: ["code", "reasoning"],
  apiKeyEnv: "OPENAI_API_KEY",
});

import { ProviderClientFactory } from "@reaatech/llm-router-engine";
 
const factory = ProviderClientFactory.getInstance();
 
factory.registerClientFactory("openai", () => ({
  provider: "openai",
  async complete(options) {
    const response = await openai.chat.completions.create({
      model: options.modelId ?? "gpt-4-turbo",
      messages: [{ role: "user", content: options.prompt }],
      max_tokens: options.maxTokens,
    });
    return {
      content: response.choices[0]?.message?.content ?? "",
      inputTokens: response.usage?.prompt_tokens ?? 0,
      outputTokens: response.usage?.completion_tokens ?? 0,
    };
  },
}));

import { QualityScorer, createRuleBasedScorer } from "@reaatech/llm-router-engine";
 
const scorer = new QualityScorer();
 
// Register a rule-based scorer (included by default)
scorer.register("rule-based", createRuleBasedScorer(), true);
 
// Score a result
const score = await scorer.score(request, result, model);
console.log(score.overall, score.relevance, score.correctness);

import { evalHooksManager } from "@reaatech/llm-router-engine";
 
evalHooksManager.onPreRouting(async (request, context) => {
  if (request.userTier === "premium") {
    request.confidenceThreshold = 0.95;
  }
  return request;
});
 
evalHooksManager.onPostExecution(async (result, decision, request, context) => {
  await analytics.track("routing_complete", {
    modelId: decision.modelId,
    cost: result.actualCost,
  });
  return result;
});

import { ABTestManager } from "@reaatech/llm-router-engine";
 
const ab = new ABTestManager();
ab.start({
  testA: { modelId: "glm-edge", trafficPercent: 50 },
  testB: { modelId: "kat-coder-pro", trafficPercent: 50 },
});
 
const selectedModel = ab.select(); // Randomly assigns to A or B
ab.record(selectedModel, { latencyMs: 42, qualityScore: 4.5 });
 
const stats = ab.getStats();
console.log(stats.testA.winRate, stats.testB.winRate);

import { PerformanceTracker } from "@reaatech/llm-router-engine";
 
const tracker = new PerformanceTracker();
tracker.record("glm-edge", 42, true, 4.5);
 
const perf = tracker.getAllPerformance([modelDef1, modelDef2]);
console.log(perf[0].latencyP50, perf[0].latencyP95);

import { loadRouterConfig, parseRouterConfig } from "@reaatech/llm-router-engine";
 
// Load from file
const config = loadRouterConfig("llm-router.config.yaml");
 
// Parse from string
const config2 = parseRouterConfig(`...`);

import {
  createLogger,
  setupTracing,
  MetricsCollector,
  ObservabilityDashboard,
} from "@reaatech/llm-router-engine";