@khanglvm/llm-router 2.3.7 → 2.4.0

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.0] - 2026-04-18
+
+### Added
+- Claude Code can now store a router-managed `claudeCode.webSearchProvider` selection, with validation plus Web UI controls for choosing either built-in web search providers or hosted search routes.
+- Native Claude web search and page-fetch tool calls can now be intercepted locally for non-AMP clients, so Claude-compatible traffic can use the router-managed shared web search stack instead of falling back to upstream-native tools.
+- `yarn dev` now exposes a one-click "Sync production config" action that clones the current production config into the dedicated dev config while preserving the dev router's local server settings.
+
+### Fixed
+- `yarn dev` now launches the detached router backend with the runtime start path, so the dedicated dev router port is honored instead of conflicting with the fixed production port.
+- Dev-mode router reclaim now leaves startup-managed production instances alone when reclaiming non-fixed dev ports.
+- The dev terminal and web console now clearly mark when you are operating in the isolated development sandbox.
+
 ## [2.3.7] - 2026-04-18
 
 ### Fixed

package/README.md

@@ -29,6 +29,8 @@ llr ai-help  # agent-oriented setup brief
 - **Model aliases with routing** — group models into stable alias names with weighted round-robin, quota-aware balancing, and automatic fallback
 - **Rate limiting** — set request caps per model or across all models over configurable time windows
 - **Coding tool routing** — one-click routing config for Codex CLI, Claude Code, Factory Droid, and AMP
+- **Dev sandbox** — `yarn dev` runs the console against a dedicated dev config/router port, highlights dev mode in terminal + UI, and can clone the production config into the sandbox for quick iteration
+- **Claude native web tools** — local handling for Claude web search and page fetch requests, with selectable Claude Code web-search providers from the shared Web Search config
 - **Seamless local updates** — `llr update` keeps the fixed local router endpoint online, drains in-flight requests, and automatically retries through backend restart windows
 - **Web search** — built-in web search for AMP and other router-managed tools
 - **Deployable** — run locally or deploy to Cloudflare Workers
@@ -40,6 +42,14 @@ llr ai-help  # agent-oriented setup brief
 
 That means `llr update` can install a new package version and gracefully swap the backend without breaking active CLI or tool requests. Requests that arrive during the short backend handoff are deferred and retried automatically instead of failing immediately. The Web UI may reconnect during that window, but router-managed API traffic keeps the same public local endpoint.
 
+## Development Sandbox
+
+```bash
+yarn dev
+```
+
+Development mode uses the dedicated `~/.llm-router-dev.json` config and its own local router port so it can run alongside a startup-managed or manually started production router. The terminal and Web UI both show a dev-mode indicator, and the dev Web UI includes a one-click sync action to copy the current production config into the sandbox without changing the dev router binding.
+
 ## Web UI
 
 ### Alias & Fallback
@@ -66,6 +76,8 @@ Route Claude Code through the gateway with per-tier model bindings.
 
 ![Claude Code Routing](./assets/screenshots/web-ui-claude-code.png)
 
+Claude Code can also select a shared Web Search provider or hosted search route from the router config. When Claude-compatible traffic uses native web-search or page-fetch tools, LLM Router can satisfy those calls through the selected shared web-search provider instead of relying on upstream-native web tooling.
+
 ### Factory Droid
 
 Route Factory Droid through the gateway via a managed custom model entry with reasoning effort control.

package/package.json

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

package/src/node/instance-state.js

