@khanglvm/llm-router 2.3.4 → 2.3.6

package/src/node/web-console-server.js

@@ -1488,7 +1488,8 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     const endpointUrl = buildAmpClientEndpointUrl(settings);
     try {
       const state = await readFactoryDroidRoutingState({
-        endpointUrl
+        endpointUrl,
+        config
       });
       return {
         ...state,
@@ -1512,6 +1513,13 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
           missionValidatorModel: "",
           reasoningEffort: ""
         },
+        bindingIds: {
+          defaultModel: "",
+          missionOrchestratorModel: "",
+          missionWorkerModel: "",
+          missionValidatorModel: "",
+          reasoningEffort: ""
+        },
         endpointUrl,
         error: error instanceof Error ? error.message : String(error)
       };
@@ -1551,6 +1559,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
         endpointUrl: nextEndpointUrl,
         apiKey: nextMasterKey,
         bindings,
+        config: nextConfig,
         captureBackup: false
       });
       if (endpointOrKeyChanged) {
@@ -3487,6 +3496,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
           endpointUrl,
           apiKey,
           bindings,
+          config: nextConfig,
           captureBackup: true
         });
         addLog("success", "Factory Droid routing enabled.", patchResult.baseUrl);
@@ -3537,6 +3547,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
           endpointUrl,
           apiKey,
           bindings,
+          config: configState.normalizedConfig,
           captureBackup: false
         });
         addLog("success", "Factory Droid model bindings updated.", patchResult.bindings.defaultModel || "Default");

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;

package/src/shared/coding-tool-bindings.js

@@ -64,6 +64,139 @@ export const FACTORY_DROID_REASONING_EFFORT_VALUES = Object.freeze([
   "high"
 ]);
 
+function stripFactoryDroidRouterModelIdPrefix(value) {
+  const normalized = String(value || "").trim();
+  if (normalized.startsWith("custom:")) return normalized.slice("custom:".length).trim();
+  return normalized;
+}
+
+function sanitizeFactoryDroidRouterModelIdPart(value) {
+  return String(value || "")
+    .trim()
+    .replace(/[/:]+/g, "-")
+    .replace(/\s+/g, "-")
+    .replace(/[^A-Za-z0-9._-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function formatFactoryDroidDisplayNameBase(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) return "";
+  if (/^gpt(?=[-\s.]|$)/i.test(normalized)) return `GPT${normalized.slice(3)}`;
+  if (/^glm(?=[-\s.]|$)/i.test(normalized)) return `GLM${normalized.slice(3)}`;
+  if (/^claude(?=[-\s.]|$)/i.test(normalized)) return `Claude${normalized.slice(6)}`;
+  return normalized;
+}
+
+export function isFactoryDroidRouterModelId(value) {
+  const normalized = stripFactoryDroidRouterModelIdPrefix(value);
+  return normalized.startsWith("llm-");
+}
+
+export function parseFactoryDroidRouterModelId(value) {
+  const normalized = stripFactoryDroidRouterModelIdPrefix(value);
+  if (!normalized.startsWith("llm-")) return null;
+
+  if (normalized.startsWith("llm-alias:")) {
+    const aliasId = normalized.slice("llm-alias:".length).trim();
+    return aliasId
+      ? {
+          kind: "alias",
+          aliasId,
+          routeRef: aliasId
+        }
+      : null;
+  }
+
+  if (normalized.startsWith("llm-alias-")) {
+    const aliasId = normalized.slice("llm-alias-".length).trim();
+    return aliasId
+      ? {
+          kind: "alias",
+          aliasId,
+          routeRef: ""
+        }
+      : null;
+  }
+
+  const body = normalized.slice("llm-".length);
+  const separatorIndex = body.indexOf(":");
+  if (separatorIndex <= 0) return null;
+
+  const providerId = body.slice(0, separatorIndex).trim();
+  const modelId = body.slice(separatorIndex + 1).trim();
+  if (!providerId || !modelId) return null;
+
+  return {
+    kind: "model",
+    providerId,
+    modelId,
+    routeRef: `${providerId}/${modelId}`
+  };
+}
+
+export function resolveFactoryDroidRouterModelRef(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) return "";
+  return parseFactoryDroidRouterModelId(normalized)?.routeRef || normalized;
+}
+
+export function buildFactoryDroidRouterModelId(modelRef, { kind = "" } = {}) {
+  const normalizedModelRef = String(modelRef || "").trim();
+  if (!normalizedModelRef) return "";
+  if (normalizedModelRef.startsWith("custom:llm-")) {
+    const parsed = parseFactoryDroidRouterModelId(normalizedModelRef);
+    return parsed?.routeRef
+      ? buildFactoryDroidRouterModelId(parsed.routeRef, { kind: parsed.kind })
+      : normalizedModelRef;
+  }
+  if (normalizedModelRef.startsWith("llm-")) {
+    const parsed = parseFactoryDroidRouterModelId(normalizedModelRef);
+    return parsed?.routeRef
+      ? buildFactoryDroidRouterModelId(parsed.routeRef, { kind: parsed.kind })
+      : `custom:${normalizedModelRef}`;
+  }
+
+  const explicitKind = String(kind || "").trim().toLowerCase();
+  if (explicitKind === "alias") {
+    const aliasId = sanitizeFactoryDroidRouterModelIdPart(normalizedModelRef);
+    return aliasId ? `custom:llm-alias-${aliasId}` : "";
+  }
+
+  if (explicitKind === "model") {
+    const separatorIndex = normalizedModelRef.indexOf("/");
+    if (separatorIndex <= 0 || separatorIndex >= normalizedModelRef.length - 1) return "";
+    const providerId = normalizedModelRef.slice(0, separatorIndex).trim();
+    const modelId = normalizedModelRef.slice(separatorIndex + 1).trim();
+    const providerSlug = sanitizeFactoryDroidRouterModelIdPart(providerId);
+    const modelSlug = sanitizeFactoryDroidRouterModelIdPart(modelId);
+    return providerSlug && modelSlug ? `custom:llm-${providerSlug}-${modelSlug}` : "";
+  }
+
+  if (!normalizedModelRef.includes("/")) {
+    return buildFactoryDroidRouterModelId(normalizedModelRef, { kind: "alias" });
+  }
+
+  return buildFactoryDroidRouterModelId(normalizedModelRef, { kind: "model" });
+}
+
+export function buildFactoryDroidRouterDisplayName(modelRef, { kind = "" } = {}) {
+  const normalizedModelRef = String(modelRef || "").trim();
+  if (!normalizedModelRef) return "";
+
+  const explicitKind = String(kind || "").trim().toLowerCase();
+  const inferredKind = explicitKind || (normalizedModelRef.includes("/") ? "model" : "alias");
+  if (inferredKind === "alias") {
+    return `[LLM Alias] ${formatFactoryDroidDisplayNameBase(normalizedModelRef)}`;
+  }
+
+  const modelName = normalizedModelRef.includes("/")
+    ? normalizedModelRef.slice(normalizedModelRef.indexOf("/") + 1).trim()
+    : normalizedModelRef;
+  return `[LLM] ${formatFactoryDroidDisplayNameBase(modelName)}`;
+}
+
 export function normalizeFactoryDroidReasoningEffort(value) {
   const normalized = String(value || "").trim().toLowerCase();
   return FACTORY_DROID_REASONING_EFFORT_VALUES.includes(normalized) ? normalized : "";