llm-switcher 1.6.9 → 1.6.11

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog — LLM Switcher
 
+## Release 1.6.11 — 2026-10-11
+
+- **Output limit.** The proxy keeps the output limit of each model from the `/models` list of the profile (`max_output_tokens` or `top_provider.max_completion_tokens`) in `model-windows.json`. If the client asks for more tokens than this limit, the proxy sends the limit. This applies to `max_tokens`, `max_completion_tokens` and `maxOutputTokens`. If the limit is not known, the value does not change. The limit does not apply to the anthropic-to-anthropic passthrough (direct mode, outFormat `anthropic`, and the native goal-check request). These requests go to the upstream unchanged.
+- **Images to a text-only chat model.** If a chat upstream refuses an image with HTTP 400, the proxy sends the request one more time. In that request, each image is the text `[image omitted: this model does not accept images]`. The retry happens in each request. The proxy remembers nothing between requests.
+- **Test cleanup.** The browser tests and the gateway tests stop the gateway, the stand-in interceptor, an interceptor that the gateway started, and Chromium. They also delete their temp directories. This occurs also when a test fails or the test process gets `SIGTERM`, `SIGINT` or `SIGHUP`.
+
+## 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);
@@ -1601,6 +1654,13 @@ function emitUpstreamBody(outFormat, ir, model, opts = {}) {
   // thinkingMode 'off' applies to all upstreams: drop the client's thinking entirely.
   let src = normThinkingMode(opts.thinkingMode) === 'off' ? { ...ir, thinking: { type: 'disabled' } } : ir;
   if (isAntigravityModel(model) && src.system) src = { ...src, system: src.system.replace(BILLING_HEADER_RE, '') };
+  // An upstream refuses a max tokens above the model's output limit. The Anthropic body always
+  // carries one (4096 when the client sent none), so that default is clamped too.
+  const limit = opts.maxOutputTokens;
+  if (Number.isFinite(limit) && limit > 0) {
+    const asked = typeof src.params?.maxTokens === 'number' ? src.params.maxTokens : (outFormat === 'anthropic' ? 4096 : null);
+    if (asked != null && asked > limit) src = { ...src, params: { ...src.params, maxTokens: limit } };
+  }
   switch (outFormat) {
     case 'anthropic': return irToAnthropicBody(src, model, opts);
     case 'vertex': return irToVertexBody(src, model, opts);
@@ -1609,6 +1669,31 @@ function emitUpstreamBody(outFormat, ir, model, opts = {}) {
   }
 }
 
+// A text-only chat model refuses an image part with a 400. These are the refusals seen so far;
+// a looser match would turn an unrelated 400 into a silent retry without the image.
+export const IMAGE_OMITTED_TEXT = '[image omitted: this model does not accept images]';
+
+export function refusesImageInput(text) {
+  const t = String(text || '').toLowerCase();
+  return t.includes('unknown variant `image_url`') || t.includes('image_url is only supported by certain models')
+    || t.includes('does not support image') || t.includes('image input is not supported')
+    || (t.includes('vision') && t.includes('not supported'));
+}
+
+// Replaces every image part of a chat body with IMAGE_OMITTED_TEXT, in place. Returns how many it replaced.
+export function omitChatImages(body) {
+  let replaced = 0;
+  for (const m of Array.isArray(body?.messages) ? body.messages : []) {
+    if (!Array.isArray(m?.content)) continue;
+    m.content = m.content.map(p => {
+      if (p?.type !== 'image_url') return p;
+      replaced++;
+      return { type: 'text', text: IMAGE_OMITTED_TEXT };
+    });
+  }
+  return replaced;
+}
+
 // ---------------- native Anthropic healer (direct passthrough) ----------------
 // The anthropic -> anthropic branch skips IR (to preserve thinking signatures, cache_control, documents...),
 // so it patches the Anthropic payload directly, touching only what the API will definitely reject:
@@ -1647,6 +1732,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 +1805,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 +1900,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.11",
   "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

@@ -11,7 +11,7 @@ import { createFrameReader } from './blindfold/wsframe.mjs';
 import {
   OUT_FORMATS, parseToIR, emitUpstreamBody, irToAnthropicBody, createUpstreamNormalizer, createCollector,
   createThinkTagSplitter, splitThinkTags, healAnthropicPayload, estimateTokens, THINKING_MODES, VALID_EFFORTS,
-  toGeminiSchema, isAntigravityModel,
+  toGeminiSchema, isAntigravityModel, refusesImageInput, omitChatImages,
   createAnthropicStream, createChatStream, createResponsesStream, createVertexStream,
   buildAnthropicMessage, buildChatMessage, buildResponsesMessage, buildVertexMessage,
   createCodeAssistStream, buildCodeAssistMessage
@@ -26,7 +26,7 @@ import {
   codexModelEntry,
   contractLabSettings, STATE_DIR, stopRecordedBlindfold
 } from './state.mjs';
-import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows } from './windows.mjs';
+import { parseModelWindows, resolveProfileWindows, readLocalCodexWindows, readWindowsCache } from './windows.mjs';
 import { createToolVocab, NULL_TOOL_VOCAB, toolNameMapForIR } from './toolvocab.mjs';
 import { readUpstreamPayloads } from './upstream-stream.mjs';
 import { compactionResponse, emitCompaction, expandGatewayCompactions, collectCompaction } from './compaction.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);
 }
