@yzj01/llm-router 1.0.0

package/dist/cli.js

@@ -0,0 +1,2490 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { fileURLToPath } from "url";
+
+// src/config-loader.ts
+import { readFileSync } from "fs";
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function assertFiniteNumber(value, path) {
+  if (!isFiniteNumber(value)) {
+    throw new Error(`${path} must be a finite number`);
+  }
+}
+function assertPublicModelMetadata(value, path) {
+  if (!value || typeof value !== "object") {
+    throw new Error(`${path}.metadata is required`);
+  }
+  const metadata = value;
+  const metadataPath = `${path}.metadata`;
+  for (const key of ["name", "reasoning", "contextWindow", "maxTokens", "cost"]) {
+    if (!hasOwn(metadata, key)) {
+      throw new Error(`${metadataPath}.${key} is required`);
+    }
+  }
+  if (typeof metadata.name !== "string") {
+    throw new Error(`${metadataPath}.name must be a string`);
+  }
+  if (typeof metadata.reasoning !== "boolean") {
+    throw new Error(`${metadataPath}.reasoning must be a boolean`);
+  }
+  if (typeof metadata.contextWindow !== "number") {
+    throw new Error(`${metadataPath}.contextWindow must be a number`);
+  }
+  if (typeof metadata.maxTokens !== "number") {
+    throw new Error(`${metadataPath}.maxTokens must be a number`);
+  }
+  if (!metadata.cost || typeof metadata.cost !== "object") {
+    throw new Error(`${metadataPath}.cost must be an object`);
+  }
+  const cost = metadata.cost;
+  const costPath = `${metadataPath}.cost`;
+  for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+    if (!hasOwn(cost, key)) {
+      throw new Error(`${costPath}.${key} is required`);
+    }
+  }
+  for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+    if (typeof cost[key] !== "number") {
+      throw new Error(`${costPath}.${key} must be a number`);
+    }
+  }
+}
+function assertAliasPublicModel(publicModels, id, path) {
+  const publicModel = publicModels[id];
+  if (!publicModel) {
+    throw new Error(`${path} references unknown publicModel: ${id}`);
+  }
+  if (publicModel.kind !== "alias") {
+    throw new Error(`${path} must reference a publicModel with kind: "alias"`);
+  }
+}
+function loadConfig(source) {
+  const raw = source.kind === "inline" ? source.config : JSON.parse(readFileSync(source.path, "utf-8"));
+  validateConfig(raw);
+  return raw;
+}
+function validateConfig(config) {
+  const modelIds = /* @__PURE__ */ new Set();
+  for (const model of config.models) {
+    if (modelIds.has(model.id)) {
+      throw new Error(`Duplicate model ID: ${model.id}`);
+    }
+    modelIds.add(model.id);
+  }
+  const auto = config.publicModels.auto;
+  if (!auto || auto.kind !== "router") {
+    throw new Error('publicModels must contain "auto" with kind: "router"');
+  }
+  assertPublicModelMetadata(auto.metadata, "publicModels.auto");
+  for (const [publicModelId, publicModel] of Object.entries(config.publicModels)) {
+    if (publicModel.kind === "router") {
+      if (publicModelId !== "auto") {
+        throw new Error(`publicModels.${publicModelId}: only auto may use kind: "router"`);
+      }
+      assertPublicModelMetadata(publicModel.metadata, `publicModels.${publicModelId}`);
+      continue;
+    }
+    if (!Array.isArray(publicModel.candidates) || publicModel.candidates.length === 0) {
+      throw new Error(`publicModels.${publicModelId}.candidates must not be empty`);
+    }
+    for (const candidate of publicModel.candidates) {
+      if (!modelIds.has(candidate)) {
+        throw new Error(`Unknown candidate '${candidate}' in publicModels.${publicModelId}`);
+      }
+    }
+    if (publicModel.metadata != null) {
+      assertPublicModelMetadata(publicModel.metadata, `publicModels.${publicModelId}`);
+    }
+  }
+  for (const tier of ["SIMPLE", "MEDIUM", "COMPLEX", "REASONING"]) {
+    if (!config.routing.tiers[tier]) {
+      throw new Error(`routing.tiers.${tier} is required`);
+    }
+  }
+  for (const [tier, tierConfig] of Object.entries(config.routing.tiers)) {
+    assertAliasPublicModel(config.publicModels, tierConfig.publicModel, `routing.tiers.${tier}.publicModel`);
+    for (const fallbackId of tierConfig.fallback ?? []) {
+      assertAliasPublicModel(config.publicModels, fallbackId, `routing.tiers.${tier}.fallback`);
+    }
+  }
+  if (hasOwn(config.routing, "tierBoundaries")) {
+    const tierBoundaries = config.routing.tierBoundaries;
+    if (!tierBoundaries || typeof tierBoundaries !== "object" || Array.isArray(tierBoundaries)) {
+      throw new Error("routing.tierBoundaries must be an object");
+    }
+    const { simpleMedium, mediumComplex, complexReasoning } = tierBoundaries;
+    assertFiniteNumber(simpleMedium, "routing.tierBoundaries.simpleMedium");
+    assertFiniteNumber(mediumComplex, "routing.tierBoundaries.mediumComplex");
+    assertFiniteNumber(complexReasoning, "routing.tierBoundaries.complexReasoning");
+    if (!(simpleMedium <= mediumComplex && mediumComplex <= complexReasoning)) {
+      throw new Error(
+        "routing.tierBoundaries must satisfy simpleMedium <= mediumComplex <= complexReasoning"
+      );
+    }
+  }
+  if (hasOwn(config.routing, "confidenceThreshold")) {
+    assertFiniteNumber(config.routing.confidenceThreshold, "routing.confidenceThreshold");
+    if (config.routing.confidenceThreshold < 0 || config.routing.confidenceThreshold > 1) {
+      throw new Error("routing.confidenceThreshold must be between 0 and 1");
+    }
+  }
+  if (!Number.isInteger(config.proxy.port) || config.proxy.port < 1 || config.proxy.port > 65535) {
+    throw new Error(`proxy.port must be an integer between 1-65535, got: ${config.proxy.port}`);
+  }
+  if (config.proxy.headers) {
+    for (const [key, value] of Object.entries(config.proxy.headers)) {
+      if (typeof value !== "string") {
+        throw new Error(`proxy.headers['${key}'] must be a string, got: ${typeof value}`);
+      }
+    }
+  }
+}
+
+// src/proxy-config-resolver.ts
+function resolveProxyConfig(baseConfig, overrides = {}) {
+  const mergedHeaders = mergeHeaders(baseConfig.headers, overrides.headers);
+  return {
+    port: overrides.port ?? baseConfig.port,
+    upstreamUrl: overrides.upstreamUrl ?? baseConfig.upstreamUrl,
+    apiKey: overrides.apiKey ?? baseConfig.apiKey,
+    headers: mergedHeaders,
+    trace: overrides.trace ?? baseConfig.trace
+  };
+}
+function mergeHeaders(base, override) {
+  if (base === void 0 && override === void 0) {
+    return void 0;
+  }
+  return { ...base, ...override };
+}
+
+// src/proxy.ts
+import http from "http";
+
+// src/router/rules.ts
+function scoreTokenCount(estimatedTokens, thresholds) {
+  if (estimatedTokens < thresholds.simple) {
+    return { name: "tokenCount", score: -1, signal: `short (${estimatedTokens} tokens)` };
+  }
+  if (estimatedTokens > thresholds.complex) {
+    return { name: "tokenCount", score: 1, signal: `long (${estimatedTokens} tokens)` };
+  }
+  return { name: "tokenCount", score: 0, signal: null };
+}
+function scoreKeywordMatch(text, keywords, name, signalLabel, thresholds, scores) {
+  const matches = keywords.filter((keyword) => text.includes(keyword.toLowerCase()));
+  if (matches.length >= thresholds.high) {
+    return { name, score: scores.high, signal: `${signalLabel} (${matches.slice(0, 3).join(", ")})` };
+  }
+  if (matches.length >= thresholds.low) {
+    return { name, score: scores.low, signal: `${signalLabel} (${matches.slice(0, 3).join(", ")})` };
+  }
+  return { name, score: scores.none, signal: null };
+}
+function scoreMultiStep(text) {
+  const patterns = [/first.*then/i, /step \d/i, /\d\.\s/];
+  return patterns.some((pattern) => pattern.test(text)) ? { name: "multiStepPatterns", score: 0.5, signal: "multi-step" } : { name: "multiStepPatterns", score: 0, signal: null };
+}
+function scoreQuestionComplexity(prompt) {
+  const count = (prompt.match(/\?/g) ?? []).length;
+  return count > 3 ? { name: "questionComplexity", score: 0.5, signal: `${count} questions` } : { name: "questionComplexity", score: 0, signal: null };
+}
+function scoreAgenticTask(text, keywords) {
+  let matchCount = 0;
+  const signals = [];
+  for (const keyword of keywords) {
+    if (text.includes(keyword.toLowerCase())) {
+      matchCount++;
+      if (signals.length < 3) signals.push(keyword);
+    }
+  }
+  if (matchCount >= 4) {
+    return {
+      dimensionScore: { name: "agenticTask", score: 1, signal: `agentic (${signals.join(", ")})` },
+      agenticScore: 1
+    };
+  }
+  if (matchCount >= 3) {
+    return {
+      dimensionScore: { name: "agenticTask", score: 0.6, signal: `agentic (${signals.join(", ")})` },
+      agenticScore: 0.6
+    };
+  }
+  if (matchCount >= 1) {
+    return {
+      dimensionScore: { name: "agenticTask", score: 0.2, signal: `agentic-light (${signals.join(", ")})` },
+      agenticScore: 0.2
+    };
+  }
+  return {
+    dimensionScore: { name: "agenticTask", score: 0, signal: null },
+    agenticScore: 0
+  };
+}
+function classifyByRules(prompt, _systemPrompt, estimatedTokens, config) {
+  const userText = prompt.toLowerCase();
+  const dimensions = [
+    scoreTokenCount(estimatedTokens, config.tokenCountThresholds),
+    scoreKeywordMatch(userText, config.codeKeywords, "codePresence", "code", { low: 1, high: 2 }, { none: 0, low: 0.5, high: 1 }),
+    scoreKeywordMatch(userText, config.reasoningKeywords, "reasoningMarkers", "reasoning", { low: 1, high: 2 }, { none: 0, low: 0.7, high: 1 }),
+    scoreKeywordMatch(userText, config.technicalKeywords, "technicalTerms", "technical", { low: 2, high: 4 }, { none: 0, low: 0.5, high: 1 }),
+    scoreKeywordMatch(userText, config.creativeKeywords, "creativeMarkers", "creative", { low: 1, high: 2 }, { none: 0, low: 0.5, high: 0.7 }),
+    scoreKeywordMatch(userText, config.simpleKeywords, "simpleIndicators", "simple", { low: 1, high: 2 }, { none: 0, low: -1, high: -1 }),
+    scoreMultiStep(userText),
+    scoreQuestionComplexity(prompt),
+    scoreKeywordMatch(userText, config.imperativeVerbs, "imperativeVerbs", "imperative", { low: 1, high: 2 }, { none: 0, low: 0.3, high: 0.5 }),
+    scoreKeywordMatch(userText, config.constraintIndicators, "constraintCount", "constraints", { low: 1, high: 3 }, { none: 0, low: 0.3, high: 0.7 }),
+    scoreKeywordMatch(userText, config.outputFormatKeywords, "outputFormat", "format", { low: 1, high: 2 }, { none: 0, low: 0.4, high: 0.7 }),
+    scoreKeywordMatch(userText, config.referenceKeywords, "referenceComplexity", "references", { low: 1, high: 2 }, { none: 0, low: 0.3, high: 0.5 }),
+    scoreKeywordMatch(userText, config.negationKeywords, "negationComplexity", "negation", { low: 2, high: 3 }, { none: 0, low: 0.3, high: 0.5 }),
+    scoreKeywordMatch(userText, config.domainSpecificKeywords, "domainSpecificity", "domain-specific", { low: 1, high: 2 }, { none: 0, low: 0.5, high: 0.8 })
+  ];
+  const agenticResult = scoreAgenticTask(userText, config.agenticTaskKeywords);
+  dimensions.push(agenticResult.dimensionScore);
+  const signals = dimensions.filter((dimension) => dimension.signal !== null).map((dimension) => dimension.signal);
+  const weightedScore = dimensions.reduce(
+    (score, dimension) => score + dimension.score * (config.dimensionWeights[dimension.name] ?? 0),
+    0
+  );
+  const reasoningMatches = config.reasoningKeywords.filter(
+    (keyword) => userText.includes(keyword.toLowerCase())
+  );
+  if (reasoningMatches.length >= 2) {
+    return {
+      score: weightedScore,
+      tier: "REASONING",
+      confidence: Math.max(calibrateConfidence(Math.max(weightedScore, 0.3), config.confidenceSteepness), 0.85),
+      signals,
+      agenticScore: agenticResult.agenticScore,
+      dimensions
+    };
+  }
+  const { simpleMedium, mediumComplex, complexReasoning } = config.tierBoundaries;
+  let tier;
+  let distanceFromBoundary;
+  if (weightedScore < simpleMedium) {
+    tier = "SIMPLE";
+    distanceFromBoundary = simpleMedium - weightedScore;
+  } else if (weightedScore < mediumComplex) {
+    tier = "MEDIUM";
+    distanceFromBoundary = Math.min(weightedScore - simpleMedium, mediumComplex - weightedScore);
+  } else if (weightedScore < complexReasoning) {
+    tier = "COMPLEX";
+    distanceFromBoundary = Math.min(weightedScore - mediumComplex, complexReasoning - weightedScore);
+  } else {
+    tier = "REASONING";
+    distanceFromBoundary = weightedScore - complexReasoning;
+  }
+  const confidence = calibrateConfidence(distanceFromBoundary, config.confidenceSteepness);
+  if (confidence < config.confidenceThreshold) {
+    return {
+      score: weightedScore,
+      tier: null,
+      confidence,
+      signals,
+      agenticScore: agenticResult.agenticScore,
+      dimensions
+    };
+  }
+  return {
+    score: weightedScore,
+    tier,
+    confidence,
+    signals,
+    agenticScore: agenticResult.agenticScore,
+    dimensions
+  };
+}
+function calibrateConfidence(distance, steepness) {
+  return 1 / (1 + Math.exp(-steepness * distance));
+}
+
+// src/router/selector.ts
+var DEFAULT_BASELINE_INPUT_PRICE = 0.56;
+var DEFAULT_BASELINE_OUTPUT_PRICE = 1.68;
+function selectModel(tier, confidence, method, reasoning, tierConfigs, modelPricing, estimatedInputTokens, maxOutputTokens, agenticScore, score) {
+  const config = tierConfigs[tier];
+  if (!config) {
+    throw new Error(`Missing tier config for ${tier}`);
+  }
+  const model = config.primary;
+  const baselineModel = tierConfigs["COMPLEX"].primary;
+  const costs = calculateModelCost(
+    model,
+    modelPricing,
+    estimatedInputTokens,
+    maxOutputTokens,
+    baselineModel
+  );
+  return {
+    publicModel: model,
+    tier,
+    confidence,
+    method,
+    reasoning,
+    ...costs,
+    ...agenticScore !== void 0 && { agenticScore },
+    ...score !== void 0 && { score }
+  };
+}
+function calculateModelCost(model, modelPricing, estimatedInputTokens, maxOutputTokens, baselineModelId) {
+  const pricing = modelPricing.get(model);
+  const inputCost = estimatedInputTokens / 1e6 * (pricing?.inputPrice ?? 0);
+  const outputCost = maxOutputTokens / 1e6 * (pricing?.outputPrice ?? 0);
+  const costEstimate = inputCost + outputCost;
+  const baselinePricing = baselineModelId ? modelPricing.get(baselineModelId) : void 0;
+  const baselineInput = estimatedInputTokens / 1e6 * (baselinePricing?.inputPrice ?? DEFAULT_BASELINE_INPUT_PRICE);
+  const baselineOutput = maxOutputTokens / 1e6 * (baselinePricing?.outputPrice ?? DEFAULT_BASELINE_OUTPUT_PRICE);
+  const baselineCost = baselineInput + baselineOutput;
+  const savings = baselineCost > 0 ? Math.max(0, (baselineCost - costEstimate) / baselineCost) : 0;
+  return { costEstimate, baselineCost, savings };
+}
+
+// src/router/strategy.ts
+var RulesStrategy = class {
+  name = "rules";
+  route(prompt, systemPrompt, maxOutputTokens, options) {
+    const { config, modelPricing } = options;
+    if (!config) {
+      throw new Error("Routing config is required at runtime");
+    }
+    if (!modelPricing) {
+      throw new Error("Model pricing is required at runtime");
+    }
+    const fullText = `${systemPrompt ?? ""} ${prompt}`;
+    const estimatedTokens = Math.ceil(fullText.length / 4);
+    const ruleResult = classifyByRules(
+      prompt,
+      systemPrompt,
+      estimatedTokens,
+      config.scoring
+    );
+    const { tierConfigs, profile, profileSuffix } = chooseTierConfigs(options);
+    const hasStructuredOutput = systemPrompt ? /json|structured|schema/i.test(systemPrompt) : false;
+    let tier;
+    let confidence;
+    let reasoning = `score=${ruleResult.score.toFixed(2)} | ${ruleResult.signals.join(", ")}`;
+    if (ruleResult.tier !== null) {
+      tier = ruleResult.tier;
+      confidence = ruleResult.confidence;
+    } else {
+      tier = config.overrides?.ambiguousDefaultTier ?? "MEDIUM";
+      confidence = 0.5;
+      reasoning += ` | ambiguous -> default: ${tier}`;
+    }
+    if (hasStructuredOutput) {
+      const tierRank = {
+        SIMPLE: 0,
+        MEDIUM: 1,
+        COMPLEX: 2,
+        REASONING: 3
+      };
+      const minTier = config.overrides?.structuredOutputMinTier ?? "MEDIUM";
+      if (tierRank[tier] < tierRank[minTier]) {
+        reasoning += ` | upgraded to ${minTier} (structured output)`;
+        tier = minTier;
+      } else {
+        reasoning += " | structured output";
+      }
+    }
+    reasoning += profileSuffix;
+    const decision = selectModel(
+      tier,
+      confidence,
+      "rules",
+      reasoning,
+      tierConfigs,
+      modelPricing,
+      estimatedTokens,
+      maxOutputTokens,
+      ruleResult.agenticScore,
+      ruleResult.score
+    );
+    return { ...decision, tierConfigs, profile };
+  }
+};
+function chooseTierConfigs(options) {
+  const config = options?.config;
+  if (!config?.tiers) {
+    throw new Error("Routing tiers are required at runtime");
+  }
+  return {
+    tierConfigs: config.tiers,
+    profile: "default",
+    profileSuffix: ""
+  };
+}
+var registry = /* @__PURE__ */ new Map();
+registry.set("rules", new RulesStrategy());
+function getStrategy(name) {
+  const strategy = registry.get(name);
+  if (!strategy) {
+    throw new Error(`Unknown routing strategy: ${name}`);
+  }
+  return strategy;
+}
+
+// src/router/config.ts
+var DEFAULT_ROUTING_CONFIG = {
+  version: "2.0",
+  scoring: {
+    tokenCountThresholds: { simple: 50, complex: 500 },
+    // Multilingual keywords: EN + ZH + JA + RU + DE + ES + PT + KO + AR
+    codeKeywords: [
+      // English
+      "function",
+      "class",
+      "import",
+      "def",
+      "SELECT",
+      "async",
+      "await",
+      "const",
+      "let",
+      "var",
+      "return",
+      "```",
+      // Chinese
+      "\u51FD\u6570",
+      "\u7C7B",
+      "\u5BFC\u5165",
+      "\u5B9A\u4E49",
+      "\u67E5\u8BE2",
+      "\u5F02\u6B65",
+      "\u7B49\u5F85",
+      "\u5E38\u91CF",
+      "\u53D8\u91CF",
+      "\u8FD4\u56DE",
+      // Japanese
+      "\u95A2\u6570",
+      "\u30AF\u30E9\u30B9",
+      "\u30A4\u30F3\u30DD\u30FC\u30C8",
+      "\u975E\u540C\u671F",
+      "\u5B9A\u6570",
+      "\u5909\u6570",
+      // Russian
+      "\u0444\u0443\u043D\u043A\u0446\u0438\u044F",
+      "\u043A\u043B\u0430\u0441\u0441",
+      "\u0438\u043C\u043F\u043E\u0440\u0442",
+      "\u043E\u043F\u0440\u0435\u0434\u0435\u043B",
+      "\u0437\u0430\u043F\u0440\u043E\u0441",
+      "\u0430\u0441\u0438\u043D\u0445\u0440\u043E\u043D\u043D\u044B\u0439",
+      "\u043E\u0436\u0438\u0434\u0430\u0442\u044C",
+      "\u043A\u043E\u043D\u0441\u0442\u0430\u043D\u0442\u0430",
+      "\u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u0430\u044F",
+      "\u0432\u0435\u0440\u043D\u0443\u0442\u044C",
+      // German
+      "funktion",
+      "klasse",
+      "importieren",
+      "definieren",
+      "abfrage",
+      "asynchron",
+      "erwarten",
+      "konstante",
+      "variable",
+      "zur\xFCckgeben",
+      // Spanish
+      "funci\xF3n",
+      "clase",
+      "importar",
+      "definir",
+      "consulta",
+      "as\xEDncrono",
+      "esperar",
+      "constante",
+      "variable",
+      "retornar",
+      // Portuguese
+      "fun\xE7\xE3o",
+      "classe",
+      "importar",
+      "definir",
+      "consulta",
+      "ass\xEDncrono",
+      "aguardar",
+      "constante",
+      "vari\xE1vel",
+      "retornar",
+      // Korean
+      "\uD568\uC218",
+      "\uD074\uB798\uC2A4",
+      "\uAC00\uC838\uC624\uAE30",
+      "\uC815\uC758",
+      "\uCFFC\uB9AC",
+      "\uBE44\uB3D9\uAE30",
+      "\uB300\uAE30",
+      "\uC0C1\uC218",
+      "\uBCC0\uC218",
+      "\uBC18\uD658",
+      // Arabic
+      "\u062F\u0627\u0644\u0629",
+      "\u0641\u0626\u0629",
+      "\u0627\u0633\u062A\u064A\u0631\u0627\u062F",
+      "\u062A\u0639\u0631\u064A\u0641",
+      "\u0627\u0633\u062A\u0639\u0644\u0627\u0645",
+      "\u063A\u064A\u0631 \u0645\u062A\u0632\u0627\u0645\u0646",
+      "\u0627\u0646\u062A\u0638\u0627\u0631",
+      "\u062B\u0627\u0628\u062A",
+      "\u0645\u062A\u063A\u064A\u0631",
+      "\u0625\u0631\u062C\u0627\u0639"
+    ],
+    reasoningKeywords: [
+      // English
+      "prove",
+      "theorem",
+      "derive",
+      "step by step",
+      "chain of thought",
+      "formally",
+      "mathematical",
+      "proof",
+      "logically",
+      // Chinese
+      "\u8BC1\u660E",
+      "\u5B9A\u7406",
+      "\u63A8\u5BFC",
+      "\u9010\u6B65",
+      "\u601D\u7EF4\u94FE",
+      "\u5F62\u5F0F\u5316",
+      "\u6570\u5B66",
+      "\u903B\u8F91",
+      // Japanese
+      "\u8A3C\u660E",
+      "\u5B9A\u7406",
+      "\u5C0E\u51FA",
+      "\u30B9\u30C6\u30C3\u30D7\u30D0\u30A4\u30B9\u30C6\u30C3\u30D7",
+      "\u8AD6\u7406\u7684",
+      // Russian
+      "\u0434\u043E\u043A\u0430\u0437\u0430\u0442\u044C",
+      "\u0434\u043E\u043A\u0430\u0436\u0438",
+      "\u0434\u043E\u043A\u0430\u0437\u0430\u0442\u0435\u043B\u044C\u0441\u0442\u0432",
+      "\u0442\u0435\u043E\u0440\u0435\u043C\u0430",
+      "\u0432\u044B\u0432\u0435\u0441\u0442\u0438",
+      "\u0448\u0430\u0433 \u0437\u0430 \u0448\u0430\u0433\u043E\u043C",
+      "\u043F\u043E\u0448\u0430\u0433\u043E\u0432\u043E",
+      "\u043F\u043E\u044D\u0442\u0430\u043F\u043D\u043E",
+      "\u0446\u0435\u043F\u043E\u0447\u043A\u0430 \u0440\u0430\u0441\u0441\u0443\u0436\u0434\u0435\u043D\u0438\u0439",
+      "\u0440\u0430\u0441\u0441\u0443\u0436\u0434\u0435\u043D\u0438",
+      "\u0444\u043E\u0440\u043C\u0430\u043B\u044C\u043D\u043E",
+      "\u043C\u0430\u0442\u0435\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438",
+      "\u043B\u043E\u0433\u0438\u0447\u0435\u0441\u043A\u0438",
+      // German
+      "beweisen",
+      "beweis",
+      "theorem",
+      "ableiten",
+      "schritt f\xFCr schritt",
+      "gedankenkette",
+      "formal",
+      "mathematisch",
+      "logisch",
+      // Spanish
+      "demostrar",
+      "teorema",
+      "derivar",
+      "paso a paso",
+      "cadena de pensamiento",
+      "formalmente",
+      "matem\xE1tico",
+      "prueba",
+      "l\xF3gicamente",
+      // Portuguese
+      "provar",
+      "teorema",
+      "derivar",
+      "passo a passo",
+      "cadeia de pensamento",
+      "formalmente",
+      "matem\xE1tico",
+      "prova",
+      "logicamente",
+      // Korean
+      "\uC99D\uBA85",
+      "\uC815\uB9AC",
+      "\uB3C4\uCD9C",
+      "\uB2E8\uACC4\uBCC4",
+      "\uC0AC\uACE0\uC758 \uC5F0\uC1C4",
+      "\uD615\uC2DD\uC801",
+      "\uC218\uD559\uC801",
+      "\uB17C\uB9AC\uC801",
+      // Arabic
+      "\u0625\u062B\u0628\u0627\u062A",
+      "\u0646\u0638\u0631\u064A\u0629",
+      "\u0627\u0634\u062A\u0642\u0627\u0642",
+      "\u062E\u0637\u0648\u0629 \u0628\u062E\u0637\u0648\u0629",
+      "\u0633\u0644\u0633\u0644\u0629 \u0627\u0644\u062A\u0641\u0643\u064A\u0631",
+      "\u0631\u0633\u0645\u064A\u0627\u064B",
+      "\u0631\u064A\u0627\u0636\u064A",
+      "\u0628\u0631\u0647\u0627\u0646",
+      "\u0645\u0646\u0637\u0642\u064A\u0627\u064B"
+    ],
+    simpleKeywords: [
+      // English
+      "what is",
+      "define",
+      "translate",
+      "hello",
+      "yes or no",
+      "capital of",
+      "how old",
+      "who is",
+      "when was",
+      // Chinese
+      "\u4EC0\u4E48\u662F",
+      "\u5B9A\u4E49",
+      "\u7FFB\u8BD1",
+      "\u4F60\u597D",
+      "\u662F\u5426",
+      "\u9996\u90FD",
+      "\u591A\u5927",
+      "\u8C01\u662F",
+      "\u4F55\u65F6",
+      // Japanese
+      "\u3068\u306F",
+      "\u5B9A\u7FA9",
+      "\u7FFB\u8A33",
+      "\u3053\u3093\u306B\u3061\u306F",
+      "\u306F\u3044\u304B\u3044\u3044\u3048",
+      "\u9996\u90FD",
+      "\u8AB0",
+      // Russian
+      "\u0447\u0442\u043E \u0442\u0430\u043A\u043E\u0435",
+      "\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0435",
+      "\u043F\u0435\u0440\u0435\u0432\u0435\u0441\u0442\u0438",
+      "\u043F\u0435\u0440\u0435\u0432\u0435\u0434\u0438",
+      "\u043F\u0440\u0438\u0432\u0435\u0442",
+      "\u0434\u0430 \u0438\u043B\u0438 \u043D\u0435\u0442",
+      "\u0441\u0442\u043E\u043B\u0438\u0446\u0430",
+      "\u0441\u043A\u043E\u043B\u044C\u043A\u043E \u043B\u0435\u0442",
+      "\u043A\u0442\u043E \u0442\u0430\u043A\u043E\u0439",
+      "\u043A\u043E\u0433\u0434\u0430",
+      "\u043E\u0431\u044A\u044F\u0441\u043D\u0438",
+      // German
+      "was ist",
+      "definiere",
+      "\xFCbersetze",
+      "hallo",
+      "ja oder nein",
+      "hauptstadt",
+      "wie alt",
+      "wer ist",
+      "wann",
+      "erkl\xE4re",
+      // Spanish
+      "qu\xE9 es",
+      "definir",
+      "traducir",
+      "hola",
+      "s\xED o no",
+      "capital de",
+      "cu\xE1ntos a\xF1os",
+      "qui\xE9n es",
+      "cu\xE1ndo",
+      // Portuguese
+      "o que \xE9",
+      "definir",
+      "traduzir",
+      "ol\xE1",
+      "sim ou n\xE3o",
+      "capital de",
+      "quantos anos",
+      "quem \xE9",
+      "quando",
+      // Korean
+      "\uBB34\uC5C7",
+      "\uC815\uC758",
+      "\uBC88\uC5ED",
+      "\uC548\uB155\uD558\uC138\uC694",
+      "\uC608 \uB610\uB294 \uC544\uB2C8\uC624",
+      "\uC218\uB3C4",
+      "\uB204\uAD6C",
+      "\uC5B8\uC81C",
+      // Arabic
+      "\u0645\u0627 \u0647\u0648",
+      "\u062A\u0639\u0631\u064A\u0641",
+      "\u062A\u0631\u062C\u0645",
+      "\u0645\u0631\u062D\u0628\u0627",
+      "\u0646\u0639\u0645 \u0623\u0648 \u0644\u0627",
+      "\u0639\u0627\u0635\u0645\u0629",
+      "\u0645\u0646 \u0647\u0648",
+      "\u0645\u062A\u0649"
+    ],
+    technicalKeywords: [
+      // English
+      "algorithm",
+      "optimize",
+      "architecture",
+      "distributed",
+      "kubernetes",
+      "microservice",
+      "database",
+      "infrastructure",
+      // Chinese
+      "\u7B97\u6CD5",
+      "\u4F18\u5316",
+      "\u67B6\u6784",
+      "\u5206\u5E03\u5F0F",
+      "\u5FAE\u670D\u52A1",
+      "\u6570\u636E\u5E93",
+      "\u57FA\u7840\u8BBE\u65BD",
+      // Japanese
+      "\u30A2\u30EB\u30B4\u30EA\u30BA\u30E0",
+      "\u6700\u9069\u5316",
+      "\u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3",
+      "\u5206\u6563",
+      "\u30DE\u30A4\u30AF\u30ED\u30B5\u30FC\u30D3\u30B9",
+      "\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9",
+      // Russian
+      "\u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C",
+      "\u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
+      "\u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0430\u0446\u0438",
+      "\u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0438\u0440\u0443\u0439",
+      "\u0430\u0440\u0445\u0438\u0442\u0435\u043A\u0442\u0443\u0440\u0430",
+      "\u0440\u0430\u0441\u043F\u0440\u0435\u0434\u0435\u043B\u0451\u043D\u043D\u044B\u0439",
+      "\u043C\u0438\u043A\u0440\u043E\u0441\u0435\u0440\u0432\u0438\u0441",
+      "\u0431\u0430\u0437\u0430 \u0434\u0430\u043D\u043D\u044B\u0445",
+      "\u0438\u043D\u0444\u0440\u0430\u0441\u0442\u0440\u0443\u043A\u0442\u0443\u0440\u0430",
+      // German
+      "algorithmus",
+      "optimieren",
+      "architektur",
+      "verteilt",
+      "kubernetes",
+      "mikroservice",
+      "datenbank",
+      "infrastruktur",
+      // Spanish
+      "algoritmo",
+      "optimizar",
+      "arquitectura",
+      "distribuido",
+      "microservicio",
+      "base de datos",
+      "infraestructura",
+      // Portuguese
+      "algoritmo",
+      "otimizar",
+      "arquitetura",
+      "distribu\xEDdo",
+      "microsservi\xE7o",
+      "banco de dados",
+      "infraestrutura",
+      // Korean
+      "\uC54C\uACE0\uB9AC\uC998",
+      "\uCD5C\uC801\uD654",
+      "\uC544\uD0A4\uD14D\uCC98",
+      "\uBD84\uC0B0",
+      "\uB9C8\uC774\uD06C\uB85C\uC11C\uBE44\uC2A4",
+      "\uB370\uC774\uD130\uBCA0\uC774\uC2A4",
+      "\uC778\uD504\uB77C",
+      // Arabic
+      "\u062E\u0648\u0627\u0631\u0632\u0645\u064A\u0629",
+      "\u062A\u062D\u0633\u064A\u0646",
+      "\u0628\u0646\u064A\u0629",
+      "\u0645\u0648\u0632\u0639",
+      "\u062E\u062F\u0645\u0629 \u0645\u0635\u063A\u0631\u0629",
+      "\u0642\u0627\u0639\u062F\u0629 \u0628\u064A\u0627\u0646\u0627\u062A",
+      "\u0628\u0646\u064A\u0629 \u062A\u062D\u062A\u064A\u0629"
+    ],
+    creativeKeywords: [
+      // English
+      "story",
+      "poem",
+      "compose",
+      "brainstorm",
+      "creative",
+      "imagine",
+      "write a",
+      // Chinese
+      "\u6545\u4E8B",
+      "\u8BD7",
+      "\u521B\u4F5C",
+      "\u5934\u8111\u98CE\u66B4",
+      "\u521B\u610F",
+      "\u60F3\u8C61",
+      "\u5199\u4E00\u4E2A",
+      // Japanese
+      "\u7269\u8A9E",
+      "\u8A69",
+      "\u4F5C\u66F2",
+      "\u30D6\u30EC\u30A4\u30F3\u30B9\u30C8\u30FC\u30E0",
+      "\u5275\u9020\u7684",
+      "\u60F3\u50CF",
+      // Russian
+      "\u0438\u0441\u0442\u043E\u0440\u0438\u044F",
+      "\u0440\u0430\u0441\u0441\u043A\u0430\u0437",
+      "\u0441\u0442\u0438\u0445\u043E\u0442\u0432\u043E\u0440\u0435\u043D\u0438\u0435",
+      "\u0441\u043E\u0447\u0438\u043D\u0438\u0442\u044C",
+      "\u0441\u043E\u0447\u0438\u043D\u0438",
+      "\u043C\u043E\u0437\u0433\u043E\u0432\u043E\u0439 \u0448\u0442\u0443\u0440\u043C",
+      "\u0442\u0432\u043E\u0440\u0447\u0435\u0441\u043A\u0438\u0439",
+      "\u043F\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u0438\u0442\u044C",
+      "\u043F\u0440\u0438\u0434\u0443\u043C\u0430\u0439",
+      "\u043D\u0430\u043F\u0438\u0448\u0438",
+      // German
+      "geschichte",
+      "gedicht",
+      "komponieren",
+      "brainstorming",
+      "kreativ",
+      "vorstellen",
+      "schreibe",
+      "erz\xE4hlung",
+      // Spanish
+      "historia",
+      "poema",
+      "componer",
+      "lluvia de ideas",
+      "creativo",
+      "imaginar",
+      "escribe",
+      // Portuguese
+      "hist\xF3ria",
+      "poema",
+      "compor",
+      "criativo",
+      "imaginar",
+      "escreva",
+      // Korean
+      "\uC774\uC57C\uAE30",
+      "\uC2DC",
+      "\uC791\uACE1",
+      "\uBE0C\uB808\uC778\uC2A4\uD1A0\uBC0D",
+      "\uCC3D\uC758\uC801",
+      "\uC0C1\uC0C1",
+      "\uC791\uC131",
+      // Arabic
+      "\u0642\u0635\u0629",
+      "\u0642\u0635\u064A\u062F\u0629",
+      "\u062A\u0623\u0644\u064A\u0641",
+      "\u0639\u0635\u0641 \u0630\u0647\u0646\u064A",
+      "\u0625\u0628\u062F\u0627\u0639\u064A",
+      "\u062A\u062E\u064A\u0644",
+      "\u0627\u0643\u062A\u0628"
+    ],
+    imperativeVerbs: [
+      // English
+      "build",
+      "create",
+      "implement",
+      "design",
+      "develop",
+      "construct",
+      "generate",
+      "deploy",
+      "configure",
+      "set up",
+      // Chinese
+      "\u6784\u5EFA",
+      "\u521B\u5EFA",
+      "\u5B9E\u73B0",
+      "\u8BBE\u8BA1",
+      "\u5F00\u53D1",
+      "\u751F\u6210",
+      "\u90E8\u7F72",
+      "\u914D\u7F6E",
+      "\u8BBE\u7F6E",
+      // Japanese
+      "\u69CB\u7BC9",
+      "\u4F5C\u6210",
+      "\u5B9F\u88C5",
+      "\u8A2D\u8A08",
+      "\u958B\u767A",
+      "\u751F\u6210",
+      "\u30C7\u30D7\u30ED\u30A4",
+      "\u8A2D\u5B9A",
+      // Russian
+      "\u043F\u043E\u0441\u0442\u0440\u043E\u0438\u0442\u044C",
+      "\u043F\u043E\u0441\u0442\u0440\u043E\u0439",
+      "\u0441\u043E\u0437\u0434\u0430\u0442\u044C",
+      "\u0441\u043E\u0437\u0434\u0430\u0439",
+      "\u0440\u0435\u0430\u043B\u0438\u0437\u043E\u0432\u0430\u0442\u044C",
+      "\u0440\u0435\u0430\u043B\u0438\u0437\u0443\u0439",
+      "\u0441\u043F\u0440\u043E\u0435\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
+      "\u0440\u0430\u0437\u0440\u0430\u0431\u043E\u0442\u0430\u0442\u044C",
+      "\u0440\u0430\u0437\u0440\u0430\u0431\u043E\u0442\u0430\u0439",
+      "\u0441\u043A\u043E\u043D\u0441\u0442\u0440\u0443\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
+      "\u0441\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
+      "\u0441\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u0443\u0439",
+      "\u0440\u0430\u0437\u0432\u0435\u0440\u043D\u0443\u0442\u044C",
+      "\u0440\u0430\u0437\u0432\u0435\u0440\u043D\u0438",
+      "\u043D\u0430\u0441\u0442\u0440\u043E\u0438\u0442\u044C",
+      "\u043D\u0430\u0441\u0442\u0440\u043E\u0439",
+      // German
+      "erstellen",
+      "bauen",
+      "implementieren",
+      "entwerfen",
+      "entwickeln",
+      "konstruieren",
+      "generieren",
+      "bereitstellen",
+      "konfigurieren",
+      "einrichten",
+      // Spanish
+      "construir",
+      "crear",
+      "implementar",
+      "dise\xF1ar",
+      "desarrollar",
+      "generar",
+      "desplegar",
+      "configurar",
+      // Portuguese
+      "construir",
+      "criar",
+      "implementar",
+      "projetar",
+      "desenvolver",
+      "gerar",
+      "implantar",
+      "configurar",
+      // Korean
+      "\uAD6C\uCD95",
+      "\uC0DD\uC131",
+      "\uAD6C\uD604",
+      "\uC124\uACC4",
+      "\uAC1C\uBC1C",
+      "\uBC30\uD3EC",
+      "\uC124\uC815",
+      // Arabic
+      "\u0628\u0646\u0627\u0621",
+      "\u0625\u0646\u0634\u0627\u0621",
+      "\u062A\u0646\u0641\u064A\u0630",
+      "\u062A\u0635\u0645\u064A\u0645",
+      "\u062A\u0637\u0648\u064A\u0631",
+      "\u062A\u0648\u0644\u064A\u062F",
+      "\u0646\u0634\u0631",
+      "\u0625\u0639\u062F\u0627\u062F"
+    ],
+    constraintIndicators: [
+      // English
+      "under",
+      "at most",
+      "at least",
+      "within",
+      "no more than",
+      "o(",
+      "maximum",
+      "minimum",
+      "limit",
+      "budget",
+      // Chinese
+      "\u4E0D\u8D85\u8FC7",
+      "\u81F3\u5C11",
+      "\u6700\u591A",
+      "\u5728\u5185",
+      "\u6700\u5927",
+      "\u6700\u5C0F",
+      "\u9650\u5236",
+      "\u9884\u7B97",
+      // Japanese
+      "\u4EE5\u4E0B",
+      "\u6700\u5927",
+      "\u6700\u5C0F",
+      "\u5236\u9650",
+      "\u4E88\u7B97",
+      // Russian
+      "\u043D\u0435 \u0431\u043E\u043B\u0435\u0435",
+      "\u043D\u0435 \u043C\u0435\u043D\u0435\u0435",
+      "\u043A\u0430\u043A \u043C\u0438\u043D\u0438\u043C\u0443\u043C",
+      "\u0432 \u043F\u0440\u0435\u0434\u0435\u043B\u0430\u0445",
+      "\u043C\u0430\u043A\u0441\u0438\u043C\u0443\u043C",
+      "\u043C\u0438\u043D\u0438\u043C\u0443\u043C",
+      "\u043E\u0433\u0440\u0430\u043D\u0438\u0447\u0435\u043D\u0438\u0435",
+      "\u0431\u044E\u0434\u0436\u0435\u0442",
+      // German
+      "h\xF6chstens",
+      "mindestens",
+      "innerhalb",
+      "nicht mehr als",
+      "maximal",
+      "minimal",
+      "grenze",
+      "budget",
+      // Spanish
+      "como m\xE1ximo",
+      "al menos",
+      "dentro de",
+      "no m\xE1s de",
+      "m\xE1ximo",
+      "m\xEDnimo",
+      "l\xEDmite",
+      "presupuesto",
+      // Portuguese
+      "no m\xE1ximo",
+      "pelo menos",
+      "dentro de",
+      "n\xE3o mais que",
+      "m\xE1ximo",
+      "m\xEDnimo",
+      "limite",
+      "or\xE7amento",
+      // Korean
+      "\uC774\uD558",
+      "\uC774\uC0C1",
+      "\uCD5C\uB300",
+      "\uCD5C\uC18C",
+      "\uC81C\uD55C",
+      "\uC608\uC0B0",
+      // Arabic
+      "\u0639\u0644\u0649 \u0627\u0644\u0623\u0643\u062B\u0631",
+      "\u0639\u0644\u0649 \u0627\u0644\u0623\u0642\u0644",
+      "\u0636\u0645\u0646",
+      "\u0644\u0627 \u064A\u0632\u064A\u062F \u0639\u0646",
+      "\u0623\u0642\u0635\u0649",
+      "\u0623\u062F\u0646\u0649",
+      "\u062D\u062F",
+      "\u0645\u064A\u0632\u0627\u0646\u064A\u0629"
+    ],
+    outputFormatKeywords: [
+      // English
+      "json",
+      "yaml",
+      "xml",
+      "table",
+      "csv",
+      "markdown",
+      "schema",
+      "format as",
+      "structured",
+      // Chinese
+      "\u8868\u683C",
+      "\u683C\u5F0F\u5316\u4E3A",
+      "\u7ED3\u6784\u5316",
+      // Japanese
+      "\u30C6\u30FC\u30D6\u30EB",
+      "\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8",
+      "\u69CB\u9020\u5316",
+      // Russian
+      "\u0442\u0430\u0431\u043B\u0438\u0446\u0430",
+      "\u0444\u043E\u0440\u043C\u0430\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043A\u0430\u043A",
+      "\u0441\u0442\u0440\u0443\u043A\u0442\u0443\u0440\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0439",
+      // German
+      "tabelle",
+      "formatieren als",
+      "strukturiert",
+      // Spanish
+      "tabla",
+      "formatear como",
+      "estructurado",
+      // Portuguese
+      "tabela",
+      "formatar como",
+      "estruturado",
+      // Korean
+      "\uD14C\uC774\uBE14",
+      "\uD615\uC2DD",
+      "\uAD6C\uC870\uD654",
+      // Arabic
+      "\u062C\u062F\u0648\u0644",
+      "\u062A\u0646\u0633\u064A\u0642",
+      "\u0645\u0646\u0638\u0645"
+    ],
+    referenceKeywords: [
+      // English
+      "above",
+      "below",
+      "previous",
+      "following",
+      "the docs",
+      "the api",
+      "the code",
+      "earlier",
+      "attached",
+      // Chinese
+      "\u4E0A\u9762",
+      "\u4E0B\u9762",
+      "\u4E4B\u524D",
+      "\u63A5\u4E0B\u6765",
+      "\u6587\u6863",
+      "\u4EE3\u7801",
+      "\u9644\u4EF6",
+      // Japanese
+      "\u4E0A\u8A18",
+      "\u4E0B\u8A18",
+      "\u524D\u306E",
+      "\u6B21\u306E",
+      "\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8",
+      "\u30B3\u30FC\u30C9",
+      // Russian
+      "\u0432\u044B\u0448\u0435",
+      "\u043D\u0438\u0436\u0435",
+      "\u043F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0438\u0439",
+      "\u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439",
+      "\u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u0430\u0446\u0438\u044F",
+      "\u043A\u043E\u0434",
+      "\u0440\u0430\u043D\u0435\u0435",
+      "\u0432\u043B\u043E\u0436\u0435\u043D\u0438\u0435",
+      // German
+      "oben",
+      "unten",
+      "vorherige",
+      "folgende",
+      "dokumentation",
+      "der code",
+      "fr\xFCher",
+      "anhang",
+      // Spanish
+      "arriba",
+      "abajo",
+      "anterior",
+      "siguiente",
+      "documentaci\xF3n",
+      "el c\xF3digo",
+      "adjunto",
+      // Portuguese
+      "acima",
+      "abaixo",
+      "anterior",
+      "seguinte",
+      "documenta\xE7\xE3o",
+      "o c\xF3digo",
+      "anexo",
+      // Korean
+      "\uC704",
+      "\uC544\uB798",
+      "\uC774\uC804",
+      "\uB2E4\uC74C",
+      "\uBB38\uC11C",
+      "\uCF54\uB4DC",
+      "\uCCA8\uBD80",
+      // Arabic
+      "\u0623\u0639\u0644\u0627\u0647",
+      "\u0623\u062F\u0646\u0627\u0647",
+      "\u0627\u0644\u0633\u0627\u0628\u0642",
+      "\u0627\u0644\u062A\u0627\u0644\u064A",
+      "\u0627\u0644\u0648\u062B\u0627\u0626\u0642",
+      "\u0627\u0644\u0643\u0648\u062F",
+      "\u0645\u0631\u0641\u0642"
+    ],
+    negationKeywords: [
+      // English
+      "don't",
+      "do not",
+      "avoid",
+      "never",
+      "without",
+      "except",
+      "exclude",
+      "no longer",
+      // Chinese
+      "\u4E0D\u8981",
+      "\u907F\u514D",
+      "\u4ECE\u4E0D",
+      "\u6CA1\u6709",
+      "\u9664\u4E86",
+      "\u6392\u9664",
+      // Japanese
+      "\u3057\u306A\u3044\u3067",
+      "\u907F\u3051\u308B",
+      "\u6C7A\u3057\u3066",
+      "\u306A\u3057\u3067",
+      "\u9664\u304F",
+      // Russian
+      "\u043D\u0435 \u0434\u0435\u043B\u0430\u0439",
+      "\u043D\u0435 \u043D\u0430\u0434\u043E",
+      "\u043D\u0435\u043B\u044C\u0437\u044F",
+      "\u0438\u0437\u0431\u0435\u0433\u0430\u0442\u044C",
+      "\u043D\u0438\u043A\u043E\u0433\u0434\u0430",
+      "\u0431\u0435\u0437",
+      "\u043A\u0440\u043E\u043C\u0435",
+      "\u0438\u0441\u043A\u043B\u044E\u0447\u0438\u0442\u044C",
+      "\u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435",
+      // German
+      "nicht",
+      "vermeide",
+      "niemals",
+      "ohne",
+      "au\xDFer",
+      "ausschlie\xDFen",
+      "nicht mehr",
+      // Spanish
+      "no hagas",
+      "evitar",
+      "nunca",
+      "sin",
+      "excepto",
+      "excluir",
+      // Portuguese
+      "n\xE3o fa\xE7a",
+      "evitar",
+      "nunca",
+      "sem",
+      "exceto",
+      "excluir",
+      // Korean
+      "\uD558\uC9C0 \uB9C8",
+      "\uD53C\uD558\uB2E4",
+      "\uC808\uB300",
+      "\uC5C6\uC774",
+      "\uC81C\uC678",
+      // Arabic
+      "\u0644\u0627 \u062A\u0641\u0639\u0644",
+      "\u062A\u062C\u0646\u0628",
+      "\u0623\u0628\u062F\u0627\u064B",
+      "\u0628\u062F\u0648\u0646",
+      "\u0628\u0627\u0633\u062A\u062B\u0646\u0627\u0621",
+      "\u0627\u0633\u062A\u0628\u0639\u0627\u062F"
+    ],
+    domainSpecificKeywords: [
+      // English
+      "quantum",
+      "fpga",
+      "vlsi",
+      "risc-v",
+      "asic",
+      "photonics",
+      "genomics",
+      "proteomics",
+      "topological",
+      "homomorphic",
+      "zero-knowledge",
+      "lattice-based",
+      // Chinese
+      "\u91CF\u5B50",
+      "\u5149\u5B50\u5B66",
+      "\u57FA\u56E0\u7EC4\u5B66",
+      "\u86CB\u767D\u8D28\u7EC4\u5B66",
+      "\u62D3\u6251",
+      "\u540C\u6001",
+      "\u96F6\u77E5\u8BC6",
+      "\u683C\u5BC6\u7801",
+      // Japanese
+      "\u91CF\u5B50",
+      "\u30D5\u30A9\u30C8\u30CB\u30AF\u30B9",
+      "\u30B2\u30CE\u30DF\u30AF\u30B9",
+      "\u30C8\u30DD\u30ED\u30B8\u30AB\u30EB",
+      // Russian
+      "\u043A\u0432\u0430\u043D\u0442\u043E\u0432\u044B\u0439",
+      "\u0444\u043E\u0442\u043E\u043D\u0438\u043A\u0430",
+      "\u0433\u0435\u043D\u043E\u043C\u0438\u043A\u0430",
+      "\u043F\u0440\u043E\u0442\u0435\u043E\u043C\u0438\u043A\u0430",
+      "\u0442\u043E\u043F\u043E\u043B\u043E\u0433\u0438\u0447\u0435\u0441\u043A\u0438\u0439",
+      "\u0433\u043E\u043C\u043E\u043C\u043E\u0440\u0444\u043D\u044B\u0439",
+      "\u0441 \u043D\u0443\u043B\u0435\u0432\u044B\u043C \u0440\u0430\u0437\u0433\u043B\u0430\u0448\u0435\u043D\u0438\u0435\u043C",
+      "\u043D\u0430 \u043E\u0441\u043D\u043E\u0432\u0435 \u0440\u0435\u0448\u0451\u0442\u043E\u043A",
+      // German
+      "quanten",
+      "photonik",
+      "genomik",
+      "proteomik",
+      "topologisch",
+      "homomorph",
+      "zero-knowledge",
+      "gitterbasiert",
+      // Spanish
+      "cu\xE1ntico",
+      "fot\xF3nica",
+      "gen\xF3mica",
+      "prote\xF3mica",
+      "topol\xF3gico",
+      "homom\xF3rfico",
+      // Portuguese
+      "qu\xE2ntico",
+      "fot\xF4nica",
+      "gen\xF4mica",
+      "prote\xF4mica",
+      "topol\xF3gico",
+      "homom\xF3rfico",
+      // Korean
+      "\uC591\uC790",
+      "\uD3EC\uD1A0\uB2C9\uC2A4",
+      "\uC720\uC804\uCCB4\uD559",
+      "\uC704\uC0C1",
+      "\uB3D9\uD615",
+      // Arabic
+      "\u0643\u0645\u064A",
+      "\u0636\u0648\u0626\u064A\u0627\u062A",
+      "\u062C\u064A\u0646\u0648\u0645\u064A\u0627\u062A",
+      "\u0637\u0648\u0628\u0648\u0644\u0648\u062C\u064A",
+      "\u062A\u0645\u0627\u062B\u0644\u064A"
+    ],
+    // Agentic task keywords - file ops, execution, multi-step, iterative work
+    // Pruned: removed overly common words like "then", "first", "run", "test", "build"
+    agenticTaskKeywords: [
+      // English - File operations (clearly agentic)
+      "read file",
+      "read the file",
+      "look at",
+      "check the",
+      "open the",
+      "edit",
+      "modify",
+      "update the",
+      "change the",
+      "write to",
+      "create file",
+      // English - Execution (specific commands only)
+      "execute",
+      "deploy",
+      "install",
+      "npm",
+      "pip",
+      "compile",
+      // English - Multi-step patterns (specific only)
+      "after that",
+      "and also",
+      "once done",
+      "step 1",
+      "step 2",
+      // English - Iterative work
+      "fix",
+      "debug",
+      "until it works",
+      "keep trying",
+      "iterate",
+      "make sure",
+      "verify",
+      "confirm",
+      // Chinese (keep specific ones)
+      "\u8BFB\u53D6\u6587\u4EF6",
+      "\u67E5\u770B",
+      "\u6253\u5F00",
+      "\u7F16\u8F91",
+      "\u4FEE\u6539",
+      "\u66F4\u65B0",
+      "\u521B\u5EFA",
+      "\u6267\u884C",
+      "\u90E8\u7F72",
+      "\u5B89\u88C5",
+      "\u7B2C\u4E00\u6B65",
+      "\u7B2C\u4E8C\u6B65",
+      "\u4FEE\u590D",
+      "\u8C03\u8BD5",
+      "\u76F4\u5230",
+      "\u786E\u8BA4",
+      "\u9A8C\u8BC1",
+      // Spanish
+      "leer archivo",
+      "editar",
+      "modificar",
+      "actualizar",
+      "ejecutar",
+      "desplegar",
+      "instalar",
+      "paso 1",
+      "paso 2",
+      "arreglar",
+      "depurar",
+      "verificar",
+      // Portuguese
+      "ler arquivo",
+      "editar",
+      "modificar",
+      "atualizar",
+      "executar",
+      "implantar",
+      "instalar",
+      "passo 1",
+      "passo 2",
+      "corrigir",
+      "depurar",
+      "verificar",
+      // Korean
+      "\uD30C\uC77C \uC77D\uAE30",
+      "\uD3B8\uC9D1",
+      "\uC218\uC815",
+      "\uC5C5\uB370\uC774\uD2B8",
+      "\uC2E4\uD589",
+      "\uBC30\uD3EC",
+      "\uC124\uCE58",
+      "\uB2E8\uACC4 1",
+      "\uB2E8\uACC4 2",
+      "\uB514\uBC84\uADF8",
+      "\uD655\uC778",
+      // Arabic
+      "\u0642\u0631\u0627\u0621\u0629 \u0645\u0644\u0641",
+      "\u062A\u062D\u0631\u064A\u0631",
+      "\u062A\u0639\u062F\u064A\u0644",
+      "\u062A\u062D\u062F\u064A\u062B",
+      "\u062A\u0646\u0641\u064A\u0630",
+      "\u0646\u0634\u0631",
+      "\u062A\u062B\u0628\u064A\u062A",
+      "\u0627\u0644\u062E\u0637\u0648\u0629 1",
+      "\u0627\u0644\u062E\u0637\u0648\u0629 2",
+      "\u0625\u0635\u0644\u0627\u062D",
+      "\u062A\u0635\u062D\u064A\u062D",
+      "\u062A\u062D\u0642\u0642"
+    ],
+    // Dimension weights (sum to 1.0)
+    dimensionWeights: {
+      tokenCount: 0.08,
+      codePresence: 0.15,
+      reasoningMarkers: 0.18,
+      technicalTerms: 0.1,
+      creativeMarkers: 0.05,
+      simpleIndicators: 0.02,
+      // Reduced from 0.12 to make room for agenticTask
+      multiStepPatterns: 0.12,
+      questionComplexity: 0.05,
+      imperativeVerbs: 0.03,
+      constraintCount: 0.04,
+      outputFormat: 0.03,
+      referenceComplexity: 0.02,
+      negationComplexity: 0.01,
+      domainSpecificity: 0.02,
+      agenticTask: 0.04
+      // Reduced - agentic signals influence tier selection, not dominate it
+    },
+    // Tier boundaries on weighted score axis
+    tierBoundaries: {
+      simpleMedium: 0,
+      mediumComplex: 0.3,
+      // Raised from 0.18 - prevent simple tasks from reaching expensive COMPLEX tier
+      complexReasoning: 0.5
+      // Raised from 0.4 - reserve for true reasoning tasks
+    },
+    // Sigmoid steepness for confidence calibration
+    confidenceSteepness: 12,
+    // Below this confidence → ambiguous (null tier)
+    confidenceThreshold: 0.7
+  },
+  overrides: {
+    structuredOutputMinTier: "MEDIUM",
+    ambiguousDefaultTier: "MEDIUM"
+  }
+};
+
+// src/router/trace.ts
+function defaultTraceWriter() {
+  return console.debug.bind(console);
+}
+function resolveTraceWriter(logger) {
+  return logger?.debug ?? logger?.info ?? defaultTraceWriter();
+}
+function normalizeTraceMode(mode) {
+  if (mode === "summary" || mode === "debug") {
+    return mode;
+  }
+  return "off";
+}
+function getPromptPreview(prompt) {
+  const chars = Array.from(prompt);
+  if (chars.length <= 24) {
+    return prompt;
+  }
+  return `${chars.slice(0, 10).join("")}...${chars.slice(-10).join("")}`;
+}
+function buildTraceSummary(input) {
+  const requestCode = getRequestCode(input);
+  const profileCode = getProfileOrTierCode(input.profile, input.tier);
+  return [
+    requestCode,
+    profileCode,
+    input.routedModel,
+    input.reason
+  ].join(":");
+}
+function emitRouteTrace(mode, detail, writer = defaultTraceWriter()) {
+  if (mode === "off") {
+    return;
+  }
+  if (mode === "summary") {
+    try {
+      writer(
+        `[llm-router] ${detail.trace} model=${detail.actualModel} fallback=${detail.fallback}`
+      );
+    } catch {
+    }
+    return;
+  }
+  try {
+    writer(JSON.stringify(detail));
+  } catch {
+  }
+}
+function getRequestCode(input) {
+  if (input.explicit || !input.routed) {
+    return "explicit";
+  }
+  if (input.requestedModel !== "auto") {
+    return input.requestedModel;
+  }
+  return "auto";
+}
+function getProfileOrTierCode(profile, tier) {
+  if (profile === "agentic") {
+    return "agentic";
+  }
+  return tier.toLowerCase();
+}
+
+// src/router/index.ts
+function route(prompt, systemPrompt, maxOutputTokens, options) {
+  return getStrategy("rules").route(
+    prompt,
+    systemPrompt,
+    maxOutputTokens,
+    options
+  );
+}
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.deepseek.com";
+var DEFAULT_PORT = 8402;
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+function resolveConfig(input = {}) {
+  return {
+    baseUrl: normalizeBaseUrl(input.baseUrl ?? DEFAULT_BASE_URL),
+    apiKey: input.apiKey,
+    headers: input.headers ?? {},
+    port: input.port ?? DEFAULT_PORT,
+    sessionPinning: input.sessionPinning ?? true,
+    traceMode: normalizeTraceMode(input.traceMode),
+    traceLogger: input.traceLogger
+  };
+}
+
+// src/model-registry.ts
+function createModelRegistry(models) {
+  const map = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    if (map.has(model.id)) {
+      throw new Error(`Duplicate model ID: ${model.id}`);
+    }
+    map.set(model.id, { ...model });
+  }
+  return {
+    get(id) {
+      const model = map.get(id);
+      return model ? { ...model } : void 0;
+    },
+    has(id) {
+      return map.has(id);
+    },
+    all() {
+      return Array.from(map.values(), (model) => ({ ...model }));
+    }
+  };
+}
+
+// src/public-model-resolver.ts
+function resolvePublicModelCandidate(publicModelId, publicModels, registry2) {
+  const pub = publicModels[publicModelId];
+  if (!pub) {
+    throw new Error(`Unknown public model: ${publicModelId}`);
+  }
+  if (pub.kind === "router") {
+    throw new Error("Cannot resolve router model directly");
+  }
+  const candidateId = selectCandidateId(pub.candidates, registry2, pub.selection ?? "cheapest");
+  const candidate = registry2.get(candidateId);
+  if (!candidate) {
+    throw new Error(`Candidate model not found in registry: ${candidateId}`);
+  }
+  return candidate;
+}
+function selectCandidateId(candidates, registry2, selection) {
+  if (candidates.length === 0) {
+    throw new Error("No candidates available for public model");
+  }
+  if (selection === "first") {
+    const first = candidates[0];
+    if (!registry2.has(first)) {
+      throw new Error(`Candidate model not found in registry: ${first}`);
+    }
+    return first;
+  }
+  let selectedId;
+  let selectedCost = Number.POSITIVE_INFINITY;
+  for (const candidateId of candidates) {
+    const model = registry2.get(candidateId);
+    if (!model) {
+      throw new Error(`Candidate model not found in registry: ${candidateId}`);
+    }
+    const cost = model.inputPrice + model.outputPrice;
+    if (cost < selectedCost) {
+      selectedId = candidateId;
+      selectedCost = cost;
+    }
+  }
+  if (!selectedId) {
+    throw new Error("No candidates available for public model");
+  }
+  return selectedId;
+}
+
+// src/session.ts
+import { createHash } from "crypto";
+var DEFAULT_SESSION_CONFIG = {
+  enabled: true,
+  ttlMs: 30 * 60 * 1e3,
+  cleanupIntervalMs: 5 * 60 * 1e3
+};
+var SessionStore = class {
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  cleanupTimer;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_SESSION_CONFIG, ...config };
+    if (this.config.enabled && this.config.cleanupIntervalMs > 0) {
+      this.cleanupTimer = setInterval(() => {
+        this.cleanupExpired();
+      }, this.config.cleanupIntervalMs);
+      this.cleanupTimer.unref?.();
+    }
+  }
+  /**
+   * 读取一个未过期 session；如果已经过期，会顺手删除并返回 undefined。
+   */
+  getSession(sessionId) {
+    if (!this.config.enabled || !sessionId) return void 0;
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return void 0;
+    if (this.isExpired(entry)) {
+      this.sessions.delete(sessionId);
+      return void 0;
+    }
+    return entry;
+  }
+  /**
+   * 创建或更新某个 session 的 pinning 结果，同时保留历史用量累计值。
+   */
+  setSession(sessionId, input) {
+    if (!this.config.enabled || !sessionId) return void 0;
+    const now = Date.now();
+    const existing = this.getSession(sessionId);
+    const entry = {
+      sessionId,
+      physicalModelId: input.physicalModelId,
+      routedPublicModel: input.routedPublicModel,
+      pinnedTier: input.pinnedTier,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+      expiresAt: now + this.config.ttlMs,
+      inputTokens: existing?.inputTokens ?? 0,
+      outputTokens: existing?.outputTokens ?? 0,
+      costEstimate: existing?.costEstimate ?? 0
+    };
+    this.sessions.set(sessionId, entry);
+    return entry;
+  }
+  /**
+   * 只刷新 TTL，不改动当前 alias / physical model 选择结果。
+   */
+  touchSession(sessionId) {
+    const entry = this.getSession(sessionId);
+    if (!entry) return false;
+    const now = Date.now();
+    entry.updatedAt = now;
+    entry.expiresAt = now + this.config.ttlMs;
+    return true;
+  }
+  clearSession(sessionId) {
+    if (!sessionId) return false;
+    return this.sessions.delete(sessionId);
+  }
+  clearAll() {
+    this.sessions.clear();
+  }
+  /**
+   * 返回清理过期项后的聚合统计。
+   */
+  getStats() {
+    this.cleanupExpired();
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCostEstimate = 0;
+    for (const entry of this.sessions.values()) {
+      totalInputTokens += entry.inputTokens;
+      totalOutputTokens += entry.outputTokens;
+      totalCostEstimate += entry.costEstimate;
+    }
+    return {
+      enabled: this.config.enabled,
+      size: this.sessions.size,
+      totalInputTokens,
+      totalOutputTokens,
+      totalCostEstimate
+    };
+  }
+  /**
+   * 把一次上游调用的 token / cost 增量累计到 session 上。
+   */
+  recordUsage(sessionId, usage) {
+    const entry = this.getSession(sessionId);
+    if (!entry) return;
+    entry.inputTokens += usage.inputTokens ?? 0;
+    entry.outputTokens += usage.outputTokens ?? 0;
+    entry.costEstimate += usage.costEstimate ?? 0;
+    entry.updatedAt = Date.now();
+  }
+  /**
+   * 停止后台清理定时器。
+   */
+  close() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+  }
+  cleanupExpired() {
+    if (!this.config.enabled) return;
+    for (const [sessionId, entry] of this.sessions) {
+      if (this.isExpired(entry)) {
+        this.sessions.delete(sessionId);
+      }
+    }
+  }
+  isExpired(entry) {
+    return Date.now() >= entry.expiresAt;
+  }
+};
+function hashRequestContent(content, toolNames = []) {
+  const normalizedContent = content.trim().replace(/\s+/g, " ");
+  const normalizedTools = [...toolNames].map((tool) => tool.trim()).filter(Boolean).sort().join(",");
+  return hashHex(`${normalizedContent}
+${normalizedTools}`, 8);
+}
+function deriveSessionId(headers, messages) {
+  const explicit = headers["x-session-id"];
+  const explicitId = pickHeaderValue(explicit);
+  if (explicitId) return explicitId;
+  const firstUserContent = findFirstUserContent(messages);
+  if (!firstUserContent) return void 0;
+  return hashRequestContent(firstUserContent);
+}
+function pickHeaderValue(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || void 0;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const trimmed = item.trim();
+      if (trimmed) return trimmed;
+    }
+  }
+  return void 0;
+}
+function findFirstUserContent(messages) {
+  for (const message of messages) {
+    if (!message || typeof message !== "object") continue;
+    const record = message;
+    if (record.role !== "user") continue;
+    const text = contentToText(record.content);
+    if (text.trim()) return text;
+  }
+  return void 0;
+}
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (!part || typeof part !== "object") return "";
+      const record = part;
+      return record.type === "text" && typeof record.text === "string" ? record.text : "";
+    }).filter(Boolean).join(" ");
+  }
+  return "";
+}
+function hashHex(value, length) {
+  return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+
+// src/proxy.ts
+var VERSION = "1.0.0";
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "host",
+  "content-length"
+]);
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var REQUESTABLE_PUBLIC_MODELS = /* @__PURE__ */ new Set(["auto"]);
+var PUBLIC_HEADER_PREFIXES = ["x-xy-router-"];
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+var OPENCLAW_CLI_TURN_PATTERN = /(?:^|\n)\[[^\]\n]+?\]\s+([\s\S]*?)(?=(?:\n\[[^\]\n]+?\]\s+)|$)/g;
+function extractRouteTextFromUserMessage(text) {
+  const matches = [...text.matchAll(OPENCLAW_CLI_TURN_PATTERN)];
+  const last = matches.at(-1)?.[1]?.trim();
+  return last || text;
+}
+function extractPrompt(messages) {
+  const parts = [];
+  let system;
+  let openingText = "";
+  let lastUserText = "";
+  for (const msg of messages) {
+    if (!msg || typeof msg !== "object") continue;
+    const role = msg.role;
+    const content = msg.content;
+    let text2 = "";
+    if (typeof content === "string") {
+      text2 = content;
+    } else if (Array.isArray(content)) {
+      text2 = content.filter(
+        (p) => typeof p === "object" && p !== null && p.type === "text"
+      ).map((p) => typeof p.text === "string" ? p.text : "").join(" ");
+    }
+    if (role === "system") {
+      system = system ? `${system}
+${text2}` : text2;
+    } else {
+      parts.push(text2);
+      if (role === "user" && text2.trim()) {
+        lastUserText = extractRouteTextFromUserMessage(text2);
+      }
+      if (!openingText && text2.trim()) {
+        openingText = text2;
+      }
+    }
+  }
+  const text = parts.join(" ");
+  return { text, routeText: lastUserText || text, system, openingText };
+}
+function buildUpstreamHeaders(req, cfg) {
+  const headers = {};
+  const setHeader = (key, value) => {
+    const existingKey = Object.keys(headers).find(
+      (candidate) => candidate.toLowerCase() === key.toLowerCase()
+    );
+    if (existingKey) {
+      delete headers[existingKey];
+    }
+    headers[key] = value;
+  };
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (HOP_BY_HOP.has(key.toLowerCase())) continue;
+    if (value !== void 0) {
+      setHeader(key, Array.isArray(value) ? value.join(", ") : value);
+    }
+  }
+  for (const [key, value] of Object.entries(cfg.headers)) {
+    setHeader(key, value);
+  }
+  const hasAuth = Object.keys(headers).some(
+    (k) => k.toLowerCase() === "authorization"
+  );
+  if (!hasAuth && cfg.apiKey) {
+    headers.authorization = `Bearer ${cfg.apiKey}`;
+  }
+  if (!Object.keys(headers).some((k) => k.toLowerCase() === "content-type")) {
+    setHeader("content-type", "application/json");
+  }
+  return headers;
+}
+function writeJson(res, status, body) {
+  if (!res.headersSent) {
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify(body));
+  }
+}
+function copyResponseHeaders(response, extraHeaders) {
+  const headers = {};
+  for (const [key, value] of response.headers.entries()) {
+    const lower = key.toLowerCase();
+    if (HOP_BY_HOP.has(lower)) continue;
+    if (PUBLIC_HEADER_PREFIXES.some((prefix) => lower.startsWith(prefix)))
+      continue;
+    headers[key] = value;
+  }
+  Object.assign(headers, extraHeaders);
+  return headers;
+}
+async function streamResponse(response, res) {
+  if (response.body) {
+    for await (const chunk of response.body) {
+      res.write(chunk);
+    }
+  }
+  res.end();
+}
+function writeOpenAiError(res, status, message, type = "invalid_request_error", code = null, headers) {
+  if (headers) {
+    for (const [key, value] of Object.entries(headers)) {
+      res.setHeader(key, value);
+    }
+  }
+  writeJson(res, status, {
+    error: {
+      message,
+      type,
+      param: null,
+      code
+    }
+  });
+}
+async function fetchUpstream(cfg, req, body, actualModel) {
+  try {
+    const response = await fetch(`${cfg.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: buildUpstreamHeaders(req, cfg),
+      body: JSON.stringify({ ...body, model: actualModel })
+    });
+    if (RETRYABLE_STATUS.has(response.status)) {
+      return { ok: false, reason: "retryable", response };
+    }
+    return { ok: true, response };
+  } catch (error) {
+    return { ok: false, reason: "network_error", error };
+  }
+}
+function getMaxOutputTokens(body) {
+  const maxTokens = body.max_tokens;
+  if (typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0) {
+    return Math.ceil(maxTokens);
+  }
+  const maxCompletionTokens = body.max_completion_tokens;
+  if (typeof maxCompletionTokens === "number" && Number.isFinite(maxCompletionTokens) && maxCompletionTokens > 0) {
+    return Math.ceil(maxCompletionTokens);
+  }
+  return 1024;
+}
+function buildRouterOptions(options) {
+  return {
+    config: options.routingConfig,
+    modelPricing: options.modelPricing
+  };
+}
+function buildRoutingConfigFromRawConfig(rawConfig) {
+  const scoring = {
+    ...DEFAULT_ROUTING_CONFIG.scoring,
+    tierBoundaries: {
+      ...DEFAULT_ROUTING_CONFIG.scoring.tierBoundaries,
+      ...rawConfig.routing.tierBoundaries
+    },
+    confidenceThreshold: rawConfig.routing.confidenceThreshold ?? DEFAULT_ROUTING_CONFIG.scoring.confidenceThreshold
+  };
+  return {
+    ...DEFAULT_ROUTING_CONFIG,
+    scoring,
+    tiers: mapRawTierEntries(rawConfig.routing.tiers),
+    overrides: {
+      structuredOutputMinTier: rawConfig.routing.structuredOutputMinTier ?? "MEDIUM",
+      ambiguousDefaultTier: rawConfig.routing.ambiguousDefaultTier ?? "MEDIUM"
+    }
+  };
+}
+function mapRawTierEntries(entries) {
+  return Object.fromEntries(
+    Object.entries(entries).map(([tier, entry]) => [
+      tier,
+      {
+        primary: entry.publicModel,
+        fallback: entry.fallback ?? []
+      }
+    ])
+  );
+}
+function buildModelPricingFromPublicModels(publicModels, registry2) {
+  return new Map(
+    Object.entries(publicModels).map(([publicModelId, config]) => {
+      if (config.kind === "router") {
+        return [
+          publicModelId,
+          {
+            inputPrice: config.metadata.cost.input,
+            outputPrice: config.metadata.cost.output
+          }
+        ];
+      }
+      const physicalModel = resolvePublicModelCandidate(
+        publicModelId,
+        publicModels,
+        registry2
+      );
+      return [
+        publicModelId,
+        {
+          inputPrice: physicalModel.inputPrice,
+          outputPrice: physicalModel.outputPrice
+        }
+      ];
+    })
+  );
+}
+var TIER_ORDER = {
+  SIMPLE: 0,
+  MEDIUM: 1,
+  COMPLEX: 2,
+  REASONING: 3
+};
+function isLowerTier(nextTier, pinnedTier) {
+  return TIER_ORDER[nextTier] < TIER_ORDER[pinnedTier];
+}
+function getExplicitTier(publicModelId, entries) {
+  const matches = Object.entries(entries).filter(([, entry]) => entry.publicModel === publicModelId).map(([tier]) => tier);
+  if (matches.length === 0) {
+    return "MEDIUM";
+  }
+  return matches.reduce(
+    (highest, tier) => TIER_ORDER[tier] > TIER_ORDER[highest] ? tier : highest
+  );
+}
+function getTraceReason(selected, failed) {
+  if (selected.explicit) return "user";
+  if (selected.decision?.tier === "REASONING") return "reasoning";
+  if (failed) return "error";
+  return "first-pass";
+}
+function buildPublicHeaders(cfg, selected, finalTier, trace) {
+  return {
+    "x-xy-router-model": selected.routedModel,
+    "x-xy-router-actual-model": selected.actualModel,
+    "x-xy-router-tier": finalTier,
+    "x-xy-router-trace": trace,
+    "x-xy-router-routed": String(selected.routed),
+    "x-xy-router-fallback": "false",
+    "x-xy-router-upstream": cfg.baseUrl
+  };
+}
+function emitProxyTrace(cfg, selected, finalTier, attempts, sessionAction, failed) {
+  const writer = resolveTraceWriter(cfg.traceLogger);
+  const reason = getTraceReason(selected, failed);
+  const trace = buildTraceSummary({
+    requestedModel: selected.requestedModel,
+    routedModel: selected.routedModel,
+    actualModel: selected.actualModel,
+    tier: finalTier,
+    profile: selected.decision?.profile ?? "default",
+    reason,
+    routed: selected.routed,
+    explicit: selected.explicit,
+    fallback: false
+  });
+  const detail = {
+    trace,
+    requestedModel: selected.requestedModel,
+    routedModel: selected.routedModel,
+    actualModel: selected.actualModel,
+    tier: finalTier,
+    profile: selected.decision?.profile ?? "default",
+    reason,
+    explicit: selected.explicit,
+    routed: selected.routed,
+    fallback: false,
+    attempts,
+    sessionAction,
+    ...selected.decision && {
+      method: selected.decision.method,
+      confidence: selected.decision.confidence,
+      ...selected.decision.score !== void 0 && {
+        score: selected.decision.score
+      },
+      ...selected.decision.agenticScore !== void 0 && {
+        agenticScore: selected.decision.agenticScore
+      }
+    },
+    ...cfg.traceMode === "debug" && {
+      promptPreview: getPromptPreview(selected.routeText)
+    }
+  };
+  emitRouteTrace(cfg.traceMode, detail, writer);
+  return trace;
+}
+function chooseModel(requestedModel, body, headers, sessionStore, cfg, tierEntries, publicModels, registry2, routerOptions) {
+  const prompt = extractPrompt(body.messages ?? []);
+  if (requestedModel !== "auto") {
+    const physicalModel2 = resolvePublicModelCandidate(
+      requestedModel,
+      publicModels,
+      registry2
+    );
+    return {
+      routedModel: requestedModel,
+      actualModel: physicalModel2.id,
+      tier: getExplicitTier(requestedModel, tierEntries),
+      routeText: prompt.routeText,
+      requestedModel,
+      routed: false,
+      explicit: true,
+      sessionAction: "none"
+    };
+  }
+  const sessionId = deriveSessionId(headers, body.messages ?? []);
+  const existing = cfg.sessionPinning ? sessionStore.getSession(sessionId) : void 0;
+  const decision = route(
+    prompt.routeText,
+    prompt.system,
+    getMaxOutputTokens(body),
+    routerOptions
+  );
+  const routedModel = decision.publicModel;
+  const physicalModel = resolvePublicModelCandidate(
+    routedModel,
+    publicModels,
+    registry2
+  );
+  if (existing && isLowerTier(decision.tier, existing.pinnedTier)) {
+    sessionStore.touchSession(sessionId);
+    return {
+      routedModel: existing.routedPublicModel,
+      actualModel: existing.physicalModelId,
+      tier: existing.pinnedTier,
+      routeText: prompt.routeText,
+      requestedModel,
+      sessionId,
+      routed: true,
+      explicit: false,
+      sessionAction: "reuse"
+    };
+  }
+  return {
+    routedModel,
+    actualModel: physicalModel.id,
+    tier: decision.tier,
+    decision,
+    routeText: prompt.routeText,
+    requestedModel,
+    sessionId,
+    routed: true,
+    explicit: false,
+    sessionAction: "none"
+  };
+}
+async function proxyChat(req, res, cfg, sessionStore, tierEntries, publicModels, registry2, routerOptions) {
+  const rawBody = await readBody(req);
+  let body;
+  try {
+    body = JSON.parse(rawBody);
+  } catch {
+    writeOpenAiError(res, 400, "Invalid JSON body");
+    return;
+  }
+  if (!body || typeof body !== "object") {
+    writeOpenAiError(res, 400, "Body must be a JSON object");
+    return;
+  }
+  const bodyObj = body;
+  const requestedModelId = bodyObj.model;
+  const supportedModels = [...REQUESTABLE_PUBLIC_MODELS].filter((modelId) => publicModels[modelId]).sort().join(", ");
+  if (typeof requestedModelId !== "string" || !publicModels[requestedModelId] || !REQUESTABLE_PUBLIC_MODELS.has(requestedModelId)) {
+    writeOpenAiError(
+      res,
+      400,
+      `Unknown model "${String(requestedModelId)}". Supported models: ${supportedModels}`,
+      "invalid_request_error",
+      "model_not_found"
+    );
+    return;
+  }
+  const selected = chooseModel(
+    requestedModelId,
+    bodyObj,
+    req.headers,
+    sessionStore,
+    cfg,
+    tierEntries,
+    publicModels,
+    registry2,
+    routerOptions
+  );
+  const physicalModel = registry2.get(selected.actualModel);
+  if (!physicalModel) {
+    writeOpenAiError(
+      res,
+      500,
+      `Physical model not found in registry: ${selected.actualModel}`
+    );
+    return;
+  }
+  const attempt = await fetchUpstream(cfg, req, bodyObj, physicalModel.id);
+  const attempts = [
+    attempt.ok ? { model: selected.actualModel, status: "success" } : {
+      model: selected.actualModel,
+      status: "error",
+      error: attempt.reason === "network_error" ? "network_error" : `upstream_http_${attempt.response.status}`
+    }
+  ];
+  const finalTier = selected.tier;
+  let sessionAction = selected.sessionAction;
+  if (!attempt.ok && attempt.reason === "network_error") {
+    const trace2 = emitProxyTrace(
+      cfg,
+      selected,
+      finalTier,
+      attempts,
+      sessionAction,
+      true
+    );
+    const headers2 = buildPublicHeaders(cfg, selected, finalTier, trace2);
+    writeOpenAiError(
+      res,
+      502,
+      attempt.error instanceof Error ? attempt.error.message : "Upstream request failed",
+      "invalid_request_error",
+      null,
+      headers2
+    );
+    return;
+  }
+  if (attempt.ok && selected.sessionId && !selected.explicit) {
+    sessionStore.setSession(selected.sessionId, {
+      physicalModelId: selected.actualModel,
+      routedPublicModel: selected.routedModel,
+      pinnedTier: finalTier
+    });
+    if (sessionAction === "none") {
+      sessionAction = "set";
+    }
+  }
+  const trace = emitProxyTrace(
+    cfg,
+    selected,
+    finalTier,
+    attempts,
+    sessionAction,
+    !attempt.ok
+  );
+  const headers = buildPublicHeaders(cfg, selected, finalTier, trace);
+  const responseHeaders = copyResponseHeaders(attempt.response, headers);
+  res.statusCode = attempt.response.status;
+  for (const [k, v] of Object.entries(responseHeaders)) {
+    res.setHeader(k, v);
+  }
+  await streamResponse(attempt.response, res);
+}
+async function startProxy(options) {
+  const cfg = resolveConfig({
+    baseUrl: options.config.proxy.upstreamUrl,
+    apiKey: options.config.proxy.apiKey,
+    headers: options.config.proxy.headers,
+    port: options.config.proxy.port,
+    traceMode: options.config.proxy.trace,
+    traceLogger: options.traceLogger,
+    sessionPinning: options.session?.enabled
+  });
+  const sessionStore = new SessionStore(options.session);
+  const publicModels = options.config.publicModels;
+  const tierEntries = options.config.routing.tiers;
+  const registry2 = createModelRegistry(options.config.models);
+  const routerOptions = buildRouterOptions({
+    routingConfig: buildRoutingConfigFromRawConfig(options.config),
+    modelPricing: buildModelPricingFromPublicModels(publicModels, registry2)
+  });
+  const server = http.createServer((req, res) => {
+    void (async () => {
+      try {
+        const url = req.url ?? "/";
+        if (req.method === "GET" && url === "/health") {
+          res.setHeader("content-type", "application/json");
+          res.end(
+            JSON.stringify({
+              status: "ok",
+              baseUrl: cfg.baseUrl,
+              version: VERSION
+            })
+          );
+          return;
+        }
+        if (req.method === "POST" && url === "/v1/chat/completions") {
+          await proxyChat(
+            req,
+            res,
+            cfg,
+            sessionStore,
+            tierEntries,
+            publicModels,
+            registry2,
+            routerOptions
+          );
+          return;
+        }
+        writeOpenAiError(res, 404, "Not Found");
+      } catch (error) {
+        if (!res.headersSent) {
+          writeOpenAiError(res, 502, String(error));
+        } else {
+          res.destroy();
+        }
+      }
+    })();
+  });
+  const port = await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(cfg.port, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Could not determine server port"));
+        return;
+      }
+      resolve(address.port);
+    });
+  });
+  return {
+    port,
+    baseUrl: cfg.baseUrl,
+    close: () => new Promise((resolve, reject) => {
+      server.close((err) => {
+        sessionStore.close();
+        if (err) reject(err);
+        else resolve();
+      });
+    })
+  };
+}
+
+// src/cli.ts
+function parseArgs(rawArgs) {
+  const result = { help: false, version: false, unknown: [] };
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        result.help = true;
+        break;
+      case "--version":
+      case "-v":
+        result.version = true;
+        break;
+      case "--port": {
+        const val = rawArgs[++i];
+        if (val === void 0) {
+          result.unknown.push(arg);
+          break;
+        }
+        const port = Number.parseInt(val, 10);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+          result.unknown.push(arg, val);
+        } else {
+          result.port = port;
+        }
+        break;
+      }
+      case "--config": {
+        const val = rawArgs[++i];
+        if (val === void 0) {
+          result.unknown.push(arg);
+        } else {
+          result.config = val;
+        }
+        break;
+      }
+      case "--api-key": {
+        const val = rawArgs[++i];
+        if (val === void 0) {
+          result.unknown.push(arg);
+        } else {
+          result.apiKey = val;
+        }
+        break;
+      }
+      case "--base-url": {
+        const val = rawArgs[++i];
+        if (val === void 0) {
+          result.unknown.push(arg);
+        } else {
+          result.baseUrl = val;
+        }
+        break;
+      }
+      default:
+        result.unknown.push(arg);
+        break;
+    }
+  }
+  return result;
+}
+function helpText() {
+  return `llm-router v${VERSION}
+
+Usage:
+  llm-router --config <path>          Start the local proxy with config
+  llm-router --config <path> --port 9000  Listen on a custom port
+
+Options:
+  --help, -h                            Show help
+  --version, -v                         Show version
+  --config <path>                       Configuration file path (required)
+  --port <number>                       Override proxy port
+  --api-key <key>                       Override API key
+  --base-url <url>                      Override upstream API base URL`;
+}
+var defaultRuntime = {
+  log: console.log,
+  error: console.error,
+  exit: (code) => process.exit(code),
+  onSignal: (signal, handler) => process.on(signal, handler),
+  startProxy
+};
+async function runCli(rawArgs, runtime = {}) {
+  const rt = { ...defaultRuntime, ...runtime };
+  const args = parseArgs(rawArgs);
+  if (args.help) {
+    rt.log(helpText());
+    rt.exit(0);
+    return;
+  }
+  if (args.version) {
+    rt.log(`v${VERSION}`);
+    rt.exit(0);
+    return;
+  }
+  if (args.unknown.length > 0) {
+    for (const cmd of args.unknown) {
+      rt.error(`Unsupported command: ${cmd}`);
+    }
+    rt.exit(1);
+    return;
+  }
+  if (!args.config) {
+    rt.error("Missing required argument: --config <path>");
+    rt.exit(1);
+    return;
+  }
+  const rawConfig = loadConfig({ kind: "file", path: args.config });
+  const proxyConfig = resolveProxyConfig(rawConfig.proxy, {
+    port: args.port,
+    upstreamUrl: args.baseUrl,
+    apiKey: args.apiKey
+  });
+  const runtimeConfig = {
+    ...rawConfig,
+    proxy: proxyConfig
+  };
+  const handle = await rt.startProxy({
+    config: runtimeConfig
+  });
+  rt.log(`llm-router listening on http://127.0.0.1:${handle.port}`);
+  const shutdown = async () => {
+    rt.log("\nShutting down...");
+    await handle.close();
+    rt.exit(0);
+  };
+  rt.onSignal("SIGINT", () => {
+    void shutdown();
+  });
+  rt.onSignal("SIGTERM", () => {
+    void shutdown();
+  });
+}
+function isMain() {
+  return process.argv[1] === fileURLToPath(import.meta.url);
+}
+if (isMain()) {
+  void runCli(process.argv.slice(2));
+}
+export {
+  isMain,
+  parseArgs,
+  runCli
+};
+//# sourceMappingURL=cli.js.map