@khanglvm/llm-router 2.3.2 → 2.3.5

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.3.5] - 2026-04-17
+
+### Fixed
+- Added model-aware reasoning/effort conversion so routed requests automatically fall back to the safest supported effort level for the actual backend model, including GPT-5 Codex/OpenAI targets and Claude Opus 4.6 vs 4.7 targets behind the same alias.
+
+## [2.3.4] - 2026-04-17
+
+### Fixed
+- Updated the live provider suite to exercise RamCloud with `minimax-m2.7` only and switched the Claude Code live alias from `normal` to `default`, matching the generated router config so real-provider publish checks pass again.
+
+## [2.3.3] - 2026-04-17
+
+### Fixed
+- Prevented repeated failed OpenAI `/v1/chat/completions` tool-routing attempts for Claude Code requests on dual-format Claude routes by respecting model format preferences and suppressing noisy re-tries after a successful Claude fallback.
+
 ## [2.3.2] - 2026-04-17
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khanglvm/llm-router",
-  "version": "2.3.2",
+  "version": "2.3.5",
   "description": "LLM Router: single gateway endpoint for multi-provider LLMs with unified OpenAI+Anthropic format and seamless fallback",
   "keywords": [
     "llm-router",

package/src/runtime/handler/provider-call.js

@@ -43,10 +43,87 @@ import {
   resolveLargeRequestLogThresholdBytes
 } from "./large-request-log.js";
 
+const OPENAI_TOOL_ROUTING_SUPPRESSION_TTL_MS = 30 * 60 * 1000;
+const openAIToolRoutingSuppressionUntil = new Map();
+
 function isSubscriptionProvider(provider) {
   return provider?.type === "subscription";
 }
 
+function normalizeFormatList(values) {
+  return [...new Set(
+    (Array.isArray(values) ? values : [values])
+      .map((value) => String(value || "").trim())
+      .filter((value) => value === FORMATS.OPENAI || value === FORMATS.CLAUDE)
+  )];
+}
+
+function resolveCandidateModel(provider, model, modelId) {
+  if (model && typeof model === "object" && !Array.isArray(model)) {
+    return model;
+  }
+  const normalizedModelId = String(modelId || "").trim();
+  if (!normalizedModelId || !Array.isArray(provider?.models)) return null;
+  return provider.models.find((entry) => String(entry?.id || "").trim() === normalizedModelId) || null;
+}
+
+function getProviderModelSupportedFormats(provider, model, modelId) {
+  const resolvedModel = resolveCandidateModel(provider, model, modelId);
+  const configuredFormats = normalizeFormatList(resolvedModel?.formats || resolvedModel?.format);
+  const resolvedModelId = String(resolvedModel?.id || modelId || "").trim();
+  if (!resolvedModelId) return configuredFormats;
+
+  const preferredFormat = provider?.lastProbe?.modelPreferredFormat?.[resolvedModelId];
+  if (preferredFormat === FORMATS.OPENAI || preferredFormat === FORMATS.CLAUDE) {
+    return [preferredFormat];
+  }
+
+  const probedFormats = normalizeFormatList(provider?.lastProbe?.modelSupport?.[resolvedModelId]);
+  return probedFormats.length > 0 ? probedFormats : configuredFormats;
+}
+
+function getProviderModelPreferredFormat(provider, model, modelId) {
+  const resolvedModel = resolveCandidateModel(provider, model, modelId);
+  const resolvedModelId = String(resolvedModel?.id || modelId || "").trim();
+  if (!resolvedModelId) return "";
+  const preferredFormat = String(provider?.lastProbe?.modelPreferredFormat?.[resolvedModelId] || "").trim();
+  return preferredFormat === FORMATS.OPENAI || preferredFormat === FORMATS.CLAUDE
+    ? preferredFormat
+    : "";
+}
+
+function buildOpenAIToolRoutingSuppressionKey(candidate) {
+  const providerId = String(candidate?.providerId || candidate?.provider?.id || "").trim();
+  const modelId = String(candidate?.modelId || candidate?.model?.id || candidate?.backend || "").trim();
+  if (!providerId || !modelId) return "";
+  return `${providerId}/${modelId}`;
+}
+
+function pruneOpenAIToolRoutingSuppressions(now = Date.now()) {
+  for (const [key, expiresAt] of openAIToolRoutingSuppressionUntil.entries()) {
+    if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+      openAIToolRoutingSuppressionUntil.delete(key);
+    }
+  }
+}
+
+function isOpenAIToolRoutingSuppressed(candidate, now = Date.now()) {
+  const key = buildOpenAIToolRoutingSuppressionKey(candidate);
+  if (!key) return false;
+  pruneOpenAIToolRoutingSuppressions(now);
+  return Number(openAIToolRoutingSuppressionUntil.get(key)) > now;
+}
+
+function suppressOpenAIToolRouting(candidate, now = Date.now()) {
+  const key = buildOpenAIToolRoutingSuppressionKey(candidate);
+  if (!key) return;
+  openAIToolRoutingSuppressionUntil.set(key, now + OPENAI_TOOL_ROUTING_SUPPRESSION_TTL_MS);
+}
+
+export function resetOpenAIToolRoutingLearningState() {
+  openAIToolRoutingSuppressionUntil.clear();
+}
+
 function queueLargeRequestEvent(onLargeRequestLog, payload) {
   if (typeof onLargeRequestLog !== "function") return;
   try {
@@ -313,6 +390,9 @@ function normalizeProviderRequestKind(targetFormat, requestKind) {
 
 function shouldPreferOpenAIForClaudeToolCalls({
   provider,
+  model,
+  modelId,
+  candidate,
   sourceFormat,
   targetFormat,
   requestKind,
@@ -320,6 +400,11 @@ function shouldPreferOpenAIForClaudeToolCalls({
 } = {}) {
   if (sourceFormat !== FORMATS.CLAUDE || targetFormat !== FORMATS.CLAUDE) return false;
   if (!hasToolDefinitions(body)) return false;
+  if (candidate && isOpenAIToolRoutingSuppressed(candidate)) return false;
+  const preferredFormat = getProviderModelPreferredFormat(provider, model, modelId);
+  if (preferredFormat === FORMATS.CLAUDE) return false;
+  const modelFormats = getProviderModelSupportedFormats(provider, model, modelId);
+  if (modelFormats.length > 0 && !modelFormats.includes(FORMATS.OPENAI)) return false;
   if (!getProviderFormats(provider).includes(FORMATS.OPENAI)) return false;
   return Boolean(resolveProviderUrl(provider, FORMATS.OPENAI, normalizeProviderRequestKind(FORMATS.OPENAI, requestKind)));
 }
@@ -664,6 +749,9 @@ export async function makeProviderCall({
 
   const preferOpenAIToolRouting = !isSubscriptionProvider(provider) && shouldPreferOpenAIForClaudeToolCalls({
     provider,
+    model: candidate?.model,
+    modelId: candidate?.modelId,
+    candidate,
     sourceFormat,
     targetFormat,
     requestKind,
@@ -1064,6 +1152,9 @@ export async function makeProviderCall({
     try {
       const fallbackResponse = await executeHttpProviderRequest(fallbackPlan);
       if (fallbackResponse instanceof Response && fallbackResponse.ok) {
+        if (preferOpenAIToolRouting) {
+          suppressOpenAIToolRouting(candidate);
+        }
         response = fallbackResponse;
         activePlan = fallbackPlan;
       }

package/src/runtime/handler/reasoning-effort.js

@@ -16,6 +16,16 @@ const EFFORT_HEADER_PATTERNS = [
   /thinking[-_]?effort/i
 ];
 
+const ORDERED_EFFORT_LEVELS = Object.freeze([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+]);
+
 function readHeaderValue(headers, name) {
   if (!headers || !name) return "";
   if (typeof headers.get === "function") {
@@ -63,7 +73,8 @@ function normalizeEffort(rawValue) {
   if (compact === "low") return "low";
   if (["medium", "normal", "standard", "default"].includes(compact)) return "medium";
   if (compact === "high") return "high";
-  if (["xhigh", "extra high", "max", "maximum"].includes(compact)) return "xhigh";
+  if (["xhigh", "extra high"].includes(compact)) return "xhigh";
+  if (["max", "maximum"].includes(compact)) return "max";
 
   if (compact.includes("ultra")) return "xhigh";
   if (compact.includes("think hard") || compact.includes("harder")) return "high";
@@ -71,6 +82,60 @@ function normalizeEffort(rawValue) {
   return "";
 }
 
+function getEffortRank(effort) {
+  return ORDERED_EFFORT_LEVELS.indexOf(normalizeEffort(effort));
+}
+
+function normalizeModelMatcherValue(value) {
+  let text = String(value || "").trim().toLowerCase();
+  if (!text) return "";
+
+  const slashIndex = Math.max(text.lastIndexOf("/"), text.lastIndexOf(":"));
+  if (slashIndex >= 0) {
+    text = text.slice(slashIndex + 1);
+  }
+
+  return text
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function matchesModelPattern(targetModel, pattern) {
+  const normalizedModel = normalizeModelMatcherValue(targetModel);
+  if (!normalizedModel) return false;
+  return new RegExp(`(?:^|-)${pattern}(?:-|$)`).test(normalizedModel);
+}
+
+function resolveSupportedEffort(requestedEffort, supportedEfforts = []) {
+  const normalizedRequested = normalizeEffort(requestedEffort);
+  if (!normalizedRequested) return "";
+
+  const normalizedSupported = [...new Set(
+    (Array.isArray(supportedEfforts) ? supportedEfforts : [supportedEfforts])
+      .map((effort) => normalizeEffort(effort))
+      .filter(Boolean)
+  )];
+  if (normalizedSupported.length === 0) return normalizedRequested;
+  if (normalizedSupported.includes(normalizedRequested)) return normalizedRequested;
+
+  const requestedRank = getEffortRank(normalizedRequested);
+  let bestAtOrBelow = "";
+  let bestAtOrBelowRank = -1;
+  for (const supported of normalizedSupported) {
+    const supportedRank = getEffortRank(supported);
+    if (supportedRank <= requestedRank && supportedRank > bestAtOrBelowRank) {
+      bestAtOrBelow = supported;
+      bestAtOrBelowRank = supportedRank;
+    }
+  }
+  if (bestAtOrBelow) return bestAtOrBelow;
+
+  return normalizedSupported.reduce((lowest, supported) => (
+    getEffortRank(supported) < getEffortRank(lowest) ? supported : lowest
+  ), normalizedSupported[0]);
+}
+
 function parseNumber(value) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) return undefined;
@@ -81,6 +146,7 @@ function extractEffortFromBody(body) {
   if (!body || typeof body !== "object") return "";
 
   const directCandidates = [
+    body.output_config?.effort,
     body.reasoning_effort,
     body.reasoningEffort,
     body["reasoning-effort"],
@@ -121,12 +187,15 @@ function inferEffortFromClaudeThinking(body) {
 
   if (Number.isFinite(maxTokens) && maxTokens > 0) {
     const ratio = budgetTokens / maxTokens;
-    if (ratio >= 0.9) return "max";
+    if (ratio >= 0.97) return "max";
+    if (ratio >= 0.82) return "xhigh";
     if (ratio >= 0.65) return "high";
     if (ratio >= 0.3) return "medium";
     return "low";
   }
 
+  if (budgetTokens >= 31999) return "max";
+  if (budgetTokens >= 28000) return "xhigh";
   if (budgetTokens >= 24000) return "high";
   if (budgetTokens >= 6000) return "medium";
   return "low";
@@ -153,39 +222,55 @@ function prefersNestedOpenAIReasoning(targetModel) {
   return model.startsWith("gpt-5");
 }
 
-function supportsOpenAIXHighEffort(targetModel) {
-  const model = String(targetModel || "").trim().toLowerCase();
-  if (!model) return false;
-  if (model.startsWith("gpt-5.2")) return true;
-  if (model.startsWith("gpt-5.3-codex")) return true;
-  return false;
+function resolveOpenAISupportedEfforts(targetModel) {
+  if (matchesModelPattern(targetModel, "gpt-5-4-pro")) return ["medium", "high", "xhigh"];
+  if (matchesModelPattern(targetModel, "gpt-5-pro")) return ["high"];
+  if (matchesModelPattern(targetModel, "gpt-5-4")) return ["none", "low", "medium", "high", "xhigh"];
+  if (matchesModelPattern(targetModel, "gpt-5-3-codex")) return ["low", "medium", "high", "xhigh"];
+  if (matchesModelPattern(targetModel, "gpt-5-2-codex")) return ["low", "medium", "high", "xhigh"];
+  if (matchesModelPattern(targetModel, "gpt-5-2-pro")) return ["medium", "high", "xhigh"];
+  if (matchesModelPattern(targetModel, "gpt-5-2")) return ["none", "low", "medium", "high", "xhigh"];
+  if (matchesModelPattern(targetModel, "gpt-5-1-codex")) return ["low", "medium", "high"];
+  if (matchesModelPattern(targetModel, "gpt-5-1")) return ["none", "low", "medium", "high"];
+  if (matchesModelPattern(targetModel, "gpt-5")) return ["minimal", "low", "medium", "high"];
+  return ["low", "medium", "high"];
 }
 
-function supportsOpenAINoneEffort(targetModel) {
-  const model = String(targetModel || "").trim().toLowerCase();
-  if (!model) return false;
-  if (model.startsWith("gpt-5.1") && !model.includes("codex")) return true;
-  if (model.startsWith("gpt-5.2") && !model.includes("codex") && !model.includes("pro")) return true;
-  return false;
+function resolveClaudeEffortProfile(targetModel) {
+  if (matchesModelPattern(targetModel, "opus-4-7")) {
+    return {
+      supportsEffortApi: true,
+      requiresAdaptiveThinking: true,
+      preserveManualBudgetThinking: false,
+      supportedEfforts: ["low", "medium", "high", "xhigh", "max"]
+    };
+  }
+  if (matchesModelPattern(targetModel, "opus-4-6") || matchesModelPattern(targetModel, "sonnet-4-6")) {
+    return {
+      supportsEffortApi: true,
+      requiresAdaptiveThinking: true,
+      preserveManualBudgetThinking: true,
+      supportedEfforts: ["low", "medium", "high", "max"]
+    };
+  }
+  if (matchesModelPattern(targetModel, "opus-4-5")) {
+    return {
+      supportsEffortApi: false,
+      requiresAdaptiveThinking: false,
+      preserveManualBudgetThinking: true,
+      supportedEfforts: ["low", "medium", "high", "max"]
+    };
+  }
+  return {
+    supportsEffortApi: false,
+    requiresAdaptiveThinking: false,
+    preserveManualBudgetThinking: true,
+    supportedEfforts: ["low", "medium", "high"]
+  };
 }
 
 function mapEffortToOpenAI(effort, targetModel) {
-  switch (effort) {
-    case "none":
-      return supportsOpenAINoneEffort(targetModel) ? "none" : "low";
-    case "minimal":
-      return "low";
-    case "low":
-      return "low";
-    case "medium":
-      return "medium";
-    case "high":
-      return "high";
-    case "xhigh":
-      return supportsOpenAIXHighEffort(targetModel) ? "xhigh" : "high";
-    default:
-      return "";
-  }
+  return resolveSupportedEffort(effort, resolveOpenAISupportedEfforts(targetModel));
 }
 
 function applyOpenAIEffort(providerBody, effort, targetModel) {
@@ -236,6 +321,7 @@ function toClaudeThinkingBudget(effort, maxTokens) {
     case "high":
       return clampBudget(Math.round(safeMaxTokens * 0.75), 1024, maxBudget);
     case "xhigh":
+      return clampBudget(Math.round(safeMaxTokens * 0.9), 1024, maxBudget);
     case "max":
       return maxBudget;
     default:
@@ -243,10 +329,37 @@ function toClaudeThinkingBudget(effort, maxTokens) {
   }
 }
 
-function applyClaudeEffort(providerBody, effort, { sourceFormat, originalBody } = {}) {
+function applyClaudeEffort(providerBody, effort, { sourceFormat, originalBody, targetModel } = {}) {
   const nextBody = { ...(providerBody || {}) };
+  const requestedEffort = normalizeEffort(effort);
+  const profile = resolveClaudeEffortProfile(targetModel);
+  const mappedEffort = resolveSupportedEffort(requestedEffort, profile.supportedEfforts);
+
+  if (profile.supportsEffortApi && mappedEffort) {
+    nextBody.output_config = {
+      ...(nextBody.output_config && typeof nextBody.output_config === "object" && !Array.isArray(nextBody.output_config)
+        ? nextBody.output_config
+        : {}),
+      effort: mappedEffort
+    };
+
+    const explicitBudgetTokens = parseNumber(nextBody?.thinking?.budget_tokens);
+    const explicitThinkingType = String(nextBody?.thinking?.type || "").trim().toLowerCase();
+    if (profile.preserveManualBudgetThinking && Number.isFinite(explicitBudgetTokens)) {
+      return nextBody;
+    }
+
+    if (profile.requiresAdaptiveThinking) {
+      if (explicitThinkingType === "disabled") {
+        nextBody.thinking = { type: "disabled" };
+      } else {
+        nextBody.thinking = { type: "adaptive" };
+      }
+    }
+    return nextBody;
+  }
 
-  if (effort === "none" || effort === "minimal") {
+  if (requestedEffort === "none" || requestedEffort === "minimal") {
     delete nextBody.thinking;
     return nextBody;
   }
@@ -267,7 +380,7 @@ function applyClaudeEffort(providerBody, effort, { sourceFormat, originalBody }
     nextBody.max_tokens = maxTokens;
   }
 
-  const budgetTokens = toClaudeThinkingBudget(effort, maxTokens);
+  const budgetTokens = toClaudeThinkingBudget(mappedEffort || requestedEffort, maxTokens);
   if (!Number.isFinite(budgetTokens)) {
     return nextBody;
   }
@@ -316,7 +429,8 @@ export function applyReasoningEffortMapping({
   if (targetFormat === FORMATS.CLAUDE) {
     return applyClaudeEffort(providerBody, effort, {
       sourceFormat,
-      originalBody
+      originalBody,
+      targetModel
     });
   }
   return providerBody;