@blockrun/llm 3.11.0 → 3.13.0

package/dist/index.cjs

@@ -88,7 +88,7 @@ __export(index_exports, {
   importSolanaWallet: () => importSolanaWallet,
   importWallet: () => importWallet,
   listDiscoveredSolanaWallets: () => listDiscoveredSolanaWallets,
-  listDiscoveredWallets: () => listDiscoveredWallets,
+  listDiscoveredWallets: () => listDiscoveredWallets2,
   loadSolanaWallet: () => loadSolanaWallet,
   loadWallet: () => loadWallet,
   logCost: () => logCost,
@@ -97,7 +97,7 @@ __export(index_exports, {
   saveToCache: () => saveToCache,
   saveWallet: () => saveWallet,
   scanSolanaWallets: () => scanSolanaWallets,
-  scanWallets: () => scanWallets,
+  scanWallets: () => scanWallets2,
   setCache: () => setCache,
   setupAgentSolanaWallet: () => setupAgentSolanaWallet,
   setupAgentWallet: () => setupAgentWallet,
@@ -145,6 +145,3362 @@ var APIError = class extends BlockrunError {
   }
 };
 
+// node_modules/.pnpm/@blockrun+router-core@https+++codeload.github.com+BlockRunAI+router-core+tar.gz+d4308049348e1_gni7wlazdyzf7iqax5nhqdpoqi/node_modules/@blockrun/router-core/dist/index.js
+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((kw) => text.includes(kw.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/];
+  const hits = patterns.filter((p) => p.test(text));
+  if (hits.length > 0) {
+    return { name: "multiStepPatterns", score: 0.5, signal: "multi-step" };
+  }
+  return { name: "multiStepPatterns", score: 0, signal: null };
+}
+function scoreQuestionComplexity(prompt) {
+  const count = (prompt.match(/\?/g) || []).length;
+  if (count > 3) {
+    return { name: "questionComplexity", score: 0.5, signal: `${count} questions` };
+  }
+  return { 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
+    };
+  } else if (matchCount >= 3) {
+    return {
+      dimensionScore: {
+        name: "agenticTask",
+        score: 0.6,
+        signal: `agentic (${signals.join(", ")})`
+      },
+      agenticScore: 0.6
+    };
+  } else 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 = [
+    // Token count uses total estimated tokens (system + user) — context size matters for model selection
+    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),
+    // 6 new dimensions
+    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 agenticScore = agenticResult.agenticScore;
+  const signals = dimensions.filter((d) => d.signal !== null).map((d) => d.signal);
+  const weights = config.dimensionWeights;
+  let weightedScore = 0;
+  for (const d of dimensions) {
+    const w = weights[d.name] ?? 0;
+    weightedScore += d.score * w;
+  }
+  const reasoningMatches = config.reasoningKeywords.filter(
+    (kw) => userText.includes(kw.toLowerCase())
+  );
+  if (reasoningMatches.length >= 2) {
+    const confidence2 = calibrateConfidence(
+      Math.max(weightedScore, 0.3),
+      // ensure positive for confidence calc
+      config.confidenceSteepness
+    );
+    return {
+      score: weightedScore,
+      tier: "REASONING",
+      confidence: Math.max(confidence2, 0.85),
+      signals,
+      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, dimensions };
+  }
+  return { score: weightedScore, tier, confidence, signals, agenticScore, dimensions };
+}
+function calibrateConfidence(distance, steepness) {
+  return 1 / (1 + Math.exp(-steepness * distance));
+}
+var BASELINE_MODEL_ID = "anthropic/claude-opus-4.7";
+var BASELINE_INPUT_PRICE = 5;
+var BASELINE_OUTPUT_PRICE = 25;
+function selectModel(tier, confidence, method, reasoning, tierConfigs, modelPricing, estimatedInputTokens, maxOutputTokens, routingProfile, agenticScore) {
+  const tierConfig = tierConfigs[tier];
+  const model = tierConfig.primary;
+  const pricing = modelPricing.get(model);
+  let costEstimate;
+  if (pricing?.flatPrice !== void 0) {
+    costEstimate = pricing.flatPrice;
+  } else {
+    const inputPrice = pricing?.inputPrice ?? 0;
+    const outputPrice = pricing?.outputPrice ?? 0;
+    costEstimate = estimatedInputTokens / 1e6 * inputPrice + maxOutputTokens / 1e6 * outputPrice;
+  }
+  const opusPricing = modelPricing.get(BASELINE_MODEL_ID);
+  const opusInputPrice = opusPricing?.inputPrice ?? BASELINE_INPUT_PRICE;
+  const opusOutputPrice = opusPricing?.outputPrice ?? BASELINE_OUTPUT_PRICE;
+  const baselineInput = estimatedInputTokens / 1e6 * opusInputPrice;
+  const baselineOutput = maxOutputTokens / 1e6 * opusOutputPrice;
+  const baselineCost = baselineInput + baselineOutput;
+  const savings = routingProfile === "premium" ? 0 : baselineCost > 0 ? Math.max(0, (baselineCost - costEstimate) / baselineCost) : 0;
+  return {
+    model,
+    tier,
+    confidence,
+    method,
+    reasoning,
+    costEstimate,
+    baselineCost,
+    savings,
+    ...agenticScore !== void 0 && { agenticScore }
+  };
+}
+function getFallbackChain(tier, tierConfigs) {
+  const config = tierConfigs[tier];
+  return [config.primary, ...config.fallback];
+}
+var SERVER_MARGIN_PERCENT = 5;
+var MIN_PAYMENT_USD = 1e-3;
+function calculateModelCost(model, modelPricing, estimatedInputTokens, maxOutputTokens, routingProfile) {
+  const pricing = modelPricing.get(model);
+  let costEstimate;
+  if (pricing?.flatPrice !== void 0) {
+    costEstimate = Math.max(pricing.flatPrice * (1 + SERVER_MARGIN_PERCENT / 100), MIN_PAYMENT_USD);
+  } else {
+    const inputPrice = pricing?.inputPrice ?? 0;
+    const outputPrice = pricing?.outputPrice ?? 0;
+    const inputCost = estimatedInputTokens / 1e6 * inputPrice;
+    const outputCost = maxOutputTokens / 1e6 * outputPrice;
+    costEstimate = Math.max(
+      (inputCost + outputCost) * (1 + SERVER_MARGIN_PERCENT / 100),
+      MIN_PAYMENT_USD
+    );
+  }
+  const opusPricing = modelPricing.get(BASELINE_MODEL_ID);
+  const opusInputPrice = opusPricing?.inputPrice ?? BASELINE_INPUT_PRICE;
+  const opusOutputPrice = opusPricing?.outputPrice ?? BASELINE_OUTPUT_PRICE;
+  const baselineInput = estimatedInputTokens / 1e6 * opusInputPrice;
+  const baselineOutput = maxOutputTokens / 1e6 * opusOutputPrice;
+  const baselineCost = baselineInput + baselineOutput;
+  const savings = routingProfile === "premium" ? 0 : baselineCost > 0 ? Math.max(0, (baselineCost - costEstimate) / baselineCost) : 0;
+  return { costEstimate, baselineCost, savings };
+}
+function filterCandidatesByCapacity(models, estimatedInputTokens, requestedOutputTokens, getCapabilities) {
+  const filtered = models.filter((modelId) => {
+    const capabilities = getCapabilities(modelId);
+    if (!capabilities) return true;
+    return capabilities.contextWindow >= (estimatedInputTokens + requestedOutputTokens) * 1.1 && capabilities.maxOutput >= requestedOutputTokens;
+  });
+  return filtered;
+}
+function applyPromotions(tierConfigs, promotions, profile, now = /* @__PURE__ */ new Date()) {
+  if (!promotions || promotions.length === 0) return tierConfigs;
+  let result = tierConfigs;
+  for (const promo of promotions) {
+    const start = new Date(promo.startDate);
+    const end = new Date(promo.endDate);
+    if (now < start || now >= end) continue;
+    if (promo.profiles && !promo.profiles.includes(profile)) continue;
+    if (result === tierConfigs) {
+      result = { ...tierConfigs };
+      for (const t of Object.keys(result)) {
+        result[t] = { ...result[t] };
+      }
+    }
+    for (const [tier, override] of Object.entries(promo.tierOverrides)) {
+      if (!result[tier]) continue;
+      if (override.primary) result[tier].primary = override.primary;
+      if (override.fallback) result[tier].fallback = override.fallback;
+    }
+  }
+  return result;
+}
+var RulesStrategy = class {
+  name = "rules";
+  route(prompt, systemPrompt, maxOutputTokens, options) {
+    const { config, modelPricing } = options;
+    const fullText = `${systemPrompt ?? ""} ${prompt}`;
+    const estimatedTokens = Math.ceil(fullText.length / 4);
+    const scanLimit = Math.max(1, Math.min(8e3, config.classifier.promptTruncationChars));
+    const sample = (value) => {
+      if (value.length <= scanLimit) return value;
+      const prefixLength = Math.ceil(scanLimit / 2);
+      return `${value.slice(0, prefixLength)}
+${value.slice(-(scanLimit - prefixLength))}`;
+    };
+    const scannedPrompt = sample(prompt);
+    const scannedSystemPrompt = systemPrompt ? sample(systemPrompt) : void 0;
+    const ruleResult = classifyByRules(
+      scannedPrompt,
+      scannedSystemPrompt,
+      estimatedTokens,
+      config.scoring
+    );
+    const { routingProfile } = options;
+    let tierConfigs;
+    let profileSuffix;
+    let profile;
+    if (routingProfile === "eco") {
+      tierConfigs = config.ecoTiers ?? config.tiers;
+      profileSuffix = config.ecoTiers ? " | eco" : " | eco (default tiers)";
+      profile = "eco";
+    } else if (routingProfile === "premium") {
+      tierConfigs = config.premiumTiers ?? config.tiers;
+      profileSuffix = config.premiumTiers ? " | premium" : " | premium (default tiers)";
+      profile = "premium";
+    } else {
+      const agenticScore = ruleResult.agenticScore ?? 0;
+      const isAutoAgentic = agenticScore >= 0.5;
+      const agenticModeSetting = config.overrides.agenticMode;
+      const hasToolsInRequest = options.requiresTools ?? options.hasTools ?? false;
+      let useAgenticTiers;
+      if (agenticModeSetting === false) {
+        useAgenticTiers = false;
+      } else if (agenticModeSetting === true) {
+        useAgenticTiers = config.agenticTiers != null;
+      } else {
+        useAgenticTiers = (hasToolsInRequest || isAutoAgentic) && config.agenticTiers != null;
+      }
+      tierConfigs = useAgenticTiers ? config.agenticTiers : config.tiers;
+      profileSuffix = useAgenticTiers ? ` | agentic${hasToolsInRequest ? " (tools)" : ""}` : "";
+      profile = useAgenticTiers ? "agentic" : "auto";
+    }
+    tierConfigs = applyPromotions(tierConfigs, config.promotions, profile, options.now);
+    const agenticScoreValue = ruleResult.agenticScore;
+    if (estimatedTokens > config.overrides.maxTokensForceComplex) {
+      const decision2 = selectModel(
+        "COMPLEX",
+        0.95,
+        "rules",
+        `Input exceeds ${config.overrides.maxTokensForceComplex} tokens${profileSuffix}`,
+        tierConfigs,
+        modelPricing,
+        estimatedTokens,
+        maxOutputTokens,
+        routingProfile,
+        agenticScoreValue
+      );
+      return { ...decision2, tierConfigs, profile };
+    }
+    const hasStructuredOutput = options.requiresStructuredOutput === true || (scannedSystemPrompt ? /json|structured|schema/i.test(scannedSystemPrompt) : false);
+    let tier;
+    let confidence;
+    const method = "rules";
+    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;
+      confidence = 0.5;
+      reasoning += ` | ambiguous -> default: ${tier}`;
+    }
+    if (hasStructuredOutput) {
+      const tierRank = { SIMPLE: 0, MEDIUM: 1, COMPLEX: 2, REASONING: 3 };
+      const minTier = config.overrides.structuredOutputMinTier;
+      if (tierRank[tier] < tierRank[minTier]) {
+        reasoning += ` | upgraded to ${minTier} (structured output)`;
+        tier = minTier;
+      }
+    }
+    reasoning += profileSuffix;
+    const decision = selectModel(
+      tier,
+      confidence,
+      method,
+      reasoning,
+      tierConfigs,
+      modelPricing,
+      estimatedTokens,
+      maxOutputTokens,
+      routingProfile,
+      agenticScoreValue
+    );
+    return { ...decision, tierConfigs, profile };
+  }
+};
+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;
+}
+function registerStrategy(strategy) {
+  registry.set(strategy.name, strategy);
+}
+var DEFAULT_MODEL_CAPABILITIES = Object.freeze({
+  "anthropic/claude-fable-5": {
+    contextWindow: 1e6,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "anthropic/claude-haiku-4.5": {
+    contextWindow: 2e5,
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "anthropic/claude-opus-4.6": {
+    contextWindow: 1e6,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "anthropic/claude-opus-4.7": {
+    contextWindow: 1e6,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "anthropic/claude-opus-4.8": {
+    contextWindow: 1e6,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "anthropic/claude-opus-5": {
+    contextWindow: 1e6,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "anthropic/claude-sonnet-4.6": {
+    contextWindow: 2e5,
+    maxOutputTokens: 64e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "anthropic/claude-sonnet-5": {
+    contextWindow: 1e6,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "deepseek/deepseek-chat": {
+    contextWindow: 1e6,
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "deepseek/deepseek-reasoner": {
+    contextWindow: 1e6,
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "deepseek/deepseek-v4-pro": {
+    contextWindow: 1048576,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "free/deepseek-v4-flash": {
+    contextWindow: 1e6,
+    maxOutputTokens: 16384,
+    supportsTools: false,
+    supportsVision: false
+  },
+  "free/gpt-oss-120b": {
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    supportsTools: false,
+    supportsVision: false
+  },
+  "free/gpt-oss-20b": {
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    supportsTools: false,
+    supportsVision: false
+  },
+  "free/seed-oss-36b": {
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    supportsTools: false,
+    supportsVision: false
+  },
+  "google/gemini-2.5-flash": {
+    contextWindow: 1e6,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "google/gemini-2.5-flash-lite": {
+    contextWindow: 1e6,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "google/gemini-2.5-pro": {
+    contextWindow: 105e4,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "google/gemini-3-flash-preview": {
+    contextWindow: 1e6,
+    maxOutputTokens: 65536,
+    supportsTools: false,
+    supportsVision: true
+  },
+  "google/gemini-3.1-flash-lite": {
+    contextWindow: 1e6,
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "google/gemini-3.1-pro": {
+    contextWindow: 105e4,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "google/gemini-3.5-flash": {
+    contextWindow: 1048576,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "moonshot/kimi-k2.5": {
+    contextWindow: 262144,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "moonshot/kimi-k2.6": {
+    contextWindow: 262144,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "moonshot/kimi-k2.7": {
+    contextWindow: 262144,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "moonshot/kimi-k3": {
+    contextWindow: 1048576,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "openai/gpt-4.1": {
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "openai/gpt-4o-mini": {
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "openai/gpt-5-mini": {
+    contextWindow: 2e5,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "openai/gpt-5.3-codex": {
+    contextWindow: 4e5,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "openai/gpt-5.4": {
+    contextWindow: 4e5,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "openai/gpt-5.4-nano": {
+    contextWindow: 105e4,
+    maxOutputTokens: 32768,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "openai/gpt-5.5": {
+    contextWindow: 105e4,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "openai/gpt-5.6-terra": {
+    contextWindow: 105e4,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "openai/o3": {
+    contextWindow: 2e5,
+    maxOutputTokens: 1e5,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "openai/o4-mini": {
+    contextWindow: 128e3,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "qwen/qwen3.7-max": {
+    contextWindow: 1e6,
+    maxOutputTokens: 65536,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "xai/grok-3-mini": {
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "xai/grok-4-0709": {
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "xai/grok-4-1-fast-non-reasoning": {
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "xai/grok-4-1-fast-reasoning": {
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "xai/grok-4-fast-non-reasoning": {
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "xai/grok-4-fast-reasoning": {
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "xai/grok-4.5": {
+    contextWindow: 5e5,
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    supportsVision: true
+  },
+  "zai/glm-5.1": {
+    contextWindow: 2e5,
+    maxOutputTokens: 128e3,
+    supportsTools: true,
+    supportsVision: false
+  },
+  "zai/glm-5.2": {
+    contextWindow: 1e6,
+    maxOutputTokens: 262144,
+    supportsTools: true,
+    supportsVision: false
+  }
+});
+var model_profiles_generated_default = {
+  "openai/gpt-5.5": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 6243.1,
+    p95LatencyMs: 9865,
+    outputTokensPerSecond: 12.53,
+    errorRate: 0,
+    samples: 3
+  },
+  "openai/gpt-5.4-pro": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 13015.5,
+    p95LatencyMs: 23976.4,
+    outputTokensPerSecond: 6.42,
+    errorRate: 0,
+    samples: 3
+  },
+  "openai/gpt-5.4-mini": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 5550,
+    p95LatencyMs: 6595.7,
+    outputTokensPerSecond: 11.96,
+    errorRate: 0.3333,
+    samples: 3
+  },
+  "openai/gpt-5.3-codex": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 4617.1,
+    p95LatencyMs: 5800.7,
+    outputTokensPerSecond: 12.48,
+    errorRate: 0,
+    samples: 3
+  },
+  "anthropic/claude-opus-4.8": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 3915.1,
+    p95LatencyMs: 6130.8,
+    outputTokensPerSecond: 16.33,
+    errorRate: 0,
+    samples: 3
+  },
+  "anthropic/claude-opus-4.6": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 3765.5,
+    p95LatencyMs: 4257.2,
+    outputTokensPerSecond: 14.18,
+    errorRate: 0,
+    samples: 3
+  },
+  "anthropic/claude-sonnet-4.6": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 3860.6,
+    p95LatencyMs: 5093.5,
+    outputTokensPerSecond: 13.85,
+    errorRate: 0,
+    samples: 3
+  },
+  "anthropic/claude-haiku-4.5": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 2734.9,
+    p95LatencyMs: 3181.6,
+    outputTokensPerSecond: 19.58,
+    errorRate: 0,
+    samples: 3
+  },
+  "google/gemini-3.1-pro": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 13935.7,
+    p95LatencyMs: 26675.3,
+    outputTokensPerSecond: 77.47,
+    errorRate: 0,
+    samples: 3
+  },
+  "google/gemini-3.5-flash": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 4608.7,
+    p95LatencyMs: 8420.9,
+    outputTokensPerSecond: 57.88,
+    errorRate: 0,
+    samples: 3
+  },
+  "google/gemini-3.1-flash-lite": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 4619.7,
+    p95LatencyMs: 9927.1,
+    outputTokensPerSecond: 42.01,
+    errorRate: 0,
+    samples: 3
+  },
+  "google/gemini-2.5-flash": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 5506.9,
+    p95LatencyMs: 11462.5,
+    outputTokensPerSecond: 65.19,
+    errorRate: 0,
+    samples: 3
+  },
+  "deepseek/deepseek-v4-pro": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 6044.8,
+    p95LatencyMs: 10782.3,
+    outputTokensPerSecond: 22.47,
+    errorRate: 0,
+    samples: 3
+  },
+  "deepseek/deepseek-reasoner": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 4111.9,
+    p95LatencyMs: 5305.7,
+    outputTokensPerSecond: 16.46,
+    errorRate: 0,
+    samples: 3
+  },
+  "deepseek/deepseek-chat": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 2648.6,
+    p95LatencyMs: 3524.1,
+    outputTokensPerSecond: 16.73,
+    errorRate: 0,
+    samples: 3
+  },
+  "moonshot/kimi-k2.7": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 4295.4,
+    p95LatencyMs: 6153.8,
+    outputTokensPerSecond: 18.54,
+    errorRate: 0,
+    samples: 3
+  },
+  "qwen/qwen3.7-max": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 30729.4,
+    p95LatencyMs: 39622,
+    outputTokensPerSecond: 36.89,
+    errorRate: 0.3333,
+    samples: 3
+  },
+  "xai/grok-4.3": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 6946.1,
+    p95LatencyMs: 9495.4,
+    outputTokensPerSecond: 65.3,
+    errorRate: 0,
+    samples: 3
+  },
+  "xai/grok-4.20-reasoning": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 3472.4,
+    p95LatencyMs: 5332.4,
+    outputTokensPerSecond: 13.27,
+    errorRate: 0,
+    samples: 3
+  },
+  "xai/grok-4.20-non-reasoning": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 5174.4,
+    p95LatencyMs: 6081.7,
+    outputTokensPerSecond: 10.21,
+    errorRate: 0.3333,
+    samples: 3
+  },
+  "xai/grok-4-1-fast-reasoning": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 13148.2,
+    p95LatencyMs: 19104.2,
+    outputTokensPerSecond: 4.28,
+    errorRate: 0,
+    samples: 3
+  },
+  "minimax/minimax-m3": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 3385,
+    p95LatencyMs: 4247.2,
+    outputTokensPerSecond: 15.16,
+    errorRate: 0,
+    samples: 3
+  },
+  "minimax/minimax-m2.7": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 4596.7,
+    p95LatencyMs: 6884.6,
+    outputTokensPerSecond: 17.03,
+    errorRate: 0,
+    samples: 3
+  },
+  "zai/glm-5.2": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 4406.3,
+    p95LatencyMs: 6139.7,
+    outputTokensPerSecond: 10.41,
+    errorRate: 0,
+    samples: 3
+  },
+  "zai/glm-5.1": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 7775.4,
+    p95LatencyMs: 9182.1,
+    outputTokensPerSecond: 6.08,
+    errorRate: 0,
+    samples: 3
+  },
+  "zai/glm-5": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 4159.4,
+    p95LatencyMs: 4992.7,
+    outputTokensPerSecond: 10.28,
+    errorRate: 0,
+    samples: 3
+  },
+  "free/qwen3-coder-480b": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 2063.9,
+    p95LatencyMs: 3646.3,
+    outputTokensPerSecond: 39.8,
+    errorRate: 0,
+    samples: 3
+  },
+  "free/mistral-large-3-675b": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 3147.5,
+    p95LatencyMs: 5555.3,
+    outputTokensPerSecond: 27.76,
+    errorRate: 0,
+    samples: 3
+  },
+  "free/nemotron-3-nano-omni-30b-a3b-reasoning": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 6508.4,
+    p95LatencyMs: 14252.7,
+    outputTokensPerSecond: 68.26,
+    errorRate: 0,
+    samples: 3
+  },
+  "free/glm-4.7": {
+    measuredAt: "2026-07-21T10:21:31Z",
+    latencyMs: 2014.8,
+    p95LatencyMs: 3039.9,
+    outputTokensPerSecond: 39.92,
+    errorRate: 0,
+    samples: 3
+  }
+};
+var LIVE_MODEL_PROFILES = Object.freeze(
+  model_profiles_generated_default
+);
+var HISTORICAL_MODEL_PROFILES = Object.freeze({
+  "anthropic/claude-haiku-4.5": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 2305,
+    outputTokensPerSecond: 140.6
+  },
+  "anthropic/claude-opus-4.6": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 2139,
+    outputTokensPerSecond: 119.7
+  },
+  "anthropic/claude-sonnet-4.6": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 2110,
+    outputTokensPerSecond: 121.3
+  },
+  "deepseek/deepseek-chat": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 1431,
+    outputTokensPerSecond: 179.2,
+    intelligenceIndex: 32
+  },
+  "google/gemini-2.5-flash": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 1238,
+    outputTokensPerSecond: 207.6,
+    intelligenceIndex: 20
+  },
+  "google/gemini-2.5-flash-lite": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 1353,
+    outputTokensPerSecond: 192.5,
+    intelligenceIndex: 20
+  },
+  "google/gemini-2.5-pro": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 1294,
+    outputTokensPerSecond: 197.8
+  },
+  "google/gemini-3.1-pro": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 1609,
+    outputTokensPerSecond: 167.2
+  },
+  "moonshot/kimi-k2.5": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 1646,
+    outputTokensPerSecond: 155.7
+  },
+  "openai/gpt-4o-mini": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 2764,
+    outputTokensPerSecond: 92.8
+  },
+  "openai/gpt-5.3-codex": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 7935,
+    outputTokensPerSecond: 32.3
+  },
+  "xai/grok-4-1-fast-non-reasoning": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 1244,
+    outputTokensPerSecond: 205.8,
+    intelligenceIndex: 41
+  },
+  "xai/grok-4-1-fast-reasoning": {
+    measuredAt: "2026-03-16T13:50:48Z",
+    latencyMs: 1454,
+    outputTokensPerSecond: 176.2,
+    intelligenceIndex: 41
+  }
+});
+function inferToolRequirement(prompt, _systemPrompt, toolChoice) {
+  if (toolChoice === "none") return false;
+  if (toolChoice === "required") return true;
+  if (typeof toolChoice === "object" && toolChoice !== null && toolChoice.type === "function") {
+    return true;
+  }
+  const text = prompt;
+  const explicitTool = /\b(?:use|call|invoke)\s+(?:the\s+)?[\w.-]+\s+(?:tool|function|api)\b|\btool[_ -]?call\b|使用.{0,20}(?:工具|函数|接口)|调用.{0,20}(?:工具|函数|接口)/i;
+  const codeEnvironment = /\b(?:run|execute)\s+(?:the\s+)?(?:tests?|command|script|build|linter)|\b(?:edit|modify|patch|create|write|save|delete|rename|move|inspect|read)\b.{0,60}\b(?:file|repository|repo|codebase|directory|folder)\b|\b(?:terminal|shell|bash|zsh|pytest|npm test|pnpm test|git\s+(?:status|diff|commit)|docker)\b|(?:运行|执行).{0,20}(?:测试|命令|脚本|构建)|(?:修改|编辑|修复|创建|读取|检查|保存).{0,30}(?:文件|仓库|代码库|目录)/i;
+  const webAction = /\b(?:browse|search|look up|fetch|open)\b.{0,80}\b(?:web|website|url|online|documentation|docs|news|weather|price)\b|(?:浏览|搜索|查询|打开).{0,30}(?:网页|网站|链接|文档|新闻|天气|价格)/i;
+  const statefulAction = /\b(?:refund|cancel|book|reserve|purchase|buy|return|exchange|transfer|update|change)\b.{0,80}\b(?:order|booking|reservation|account|address|payment|subscription|ticket|flight|item)\b|(?:退款|取消|预订|购买|退货|换货|转账|更新|修改).{0,30}(?:订单|预订|账户|地址|付款|订阅|票|航班|商品)/i;
+  return explicitTool.test(text) || codeEnvironment.test(text) || webAction.test(text) || statefulAction.test(text);
+}
+var DEFAULT_PORTFOLIO_WEIGHTS = {
+  auto: {
+    quality: 0.47,
+    capability: 0.2,
+    cost: 0.18,
+    speed: 0.07,
+    reliability: 0.03,
+    legacy: 0.05
+  },
+  eco: { quality: 0.36, capability: 0.2, cost: 0.28, speed: 0.1, reliability: 0.04, legacy: 0.02 },
+  premium: {
+    quality: 0.58,
+    capability: 0.2,
+    cost: 0.08,
+    speed: 0.06,
+    reliability: 0.06,
+    legacy: 0.02
+  },
+  highStakesBoost: { quality: 0.08, reliability: 0.05 },
+  latencySensitiveSpeedBoost: 0.08,
+  affinityFloorGap: { auto: 0.1, eco: 0.22, premium: 0.05 }
+};
+function likelyNeedsParallelToolCalls(prompt, needsTools, toolCount, toolNames) {
+  if (!needsTools || toolCount === void 0 || toolCount < 1) return false;
+  const text = prompt.trim();
+  const explicitRepeat = /\b(?:in parallel|simultaneously|concurrently|for each|each of|every one|both|(?:two|three|multiple|several)\s+(?:cities|locations|items|tasks|orders|users|files))\b|并行|同时|分别|每个|各自|(?:两个|三个|多个)(?:城市|地点|项目|任务|订单|用户|文件)|cada uno|para cada|simult[aá]neamente/i.test(
+    text
+  );
+  if (explicitRepeat) return true;
+  const sentenceClauses = text.split(/[.!?。！？]+/).map((part) => part.trim()).filter((part) => part.length >= 8);
+  if (/\b(?:also|additionally|furthermore)\b|另外|此外|그리고/i.test(text) && sentenceClauses.length >= 2 || /\band\s+(?:also|for the)\b/i.test(text))
+    return true;
+  const pairedQuantity = /\b\d+(?:\.\d+)?\s+(?:and|or)\s+\d+(?:\.\d+)?\s*(?:gb|mb|tb|kg|g|ml|oz|cups?|cores?|cpus?)\b/i.test(
+    text
+  );
+  if (pairedQuantity) return true;
+  const operationTokens = /* @__PURE__ */ new Set([
+    "add",
+    "delete",
+    "remove",
+    "cancel",
+    "return",
+    "exchange",
+    "modify",
+    "book",
+    "transfer",
+    "send",
+    "upload",
+    "download",
+    "create",
+    "close"
+  ]);
+  const lowered = text.toLowerCase();
+  const matchedOperationTokens = new Set(
+    (toolNames ?? []).flatMap((name) => name.toLowerCase().split(/[^a-z0-9\u3400-\u9fff]+/)).filter((token) => operationTokens.has(token) && lowered.includes(token))
+  );
+  if (matchedOperationTokens.size >= 2) return true;
+  const nonEmptyLines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const quantityMentions = text.match(
+    /\b(?:\d+(?:\.\d+)?|one|two|three|four|five|six|seven|eight|nine|ten)\s*(?:oz|ounce|ounces|g|gram|grams|kg|ml|cups?|pieces?|tablespoons?)\b/gi
+  ) ?? [];
+  if (nonEmptyLines.length >= 2 && quantityMentions.length >= 2) return true;
+  const repeatedLookup = /\b(?:weather|climate|clima|tiempo|temperature|snow|news|report)\b|天气|气象|温度|降雪|新闻|报告/i.test(
+    text
+  );
+  const multiLocationConnector = /\b(?:and also|both|y|e)\b|还有|以及|和|、/i.test(text);
+  const commaSeparatedLocations = (text.match(/[,，]/g) ?? []).length >= 2;
+  if (repeatedLookup && (multiLocationConnector || commaSeparatedLocations)) return true;
+  const distinctOrderParts = /\b(?:food|meal)\b[\s\S]*\bdrink\b|\bdrink\b[\s\S]*\b(?:food|meal)\b/i.test(text);
+  const koreanParallelClauses = (text.match(/,/g) ?? []).length >= 3 && /하고|그리고/.test(text);
+  return distinctOrderParts || koreanParallelClauses;
+}
+function classifyTask(prompt, systemPrompt, options) {
+  const fullText = `${systemPrompt ?? ""} ${prompt}`;
+  const estimatedInputTokens = Math.ceil(fullText.length / 4);
+  const scanLimit = Math.max(1, Math.min(8e3, options.config.classifier.promptTruncationChars));
+  const sample = (value) => {
+    if (value.length <= scanLimit) return value;
+    const prefixLength = Math.ceil(scanLimit / 2);
+    return `${value.slice(0, prefixLength)}
+${value.slice(-(scanLimit - prefixLength))}`;
+  };
+  const scannedPrompt = sample(prompt);
+  const scannedSystemPrompt = sample(systemPrompt ?? "");
+  const scannedFullText = `${scannedSystemPrompt} ${scannedPrompt}`;
+  const text = scannedPrompt.toLowerCase();
+  const explicitCodeSignal = /```|\b(?:typescript|javascript|python|rust|java|sql|stack trace|traceback|exception)\b|\.(?:ts|tsx|js|py|go|rs)\b/i.test(
+    scannedPrompt
+  );
+  const codeConstructSignal = /\b(?:implement|refactor|debug|write|edit|modify|create|define|review|fix)\b[\s\S]{0,48}\b(?:api|function|class|method)\b|\b(?:api|function|class|method)\b[\s\S]{0,48}\b(?:code|implementation|typescript|javascript|python|rust|java)\b/i.test(
+    scannedPrompt
+  );
+  const nativeCodeSignal = /\b(?:programmed|written|implemented?|code)\s+(?:in|using)\s+(?:c\+\+|c|rust|go)\b/i.test(
+    scannedPrompt
+  );
+  const hasCode = explicitCodeSignal || codeConstructSignal || nativeCodeSignal;
+  const toolsAvailable = options.hasTools ?? false;
+  const needsTools = options.requiresTools ?? (toolsAvailable && inferToolRequirement(scannedPrompt, scannedSystemPrompt));
+  const likelyParallelToolCalls = likelyNeedsParallelToolCalls(
+    scannedPrompt,
+    needsTools,
+    options.toolCount,
+    options.toolNames
+  );
+  const normalizedToolNames = (options.toolNames ?? []).map((name) => name.toLowerCase());
+  const airlineToolSignal = normalizedToolNames.some(
+    (name) => /(?:flight|reservation|airport|baggage|passenger)/.test(name)
+  );
+  const retailToolSignal = normalizedToolNames.some(
+    (name) => /(?:order|product|item|return|exchange|address)/.test(name)
+  );
+  const webResearchToolSignal = normalizedToolNames.some(
+    (name) => /^(?:web_?search|web_?fetch)$/.test(name)
+  );
+  const agentDomain = airlineToolSignal && !retailToolSignal ? "airline" : retailToolSignal && !airlineToolSignal ? "retail" : webResearchToolSignal ? "web_research" : "other";
+  const clueConnectors = scannedFullText.match(
+    /\b(?:after|before|while|where|whose|which|in \d{4}|as of|over \d+|another|also|furthermore)\b|(?:之后|之前|其中|截至|超过|另一个|此外)/gi
+  ) ?? [];
+  const entityResolutionSignal = /\b(?:identify|who (?:is|was)|what (?:is|was) the name|which (?:person|player|company|country|city)|find the (?:person|player|name|entity))\b|(?:找出|识别|是谁|哪位|名称是什么)/i.test(
+    scannedFullText
+  );
+  const exactAnswerSignal = /\b(?:exact answer|single best-supported answer|following clues|multiple public sources)\b|(?:精确答案|根据.*线索|多个公开来源)/i.test(
+    scannedFullText
+  );
+  const deepWebResearch = agentDomain === "web_research" && (exactAnswerSignal || entityResolutionSignal && (clueConnectors.length >= 3 || prompt.length >= 320));
+  const globalOptimizationSignal = /\b(?:cheapest|lowest[- ]price|least expensive|most expensive|highest(?:[- ]priced)?|largest|smallest|maximum|minimum|best available|closest|not (?:cost|exceed))\b|最便宜|最低价|最贵|最高价|最大|最小/i.test(
+    scannedPrompt
+  );
+  const globalScopeSignal = /\b(?:everything|all (?:(?:my|your|their|the) )?(?:future |upcoming )?(?:items|orders|passengers|flights|reservations|bookings)|every (?:item|order|passenger|flight|reservation|booking))\b|全部|所有|每个/i.test(
+    scannedPrompt
+  );
+  const globalChoiceSignal = globalOptimizationSignal || globalScopeSignal;
+  const crossRecordSignal = /\b(?:another|other|different|previous)\s+(?:order|reservation|booking|account|address)\b|另一(?:个)?(?:订单|预订|账户|地址)|其他(?:订单|预订|账户|地址)/i.test(
+    scannedPrompt
+  );
+  const reservationIds = scannedPrompt.match(/\b[A-Z0-9]{6}\b/g) ?? [];
+  const crossReservationBatchSignal = agentDomain === "airline" && (/\b(?:two|three|multiple|several)(?:\s+of\s+(?:my|our|the))?\s+(?:upcoming\s+)?(?:reservations?|bookings?)\b|\b(?:a\s+)?(?:second|third)\s+(?:reservation|booking)\b/i.test(
+    scannedPrompt
+  ) || new Set(reservationIds).size >= 2);
+  const conditionalGlobalWorkflowSignal = agentDomain === "airline" && globalScopeSignal && /\b(?:if|that (?:contain|have)|longer than|shorter than|under|over|at (?:most|least)|wherever possible)\b|如果|超过|少于|不超过|尽可能/i.test(
+    scannedPrompt
+  ) && /\b(?:cancel|change|upgrade|move|book)\b[\s\S]*\b(?:cancel|change|upgrade|move|book)\b|取消[\s\S]*(?:升级|更改)|升级[\s\S]*(?:取消|更改)/i.test(
+    scannedPrompt
+  );
+  const policyExceptionSignal = agentDomain === "retail" && /\b(?:return|refund|send back|get (?:my |the )?money back)\b|退货|退款|退回/i.test(
+    scannedPrompt
+  ) && /\b(?:amex|american express|visa|mastercard|credit card|debit card|different card|another card|other card)\b|信用卡|借记卡|其他卡|另一张卡/i.test(
+    scannedPrompt
+  );
+  const singleSelectedPolicyException = policyExceptionSignal && /\b(?:return|refund|send back)\b[^.!?。！？]{0,96}\b(?:the )?(?:pricier|cheaper|more expensive|less expensive|costlier|one)\b/i.test(
+    scannedPrompt
+  );
+  const negotiatedWorkflowSignal = agentDomain === "retail" && /\b(?:return|exchange)\b|退货|退回|换货|交换/i.test(scannedPrompt);
+  const numberedSteps = (scannedPrompt.match(/(?:^|\s)\d+(?:\.\d+)*[.)]\s+/g) ?? []).length;
+  const complexMultiToolPlan = likelyParallelToolCalls && ((options.toolCount ?? 0) >= 6 || numberedSteps >= 3 || prompt.length > 1200);
+  let agentRisk = needsTools && singleSelectedPolicyException ? "policy_exception_simple" : needsTools && policyExceptionSignal ? "policy_exception" : (
+    // Airline prompts that require a global optimum (for example the
+    // cheapest itinerary across several candidates) are materially harder
+    // than applying one change to every passenger in a known reservation.
+    // Full-session evidence supports Sonnet for the former, while upgrading
+    // the latter merely because it says "all passengers" caused a large cost
+    // increase without a quality gain.
+    needsTools && agentDomain === "airline" && (globalOptimizationSignal || conditionalGlobalWorkflowSignal) ? "complex_high" : needsTools && (likelyParallelToolCalls || globalChoiceSignal || crossRecordSignal || crossReservationBatchSignal || negotiatedWorkflowSignal) ? "high" : "standard"
+  );
+  const needsVision = options.hasVision ?? false;
+  const needsStructuredOutput = options.requiresStructuredOutput ?? false;
+  const latencySensitive = /\b(?:urgent|asap|fast|quick|low latency|real[- ]time)\b|尽快|马上|快速|低延迟/i.test(
+    scannedFullText
+  );
+  const highStakes = /\b(?:production|security|payment|legal|medical|financial|audit)\b|生产|安全|支付|法律|医疗|财务|审计/i.test(
+    scannedFullText
+  );
+  const terminalToolSignal = normalizedToolNames.some(
+    (name) => /^(?:terminalexec|terminalinspect|terminalsendkeys)$/.test(name)
+  );
+  const simpleTerminalArtifact = /\b(?:create|write|convert|generate|build|implement|run|fix|repair|debug|make)\b[\s\S]{0,120}\b(?:file|script|csv|parquet|json|txt|server|endpoint)\b/i.test(
+    scannedPrompt
+  );
+  const terminalComplexRepair = terminalToolSignal && /\b(?:multiple|several)\s+(?:scripts?|files?|components?)\b|\b(?:pipeline|dependencies)\b[\s\S]{0,100}\b(?:fail|issue|fix|repair|run|execute)\b|\b(?:identify|find|fix|repair)\s+(?:and\s+)?(?:fix\s+)?all\s+(?:the\s+)?issues\b/i.test(
+    scannedPrompt
+  );
+  const mentionedTerminalRuntimes = new Set(
+    (scannedPrompt.match(/\b(?:gcc|clang|rustc|javac|go\s+build|node|python)\b/gi) ?? []).map(
+      (name) => name.toLowerCase().replace(/\s+/g, " ")
+    )
+  );
+  const terminalCrossRuntimeArtifact = terminalToolSignal && (/\bpolyglot\b/i.test(scannedPrompt) || /\b(?:both|each)\b[\s\S]{0,120}\b(?:compilers?|runtimes?|toolchains?)\b/i.test(
+    scannedPrompt
+  ) || mentionedTerminalRuntimes.size >= 2 && /\b(?:compile|build|run|execute)\b/i.test(scannedPrompt));
+  const terminalFrameworkToNativeArtifact = terminalToolSignal && /\b(?:pytorch|tensorflow|jax|onnx|state[_ -]?dict|checkpoint|safetensors?)\b|\.(?:pth|pt|onnx)\b/i.test(
+    scannedPrompt
+  ) && /\b(?:pure|native|programmed|written|implemented?)\s+(?:in|using)\s+(?:c\+\+|c|rust|go)\b|\b(?:c\+\+|c|rust|go)\s+(?:program|binary|executable|cli|tool|implementation)\b/i.test(
+    scannedPrompt
+  ) && /\b(?:inference|model|weights?|tensor|export|convert|load)\b/i.test(scannedPrompt);
+  if (needsTools && (terminalComplexRepair || terminalCrossRuntimeArtifact || terminalFrameworkToNativeArtifact) && (agentRisk === "standard" || agentRisk === "high"))
+    agentRisk = "complex_high";
+  const complexTerminalOperation = /\b(?:git|ssh|nginx|https|certificate|authentication|credential|deploy|production|encrypt|gpg|shred|securely delete|decommission|benchmark|evaluate|embedding|chess|image|search the web|schema|statistical|statistics|aggregate|join|multiple inputs?)\b/i.test(
+    scannedPrompt
+  );
+  const terminalCredentialSignal = /\b(?:ssh|nginx|certificate|authentication|credentials?|passwords?|api keys?|deploy|production|encrypt|gpg|shred|securely delete|decommission)\b/i.test(
+    scannedPrompt
+  ) || /\b(?:access|auth|authentication|bearer|secret|api)\s+tokens?\b|\btokens?\s+(?:secret|credential|authentication)\b/i.test(
+    scannedPrompt
+  );
+  const terminalSafetySensitive = terminalToolSignal && (highStakes || terminalCredentialSignal);
+  const implicitTerminalCode = needsTools && terminalToolSignal && agentRisk === "standard" && !highStakes && !complexTerminalOperation && numberedSteps < 3 && prompt.length <= 1e3 && simpleTerminalArtifact;
+  const language = /[\u3400-\u9fff]/.test(scannedFullText) ? "zh" : "other";
+  const multipleChoiceSignals = (scannedPrompt.match(/(?:^|\n)\s*[A-D][.)]\s+/gim) ?? []).length;
+  const numericSignals = (scannedPrompt.match(/-?\d+(?:[.,]\d+)?/g) ?? []).length;
+  const compactMathProblem = !hasCode && prompt.length < 2500 && numericSignals >= 2 && (/[+×÷=%$€£¥]|\b(?:total|each|per|times|half|twice|percent|how many|how much|calculate)\b/i.test(
+    scannedPrompt
+  ) || /[?？]\s*$/.test(scannedPrompt.trim()) || numericSignals >= 3);
+  let taskType = "chat";
+  if (needsVision) taskType = "vision";
+  else if (estimatedInputTokens > 8e4) taskType = "long_context";
+  else if (needsTools && (hasCode || implicitTerminalCode)) taskType = "code_agent";
+  else if (needsTools && likelyParallelToolCalls && !complexMultiToolPlan)
+    taskType = "tool_agent_parallel";
+  else if (needsTools) taskType = "tool_agent";
+  else if (multipleChoiceSignals >= 3) taskType = "reasoning_mcq";
+  else if (compactMathProblem) taskType = "reasoning_math";
+  else if (/\b(?:bug|debug|error|failure|failing|regression|crash|修复|报错|错误|调试)\b/i.test(text))
+    taskType = "debug";
+  else if (hasCode || /\b(?:refactor|implement|patch|edit|rewrite|重构|实现|修改)\b/i.test(text))
+    taskType = "code_edit";
+  else if (needsStructuredOutput || /\b(?:extract|json|schema|csv|字段|提取)\b/i.test(text))
+    taskType = "extraction";
+  else if (/\b(?:prove|derive|theorem|formal|mathematical|reasoning|证明|推导|定理|数学)\b/i.test(text))
+    taskType = "reasoning";
+  return {
+    taskType,
+    estimatedInputTokens,
+    hasCode,
+    needsTools,
+    toolsAvailable,
+    needsVision,
+    needsStructuredOutput,
+    latencySensitive,
+    highStakes,
+    language,
+    likelyParallelToolCalls,
+    complexMultiToolPlan,
+    agentDomain,
+    deepWebResearch,
+    agentRisk,
+    terminalToolSignal,
+    terminalSafetySensitive,
+    implicitTerminalCode
+  };
+}
+function affinity(modelId, task, language = "other", agentDomain = "other", deepWebResearch = false, agentRisk = "standard", terminalToolSignal = false, terminalSafetySensitive = false) {
+  const id = modelId.toLowerCase();
+  const modelName = id.slice(id.indexOf("/") + 1);
+  const match = (values, score) => values.some((value) => modelName === value) ? score : 0;
+  const base = 0.68;
+  switch (task) {
+    case "code_agent":
+      if (terminalToolSignal && agentRisk === "complex_high") {
+        return Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["gpt-5.3-codex"], 0.87),
+          match(["gpt-5-mini"], 0.78),
+          match(["gemini-3.5-flash"], 0.76)
+        );
+      }
+      return Math.max(
+        base,
+        match(["gpt-5.3-codex"], 1),
+        match(["claude-sonnet-5"], 0.98),
+        match(["gpt-5-mini"], 0.96),
+        match(["gemini-3.5-flash"], 0.92),
+        match(["kimi-k3"], 0.9),
+        match(["deepseek-v4-pro", "glm-5.2"], 0.88)
+      );
+    case "tool_agent":
+      if (terminalToolSignal && agentRisk === "complex_high") {
+        return Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["gpt-5.3-codex"], 0.87),
+          match(["gpt-5-mini"], 0.78),
+          match(["gemini-3.5-flash"], 0.76)
+        );
+      }
+      if (terminalToolSignal && !terminalSafetySensitive) {
+        return Math.max(
+          base,
+          match(["gpt-5-mini"], 1),
+          match(["gpt-5.3-codex"], 0.98),
+          match(["claude-sonnet-5"], 0.9),
+          match(["gemini-3.5-flash"], 0.89)
+        );
+      }
+      if (terminalToolSignal && terminalSafetySensitive) {
+        return Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["claude-opus-4.8"], 0.9),
+          match(["gpt-5.3-codex"], 0.84)
+        );
+      }
+      if (agentDomain === "web_research") {
+        return deepWebResearch ? Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["gpt-5-mini"], 0.88),
+          match(["gemini-3.5-flash"], 0.84),
+          match(["claude-opus-5"], 0.8),
+          match(["claude-opus-4.8"], 0.78)
+        ) : Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["gpt-5-mini"], 0.88),
+          match(["gemini-3.5-flash"], 0.86),
+          match(["claude-opus-5"], 0.84),
+          match(["claude-opus-4.8"], 0.82)
+        );
+      }
+      if (agentDomain === "retail") {
+        if (agentRisk === "standard") {
+          return Math.max(
+            base,
+            match(["gpt-5-mini"], 1),
+            match(["claude-sonnet-5"], 0.88),
+            match(["gemini-3.5-flash"], 0.82),
+            match(["gpt-5.3-codex"], 0.81),
+            match(["kimi-k3"], 0.78),
+            match(["deepseek-v4-pro"], 0.76)
+          );
+        }
+        if (agentRisk === "policy_exception") {
+          return Math.max(
+            base,
+            match(["gpt-4.1"], 1),
+            match(["claude-sonnet-5"], 0.9),
+            match(["deepseek-v4-pro"], 0.82),
+            match(["gpt-5-mini"], 0.8),
+            match(["gpt-4o-mini"], 0.76)
+          );
+        }
+        if (agentRisk === "policy_exception_simple") {
+          return Math.max(
+            base,
+            match(["gpt-5-mini"], 1),
+            match(["gpt-4.1"], 0.86),
+            match(["deepseek-v4-pro"], 0.82),
+            match(["gpt-4o-mini"], 0.8)
+          );
+        }
+        return Math.max(
+          base,
+          match(["deepseek-v4-pro"], 1),
+          match(["claude-sonnet-5"], 0.88),
+          match(["gemini-3.5-flash"], 0.82),
+          match(["gpt-5.3-codex"], 0.81),
+          match(["kimi-k3"], 0.78),
+          match(["gpt-5-mini"], 0.76)
+        );
+      }
+      if (agentDomain === "airline") {
+        if (agentRisk === "complex_high") {
+          return Math.max(
+            base,
+            match(["claude-sonnet-5"], 1),
+            match(["gpt-5-mini"], 0.78),
+            match(["gemini-3.5-flash"], 0.76),
+            match(["deepseek-v4-pro"], 0.74)
+          );
+        }
+        return Math.max(
+          base,
+          match(["gpt-5-mini"], 1),
+          match(["claude-sonnet-5"], 0.9),
+          match(["gemini-3.5-flash"], 0.8),
+          match(["deepseek-v4-pro"], 0.76)
+        );
+      }
+      return Math.max(
+        base,
+        match(["claude-sonnet-5"], 1),
+        match(["gemini-3.5-flash"], 0.88),
+        match(["gpt-5.3-codex"], 0.87),
+        match(["gpt-5-mini"], 0.84),
+        match(["kimi-k3"], 0.85),
+        match(["deepseek-v4-pro"], 0.82)
+      );
+    case "tool_agent_parallel":
+      if (terminalToolSignal) {
+        return terminalSafetySensitive ? Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["claude-opus-4.8"], 0.9),
+          match(["gpt-5.3-codex"], 0.86)
+        ) : Math.max(
+          base,
+          match(["gpt-5-mini"], 1),
+          match(["gpt-5.3-codex"], 0.98),
+          match(["claude-sonnet-5"], 0.92),
+          match(["gemini-3.5-flash"], 0.88)
+        );
+      }
+      if (agentDomain === "web_research") {
+        return deepWebResearch ? Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["gpt-5-mini"], 0.88),
+          match(["gemini-3.5-flash"], 0.84),
+          match(["claude-opus-5"], 0.8),
+          match(["claude-opus-4.8"], 0.78)
+        ) : Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["gpt-5-mini"], 0.88),
+          match(["gemini-3.5-flash"], 0.86),
+          match(["claude-opus-5"], 0.84),
+          match(["claude-opus-4.8"], 0.82)
+        );
+      }
+      if (agentDomain === "retail") {
+        if (agentRisk === "policy_exception") {
+          return Math.max(
+            base,
+            match(["gpt-4.1"], 1),
+            match(["claude-sonnet-5"], 0.9),
+            match(["deepseek-v4-pro"], 0.82),
+            match(["gpt-5-mini"], 0.8),
+            match(["gpt-4o-mini"], 0.76)
+          );
+        }
+        if (agentRisk === "policy_exception_simple") {
+          return Math.max(
+            base,
+            match(["gpt-5-mini"], 1),
+            match(["gpt-4.1"], 0.86),
+            match(["deepseek-v4-pro"], 0.82),
+            match(["gpt-4o-mini"], 0.8)
+          );
+        }
+        return Math.max(
+          base,
+          match(["deepseek-v4-pro"], 1),
+          match(["claude-sonnet-5"], 0.88),
+          match(["claude-opus-4.8"], 0.84),
+          match(["gpt-5-mini"], 0.78),
+          match(["gemini-3.5-flash"], 0.76)
+        );
+      }
+      if (agentDomain === "airline") {
+        return agentRisk === "complex_high" ? Math.max(
+          base,
+          match(["claude-sonnet-5"], 1),
+          match(["gpt-5-mini"], 0.78),
+          match(["claude-opus-4.8"], 0.76),
+          match(["gemini-3.5-flash"], 0.74)
+        ) : Math.max(
+          base,
+          match(["gpt-5-mini"], 1),
+          match(["claude-sonnet-5"], 0.9),
+          match(["gemini-3.5-flash"], 0.8)
+        );
+      }
+      return Math.max(
+        base,
+        match(["claude-opus-4.8"], 1),
+        match(["claude-sonnet-5"], 0.84),
+        match(["grok-4.5"], 0.82),
+        match(["gemini-3.5-flash"], 0.8),
+        match(["deepseek-v4-pro"], 0.78)
+      );
+    case "code_edit":
+    case "debug":
+      return Math.max(
+        base,
+        match(["gpt-5.3-codex"], 1),
+        match(["claude-sonnet-4.6"], 0.94),
+        match(["glm-5.2"], 0.9),
+        match(["kimi-k2.7", "deepseek-v4-pro"], 0.86)
+      );
+    case "reasoning":
+      return Math.max(
+        base,
+        match(["claude-sonnet-5", "claude-sonnet-4.6"], 0.98),
+        match(["deepseek-v4-pro"], 0.95),
+        match(["grok-4.5"], 0.94),
+        match(["gemini-3.1-pro", "gemini-3.5-flash"], 0.92)
+      );
+    case "reasoning_mcq":
+      return Math.max(
+        base,
+        match(["gemini-3-flash-preview"], 1),
+        match(["gemini-3.5-flash"], 0.91),
+        match(["grok-4.5"], 0.9),
+        match(["claude-sonnet-5"], 0.88),
+        match(["deepseek-v4-pro"], 0.84)
+      );
+    case "reasoning_math":
+      return Math.max(
+        base,
+        match(["gemini-3.5-flash"], 1),
+        match(["grok-4.5"], 0.93),
+        match(["claude-sonnet-5", "deepseek-v4-pro", "kimi-k3"], 0.9),
+        match(["kimi-k2.7"], 0.84)
+      );
+    case "vision":
+      return Math.max(
+        base,
+        match(["gemini-3.1-pro"], 0.96),
+        match(["qwen3.7-max", "claude-sonnet-4.6", "kimi-k2.7", "grok-4.3"], 0.9)
+      );
+    case "long_context":
+      return Math.max(
+        base,
+        match(["gemini-3.1-pro"], 1),
+        match(["qwen3.7-max", "glm-5.2"], 0.89),
+        match(["gemini-3.5-flash"], 0.88),
+        match(["deepseek-v4-pro"], 0.85)
+      );
+    case "extraction": {
+      const kimiExtractionAffinity = language === "zh" ? 1 : 0.9;
+      return Math.max(
+        base,
+        match(["gemini-3.5-flash", "gemini-2.5-flash", "gpt-4o-mini"], 0.9),
+        match(["claude-sonnet-5", "claude-sonnet-4.6"], 0.9),
+        match(["kimi-k3", "kimi-k2.7"], kimiExtractionAffinity)
+      );
+    }
+    default:
+      return Math.max(
+        base,
+        match(["gemini-3.5-flash", "gemini-2.5-flash", "kimi-k3", "kimi-k2.7"], 0.86)
+      );
+  }
+}
+function evidenceCandidates(task) {
+  if (task === "code_agent") {
+    return [
+      "openai/gpt-5.3-codex",
+      "anthropic/claude-sonnet-5",
+      "openai/gpt-5-mini",
+      "google/gemini-3.5-flash",
+      "moonshot/kimi-k3",
+      "deepseek/deepseek-v4-pro"
+    ];
+  }
+  if (task === "tool_agent") {
+    return [
+      "anthropic/claude-sonnet-5",
+      "anthropic/claude-opus-5",
+      "openai/gpt-5-mini",
+      "openai/gpt-4.1",
+      "openai/gpt-4o-mini",
+      "google/gemini-3.5-flash",
+      "openai/gpt-5.3-codex",
+      "moonshot/kimi-k3",
+      "deepseek/deepseek-v4-pro"
+    ];
+  }
+  if (task === "tool_agent_parallel") {
+    return [
+      "anthropic/claude-opus-5",
+      "anthropic/claude-opus-4.8",
+      "anthropic/claude-sonnet-5",
+      "openai/gpt-5-mini",
+      "openai/gpt-4.1",
+      "openai/gpt-4o-mini",
+      "xai/grok-4.5",
+      "google/gemini-3.5-flash",
+      "deepseek/deepseek-v4-pro"
+    ];
+  }
+  if (task === "long_context") {
+    return [
+      "google/gemini-3.1-pro",
+      "deepseek/deepseek-v4-pro",
+      "qwen/qwen3.7-max",
+      "zai/glm-5.2",
+      "google/gemini-3.5-flash"
+    ];
+  }
+  if (task === "reasoning_mcq") {
+    return [
+      "google/gemini-3-flash-preview",
+      "google/gemini-3.5-flash",
+      "xai/grok-4.5",
+      "anthropic/claude-sonnet-5",
+      "deepseek/deepseek-v4-pro"
+    ];
+  }
+  if (task === "reasoning_math") {
+    return [
+      "google/gemini-3.5-flash",
+      "xai/grok-4.5",
+      "anthropic/claude-sonnet-5",
+      "deepseek/deepseek-v4-pro",
+      "moonshot/kimi-k3"
+    ];
+  }
+  return [];
+}
+function isEligible(modelId, features, maxOutputTokens, options) {
+  const model = options.modelCapabilities?.[modelId] ?? DEFAULT_MODEL_CAPABILITIES[modelId];
+  if (!model) return true;
+  if (features.needsTools && !model.supportsTools) return false;
+  if (features.needsVision && !model.supportsVision) return false;
+  if (features.needsStructuredOutput && !model.supportsTools) return false;
+  if (model.maxOutputTokens < maxOutputTokens) return false;
+  return model.contextWindow >= (features.estimatedInputTokens + maxOutputTokens) * 1.1;
+}
+function estimatedCost(modelId, options, inputTokens, outputTokens) {
+  const price = options.modelPricing.get(modelId);
+  if (!price) return Number.POSITIVE_INFINITY;
+  if (price.flatPrice !== void 0) return price.flatPrice;
+  return (inputTokens * price.inputPrice + outputTokens * price.outputPrice) / 1e6;
+}
+function profileScore(modelId, options, now) {
+  const profile = options.modelPerformance?.[modelId] ?? LIVE_MODEL_PROFILES[modelId] ?? HISTORICAL_MODEL_PROFILES[modelId];
+  if (!profile) return void 0;
+  const measuredAt = Date.parse(profile.measuredAt);
+  if (!Number.isFinite(measuredAt)) return void 0;
+  const ageDays = Math.max(0, (now.getTime() - measuredAt) / 864e5);
+  const sampleConfidence = profile.samples === void 0 ? 1 : Math.min(1, Math.max(0, profile.samples) / 10);
+  const freshness = Math.pow(0.5, ageDays / 30) * sampleConfidence;
+  const quality = profile.intelligenceIndex === void 0 ? void 0 : Math.min(1, profile.intelligenceIndex / 50);
+  const speed = Math.min(
+    1,
+    (2e3 / Math.max(500, profile.latencyMs) + profile.outputTokensPerSecond / 250) / 2
+  );
+  const tailSpeed = Math.min(1, 3e3 / Math.max(750, profile.p95LatencyMs ?? profile.latencyMs));
+  const reliability = Math.max(0, 1 - (profile.errorRate ?? 0));
+  return { quality, speed, tailSpeed, reliability, freshness };
+}
+var PortfolioStrategy = class {
+  name = "portfolio";
+  route(prompt, systemPrompt, maxOutputTokens, options) {
+    const features = classifyTask(prompt, systemPrompt, options);
+    const base = new RulesStrategy().route(prompt, systemPrompt, maxOutputTokens, {
+      ...options,
+      requiresTools: features.needsTools
+    });
+    const tierConfigs = base.tierConfigs;
+    if (!tierConfigs) return base;
+    const targetTier = (features.taskType === "reasoning_mcq" || features.taskType === "reasoning_math") && (base.tier === "SIMPLE" || base.tier === "MEDIUM") ? "REASONING" : base.tier;
+    const tierConfig = tierConfigs[targetTier];
+    const configuredCandidates = tierConfig ? getFallbackChain(targetTier, tierConfigs) : [];
+    const chain = [
+      .../* @__PURE__ */ new Set([...configuredCandidates, ...evidenceCandidates(features.taskType)])
+    ].filter((model2) => typeof model2 === "string" && model2.length > 0);
+    const eligible = chain.filter(
+      (model2) => isEligible(model2, features, maxOutputTokens, options)
+    );
+    const eligibleCandidates = eligible.length > 0 ? eligible : chain;
+    if (eligibleCandidates.length === 0) return base;
+    const profileName = options.routingProfile === "eco" ? "eco" : options.routingProfile === "premium" ? "premium" : "auto";
+    const portfolio = options.config.portfolio ?? DEFAULT_PORTFOLIO_WEIGHTS;
+    const getAffinity = (model2) => affinity(
+      model2,
+      features.taskType,
+      features.language,
+      features.agentDomain,
+      features.deepWebResearch,
+      features.agentRisk,
+      features.terminalToolSignal,
+      features.terminalSafetySensitive
+    );
+    const bestAffinity = Math.max(...eligibleCandidates.map(getAffinity));
+    const specificAffinity = eligibleCandidates.filter((model2) => getAffinity(model2) > 0.68);
+    const affinityPool = specificAffinity.length > 0 ? specificAffinity : [eligibleCandidates[0]];
+    const affinityFloorGap = features.terminalToolSignal ? Math.max(
+      portfolio.affinityFloorGap[profileName],
+      features.terminalSafetySensitive ? 0.15 : 0.12
+    ) : portfolio.affinityFloorGap[profileName];
+    const candidates = affinityPool.filter(
+      (model2) => getAffinity(model2) >= bestAffinity - affinityFloorGap
+    );
+    const costs = candidates.map(
+      (model2) => estimatedCost(model2, options, features.estimatedInputTokens, maxOutputTokens)
+    );
+    const finiteCosts = costs.filter(Number.isFinite);
+    const minCost = finiteCosts.length > 0 ? Math.min(...finiteCosts) : 0;
+    const maxCost = finiteCosts.length > 0 ? Math.max(...finiteCosts) : 1;
+    const now = options.now ?? /* @__PURE__ */ new Date();
+    const profileWeights = portfolio[profileName];
+    const rankedEntries = candidates.map((model2, index) => {
+      const cost = estimatedCost(model2, options, features.estimatedInputTokens, maxOutputTokens);
+      const costScore = Number.isFinite(cost) && maxCost > minCost ? 1 - (cost - minCost) / (maxCost - minCost) : 0.5;
+      const capabilityScore = isEligible(model2, features, maxOutputTokens, options) ? 1 : 0;
+      const profile = profileScore(model2, options, now);
+      const observedQuality = profile?.quality === void 0 ? getAffinity(model2) : getAffinity(model2) * (1 - profile.freshness) + profile.quality * profile.freshness;
+      const observedSpeed = profile ? profile.speed * profile.freshness : 0.5;
+      const observedTailSpeed = profile ? profile.tailSpeed * profile.freshness : 0.5;
+      const observedReliability = profile ? profile.reliability * profile.freshness + (1 - profile.freshness) : 1;
+      const legacyScore = 1 - index / Math.max(1, candidates.length - 1);
+      const qualityWeight = profileWeights.quality + (features.highStakes ? portfolio.highStakesBoost.quality : 0);
+      const speedScore = features.latencySensitive ? observedTailSpeed : observedSpeed;
+      const speedWeight = profileWeights.speed + (features.latencySensitive ? portfolio.latencySensitiveSpeedBoost : 0);
+      const reliabilityWeight = profileWeights.reliability + (features.highStakes ? portfolio.highStakesBoost.reliability : 0);
+      const score = observedQuality * qualityWeight + capabilityScore * profileWeights.capability + costScore * profileWeights.cost + speedScore * speedWeight + observedReliability * reliabilityWeight + legacyScore * profileWeights.legacy;
+      return {
+        model: model2,
+        score,
+        quality: observedQuality,
+        cost: costScore,
+        speed: speedScore,
+        reliability: observedReliability
+      };
+    }).sort((a, b) => b.score - a.score);
+    const scoredModels = rankedEntries.map((item) => item.model);
+    const webResearchFallbackOrder = [
+      "anthropic/claude-sonnet-5",
+      "openai/gpt-5-mini",
+      "google/gemini-3.5-flash",
+      "anthropic/claude-opus-5",
+      "anthropic/claude-opus-4.8",
+      "openai/gpt-5.3-codex"
+    ];
+    const ranked = features.agentDomain === "web_research" ? [
+      ...scoredModels,
+      ...webResearchFallbackOrder.filter(
+        (model2) => eligibleCandidates.includes(model2) && !scoredModels.includes(model2)
+      ),
+      ...eligibleCandidates.filter(
+        (model2) => !scoredModels.includes(model2) && !webResearchFallbackOrder.includes(model2)
+      )
+    ] : features.taskType === "tool_agent" || features.taskType === "tool_agent_parallel" && features.agentDomain !== "other" ? [
+      ...scoredModels,
+      ...eligibleCandidates.filter((model2) => !scoredModels.includes(model2))
+    ] : [
+      ...scoredModels,
+      ...eligibleCandidates.filter((model2) => !scoredModels.includes(model2))
+    ];
+    const model = ranked[0] ?? base.model;
+    const selectedTierConfigs = {
+      ...tierConfigs,
+      [targetTier]: { primary: model, fallback: ranked.slice(1) }
+    };
+    const decision = selectModel(
+      targetTier,
+      base.confidence,
+      "portfolio",
+      `${base.reasoning} | v3 task=${features.taskType} agentRisk=${features.agentRisk} deepWebResearch=${features.deepWebResearch} terminalCode=${features.implicitTerminalCode} terminalSafety=${features.terminalSafetySensitive} candidates=${ranked.length}`,
+      selectedTierConfigs,
+      options.modelPricing,
+      features.estimatedInputTokens,
+      maxOutputTokens,
+      options.routingProfile,
+      base.agenticScore
+    );
+    return {
+      ...decision,
+      tierConfigs: selectedTierConfigs,
+      profile: base.profile,
+      candidates: ranked,
+      candidateScores: rankedEntries.map(({ model: model2, score, quality, cost, speed, reliability }) => ({
+        model: model2,
+        score,
+        quality,
+        cost,
+        speed,
+        reliability
+      })),
+      taskType: features.taskType,
+      routerVersion: "v3-portfolio"
+    };
+  }
+};
+var DEFAULT_ROUTING_CONFIG = {
+  version: "3.4",
+  strategy: "portfolio",
+  portfolio: {
+    auto: {
+      quality: 0.47,
+      capability: 0.2,
+      cost: 0.18,
+      speed: 0.07,
+      reliability: 0.03,
+      legacy: 0.05
+    },
+    eco: {
+      quality: 0.36,
+      capability: 0.2,
+      cost: 0.28,
+      speed: 0.1,
+      reliability: 0.04,
+      legacy: 0.02
+    },
+    premium: {
+      quality: 0.58,
+      capability: 0.2,
+      cost: 0.08,
+      speed: 0.06,
+      reliability: 0.06,
+      legacy: 0.02
+    },
+    highStakesBoost: { quality: 0.08, reliability: 0.05 },
+    latencySensitiveSpeedBoost: 0.08,
+    affinityFloorGap: { auto: 0.1, eco: 0.22, premium: 0.05 }
+  },
+  classifier: {
+    llmModel: "google/gemini-2.5-flash",
+    llmMaxTokens: 10,
+    llmTemperature: 0,
+    promptTruncationChars: 500,
+    cacheTtlMs: 36e5
+    // 1 hour
+  },
+  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"
+    ],
+    // New dimension keyword lists (multilingual)
+    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
+  },
+  // Auto (balanced) tier configs - current default smart routing
+  // Benchmark-tuned 2026-03-16: balancing quality (retention) + latency
+  tiers: {
+    SIMPLE: {
+      primary: "google/gemini-2.5-flash",
+      // 1,238ms, IQ 20, 60% retention (best) — fast AND quality
+      fallback: [
+        "google/gemini-3-flash-preview",
+        // 1,398ms, IQ 46 — smarter fallback
+        "deepseek/deepseek-chat",
+        // V4 Flash chat ($0.20/$0.40, 1M ctx) — repriced 2026-04-24
+        "moonshot/kimi-k2.5",
+        // 1,646ms, IQ 47, strong quality
+        "google/gemini-3.1-flash-lite",
+        // $0.25/$1.50, 1M context — newest flash-lite
+        "google/gemini-2.5-flash-lite",
+        // 1,353ms, $0.10/$0.40
+        "openai/gpt-5.4-nano",
+        // $0.20/$1.25, 1M context
+        "xai/grok-4-fast-non-reasoning",
+        // 1,143ms, $0.20/$0.50 — fast fallback
+        "free/gpt-oss-120b"
+        // 1,252ms, FREE fallback (hidden from /v1/models but direct calls work)
+      ]
+    },
+    MEDIUM: {
+      primary: "moonshot/kimi-k2.7",
+      // $0.95/$4.00, 256K ctx, multi-modal + reasoning — Moonshot flagship; promoted from K2.6 (2026-06-14) after BlockRun added K2.7 + hid K2.6. Same price as K2.6.
+      fallback: [
+        "moonshot/kimi-k2.6",
+        // identical-cost in-family hot swap (K2.6 still routable)
+        "moonshot/kimi-k2.5",
+        // $0.60/$3.00 — graceful-degradation backstop
+        "google/gemini-3-flash-preview",
+        // 1,398ms, IQ 46 — nearly same IQ, faster + cheaper
+        "deepseek/deepseek-chat",
+        // 1,431ms, IQ 32, 41% retention
+        "google/gemini-2.5-flash",
+        // 1,238ms, 60% retention
+        "google/gemini-3.1-flash-lite",
+        // $0.25/$1.50, 1M context
+        "google/gemini-2.5-flash-lite",
+        // 1,353ms, $0.10/$0.40
+        "xai/grok-4-1-fast-non-reasoning",
+        // 1,244ms, fast fallback
+        "xai/grok-3-mini"
+        // 1,202ms, $0.30/$0.50
+      ]
+    },
+    COMPLEX: {
+      primary: "google/gemini-3.1-pro",
+      // 1,609ms, IQ 57 — fast flagship quality
+      fallback: [
+        "google/gemini-3-flash-preview",
+        // 1,398ms, IQ 46 — fast + smart
+        "xai/grok-4-0709",
+        // 1,348ms, IQ 41
+        "google/gemini-2.5-pro",
+        // 1,294ms
+        "anthropic/claude-sonnet-5",
+        // near-Opus quality at Sonnet cost, 1M ctx
+        "anthropic/claude-sonnet-4.6",
+        // 2,110ms, IQ 52 — quality fallback
+        "deepseek/deepseek-chat",
+        // 1,431ms, IQ 32
+        "google/gemini-2.5-flash",
+        // 1,238ms, IQ 20 — cheap last resort
+        "openai/gpt-5.6-terra",
+        // GPT-5.6 balanced tier — newest generation, stable (Sol excluded: #202)
+        "openai/gpt-5.5",
+        // Prior OpenAI flagship — 1M+ ctx, native agent + computer use; benchmark TBD
+        "openai/gpt-5.4"
+        // 6,213ms, IQ 57 — previous flagship, benchmarked
+      ]
+    },
+    REASONING: {
+      primary: "xai/grok-4-1-fast-reasoning",
+      // 1,454ms, $0.20/$0.50
+      fallback: [
+        "xai/grok-4-fast-reasoning",
+        // 1,298ms, $0.20/$0.50
+        "deepseek/deepseek-reasoner",
+        // V4 Flash thinking ($0.20/$0.40, 1M ctx)
+        "deepseek/deepseek-v4-pro",
+        // V4 Pro flagship ($0.50/$1.00 promo through 2026-05-31, list $2/$4) — strongest open-weight reasoner
+        "openai/o4-mini",
+        // 2,328ms ($1.10/$4.40)
+        "openai/o3"
+        // 2,862ms
+      ]
+    }
+  },
+  // Eco tier configs - absolute cheapest (blockrun/eco)
+  ecoTiers: {
+    SIMPLE: {
+      primary: "free/gpt-oss-120b",
+      // FREE! $0.00/$0.00 — heavy user default
+      fallback: [
+        "free/gpt-oss-20b",
+        // FREE — smaller, faster
+        "free/deepseek-v4-flash",
+        // FREE — 1M ctx; slow (~10 tok/s, 07-28 probe) but completes
+        // seed-oss-36b sat here as the free coder until it EOL'd 2026-08-03 (HTTP 410).
+        // gpt-oss-120b/20b already head this chain, so the rung is dropped, not retargeted.
+        "google/gemini-3.1-flash-lite",
+        // $0.25/$1.50 — newest flash-lite
+        "openai/gpt-5.4-nano",
+        // $0.20/$1.25 — fast nano
+        "google/gemini-2.5-flash-lite",
+        // $0.10/$0.40
+        "xai/grok-4-fast-non-reasoning"
+        // $0.20/$0.50
+      ]
+    },
+    MEDIUM: {
+      primary: "google/gemini-3.1-flash-lite",
+      // $0.25/$1.50 — newest flash-lite
+      fallback: [
+        "openai/gpt-5.4-nano",
+        // $0.20/$1.25
+        "google/gemini-2.5-flash-lite",
+        // $0.10/$0.40
+        "xai/grok-4-fast-non-reasoning",
+        "google/gemini-2.5-flash"
+      ]
+    },
+    COMPLEX: {
+      primary: "google/gemini-3.1-flash-lite",
+      // $0.25/$1.50
+      fallback: [
+        "google/gemini-2.5-flash-lite",
+        "xai/grok-4-0709",
+        "google/gemini-2.5-flash",
+        "deepseek/deepseek-chat"
+      ]
+    },
+    REASONING: {
+      primary: "xai/grok-4-1-fast-reasoning",
+      // $0.20/$0.50
+      fallback: [
+        "xai/grok-4-fast-reasoning",
+        "deepseek/deepseek-reasoner",
+        // V4 Flash thinking — $0.20/$0.40
+        "deepseek/deepseek-v4-pro"
+        // V4 Pro flagship — $0.50/$1.00 promo, post-promo $2/$4
+      ]
+    }
+  },
+  // Premium tier configs - best quality (blockrun/premium)
+  // codex=complex coding, kimi=simple coding, sonnet=reasoning/instructions, opus=architecture/PM/audits
+  premiumTiers: {
+    SIMPLE: {
+      primary: "moonshot/kimi-k2.7",
+      // $0.95/$4.00 - Moonshot flagship (256K ctx, multi-modal + reasoning); promoted from K2.6 (2026-06-14), same price
+      fallback: [
+        "moonshot/kimi-k2.6",
+        // identical-cost in-family hot swap (K2.6 still routable)
+        "moonshot/kimi-k2.5",
+        // $0.60/$3.00 - proven reliable backstop when Moonshot direct API falters
+        "google/gemini-2.5-flash",
+        // 60% retention, fast growth
+        "anthropic/claude-haiku-4.5",
+        "google/gemini-2.5-flash-lite",
+        "deepseek/deepseek-chat"
+      ]
+    },
+    MEDIUM: {
+      primary: "openai/gpt-5.3-codex",
+      // $1.75/$14 - 400K context, 128K output, replaces 5.2
+      fallback: [
+        "moonshot/kimi-k2.7",
+        // Moonshot flagship
+        "moonshot/kimi-k2.6",
+        "moonshot/kimi-k2.5",
+        "google/gemini-2.5-flash",
+        // 60% retention, good coding capability
+        "google/gemini-2.5-pro",
+        "xai/grok-4-0709",
+        "anthropic/claude-sonnet-5",
+        "anthropic/claude-sonnet-4.6"
+      ]
+    },
+    COMPLEX: {
+      // fable-5 was promoted here 2026-06-11, force-reverted 2026-06-13 when Anthropic
+      // withdrew the offer, and restored 2026-07-14 now that BlockRun has relisted it.
+      primary: "anthropic/claude-fable-5",
+      // Best quality for complex tasks — Mythos-class flagship above Opus ($10/$50, 1M ctx, always-on thinking)
+      // Fallback chain de-Gemini'd 2026-04-22: when Anthropic 503s, Gemini is
+      // also prone to "high demand" 503s (correlated failure — everyone falls
+      // back to Google at the same time). Prefer xAI Grok → Moonshot → OpenAI
+      // flagship → DeepSeek → NVIDIA free instead.
+      fallback: [
+        "anthropic/claude-opus-5",
+        // in-family hot swap first (half the price, 1M ctx + adaptive thinking)
+        "anthropic/claude-opus-4.8",
+        // in-family hot swap (identical cost to 5)
+        "anthropic/claude-opus-4.7",
+        // in-family hot swap (identical cost to 4.8)
+        "anthropic/claude-opus-4.6",
+        // in-family hot swap
+        "anthropic/claude-sonnet-5",
+        // Sonnet-tier drop-down, near-Opus quality
+        "anthropic/claude-sonnet-4.6",
+        "xai/grok-4.5",
+        // xAI flagship — 503-resistant, direct-xAI SKU (added 2026-07-14)
+        "xai/grok-4-0709",
+        // 503-resistant flagship
+        "moonshot/kimi-k2.7",
+        // Moonshot flagship, independent infra
+        "moonshot/kimi-k2.6",
+        "moonshot/kimi-k2.5",
+        "openai/gpt-5.6-terra",
+        // GPT-5.6 balanced tier — newest generation, stable (Sol excluded: #202)
+        "openai/gpt-5.5",
+        // Prior OpenAI flagship — 1M+ ctx, native agent + computer use
+        "openai/gpt-5.4",
+        // Previous flagship (slow but stable, benchmarked at 6,213ms)
+        "openai/gpt-5.3-codex",
+        "deepseek/deepseek-chat",
+        // Cheap, reliable
+        "free/gpt-oss-120b"
+        // NVIDIA free ultimate backstop (was seed-oss-36b; EOL'd 2026-08-03)
+      ]
+    },
+    REASONING: {
+      primary: "anthropic/claude-sonnet-4.6",
+      // 2,110ms, $3/$15 - best for reasoning/instructions
+      fallback: [
+        "anthropic/claude-sonnet-5",
+        // in-family hot swap — same cost, adaptive thinking, 1M ctx
+        "anthropic/claude-opus-5",
+        // Newest flagship Opus w/ adaptive thinking
+        "anthropic/claude-opus-4.8",
+        // Prior flagship Opus — identical cost to 5
+        "anthropic/claude-opus-4.7",
+        // Flagship Opus w/ adaptive thinking
+        "anthropic/claude-opus-4.6",
+        // 2,139ms
+        "xai/grok-4-1-fast-reasoning",
+        // 1,454ms, cheap fast reasoning
+        "openai/o4-mini",
+        // 2,328ms ($1.10/$4.40)
+        "openai/o3"
+        // 2,862ms
+      ]
+    }
+  },
+  // Agentic tier configs - models that excel at multi-step autonomous tasks
+  agenticTiers: {
+    SIMPLE: {
+      primary: "openai/gpt-4o-mini",
+      // $0.15/$0.60 - best tool compliance at lowest cost
+      fallback: [
+        "moonshot/kimi-k2.5",
+        // 1,646ms, strong tool use quality
+        "anthropic/claude-haiku-4.5",
+        // 2,305ms
+        "xai/grok-4-1-fast-non-reasoning"
+        // 1,244ms, fast fallback
+      ]
+    },
+    MEDIUM: {
+      primary: "moonshot/kimi-k2.7",
+      // $0.95/$4.00 — Moonshot flagship, strong tool use; promoted from K2.6 (2026-06-14) after BlockRun added K2.7 + hid K2.6. Same price.
+      fallback: [
+        "moonshot/kimi-k2.6",
+        // identical-cost in-family hot swap (K2.6 still routable)
+        "moonshot/kimi-k2.5",
+        // $0.60/$3.00 — graceful-degradation backstop
+        "xai/grok-4-1-fast-non-reasoning",
+        // 1,244ms, fast fallback
+        "openai/gpt-4o-mini",
+        // 2,764ms, reliable tool calling
+        "anthropic/claude-haiku-4.5",
+        // 2,305ms
+        "deepseek/deepseek-chat"
+        // 1,431ms
+      ]
+    },
+    COMPLEX: {
+      primary: "anthropic/claude-sonnet-4.6",
+      // 2,110ms — best agentic quality
+      // Fallback chain de-Gemini'd 2026-04-22: Gemini's "high demand" 503s
+      // correlate with Anthropic outages (everyone falls back together).
+      // Prefer 503-resistant providers first.
+      fallback: [
+        "anthropic/claude-sonnet-5",
+        // in-family hot swap — same cost, near-Opus agentic quality
+        "anthropic/claude-opus-5",
+        // Newest flagship Opus — in-family hot swap
+        "anthropic/claude-opus-4.8",
+        // Prior flagship Opus — identical cost to 5
+        "anthropic/claude-opus-4.7",
+        // Flagship Opus — in-family hot swap
+        "anthropic/claude-opus-4.6",
+        // 2,139ms
+        "xai/grok-4-0709",
+        // 1,348ms — strong tool use, independent infra
+        "moonshot/kimi-k2.7",
+        // Moonshot flagship — strong tool use, independent infra
+        "moonshot/kimi-k2.5",
+        // cost-stability backstop
+        "openai/gpt-5.6-terra",
+        // GPT-5.6 balanced tier — newest generation, stable (Sol excluded: #202)
+        "openai/gpt-5.5",
+        // Prior flagship — native agent + computer use (exactly the agentic-tier use case)
+        "openai/gpt-5.4",
+        // Previous flagship — 6,213ms, reliable
+        "deepseek/deepseek-chat",
+        // 1,431ms — cheap, reliable
+        "free/gpt-oss-120b"
+        // NVIDIA free ultimate backstop (was seed-oss-36b; EOL'd 2026-08-03)
+      ]
+    },
+    REASONING: {
+      primary: "anthropic/claude-sonnet-4.6",
+      // 2,110ms — strong tool use + reasoning
+      fallback: [
+        "anthropic/claude-sonnet-5",
+        // in-family hot swap — same cost, adaptive thinking
+        "anthropic/claude-opus-5",
+        // Newest flagship Opus w/ adaptive thinking
+        "anthropic/claude-opus-4.8",
+        // Prior flagship Opus — identical cost to 5
+        "anthropic/claude-opus-4.7",
+        // Flagship Opus w/ adaptive thinking
+        "anthropic/claude-opus-4.6",
+        // 2,139ms
+        "xai/grok-4-1-fast-reasoning",
+        // 1,454ms
+        "deepseek/deepseek-reasoner"
+        // 1,454ms
+      ]
+    }
+  },
+  // Time-windowed promotions — auto-applied when active, ignored when expired
+  promotions: [
+    {
+      name: "GLM-5.1 Launch Promo ($0.001 flat)",
+      startDate: "2026-04-01",
+      endDate: "2026-05-01",
+      tierOverrides: {
+        SIMPLE: { primary: "zai/glm-5.1" }
+      },
+      profiles: ["auto"]
+      // only auto profile — eco stays free, premium stays premium
+    }
+  ],
+  overrides: {
+    maxTokensForceComplex: 1e5,
+    structuredOutputMinTier: "MEDIUM",
+    ambiguousDefaultTier: "MEDIUM"
+    // agenticMode left undefined → auto-detect via tools/agenticScore.
+    // Set to `true` to force agentic tiers; `false` to disable them entirely.
+  }
+};
+registerStrategy(new PortfolioStrategy());
+function route(prompt, systemPrompt, maxOutputTokens, options) {
+  const strategy = getStrategy(options.config.strategy ?? "portfolio");
+  return strategy.route(prompt, systemPrompt, maxOutputTokens, options);
+}
+
+// src/router-adapter.ts
+var AUTO_ROUTING_PROFILES = {
+  "blockrun/auto": "auto",
+  "blockrun/eco": "eco",
+  "blockrun/premium": "premium"
+};
+var BASE_MINIMUM_PAYMENT_USD = 2e-3;
+var SOLANA_MINIMUM_PAYMENT_USD = 1e-3;
+function isTransientError(err) {
+  if (err instanceof PaymentError) return false;
+  if (err instanceof APIError) {
+    return [429, 502, 503, 504, 522, 524].includes(err.statusCode);
+  }
+  if (err instanceof Error) {
+    if (err.name === "AbortError") return true;
+    if (err.name === "TypeError" && /fetch|network/i.test(err.message)) return true;
+  }
+  return false;
+}
+function errSummary(err) {
+  if (err instanceof APIError) return `APIError ${err.statusCode}`;
+  if (err instanceof Error) {
+    const msg = err.message.length > 80 ? err.message.slice(0, 80) : err.message;
+    return `${err.name}: ${msg}`;
+  }
+  return String(err).slice(0, 100);
+}
+function routingProfileForModel(model) {
+  return AUTO_ROUTING_PROFILES[model.toLowerCase()];
+}
+function routingText(messages) {
+  const systemPrompt = messages.filter((message) => message.role === "system" && typeof message.content === "string").map((message) => message.content).join("\n") || void 0;
+  const lastUser = [...messages].reverse().find((message) => message.role === "user" && typeof message.content === "string");
+  const lastText = [...messages].reverse().find((message) => typeof message.content === "string");
+  let conversationChars = 0;
+  let hasVision = false;
+  for (const message of messages) {
+    if (typeof message.content === "string") {
+      conversationChars += message.content.length;
+    } else if (Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part?.type === "image_url" || part?.type === "image") hasVision = true;
+        if (typeof part?.text === "string") conversationChars += part.text.length;
+      }
+    }
+  }
+  return {
+    prompt: lastUser?.content ?? lastText?.content ?? "",
+    systemPrompt,
+    conversationChars,
+    hasVision
+  };
+}
+function routeWithCatalog(prompt, systemPrompt, maxOutputTokens, modelPricing, options = {}) {
+  const tools = options.tools ?? [];
+  const requiresTools = options.toolChoice === "none" ? false : options.toolChoice === "required" || typeof options.toolChoice === "object" ? true : void 0;
+  const decision = route(prompt, systemPrompt, maxOutputTokens, {
+    config: DEFAULT_ROUTING_CONFIG,
+    modelPricing,
+    routingProfile: options.routingProfile,
+    hasTools: tools.length > 0,
+    toolCount: tools.length,
+    toolNames: tools.map((tool) => tool.function.name),
+    requiresTools,
+    hasVision: options.hasVision,
+    requiresStructuredOutput: options.requiresStructuredOutput
+  });
+  const tierConfigs = decision.tierConfigs ?? DEFAULT_ROUTING_CONFIG.tiers;
+  const ranked = decision.candidates?.length ? decision.candidates : [decision.model, ...getFallbackChain(decision.tier, tierConfigs)];
+  const callable = [];
+  for (const id of ranked) {
+    const resolved = !id.startsWith("free/") ? id : modelPricing.has(`nvidia/${id.slice(5)}`) ? `nvidia/${id.slice(5)}` : null;
+    if (resolved && !callable.includes(resolved)) callable.push(resolved);
+  }
+  const estimatedInputTokens = Math.ceil(
+    Math.max(options.conversationChars ?? 0, `${systemPrompt ?? ""} ${prompt}`.length) / 4
+  );
+  const fitting = filterCandidatesByCapacity(
+    callable,
+    estimatedInputTokens,
+    maxOutputTokens,
+    (id) => {
+      const caps = DEFAULT_MODEL_CAPABILITIES[id];
+      return caps ? { contextWindow: caps.contextWindow, maxOutput: caps.maxOutputTokens } : void 0;
+    }
+  );
+  const availableCandidates = fitting.length > 0 ? fitting : callable;
+  const model = availableCandidates[0] ?? decision.model;
+  const costs = calculateModelCost(
+    model,
+    modelPricing,
+    estimatedInputTokens,
+    maxOutputTokens,
+    options.routingProfile
+  );
+  const minimumPaymentUsd = options.minimumPaymentUsd ?? SOLANA_MINIMUM_PAYMENT_USD;
+  const entry = modelPricing.get(model);
+  const isFree = entry !== void 0 && entry.inputPrice === 0 && entry.outputPrice === 0 && !entry.flatPrice;
+  const costEstimate = isFree ? 0 : Math.max(costs.costEstimate, minimumPaymentUsd);
+  const savings = options.routingProfile === "premium" || costs.baselineCost <= 0 ? 0 : entry !== void 0 ? Math.max(0, (costs.baselineCost - costEstimate) / costs.baselineCost) : decision.savings;
+  return {
+    ...decision,
+    ...costs,
+    costEstimate,
+    savings,
+    model,
+    reasoning: model === decision.model ? decision.reasoning : `${decision.reasoning} | catalog fallback: ${model}`,
+    candidates: availableCandidates,
+    candidateScores: decision.candidateScores?.filter(
+      (score) => availableCandidates.includes(score.model)
+    ),
+    fallbacks: availableCandidates.slice(1)
+  };
+}
+
 // src/x402.ts
 var import_accounts = require("viem/accounts");
 
@@ -608,29 +3964,10 @@ function getCostSummary() {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.11.0";
+var SDK_VERSION = "3.13.0";
 var USER_AGENT = `blockrun-ts/${SDK_VERSION}`;
 
 // src/client.ts
-function isTransientError(err) {
-  if (err instanceof PaymentError) return false;
-  if (err instanceof APIError) {
-    return [429, 502, 503, 504, 522, 524].includes(err.statusCode);
-  }
-  if (err instanceof Error) {
-    if (err.name === "AbortError") return true;
-    if (err.name === "TypeError" && /fetch|network/i.test(err.message)) return true;
-  }
-  return false;
-}
-function errSummary(err) {
-  if (err instanceof APIError) return `APIError ${err.statusCode}`;
-  if (err instanceof Error) {
-    const msg = err.message.length > 80 ? err.message.slice(0, 80) : err.message;
-    return `${err.name}: ${msg}`;
-  }
-  return String(err).slice(0, 100);
-}
 function mapRawToModel(m) {
   return {
     id: m.id,
@@ -685,7 +4022,7 @@ var LLMClient = class _LLMClient {
   modelPricingPromise = null;
   // Pre-auth cache: avoids the 402 round-trip on repeat requests to the same model.
   // Key = "endpoint:model", value = cached payment header + timestamp.
-  // TTL: 1 hour (mirrors ClawRouter's payment-preauth.ts approach).
+  // TTL: 1 hour — pre-auth quotes are stable server-side on that horizon.
   preAuthCache = /* @__PURE__ */ new Map();
   static PRE_AUTH_TTL_MS = 36e5;
   /**
@@ -739,11 +4076,35 @@ var LLMClient = class _LLMClient {
     });
     return result.choices[0].message.content || "";
   }
+  async makeRoutingDecision(prompt, systemPrompt, maxOutputTokens, options = {}) {
+    return routeWithCatalog(
+      prompt,
+      systemPrompt,
+      maxOutputTokens,
+      await this.getModelPricing(),
+      { ...options, minimumPaymentUsd: BASE_MINIMUM_PAYMENT_USD }
+    );
+  }
+  /**
+   * Inspect a local routing decision without making or paying for a model call.
+   * The first invocation may fetch the public model catalog for current prices.
+   */
+  async route(prompt, options) {
+    return this.makeRoutingDecision(
+      prompt,
+      options?.system,
+      options?.maxOutputTokens ?? options?.maxTokens ?? DEFAULT_MAX_TOKENS,
+      {
+        routingProfile: options?.routingProfile,
+        requiresStructuredOutput: options?.responseFormat !== void 0
+      }
+    );
+  }
   /**
    * Smart chat with automatic model routing.
    *
-   * Uses ClawRouter's deterministic portfolio router (Router v3.4, the Auto
-   * default since v0.12.242): it classifies the task shape locally (<1ms, no
+   * Uses BlockRun's product-neutral Router Core portfolio strategy: it
+   * classifies the task shape locally (no
    * extra model call), enforces capability constraints as hard filters, and
    * ranks an ordered candidate portfolio — the cheapest model that can handle
    * the request wins, and the rest become the transient-error fallback chain.
@@ -771,33 +4132,8 @@ var LLMClient = class _LLMClient {
    * ```
    */
   async smartChat(prompt, options) {
-    const modelPricing = await this.getModelPricing();
-    const maxOutputTokens = options?.maxOutputTokens || options?.maxTokens || 1024;
-    let route;
-    let DEFAULT_ROUTING_CONFIG;
-    let getFallbackChain;
-    try {
-      ({ route, DEFAULT_ROUTING_CONFIG, getFallbackChain } = await import("@blockrun/clawrouter"));
-    } catch (err) {
-      throw new Error(
-        `smartChat() requires the optional '@blockrun/clawrouter' routing engine, which is not installed or failed to load. Install it, or call chat() with an explicit model instead. Cause: ${err.message}`
-      );
-    }
-    const decision = route(prompt, options?.system, maxOutputTokens, {
-      config: DEFAULT_ROUTING_CONFIG,
-      modelPricing,
-      routingProfile: options?.routingProfile
-    });
-    const tierConfigs = decision.tierConfigs ?? DEFAULT_ROUTING_CONFIG.tiers;
-    const ranked = decision.candidates?.length ? decision.candidates : [decision.model, ...getFallbackChain(decision.tier, tierConfigs)];
-    const callable = [];
-    for (const id of ranked) {
-      const resolved = !id.startsWith("free/") ? id : modelPricing.has(`nvidia/${id.slice(5)}`) ? `nvidia/${id.slice(5)}` : null;
-      if (resolved && !callable.includes(resolved)) callable.push(resolved);
-    }
-    const primary = callable[0] ?? decision.model;
-    const fallbacks = callable.slice(1);
-    const response = await this.chat(primary, prompt, {
+    const decision = await this.route(prompt, options);
+    const response = await this.chat(decision.model, prompt, {
       system: options?.system,
       maxTokens: options?.maxTokens,
       temperature: options?.temperature,
@@ -806,14 +4142,47 @@ var LLMClient = class _LLMClient {
       searchParameters: options?.searchParameters,
       responseFormat: options?.responseFormat,
       stop: options?.stop,
-      fallbackModels: fallbacks
+      // An explicit caller-supplied chain wins over the routed one.
+      fallbackModels: options?.fallbackModels ?? decision.fallbacks
     });
     return {
       response,
-      model: primary,
-      routing: { ...decision, model: primary, fallbacks }
+      model: decision.model,
+      routing: decision
     };
   }
+  /** Route a full Agent/tool conversation while preserving its complete response. */
+  async smartChatCompletion(messages, options = {}) {
+    const { prompt, systemPrompt, conversationChars, hasVision } = routingText(messages);
+    const decision = await this.makeRoutingDecision(
+      prompt,
+      systemPrompt,
+      options.maxOutputTokens ?? options.maxTokens ?? DEFAULT_MAX_TOKENS,
+      {
+        routingProfile: options.routingProfile,
+        requiresStructuredOutput: options.responseFormat !== void 0,
+        tools: options.tools,
+        toolChoice: options.toolChoice,
+        conversationChars,
+        hasVision
+      }
+    );
+    const response = await this.chatCompletion(decision.model, messages, {
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP,
+      search: options.search,
+      searchParameters: options.searchParameters,
+      tools: options.tools,
+      toolChoice: options.toolChoice,
+      responseFormat: options.responseFormat,
+      stop: options.stop,
+      // An explicit caller-supplied chain wins over the routed one.
+      fallbackModels: options.fallbackModels ?? decision.fallbacks
+    });
+    response.routing = decision;
+    return { response, model: decision.model, routing: decision };
+  }
   /**
    * Get model pricing map (cached).
    * Fetches from API on first call, then returns cached result.
@@ -833,31 +4202,18 @@ var LLMClient = class _LLMClient {
       this.modelPricingPromise = null;
     }
   }
-  /**
-   * Fetch model pricing from API.
-   *
-   * For flat-billed models (e.g. ZAI GLM-5 family at $0.001/call) the
-   * router still expects per-token rates, so we synthesise an equivalent
-   * per-token price assuming ~1500 total tokens per call. Without this,
-   * flat models would resolve to inputPrice=outputPrice=0 and the router
-   * would treat them as free, biasing routing decisions and reporting
-   * inflated savings %.
-   */
+  /** Fetch model pricing from the live catalog, preserving flat billing. */
   async fetchModelPricing() {
     const models = await this.listModels();
     const pricing = /* @__PURE__ */ new Map();
     for (const model of models) {
-      if (model.billingMode === "flat" && model.flatPrice && model.flatPrice > 0) {
-        const perDirection = model.flatPrice * 1e6 / 1500 / 2;
-        pricing.set(model.id, {
-          inputPrice: perDirection,
-          outputPrice: perDirection
-        });
+      if (model.available === false) continue;
+      const inputPrice = Number.isFinite(model.inputPrice) ? model.inputPrice : 0;
+      const outputPrice = Number.isFinite(model.outputPrice) ? model.outputPrice : 0;
+      if (model.billingMode === "flat" && Number.isFinite(model.flatPrice) && model.flatPrice > 0) {
+        pricing.set(model.id, { inputPrice, outputPrice, flatPrice: model.flatPrice });
       } else {
-        pricing.set(model.id, {
-          inputPrice: model.inputPrice,
-          outputPrice: model.outputPrice
-        });
+        pricing.set(model.id, { inputPrice, outputPrice });
       }
     }
     return pricing;
@@ -877,6 +4233,13 @@ var LLMClient = class _LLMClient {
    * @returns ChatResponse object with choices and usage
    */
   async chatCompletion(model, messages, options) {
+    const routingProfile = routingProfileForModel(model);
+    if (routingProfile) {
+      return (await this.smartChatCompletion(messages, {
+        ...options,
+        routingProfile
+      })).response;
+    }
     validateMaxTokens(options?.maxTokens);
     const buildBody = (m) => {
       const body = {
@@ -1149,9 +4512,28 @@ var LLMClient = class _LLMClient {
    */
   async chatCompletionStream(model, messages, options) {
     validateMaxTokens(options?.maxTokens);
+    let requestModel = model;
+    const routingProfile = routingProfileForModel(model);
+    if (routingProfile) {
+      const { prompt, systemPrompt, conversationChars, hasVision } = routingText(messages);
+      const decision = await this.makeRoutingDecision(
+        prompt,
+        systemPrompt,
+        options?.maxTokens ?? DEFAULT_MAX_TOKENS,
+        {
+          routingProfile,
+          requiresStructuredOutput: options?.responseFormat !== void 0,
+          tools: options?.tools,
+          toolChoice: options?.toolChoice,
+          conversationChars,
+          hasVision
+        }
+      );
+      requestModel = decision.model;
+    }
     const url = `${this.apiUrl}/v1/chat/completions`;
     const body = {
-      model,
+      model: requestModel,
       messages,
       max_tokens: options?.maxTokens ?? DEFAULT_MAX_TOKENS,
       stream: true
@@ -1162,7 +4544,7 @@ var LLMClient = class _LLMClient {
     if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
     if (options?.responseFormat !== void 0) body.response_format = options.responseFormat;
     if (options?.stop !== void 0) body.stop = options.stop;
-    const cacheKey2 = `/v1/chat/completions:${model}`;
+    const cacheKey2 = `/v1/chat/completions:${requestModel}`;
     const cached = this.preAuthCache.get(cacheKey2);
     const now = Date.now();
     if (cached && now - cached.cachedAt < _LLMClient.PRE_AUTH_TTL_MS) {
@@ -1672,8 +5054,8 @@ var LLMClient = class _LLMClient {
    * @example
    * const results = await client.exa("search", { query: "latest AI research", numResults: 5 });
    */
-  async exa(path5, body) {
-    return this.requestWithPaymentRaw(`/v1/exa/${path5}`, body);
+  async exa(path6, body) {
+    return this.requestWithPaymentRaw(`/v1/exa/${path6}`, body);
   }
   /**
    * Neural web search via Exa. Returns semantically relevant URLs and metadata.
@@ -1772,7 +5154,13 @@ var LLMClient = class _LLMClient {
    */
   async getBalance() {
     const usdcContract = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-    const rpcs = ["https://base.publicnode.com", "https://mainnet.base.org", "https://base.meowrpc.com"];
+    const configuredRpc = typeof process !== "undefined" && process.env ? process.env.BASE_RPC_URL : void 0;
+    const rpcs = [
+      configuredRpc,
+      "https://base-rpc.publicnode.com",
+      "https://mainnet.base.org",
+      "https://base.llamarpc.com"
+    ].filter((rpc) => Boolean(rpc));
     const selector = "0x70a08231";
     const paddedAddress = this.account.address.slice(2).toLowerCase().padStart(64, "0");
     const data = selector + paddedAddress;
@@ -1790,7 +5178,9 @@ var LLMClient = class _LLMClient {
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify(payload)
         });
+        if (!response.ok) throw new Error(`Base RPC returned ${response.status}`);
         const result = await response.json();
+        if (!result.result || result.error) throw new Error("Base RPC returned no balance result");
         const balanceRaw = parseInt(result.result || "0x0", 16);
         return balanceRaw / 1e6;
       } catch (e) {
@@ -1813,8 +5203,8 @@ var LLMClient = class _LLMClient {
    * const market = await client.pm("kalshi/markets/KXBTC-25MAR14");
    * const results = await client.pm("polymarket/search", { q: "bitcoin" });
    */
-  async pm(path5, params) {
-    return this.getWithPaymentRaw(`/v1/pm/${path5}`, params);
+  async pm(path6, params) {
+    return this.getWithPaymentRaw(`/v1/pm/${path6}`, params);
   }
   /**
    * Structured query for Predexon prediction market data (POST endpoints).
@@ -1830,8 +5220,8 @@ var LLMClient = class _LLMClient {
    *   addresses: ["0xabc...", "0xdef..."],
    * });
    */
-  async pmQuery(path5, query) {
-    return this.requestWithPaymentRaw(`/v1/pm/${path5}`, query);
+  async pmQuery(path6, query) {
+    return this.requestWithPaymentRaw(`/v1/pm/${path6}`, query);
   }
   // ── PM convenience helpers (Predexon v2) ─────────────────────────────────
   // Thin wrappers over pm() / pmQuery() for the most common v2 endpoints.
@@ -1919,8 +5309,8 @@ var LLMClient = class _LLMClient {
    *               "prices/coingecko:bitcoin,base:0x..."
    * @param params - Query parameters passed through to DefiLlama
    */
-  async defi(path5, params) {
-    return this.getWithPaymentRaw(`/v1/defillama/${path5}`, params);
+  async defi(path6, params) {
+    return this.getWithPaymentRaw(`/v1/defillama/${path6}`, params);
   }
   /** All DeFi protocols with TVL ($0.005/call). */
   async defiProtocols() {
@@ -1956,9 +5346,9 @@ var LLMClient = class _LLMClient {
    * @param params - Query params (chainId, sellToken, buyToken, sellAmount, taker, ...)
    * @param body - JSON body — pass to switch to POST (gasless/submit only)
    */
-  async dex(path5, params, body) {
-    if (body) return this.requestWithPaymentRaw(`/v1/zerox/${path5}`, body);
-    return this.getWithPaymentRaw(`/v1/zerox/${path5}`, params);
+  async dex(path6, params, body) {
+    if (body) return this.requestWithPaymentRaw(`/v1/zerox/${path6}`, body);
+    return this.getWithPaymentRaw(`/v1/zerox/${path6}`, params);
   }
   /** Indicative Permit2 swap price — no commitment (free). */
   async dexPrice(params) {
@@ -2002,8 +5392,8 @@ var LLMClient = class _LLMClient {
    *               "sandbox/status", "sandbox/terminate" ($0.001 each)
    * @param body - JSON body for the endpoint
    */
-  async modal(path5, body) {
-    return this.requestWithPaymentRaw(`/v1/modal/${path5}`, body ?? {});
+  async modal(path6, body) {
+    return this.requestWithPaymentRaw(`/v1/modal/${path6}`, body ?? {});
   }
   /** Create a sandboxed compute environment ($0.01 CPU / $0.05 GPU). */
   async modalSandboxCreate(body) {
@@ -3365,8 +6755,8 @@ var PhoneClient = class {
     return data;
   }
   // ─── Internals ─────────────────────────────────────────────────────────
-  async request(path5, body) {
-    const url = `${this.apiUrl}/v1/phone/${path5}`;
+  async request(path6, body) {
+    const url = `${this.apiUrl}/v1/phone/${path6}`;
     const response = await this.fetchWithTimeout(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -3773,10 +7163,10 @@ var PriceClient = class {
   }
   async price(category, symbol, options) {
     if (!symbol) throw new Error("symbol is required");
-    const path5 = categoryPath(category, options?.market, "price", symbol);
+    const path6 = categoryPath(category, options?.market, "price", symbol);
     const query = {};
     if (options?.session) query.session = options.session;
-    const data = await this.getWithPayment(path5, query);
+    const data = await this.getWithPayment(path6, query);
     return {
       symbol: data.symbol ?? symbol.toUpperCase(),
       price: data.price,
@@ -3795,14 +7185,14 @@ var PriceClient = class {
     if (!options.from || options.from <= 0) {
       throw new Error("history requires options.from (unix seconds)");
     }
-    const path5 = categoryPath(category, options.market, "history", symbol);
+    const path6 = categoryPath(category, options.market, "history", symbol);
     const query = {
       resolution: options.resolution ?? "D",
       from: String(options.from)
     };
     if (options.to) query.to = String(options.to);
     if (options.session) query.session = options.session;
-    const data = await this.getWithPayment(path5, query);
+    const data = await this.getWithPayment(path6, query);
     return {
       symbol: data.symbol ?? symbol.toUpperCase(),
       resolution: data.resolution ?? (options.resolution ?? "D"),
@@ -3814,12 +7204,12 @@ var PriceClient = class {
     };
   }
   async listSymbols(category, options) {
-    const path5 = categoryPath(category, options?.market, "list");
+    const path6 = categoryPath(category, options?.market, "list");
     const query = {
       limit: String(options?.limit && options.limit > 0 ? options.limit : 100)
     };
     if (options?.query) query.q = options.query;
-    const data = await this.getWithPayment(path5, query);
+    const data = await this.getWithPayment(path6, query);
     if (Array.isArray(data)) {
       return { symbols: data, count: data.length };
     }
@@ -3978,19 +7368,19 @@ var SurfClient = class {
    * `/v1/surf` is tolerated and stripped). Query params are URL-encoded;
    * arrays become repeated keys (`?a=1&a=2`).
    */
-  async get(path5, params) {
-    const url = this.buildUrl(path5, params);
+  async get(path6, params) {
+    const url = this.buildUrl(path6, params);
     return this.requestWithPayment(url, "GET");
   }
   /**
    * POST a Surf endpoint with a JSON body. Same path normalization as `get`.
    */
-  async post(path5, body) {
-    const url = this.buildUrl(path5);
+  async post(path6, body) {
+    const url = this.buildUrl(path6);
     return this.requestWithPayment(url, "POST", body);
   }
-  buildUrl(path5, params) {
-    let normalized = path5.startsWith("/") ? path5 : `/${path5}`;
+  buildUrl(path6, params) {
+    let normalized = path6.startsWith("/") ? path6 : `/${path6}`;
     if (!normalized.startsWith(SURF_PREFIX)) {
       normalized = `${SURF_PREFIX}${normalized}`;
     }
@@ -4390,15 +7780,15 @@ var BlockrunClient = class {
    * `/api` is tolerated and stripped). Query params are URL-encoded; arrays
    * become repeated keys (`?a=1&a=2`); undefined/null are dropped.
    */
-  async get(path5, params) {
-    const url = this.buildUrl(path5, params);
+  async get(path6, params) {
+    const url = this.buildUrl(path6, params);
     return this.requestWithPayment(url, "GET");
   }
   /**
    * POST a BlockRun endpoint with a JSON body.
    */
-  async post(path5, body) {
-    const url = this.buildUrl(path5);
+  async post(path6, body) {
+    const url = this.buildUrl(path6);
     return this.requestWithPayment(url, "POST", body);
   }
   /**
@@ -4413,8 +7803,8 @@ var BlockrunClient = class {
    * short-circuits and returns the body. Most long-running endpoints (image,
    * video, music, voice) return 202 with a poll_url.
    */
-  async poll(path5, body, options) {
-    const submitUrl = this.buildUrl(path5);
+  async poll(path6, body, options) {
+    const submitUrl = this.buildUrl(path6);
     const budgetMs = options?.budgetMs ?? DEFAULT_POLL_BUDGET_MS;
     const intervalMs = options?.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     const resp402 = await this.fetchWithTimeout(submitUrl, {
@@ -4513,8 +7903,8 @@ var BlockrunClient = class {
    *     process.stdout.write(chunk.choices?.[0]?.delta?.content ?? "");
    *   }
    */
-  async *stream(path5, body) {
-    const url = this.buildUrl(path5);
+  async *stream(path6, body) {
+    const url = this.buildUrl(path6);
     const requestBody = JSON.stringify(body ?? {});
     const resp402 = await this.fetchWithTimeout(url, {
       method: "POST",
@@ -4580,8 +7970,8 @@ var BlockrunClient = class {
   // --------------------------------------------------------------------
   // Internal: shared infrastructure
   // --------------------------------------------------------------------
-  buildUrl(path5, params) {
-    let normalized = path5.startsWith("/") ? path5 : `/${path5}`;
+  buildUrl(path6, params) {
+    let normalized = path6.startsWith("/") ? path6 : `/${path6}`;
     if (normalized.startsWith("/api/")) {
       normalized = normalized.slice(4);
     }
@@ -4734,46 +8124,64 @@ function sleep(ms) {
 }
 
 // src/wallet.ts
-var import_accounts15 = require("viem/accounts");
+var import_accounts16 = require("viem/accounts");
+
+// node_modules/.pnpm/@blockrun+core@0.1.1_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@3.25.76/node_modules/@blockrun/core/dist/config.js
 var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
 var os2 = __toESM(require("os"), 1);
-var USDC_BASE_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var BASE_CHAIN_ID2 = "8453";
-var WALLET_DIR = path2.join(os2.homedir(), ".blockrun");
-var WALLET_FILE = path2.join(WALLET_DIR, ".session");
-function createWallet() {
-  const privateKey = (0, import_accounts15.generatePrivateKey)();
-  const account = (0, import_accounts15.privateKeyToAccount)(privateKey);
+var path2 = __toESM(require("path"), 1);
+function homeDir() {
+  return process.env.BLOCKRUN_HOME || os2.homedir();
+}
+function blockrunDir() {
+  return path2.join(homeDir(), ".blockrun");
+}
+function paths() {
+  const dir = blockrunDir();
   return {
-    address: account.address,
-    privateKey
+    dir,
+    session: path2.join(dir, ".session"),
+    legacy: path2.join(dir, "wallet.key"),
+    solana: path2.join(dir, ".solana"),
+    config: path2.join(dir, "config.json"),
+    costLog: path2.join(dir, "cost_log.jsonl")
   };
 }
-function saveWallet(privateKey) {
-  if (!fs2.existsSync(WALLET_DIR)) {
-    fs2.mkdirSync(WALLET_DIR, { recursive: true });
+
+// node_modules/.pnpm/@blockrun+core@0.1.1_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@3.25.76/node_modules/@blockrun/core/dist/wallet.js
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var import_accounts15 = require("viem/accounts");
+function normalize(raw) {
+  const k = raw.trim();
+  return k.startsWith("0x") ? k : `0x${k}`;
+}
+function addressFromKey(raw) {
+  try {
+    return (0, import_accounts15.privateKeyToAccount)(normalize(raw)).address;
+  } catch {
+    return null;
   }
-  fs2.writeFileSync(WALLET_FILE, privateKey, { mode: 384 });
-  return WALLET_FILE;
 }
 function scanWallets() {
-  const home = os2.homedir();
+  const home = homeDir();
   const results = [];
   try {
-    const entries = fs2.readdirSync(home, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.name.startsWith(".") || !entry.isDirectory()) continue;
-      const walletFile = path2.join(home, entry.name, "wallet.json");
-      if (!fs2.existsSync(walletFile)) continue;
+    for (const entry of fs3.readdirSync(home, { withFileTypes: true })) {
+      if (!entry.name.startsWith(".") || !entry.isDirectory())
+        continue;
+      const walletFile2 = path3.join(home, entry.name, "wallet.json");
+      if (!fs3.existsSync(walletFile2))
+        continue;
       try {
-        const data = JSON.parse(fs2.readFileSync(walletFile, "utf-8"));
+        const data = JSON.parse(fs3.readFileSync(walletFile2, "utf-8"));
         const pk = data.privateKey || "";
-        const addr = data.address || "";
-        if (pk && addr) {
-          const mtime = fs2.statSync(walletFile).mtimeMs;
-          results.push({ mtime, privateKey: pk, address: addr, source: walletFile });
-        }
+        if (!pk)
+          continue;
+        const derived = addressFromKey(pk);
+        if (!derived)
+          continue;
+        results.push({ mtime: fs3.statSync(walletFile2).mtimeMs, privateKey: pk, address: derived, source: walletFile2 });
       } catch {
         continue;
       }
@@ -4784,71 +8192,97 @@ function scanWallets() {
   return results.map(({ privateKey, address, source }) => ({ privateKey, address, source }));
 }
 function listDiscoveredWallets() {
-  const listed = [];
-  for (const entry of scanWallets()) {
-    try {
-      listed.push({
-        address: (0, import_accounts15.privateKeyToAccount)(entry.privateKey).address,
-        source: entry.source
-      });
-    } catch {
-      continue;
-    }
-  }
-  return listed;
+  return scanWallets().map(({ address, source }) => ({ address, source }));
 }
-function importWallet(address) {
+function adoptWallet(address) {
   const wanted = address.trim().toLowerCase();
+  const p = paths();
   for (const entry of scanWallets()) {
-    let derived;
-    try {
-      derived = (0, import_accounts15.privateKeyToAccount)(entry.privateKey).address;
-    } catch {
+    if (entry.address.toLowerCase() !== wanted)
       continue;
-    }
-    if (derived.toLowerCase() !== wanted) continue;
-    if (fs2.existsSync(WALLET_FILE)) {
-      const current = fs2.readFileSync(WALLET_FILE, "utf-8").trim();
-      if (current && current !== entry.privateKey) {
-        const backup = path2.join(WALLET_DIR, `.session.backup-${Math.floor(Date.now() / 1e3)}`);
-        fs2.writeFileSync(backup, current, { mode: 384 });
+    const privateKey = normalize(entry.privateKey);
+    if (fs3.existsSync(p.session)) {
+      const current = fs3.readFileSync(p.session, "utf8").trim();
+      if (current && normalize(current) !== privateKey) {
+        const backup = path3.join(p.dir, `.session.backup-${Math.floor(Date.now() / 1e3)}`);
+        fs3.writeFileSync(backup, current, { mode: 384 });
       }
     }
-    saveWallet(entry.privateKey);
-    return derived;
+    fs3.mkdirSync(p.dir, { recursive: true });
+    fs3.writeFileSync(p.session, privateKey, { mode: 384 });
+    return { address: entry.address, privateKey, source: "session" };
   }
   const available = listDiscoveredWallets().map((w) => w.address);
-  throw new Error(
-    `No discovered wallet controls ${address}. Available: ${available.length ? available.join(", ") : "none"}`
-  );
+  throw new Error(`No discovered wallet controls ${address}. Available: ${available.length ? available.join(", ") : "none"}`);
 }
-function loadWallet() {
-  if (fs2.existsSync(WALLET_FILE)) {
-    const key = fs2.readFileSync(WALLET_FILE, "utf-8").trim();
-    if (key) return key;
-  }
-  const legacyFile = path2.join(WALLET_DIR, "wallet.key");
-  if (fs2.existsSync(legacyFile)) {
-    const key = fs2.readFileSync(legacyFile, "utf-8").trim();
-    if (key) return key;
+function resolveFromFiles() {
+  const p = paths();
+  if (fs3.existsSync(p.session)) {
+    const raw = fs3.readFileSync(p.session, "utf8").trim();
+    if (raw)
+      return { privateKey: normalize(raw), source: "session" };
+  }
+  if (fs3.existsSync(p.legacy)) {
+    const raw = fs3.readFileSync(p.legacy, "utf8").trim();
+    if (raw)
+      return { privateKey: normalize(raw), source: "legacy" };
   }
   return null;
 }
+function resolvePrivateKey(env = process.env) {
+  const fromEnv = env.BLOCKRUN_WALLET_KEY || env.BASE_CHAIN_WALLET_KEY;
+  if (fromEnv && fromEnv.trim()) {
+    return { privateKey: normalize(fromEnv), source: "env" };
+  }
+  return resolveFromFiles();
+}
+
+// src/wallet.ts
+var fs4 = __toESM(require("fs"), 1);
+var USDC_BASE_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var BASE_CHAIN_ID2 = "8453";
+function walletDir() {
+  return paths().dir;
+}
+function walletFile() {
+  return paths().session;
+}
+function createWallet() {
+  const privateKey = (0, import_accounts16.generatePrivateKey)();
+  const account = (0, import_accounts16.privateKeyToAccount)(privateKey);
+  return {
+    address: account.address,
+    privateKey
+  };
+}
+function saveWallet(privateKey) {
+  const dir = walletDir();
+  const file = walletFile();
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+  fs4.writeFileSync(file, privateKey, { mode: 384 });
+  return file;
+}
+function scanWallets2() {
+  return scanWallets();
+}
+function listDiscoveredWallets2() {
+  return listDiscoveredWallets();
+}
+function importWallet(address) {
+  return adoptWallet(address).address;
+}
+function loadWallet() {
+  return resolveFromFiles()?.privateKey ?? null;
+}
 function formatWalletMigrationNotice(newAddress) {
-  let discovered;
+  let addresses;
   try {
-    discovered = scanWallets();
+    addresses = listDiscoveredWallets().map((w) => w.address);
   } catch {
     return null;
   }
-  const addresses = [];
-  for (const entry of discovered) {
-    try {
-      addresses.push((0, import_accounts15.privateKeyToAccount)(entry.privateKey).address);
-    } catch {
-      continue;
-    }
-  }
   if (addresses.length === 0) return null;
   const found = addresses.map((addr) => `  ${addr}`).join("\n");
   return `
@@ -4875,30 +8309,18 @@ BLOCKRUN_WALLET_KEY=<private-key> for a single run without changing anything.
 `;
 }
 function getOrCreateWallet() {
-  const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
-  if (envKey) {
-    const account = (0, import_accounts15.privateKeyToAccount)(envKey);
-    return { address: account.address, privateKey: envKey, isNew: false };
-  }
-  const fileKey = loadWallet();
-  if (fileKey) {
-    const account = (0, import_accounts15.privateKeyToAccount)(fileKey);
-    return { address: account.address, privateKey: fileKey, isNew: false };
+  const resolved = resolvePrivateKey();
+  if (resolved) {
+    const account = (0, import_accounts16.privateKeyToAccount)(resolved.privateKey);
+    return { address: account.address, privateKey: resolved.privateKey, isNew: false };
   }
   const { address, privateKey } = createWallet();
   saveWallet(privateKey);
   return { address, privateKey, isNew: true };
 }
 function getWalletAddress() {
-  const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
-  if (envKey) {
-    return (0, import_accounts15.privateKeyToAccount)(envKey).address;
-  }
-  const fileKey = loadWallet();
-  if (fileKey) {
-    return (0, import_accounts15.privateKeyToAccount)(fileKey).address;
-  }
-  return null;
+  const resolved = resolvePrivateKey();
+  return resolved ? (0, import_accounts16.privateKeyToAccount)(resolved.privateKey).address : null;
 }
 function getEip681Uri(address, amountUsdc = 1) {
   const amountWei = Math.floor(amountUsdc * 1e6);
@@ -4960,15 +8382,15 @@ function formatFundingMessageCompact(address) {
   return `I need a little top-up to keep helping you! Send USDC on Base to: ${address}
 Check my balance: ${links.basescan}`;
 }
-var WALLET_FILE_PATH = WALLET_FILE;
-var WALLET_DIR_PATH = WALLET_DIR;
+var WALLET_FILE_PATH = walletFile();
+var WALLET_DIR_PATH = walletDir();
 
 // src/solana-wallet.ts
-var fs3 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
 var os3 = __toESM(require("os"), 1);
-var WALLET_DIR2 = path3.join(os3.homedir(), ".blockrun");
-var SOLANA_WALLET_FILE = path3.join(WALLET_DIR2, ".solana-session");
+var WALLET_DIR = path4.join(os3.homedir(), ".blockrun");
+var SOLANA_WALLET_FILE = path4.join(WALLET_DIR, ".solana-session");
 async function createSolanaWallet() {
   const { Keypair } = await loadSolanaWeb3("Solana wallet operations");
   const bs58 = await import("bs58");
@@ -5032,39 +8454,39 @@ async function solanaPublicKey(privateKey) {
   return Keypair.fromSecretKey(bytes).publicKey.toBase58();
 }
 function saveSolanaWallet(privateKey) {
-  if (!fs3.existsSync(WALLET_DIR2)) fs3.mkdirSync(WALLET_DIR2, { recursive: true });
-  fs3.writeFileSync(SOLANA_WALLET_FILE, privateKey, { mode: 384 });
+  if (!fs5.existsSync(WALLET_DIR)) fs5.mkdirSync(WALLET_DIR, { recursive: true });
+  fs5.writeFileSync(SOLANA_WALLET_FILE, privateKey, { mode: 384 });
   return SOLANA_WALLET_FILE;
 }
 function scanSolanaWallets() {
   const home = os3.homedir();
   const results = [];
   try {
-    const entries = fs3.readdirSync(home, { withFileTypes: true });
+    const entries = fs5.readdirSync(home, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.name.startsWith(".") || !entry.isDirectory()) continue;
-      const solanaWalletFile = path3.join(home, entry.name, "solana-wallet.json");
-      if (fs3.existsSync(solanaWalletFile)) {
+      const solanaWalletFile = path4.join(home, entry.name, "solana-wallet.json");
+      if (fs5.existsSync(solanaWalletFile)) {
         try {
-          const data = JSON.parse(fs3.readFileSync(solanaWalletFile, "utf-8"));
+          const data = JSON.parse(fs5.readFileSync(solanaWalletFile, "utf-8"));
           const pk = data.privateKey || "";
           const addr = data.address || "";
           if (pk && addr) {
-            const mtime = fs3.statSync(solanaWalletFile).mtimeMs;
+            const mtime = fs5.statSync(solanaWalletFile).mtimeMs;
             results.push({ mtime, secretKey: pk, publicKey: addr, source: solanaWalletFile });
           }
         } catch {
         }
       }
       if (entry.name === ".brcc") {
-        const brccWalletFile = path3.join(home, entry.name, "wallet.json");
-        if (fs3.existsSync(brccWalletFile)) {
+        const brccWalletFile = path4.join(home, entry.name, "wallet.json");
+        if (fs5.existsSync(brccWalletFile)) {
           try {
-            const data = JSON.parse(fs3.readFileSync(brccWalletFile, "utf-8"));
+            const data = JSON.parse(fs5.readFileSync(brccWalletFile, "utf-8"));
             const pk = data.privateKey || "";
             const addr = data.address || "";
             if (pk && addr) {
-              const mtime = fs3.statSync(brccWalletFile).mtimeMs;
+              const mtime = fs5.statSync(brccWalletFile).mtimeMs;
               results.push({ mtime, secretKey: pk, publicKey: addr, source: brccWalletFile });
             }
           } catch {
@@ -5078,8 +8500,8 @@ function scanSolanaWallets() {
   return results.map(({ secretKey, publicKey, source }) => ({ secretKey, publicKey, source }));
 }
 function loadSolanaWallet() {
-  if (fs3.existsSync(SOLANA_WALLET_FILE)) {
-    const key = fs3.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
+  if (fs5.existsSync(SOLANA_WALLET_FILE)) {
+    const key = fs5.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
     if (key) return key;
   }
   return null;
@@ -5105,14 +8527,14 @@ async function importSolanaWallet(address) {
       continue;
     }
     if (derived !== wanted) continue;
-    if (fs3.existsSync(SOLANA_WALLET_FILE)) {
-      const current = fs3.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
+    if (fs5.existsSync(SOLANA_WALLET_FILE)) {
+      const current = fs5.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
       if (current && current !== entry.secretKey) {
-        const backup = path3.join(
-          WALLET_DIR2,
+        const backup = path4.join(
+          WALLET_DIR,
           `.solana-session.backup-${Math.floor(Date.now() / 1e3)}`
         );
-        fs3.writeFileSync(backup, current, { mode: 384 });
+        fs5.writeFileSync(backup, current, { mode: 384 });
       }
     }
     saveSolanaWallet(entry.secretKey);
@@ -5180,8 +8602,8 @@ async function getOrCreateSolanaWallet() {
     );
     return { privateKey: envKey, address: address2, isNew: false };
   }
-  if (fs3.existsSync(SOLANA_WALLET_FILE)) {
-    const fileKey = fs3.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
+  if (fs5.existsSync(SOLANA_WALLET_FILE)) {
+    const fileKey = fs5.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
     if (fileKey) {
       const address2 = await solanaPublicKeyFrom(fileKey, SOLANA_WALLET_FILE);
       return { privateKey: fileKey, address: address2, isNew: false };
@@ -5228,6 +8650,8 @@ var SolanaLLMClient = class {
   sessionTotalUsd = 0;
   sessionCalls = 0;
   addressCache = null;
+  modelPricingCache = null;
+  modelPricingPromise = null;
   constructor(options = {}) {
     const envKey = typeof process !== "undefined" && process.env ? process.env.SOLANA_WALLET_KEY : void 0;
     const privateKey = options.privateKey || envKey;
@@ -5262,25 +8686,141 @@ var SolanaLLMClient = class {
       temperature: options?.temperature,
       topP: options?.topP,
       search: options?.search,
-      searchParameters: options?.searchParameters
+      searchParameters: options?.searchParameters,
+      responseFormat: options?.responseFormat,
+      stop: options?.stop,
+      fallbackModels: options?.fallbackModels
     });
     return result.choices[0].message.content || "";
   }
   /** Full chat completion (OpenAI-compatible). */
   async chatCompletion(model, messages, options) {
+    const routingProfile = routingProfileForModel(model);
+    if (routingProfile) {
+      return (await this.smartChatCompletion(messages, {
+        ...options,
+        routingProfile
+      })).response;
+    }
     validateMaxTokens(options?.maxTokens);
-    const body = {
-      model,
-      messages,
-      max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS2
+    const buildBody = (candidate) => {
+      const body = {
+        model: candidate,
+        messages,
+        max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS2
+      };
+      if (options?.temperature !== void 0) body.temperature = options.temperature;
+      if (options?.topP !== void 0) body.top_p = options.topP;
+      if (options?.searchParameters !== void 0) body.search_parameters = options.searchParameters;
+      else if (options?.search === true) body.search_parameters = { mode: "on" };
+      if (options?.tools !== void 0) body.tools = options.tools;
+      if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
+      if (options?.responseFormat !== void 0) body.response_format = options.responseFormat;
+      if (options?.stop !== void 0) body.stop = options.stop;
+      return body;
     };
-    if (options?.temperature !== void 0) body.temperature = options.temperature;
-    if (options?.topP !== void 0) body.top_p = options.topP;
-    if (options?.searchParameters !== void 0) body.search_parameters = options.searchParameters;
-    else if (options?.search === true) body.search_parameters = { mode: "on" };
-    if (options?.tools !== void 0) body.tools = options.tools;
-    if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
-    return this.requestWithPayment("/v1/chat/completions", body);
+    const chain = [model, ...options?.fallbackModels ?? []];
+    let lastError;
+    for (let index = 0; index < chain.length; index += 1) {
+      const candidate = chain[index];
+      try {
+        return await this.requestWithPayment("/v1/chat/completions", buildBody(candidate));
+      } catch (error) {
+        lastError = error;
+        if (!isTransientError(error) || index === chain.length - 1) throw error;
+        console.error(`[@blockrun/llm] ${candidate} -> ${chain[index + 1]} (${errSummary(error)})`);
+      }
+    }
+    throw lastError;
+  }
+  async getModelPricing() {
+    if (this.modelPricingCache) return this.modelPricingCache;
+    if (this.modelPricingPromise) return this.modelPricingPromise;
+    this.modelPricingPromise = (async () => {
+      const models = await this.listModels();
+      const pricing = /* @__PURE__ */ new Map();
+      for (const model of models) {
+        const raw = model;
+        if (model.available === false) continue;
+        const num = (value) => {
+          const n = Number(value ?? 0);
+          return Number.isFinite(n) ? n : 0;
+        };
+        const inputPrice = num(model.inputPrice ?? raw.input_price ?? raw.pricing?.input);
+        const outputPrice = num(model.outputPrice ?? raw.output_price ?? raw.pricing?.output);
+        const flatPrice = num(model.flatPrice ?? raw.flat_price ?? raw.pricing?.flat);
+        pricing.set(model.id, {
+          inputPrice,
+          outputPrice,
+          ...(model.billingMode ?? raw.billing_mode) === "flat" && flatPrice > 0 ? { flatPrice } : {}
+        });
+      }
+      return pricing;
+    })();
+    try {
+      this.modelPricingCache = await this.modelPricingPromise;
+      return this.modelPricingCache;
+    } finally {
+      this.modelPricingPromise = null;
+    }
+  }
+  /** Inspect a Solana route without making or paying for a model call. */
+  async route(prompt, options) {
+    return routeWithCatalog(
+      prompt,
+      options?.system,
+      options?.maxOutputTokens ?? options?.maxTokens ?? DEFAULT_MAX_TOKENS2,
+      await this.getModelPricing(),
+      {
+        routingProfile: options?.routingProfile,
+        requiresStructuredOutput: options?.responseFormat !== void 0,
+        minimumPaymentUsd: SOLANA_MINIMUM_PAYMENT_USD
+      }
+    );
+  }
+  /** Smart one-line chat paid on Solana. */
+  async smartChat(prompt, options) {
+    const decision = await this.route(prompt, options);
+    const response = await this.chat(decision.model, prompt, {
+      ...options,
+      // An explicit caller-supplied chain wins over the routed one.
+      fallbackModels: options?.fallbackModels ?? decision.fallbacks
+    });
+    return { response, model: decision.model, routing: decision };
+  }
+  /** Smart full message/tool completion paid on Solana. */
+  async smartChatCompletion(messages, options = {}) {
+    const { prompt, systemPrompt, conversationChars, hasVision } = routingText(messages);
+    const decision = routeWithCatalog(
+      prompt,
+      systemPrompt,
+      options.maxOutputTokens ?? options.maxTokens ?? DEFAULT_MAX_TOKENS2,
+      await this.getModelPricing(),
+      {
+        routingProfile: options.routingProfile,
+        requiresStructuredOutput: options.responseFormat !== void 0,
+        tools: options.tools,
+        toolChoice: options.toolChoice,
+        conversationChars,
+        hasVision,
+        minimumPaymentUsd: SOLANA_MINIMUM_PAYMENT_USD
+      }
+    );
+    const response = await this.chatCompletion(decision.model, messages, {
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP,
+      search: options.search,
+      searchParameters: options.searchParameters,
+      tools: options.tools,
+      toolChoice: options.toolChoice,
+      responseFormat: options.responseFormat,
+      stop: options.stop,
+      // An explicit caller-supplied chain wins over the routed one.
+      fallbackModels: options.fallbackModels ?? decision.fallbacks
+    });
+    response.routing = decision;
+    return { response, model: decision.model, routing: decision };
   }
   /** List available models. */
   async listModels() {
@@ -5345,11 +8885,11 @@ var SolanaLLMClient = class {
     return data;
   }
   // ── Prediction Markets (Powered by Predexon) ────────────────────────────
-  async pm(path5, params) {
-    return this.getWithPaymentRaw(`/v1/pm/${path5}`, params);
+  async pm(path6, params) {
+    return this.getWithPaymentRaw(`/v1/pm/${path6}`, params);
   }
-  async pmQuery(path5, query) {
-    return this.requestWithPaymentRaw(`/v1/pm/${path5}`, query);
+  async pmQuery(path6, query) {
+    return this.requestWithPaymentRaw(`/v1/pm/${path6}`, query);
   }
   // ── Exa Web Search (Powered by Exa) ──────────────────────────────────────
   /**
@@ -5361,8 +8901,8 @@ var SolanaLLMClient = class {
    * @example
    * const results = await client.exa("search", { query: "latest AI research", numResults: 5 });
    */
-  async exa(path5, body) {
-    return this.requestWithPaymentRaw(`/v1/exa/${path5}`, body);
+  async exa(path6, body) {
+    return this.requestWithPaymentRaw(`/v1/exa/${path6}`, body);
   }
   /**
    * Neural and keyword web search via Exa (Solana payment, $0.01/request).
@@ -5412,8 +8952,8 @@ var SolanaLLMClient = class {
    *               "prices/coingecko:bitcoin,base:0x..."
    * @param params - Query parameters passed through to DefiLlama
    */
-  async defi(path5, params) {
-    return this.getWithPaymentRaw(`/v1/defillama/${path5}`, params);
+  async defi(path6, params) {
+    return this.getWithPaymentRaw(`/v1/defillama/${path6}`, params);
   }
   /** All DeFi protocols with TVL ($0.005/call). */
   async defiProtocols() {
@@ -5449,9 +8989,9 @@ var SolanaLLMClient = class {
    * @param params - Query params (chainId, sellToken, buyToken, sellAmount, taker, ...)
    * @param body - JSON body — pass to switch to POST (gasless/submit only)
    */
-  async dex(path5, params, body) {
-    if (body) return this.requestWithPaymentRaw(`/v1/zerox/${path5}`, body);
-    return this.getWithPaymentRaw(`/v1/zerox/${path5}`, params);
+  async dex(path6, params, body) {
+    if (body) return this.requestWithPaymentRaw(`/v1/zerox/${path6}`, body);
+    return this.getWithPaymentRaw(`/v1/zerox/${path6}`, params);
   }
   /** Indicative Permit2 swap price — no commitment (free). */
   async dexPrice(params) {
@@ -5495,8 +9035,8 @@ var SolanaLLMClient = class {
    *               "sandbox/status", "sandbox/terminate" ($0.001 each)
    * @param body - JSON body for the endpoint
    */
-  async modal(path5, body) {
-    return this.requestWithPaymentRaw(`/v1/modal/${path5}`, body ?? {});
+  async modal(path6, body) {
+    return this.requestWithPaymentRaw(`/v1/modal/${path6}`, body ?? {});
   }
   /** Create a sandboxed compute environment ($0.01 CPU / $0.05 GPU). */
   async modalSandboxCreate(body) {
@@ -5813,13 +9353,13 @@ function solanaClient(options = {}) {
 }
 
 // src/cache.ts
-var fs4 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
 var os4 = __toESM(require("os"), 1);
 var crypto2 = __toESM(require("crypto"), 1);
-var CACHE_DIR = path4.join(os4.homedir(), ".blockrun", "cache");
-var DATA_DIR = path4.join(os4.homedir(), ".blockrun", "data");
-var COST_LOG_FILE2 = path4.join(os4.homedir(), ".blockrun", "cost_log.jsonl");
+var CACHE_DIR = path5.join(os4.homedir(), ".blockrun", "cache");
+var DATA_DIR = path5.join(os4.homedir(), ".blockrun", "data");
+var COST_LOG_FILE2 = path5.join(os4.homedir(), ".blockrun", "cost_log.jsonl");
 var DEFAULT_TTL = {
   "/v1/partner/": 3600 * 1e3,
   "/v1/pm/": 1800 * 1e3,
@@ -5839,19 +9379,19 @@ function cacheKey(endpoint, body) {
   return crypto2.createHash("sha256").update(keyData).digest("hex").slice(0, 16);
 }
 function cachePath(key) {
-  return path4.join(CACHE_DIR, `${key}.json`);
+  return path5.join(CACHE_DIR, `${key}.json`);
 }
 function getCached(key) {
   const filePath = cachePath(key);
-  if (!fs4.existsSync(filePath)) return null;
+  if (!fs6.existsSync(filePath)) return null;
   try {
-    const raw = fs4.readFileSync(filePath, "utf-8");
+    const raw = fs6.readFileSync(filePath, "utf-8");
     const entry = JSON.parse(raw);
     const ttl = entry.ttlMs ?? getTtl(entry.endpoint ?? "");
     if (ttl <= 0) return null;
     if (Date.now() - entry.cachedAt > ttl) {
       try {
-        fs4.unlinkSync(filePath);
+        fs6.unlinkSync(filePath);
       } catch {
       }
       return null;
@@ -5870,7 +9410,7 @@ function getCachedByRequest(endpoint, body) {
 function setCache(key, data, ttlMs) {
   if (ttlMs <= 0) return;
   try {
-    fs4.mkdirSync(CACHE_DIR, { recursive: true });
+    fs6.mkdirSync(CACHE_DIR, { recursive: true });
   } catch {
   }
   const entry = {
@@ -5879,7 +9419,7 @@ function setCache(key, data, ttlMs) {
     ttlMs
   };
   try {
-    fs4.writeFileSync(cachePath(key), JSON.stringify(entry));
+    fs6.writeFileSync(cachePath(key), JSON.stringify(entry));
   } catch {
   }
 }
@@ -5900,7 +9440,7 @@ function readableFilename(endpoint, body) {
 }
 function saveReadable(endpoint, body, response, costUsd) {
   try {
-    fs4.mkdirSync(DATA_DIR, { recursive: true });
+    fs6.mkdirSync(DATA_DIR, { recursive: true });
   } catch {
   }
   const filename = readableFilename(endpoint, body);
@@ -5912,14 +9452,14 @@ function saveReadable(endpoint, body, response, costUsd) {
     response
   };
   try {
-    fs4.writeFileSync(path4.join(DATA_DIR, filename), JSON.stringify(entry, null, 2));
+    fs6.writeFileSync(path5.join(DATA_DIR, filename), JSON.stringify(entry, null, 2));
   } catch {
   }
 }
 function appendCostLog(endpoint, costUsd) {
   if (costUsd <= 0) return;
   try {
-    fs4.mkdirSync(path4.dirname(COST_LOG_FILE2), { recursive: true });
+    fs6.mkdirSync(path5.dirname(COST_LOG_FILE2), { recursive: true });
   } catch {
   }
   const entry = {
@@ -5928,7 +9468,7 @@ function appendCostLog(endpoint, costUsd) {
     cost_usd: costUsd
   };
   try {
-    fs4.appendFileSync(COST_LOG_FILE2, JSON.stringify(entry) + "\n");
+    fs6.appendFileSync(COST_LOG_FILE2, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
@@ -5936,7 +9476,7 @@ function saveToCache(endpoint, body, response, costUsd = 0) {
   const ttl = getTtl(endpoint);
   if (ttl > 0) {
     try {
-      fs4.mkdirSync(CACHE_DIR, { recursive: true });
+      fs6.mkdirSync(CACHE_DIR, { recursive: true });
     } catch {
     }
     const key = cacheKey(endpoint, body);
@@ -5948,7 +9488,7 @@ function saveToCache(endpoint, body, response, costUsd = 0) {
       costUsd
     };
     try {
-      fs4.writeFileSync(cachePath(key), JSON.stringify(entry));
+      fs6.writeFileSync(cachePath(key), JSON.stringify(entry));
     } catch {
     }
   }
@@ -5956,14 +9496,14 @@ function saveToCache(endpoint, body, response, costUsd = 0) {
   appendCostLog(endpoint, costUsd);
 }
 function clearCache() {
-  if (!fs4.existsSync(CACHE_DIR)) return 0;
+  if (!fs6.existsSync(CACHE_DIR)) return 0;
   let count = 0;
   try {
-    const files = fs4.readdirSync(CACHE_DIR);
+    const files = fs6.readdirSync(CACHE_DIR);
     for (const file of files) {
       if (file.endsWith(".json")) {
         try {
-          fs4.unlinkSync(path4.join(CACHE_DIR, file));
+          fs6.unlinkSync(path5.join(CACHE_DIR, file));
           count++;
         } catch {
         }
@@ -5974,14 +9514,14 @@ function clearCache() {
   return count;
 }
 function getCostLogSummary() {
-  if (!fs4.existsSync(COST_LOG_FILE2)) {
+  if (!fs6.existsSync(COST_LOG_FILE2)) {
     return { totalUsd: 0, calls: 0, byEndpoint: {} };
   }
   let totalUsd = 0;
   let calls = 0;
   const byEndpoint = {};
   try {
-    const content = fs4.readFileSync(COST_LOG_FILE2, "utf-8").trim();
+    const content = fs6.readFileSync(COST_LOG_FILE2, "utf-8").trim();
     if (!content) return { totalUsd: 0, calls: 0, byEndpoint: {} };
     for (const line of content.split("\n")) {
       if (!line) continue;
@@ -6161,7 +9701,8 @@ var ChatCompletions = class {
         },
         finish_reason: choice.finish_reason || "stop"
       })),
-      usage: response.usage
+      usage: response.usage,
+      routing: response.routing
     };
   }
 };
@@ -6194,7 +9735,7 @@ var OpenAI = class {
 };
 
 // src/anthropic-compat.ts
-var import_accounts16 = require("viem/accounts");
+var import_accounts17 = require("viem/accounts");
 var AnthropicClient = class {
   _client = null;
   _clientPromise = null;
@@ -6207,7 +9748,7 @@ var AnthropicClient = class {
     const key = options.privateKey ?? wallet.privateKey;
     validatePrivateKey(key);
     this._privateKey = key;
-    this._account = (0, import_accounts16.privateKeyToAccount)(this._privateKey);
+    this._account = (0, import_accounts17.privateKeyToAccount)(this._privateKey);
     const apiUrl = options.apiUrl ?? "https://blockrun.ai/api";
     validateApiUrl(apiUrl);
     this._apiUrl = apiUrl.replace(/\/$/, "");