@khanglvm/llm-router 2.0.0-beta.2 → 2.0.1

package/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### 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.
+
+## [2.0.1] - 2026-03-15
+
+### Fixed
+- Fixed alias-route failover after transient upstream failures. When every candidate on a route was only in cooldown, the balancer now retries the earliest-recovering candidate instead of returning `No eligible providers remain for route ...`.
+
+## [2.0.0] - 2026-03-15
+
+### Changed
+- Promoted the 2.x operator surface to the official stable `2.0.0` release.
+- Rebranded the user-facing CLI/docs name to `LLM Router` with `llr` as the primary command while keeping the published package scope as `@khanglvm/llm-router`.
+- Updated README and CLI help/examples to use the new branding and command.
+- Expanded the CLI management surface so agents can validate config state, inspect runtime/tool state (`validate`, `snapshot`, `tool-status`), reclaim the fixed local router port, run standalone provider diagnostics, and patch Codex CLI / Claude Code / AMP client routing without depending on the web console.
+- Updated `llr ai-help` and local agent instructions to prefer first-party CLI commands for validation, router recovery, coding-tool routing, and router inspection.
+
+### Removed
+- Removed prerelease release notes from the main public docs surface for the stable `2.0.0` release.
+- Removed the deprecated TUI entry flow from the supported operator surface and from the real-provider live suite coverage.
+
 ## [2.0.0-beta.2] - 2026-03-13
 
 ### Changed

package/README.md

