@khanglvm/llm-router 2.0.0-beta.1 → 2.0.0

package/src/runtime/handler/request.js

@@ -3,11 +3,28 @@ import { extractAmpGeminiRouteInfo } from "./amp-gemini.js";
 import { toNonNegativeInteger } from "./utils.js";
 
 const DEFAULT_MAX_REQUEST_BODY_BYTES = 1 * 1024 * 1024;
+const DEFAULT_RESPONSES_MAX_REQUEST_BODY_BYTES = 8 * 1024 * 1024;
 const MIN_MAX_REQUEST_BODY_BYTES = 4 * 1024;
 const MAX_MAX_REQUEST_BODY_BYTES = 20 * 1024 * 1024;
 const DEFAULT_UPSTREAM_TIMEOUT_MS = 60_000;
 const MIN_UPSTREAM_TIMEOUT_MS = 1_000;
 const MAX_UPSTREAM_TIMEOUT_MS = 300_000;
+const DEFAULT_OUTPUT_TOKEN_RESERVE = 1_024;
+const AMP_ANTHROPIC_CONTEXT_BASELINE_TOKENS = 200_000;
+const AMP_ANTHROPIC_CONTEXT_1M_TOKENS = 1_000_000;
+const AMP_ANTHROPIC_CONTEXT_1M_BETA = "context-1m-2025-08-07";
+const AMP_CONTEXT_HINTS_BY_MODEL = new Map([
+  ["free", { minimumContextTokens: 136_000, source: "amp:model:free" }],
+  ["rush", { minimumContextTokens: 136_000, source: "amp:model:rush" }],
+  ["smart", { minimumContextTokens: 168_000, source: "amp:model:smart" }],
+  ["deep", { minimumContextTokens: 272_000, source: "amp:model:deep" }],
+  ["large", { minimumContextTokens: 936_000, source: "amp:model:large" }],
+  ["claude-haiku-4-5-20251001", { minimumContextTokens: 136_000, source: "amp:model:claude-haiku-4-5-20251001" }],
+  ["claude-opus-4-6", { minimumContextTokens: 168_000, source: "amp:model:claude-opus-4-6" }],
+  ["openai/gpt-5.3-codex", { minimumContextTokens: 272_000, source: "amp:model:openai/gpt-5.3-codex" }],
+  ["claude-sonnet-4-6", { minimumContextTokens: 936_000, source: "amp:model:claude-sonnet-4-6" }],
+  ["gpt-5.3-codex", { minimumContextTokens: 968_000, source: "amp:model:gpt-5.3-codex" }]
+]);
 const AMP_API_PROVIDER_PREFIX = "/api/provider/";
 const AMP_MANAGEMENT_ROOT_PREFIXES = [
   "/auth",
@@ -133,10 +150,14 @@ function resolveAmpProviderRoute(path, method) {
   return null;
 }
 
-export function resolveMaxRequestBodyBytes(env = {}) {
+export function resolveMaxRequestBodyBytes(env = {}, options = {}) {
+  const requestKind = String(options?.requestKind || "").trim().toLowerCase();
+  const fallbackLimit = requestKind === "responses"
+    ? DEFAULT_RESPONSES_MAX_REQUEST_BODY_BYTES
+    : DEFAULT_MAX_REQUEST_BODY_BYTES;
   const configured = toNonNegativeInteger(
     env?.LLM_ROUTER_MAX_REQUEST_BODY_BYTES,
-    DEFAULT_MAX_REQUEST_BODY_BYTES
+    fallbackLimit
   );
   return Math.min(
     MAX_MAX_REQUEST_BODY_BYTES,
@@ -162,6 +183,26 @@ function parseContentLength(value) {
   return parsed;
 }
 
+function parseNonNegativeNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) return 0;
+  return Math.floor(parsed);
+}
+
+function parseHeaderTokenList(value) {
+  if (!value) return [];
+  return String(value)
+    .split(",")
+    .map((entry) => entry.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function lookupAmpContextHint(model) {
+  const key = String(model || "").trim().toLowerCase();
+  if (!key) return null;
+  return AMP_CONTEXT_HINTS_BY_MODEL.get(key) || null;
+}
+
 function createRequestBodyTooLargeError(maxBytes) {
   const error = new Error(`Request body exceeds ${maxBytes} bytes.`);
   error.code = "REQUEST_BODY_TOO_LARGE";
@@ -210,6 +251,91 @@ export async function parseJsonBodyWithLimit(request, maxBytes) {
   return JSON.parse(raw);
 }
 
+export function estimateRequestContextTokens(body = {}) {
+  if (!body || typeof body !== "object") {
+    return {
+      estimatedInputTokens: 0,
+      requestedOutputTokens: 0,
+      safetyPaddingTokens: 0,
+      estimatedRequiredTokens: 0
+    };
+  }
+
+  let serialized = "";
+  try {
+    serialized = JSON.stringify(body) || "";
+  } catch {
+    serialized = "";
+  }
+
+  const charLength = serialized.length;
+  const byteLength = serialized
+    ? new TextEncoder().encode(serialized).byteLength
+    : 0;
+  const estimatedInputTokens = Math.max(
+    Math.ceil(charLength / 4),
+    Math.ceil(byteLength / 3)
+  );
+
+  const explicitOutputTokens = Math.max(
+    parseNonNegativeNumber(body?.max_output_tokens),
+    parseNonNegativeNumber(body?.max_completion_tokens),
+    parseNonNegativeNumber(body?.max_tokens)
+  );
+  const requestedOutputTokens = explicitOutputTokens > 0
+    ? explicitOutputTokens
+    : DEFAULT_OUTPUT_TOKEN_RESERVE;
+  const safetyPaddingTokens = estimatedInputTokens > 0
+    ? Math.max(256, Math.ceil(estimatedInputTokens * 0.1))
+    : 0;
+
+  return {
+    estimatedInputTokens,
+    requestedOutputTokens,
+    safetyPaddingTokens,
+    estimatedRequiredTokens: estimatedInputTokens + requestedOutputTokens + safetyPaddingTokens
+  };
+}
+
+export function inferAmpContextRequirement(request, body = {}, options = {}) {
+  if (String(options?.clientType || "").trim().toLowerCase() !== "amp") {
+    return {
+      minimumContextTokens: 0,
+      source: ""
+    };
+  }
+
+  const providerHint = String(options?.providerHint || "").trim().toLowerCase();
+  const requestKind = String(options?.requestKind || "").trim().toLowerCase();
+  const requestedModelHint = lookupAmpContextHint(body?.model);
+  const anthropicBetaFlags = parseHeaderTokenList(
+    request?.headers?.get("anthropic-beta") || request?.headers?.get("Anthropic-Beta")
+  );
+
+  if (anthropicBetaFlags.includes(AMP_ANTHROPIC_CONTEXT_1M_BETA)) {
+    return {
+      minimumContextTokens: AMP_ANTHROPIC_CONTEXT_1M_TOKENS,
+      source: `amp:anthropic-beta:${AMP_ANTHROPIC_CONTEXT_1M_BETA}`
+    };
+  }
+
+  if (requestedModelHint) {
+    return requestedModelHint;
+  }
+
+  if (providerHint === "anthropic" || requestKind === "messages") {
+    return {
+      minimumContextTokens: AMP_ANTHROPIC_CONTEXT_BASELINE_TOKENS,
+      source: "amp:anthropic-route:200k-baseline"
+    };
+  }
+
+  return {
+    minimumContextTokens: 0,
+    source: ""
+  };
+}
+
 export function isJsonRequest(request) {
   const contentType = String(request.headers.get("content-type") || "").toLowerCase();
   return contentType.includes("application/json") || contentType.includes("+json");

package/src/runtime/handler/route-debug.js

@@ -41,6 +41,9 @@ export function buildRouteDebugState(enabled, resolved) {
     selectedCandidate: "",
     skippedCandidates: [],
     attempts: [],
+    contextRequiredTokens: "",
+    contextHintSource: "",
+    contextRisk: "",
     toolTypes: "",
     toolRouting: ""
   };
@@ -81,6 +84,24 @@ export function setRouteToolDebug(debugState, toolTypes, toolRouting = "") {
   debugState.toolRouting = String(toolRouting || "").trim();
 }
 
+export function setRouteContextDebug(debugState, { requiredTokens, hintSource, risk } = {}) {
+  if (!debugState?.enabled) return;
+
+  const normalizedRequiredTokens = Number(requiredTokens);
+  if (Number.isFinite(normalizedRequiredTokens) && normalizedRequiredTokens > 0) {
+    debugState.contextRequiredTokens = String(Math.floor(normalizedRequiredTokens));
+  }
+
+  const normalizedHintSource = String(hintSource || "").trim();
+  if (normalizedHintSource) {
+    debugState.contextHintSource = normalizedHintSource;
+  }
+
+  if (risk !== undefined) {
+    debugState.contextRisk = String(risk || "").trim();
+  }
+}
+
 export function withRouteDebugHeaders(response, debugState) {
   if (!debugState?.enabled || !(response instanceof Response)) {
     return response;
@@ -107,6 +128,21 @@ export function withRouteDebugHeaders(response, debugState) {
     headers.set("x-llm-router-attempts", attempts);
   }
 
+  const contextRequiredTokens = toSafeHeaderValue(debugState.contextRequiredTokens);
+  if (contextRequiredTokens) {
+    headers.set("x-llm-router-context-required", contextRequiredTokens);
+  }
+
+  const contextHintSource = toSafeHeaderValue(debugState.contextHintSource);
+  if (contextHintSource) {
+    headers.set("x-llm-router-context-hint-source", contextHintSource);
+  }
+
+  const contextRisk = toSafeHeaderValue(debugState.contextRisk);
+  if (contextRisk) {
+    headers.set("x-llm-router-context-risk", contextRisk);
+  }
+
   const toolTypes = toSafeHeaderValue(debugState.toolTypes);
   if (toolTypes) {
     headers.set("x-llm-router-tool-types", toolTypes);

package/src/runtime/handler.js

@@ -23,6 +23,8 @@ import {
 import { corsResponse, jsonResponse } from "./handler/http.js";
 import {
   detectUserRequestFormat,
+  estimateRequestContextTokens,
+  inferAmpContextRequirement,
   isAmpManagementPath,
   isJsonRequest,
   isStreamingEnabled,
@@ -43,6 +45,7 @@ import {
   convertAmpGeminiRequestToOpenAI,
   hasGeminiWebSearchTool
 } from "./handler/amp-gemini.js";
+import { shouldInterceptAmpWebSearch } from "./handler/amp-web-search.js";
 import {
   isRequestFromAllowedIp,
   resolveAllowedOrigin,
@@ -55,7 +58,7 @@ import {
   resolveFallbackCircuitPolicy,
   resolveRetryPolicy
 } from "./handler/fallback.js";
-import { sleep } from "./handler/utils.js";
+import { parseJsonSafely, sleep } from "./handler/utils.js";
 import {
   applyCandidateFailureState,
   applyRuntimeRetryPolicyGuards,
@@ -68,6 +71,7 @@ import {
   isRoutingDebugEnabled,
   recordRouteAttempt,
   recordRouteSkip,
+  setRouteContextDebug,
   setRouteSelectedCandidate,
   setRouteToolDebug,
   withRouteDebugHeaders
@@ -96,13 +100,6 @@ function filterCandidatesByFormat(candidates) {
   return { eligible, skipped };
 }
 
-function hasNextEligibleCandidate(entries, startIndex) {
-  for (let index = startIndex + 1; index < (entries || []).length; index += 1) {
-    if (entries[index]?.eligible) return true;
-  }
-  return false;
-}
-
 function extractBuiltInToolTypes(body) {
   const tools = Array.isArray(body?.tools) ? body.tools : [];
   const seen = new Set();
@@ -161,11 +158,111 @@ function isChatGPTCodexCandidate(candidate) {
   return subscriptionType === "chatgpt-codex";
 }
 
+function resolveCandidateContextWindow(candidate) {
+  const raw = candidate?.contextWindow ?? candidate?.model?.contextWindow;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return Math.floor(parsed);
+}
+
+function resolveSelectedContextRisk(candidate, estimatedRequiredTokens) {
+  const requiredTokens = Number(estimatedRequiredTokens);
+  if (!candidate || !Number.isFinite(requiredTokens) || requiredTokens <= 0) return "";
+
+  const contextWindow = resolveCandidateContextWindow(candidate);
+  if (!contextWindow) {
+    return "selected-context-window-unknown";
+  }
+  if (contextWindow < requiredTokens) {
+    return `selected-context-window-below-required:${contextWindow}<${requiredTokens}`;
+  }
+  return "";
+}
+
 const WEB_SEARCH_UNAVAILABLE_HINTS = [
   "web search credits are unavailable in this session",
   "web access unavailable (out of credits)",
   "web access unavailable"
 ];
+const ACTIVITY_LOG_ERROR_DETAIL_MAX_CHARS = 240;
+
+function queueActivityEvent(onActivityLog, payload) {
+  if (typeof onActivityLog !== "function") return;
+  try {
+    const result = onActivityLog(payload);
+    if (result && typeof result.then === "function") {
+      result.catch(() => {});
+    }
+  } catch {
+  }
+}
+
+function getNextEligibleCandidateEntry(entries, startIndex) {
+  for (let index = startIndex + 1; index < (entries || []).length; index += 1) {
+    if (entries[index]?.eligible) return entries[index];
+  }
+  return null;
+}
+
+function formatActivityCandidateLabel(candidate) {
+  const providerId = String(candidate?.providerId || "unknown").trim() || "unknown";
+  const modelId = String(candidate?.modelId || candidate?.backend || "unknown").trim() || "unknown";
+  return `${providerId}/${modelId}`;
+}
+
+function formatActivityRouteLabel(requestedModel, resolved) {
+  const requested = String(requestedModel || "").trim() || "smart";
+  const routeRef = String(resolved?.routeRef || "").trim();
+  return routeRef && routeRef !== requested ? `${requested} -> ${routeRef}` : (routeRef || requested);
+}
+
+function formatFailureCategory(category) {
+  return String(category || "")
+    .trim()
+    .replace(/_/g, " ");
+}
+
+function buildFailureSummary(result, classification) {
+  const parts = [];
+  const status = Number.isFinite(result?.status) ? Number(result.status) : 0;
+  if (status > 0) parts.push(`status ${status}`);
+  const category = formatFailureCategory(classification?.category);
+  if (category) parts.push(category);
+  return parts.join(" · ") || "request failed";
+}
+
+function buildActivityDetail(baseMessage, providerMessage = "") {
+  const detail = String(providerMessage || "").trim();
+  if (!detail) return baseMessage;
+  return `${baseMessage} Provider said: ${detail}`;
+}
+
+async function readActivityErrorDetail(result) {
+  const response = result?.upstreamResponse instanceof Response
+    ? result.upstreamResponse
+    : (result?.response instanceof Response ? result.response : null);
+  if (!(response instanceof Response)) return "";
+
+  try {
+    const raw = (await response.clone().text()).trim();
+    if (!raw) return "";
+    const parsed = parseJsonSafely(raw, null);
+    const message = parsed?.error?.message
+      || parsed?.error?.code
+      || parsed?.error?.type
+      || parsed?.error
+      || parsed?.code
+      || parsed?.type
+      || parsed?.message
+      || raw;
+    const compact = String(message || "").replace(/\s+/g, " ").trim();
+    if (!compact) return "";
+    if (compact.length <= ACTIVITY_LOG_ERROR_DETAIL_MAX_CHARS) return compact;
+    return `${compact.slice(0, ACTIVITY_LOG_ERROR_DETAIL_MAX_CHARS - 1)}…`;
+  } catch {
+    return "";
+  }
+}
 
 function extractAssistantTextFragments(payload) {
   const fragments = [];
@@ -340,7 +437,9 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
     return jsonResponse({ error: "Unsupported Media Type. Use application/json." }, 415);
   }
 
-  const maxRequestBodyBytes = resolveMaxRequestBodyBytes(env);
+  const maxRequestBodyBytes = resolveMaxRequestBodyBytes(env, {
+    requestKind: options.requestKind
+  });
   let body;
   try {
     body = await parseJsonBodyWithLimit(request, maxRequestBodyBytes);
@@ -359,7 +458,14 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
   const requestedModel = body?.model || "smart";
   const stream = isStreamingEnabled(sourceFormat, body);
 
-  if (shouldProxyAmpWebSearchRequest(options.clientType, builtInToolTypes, config)) {
+  const interceptAmpWebSearch = shouldInterceptAmpWebSearch({
+    clientType: options.clientType,
+    originalBody: body,
+    runtimeConfig: config,
+    env
+  });
+
+  if (!interceptAmpWebSearch && shouldProxyAmpWebSearchRequest(options.clientType, builtInToolTypes, config)) {
     const routeDebug = buildAmpWebSearchProxyDebugState(env, requestedModel, builtInToolTypes);
     if (routeDebug.enabled) {
       console.warn(
@@ -415,6 +521,30 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
     ...resolved,
     sourceFormat
   };
+  const routeLabel = formatActivityRouteLabel(requestedModel, resolved);
+  const requestContext = estimateRequestContextTokens(body);
+  const ampContextRequirement = inferAmpContextRequirement(request, body, options);
+  const effectiveRequiredTokens = Math.max(
+    Number(requestContext?.estimatedRequiredTokens) || 0,
+    Number(ampContextRequirement?.minimumContextTokens) || 0
+  );
+  const effectiveRequestContext = {
+    ...requestContext,
+    ampMinimumContextTokens: Number(ampContextRequirement?.minimumContextTokens) || 0,
+    ampContextSource: String(ampContextRequirement?.source || "").trim(),
+    estimatedRequiredTokens: effectiveRequiredTokens
+  };
+  setRouteContextDebug(routeDebug, {
+    requiredTokens: effectiveRequiredTokens,
+    hintSource: effectiveRequiredTokens > (Number(requestContext?.estimatedRequiredTokens) || 0)
+      ? ampContextRequirement?.source || "request-context-hint"
+      : (effectiveRequiredTokens > 0 ? "request-body-estimate" : "")
+  });
+  if (routeDebug.enabled && effectiveRequestContext.ampContextSource) {
+    console.warn(
+      `[llm-router] context hint request=${requestedModel} source=${effectiveRequestContext.ampContextSource} required=${effectiveRequiredTokens}`
+    );
+  }
   const routeCandidates = [resolved.primary, ...resolved.fallbacks];
   const formatFiltered = filterCandidatesByFormat(routeCandidates);
   for (const skipped of formatFiltered.skipped) {
@@ -449,6 +579,7 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
       candidates: prioritizedCandidates.candidates,
       stateStore,
       config,
+      requestContext: effectiveRequestContext,
       now
     });
   } catch (error) {
@@ -463,6 +594,12 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
 
   routeDebug.strategy = ranking.strategy;
   setRouteSelectedCandidate(routeDebug, ranking.selectedEntry?.candidate);
+  setRouteContextDebug(routeDebug, {
+    risk: resolveSelectedContextRisk(
+      ranking.selectedEntry?.candidate,
+      effectiveRequestContext.estimatedRequiredTokens
+    )
+  });
   for (const skippedEntry of (ranking.skippedEntries || [])) {
     recordRouteSkip(routeDebug, skippedEntry.candidate, skippedEntry.skipReasons);
   }
@@ -480,6 +617,7 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
   let lastErrorResult = null;
   let lastErrorMessage = "Unknown error";
   let routeSelectionCommitted = false;
+  let pendingFallbackContext = null;
 
   for (let index = 0; index < ranking.entries.length; index += 1) {
     const entry = ranking.entries[index];
@@ -505,14 +643,16 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
     while (attempt < maxAttempts) {
       attempt += 1;
       result = await makeProviderCall({
-      body,
-      sourceFormat,
-      stream,
-      requestKind: options.requestKind,
-      candidate,
-      requestHeaders: request.headers,
-      env,
-      clientType: options.clientType
+        body,
+        sourceFormat,
+        stream,
+        requestKind: options.requestKind,
+        candidate,
+        requestHeaders: request.headers,
+        env,
+        clientType: options.clientType,
+        runtimeConfig: config,
+        stateStore
       });
 
       if (!quotaConsumed && shouldConsumeQuotaFromResult(result)) {
@@ -538,7 +678,22 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
         }
         await clearCandidateRoutingState(stateStore, entry.candidateKey);
         setRouteSelectedCandidate(routeDebug, candidate, { overwrite: true });
+        setRouteContextDebug(routeDebug, {
+          risk: resolveSelectedContextRisk(candidate, effectiveRequestContext.estimatedRequiredTokens)
+        });
         recordRouteAttempt(routeDebug, candidate, result.status, null, attempt);
+        if (pendingFallbackContext) {
+          queueActivityEvent(options.onActivityLog, {
+            level: "success",
+            message: `Fallback request succeeded for ${routeLabel}.`,
+            detail: `${formatActivityCandidateLabel(candidate)} completed the request after ${pendingFallbackContext.failedCandidate} failed (${pendingFallbackContext.failureSummary}).`,
+            source: "runtime",
+            category: "usage",
+            kind: "fallback-succeeded",
+            route: routeLabel
+          });
+          pendingFallbackContext = null;
+        }
         return withRouteDebugHeaders(result.response, routeDebug);
       }
 
@@ -571,8 +726,41 @@ async function handleRouteRequest(request, env, getConfig, sourceFormatHint, opt
       isFallbackAttempt
     );
 
-    const hasNextCandidate = hasNextEligibleCandidate(ranking.entries, index);
+    const nextCandidateEntry = getNextEligibleCandidateEntry(ranking.entries, index);
+    const hasNextCandidate = Boolean(nextCandidateEntry);
+    const failureSummary = buildFailureSummary(result, classification);
+    const providerMessage = await readActivityErrorDetail(result);
+    if (hasNextCandidate && classification?.allowFallback !== false) {
+      queueActivityEvent(options.onActivityLog, {
+        level: "warn",
+        message: `Request fallback triggered for ${routeLabel}.`,
+        detail: buildActivityDetail(
+          `${formatActivityCandidateLabel(candidate)} failed (${failureSummary}). Trying ${formatActivityCandidateLabel(nextCandidateEntry?.candidate)} next.`,
+          providerMessage
+        ),
+        source: "runtime",
+        category: "usage",
+        kind: "fallback-triggered",
+        route: routeLabel
+      });
+      pendingFallbackContext = {
+        failedCandidate: formatActivityCandidateLabel(candidate),
+        failureSummary
+      };
+    }
     if (!hasNextCandidate || classification?.allowFallback === false) {
+      queueActivityEvent(options.onActivityLog, {
+        level: "error",
+        message: `Request failed for ${routeLabel}.`,
+        detail: buildActivityDetail(
+          `${formatActivityCandidateLabel(candidate)} failed (${failureSummary})${classification?.allowFallback === false ? ". Fallback stopped for this error." : ". No more fallbacks are available."}`,
+          providerMessage
+        ),
+        source: "runtime",
+        category: "usage",
+        kind: "request-failed",
+        route: routeLabel
+      });
       return withRouteDebugHeaders(await buildFailureResponse(result), routeDebug);
     }
   }
@@ -779,7 +967,9 @@ export function createFetchHandler(options) {
 
       let body;
       try {
-        body = await parseJsonBodyWithLimit(request, resolveMaxRequestBodyBytes(env));
+        body = await parseJsonBodyWithLimit(request, resolveMaxRequestBodyBytes(env, {
+          requestKind: route.requestKind
+        }));
       } catch (error) {
         if (error && typeof error === "object" && error.code === "REQUEST_BODY_TOO_LARGE") {
           return respond(jsonResponse({ error: "Request body too large" }, 413));

package/src/runtime/subscription-provider.js

@@ -142,7 +142,7 @@ export async function makeSubscriptionProviderCall({ provider, body, stream }) {
         type: 'error',
         error: {
           type: 'authentication_error',
-          message: `Not authenticated for subscription profile '${profileId}'. Run 'llm-router subscription login --profile=${profileId}' first.`
+          message: `Not authenticated for subscription profile '${profileId}'. Run 'llr subscription login --profile=${profileId}' first.`
         }
       }), {
         status: 401,

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

@@ -0,0 +1,49 @@
+export const CODEX_CLI_INHERIT_MODEL_VALUE = "__codex_cli_inherit__";
+export const CODEX_CLI_REASONING_EFFORT_VALUES = Object.freeze([
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+]);
+export const CLAUDE_CODE_THINKING_LEVEL_VALUES = Object.freeze([
+  "low",
+  "medium",
+  "high",
+  "max"
+]);
+export const CLAUDE_CODE_THINKING_TOKENS_BY_LEVEL = Object.freeze({
+  low: 4096,
+  medium: 12000,
+  high: 24000,
+  max: 31999
+});
+
+export function isCodexCliInheritModelBinding(value) {
+  return String(value || "").trim() === CODEX_CLI_INHERIT_MODEL_VALUE;
+}
+
+export function normalizeCodexCliReasoningEffort(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  return CODEX_CLI_REASONING_EFFORT_VALUES.includes(normalized) ? normalized : "";
+}
+
+export function normalizeClaudeCodeThinkingLevel(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  return CLAUDE_CODE_THINKING_LEVEL_VALUES.includes(normalized) ? normalized : "";
+}
+
+export function mapClaudeCodeThinkingLevelToTokens(level) {
+  const normalizedLevel = normalizeClaudeCodeThinkingLevel(level);
+  if (!normalizedLevel) return "";
+  return String(CLAUDE_CODE_THINKING_TOKENS_BY_LEVEL[normalizedLevel] || "");
+}
+
+export function mapClaudeCodeThinkingTokensToLevel(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return "";
+  if (parsed >= CLAUDE_CODE_THINKING_TOKENS_BY_LEVEL.max) return "max";
+  if (parsed >= CLAUDE_CODE_THINKING_TOKENS_BY_LEVEL.high) return "high";
+  if (parsed >= 6000) return "medium";
+  return "low";
+}