@@ -239,6 +239,7 @@ export async function waitForRuntimeMatch(options = {}, deps = {}) {
 
 export function spawnStartProcess({
   cliPath,
+  startCommand = "start-runtime",
   configPath,
   host = FIXED_LOCAL_ROUTER_HOST,
   port = FIXED_LOCAL_ROUTER_PORT,
@@ -256,7 +257,7 @@ export function spawnStartProcess({
 
   const args = [
     finalCliPath,
-    "start",
+    String(startCommand || "start-runtime").trim() || "start-runtime",
     `--config=${configPath}`,
     `--host=${host}`,
     `--port=${port}`,
@@ -290,7 +291,10 @@ export async function startDetachedRouterService(options = {}, deps = {}) {
 
   let child;
   try {
-    child = spawnStartProcessFn(options, {
+    child = spawnStartProcessFn({
+      ...options,
+      startCommand: String(options?.startCommand || "start-runtime").trim() || "start-runtime"
+    }, {
       detached: true,
       stdio: ["ignore", "pipe", "pipe"],
       unref: false,

package/src/node/port-reclaim.js

@@ -1,5 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { clearRuntimeState, getActiveRuntimeState } from "./instance-state.js";
+import { FIXED_LOCAL_ROUTER_PORT } from "./local-server-settings.js";
 import { startupStatus, stopStartup } from "./startup-manager.js";
 
 export function parsePidList(text) {
@@ -119,7 +120,9 @@ export async function stopStartupManagedListener({ port, line, error }, deps = {
   let shouldStopStartup = false;
   if (activeRuntimeState?.managedByStartup) {
     shouldStopStartup = Number(activeRuntimeState.port) === Number(port);
-  } else if (!activeRuntimeState) {
+  }
+
+  if (!shouldStopStartup && Number(port) === Number(FIXED_LOCAL_ROUTER_PORT)) {
     try {
       const status = await startupStatusFn();
       shouldStopStartup = Boolean(status?.running);

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

@@ -68,6 +68,7 @@ import {
   OLLAMA_KEEP_ALIVE_PATTERN,
   OLLAMA_PROVIDER_TYPE,
   configHasProvider,
+  normalizeClaudeCodeWebSearchProvider,
   normalizeOllamaConfig,
   normalizeRuntimeConfig,
   resolveProviderApiKey,
@@ -850,6 +851,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     host = "127.0.0.1",
     port = 8788,
     configPath = getDefaultConfigPath(),
+    productionConfigPath = getDefaultConfigPath(),
     activityLogPath = "",
     routerHost = FIXED_LOCAL_ROUTER_HOST,
     routerPort = FIXED_LOCAL_ROUTER_PORT,
@@ -891,6 +893,8 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     ? deps.loadWebConsoleDevAssets
     : loadWebConsoleDevAssets;
   const resolvedRouterCliPath = String(cliPathForRouter || process.env.LLM_ROUTER_CLI_PATH || process.argv[1] || "").trim();
+  const resolvedConfigPath = path.resolve(String(configPath || getDefaultConfigPath()).trim() || getDefaultConfigPath());
+  const resolvedProductionConfigPath = path.resolve(String(productionConfigPath || getDefaultConfigPath()).trim() || getDefaultConfigPath());
   const resolvedActivityLogPath = resolveActivityLogPath(configPath, activityLogPath);
   const startupControlsEnabled = !devMode;
   const defaultRouterSettings = {
@@ -1326,6 +1330,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
   async function readClaudeCodeGlobalRoutingState(settings = {}, config = null) {
     const endpointUrl = buildAmpClientEndpointUrl(settings);
     const apiKey = String(config?.masterKey || "").trim();
+    const webSearchProvider = normalizeClaudeCodeWebSearchProvider(config?.claudeCode?.webSearchProvider);
     try {
       const state = await readClaudeCodeRoutingState({
         endpointUrl,
@@ -1334,6 +1339,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
       });
       return {
         ...state,
+        webSearchProvider,
         endpointUrl,
         error: ""
       };
@@ -1354,6 +1360,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
           subagentModel: "",
           thinkingLevel: ""
         },
+        webSearchProvider,
         endpointUrl,
         error: error instanceof Error ? error.message : String(error)
       };
@@ -2181,7 +2188,11 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     return savedConfig;
   }
 
-  async function writeAndBroadcastConfig(parsed, { source = "" } = {}) {
+  async function writeAndBroadcastConfig(parsed, {
+    source = "",
+    preserveMissingKeys = true,
+    successMessage = ""
+  } = {}) {
     const previousConfigState = await readConfigState(configPath);
     const previousConfig = previousConfigState.normalizedConfig || buildDefaultConfigObject();
     const previousLocalServer = getConfigLocalServer(previousConfigState);
@@ -2190,7 +2201,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     // This prevents partial writes (e.g. from scoped Ollama endpoints) from wiping
     // unrelated config sections like masterKey, modelAliases, amp, metadata, etc.
     const previousRaw = previousConfigState.rawConfig;
-    if (previousRaw && typeof previousRaw === "object" && parsed && typeof parsed === "object") {
+    if (preserveMissingKeys && previousRaw && typeof previousRaw === "object" && parsed && typeof parsed === "object") {
       for (const key of Object.keys(previousRaw)) {
         if (!(key in parsed)) {
           parsed[key] = previousRaw[key];
@@ -2204,7 +2215,7 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     const nextLocalServer = readLocalServerSettings(savedConfig, previousLocalServer);
 
     if (source !== "autosave") {
-      addLog("success", `Config saved to ${path.basename(configPath)}.`);
+      addLog("success", successMessage || `Config saved to ${path.basename(configPath)}.`);
     }
 
     const managedRuntime = await readManagedRuntime(previousLocalServer);
@@ -2269,6 +2280,54 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
     };
   }
 
+  async function syncConfigFromProduction() {
+    if (!devMode) {
+      const error = new Error("Production config sync is only available in dev mode.");
+      error.statusCode = 409;
+      throw error;
+    }
+
+    if (resolvedConfigPath === resolvedProductionConfigPath) {
+      const error = new Error("Current config already points to the production config file.");
+      error.statusCode = 409;
+      throw error;
+    }
+
+    const currentConfigState = await readConfigState(configPath);
+    const currentLocalServer = getConfigLocalServer(currentConfigState);
+    const productionConfigState = await readConfigState(resolvedProductionConfigPath);
+
+    if (!productionConfigState.summary?.exists) {
+      const error = new Error(`Production config file was not found at ${resolvedProductionConfigPath}.`);
+      error.statusCode = 404;
+      throw error;
+    }
+
+    if (productionConfigState.parseError) {
+      const error = new Error(`Production config JSON must parse before syncing: ${productionConfigState.parseError}`);
+      error.statusCode = 400;
+      throw error;
+    }
+
+    const clonedConfig = applyLocalServerSettings(
+      productionConfigState.normalizedConfig || buildDefaultConfigObject(),
+      currentLocalServer
+    );
+
+    const result = await writeAndBroadcastConfig(clonedConfig, {
+      source: "production-sync",
+      preserveMissingKeys: false,
+      successMessage: `Synced ${path.basename(resolvedConfigPath)} from ${path.basename(resolvedProductionConfigPath)}.`
+    });
+
+    return {
+      ...result,
+      message: `Synced dev config from ${resolvedProductionConfigPath}.`,
+      syncedFrom: resolvedProductionConfigPath,
+      syncedTo: resolvedConfigPath
+    };
+  }
+
   let routerRestartPromise = null;
 
   async function restartManagedRouterWithSettings(settings, {
@@ -2334,6 +2393,12 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
       : { ok: false };
 
     return {
+      environment: {
+        devMode,
+        configPath: resolvedConfigPath,
+        productionConfigPath: resolvedProductionConfigPath,
+        canSyncProductionConfig: devMode && resolvedConfigPath !== resolvedProductionConfigPath
+      },
       web: {
         host,
         port: actualWebPort,
@@ -2827,6 +2892,17 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
         return;
       }
 
+      if (method === "POST" && requestUrl.pathname === "/api/config/sync-production") {
+        const synced = await syncConfigFromProduction();
+        sendJson(res, 200, {
+          ...synced.snapshot,
+          message: synced.message,
+          syncedFrom: synced.syncedFrom,
+          syncedTo: synced.syncedTo
+        });
+        return;
+      }
+
       if (method === "POST" && requestUrl.pathname === "/api/config/test-provider") {
         const body = await readJsonBody(req);
         const endpoints = Array.isArray(body?.endpoints) ? body.endpoints.map((entry) => String(entry || "").trim()).filter(Boolean) : [];
@@ -3454,6 +3530,102 @@ export async function startWebConsoleServer(options = {}, deps = {}) {
         return;
       }
 
+      if (method === "POST" && requestUrl.pathname === "/api/claude-code/search-provider") {
+        const body = await readJsonBody(req);
+        const currentConfigState = await readConfigState(configPath);
+
+        let parsed;
+        try {
+          if (body?.config && typeof body.config === "object" && !Array.isArray(body.config)) {
+            parsed = body.config;
+          } else if (typeof body?.rawText === "string") {
+            const rawText = String(body.rawText || "");
+            parsed = rawText.trim() ? JSON.parse(rawText) : {};
+          } else {
+            parsed = currentConfigState.rawConfig && typeof currentConfigState.rawConfig === "object" && !Array.isArray(currentConfigState.rawConfig)
+              ? { ...currentConfigState.rawConfig }
+              : {};
+          }
+        } catch (error) {
+          sendJson(res, 400, {
+            error: `Config JSON parse failed: ${error instanceof Error ? error.message : String(error)}`
+          });
+          return;
+        }
+
+        const nextConfig = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+        const selectedProvider = normalizeClaudeCodeWebSearchProvider(
+          body?.webSearchProvider
+          ?? body?.searchProvider
+          ?? body?.providerId
+        );
+
+        if (selectedProvider) {
+          let normalizedConfig;
+          try {
+            normalizedConfig = normalizeRuntimeConfig(nextConfig, { migrateToVersion: CONFIG_VERSION });
+          } catch (error) {
+            sendJson(res, 400, {
+              error: `Config normalization failed: ${error instanceof Error ? error.message : String(error)}`
+            });
+            return;
+          }
+          const configuredProviders = Array.isArray(normalizedConfig?.webSearch?.providers) ? normalizedConfig.webSearch.providers : [];
+          const selectedExists = configuredProviders.some((provider) => normalizeClaudeCodeWebSearchProvider(provider?.id) === selectedProvider);
+          if (!selectedExists) {
+            sendJson(res, 400, {
+              error: `Claude Code web search provider '${selectedProvider}' must reference a configured webSearch provider.`
+            });
+            return;
+          }
+        }
+
+        if (selectedProvider) {
+          const currentClaudeCode = nextConfig?.claudeCode && typeof nextConfig.claudeCode === "object" && !Array.isArray(nextConfig.claudeCode)
+            ? nextConfig.claudeCode
+            : (nextConfig?.["claude-code"] && typeof nextConfig["claude-code"] === "object" && !Array.isArray(nextConfig["claude-code"])
+              ? nextConfig["claude-code"]
+              : null);
+          const nextClaudeCode = currentClaudeCode
+            ? { ...currentClaudeCode }
+            : {};
+          nextClaudeCode.webSearchProvider = selectedProvider;
+          nextConfig.claudeCode = nextClaudeCode;
+          delete nextConfig["claude-code"];
+        } else {
+          const currentClaudeCode = nextConfig?.claudeCode && typeof nextConfig.claudeCode === "object" && !Array.isArray(nextConfig.claudeCode)
+            ? nextConfig.claudeCode
+            : (nextConfig?.["claude-code"] && typeof nextConfig["claude-code"] === "object" && !Array.isArray(nextConfig["claude-code"])
+              ? nextConfig["claude-code"]
+              : null);
+          if (currentClaudeCode) {
+            const nextClaudeCode = { ...currentClaudeCode };
+            delete nextClaudeCode.webSearchProvider;
+            delete nextClaudeCode["web-search-provider"];
+            delete nextClaudeCode.searchProvider;
+            delete nextClaudeCode["search-provider"];
+            if (Object.keys(nextClaudeCode).length > 0) {
+              nextConfig.claudeCode = nextClaudeCode;
+            } else {
+              nextConfig.claudeCode = {};
+            }
+            delete nextConfig["claude-code"];
+          }
+        }
+
+        const { snapshot } = await writeAndBroadcastConfig(nextConfig, { source: "claude-code-search-provider" });
+        addLog(
+          "success",
+          selectedProvider ? "Claude Code search capability updated." : "Claude Code search capability cleared.",
+          selectedProvider || "Default router search order"
+        );
+        sendJson(res, 200, {
+          ...snapshot,
+          message: selectedProvider ? "Claude Code search capability updated." : "Claude Code search capability cleared."
+        });
+        return;
+      }
+
       if (method === "POST" && requestUrl.pathname === "/api/claude-code/effort-level") {
         const body = await readJsonBody(req);
         const effortLevel = String(body?.effortLevel || body?.thinkingLevel || "").trim();

package/src/node/web-console-ui/web-search-utils.js

@@ -306,6 +306,48 @@ export function buildWebSearchProviderRows(config = {}, snapshot = null) {
   });
 }
 
+export function buildClaudeCodeWebSearchProviderOptions(providerRows = [], selectedProviderId = "") {
+  const options = [];
+  const seen = new Set();
+
+  for (const row of Array.isArray(providerRows) ? providerRows : []) {
+    if (!row?.configured) continue;
+    const optionValue = String(row?.id || "").trim();
+    const optionKey = normalizeWebSearchProviderKey(optionValue);
+    if (!optionValue || !optionKey || seen.has(optionKey)) continue;
+
+    const label = row.kind === "hosted"
+      ? [String(row?.label || "").trim(), String(row?.modelId || "").trim()].filter(Boolean).join(" · ")
+      : (String(row?.label || optionValue).trim() || optionValue);
+    const hint = row.kind === "hosted"
+      ? (String(row?.routeId || optionValue).trim() || "Hosted web search route")
+      : (row.active === false ? "Configured but not ready" : "Configured provider");
+
+    options.push({
+      value: optionValue,
+      label,
+      hint,
+      groupKey: row.kind === "hosted" ? "hosted-web-search-routes" : "builtin-web-search-providers",
+      groupLabel: row.kind === "hosted" ? "Hosted search routes" : "Built-in search providers"
+    });
+    seen.add(optionKey);
+  }
+
+  const selectedValue = String(selectedProviderId || "").trim();
+  const selectedKey = normalizeWebSearchProviderKey(selectedValue);
+  if (selectedValue && selectedKey && !seen.has(selectedKey)) {
+    options.unshift({
+      value: selectedValue,
+      label: selectedValue,
+      hint: "Current config (not configured)",
+      groupKey: "current-claude-selection",
+      groupLabel: "Current selection"
+    });
+  }
+
+  return options;
+}
+
 export function updateWebSearchConfig(config = {}, updates = {}) {
   const next = ensureAmpDraftConfigShape(config);
   const webSearch = ensureWebSearchConfigShape(next);

package/src/runtime/config.js

@@ -559,6 +559,12 @@ function normalizeAmpWebSearchProviderId(value) {
   return AMP_WEB_SEARCH_PROVIDER_IDS.includes(normalized) ? normalized : "";
 }
 
+export function normalizeClaudeCodeWebSearchProvider(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) return "";
+  return normalizeAmpWebSearchProviderId(normalized) || normalized;
+}
+
 function normalizeAmpWebSearchStrategy(value) {
   const normalized = String(value || "").trim().toLowerCase();
   if (!normalized) return "ordered";
@@ -750,6 +756,32 @@ function normalizeAmpWebSearchConfig(rawWebSearch) {
   };
 }
 
+function normalizeClaudeCodeConfig(rawClaudeCode) {
+  if (!rawClaudeCode || typeof rawClaudeCode !== "object" || Array.isArray(rawClaudeCode)) {
+    return undefined;
+  }
+
+  const source = rawClaudeCode;
+  const hasWebSearchProvider = hasOwn(source, "webSearchProvider")
+    || hasOwn(source, "web-search-provider")
+    || hasOwn(source, "searchProvider")
+    || hasOwn(source, "search-provider");
+  const webSearchProvider = normalizeClaudeCodeWebSearchProvider(
+    source.webSearchProvider
+    ?? source["web-search-provider"]
+    ?? source.searchProvider
+    ?? source["search-provider"]
+  );
+
+  if (!hasWebSearchProvider) {
+    return undefined;
+  }
+
+  return webSearchProvider
+    ? { webSearchProvider }
+    : {};
+}
+
 function supportsOpenAIHostedWebSearchRoute(provider, model) {
   const providerFormats = dedupeStrings([...(provider?.formats || []), provider?.format]);
   if (!providerFormats.includes(FORMATS.OPENAI)) return false;
@@ -1759,11 +1791,13 @@ export function normalizeRuntimeConfig(rawConfig, options = {}) {
     ? rawAmp
     : {};
   const rawWebSearch = raw.webSearch ?? raw["web-search"];
+  const rawClaudeCode = raw.claudeCode ?? raw["claude-code"];
   const amp = normalizeAmpConfig(rawAmp);
   const webSearch = normalizeAmpWebSearchConfig(rawWebSearch)
     ?? (amp?.webSearch && typeof amp.webSearch === "object" && !Array.isArray(amp.webSearch)
       ? amp.webSearch
       : undefined);
+  const claudeCode = normalizeClaudeCodeConfig(rawClaudeCode);
   const normalizedAmp = webSearch && amp?.webSearch && typeof amp.webSearch === "object" && !Array.isArray(amp.webSearch)
     ? Object.fromEntries(
         Object.entries(amp).filter(([key]) => key !== "webSearch")
@@ -1780,6 +1814,7 @@ export function normalizeRuntimeConfig(rawConfig, options = {}) {
     modelAliases,
     amp: normalizedAmp,
     ...(webSearch ? { webSearch } : {}),
+    ...(claudeCode && Object.keys(claudeCode).length > 0 ? { claudeCode } : {}),
     ollama,
     metadata: sanitizeRuntimeMetadata(raw.metadata)
   };
@@ -2085,6 +2120,21 @@ function validateAmpConfig(config, routingIndex, errors) {
       }
     }
   }
+
+  const claudeCode = config?.claudeCode;
+  if (claudeCode && typeof claudeCode === "object" && !Array.isArray(claudeCode)) {
+    const selectedWebSearchProvider = normalizeClaudeCodeWebSearchProvider(claudeCode.webSearchProvider);
+    if (selectedWebSearchProvider) {
+      const configuredProviders = Array.isArray(webSearch?.providers) ? webSearch.providers : [];
+      const selectedExists = configuredProviders.some((provider) => {
+        const providerId = normalizeClaudeCodeWebSearchProvider(provider?.id);
+        return providerId && providerId === selectedWebSearchProvider;
+      });
+      if (!selectedExists) {
+        errors.push(`claudeCode.webSearchProvider '${selectedWebSearchProvider}' must reference a configured webSearch provider.`);
+      }
+    }
+  }
 }
 
 export function validateRuntimeConfig(config, { requireMasterKey = false, requireProvider = false } = {}) {
@@ -2325,6 +2375,9 @@ export function sanitizeConfigForDisplay(config) {
     ...config,
     masterKey: config.masterKey ? maskSecret(config.masterKey) : undefined,
     ...(sanitizedWebSearch ? { webSearch: sanitizedWebSearch } : {}),
+    ...(config.claudeCode && typeof config.claudeCode === "object" && !Array.isArray(config.claudeCode)
+      ? { claudeCode: { ...config.claudeCode } }
+      : {}),
     amp: sanitizedAmp,
     providers: (config.providers || []).map((provider) => ({
       ...provider,

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

@@ -5,6 +5,7 @@ import { buildCandidateKey } from "../state-store.js";
 import { consumeCandidateRateLimits, resolveWindowRange } from "../rate-limits.js";
 import {
   buildProviderHeaders,
+  normalizeClaudeCodeWebSearchProvider,
   resolveProviderFormat,
   resolveProviderUrl,
   resolveRouteReference
@@ -311,16 +312,29 @@ function hasSearchToolType(type) {
   if (!normalized) return false;
   return normalized === SEARCH_TOOL_NAME
     || normalized.startsWith("web_search_preview")
-    || normalized === "web_search_20250305";
+    || normalized.startsWith("web_search_");
 }
 
 function hasSearchToolName(name) {
-  const normalized = String(name || "").trim().toLowerCase();
-  return normalized === SEARCH_TOOL_NAME || normalized === "web_search_preview";
+  const normalized = String(name || "").trim().toLowerCase().replace(/\s+/g, "_");
+  return normalized === SEARCH_TOOL_NAME
+    || normalized === "web_search_preview"
+    || normalized === "websearch";
+}
+
+function hasReadWebPageToolType(type) {
+  const normalized = String(type || "").trim().toLowerCase();
+  if (!normalized) return false;
+  return normalized === READ_WEB_PAGE_TOOL_NAME
+    || normalized === "web_fetch"
+    || normalized.startsWith("web_fetch_");
 }
 
 function hasReadWebPageToolName(name) {
-  return String(name || "").trim().toLowerCase() === READ_WEB_PAGE_TOOL_NAME;
+  const normalized = String(name || "").trim().toLowerCase().replace(/\s+/g, "_");
+  return normalized === READ_WEB_PAGE_TOOL_NAME
+    || normalized === "web_fetch"
+    || normalized === "webfetch";
 }
 
 function hasInterceptableTool(tool) {
@@ -338,7 +352,7 @@ function hasInterceptableToolName(name) {
 
 function getToolName(tool) {
   if (!tool || typeof tool !== "object") return "";
-  if (hasReadWebPageToolName(tool.name) || hasReadWebPageToolName(tool.function?.name)) {
+  if (hasReadWebPageToolType(tool.type) || hasReadWebPageToolName(tool.name) || hasReadWebPageToolName(tool.function?.name)) {
     return READ_WEB_PAGE_TOOL_NAME;
   }
   if (hasSearchToolType(tool.type) || hasSearchToolName(tool.name) || hasSearchToolName(tool.function?.name)) {
@@ -405,6 +419,28 @@ function normalizeSearchProviderId(value) {
   return AMP_WEB_SEARCH_PROVIDER_META.has(normalized) ? normalized : "";
 }
 
+function normalizeSearchProviderSelection(value) {
+  return normalizeClaudeCodeWebSearchProvider(value) || "";
+}
+
+function hasNativeClaudeWebSearchTool(tool) {
+  const normalizedType = String(tool?.type || "").trim().toLowerCase();
+  return normalizedType === "web_search"
+    || (normalizedType.startsWith("web_search_") && !normalizedType.startsWith("web_search_preview"));
+}
+
+function hasNativeClaudeWebFetchTool(tool) {
+  const normalizedType = String(tool?.type || "").trim().toLowerCase();
+  return normalizedType === "web_fetch" || normalizedType.startsWith("web_fetch_");
+}
+
+function shouldUseClaudeCodeWebSearchSelection(runtimeConfig = {}, originalBody = {}) {
+  const selectedProvider = normalizeSearchProviderSelection(runtimeConfig?.claudeCode?.webSearchProvider);
+  if (!selectedProvider) return false;
+  const tools = Array.isArray(originalBody?.tools) ? originalBody.tools : [];
+  return tools.some((tool) => hasNativeClaudeWebSearchTool(tool) || hasNativeClaudeWebFetchTool(tool));
+}
+
 function normalizeSearchRoutingStrategy(value) {
   const normalized = String(value || "").trim().toLowerCase();
   if (!normalized) return "ordered";
@@ -561,7 +597,7 @@ function normalizeConfiguredSearchProviders(rawProviders, raw = {}, env = {}) {
   ];
 }
 
-export function resolveAmpWebSearchConfig(runtimeConfig = {}, env = {}) {
+export function resolveAmpWebSearchConfig(runtimeConfig = {}, env = {}, options = {}) {
   const amp = runtimeConfig?.amp && typeof runtimeConfig.amp === "object" ? runtimeConfig.amp : {};
   const raw = runtimeConfig?.webSearch && typeof runtimeConfig.webSearch === "object" && !Array.isArray(runtimeConfig.webSearch)
     ? runtimeConfig.webSearch
@@ -574,11 +610,17 @@ export function resolveAmpWebSearchConfig(runtimeConfig = {}, env = {}) {
     { min: MIN_SEARCH_COUNT, max: MAX_SEARCH_COUNT }
   );
   const providers = normalizeConfiguredSearchProviders(raw.providers, raw, env);
+  const selectedProviderId = shouldUseClaudeCodeWebSearchSelection(runtimeConfig, options?.originalBody)
+    ? normalizeSearchProviderSelection(runtimeConfig?.claudeCode?.webSearchProvider)
+    : "";
+  const selectedProviders = selectedProviderId
+    ? providers.filter((provider) => normalizeSearchProviderSelection(provider?.id) === selectedProviderId)
+    : [];
 
   return {
     strategy: normalizeSearchRoutingStrategy(raw.strategy ?? env.AMP_WEB_SEARCH_STRATEGY),
     count,
-    providers
+    providers: selectedProviders.length > 0 ? selectedProviders : providers
   };
 }
 
@@ -895,8 +937,8 @@ function buildSearchProviderStatus(provider, evaluation, runtimeConfig = {}) {
   };
 }
 
-export async function buildAmpWebSearchSnapshot(runtimeConfig = {}, { env = {}, stateStore = null, now = Date.now() } = {}) {
-  const settings = resolveAmpWebSearchConfig(runtimeConfig, env);
+export async function buildAmpWebSearchSnapshot(runtimeConfig = {}, { env = {}, stateStore = null, now = Date.now(), originalBody = null } = {}) {
+  const settings = resolveAmpWebSearchConfig(runtimeConfig, env, { originalBody });
   const effectiveStateStore = resolveSearchStateStore(stateStore);
   const providers = [];
 
@@ -1198,7 +1240,8 @@ export async function executeAmpWebSearch(query, runtimeConfig = {}, env = {}, o
   const snapshot = await buildAmpWebSearchSnapshot(runtimeConfig, {
     env,
     stateStore: options.stateStore,
-    now: options.now
+    now: options.now,
+    originalBody: options.originalBody
   });
   const stateStore = resolveSearchStateStore(options.stateStore);
   const configuredProviders = snapshot.providers.filter((provider) => provider.ready);
@@ -1227,7 +1270,8 @@ export async function executeAmpWebSearch(query, runtimeConfig = {}, env = {}, o
       const refreshedSnapshot = await buildAmpWebSearchSnapshot(runtimeConfig, {
         env,
         stateStore,
-        now: options.now
+        now: options.now,
+        originalBody: options.originalBody
       });
       const refreshedProvider = refreshedSnapshot.providers.find((entry) => entry.id === providerStatus.id) || providerStatus;
       return {
@@ -1271,12 +1315,29 @@ export function shouldInterceptAmpWebSearch({ clientType, originalBody, runtimeC
   if (requestedToolNames.length === 0) {
     return false;
   }
+  const requestsWebSearch = requestedToolNames.includes(SEARCH_TOOL_NAME);
+  const requestsReadWebPage = requestedToolNames.includes(READ_WEB_PAGE_TOOL_NAME);
   const readyProviders = resolveAmpWebSearchConfig(runtimeConfig, env).providers.filter((provider) => {
     if (!isSearchProviderConfigured(provider)) return false;
     if (!isHostedSearchProvider(provider)) return true;
     const resolvedRoute = getResolvedHostedSearchRoute(runtimeConfig, provider);
     return Boolean(resolvedRoute && supportsResolvedHostedSearchRoute(resolvedRoute.provider, resolvedRoute.model));
   });
+  if (
+    clientType === "amp"
+    && requestsWebSearch
+    && !requestsReadWebPage
+    && readyProviders.length === 0
+    && runtimeConfig?.amp?.proxyWebSearchToUpstream === true
+    && String(runtimeConfig?.amp?.upstreamUrl || "").trim()
+    && String(runtimeConfig?.amp?.upstreamApiKey || "").trim()
+  ) {
+    return false;
+  }
+  const hasNativeClaudeWebTool = tools.some((tool) => hasNativeClaudeWebSearchTool(tool) || hasNativeClaudeWebFetchTool(tool));
+  if (hasNativeClaudeWebTool) {
+    return true;
+  }
   if (readyProviders.length === 0) {
     return clientType === "amp" && requestedToolNames.includes(READ_WEB_PAGE_TOOL_NAME);
   }
@@ -2324,6 +2385,7 @@ export async function maybeInterceptAmpWebSearch({
   runtimeConfig,
   env,
   stateStore,
+  originalBody,
   executeProviderRequest
 } = {}) {
   if (!(response instanceof Response)) {
@@ -2362,7 +2424,8 @@ export async function maybeInterceptAmpWebSearch({
       runtimeConfig,
       env,
       {
-        stateStore
+        stateStore,
+        originalBody
       }
     ));
   }

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

@@ -920,6 +920,7 @@ export async function makeProviderCall({
         runtimeConfig,
         env,
         stateStore,
+        originalBody: body,
         executeProviderRequest: async (followUpBody) => {
           const followUpResult = await executeSubscriptionRequest(followUpBody);
           return followUpResult?.response instanceof Response ? followUpResult.response : null;
@@ -1219,6 +1220,7 @@ export async function makeProviderCall({
       runtimeConfig,
       env,
       stateStore,
+      originalBody: body,
       executeProviderRequest: async (followUpBody) => {
         try {
           return await executeHttpProviderRequest({