@@ -14,24 +14,14 @@ The primary CLI command is now:
 llr
 ```
 
-## Beta Notice
-
-`2.0.0-beta.2` is the current public prerelease. It includes major operator-surface changes around the Web UI, AMP routing, and coding-tool integrations.
+`2.0.1` is the current public release. It includes the Web UI, AMP routing, and coding-tool integrations introduced in the 2.x line.
 
 ## Install
 
-Stable:
-
 ```bash
 npm i -g @khanglvm/llm-router@latest
 ```
 
-Beta:
-
-```bash
-npm i -g @khanglvm/llm-router@2.0.0-beta.2
-```
-
 ## Quick Start
 
 1. Open the Web UI:
@@ -251,6 +241,11 @@ Local config path:
 
 LLM Router also keeps related runtime and token state under the same namespace for backward compatibility with the published package.
 
+Useful runtime env knobs:
+
+- `LLM_ROUTER_MAX_REQUEST_BODY_BYTES`: caps inbound JSON body size for the local router and worker runtime. Default is `8 MiB` for `/responses` requests and `1 MiB` for other JSON endpoints.
+- `LLM_ROUTER_UPSTREAM_TIMEOUT_MS`: overrides the provider request timeout.
+
 ## Development
 
 Web UI dev loop:

package/package.json

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

package/src/runtime/balancer.js

@@ -186,6 +186,19 @@ function sortEntriesByOriginalOrder(left, right) {
   return left.originalIndex - right.originalIndex;
 }
 
+function sortCooldownEntries(left, right) {
+  if (left.openUntil !== right.openUntil) {
+    return left.openUntil - right.openUntil;
+  }
+  return sortEntriesByOriginalOrder(left, right);
+}
+
+function isCooldownOnlyEntry(entry) {
+  if (!entry || entry.eligible) return false;
+  const reasons = Array.isArray(entry.skipReasons) ? entry.skipReasons : [];
+  return reasons.length > 0 && reasons.every((reason) => reason === "cooldown");
+}
+
 async function buildCandidateEntries({
   candidates,
   stateStore,
@@ -315,6 +328,19 @@ export async function rankRouteCandidates({
   const ineligibleEntries = entries
     .filter((entry) => !entry.eligible)
     .sort(sortEntriesByOriginalOrder);
+  const fallbackCooldownEntries = eligibleEntries.length === 0
+    ? ineligibleEntries
+      .filter((entry) => isCooldownOnlyEntry(entry))
+      .sort(sortCooldownEntries)
+      .map((entry) => ({
+        ...entry,
+        eligible: true,
+        skipReasons: [...entry.skipReasons, "cooldown-overridden"]
+      }))
+    : [];
+  const skippedIneligibleEntries = fallbackCooldownEntries.length > 0
+    ? ineligibleEntries.filter((entry) => !isCooldownOnlyEntry(entry))
+    : ineligibleEntries;
   const estimatedRequiredTokens = normalizeNonNegativeInteger(
     requestContext?.estimatedRequiredTokens ??
     requestContext?.requiredTokens ??
@@ -324,10 +350,13 @@ export async function rankRouteCandidates({
   const routeCursor = stateStore
     ? await stateStore.getRouteCursor(resolvedRouteKey)
     : 0;
+  const rankableEntries = fallbackCooldownEntries.length > 0
+    ? fallbackCooldownEntries
+    : eligibleEntries;
   const contextAwareGroups = shouldApplyContextAwareOrdering(route, estimatedRequiredTokens)
-    ? partitionEligibleEntriesByContextWindow(eligibleEntries, estimatedRequiredTokens)
+    ? partitionEligibleEntriesByContextWindow(rankableEntries, estimatedRequiredTokens)
     : {
-        prioritizedEntries: eligibleEntries,
+        prioritizedEntries: rankableEntries,
         deferredEntries: []
       };
   const ranking = rankEligibleEntries(
@@ -339,7 +368,7 @@ export async function rankRouteCandidates({
   const rankedEntries = [
     ...ranking.orderedEligible,
     ...contextAwareGroups.deferredEntries,
-    ...ineligibleEntries
+    ...skippedIneligibleEntries
   ];
 
   return {
@@ -351,7 +380,7 @@ export async function rankRouteCandidates({
     shouldAdvanceCursor: ranking.shouldAdvanceCursor,
     entries: rankedEntries,
     selectedEntry: ranking.orderedEligible[0] || null,
-    skippedEntries: ineligibleEntries,
+    skippedEntries: skippedIneligibleEntries,
     rankedCandidates: rankedEntries.map((entry) => entry.candidate)
   };
 }

package/src/runtime/codex-request-transformer.js

@@ -193,10 +193,15 @@ function normalizeMessageRole(role) {
   return 'user';
 }
 
-function normalizeInputMessageContent(content) {
+function getResponsesTextPartTypeForRole(role) {
+  return normalizeMessageRole(role) === 'assistant' ? 'output_text' : 'input_text';
+}
+
+function normalizeInputMessageContent(content, role) {
+  const textPartType = getResponsesTextPartTypeForRole(role);
   if (typeof content === 'string') {
     return content
-      ? [{ type: 'input_text', text: content }]
+      ? [{ type: textPartType, text: content }]
       : [];
   }
 
@@ -208,7 +213,7 @@ function normalizeInputMessageContent(content) {
 
     if ((part.type === 'text' || part.type === 'input_text' || part.type === 'output_text') && typeof part.text === 'string') {
       parts.push({
-        type: 'input_text',
+        type: textPartType,
         text: part.text
       });
       continue;
@@ -284,11 +289,12 @@ function convertMessagesToResponseInput(messages) {
       continue;
     }
 
-    const contentParts = normalizeInputMessageContent(normalizedMessage.content);
+    const normalizedRole = normalizeMessageRole(normalizedMessage.role);
+    const contentParts = normalizeInputMessageContent(normalizedMessage.content, normalizedRole);
     if (contentParts.length > 0) {
       items.push({
         type: 'message',
-        role: normalizeMessageRole(normalizedMessage.role),
+        role: normalizedRole,
         content: contentParts
       });
     } else {
@@ -296,8 +302,11 @@ function convertMessagesToResponseInput(messages) {
       if (fallbackText) {
         items.push({
           type: 'message',
-          role: normalizeMessageRole(normalizedMessage.role),
-          content: [{ type: 'input_text', text: fallbackText }]
+          role: normalizedRole,
+          content: [{
+            type: getResponsesTextPartTypeForRole(normalizedRole),
+            text: fallbackText
+          }]
         });
       }
     }

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

@@ -12,10 +12,14 @@ import {
 import { isSubscriptionProvider, makeSubscriptionProviderCall } from "../subscription-provider.js";
 
 const SEARCH_TOOL_NAME = "web_search";
+const READ_WEB_PAGE_TOOL_NAME = "read_web_page";
 const DEFAULT_SEARCH_COUNT = 5;
 const MIN_SEARCH_COUNT = 1;
 const MAX_SEARCH_COUNT = 20;
 const DEFAULT_TIMEOUT_MS = 15_000;
+const MAX_READ_WEB_PAGE_TEXT_CHARS = 24_000;
+const MAX_READ_WEB_PAGE_TABLES = 8;
+const MAX_READ_WEB_PAGE_TABLE_ROWS = 40;
 const SEARCH_ROUTE_KEY = "route:amp-web-search";
 const HOSTED_WEB_SEARCH_TEST_QUERY = "Find the sunrise time in Paris today and cite the source.";
 const SEARCH_SYSTEM_INSTRUCTION = [
@@ -64,6 +68,18 @@ const WEB_SEARCH_FUNCTION_PARAMETERS = {
   additionalProperties: false
 };
 
+const READ_WEB_PAGE_FUNCTION_PARAMETERS = {
+  type: "object",
+  properties: {
+    url: {
+      type: "string",
+      description: "The absolute URL of the web page to read."
+    }
+  },
+  required: ["url"],
+  additionalProperties: true
+};
+
 const OPENAI_WEB_SEARCH_TOOL = Object.freeze({
   type: "function",
   function: {
@@ -79,6 +95,21 @@ const CLAUDE_WEB_SEARCH_TOOL = Object.freeze({
   input_schema: WEB_SEARCH_FUNCTION_PARAMETERS
 });
 
+const OPENAI_READ_WEB_PAGE_TOOL = Object.freeze({
+  type: "function",
+  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.",
+  input_schema: READ_WEB_PAGE_FUNCTION_PARAMETERS
+});
+
 function toInteger(value, fallback, { min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER } = {}) {
   const parsed = Number.parseInt(String(value ?? ""), 10);
   if (!Number.isFinite(parsed)) return fallback;
@@ -128,6 +159,119 @@ function stripHtml(text) {
     .trim();
 }
 
+function clampText(value, maxChars = MAX_READ_WEB_PAGE_TEXT_CHARS) {
+  const normalized = String(value || "").trim();
+  if (!normalized) return "";
+  if (normalized.length <= maxChars) return normalized;
+  return `${normalized.slice(0, Math.max(0, maxChars - 15)).trimEnd()}\n[truncated]`;
+}
+
+function stripHtmlPreservingLines(text) {
+  const normalized = String(text || "")
+    .replace(/<(br|hr)\s*\/?>/gi, "\n")
+    .replace(/<\/(p|div|section|article|main|header|footer|aside|nav|li|tr|h1|h2|h3|h4|h5|h6|ul|ol|table)>/gi, "\n")
+    .replace(/<li\b[^>]*>/gi, "- ")
+    .replace(/<\/t[dh]>/gi, " | ")
+    .replace(/<t[dh]\b[^>]*>/gi, " ")
+    .replace(/<[^>]+>/g, " ");
+  return normalized
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/&#x27;|&#39;/gi, "'")
+    .replace(/&quot;/gi, "\"")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .split(/\n+/)
+    .map((line) => line.replace(/\s+/g, " ").trim())
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
+function extractHtmlTitle(html) {
+  return stripHtml((String(html || "").match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1] || "");
+}
+
+function extractPreferredHtmlSection(html) {
+  const normalized = String(html || "");
+  for (const tagName of ["main", "article", "body"]) {
+    const match = normalized.match(new RegExp(`<${tagName}\\b[^>]*>([\\s\\S]*?)<\\/${tagName}>`, "i"));
+    if (match?.[1]) return match[1];
+  }
+  return normalized;
+}
+
+function removeHtmlNoise(html) {
+  return String(html || "")
+    .replace(/<script\b[\s\S]*?<\/script>/gi, " ")
+    .replace(/<style\b[\s\S]*?<\/style>/gi, " ")
+    .replace(/<noscript\b[\s\S]*?<\/noscript>/gi, " ")
+    .replace(/<svg\b[\s\S]*?<\/svg>/gi, " ")
+    .replace(/<template\b[\s\S]*?<\/template>/gi, " ");
+}
+
+function extractHtmlTables(html) {
+  const tableBlocks = [...String(html || "").matchAll(/<table\b[\s\S]*?<\/table>/gi)].slice(0, MAX_READ_WEB_PAGE_TABLES);
+  const tables = [];
+
+  for (let index = 0; index < tableBlocks.length; index += 1) {
+    const tableHtml = tableBlocks[index]?.[0] || "";
+    const caption = stripHtml((tableHtml.match(/<caption\b[^>]*>([\s\S]*?)<\/caption>/i) || [])[1] || "");
+    const rowBlocks = [...tableHtml.matchAll(/<tr\b[\s\S]*?<\/tr>/gi)].slice(0, MAX_READ_WEB_PAGE_TABLE_ROWS);
+    const rows = rowBlocks.map((rowBlock) => {
+      const rowHtml = rowBlock?.[0] || "";
+      return [...rowHtml.matchAll(/<t[dh]\b[^>]*>([\s\S]*?)<\/t[dh]>/gi)]
+        .map((cellMatch) => stripHtml(cellMatch?.[1] || ""))
+        .filter((cell) => cell.length > 0);
+    }).filter((row) => row.length > 0);
+
+    if (rows.length === 0) continue;
+    const formattedRows = rows.map((row) => `| ${row.join(" | ")} |`).join("\n");
+    tables.push([
+      caption ? `Table ${tables.length + 1}: ${caption}` : `Table ${tables.length + 1}:`,
+      formattedRows
+    ].join("\n"));
+  }
+
+  return tables;
+}
+
+function formatReadWebPageHtml(url, html) {
+  const cleanHtml = removeHtmlNoise(html);
+  const title = extractHtmlTitle(cleanHtml);
+  const mainSection = extractPreferredHtmlSection(cleanHtml);
+  const tables = extractHtmlTables(mainSection);
+  const pageText = clampText(stripHtmlPreservingLines(mainSection));
+  const sections = [
+    `URL: ${url}`
+  ];
+
+  if (title) sections.push(`Title: ${title}`);
+  if (tables.length > 0) sections.push(`Tables:\n${tables.join("\n\n")}`);
+  if (pageText) sections.push(`Page text:\n${pageText}`);
+
+  return sections.join("\n\n").trim();
+}
+
+function formatReadWebPageBody(url, bodyText, contentType = "") {
+  const sections = [
+    `URL: ${url}`
+  ];
+  const normalizedContentType = String(contentType || "").trim();
+  if (normalizedContentType) sections.push(`Content-Type: ${normalizedContentType}`);
+  sections.push(`Page text:\n${clampText(bodyText) || "[No readable page text extracted]"}`);
+  return sections.join("\n\n").trim();
+}
+
+function looksLikeHtml(contentType, bodyText) {
+  const normalizedContentType = String(contentType || "").toLowerCase();
+  if (normalizedContentType.includes("text/html") || normalizedContentType.includes("application/xhtml+xml")) {
+    return true;
+  }
+  const sample = String(bodyText || "").trim().slice(0, 512).toLowerCase();
+  return sample.startsWith("<!doctype html") || sample.startsWith("<html") || sample.includes("<body");
+}
+
 function formatSearchResults(results) {
   const lines = [];
   for (let index = 0; index < results.length; index += 1) {
@@ -157,6 +301,34 @@ function hasSearchToolName(name) {
   return normalized === SEARCH_TOOL_NAME || normalized === "web_search_preview";
 }
 
+function hasReadWebPageToolName(name) {
+  return String(name || "").trim().toLowerCase() === READ_WEB_PAGE_TOOL_NAME;
+}
+
+function hasInterceptableTool(tool) {
+  if (!tool || typeof tool !== "object") return false;
+  return hasSearchToolType(tool.type)
+    || hasSearchToolName(tool.name)
+    || hasSearchToolName(tool.function?.name)
+    || hasReadWebPageToolName(tool.name)
+    || hasReadWebPageToolName(tool.function?.name);
+}
+
+function hasInterceptableToolName(name) {
+  return hasSearchToolName(name) || hasReadWebPageToolName(name);
+}
+
+function getToolName(tool) {
+  if (!tool || typeof tool !== "object") return "";
+  if (hasReadWebPageToolName(tool.name) || hasReadWebPageToolName(tool.function?.name)) {
+    return READ_WEB_PAGE_TOOL_NAME;
+  }
+  if (hasSearchToolType(tool.type) || hasSearchToolName(tool.name) || hasSearchToolName(tool.function?.name)) {
+    return SEARCH_TOOL_NAME;
+  }
+  return "";
+}
+
 function dedupeStrings(values = []) {
   return [...new Set(
     (Array.isArray(values) ? values : [values])
@@ -1076,20 +1248,25 @@ export async function executeAmpWebSearch(query, runtimeConfig = {}, env = {}, o
 }
 
 export function shouldInterceptAmpWebSearch({ clientType, originalBody, runtimeConfig, env }) {
-  if (clientType !== "amp") return false;
   const tools = Array.isArray(originalBody?.tools) ? originalBody.tools : [];
-  if (!tools.some((tool) => {
-    if (!tool || typeof tool !== "object") return false;
-    return hasSearchToolType(tool.type) || hasSearchToolName(tool.name) || hasSearchToolName(tool.function?.name);
-  })) {
+  const requestedToolNames = dedupeStrings(tools.map((tool) => getToolName(tool)).filter(Boolean));
+  if (requestedToolNames.length === 0) {
     return false;
   }
-  return resolveAmpWebSearchConfig(runtimeConfig, env).providers.some((provider) => {
+  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 (readyProviders.length === 0) {
+    return clientType === "amp" && requestedToolNames.includes(READ_WEB_PAGE_TOOL_NAME);
+  }
+  if (clientType === "amp") {
+    if (requestedToolNames.includes(READ_WEB_PAGE_TOOL_NAME)) return true;
+    return true;
+  }
+  return true;
 }
 
 export function rewriteProviderBodyForAmpWebSearch(providerBody, targetFormat) {
@@ -1101,21 +1278,22 @@ export function rewriteProviderBodyForAmpWebSearch(providerBody, targetFormat) {
     };
   }
 
-  let hasWebSearch = false;
+  const interceptedToolNames = new Set();
   const nextTools = [];
   for (const tool of tools) {
     if (!tool || typeof tool !== "object") {
       nextTools.push(tool);
       continue;
     }
-    if (hasSearchToolType(tool.type) || hasSearchToolName(tool.name) || hasSearchToolName(tool.function?.name)) {
-      hasWebSearch = true;
+    const toolName = getToolName(tool);
+    if (toolName) {
+      interceptedToolNames.add(toolName);
       continue;
     }
     nextTools.push(tool);
   }
 
-  if (!hasWebSearch) {
+  if (interceptedToolNames.size === 0) {
     return {
       providerBody,
       hasWebSearch: false
@@ -1123,9 +1301,11 @@ export function rewriteProviderBodyForAmpWebSearch(providerBody, targetFormat) {
   }
 
   if (targetFormat === FORMATS.OPENAI) {
-    nextTools.push(OPENAI_WEB_SEARCH_TOOL);
+    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);
   } else if (targetFormat === FORMATS.CLAUDE) {
-    nextTools.push(CLAUDE_WEB_SEARCH_TOOL);
+    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);
   }
 
   return {
@@ -1141,7 +1321,7 @@ function extractOpenAIChatProbe(payload) {
   const choice = Array.isArray(payload?.choices) ? payload.choices[0] : null;
   const message = choice?.message && typeof choice.message === "object" ? choice.message : null;
   const toolCalls = Array.isArray(message?.tool_calls)
-    ? message.tool_calls.filter((item) => hasSearchToolName(item?.function?.name))
+    ? message.tool_calls.filter((item) => hasInterceptableToolName(item?.function?.name))
     : [];
 
   return {
@@ -1171,7 +1351,7 @@ function normalizeResponseInput(input) {
 
 function extractOpenAIResponsesProbe(payload) {
   const output = Array.isArray(payload?.output) ? payload.output : [];
-  const toolCalls = output.filter((item) => item?.type === "function_call" && hasSearchToolName(item?.name));
+  const toolCalls = output.filter((item) => item?.type === "function_call" && hasInterceptableToolName(item?.name));
   const assistantInputItems = output
     .filter((item) => item && item.type !== "reasoning")
     .map((item) => {
@@ -1204,7 +1384,7 @@ function extractOpenAIResponsesProbe(payload) {
 function extractClaudeProbe(payload) {
   const content = Array.isArray(payload?.content) ? payload.content : [];
   const assistantContent = content.filter((item) => item?.type !== "thinking" && item?.type !== "redacted_thinking");
-  const toolCalls = assistantContent.filter((item) => item?.type === "tool_use" && hasSearchToolName(item?.name));
+  const toolCalls = assistantContent.filter((item) => item?.type === "tool_use" && hasInterceptableToolName(item?.name));
 
   return {
     hasWebSearchCalls: toolCalls.length > 0,
@@ -1240,6 +1420,33 @@ function extractQueryFromToolCall(toolCall) {
   return "";
 }
 
+function extractUrlFromToolCall(toolCall) {
+  if (!toolCall || typeof toolCall !== "object") return "";
+  for (const candidate of [
+    toolCall?.input?.url,
+    toolCall?.input?.uri,
+    toolCall?.input?.href
+  ]) {
+    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+  }
+  const parsedArguments = parseJsonSafely(toolCall?.arguments, {});
+  for (const candidate of [parsedArguments?.url, parsedArguments?.uri, parsedArguments?.href]) {
+    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+  }
+  const parsedFunctionArguments = parseJsonSafely(toolCall?.function?.arguments, {});
+  for (const candidate of [parsedFunctionArguments?.url, parsedFunctionArguments?.uri, parsedFunctionArguments?.href]) {
+    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+  }
+  for (const candidate of [toolCall?.function?.url, toolCall?.function?.uri, toolCall?.function?.href]) {
+    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+  }
+  return "";
+}
+
+function getToolCallName(toolCall) {
+  return getToolName(toolCall);
+}
+
 function buildToolResultText(query, searchText) {
   const normalizedQuery = String(query || "").trim();
   const normalizedResults = String(searchText || "").trim() || "[No search results available]";
@@ -1247,6 +1454,96 @@ function buildToolResultText(query, searchText) {
   return `Web search results for "${normalizedQuery}":\n\n${normalizedResults}`;
 }
 
+function buildReadWebPageResultText(url, pageText) {
+  const normalizedUrl = String(url || "").trim();
+  const normalizedPageText = String(pageText || "").trim() || "[Unable to extract web page content]";
+  if (!normalizedUrl) return normalizedPageText;
+  return `Web page content from "${normalizedUrl}":\n\n${normalizedPageText}`;
+}
+
+async function executeAmpReadWebPage(url) {
+  const normalizedUrl = String(url || "").trim();
+  if (!normalizedUrl) {
+    return {
+      text: "[Missing URL for read_web_page]",
+      providerId: READ_WEB_PAGE_TOOL_NAME,
+      backend: READ_WEB_PAGE_TOOL_NAME,
+      tag: READ_WEB_PAGE_TOOL_NAME
+    };
+  }
+
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(normalizedUrl);
+  } catch {
+    return {
+      text: `[Invalid URL for read_web_page: ${normalizedUrl}]`,
+      providerId: READ_WEB_PAGE_TOOL_NAME,
+      backend: READ_WEB_PAGE_TOOL_NAME,
+      tag: READ_WEB_PAGE_TOOL_NAME
+    };
+  }
+
+  if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+    return {
+      text: `[Unsupported URL protocol for read_web_page: ${parsedUrl.protocol}]`,
+      providerId: READ_WEB_PAGE_TOOL_NAME,
+      backend: READ_WEB_PAGE_TOOL_NAME,
+      tag: READ_WEB_PAGE_TOOL_NAME
+    };
+  }
+
+  try {
+    const response = await runFetchWithTimeout(parsedUrl.toString(), {
+      headers: {
+        Accept: "text/html,application/xhtml+xml,text/plain,application/json;q=0.9,*/*;q=0.8",
+        "User-Agent": "llm-router"
+      }
+    });
+    if (!response.ok) {
+      return {
+        text: `[Failed to read web page: ${await readSearchProviderError(response)}]`,
+        providerId: READ_WEB_PAGE_TOOL_NAME,
+        backend: READ_WEB_PAGE_TOOL_NAME,
+        tag: READ_WEB_PAGE_TOOL_NAME
+      };
+    }
+
+    const contentType = String(response.headers.get("content-type") || "").trim();
+    const bodyText = await response.text();
+    const formattedText = looksLikeHtml(contentType, bodyText)
+      ? formatReadWebPageHtml(parsedUrl.toString(), bodyText)
+      : formatReadWebPageBody(parsedUrl.toString(), bodyText, contentType);
+
+    return {
+      text: formattedText,
+      providerId: READ_WEB_PAGE_TOOL_NAME,
+      backend: READ_WEB_PAGE_TOOL_NAME,
+      tag: READ_WEB_PAGE_TOOL_NAME
+    };
+  } catch (error) {
+    return {
+      text: `[Failed to read web page: ${error instanceof Error ? error.message : String(error)}]`,
+      providerId: READ_WEB_PAGE_TOOL_NAME,
+      backend: READ_WEB_PAGE_TOOL_NAME,
+      tag: READ_WEB_PAGE_TOOL_NAME
+    };
+  }
+}
+
+async function executeAmpInterceptedToolCall(toolCall, runtimeConfig, env, options = {}) {
+  const toolName = getToolCallName(toolCall);
+  if (toolName === READ_WEB_PAGE_TOOL_NAME) {
+    return executeAmpReadWebPage(extractUrlFromToolCall(toolCall));
+  }
+  return executeAmpWebSearch(
+    extractQueryFromToolCall(toolCall),
+    runtimeConfig,
+    env,
+    options
+  );
+}
+
 function mergeClaudeSystemInstruction(system, instruction) {
   if (typeof system === "string" && system.trim()) {
     return `${system.trim()}\n\n${instruction}`;
@@ -1270,7 +1567,7 @@ function mergeOpenAIInstructions(originalInstructions, instruction) {
 
 export function buildAmpWebSearchFollowUp(providerBody, probePayload, probe, searchResultsByCall, { targetFormat, requestKind, stream }) {
   const toolCalls = Array.isArray(probe?.toolCalls) ? probe.toolCalls : [];
-  const normalizedSearchResults = Array.isArray(searchResultsByCall)
+  const normalizedToolResults = Array.isArray(searchResultsByCall)
     ? searchResultsByCall
     : [];
 
@@ -1278,10 +1575,15 @@ export function buildAmpWebSearchFollowUp(providerBody, probePayload, probe, sea
     const toolResults = toolCalls.map((toolCall, index) => ({
       type: "tool_result",
       tool_use_id: toolCall.id || `tool_${index + 1}`,
-      content: buildToolResultText(
-        extractQueryFromToolCall(toolCall),
-        normalizedSearchResults[index]?.text
-      )
+      content: getToolCallName(toolCall) === READ_WEB_PAGE_TOOL_NAME
+        ? buildReadWebPageResultText(
+            extractUrlFromToolCall(toolCall),
+            normalizedToolResults[index]?.text
+          )
+        : buildToolResultText(
+            extractQueryFromToolCall(toolCall),
+            normalizedToolResults[index]?.text
+          )
     }));
     return {
       ...providerBody,
@@ -1305,10 +1607,15 @@ export function buildAmpWebSearchFollowUp(providerBody, probePayload, probe, sea
     const toolOutputs = toolCalls.map((toolCall, index) => ({
       type: "function_call_output",
       call_id: toolCall.call_id || toolCall.id || `call_${index + 1}`,
-      output: buildToolResultText(
-        extractQueryFromToolCall(toolCall),
-        normalizedSearchResults[index]?.text
-      )
+      output: getToolCallName(toolCall) === READ_WEB_PAGE_TOOL_NAME
+        ? buildReadWebPageResultText(
+            extractUrlFromToolCall(toolCall),
+            normalizedToolResults[index]?.text
+          )
+        : buildToolResultText(
+            extractQueryFromToolCall(toolCall),
+            normalizedToolResults[index]?.text
+          )
     }));
     return {
       ...providerBody,
@@ -1331,10 +1638,15 @@ export function buildAmpWebSearchFollowUp(providerBody, probePayload, probe, sea
   const toolMessages = toolCalls.map((toolCall, index) => ({
     role: "tool",
     tool_call_id: toolCall.id || `call_${index + 1}`,
-    content: buildToolResultText(
-      extractQueryFromToolCall(toolCall),
-      normalizedSearchResults[index]?.text
-    )
+    content: getToolCallName(toolCall) === READ_WEB_PAGE_TOOL_NAME
+      ? buildReadWebPageResultText(
+          extractUrlFromToolCall(toolCall),
+          normalizedToolResults[index]?.text
+        )
+      : buildToolResultText(
+          extractQueryFromToolCall(toolCall),
+          normalizedToolResults[index]?.text
+        )
   }));
   const nextMessages = Array.isArray(providerBody.messages) ? providerBody.messages.slice() : [];
   const hasLeadingSystem = nextMessages[0]?.role === "system";
@@ -1880,8 +2192,8 @@ export async function maybeInterceptAmpWebSearch({
 
   const searchResultsByCall = [];
   for (const toolCall of (probe.toolCalls || [])) {
-    searchResultsByCall.push(await executeAmpWebSearch(
-      extractQueryFromToolCall(toolCall),
+    searchResultsByCall.push(await executeAmpInterceptedToolCall(
+      toolCall,
       runtimeConfig,
       env,
       {

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

@@ -889,6 +889,16 @@ export function normalizeClaudePassthroughStream(response) {
     state.messageStopped = true;
   }
 
+  function beginNextClaudeMessage() {
+    state.messageStarted = false;
+    state.messageStopped = false;
+    state.terminalDeltaSeen = false;
+    state.hasToolUse = false;
+    state.stopReason = null;
+    state.stopSequence = undefined;
+    state.usage = undefined;
+  }
+
   function processBlock(block, controller) {
     if (!block || !block.trim()) return;
     const parsedBlock = parseSseBlock(block);
@@ -913,6 +923,10 @@ export function normalizeClaudePassthroughStream(response) {
 
     const eventType = String(payload?.type || parsedBlock.eventType || "").trim();
     if (eventType === "message_start") {
+      if (state.messageStarted && !state.messageStopped) {
+        finalizeClaudeMessage(controller);
+        beginNextClaudeMessage();
+      }
       state.messageStarted = true;
       mergeClaudeUsage(state, payload.message?.usage);
       enqueueRawBlock(controller, block);

package/src/runtime/handler/request.js

@@ -3,6 +3,7 @@ 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;
@@ -149,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,

package/src/runtime/handler.js

@@ -437,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);
@@ -965,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/translator/request/claude-to-openai.js

@@ -4,6 +4,19 @@
 
 import { FORMATS } from "../formats.js";
 
+const WEB_SEARCH_TOOL_NAME = "web_search";
+const WEB_SEARCH_FUNCTION_PARAMETERS = {
+  type: "object",
+  properties: {
+    query: {
+      type: "string",
+      description: "The search query to run against the web."
+    }
+  },
+  required: ["query"],
+  additionalProperties: false
+};
+
 function cloneCacheControl(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
   const type = typeof value.type === "string" ? value.type.trim() : "";
@@ -40,6 +53,33 @@ function convertClaudeSystemToOpenAIContent(system) {
   return parts;
 }
 
+function normalizeWebSearchType(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function isClaudeNativeWebSearchTool(tool) {
+  if (!tool || typeof tool !== "object") return false;
+  const normalizedType = normalizeWebSearchType(tool.type);
+  return normalizedType === "web_search"
+    || (normalizedType.startsWith("web_search_") && !normalizedType.startsWith("web_search_preview"));
+}
+
+function convertClaudeWebSearchTool(tool) {
+  const description = typeof tool?.description === "string" && tool.description.trim()
+    ? tool.description.trim()
+    : "Search the web for current information, news, documentation, or real-time facts.";
+  const cacheControl = cloneCacheControl(tool?.cache_control);
+  return {
+    type: "function",
+    function: {
+      name: WEB_SEARCH_TOOL_NAME,
+      description,
+      parameters: WEB_SEARCH_FUNCTION_PARAMETERS
+    },
+    ...(cacheControl ? { cache_control: cacheControl } : {})
+  };
+}
+
 /**
  * Convert Claude request to OpenAI format
  */
@@ -89,6 +129,9 @@ export function claudeToOpenAIRequest(model, body, stream) {
   // Tools
   if (body.tools && Array.isArray(body.tools)) {
     result.tools = body.tools.map(tool => {
+      if (isClaudeNativeWebSearchTool(tool)) {
+        return convertClaudeWebSearchTool(tool);
+      }
       const cacheControl = cloneCacheControl(tool.cache_control);
       return {
         type: "function",