@@ -810,11 +828,24 @@ function resolveThinkingEffort(profile, slot, mappedModel) {
   return profile?.thinkingEffort || 'auto';
 }
 
+// The output limit the profile's own model list names for this model, or 0 when no cached list
+// names one. The cache is filled by /v1/models; this only reads it.
+function modelOutputLimit(profile, mappedModel) {
+  if (!profile?.baseURL || !mappedModel) return 0;
+  for (const entry of Object.values(readWindowsCache(STATE_DIR))) {
+    const output = entry?.baseURL === profile.baseURL ? Number(entry.models?.[mappedModel]?.output) : 0;
+    if (output > 0) return output;
+  }
+  return 0;
+}
+
 function buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot = null) {
   const effort = resolveThinkingEffort(profile, slot, mappedModel);
   const upBody = emitUpstreamBody(outFormat, ir, mappedModel, {
     thinkingMode: profile.thinkingMode,
     thinkingEffort: effort,
+    replayReasoning: profile.replayReasoning === true,
+    maxOutputTokens: modelOutputLimit(profile, mappedModel),
   });
   if (upBody?.tools && Array.isArray(upBody.tools)) {
     upBody.tools = cleanSchemaDeep(upBody.tools);
@@ -826,6 +857,20 @@ function buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot = n
   return { url, headers, upBody };
 }
 
+// Sends the upstream request. A chat 400 that says the model takes no images is retried once with
+// every image replaced by text. The status arrives before any byte goes to the client, so the client
+// sees only the retry's answer. Nothing is remembered: a false refusal costs one request, not the model.
+async function fetchUpstream(url, headers, upBody, signal, outFormat, profileKey, mappedModel) {
+  const send = () => fetch(url, { method: 'POST', headers, body: JSON.stringify(upBody), signal });
+  const res = await send();
+  const hasImage = outFormat === 'openai-chat' && upBody.messages?.some(m => Array.isArray(m?.content) && m.content.some(p => p?.type === 'image_url'));
+  if (res.status !== 400 || !hasImage) return res;
+  const errText = await res.text().catch(() => '');
+  if (!refusesImageInput(errText)) return new Response(errText, { status: res.status, statusText: res.statusText, headers: res.headers });
+  console.warn(`[${profileKey}] ${mappedModel} refused ${omitChatImages(upBody)} image(s); retrying this request as text`);
+  return send();
+}
+
 // Feeds upstream stream events to a client renderer until the stream ends, fails or is aborted.
 // Returns the stream error, or null. `sink` is the client stream whose backpressure it waits for.
 async function pumpStream(upstreamRes, { normalize, col, renderer, splitter, signal, sink, tag }) {
@@ -1263,7 +1308,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
 
     let upstreamRes;
     try {
-      upstreamRes = await fetch(url, { method: 'POST', headers, body: JSON.stringify(upBody), signal: ac.signal });
+      upstreamRes = await fetchUpstream(url, headers, upBody, ac.signal, outFormat, profileKey, mappedModel);
     } catch (fetchErr) {
       if (ac.signal.aborted) return log({ status: 499, error: 'client disconnected' });
       console.error(`[${profileKey}] Network error:`, fetchErr.message);
@@ -2534,7 +2579,7 @@ async function handleWsResponseCreate(socket, payload, req, ac, history = null)
 
     let upstreamRes;
     try {
-      upstreamRes = await fetch(url, { method: 'POST', headers, body: JSON.stringify(upBody), signal: ac.signal });
+      upstreamRes = await fetchUpstream(url, headers, upBody, ac.signal, outFormat, profileKey, mappedModel);
     } catch (fetchErr) {
       if (ac.signal.aborted) return log({ status: 499, error: 'client disconnected' });
       console.error(`[${profileKey}:ws] Network error:`, fetchErr.message);

package/tests/cdp.mjs

@@ -5,6 +5,7 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { reapDirSync, onAbnormalExit } from './helpers.mjs';
 
 const CANDIDATES = [
   process.env.LLM_SWITCHER_CHROMIUM,
@@ -48,7 +49,10 @@ export async function launchBrowser() {
     'about:blank'
   ];
   // POSIX: a process group of its own, so close() can stop the renderers and helpers too.
-  const child = spawn(findChromium(), args, { stdio: ['ignore', 'ignore', 'pipe'], env: { ...process.env, HOME: dir }, detached: process.platform !== 'win32' });
+  // TMPDIR too: Chromium makes its own org.chromium.* dirs there, and they go with the profile.
+  const child = spawn(findChromium(), args, { stdio: ['ignore', 'ignore', 'pipe'], env: { ...process.env, HOME: dir, TMPDIR: dir }, detached: process.platform !== 'win32' });
+  // The browser runs detached, so a test process that ends without close() would leave it running.
+  const cancelExitReap = onAbnormalExit(() => reapDirSync(dir, process.platform !== 'win32' ? [-child.pid] : [child.pid]));
   const stop = (signal) => {
     try {
       if (process.platform !== 'win32') process.kill(-child.pid, signal);
@@ -71,6 +75,8 @@ export async function launchBrowser() {
       stop('SIGKILL');
       await new Promise(r => { child.once('exit', r); setTimeout(r, 3000); });
     }
+    cancelExitReap();
+    fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
     throw new Error(`Chromium did not open a debugging port (exit: ${exited ?? 'killed'})\n${stderr}`);
   }
 
@@ -84,6 +90,7 @@ export async function launchBrowser() {
       return page;
     },
     async close() {
+      cancelExitReap();
       for (const p of pages) p.close();
       // The whole group: a helper that outlives the main process keeps writing into the profile.
       stop('SIGTERM');

package/tests/dashboard-fixture.mjs

@@ -8,6 +8,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { stopChild, reapDir, reapDirSync, onAbnormalExit } from './helpers.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -39,6 +40,11 @@ export function baselineConfig(port, blindfoldPort, upstreamBase) {
 export async function startDashboardFixture() {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lsw-dashboard-'));
   const cfgPath = path.join(dir, 'config.json');
+  let interceptor = null;
+  let proxy = null;
+  // A run that ends before stop() (a signal, a failed start) still stops the children and an
+  // interceptor the gateway started detached, and removes the dir.
+  const cancelExitReap = onAbnormalExit(() => reapDirSync(dir, [proxy?.pid, interceptor?.pid]));
   const received = [];
   // 'ok' answers like a healthy provider; 'deny' answers 401; 'down' answers 503.
   const upstream = { mode: 'ok', received, models: ['up-alpha', 'up-beta', 'up-gamma'], latest: '99.0.0' };
@@ -62,6 +68,23 @@ export async function startDashboardFixture() {
     });
   });
   await new Promise(r => upstreamServer.listen(0, '127.0.0.1', r));
+
+  async function stop() {
+    cancelExitReap();
+    // The gateway first: once it is gone it can start no interceptor.
+    await stopChild(proxy);
+    await stopChild(interceptor);
+    upstreamServer.close();
+    upstreamServer.closeAllConnections?.();
+    // A tool set change can start a detached interceptor of its own; stop the one the gateway recorded.
+    try {
+      const { pid } = JSON.parse(fs.readFileSync(path.join(dir, 'blindfold.json'), 'utf8'));
+      if (Number.isInteger(pid) && pid !== interceptor?.pid) process.kill(pid);
+    } catch { /* none was started */ }
+    // One it had not recorded yet still names the dir on its command line.
+    await reapDir(dir);
+  }
+
   const upstreamBase = `http://127.0.0.1:${upstreamServer.address().port}`;
 
   const port = await freePort();
@@ -96,7 +119,7 @@ export async function startDashboardFixture() {
   // The gateway starts an interceptor of its own when it finds none on the port. This one is up
   // first and answers the identity proof with this gateway's port and tool set, so nothing real
   // is spawned.
-  const interceptor = spawn(process.execPath, ['--input-type=module', '-e', `
+  interceptor = spawn(process.execPath, ['--input-type=module', '-e', `
     const s = await import(${JSON.stringify(pathToFileURL(path.join(ROOT, 'state.mjs')).href)});
     const http = await import('node:http');
     s.ensureAdminToken();
@@ -112,11 +135,11 @@ export async function startDashboardFixture() {
   for (;;) {
     const probe = await fetch(`http://127.0.0.1:${blindfoldPort}/?challenge=probe`).catch(() => null);
     if (probe?.ok) break;
-    if (Date.now() > deadline) { interceptor.kill(); throw new Error('the stand-in interceptor never came up'); }
+    if (Date.now() > deadline) { await stop(); throw new Error('the stand-in interceptor never came up'); }
     await new Promise(r => setTimeout(r, 100));
   }
 
-  const proxy = spawn(process.execPath, [path.join(ROOT, 'proxy.mjs'), '--port', String(port)], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+  proxy = spawn(process.execPath, [path.join(ROOT, 'proxy.mjs'), '--port', String(port)], { env, stdio: ['ignore', 'pipe', 'pipe'] });
   let log = '';
   proxy.stdout.on('data', d => { log += d; });
   proxy.stderr.on('data', d => { log += d; });
@@ -125,7 +148,7 @@ export async function startDashboardFixture() {
     try { started = (await fetch(`http://127.0.0.1:${port}/health`)).ok; } catch { /* not listening yet */ }
     if (!started) await new Promise(r => setTimeout(r, 100));
   }
-  if (!started) { proxy.kill(); interceptor.kill(); throw new Error(`gateway did not start:\n${log}`); }
+  if (!started) { await stop(); throw new Error(`gateway did not start:\n${log}`); }
 
   const adminToken = () => fs.readFileSync(path.join(dir, 'admin.token'), 'utf8').trim();
   return {
@@ -153,17 +176,6 @@ export async function startDashboardFixture() {
       headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
       body: JSON.stringify({ model: 'claude-opus-4-6', max_tokens: 64, messages: [{ role: 'user', content: 'hello from the test' }] })
     }).then(async r => ({ status: r.status, text: await r.text() })),
-    async stop() {
-      interceptor.kill();
-      proxy.kill();
-      upstreamServer.close();
-      upstreamServer.closeAllConnections?.();
-      // A tool set change can start a detached interceptor of its own; stop the one the gateway recorded.
-      try {
-        const { pid } = JSON.parse(fs.readFileSync(path.join(dir, 'blindfold.json'), 'utf8'));
-        if (Number.isInteger(pid) && pid !== interceptor.pid) process.kill(pid);
-      } catch { /* none was started */ }
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
+    stop
   };
 }