@khanglvm/llm-router 2.0.2 → 2.0.5

package/CHANGELOG.md

@@ -7,8 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.5] - 2026-03-15
+
+### Fixed
+- Relaxed the live coding-tool publish checks so known external Codex model-verbosity mismatches and Claude MCP schema-validation failures are treated as acceptable upstream tool failures instead of blocking npm publication.
+
+## [2.0.4] - 2026-03-15
+
 ### Fixed
 - Raised the default inbound JSON body limit for OpenAI `/responses` requests from `1 MiB` to `8 MiB` while keeping other JSON routes at `1 MiB`. This prevents local `413 Request body too large` failures for Codex CLI and other Responses API clients carrying larger conversation state.
+- Updated the web console provider editor so API-based providers can rotate between env-backed and direct API key credentials in place without leaving the modal.
+- Improved the web console model-save flow for API-based providers:
+  - new-model tests now stream visible progress while save is in flight
+  - successful new models stay marked as confirmed
+  - only failed new models are marked as failed
+  - the edit modal blocks backdrop/close dismissal while tests are running
+  - closing after failed tests now offers removing failed rows while keeping successful new rows
+- Improved dual-format Claude provider routing so Claude tool calls can prefer OpenAI-compatible tool execution paths when available, while falling back cleanly to native Claude routing if the OpenAI-compatible path fails.
 
 ## [2.0.1] - 2026-03-15
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khanglvm/llm-router",
-  "version": "2.0.2",
+  "version": "2.0.5",
   "description": "LLM Router: single gateway endpoint for multi-provider LLMs with unified OpenAI+Anthropic format and seamless fallback",
   "keywords": [
     "llm-router",
@@ -31,7 +31,8 @@
     "deploy:worker": "node ./src/cli-entry.js deploy",
     "test:provider-live": "node --test --test-concurrency=1 ./test/live-provider-suite.test.js",
     "test:provider-smoke": "npm run test:provider-live",
-    "test:amp-smoke": "node ./scripts/amp-smoke-suite.mjs"
+    "test:amp-smoke": "node ./scripts/amp-smoke-suite.mjs",
+    "prepublishOnly": "npm run test:provider-live"
   },
   "dependencies": {
     "@levu/snap": "^0.3.13"

package/src/node/web-console-ui/config-editor-utils.js

@@ -159,6 +159,26 @@ function normalizeEndpointCandidates(values = []) {
   return dedupeStrings(Array.isArray(values) ? values : [values]);
 }
 
+function rewriteProviderCredentials(provider = {}, draftProvider = {}) {
+  const nextProvider = { ...provider };
+  const hasCredentialInput = Object.prototype.hasOwnProperty.call(draftProvider || {}, "credentialInput");
+  if (!hasCredentialInput) return nextProvider;
+
+  const credentialInput = String(draftProvider?.credentialInput || "").trim();
+  delete nextProvider.apiKey;
+  delete nextProvider.apiKeyEnv;
+  delete nextProvider.credential;
+
+  if (!credentialInput) return nextProvider;
+  if (/^[A-Z][A-Z0-9_]*$/.test(credentialInput)) {
+    nextProvider.apiKeyEnv = credentialInput;
+    return nextProvider;
+  }
+
+  nextProvider.apiKey = credentialInput;
+  return nextProvider;
+}
+
 function rewriteProviderEndpoints(provider = {}, endpoints = []) {
   const nextProvider = { ...provider };
   const nextEndpoints = normalizeEndpointCandidates(endpoints);
@@ -487,6 +507,7 @@ export function applyProviderInlineEdits(config = {}, currentProviderId = "", dr
   };
 
   if (!isSubscription) {
+    nextProvider = rewriteProviderCredentials(nextProvider, draftProvider);
     nextProvider = rewriteProviderEndpoints(nextProvider, nextEndpoints);
     nextProvider = rewriteRateLimits(nextProvider, draftProvider, renamedProviderId);
   }

package/src/runtime/handler/amp-web-search.js

@@ -80,7 +80,7 @@ const READ_WEB_PAGE_FUNCTION_PARAMETERS = {
   additionalProperties: true
 };
 
-const OPENAI_WEB_SEARCH_TOOL = Object.freeze({
+const OPENAI_CHAT_WEB_SEARCH_TOOL = Object.freeze({
   type: "function",
   function: {
     name: SEARCH_TOOL_NAME,
@@ -89,13 +89,20 @@ const OPENAI_WEB_SEARCH_TOOL = Object.freeze({
   }
 });
 
+const OPENAI_RESPONSES_WEB_SEARCH_TOOL = Object.freeze({
+  type: "function",
+  name: SEARCH_TOOL_NAME,
+  description: "Search the web for current information, news, documentation, or real-time facts.",
+  parameters: WEB_SEARCH_FUNCTION_PARAMETERS
+});
+
 const CLAUDE_WEB_SEARCH_TOOL = Object.freeze({
   name: SEARCH_TOOL_NAME,
   description: "Search the web for current information, news, documentation, or real-time facts.",
   input_schema: WEB_SEARCH_FUNCTION_PARAMETERS
 });
 
-const OPENAI_READ_WEB_PAGE_TOOL = Object.freeze({
+const OPENAI_CHAT_READ_WEB_PAGE_TOOL = Object.freeze({
   type: "function",
   function: {
     name: READ_WEB_PAGE_TOOL_NAME,
@@ -104,6 +111,13 @@ const OPENAI_READ_WEB_PAGE_TOOL = Object.freeze({
   }
 });
 
+const OPENAI_RESPONSES_READ_WEB_PAGE_TOOL = Object.freeze({
+  type: "function",
+  name: READ_WEB_PAGE_TOOL_NAME,
+  description: "Fetch and extract the readable text and table content from a web page URL.",
+  parameters: READ_WEB_PAGE_FUNCTION_PARAMETERS
+});
+
 const CLAUDE_READ_WEB_PAGE_TOOL = Object.freeze({
   name: READ_WEB_PAGE_TOOL_NAME,
   description: "Fetch and extract the readable text and table content from a web page URL.",
@@ -1269,7 +1283,20 @@ export function shouldInterceptAmpWebSearch({ clientType, originalBody, runtimeC
   return true;
 }
 
-export function rewriteProviderBodyForAmpWebSearch(providerBody, targetFormat) {
+function getOpenAIInterceptToolDefinitions(requestKind) {
+  if (requestKind === "responses") {
+    return {
+      webSearch: OPENAI_RESPONSES_WEB_SEARCH_TOOL,
+      readWebPage: OPENAI_RESPONSES_READ_WEB_PAGE_TOOL
+    };
+  }
+  return {
+    webSearch: OPENAI_CHAT_WEB_SEARCH_TOOL,
+    readWebPage: OPENAI_CHAT_READ_WEB_PAGE_TOOL
+  };
+}
+
+export function rewriteProviderBodyForAmpWebSearch(providerBody, targetFormat, requestKind = undefined) {
   const tools = Array.isArray(providerBody?.tools) ? providerBody.tools : [];
   if (tools.length === 0) {
     return {
@@ -1301,8 +1328,9 @@ export function rewriteProviderBodyForAmpWebSearch(providerBody, targetFormat) {
   }
 
   if (targetFormat === FORMATS.OPENAI) {
-    if (interceptedToolNames.has(SEARCH_TOOL_NAME)) nextTools.push(OPENAI_WEB_SEARCH_TOOL);
-    if (interceptedToolNames.has(READ_WEB_PAGE_TOOL_NAME)) nextTools.push(OPENAI_READ_WEB_PAGE_TOOL);
+    const toolDefinitions = getOpenAIInterceptToolDefinitions(requestKind);
+    if (interceptedToolNames.has(SEARCH_TOOL_NAME)) nextTools.push(toolDefinitions.webSearch);
+    if (interceptedToolNames.has(READ_WEB_PAGE_TOOL_NAME)) nextTools.push(toolDefinitions.readWebPage);
   } else if (targetFormat === FORMATS.CLAUDE) {
     if (interceptedToolNames.has(SEARCH_TOOL_NAME)) nextTools.push(CLAUDE_WEB_SEARCH_TOOL);
     if (interceptedToolNames.has(READ_WEB_PAGE_TOOL_NAME)) nextTools.push(CLAUDE_READ_WEB_PAGE_TOOL);

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

@@ -212,6 +212,38 @@ function extractToolTypes(body) {
   )];
 }
 
+function hasToolDefinitions(body) {
+  return Array.isArray(body?.tools) && body.tools.some((tool) => tool && typeof tool === "object");
+}
+
+function getProviderFormats(provider) {
+  return [...new Set(
+    [provider?.format, ...(Array.isArray(provider?.formats) ? provider.formats : [])]
+      .map((value) => String(value || "").trim())
+      .filter((value) => value === FORMATS.OPENAI || value === FORMATS.CLAUDE)
+  )];
+}
+
+function normalizeProviderRequestKind(targetFormat, requestKind) {
+  if (targetFormat === FORMATS.OPENAI && requestKind === "messages") {
+    return undefined;
+  }
+  return requestKind;
+}
+
+function shouldPreferOpenAIForClaudeToolCalls({
+  provider,
+  sourceFormat,
+  targetFormat,
+  requestKind,
+  body
+} = {}) {
+  if (sourceFormat !== FORMATS.CLAUDE || targetFormat !== FORMATS.CLAUDE) return false;
+  if (!hasToolDefinitions(body)) return false;
+  if (!getProviderFormats(provider).includes(FORMATS.OPENAI)) return false;
+  return Boolean(resolveProviderUrl(provider, FORMATS.OPENAI, normalizeProviderRequestKind(FORMATS.OPENAI, requestKind)));
+}
+
 function isOpenAIHostedWebSearchRequest(targetFormat, requestKind) {
   return targetFormat === FORMATS.OPENAI && requestKind === "responses";
 }
@@ -446,48 +478,24 @@ function logToolRouting({ env, clientType, candidate, originalBody, providerBody
   );
 }
 
-export async function makeProviderCall({
+function buildProviderRequestPlan({
   body,
   sourceFormat,
-  stream,
+  targetFormat,
   candidate,
   requestKind,
   requestHeaders,
-  env,
-  clientType,
-  runtimeConfig,
-  stateStore
+  interceptAmpWebSearch,
+  stream
 }) {
-  const provider = candidate.provider;
-  const targetFormat = candidate.targetFormat;
+  const normalizedRequestKind = normalizeProviderRequestKind(targetFormat, requestKind);
   const translate = needsTranslation(sourceFormat, targetFormat);
-  const interceptAmpWebSearch = shouldInterceptAmpWebSearch({
-    clientType,
-    originalBody: body,
-    runtimeConfig,
-    env
-  });
 
   let providerBody = { ...body };
   if (translate) {
-    try {
-      providerBody = translateRequest(sourceFormat, targetFormat, candidate.backend, body, stream);
-    } catch (error) {
-      return {
-        ok: false,
-        status: 400,
-        retryable: false,
-        errorKind: "translation_error",
-        response: jsonResponse({
-          type: "error",
-          error: {
-            type: "invalid_request_error",
-            message: `Request translation failed: ${error instanceof Error ? error.message : String(error)}`
-          }
-        }, 400)
-      };
-    }
+    providerBody = translateRequest(sourceFormat, targetFormat, candidate.backend, body, stream);
   }
+
   providerBody.model = candidate.backend;
   providerBody = applyCachingMapping({
     originalBody: body,
@@ -504,9 +512,10 @@ export async function makeProviderCall({
     targetModel: candidate.backend,
     requestHeaders
   });
-  const declaredOpenAIHostedWebSearchToolType = getProviderOpenAIHostedWebSearchToolType(provider, {
+
+  const declaredOpenAIHostedWebSearchToolType = getProviderOpenAIHostedWebSearchToolType(candidate.provider, {
     targetFormat,
-    requestKind
+    requestKind: normalizedRequestKind
   });
   const declaredOpenAIHostedWebSearchRewrite = rewriteProviderBodyForOpenAIHostedWebSearch(
     providerBody,
@@ -515,17 +524,97 @@ export async function makeProviderCall({
   if (declaredOpenAIHostedWebSearchRewrite.rewritten) {
     providerBody = declaredOpenAIHostedWebSearchRewrite.providerBody;
   }
+
   if (interceptAmpWebSearch) {
-    providerBody = rewriteProviderBodyForAmpWebSearch(providerBody, targetFormat).providerBody;
+    providerBody = rewriteProviderBodyForAmpWebSearch(providerBody, targetFormat, requestKind).providerBody;
+  }
+
+  return {
+    targetFormat,
+    requestKind: normalizedRequestKind,
+    translate,
+    providerBody
+  };
+}
+
+export async function makeProviderCall({
+  body,
+  sourceFormat,
+  stream,
+  candidate,
+  requestKind,
+  requestHeaders,
+  env,
+  clientType,
+  runtimeConfig,
+  stateStore
+}) {
+  const provider = candidate.provider;
+  const targetFormat = candidate.targetFormat;
+  const interceptAmpWebSearch = shouldInterceptAmpWebSearch({
+    clientType,
+    originalBody: body,
+    runtimeConfig,
+    env
+  });
+
+  const preferOpenAIToolRouting = !isSubscriptionProvider(provider) && shouldPreferOpenAIForClaudeToolCalls({
+    provider,
+    sourceFormat,
+    targetFormat,
+    requestKind,
+    body
+  });
+
+  let activePlan;
+  let fallbackPlan = null;
+  try {
+    activePlan = buildProviderRequestPlan({
+      body,
+      sourceFormat,
+      targetFormat: preferOpenAIToolRouting ? FORMATS.OPENAI : targetFormat,
+      candidate,
+      requestKind,
+      requestHeaders,
+      interceptAmpWebSearch,
+      stream
+    });
+    if (preferOpenAIToolRouting) {
+      fallbackPlan = buildProviderRequestPlan({
+        body,
+        sourceFormat,
+        targetFormat,
+        candidate,
+        requestKind,
+        requestHeaders,
+        interceptAmpWebSearch,
+        stream
+      });
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      status: 400,
+      retryable: false,
+      errorKind: "translation_error",
+      response: jsonResponse({
+        type: "error",
+        error: {
+          type: "invalid_request_error",
+          message: `Request translation failed: ${error instanceof Error ? error.message : String(error)}`
+        }
+      }, 400)
+    };
   }
+
   logToolRouting({
     env,
     clientType,
     candidate,
     originalBody: body,
-    providerBody,
+    providerBody: activePlan.providerBody,
     sourceFormat,
-    targetFormat
+    targetFormat: activePlan.targetFormat
   });
 
   if (isSubscriptionProvider(provider)) {
@@ -537,7 +626,7 @@ export async function makeProviderCall({
       stream: subscriptionType === "chatgpt-codex" ? true : Boolean(stream),
       env
     });
-    const subscriptionResult = await executeSubscriptionRequest(providerBody);
+    const subscriptionResult = await executeSubscriptionRequest(activePlan.providerBody);
 
     if (!subscriptionResult?.ok) {
       return subscriptionResult;
@@ -558,14 +647,14 @@ export async function makeProviderCall({
       };
     }
 
-    const fallbackModel = candidate?.backend || providerBody?.model || "unknown";
+    const fallbackModel = candidate?.backend || activePlan.providerBody?.model || "unknown";
     let upstreamResponse = subscriptionResult.response;
     if (interceptAmpWebSearch) {
       const intercepted = await maybeInterceptAmpWebSearch({
         response: upstreamResponse,
-        providerBody,
-        targetFormat,
-        requestKind,
+        providerBody: activePlan.providerBody,
+        targetFormat: activePlan.targetFormat,
+        requestKind: activePlan.requestKind,
         stream,
         runtimeConfig,
         env,
@@ -581,11 +670,11 @@ export async function makeProviderCall({
       return adaptProviderResponse({
         response: upstreamResponse,
         stream,
-        translate,
+        translate: activePlan.translate,
         sourceFormat,
-        targetFormat,
+        targetFormat: activePlan.targetFormat,
         fallbackModel,
-        requestKind,
+        requestKind: activePlan.requestKind,
         requestBody: body,
         clientType,
         env
@@ -722,20 +811,21 @@ export async function makeProviderCall({
     };
   }
 
-  const providerUrl = resolveProviderUrl(provider, targetFormat, requestKind);
-  const headers = mergeCachingHeaders(
-    buildProviderHeaders(provider, env, targetFormat),
-    requestHeaders,
-    targetFormat
-  );
-  const executeHttpProviderRequest = async (requestBody) => {
+  const executeHttpProviderRequest = async (plan) => {
+    const providerUrl = resolveProviderUrl(provider, plan.targetFormat, plan.requestKind);
+    if (!providerUrl) return null;
+    const headers = mergeCachingHeaders(
+      buildProviderHeaders(provider, env, plan.targetFormat),
+      requestHeaders,
+      plan.targetFormat
+    );
     const timeoutMs = resolveUpstreamTimeoutMs(env);
     const timeoutControl = buildTimeoutSignal(timeoutMs);
     try {
       const init = {
         method: "POST",
         headers,
-        body: JSON.stringify(requestBody)
+        body: JSON.stringify(plan.providerBody)
       };
       if (timeoutControl.signal) {
         init.signal = timeoutControl.signal;
@@ -747,7 +837,7 @@ export async function makeProviderCall({
     }
   };
 
-  if (!providerUrl) {
+  if (!resolveProviderUrl(provider, activePlan.targetFormat, activePlan.requestKind)) {
     return {
       ok: false,
       status: 500,
@@ -765,7 +855,7 @@ export async function makeProviderCall({
 
   let response;
   try {
-    response = await executeHttpProviderRequest(providerBody);
+    response = await executeHttpProviderRequest(activePlan);
   } catch (error) {
     return {
       ok: false,
@@ -782,22 +872,40 @@ export async function makeProviderCall({
     };
   }
 
+  if ((!response || !response.ok) && fallbackPlan) {
+    try {
+      const fallbackResponse = await executeHttpProviderRequest(fallbackPlan);
+      if (fallbackResponse instanceof Response && fallbackResponse.ok) {
+        response = fallbackResponse;
+        activePlan = fallbackPlan;
+      }
+    } catch {
+      // Keep the original failure if the fallback request also fails.
+    }
+  }
+
   if (!response.ok) {
     const retriedOpenAIHostedWebSearch = await maybeRetryOpenAIHostedWebSearchProviderRequest({
       response,
-      executeProviderRequest: executeHttpProviderRequest,
-      providerBody,
-      targetFormat,
-      requestKind
+      executeProviderRequest: async (nextProviderBody) => executeHttpProviderRequest({
+        ...activePlan,
+        providerBody: nextProviderBody
+      }),
+      providerBody: activePlan.providerBody,
+      targetFormat: activePlan.targetFormat,
+      requestKind: activePlan.requestKind
     });
     response = retriedOpenAIHostedWebSearch.response;
-    providerBody = retriedOpenAIHostedWebSearch.providerBody;
+    activePlan = {
+      ...activePlan,
+      providerBody: retriedOpenAIHostedWebSearch.providerBody
+    };
   }
 
   if (!response.ok) {
-    const hostedWebSearchErrorKind = await resolveHostedWebSearchErrorKind(response, providerBody, {
-      targetFormat,
-      requestKind
+    const hostedWebSearchErrorKind = await resolveHostedWebSearchErrorKind(response, activePlan.providerBody, {
+      targetFormat: activePlan.targetFormat,
+      requestKind: activePlan.requestKind
     });
     return {
       ok: false,
@@ -805,23 +913,26 @@ export async function makeProviderCall({
       retryable: shouldRetryStatus(response.status),
       ...(hostedWebSearchErrorKind ? { errorKind: hostedWebSearchErrorKind } : {}),
       upstreamResponse: response,
-      translateError: translate
+      translateError: activePlan.translate
     };
   }
 
   if (interceptAmpWebSearch) {
     const intercepted = await maybeInterceptAmpWebSearch({
       response,
-      providerBody,
-      targetFormat,
-      requestKind,
+      providerBody: activePlan.providerBody,
+      targetFormat: activePlan.targetFormat,
+      requestKind: activePlan.requestKind,
       stream,
       runtimeConfig,
       env,
       stateStore,
       executeProviderRequest: async (followUpBody) => {
         try {
-          return await executeHttpProviderRequest(followUpBody);
+          return await executeHttpProviderRequest({
+            ...activePlan,
+            providerBody: followUpBody
+          });
         } catch {
           return null;
         }
@@ -833,11 +944,11 @@ export async function makeProviderCall({
   return adaptProviderResponse({
     response,
     stream,
-    translate,
+    translate: activePlan.translate,
     sourceFormat,
-    targetFormat,
+    targetFormat: activePlan.targetFormat,
     fallbackModel: candidate.backend,
-    requestKind,
+    requestKind: activePlan.requestKind,
     requestBody: body,
     clientType,
     env