llm-switcher 1.6.8 → 1.6.10

package/formats.mjs

@@ -39,6 +39,8 @@ function canonFinish(raw) {
   if (['length', 'max_tokens', 'max_output_tokens'].includes(r)) return 'length';
   if (['tool_calls', 'tool_call', 'function_call', 'function_calls', 'tool_use'].includes(r)) return 'tool_calls';
   if (['content_filter', 'safety', 'recitation', 'language', 'blocklist', 'prohibited_content', 'spii'].includes(r)) return 'content_filter';
+  // Gemini gave up on a tool call: as 'stop' the client would see a silent, empty turn.
+  if (r === 'malformed_function_call') return 'error';
   return 'stop';
 }
 
@@ -254,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);
@@ -268,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)]));
@@ -394,6 +404,7 @@ function parseArgs(v) {
   if (v === undefined || v === null) return {};
   if (typeof v === 'object') return v;
   if (typeof v === 'string') {
+    if (!v.trim()) return {};
     try { return JSON.parse(v); } catch { return { raw: v }; }
   }
   return {};
@@ -454,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}` } });
@@ -498,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
@@ -628,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) {
@@ -677,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.
@@ -721,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') {
@@ -788,7 +815,9 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
     ir.thinking = thinkingFromReasoningParam(payload.reasoning);
   }
   ir.responseFormat = responseFormatIR(payload.text?.format);
-  if (ir.compaction) { ir.tools = []; ir.toolChoice = 'none'; ir.responseFormat = null; }
+  // Tools stay declared: Anthropic refuses tool_use history without them, and OpenAI refuses
+  // tool_choice without tools. 'none' alone keeps the summary turn free of calls.
+  if (ir.compaction) { ir.toolChoice = ir.tools.length ? 'none' : null; ir.responseFormat = null; }
   return ir;
 }
 
@@ -1072,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;
@@ -1085,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')) {
@@ -1120,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);
@@ -1232,7 +1266,7 @@ function irToAnthropicBody(ir, model, opts = {}) {
     if (m.role === 'tool') {
       messages.push({
         role: 'user',
-        content: [{ type: 'tool_result', tool_use_id: m.toolCallId,
+        content: [{ type: 'tool_result', tool_use_id: safeToolId(m.toolCallId),
           content: m.images?.length ? [...contentToAnthropicBlocks(m.content), ...contentToAnthropicBlocks(m.images)] : m.content ?? '' }]
       });
       continue;
@@ -1240,7 +1274,7 @@ function irToAnthropicBody(ir, model, opts = {}) {
     if (m.role === 'assistant') {
       const blocks = contentToAnthropicBlocks(m.content).filter(b => b.type === 'text');
       for (const tc of (m.toolCalls || [])) {
-        blocks.push({ type: 'tool_use', id: tc.id, name: toolName(tc.name), input: parseArgs(tc.args) });
+        blocks.push({ type: 'tool_use', id: safeToolId(tc.id), name: toolName(tc.name), input: parseArgs(tc.args) });
       }
       if (blocks.length) messages.push({ role: 'assistant', content: blocks });
       continue;
@@ -1327,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;
@@ -1346,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 });
@@ -1395,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 } }]);
@@ -1418,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()) {
@@ -1509,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 {};
@@ -1568,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);
@@ -1629,6 +1687,11 @@ function toAnthropicBlocks(content) {
   return Array.isArray(content) ? content.filter(Boolean) : [];
 }
 
+// Anthropic refuses a text block with no visible text ("text content blocks must be non-empty").
+function isBlankText(b) {
+  return b?.type === 'text' && !(typeof b.text === 'string' && b.text.trim());
+}
+
 function toolResultText(block) {
   const c = block.content;
   const text = typeof c === 'string' ? c
@@ -1637,15 +1700,35 @@ 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 };
   const src = payload.messages.filter(m => m && (m.role === 'user' || m.role === 'assistant'));
   let changed = src.length !== payload.messages.length;
 
-  // Step 0: drop thinking blocks with fake signatures; merge adjacent user turns (so a tool_result split
-  // into a later turn can still be matched with its tool_use).
+  let system = payload.system;
+  if (Array.isArray(system) && system.some(isBlankText)) {
+    system = system.filter(b => !isBlankText(b));
+    changed = true;
+    notes.push('dropped empty text blocks');
+  }
+  const dropSystem = Array.isArray(system) ? !system.length : typeof system === 'string' && !system.trim();
+  if (dropSystem) changed = true;
+
+  // Step 0: drop thinking blocks with fake signatures and empty text blocks; rewrite foreign tool ids;
+  // merge adjacent user turns (so a tool_result split into a later turn can still be matched with its tool_use).
   const msgs = [];
+  const emptyTurn = () => ({ role: 'user', content: [{ type: 'text', text: '(empty)' }] });
+  let emptyUser = false;
   for (const m of src) {
     let content = m.content;
     if (m.role === 'assistant' && Array.isArray(content)) {
@@ -1655,11 +1738,31 @@ function healAnthropicPayload(payload) {
         notes.push('stripped placeholder-signed thinking blocks');
         content = kept;
       }
-      if (!content.length) {
+    }
+    if (Array.isArray(content)) {
+      const kept = [];
+      let renamed = false;
+      for (const b of content) {
+        if (isBlankText(b)) continue;
+        if (b?.type === 'tool_use' && b.id && safeToolId(b.id) !== b.id) { kept.push({ ...b, id: safeToolId(b.id) }); renamed = true; }
+        else if (b?.type === 'tool_result' && b.tool_use_id && safeToolId(b.tool_use_id) !== b.tool_use_id) { kept.push({ ...b, tool_use_id: safeToolId(b.tool_use_id) }); renamed = true; }
+        else kept.push(b);
+      }
+      if (kept.length !== content.length) notes.push('dropped empty text blocks');
+      if (renamed) notes.push('sanitized foreign tool ids');
+      if (renamed || kept.length !== content.length) {
         changed = true;
-        continue;
+        content = kept;
       }
     }
+    if (!toAnthropicBlocks(typeof content === 'string' ? content.trim() : content).length) {
+      // An emptied user turn still holds its place between two assistant turns, or at the end.
+      changed = true;
+      if (m.role === 'user') emptyUser = true;
+      continue;
+    }
+    if (emptyUser && m.role === 'assistant' && msgs[msgs.length - 1]?.role !== 'user') msgs.push(emptyTurn());
+    emptyUser = false;
     const last = msgs[msgs.length - 1];
     if (m.role === 'user' && last && last.role === 'user') {
       last.content = [...toAnthropicBlocks(last.content), ...toAnthropicBlocks(content)];
@@ -1668,6 +1771,42 @@ function healAnthropicPayload(payload) {
     }
     msgs.push({ ...m, content });
   }
+  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 = [];
@@ -1723,15 +1862,13 @@ function healAnthropicPayload(payload) {
   }
 
   let body = { ...payload, messages: out };
+  if (dropSystem) delete body.system;
+  else if (system !== payload.system) body.system = system;
 
   // 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;
@@ -1887,6 +2024,7 @@ function normalizeUpstream(parsed, outFormat) {
   for (const tc of smartToolCalls(node)) ev.tools.push(chunkToolFull(tc));
   const f = smartFinish(parsed, choice);
   if (f) ev.finish = canonFinish(f);
+  if (ev.finish === 'error') { ev.finish = null; ev.error = `Upstream finished with ${f}`; }
   return ev;
 }
 
@@ -2054,6 +2192,17 @@ function rand(n = 6) {
   return s.slice(0, n);
 }
 
+// Anthropic takes tool ids matching ^[a-zA-Z0-9_-]+$ only (Kimi sends "functions.Read:0"). The map must
+// stay pure: a replayed history has to give the same id, and the hash keeps "a.b" and "a:b" apart.
+function safeToolId(id) {
+  const s = String(id ?? '');
+  if (!s) return `toolu_${rand(24)}`;
+  if (/^[a-zA-Z0-9_-]+$/.test(s)) return s;
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 0x01000193);
+  return `${s.replace(/[^a-zA-Z0-9_-]/g, '_')}_${(h >>> 0).toString(36)}`;
+}
+
 function anthropicStopReason(canonical, hasTools) {
   if (canonical === 'length') return 'max_tokens';
   if (hasTools) return 'tool_use';
@@ -2147,7 +2296,7 @@ function createAnthropicStream(emit, model, opts = {}) {
         const fixed = vocab ? vocab.name(tc.name) : tc.name;
         const isShort = Boolean(vocab && typeof vocab.isShortened === 'function' && vocab.isShortened(tc.name));
         st = {
-          index: nextIndex++, id: tc.id || `toolu_${rand(24)}`, name: fixed || 'tool', closed: false,
+          index: nextIndex++, id: safeToolId(tc.id), name: fixed || 'tool', closed: false,
           // Shortened names keep caller's schema; ToolSearch query aliases still need restoring.
           buffered: '', held: Boolean(vocab && ((fixed && fixed !== tc.name && !isShort) || vocab.needsArgsRewrite?.(tc.name)))
         };
@@ -2212,7 +2361,7 @@ function buildAnthropicMessage({ model, think, text, tools, finish, prompt, comp
     // The name is written in the vocabulary the caller declared. A name it already uses is not
     // touched, so the whole layer costs nothing on a turn where the model agreed with the list.
     const fixed = repairToolCall(tc, vocab);
-    content.push({ type: 'tool_use', id: tc.id || `toolu_${rand(24)}`, name: fixed.name, input: parseArgs(fixed.args) });
+    content.push({ type: 'tool_use', id: safeToolId(tc.id), name: fixed.name, input: parseArgs(fixed.args) });
   }
   if (!content.length) content.push({ type: 'text', text: '' });
   const p = prompt || 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.6.8",
+  "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);
@@ -831,8 +850,9 @@ function buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot = n
 async function pumpStream(upstreamRes, { normalize, col, renderer, splitter, signal, sink, tag }) {
   let streamError = null;
   let events = 0;
+  const framing = {};
   try {
-    for await (const parsed of readUpstreamPayloads(upstreamRes)) {
+    for await (const parsed of readUpstreamPayloads(upstreamRes, framing)) {
       events++;
       const ev = normalize(parsed);
       col.add(ev);
@@ -850,6 +870,8 @@ async function pumpStream(upstreamRes, { normalize, col, renderer, splitter, sig
       await drained(sink, signal);
     }
     if (!streamError && events === 0) streamError = 'Upstream returned an empty stream';
+    // A clean close with no finish reason is a cut: rendered as done, it hands the client half a tool call.
+    else if (!streamError && col.finish == null && !framing.done) streamError = 'Upstream stream ended before a finish reason';
   } catch (streamErr) {
     if (!signal.aborted) {
       console.error(`[${tag}] Stream error:`, streamErr.message);

package/tests/compaction.e2e.test.mjs

@@ -21,7 +21,7 @@ async function fixture(t) {
       if (body.stream) {
         res.setHeader('content-type', 'text/event-stream');
         res.write(`data: {"choices":\ndata: [{"index":0,"delta":{"content":"${summary}"}}]}\n\n`);
-        if (!truncate) res.write(`data: {"choices":[{"index":0,"delta":{},"finish_reason":"${finish}"}]}\n\ndata: [DONE]\n\n`);
+        if (!truncate) res.write(`data: {"choices":[{"index":0,"delta":{},"finish_reason":${JSON.stringify(finish)}}]}\n\ndata: [DONE]\n\n`);
         res.end();
       } else { res.setHeader('content-type', 'application/json'); res.end(JSON.stringify({ choices: [{ message: { content: summary }, finish_reason: finish }] })); }
     });
@@ -77,3 +77,19 @@ test('WS compaction replays the compacted state through previous_response_id', {
   assert.match(JSON.stringify(f.received.at(-1).messages), /KEEP_DECISION_7391.*NEXT_TURN/);
   assert.doesNotMatch(JSON.stringify(f.received.at(-1).messages), /ORIGINAL_HISTORY/);
 });
+test('stream cut without finish_reason renders error, not completed', { timeout: 20000 }, async t => {
+  const f = await fixture(t); f.failure('stop', true);
+  const codex = events(await (await f.send({ model: 'm', stream: true, input: [{ role: 'user', content: 'hi' }] })).text());
+  assert.ok(codex.some(e => e.type === 'response.failed'), JSON.stringify(codex));
+  assert.ok(!codex.some(e => e.type === 'response.completed'), JSON.stringify(codex));
+  const claude = await fetch(`http://127.0.0.1:${f.port}/v1/messages`, { method: 'POST', headers: { 'content-type': 'application/json', 'x-profile': 'p1' },
+    body: JSON.stringify({ model: 'm', max_tokens: 64, stream: true, messages: [{ role: 'user', content: 'hi' }] }) });
+  const claudeEvents = events(await claude.text());
+  assert.ok(claudeEvents.some(e => e.type === 'error'), JSON.stringify(claudeEvents));
+  assert.ok(!claudeEvents.some(e => e.type === 'message_stop'), JSON.stringify(claudeEvents));
+});
+test('stream closed by [DONE] without finish_reason still completes', { timeout: 20000 }, async t => {
+  const f = await fixture(t); f.failure(null);
+  const codex = events(await (await f.send({ model: 'm', stream: true, input: [{ role: 'user', content: 'hi' }] })).text());
+  assert.ok(codex.some(e => e.type === 'response.completed'), JSON.stringify(codex));
+});