llm-switcher 1.6.9 → 1.6.10

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog — LLM Switcher
 
+## Release 1.6.10 — 2026-10-11
+
+- **`reasoning_content` replay.** On assistant tool-call turns, `auto` mode sends the earlier thinking as `reasoning_content`. `native` mode sends it only when the profile sets `replayReasoning: true`, because a strict OpenAI-compatible server can refuse the field. `off` mode never sends it.
+- **Codex to Anthropic with thinking.** If an open tool loop has no signed thinking, the request drops `thinking`. Anthropic refused this request with HTTP 400.
+- **Gemini schema and turn shape.** A nested object with no properties gets an optional `_placeholder` property. An untyped `const` becomes a string. Tool output with keys that start with `$` is wrapped as `{result: ...}`. A request never ends on a model turn: the proxy adds a user turn `Continue.`.
+- **Schema sanitizer.** Keywords with a `null` value and `pattern` values with lookaround are removed.
+- **Long tool names from Codex.** Names longer than 64 characters use the hashed shortener, so two long names do not collide.
+- **Repeated tool ids.** On the direct Anthropic route, a repeated `tool_use` id gets a suffix (`_2`, `_3`), and the matching `tool_result` changes with it.
+- **Context overflow errors.** Anthropic clients receive `invalid_request_error` with a message that starts with `prompt is too long`. Responses clients receive the code `context_length_exceeded`.
+
 ## Release 1.6.9 — 2026-10-11
 
 - **Compaction keeps the tools.** A Codex compaction turn with tool history now keeps the `tools` list and sets `tool_choice` to `none`. Before, Anthropic and OpenAI chat upstreams refused this turn with HTTP 400.

package/README.md

@@ -868,7 +868,8 @@ Because of this split, a provider fingerprint is never a rule in this gateway. I
 | `LLM_SWITCHER_CODE_ASSIST_TIMEOUT_MS` | Idle time of such a call, from 1000 to 2147483647 ms (default 300000). Before the answer starts, agy gets a 504. After it starts, the connection is cut. |
 | `LLM_SWITCHER_BIFROST_RETRY_MS` | Time before the gateway asks intact again after a failed Bifrost lookup (default 30000 ms). |
 | `x-llm-profile: <key>` header (alias `x-profile`) or `?profile=<key>` | Route a single request through a specific profile. An unknown key returns HTTP 400 instead of silently falling back. |
-| `profile.thinkingMode` | `auto` (default, for gateways like intact or 9Router): restore stripped thinking, inject a `<think>` guide for non-reasoning models, send `thinking` + `reasoning_effort`. `native` (strict OpenAI APIs): send only `reasoning_effort` when the client asks, never touch the prompt, use `max_completion_tokens`. `off`: never send reasoning parameters. |
+| `profile.thinkingMode` | `auto` (default, for gateways like intact or 9Router): restore stripped thinking, inject a `<think>` guide for non-reasoning models, send `thinking` + `reasoning_effort`, and send the earlier thinking as `reasoning_content` on assistant tool-call turns. `native` (strict OpenAI APIs): send only `reasoning_effort` when the client asks, never touch the prompt, use `max_completion_tokens`. Native mode never sends `reasoning_content` unless the profile sets `replayReasoning: true`. `off`: never send reasoning parameters. |
+| `profile.replayReasoning` | `true` sends the earlier thinking as `reasoning_content` on assistant tool-call turns in `native` mode. DeepSeek and Kimi thinking mode need it. The default is `false`. `auto` mode always sends the field, and `off` never sends it. The model name and the client request do not change this rule. |
 | `profile.thinkingEffort` | `auto` (default, caller/client controls effort), or an explicit override level: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `ultra`. Overrides client effort before routing upstream. Automatically maps to the nearest equivalent level accepted by the target upstream (e.g. OpenAI ceiling `high`, Anthropic `max`, Gemini budget bounds). In the Web UI, this selector dynamically hides with a guidance hint when Bifrost passthrough is active. |
 | `profile.endpoints.countTokens` | Override the Anthropic `count_tokens` URL. |
 | `profile.endpoints` | Override upstream URLs per format: `{ "openai-chat": "...", "anthropic": "...", "vertex": "https://.../models/{model}:{action}" }`. |

package/README.vi.md

@@ -863,7 +863,8 @@ Nhờ cách chia này, fingerprint của provider không bao giờ là rule tron
 | `LLM_SWITCHER_CODE_ASSIST_TIMEOUT_MS` | Thời gian chờ không có dữ liệu của lệnh gọi đó, từ 1000 tới 2147483647 ms (mặc định 300000). Trước khi câu trả lời bắt đầu, agy nhận 504. Sau khi đã bắt đầu, kết nối bị cắt. |
 | `LLM_SWITCHER_BIFROST_RETRY_MS` | Thời gian trước khi gateway hỏi lại intact sau một lần tra cứu Bifrost thất bại (mặc định 30000 ms). |
 | Header `x-llm-profile: <key>` (tên khác `x-profile`) hoặc `?profile=<key>` | Định tuyến riêng 1 request qua profile chỉ định. Key không tồn tại trả HTTP 400 thay vì âm thầm dùng profile khác. |
-| `profile.thinkingMode` | `auto` (mặc định, cho gateway như intact hoặc 9Router): phục hồi thinking bị xoá, inject hướng dẫn `<think>` cho model không có reasoning, gửi `thinking` + `reasoning_effort`. `native` (API OpenAI nghiêm ngặt): chỉ gửi `reasoning_effort` khi client yêu cầu, không sửa prompt, dùng `max_completion_tokens`. `off`: không bao giờ gửi tham số reasoning. |
+| `profile.thinkingMode` | `auto` (mặc định, cho gateway như intact hoặc 9Router): phục hồi thinking bị xoá, inject hướng dẫn `<think>` cho model không có reasoning, gửi `thinking` + `reasoning_effort`, và gửi lại thinking trước đó thành `reasoning_content` ở lượt assistant có tool call. `native` (API OpenAI nghiêm ngặt): chỉ gửi `reasoning_effort` khi client yêu cầu, không sửa prompt, dùng `max_completion_tokens`; không gửi `reasoning_content` trừ khi profile đặt `replayReasoning: true`. `off`: không bao giờ gửi tham số reasoning. |
+| `profile.replayReasoning` | `true`: ở chế độ `native`, gửi lại thinking trước đó thành `reasoning_content` ở lượt assistant có tool call. Thinking mode của DeepSeek và Kimi cần field này. Mặc định là `false`. `auto` luôn gửi, `off` không bao giờ gửi. Tên model và request của client không đổi quy tắc này. |
 | `profile.thinkingEffort` | `auto` (mặc định, client tự quyết định), hoặc đặt cố định mức override: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `ultra`. Ghi đè mức reasoning effort từ công cụ trước khi gửi lên upstream. Tự động ánh xạ về mức tương đương gần nhất mà upstream đích hỗ trợ (OpenAI trần `high`, Anthropic trần `max`, Gemini điều chỉnh `thinkingBudget`). Trên Web UI, tùy chọn này tự động ẩn cùng thông báo gợi ý khi profile bật chế độ Bifrost passthrough. |
 | `profile.endpoints.countTokens` | Ghi đè URL `count_tokens` của Anthropic. |
 | `profile.endpoints` | Ghi đè URL upstream theo từng format: `{ "openai-chat": "...", "anthropic": "...", "vertex": "https://.../models/{model}:{action}" }`. |

package/formats.mjs

@@ -256,13 +256,18 @@ function smartDelta(choice) {
 }
 
 const SCHEMA_MAPS = new Set(['properties', 'patternProperties', '$defs', 'definitions']);
+// Instance data, not schema: null is a real value here, and nothing inside may be rewritten.
+const SCHEMA_VALUES = new Set(['default', 'const', 'enum', 'examples', 'example']);
+// Lookahead and lookbehind; RE2 upstreams refuse the whole request ("invalid regex").
+const LOOKAROUND_RE = /\(\?<?[=!]/;
 
 function sanitizeJsonSchema(schema) {
   if (schema === null || schema === undefined) return { type: 'object', properties: {} };
   return sanitizeSchemaNode(schema);
 }
 
-// Inside a schema 0, false, "" and null are values (minimum: 0, additionalProperties: false), not a missing schema.
+// Inside a schema 0, false and "" are values (minimum: 0, additionalProperties: false), not a missing schema.
+// A null keyword is dropped (strict upstreams answer "null is not of type array"), except as instance data.
 function sanitizeSchemaNode(schema) {
   if (schema === null || typeof schema !== 'object') return schema;
   if (Array.isArray(schema)) return schema.map(sanitizeSchemaNode);
@@ -270,6 +275,9 @@ function sanitizeSchemaNode(schema) {
   for (const [k, v] of Object.entries(schema)) {
     if (k === '$schema' || k === 'cache_control' || k === 'encrypted') continue;
     if (k === 'format' && ['uri', 'uri-reference'].includes(v)) continue;
+    if (SCHEMA_VALUES.has(k)) { clean[k] = v; continue; }
+    if (v === null) continue;
+    if (k === 'pattern' && typeof v === 'string' && LOOKAROUND_RE.test(v)) continue;
     // A name map: each value is a schema, the map itself is not. A parameter may be named "properties".
     if (SCHEMA_MAPS.has(k) && v && typeof v === 'object' && !Array.isArray(v)) {
       clean[k] = Object.fromEntries(Object.entries(v).map(([name, sub]) => [name, sanitizeSchemaNode(sub)]));
@@ -457,10 +465,13 @@ function anthropicToIR(payload) {
       if (Array.isArray(msg.content)) {
         const parts = [];
         const toolCalls = [];
+        let reasoning = '';
         for (const part of msg.content) {
           if (!part) continue;
           if (part.type === 'text') {
             if (part.text) parts.push({ type: 'text', text: part.text });
+          } else if (part.type === 'thinking' && typeof part.thinking === 'string') {
+            reasoning += part.thinking;
           } else if (part.type === 'image' && part.source?.type === 'base64') {
             const mimeType = part.source.media_type || 'image/jpeg';
             parts.push({ type: 'image_url', image_url: { url: `data:${mimeType};base64,${part.source.data}` } });
@@ -501,6 +512,7 @@ function anthropicToIR(payload) {
           out.content = parts.every(p => p.type === 'text') ? parts.map(p => p.text).join('\n') : parts;
         }
         if (toolCalls.length) out.toolCalls = toolCalls;
+        if (reasoning && msg.role === 'assistant') out.reasoning = reasoning;
         if (out.content !== undefined || out.toolCalls) ir.messages.push(out);
       } else if (msg.content) {
         // Fallback for payloads that preprocessing/compression tools mangled into an object
@@ -631,9 +643,10 @@ const LOCAL_SHELL_PARAMS = {
   required: ['command']
 };
 
+// A plain cut at 64 would give two long namespaced tools one name; the hashed form keeps them apart.
 function responsesToolName(namespace, name) {
   const raw = namespace ? `${namespace}__${name}` : String(name || '');
-  return raw.replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 64);
+  return raw ? sanitizeToolName(raw) : '';
 }
 
 function customToolDescription(t) {
@@ -680,12 +693,19 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
     if (text) ir.system = ir.system ? `${ir.system}\n\n${text}` : text;
   };
 
+  // A reasoning item precedes the assistant output it belongs to.
+  let reasoning = '';
+  const takeReasoning = (m) => {
+    if (reasoning && m?.role === 'assistant') { m.reasoning = (m.reasoning || '') + reasoning; reasoning = ''; }
+  };
+
   // Parallel tool calls arrive as consecutive items -> merge into 1 assistant turn,
   // otherwise OpenAI Chat/Anthropic will error that tool_calls aren't answered adjacently.
   const pushCall = (call) => {
     const last = ir.messages[ir.messages.length - 1];
     if (last && last.role === 'assistant') last.toolCalls = [...(last.toolCalls || []), call];
     else ir.messages.push({ role: 'assistant', toolCalls: [call] });
+    takeReasoning(ir.messages[ir.messages.length - 1]);
   };
 
   // Responses Lite sends the tools as an input item, not in payload.tools.
@@ -724,6 +744,10 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
         } else {
           ir.messages.push({ role, content: parts });
         }
+        if (role === 'assistant') takeReasoning(ir.messages[ir.messages.length - 1]);
+      } else if (item.type === 'reasoning') {
+        const texts = (Array.isArray(item.summary) ? item.summary : []).map(x => x?.text).filter(t => typeof t === 'string' && t);
+        reasoning += texts.join('\n');
       } else if (item.type === 'function_call') {
         pushCall({ id: item.call_id || item.id || null, name: responsesToolName(item.namespace, item.name), args: parseArgs(item.arguments) });
       } else if (item.type === 'custom_tool_call') {
@@ -1077,6 +1101,7 @@ function normThinkingEffort(effort) {
 //  - 'native' (genuine OpenAI / strict OpenAI-compatible servers): only send `reasoning_effort` when
 //             the client requests thinking, don't touch the system prompt, use `max_completion_tokens`.
 //  - 'off'    : never send reasoning params, never inject prompts.
+// opts.replayReasoning: profile opt-in; native mode sends reasoning_content on tool-call turns only when it is true.
 function irToChatBody(ir, model, opts = {}) {
   const names = toolNameMapForIR(ir);
   const toolName = names.name;
@@ -1090,6 +1115,8 @@ function irToChatBody(ir, model, opts = {}) {
   const wantsThinking = mode === 'off' ? false
     : mode === 'native' ? clientWantsThinking
     : Boolean(clientWantsThinking || (modelIsThinking && (!ir.thinking || ir.thinking.type !== 'disabled')));
+  // Strict OpenAI-compatible servers may refuse an unknown message key, so native mode needs the profile flag.
+  const replayReasoning = wantsThinking && (mode === 'auto' || opts.replayReasoning === true);
 
   let systemText = ir.system || '';
   if (mode === 'auto' && wantsThinking && !modelIsThinking && !String(model).toLowerCase().includes('gemini')) {
@@ -1125,6 +1152,8 @@ function irToChatBody(ir, model, opts = {}) {
         return call;
       });
       if (out.content === undefined || out.content === '') out.content = null;
+      // DeepSeek/Kimi thinking mode refuse the next tool step without it; an empty string is accepted.
+      if (replayReasoning) out.reasoning_content = m.reasoning ?? '';
     }
     if (out.content === undefined) out.content = '';
     messages.push(out);
@@ -1332,6 +1361,8 @@ function irToAnthropicBody(ir, model, opts = {}) {
       body.thinking = { type: 'enabled', budget_tokens: Math.min(budget, body.max_tokens - 1) };
     }
   }
+  // This route never emits signed thinking blocks, so an open tool loop cannot keep thinking on.
+  if (body.thinking && endsInUnsignedToolLoop(body.messages)) delete body.thinking;
   if (body.thinking) {
     // When thinking is on, Anthropic rejects temperature != 1, top_k, or top_p < 0.95.
     if (body.temperature !== undefined && body.temperature !== 1) delete body.temperature;
@@ -1351,6 +1382,12 @@ function dataUrlToInlineData(url) {
   return { inlineData: { mimeType: m[1], data: m[2] } };
 }
 
+function hasDollarKey(v) {
+  if (Array.isArray(v)) return v.some(hasDollarKey);
+  if (!v || typeof v !== 'object') return false;
+  return Object.entries(v).some(([k, x]) => k.startsWith('$') || hasDollarKey(x));
+}
+
 // IR -> Vertex generateContent body.
 function irToVertexBody(ir, model, opts = {}) {
   const names = toolNameMapForIR(ir, { allowHyphens: false });
@@ -1400,6 +1437,8 @@ function irToVertexBody(ir, model, opts = {}) {
         const parsed = typeof m.content === 'string' ? JSON.parse(m.content) : m.content;
         // functionResponse.response must be an object (Struct), not an array/primitive.
         resp = (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : { result: parsed ?? '' };
+        // Gemini refuses a Struct key that starts with `$` (`$ref` in a schema file), so send the text.
+        if (hasDollarKey(resp)) resp = { result: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) };
       } catch { resp = { result: m.content ?? '' }; }
       // Gemini API & Vertex only accept roles 'user' | 'model' (functionResponse lives in the 'user' role).
       push('user', [{ functionResponse: { name: toolName(m.name || 'tool'), response: resp } }]);
@@ -1423,6 +1462,9 @@ function irToVertexBody(ir, model, opts = {}) {
     push('user', textPartsOf(m.content));
   }
   flushImages();
+  // Gemini refuses a request that ends on a model turn (an assistant prefill). A user turn is
+  // appended rather than the prefill dropped, so no text the client sent is lost.
+  if (contents[contents.length - 1]?.role === 'model') contents.push({ role: 'user', parts: [{ text: 'Continue.' }] });
 
   const body = { contents };
   if (ir.system && ir.system.trim()) {
@@ -1514,15 +1556,21 @@ function collapseNullableUnion(branches) {
   return { schema: rest[0], nullable: rest.length !== branches.length };
 }
 
+// Gemini refuses a nested OBJECT with no properties (a free-form map such as `env`). One optional
+// key keeps the type an object; the root of a tool with no arguments may stay empty.
+const GEMINI_PLACEHOLDER_PROPERTIES = { _placeholder: { type: 'boolean', description: 'Unused. Leave unset.' } };
+
 function toGeminiSchema(schema, root, seen) {
+  const nested = Boolean(root);
+  const emptyProperties = () => (nested ? { ...GEMINI_PLACEHOLDER_PROPERTIES } : {});
   // Shorthand left by some MCP servers: a bare "object"/"string" where a Schema belongs.
   // Vertex rejects the raw string with INVALID_ARGUMENT, so expand it.
   if (typeof schema === 'string') {
-    return schema === 'object' ? { type: 'object', properties: {} } : { type: schema };
+    return schema === 'object' ? { type: 'object', properties: emptyProperties() } : { type: schema };
   }
   if (!schema || typeof schema !== 'object' || Array.isArray(schema)) return schema;
   // The same hole as the string shorthand above: an empty schema has no type Vertex can read.
-  if (Object.keys(schema).length === 0) return { type: 'object', properties: {} };
+  if (Object.keys(schema).length === 0) return { type: 'object', properties: emptyProperties() };
   root = root || schema;
   seen = seen || new Set();
   if (seen.has(schema)) return {};
@@ -1573,8 +1621,13 @@ function toGeminiSchema(schema, root, seen) {
     }
   }
   if (!out.type && out.properties) out.type = 'object';
-  if (out.type === 'object' && !out.properties) out.properties = {};
-  if (out.enum && !out.type) out.type = 'string';
+  if (out.type === 'object' && !(out.properties && Object.keys(out.properties).length)) out.properties = emptyProperties();
+  if (out.enum && !out.type) {
+    // Gemini enum values are strings only; an untyped `const: true` would otherwise stay boolean.
+    out.type = 'string';
+    out.enum = out.enum.filter(x => x !== null).map(String);
+    if (!out.enum.length) delete out.enum;
+  }
   if (out.enum && out.type !== 'string') {
     // Gemini supports enum for strings only. Keep the constraint as text for the model.
     const values = (schema.enum || (Object.hasOwn(schema, 'const') ? [schema.const] : [])).filter(x => x !== null);
@@ -1647,6 +1700,15 @@ function toolResultText(block) {
   return `[Tool Result${block.tool_use_id ? ` (${block.tool_use_id})` : ''}]: ${text}`;
 }
 
+// Anthropic: "a final assistant message must start with a thinking block" when thinking is on mid tool loop.
+function endsInUnsignedToolLoop(messages) {
+  const lastUser = messages[messages.length - 1];
+  const lastAssistant = messages[messages.length - 2];
+  const inToolLoop = lastUser?.role === 'user' && toAnthropicBlocks(lastUser.content).some(b => b.type === 'tool_result');
+  const first = lastAssistant?.role === 'assistant' ? toAnthropicBlocks(lastAssistant.content)[0] : null;
+  return Boolean(inToolLoop && first && first.type !== 'thinking' && first.type !== 'redacted_thinking');
+}
+
 function healAnthropicPayload(payload) {
   const notes = [];
   if (!payload || !Array.isArray(payload.messages)) return { payload, changed: false, notes };
@@ -1711,6 +1773,41 @@ function healAnthropicPayload(payload) {
   }
   if (emptyUser && msgs[msgs.length - 1]?.role !== 'user') msgs.push(emptyTurn());
 
+  // Step 0b: an upstream that reuses an id (Kimi `functions.Bash:0`) leaves one id on two tool_use
+  // blocks, which Anthropic refuses. A later use gets a suffix, and so does its result in the next turn.
+  const allIds = new Set(msgs.flatMap(m => toAnthropicBlocks(m.content).filter(b => b.type === 'tool_use' && b.id).map(b => b.id)));
+  const usedIds = new Set();
+  for (let i = 0; i < msgs.length; i++) {
+    if (msgs[i].role !== 'assistant' || !Array.isArray(msgs[i].content)) continue;
+    const resultIds = new Map();
+    let renamed = false;
+    const content = msgs[i].content.map(b => {
+      if (b?.type !== 'tool_use' || !b.id) return b;
+      let id = b.id;
+      if (usedIds.has(id)) {
+        let n = 2;
+        while (allIds.has(`${b.id}_${n}`)) n++;
+        id = `${b.id}_${n}`;
+        allIds.add(id);
+        renamed = true;
+      }
+      usedIds.add(id);
+      resultIds.set(b.id, [...(resultIds.get(b.id) || []), id]);
+      return id === b.id ? b : { ...b, id };
+    });
+    if (!renamed) continue;
+    msgs[i] = { ...msgs[i], content };
+    const next = msgs[i + 1];
+    if (next?.role === 'user' && Array.isArray(next.content)) {
+      msgs[i + 1] = { ...next, content: next.content.map(b => {
+        const id = b?.type === 'tool_result' ? resultIds.get(b.tool_use_id)?.shift() : undefined;
+        return id && id !== b.tool_use_id ? { ...b, tool_use_id: id } : b;
+      }) };
+    }
+    changed = true;
+    notes.push('deduplicated repeated tool_use ids');
+  }
+
   // Steps 1-3: pair up tool_use / tool_result.
   const out = [];
   for (let i = 0; i < msgs.length; i++) {
@@ -1771,11 +1868,7 @@ function healAnthropicPayload(payload) {
   // Step 5: thinking + an in-progress tool loop whose last assistant turn doesn't open with thinking.
   const thinkingOn = payload.thinking && payload.thinking.type && payload.thinking.type !== 'disabled';
   if (thinkingOn) {
-    const lastUser = out[out.length - 1];
-    const lastAssistant = out[out.length - 2];
-    const inToolLoop = lastUser?.role === 'user' && toAnthropicBlocks(lastUser.content).some(b => b.type === 'tool_result');
-    const first = lastAssistant?.role === 'assistant' ? toAnthropicBlocks(lastAssistant.content)[0] : null;
-    if (inToolLoop && first && first.type !== 'thinking' && first.type !== 'redacted_thinking') {
+    if (endsInUnsignedToolLoop(out)) {
       body = { ...body };
       delete body.thinking;
       changed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.6.9",
+  "version": "1.6.10",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code and Codex, with OpenAI-compatible, Anthropic and Vertex upstreams",
   "keywords": [
     "llm",

package/proxy.mjs

@@ -378,15 +378,33 @@ function vertexStatus(status) {
   }
 }
 
+// A chat upstream names an overflow its own way; a 429 about tokens per minute is a rate limit, not this.
+const CONTEXT_OVERFLOW_RE = /maximum context length|context[_ ]length[_ ]exceeded|prompt is too long|exceeds? the (?:model'?s? )?context window/i;
+
+function isContextOverflow(status, message) {
+  return status !== 429 && status < 500 && CONTEXT_OVERFLOW_RE.test(String(message || ''));
+}
+
+// Claude Code compacts on "prompt is too long: N tokens > M maximum", so the numbers lead when the upstream names them.
+function promptTooLongMessage(message) {
+  if (/^prompt is too long/i.test(message)) return message;
+  const max = message.match(/(?:maximum context length|context window|limit) (?:is |of )?(\d+)/i)?.[1];
+  const asked = message.match(/(?:requested|resulted in|prompt (?:is|has|contains)|input (?:is|has)) (?:about )?(\d+)/i)?.[1];
+  return max && asked ? `prompt is too long: ${asked} tokens > ${max} maximum (${message})` : `prompt is too long: ${message}`;
+}
+
 // Each SDK parses errors in its own shape; Claude Code relies on error.type + retry-after to decide retries.
 function sendClientError(res, clientFormat, status, message, headers = {}) {
   let body;
+  const overflow = isContextOverflow(status, message);
   if (clientFormat === 'anthropic') {
-    body = { type: 'error', error: { type: anthropicErrorType(status), message } };
+    body = overflow
+      ? { type: 'error', error: { type: 'invalid_request_error', message: promptTooLongMessage(String(message)) } }
+      : { type: 'error', error: { type: anthropicErrorType(status), message } };
   } else if (clientFormat === 'vertex' || clientFormat === 'codeassist') {
     body = { error: { code: status, message, status: vertexStatus(status) } };
   } else {
-    body = { error: { message, type: status >= 500 ? 'server_error' : 'invalid_request_error', code: String(status) } };
+    body = { error: { message, type: status >= 500 ? 'server_error' : 'invalid_request_error', code: overflow ? 'context_length_exceeded' : String(status) } };
   }
   sendJson(res, status, body, headers);
 }
@@ -815,6 +833,7 @@ function buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot = n
   const upBody = emitUpstreamBody(outFormat, ir, mappedModel, {
     thinkingMode: profile.thinkingMode,
     thinkingEffort: effort,
+    replayReasoning: profile.replayReasoning === true,
   });
   if (upBody?.tools && Array.isArray(upBody.tools)) {
     upBody.tools = cleanSchemaDeep(upBody.tools);

package/tests/formats.test.mjs

@@ -420,7 +420,7 @@ test('toGeminiSchema: bare string shorthands become Schema objects (Vertex 400 f
   assert.deepEqual(toGeminiSchema('string'), { type: 'string' });
   assert.deepEqual(
     toGeminiSchema({ type: 'object', properties: { tags: { type: 'array', items: 'object' }, n: 'string' } }),
-    { type: 'object', properties: { tags: { type: 'array', items: { type: 'object', properties: {} } }, n: { type: 'string' } } }
+    { type: 'object', properties: { tags: { type: 'array', items: { type: 'object', properties: { _placeholder: { type: 'boolean', description: 'Unused. Leave unset.' } } } }, n: { type: 'string' } } }
   );
 });
 
@@ -1167,3 +1167,179 @@ test('Gemini MALFORMED_FUNCTION_CALL finish is an error, not stop', () => {
   const chat = normalizeUpstream({ choices: [{ delta: {}, finish_reason: 'malformed_function_call' }] }, 'openai-chat');
   assert.match(String(chat.error), /malformed_function_call/i);
 });
+
+// DeepSeek/Kimi thinking mode refuse a tool step whose earlier tool-call turn lost its reasoning_content.
+test('irToChatBody replays thinking as reasoning_content on tool-call turns', () => {
+  const ir = anthropicToIR({ model: 'x', max_tokens: 8000, thinking: { type: 'enabled', budget_tokens: 4000 }, messages: [
+    { role: 'user', content: 'list files' },
+    { role: 'assistant', content: [{ type: 'thinking', thinking: 'I should run ls', signature: 'sig' }, { type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command: 'ls' } }] },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'a.txt' }] },
+    { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_2', name: 'Bash', input: { command: 'pwd' } }] },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_2', content: '/' }] }
+  ] });
+  for (const opts of [{ thinkingMode: 'auto' }, { thinkingMode: 'native', replayReasoning: true }]) {
+    const calls = irToChatBody(ir, 'deepseek-reasoner', opts).messages.filter(m => m.tool_calls);
+    assert.equal(calls[0].reasoning_content, 'I should run ls', opts.thinkingMode);
+    assert.equal(calls[1].reasoning_content, '', opts.thinkingMode);
+  }
+  const off = emitUpstreamBody('openai-chat', ir, 'deepseek-reasoner', { thinkingMode: 'off' });
+  assert.ok(off.messages.every(m => !('reasoning_content' in m)));
+
+  const rir = responsesToIR({ model: 'x', reasoning: { effort: 'high' }, input: [
+    { type: 'message', role: 'user', content: 'go' },
+    { type: 'reasoning', summary: [{ type: 'summary_text', text: 'Plan: run ls' }], encrypted_content: 'opaque' },
+    { type: 'function_call', call_id: 'c1', name: 'shell', arguments: '{}' },
+    { type: 'function_call_output', call_id: 'c1', output: 'ok' }
+  ] });
+  const rb = irToChatBody(rir, 'kimi-k2-thinking', { thinkingMode: 'native', replayReasoning: true });
+  assert.equal(rb.messages.find(m => m.tool_calls).reasoning_content, 'Plan: run ls');
+});
+
+// Strict OpenAI-compatible servers may refuse the extra key, so native mode sends it only on the profile opt-in.
+test('irToChatBody native mode sends no reasoning_content without the profile opt-in', () => {
+  const ir = anthropicToIR({ model: 'x', max_tokens: 8000, thinking: { type: 'enabled', budget_tokens: 4000 }, messages: [
+    { role: 'user', content: 'list files' },
+    { role: 'assistant', content: [{ type: 'thinking', thinking: 'I should run ls', signature: 'sig' }, { type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command: 'ls' } }] },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'a.txt' }] },
+    { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_2', name: 'Bash', input: { command: 'pwd' } }] },
+    { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_2', content: '/' }] }
+  ] });
+  const cases = [
+    ['gpt-5', ir, { thinkingMode: 'native' }],
+    ['deepseek-reasoner', ir, { thinkingMode: 'native' }],
+    ['gpt-5', ir, { thinkingMode: 'native', replayReasoning: 'yes' }],
+    ['gpt-5', { ...ir, replayReasoning: true }, { thinkingMode: 'native' }]
+  ];
+  for (const [model, input, opts] of cases) {
+    const body = irToChatBody(input, model, opts);
+    assert.ok(body.messages.some(m => m.tool_calls), 'fixture has tool-call turns');
+    assert.ok(body.messages.every(m => !('reasoning_content' in m)), `${model} ${JSON.stringify(opts)}`);
+  }
+});
+
+test('irToAnthropicBody drops thinking for an unsigned tool loop', () => {
+  const ir = responsesToIR({ model: 'x', reasoning: { effort: 'high' }, input: [
+    { type: 'message', role: 'user', content: 'run ls' },
+    { type: 'function_call', call_id: 'c1', name: 'shell', arguments: '{"command":["ls"]}' },
+    { type: 'function_call_output', call_id: 'c1', output: 'a.txt' }
+  ] });
+  const body = irToAnthropicBody(ir, 'claude-opus-4-6');
+  assert.equal(body.thinking, undefined);
+  assert.equal(body.messages.at(-1).content[0].type, 'tool_result');
+  const forced = irToAnthropicBody(ir, 'claude-opus-4-6', { thinkingEffort: 'high' });
+  assert.equal(forced.thinking, undefined);
+  const fresh = irToAnthropicBody(responsesToIR({ model: 'x', reasoning: { effort: 'high' }, input: 'hi' }), 'claude-opus-4-6');
+  assert.equal(fresh.thinking?.type, 'enabled');
+});
+
+test('toGeminiSchema never emits an empty nested OBJECT', () => {
+  const out = toGeminiSchema({ type: 'object', properties: {
+    env: { type: 'object', additionalProperties: { type: 'string' } },
+    list: { type: 'array', items: { type: 'object' } },
+    either: { anyOf: [{ type: 'object' }, { type: 'string' }] },
+    short: 'object'
+  } });
+  const walk = (s, nested) => {
+    if (!s || typeof s !== 'object') return;
+    if (nested && s.type === 'object') assert.ok(Object.keys(s.properties || {}).length, JSON.stringify(s));
+    for (const p of Object.values(s.properties || {})) walk(p, true);
+    if (s.items) walk(s.items, true);
+    for (const b of s.anyOf || []) walk(b, true);
+  };
+  walk(out, false);
+  assert.deepEqual(toGeminiSchema({ type: 'object' }), { type: 'object', properties: {} });
+});
+
+test('irToVertexBody wraps tool output with $ keys', () => {
+  const output = JSON.stringify({ $ref: '#/definitions/Pet', definitions: { Pet: { $id: 'p' } } });
+  const nested = JSON.stringify({ a: { b: [{ $schema: 'x' }] } });
+  const ir = { ...anthropicToIR({ model: 'x', messages: [
+    { role: 'user', content: 'go' },
+    { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Bash', input: {} }, { type: 'tool_use', id: 't2', name: 'Bash', input: {} }, { type: 'tool_use', id: 't3', name: 'Bash', input: {} }] },
+    { role: 'user', content: [
+      { type: 'tool_result', tool_use_id: 't1', content: output },
+      { type: 'tool_result', tool_use_id: 't2', content: nested },
+      { type: 'tool_result', tool_use_id: 't3', content: '{"ok":true}' }
+    ] }
+  ] }) };
+  const responses = irToVertexBody(ir, 'gemini-2.5-pro').contents.flatMap(c => c.parts).filter(p => p.functionResponse).map(p => p.functionResponse.response);
+  assert.deepEqual(responses[0], { result: output });
+  assert.deepEqual(responses[1], { result: nested });
+  assert.deepEqual(responses[2], { ok: true });
+});
+
+test('toGeminiSchema stringifies an untyped const', () => {
+  const out = toGeminiSchema({ type: 'object', properties: { flag: { const: true }, n: { const: 3 }, s: { const: 'x' } } });
+  assert.deepEqual(out.properties.flag, { enum: ['true'], type: 'string' });
+  assert.deepEqual(out.properties.n, { enum: ['3'], type: 'string' });
+  assert.deepEqual(out.properties.s, { enum: ['x'], type: 'string' });
+});
+
+test('responsesToIR keeps long colliding tool names distinct', () => {
+  const ns = `mcp__${'server_with_a_long_name_'.repeat(3)}`;
+  const ir = responsesToIR({ model: 'x', input: [
+    { type: 'message', role: 'user', content: 'go' },
+    { type: 'function_call', call_id: 'c1', namespace: ns, name: 'list_items_with_filter_b', arguments: '{}' },
+    { type: 'function_call_output', call_id: 'c1', output: 'ok' }
+  ], tools: [{ type: 'namespace', name: ns, tools: [
+    { type: 'function', name: 'list_items_with_filter_a', parameters: { type: 'object', properties: {} } },
+    { type: 'function', name: 'list_items_with_filter_b', parameters: { type: 'object', properties: {} } }
+  ] }] });
+  const names = ir.tools.map(t => t.name);
+  assert.equal(names.length, 2);
+  assert.notEqual(names[0], names[1]);
+  assert.ok(names.every(n => n.length <= 64 && /^[A-Za-z0-9_-]+$/.test(n)), names.join());
+  assert.equal(ir.toolMeta[names[1]].name, 'list_items_with_filter_b');
+  assert.equal(ir.messages[1].toolCalls[0].name, names[1]);
+  assert.equal(responsesToIR({ model: 'x', input: 'hi', tools: [{ type: 'function', name: 'read_file', parameters: {} }] }).tools[0].name, 'read_file');
+});
+
+test('sanitizeJsonSchema drops null keywords and lookaround patterns', () => {
+  const out = sanitizeJsonSchema({ type: 'object', required: null, description: null, properties: {
+    slug: { type: 'string', pattern: '^(?!-)[a-z-]+$' },
+    tag: { type: 'string', pattern: '(?<=#)\\w+' },
+    plain: { type: 'string', pattern: '^[a-z]+$', default: null },
+    named: { type: 'string', pattern: '^(?<year>\\d{4})$' },
+    pattern: { type: 'string', enum: ['a', null], const: null }
+  } });
+  assert.equal('required' in out, false);
+  assert.equal('description' in out, false);
+  assert.equal('pattern' in out.properties.slug, false);
+  assert.equal('pattern' in out.properties.tag, false);
+  assert.equal(out.properties.plain.pattern, '^[a-z]+$');
+  assert.equal(out.properties.plain.default, null);
+  assert.equal(out.properties.named.pattern, '^(?<year>\\d{4})$');
+  assert.deepEqual(out.properties.pattern, { type: 'string', enum: ['a', null], const: null });
+  assert.deepEqual(sanitizeJsonSchema({ type: 'object', properties: {}, default: { a: null, b: {} } }).default, { a: null, b: {} });
+});
+
+test('irToVertexBody never ends on a model turn', () => {
+  const ir = anthropicToIR({ model: 'x', messages: [
+    { role: 'user', content: 'Write a haiku' },
+    { role: 'assistant', content: 'Autumn moon' }
+  ] });
+  const body = irToVertexBody(ir, 'gemini-2.5-pro');
+  assert.equal(body.contents.at(-1).role, 'user');
+  assert.ok(body.contents.some(c => c.role === 'model' && c.parts.some(p => p.text === 'Autumn moon')), 'the prefill text is kept');
+});
+
+test('healAnthropicPayload dedupes repeated tool_use ids', () => {
+  const use = (id, cmd) => ({ type: 'tool_use', id, name: 'Bash', input: { command: cmd } });
+  const result = (id, text) => ({ type: 'tool_result', tool_use_id: id, content: text });
+  const r = healAnthropicPayload({ model: 'claude', messages: [
+    { role: 'user', content: 'go' },
+    { role: 'assistant', content: [use('functions_Bash_0', 'ls')] },
+    { role: 'user', content: [result('functions_Bash_0', 'a.txt')] },
+    { role: 'assistant', content: [use('functions_Bash_0', 'pwd'), use('functions_Bash_1', 'id')] },
+    { role: 'user', content: [result('functions_Bash_0', '/'), result('functions_Bash_1', 'uid')] }
+  ] });
+  assert.equal(r.changed, true);
+  const msgs = r.payload.messages;
+  const ids = msgs.filter(m => m.role === 'assistant').flatMap(m => m.content.filter(b => b.type === 'tool_use').map(b => b.id));
+  assert.equal(new Set(ids).size, ids.length, ids.join());
+  assert.ok(ids.every(id => /^[a-zA-Z0-9_-]+$/.test(id)));
+  assert.equal(ids[0], 'functions_Bash_0');
+  // Each result still answers its own call.
+  assert.deepEqual(msgs[2].content.map(b => [b.tool_use_id, b.content]), [[ids[0], 'a.txt']]);
+  assert.deepEqual(msgs[4].content.map(b => [b.tool_use_id, b.content]), [[ids[1], '/'], [ids[2], 'uid']]);
+});

package/tests/gateway.e2e.test.mjs

@@ -112,6 +112,10 @@ function startUpstream() {
           res.writeHead(429, { 'Content-Type': 'application/json', 'retry-after': '7' });
           return res.end(JSON.stringify({ error: { message: 'slow down' } }));
         }
+        if (lastUser.includes('CONTEXT_OVERFLOW')) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          return res.end(JSON.stringify({ error: { message: "This model's maximum context length is 131072 tokens. However, you requested 140000 tokens (132000 in the messages, 8000 in the completion). Please reduce the length of the messages or completion.", type: 'invalid_request_error', code: 'invalid_request_error' } }));
+        }
         if (lastUser.includes('APPLY_PATCH')) {
           return sse(res, [
             { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: 'call_patch', type: 'function', function: { name: 'apply_patch', arguments: '{"input":"*** Begin Patch\\n' } }] } }] },
@@ -407,7 +411,7 @@ test('Codex via ag/* target: Gemini-hostile tool schemas are rewritten before up
   const params = up.body.tools[0].function.parameters;
   assert.deepEqual(params.properties.ids, { type: 'array', items: { type: 'string' }, nullable: true });
   assert.deepEqual(params.properties.part, { type: 'object', properties: { t: { type: 'string' } } });
-  assert.deepEqual(params.properties.raw, { type: 'object', properties: {} });
+  assert.deepEqual(params.properties.raw, { type: 'object', properties: { _placeholder: { type: 'boolean', description: 'Unused. Leave unset.' } } });
   assert.deepEqual(params.required, ['ids']);
   assert.ok(!JSON.stringify(params).includes('$ref'), 'no $ref survives');
   assert.equal(params.$defs, undefined);
@@ -594,6 +598,20 @@ test('Upstream 429 is returned in Anthropic error shape with retry-after', async
   assert.deepEqual(json, { type: 'error', error: { type: 'rate_limit_error', message: 'slow down' } });
 });
 
+// Claude Code compacts only on "prompt is too long", and Codex only on context_length_exceeded.
+test('sendClientError maps context overflow per client', async () => {
+  const cc = await post('/v1/messages', { model: 'claude-opus-4-6', max_tokens: 10, messages: [{ role: 'user', content: 'CONTEXT_OVERFLOW' }] });
+  assert.equal(cc.status, 400);
+  const ccJson = await cc.json();
+  assert.equal(ccJson.error.type, 'invalid_request_error');
+  assert.match(ccJson.error.message, /^prompt is too long: 140000 tokens > 131072 maximum/);
+  const codex = await post('/v1/responses', { model: 'gpt-5-codex', input: 'CONTEXT_OVERFLOW' });
+  assert.equal(codex.status, 400);
+  const codexJson = await codex.json();
+  assert.equal(codexJson.error.code, 'context_length_exceeded');
+  assert.match(codexJson.error.message, /maximum context length is 131072/);
+});
+
 test('Mid-stream upstream error surfaces as an error event instead of a fake end_turn', async () => {
   const res = await post('/v1/messages', { model: 'claude-opus-4-6', max_tokens: 10, stream: true, messages: [{ role: 'user', content: 'MID_STREAM_ERROR' }] });
   const events = parseSSE(await res.text());