llm-switcher 1.6.13 → 1.6.15

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog — LLM Switcher
 
+## Release 1.6.15 — 2026-10-13
+
+- **A message inside a tool batch.** Codex can put a notice between two tool outputs of one parallel batch. The proxy now moves the notice after the batch. Before, the next real output was replaced with a placeholder.
+- **Files and documents in a tool output.** An `input_file` in a Responses tool output and a `document` in an Anthropic `tool_result` now go to the model as their name. Before, the proxy wrote their base64 data into the text, which can use millions of tokens. The `input_image` parts of a Responses tool output now reach the model as images.
+- **Two shims on `PATH`.** A shim now skips every LLM Switcher shim directory when it looks for the real binary. Before, two shims on `PATH` called each other with no end, and each call wrote a new CA bundle.
+
+## Release 1.6.14 — 2026-10-12
+
+- **System turn with an odd content shape.** On the translated route, a `system` turn whose `content` is not text and not a list is dropped. Before, the request failed with a `TypeError`.
+
 ## Release 1.6.13 — 2026-10-12
 
 - **`switch on` with no profile.** `switch on` gives each tool the profile that it had before `switch off`. A tool that was off stays off. A tool that is on keeps its profile.

package/formats.mjs

@@ -462,7 +462,7 @@ function anthropicToIR(payload) {
     const text =
       typeof msg.content === 'string'
         ? msg.content
-        : (msg.content || []).filter(p => p && p.type === 'text').map(p => p.text).join('\n');
+        : Array.isArray(msg.content) ? msg.content.filter(p => p && p.type === 'text').map(p => p.text).join('\n') : '';
     if (text.trim()) ir.system = ir.system ? `${ir.system}\n\n${text}` : text;
     return true;
   };
@@ -509,7 +509,7 @@ function anthropicToIR(payload) {
                   return '';
                 }
                 if (c?.type === 'tool_reference' && typeof c.tool_name === 'string') return c;
-                return JSON.stringify(c);
+                return mediaPlaceholder(c) ?? JSON.stringify(c);
               }).filter(Boolean);
               resultText = resultParts.map(c => typeof c === 'string' ? c : JSON.stringify(c)).join('\n');
             } else if (part.content) resultText = JSON.stringify(part.content);
@@ -679,12 +679,30 @@ function responsesOutputToText(out) {
       if (typeof x === 'string') return x;
       if (typeof x?.text === 'string') return x.text;
       if (x?.type === 'input_image') return '[image]';
-      return JSON.stringify(x);
+      return mediaPlaceholder(x) ?? JSON.stringify(x);
     }).join('\n');
   }
   return out == null ? '' : JSON.stringify(out);
 }
 
+// The input_image parts of a Responses tool output, as chat image parts.
+function responsesOutputImages(out) {
+  if (!Array.isArray(out)) return [];
+  return out.filter(x => x?.type === 'input_image')
+    .map(x => (typeof x.image_url === 'string' ? x.image_url : x.image_url?.url))
+    .filter(Boolean)
+    .map(url => ({ type: 'image_url', image_url: { url } }));
+}
+
+// A file or document block carries its bytes as base64; stringified into text it costs millions of tokens
+// (The-NeXT-AI/ai-gateway#28), so it is named instead. Null for any other block.
+function mediaPlaceholder(b) {
+  if (b?.type === 'input_file') return `[file: ${b.filename || b.file_id || 'attachment'}]`;
+  if (b?.type === 'document') return `[document${b.title ? `: ${b.title}` : ''}]`;
+  if (b?.source?.type === 'base64' || typeof b?.file_data === 'string') return `[${b.type || 'attachment'}]`;
+  return null;
+}
+
 // OpenAI Responses API (Codex) -> IR.
 function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
   const ir = baseIR();
@@ -772,7 +790,8 @@ function responsesToIR(payload, { allowOpaqueCompaction = false } = {}) {
         const a = item.action || {};
         pushCall({ id: item.call_id || item.id || null, name: 'local_shell', args: { command: a.command || [], workdir: a.working_directory ?? undefined, timeout_ms: a.timeout_ms ?? undefined } });
       } else if (item.type === 'function_call_output' || item.type === 'custom_tool_call_output' || item.type === 'local_shell_call_output') {
-        ir.messages.push({ role: 'tool', toolCallId: item.call_id || item.id, content: responsesOutputToText(item.output) });
+        const images = responsesOutputImages(item.output);
+        ir.messages.push({ role: 'tool', toolCallId: item.call_id || item.id, content: responsesOutputToText(item.output), ...(images.length ? { images } : {}) });
       } else if (item.type === 'additional_tools' && Array.isArray(item.tools)) {
         toolList.push(...item.tools);
       } else if (item.type === 'compaction') {
@@ -1032,13 +1051,15 @@ function hasNativeReasoning(model) {
 //    -> OpenAI: "assistant message with 'tool_calls' must be followed by tool messages"
 //
 // Rule: a tool result is only valid when placed right after the assistant turn that declared it. Orphaned results are
-// converted to user text (preserving context); tool calls missing a result get a placeholder result.
+// converted to user text (preserving context); tool calls missing a result get a placeholder result. A non-assistant
+// message inside an unanswered batch (Codex inserts notices there) moves after the batch, so later outputs still pair.
 const MISSING_TOOL_RESULT = '[Tool result unavailable: it was removed from the conversation history]';
 
 function healToolPairs(messages) {
   const out = [];
   let pending = null;   // Map<callId, name> of the most recent assistant turn
   let deferred = [];    // orphaned results seen while awaiting results -> flushed later to preserve adjacency
+  let held = [];        // non-tool messages seen while awaiting results -> emitted after the batch
   let seq = 0;
 
   const orphanText = (m) => ({
@@ -1055,6 +1076,8 @@ function healToolPairs(messages) {
     }
     for (const m of deferred) out.push(orphanText(m));
     deferred = [];
+    out.push(...held);
+    held = [];
   };
 
   let unnamed = [];     // ids given to calls that arrived with no id, in order
@@ -1068,6 +1091,7 @@ function healToolPairs(messages) {
         const name = pending.get(id);
         pending.delete(id);
         out.push({ ...m, toolCallId: id, name: m.name || name });
+        if (!pending.size) flush();
       } else if (pending) {
         deferred.push(m);
       } else {
@@ -1075,6 +1099,10 @@ function healToolPairs(messages) {
       }
       continue;
     }
+    if (pending?.size && m.role !== 'assistant') {
+      held.push(m);
+      continue;
+    }
     flush();
     if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
       unnamed = [];
@@ -1850,7 +1878,7 @@ function isBlankText(b) {
 function toolResultText(block) {
   const c = block.content;
   const text = typeof c === 'string' ? c
-    : Array.isArray(c) ? c.map(x => (x?.type === 'text' ? x.text : x?.type === 'image' ? '[image omitted]' : JSON.stringify(x))).join('\n')
+    : Array.isArray(c) ? c.map(x => (x?.type === 'text' ? x.text : x?.type === 'image' ? '[image omitted]' : mediaPlaceholder(x) ?? JSON.stringify(x))).join('\n')
     : c ? JSON.stringify(c) : '';
   return `[Tool Result${block.tool_use_id ? ` (${block.tool_use_id})` : ''}]: ${text}`;
 }

package/package.json

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

package/shim.mjs

@@ -201,7 +201,8 @@ for _v in $(compgen -v LLM_SWITCHER_CODEX_ 2>/dev/null); do
 done
 ${caBlock}
 
-# Find the real binary: drop the shim directory from PATH so it doesn't call itself.
+# Find the real binary: drop every switcher shim directory from PATH, this one and any other
+# (a second install, a test HOME), or two shims call each other forever.
 CLEAN_PATH=""
 IFS=':'
 for p in $PATH; do
@@ -209,6 +210,7 @@ for p in $PATH; do
     "$SHIM_DIR"|"$SHIM_DIR"/) continue ;;
   esac
   [ -z "$p" ] && continue
+  if [ -f "$p/${name}" ] && grep -q 'Auto-generated by LLM Switcher' "$p/${name}" 2>/dev/null; then continue; fi
   if [ -z "$CLEAN_PATH" ]; then CLEAN_PATH="$p"; else CLEAN_PATH="$CLEAN_PATH:$p"; fi
 done
 unset IFS

package/tests/formats.test.mjs

@@ -112,6 +112,17 @@ test('healAnthropicPayload: native Anthropic passthrough keeps the billing heade
   assert.equal(payload.system[0].text, header);
 });
 
+test('anthropicToIR: a system turn whose content is neither text nor a list is dropped, not thrown', () => {
+  for (const content of [{ type: 'text', text: 'odd' }, 42, null]) {
+    const ir = anthropicToIR({
+      model: 'claude-opus-4-6', max_tokens: 10,
+      messages: [{ role: 'system', content }, { role: 'user', content: 'hi' }]
+    });
+    assert.equal(ir.system, '', JSON.stringify(content));
+    assert.deepEqual(ir.messages.map(m => m.role), ['user']);
+  }
+});
+
 test('anthropicToIR: a system turn folds into the IR system prompt', () => {
   const ir = anthropicToIR({
     model: 'claude-opus-4-6', max_tokens: 10,
@@ -1688,3 +1699,58 @@ test('the placeholder strip refuses a client name that two padded tools share',
   assert.deepEqual(JSON.parse(vocab.args(alias[0], filled)), { env: {} });
   assert.equal(vocab.args('a_b', filled), filled, 'a_b declared its own _placeholder');
 });
+
+test('responsesToIR + irToChatBody: a notice inside a parallel batch moves after it and every real output is kept', () => {
+  // Codex inserts a notice between two outputs of one batch (openai/codex#52834).
+  const ir = responsesToIR({
+    model: 'x', input: [
+      { role: 'user', content: 'do two things' },
+      { type: 'function_call', call_id: 'c1', name: 'a', arguments: '{}' },
+      { type: 'function_call', call_id: 'c2', name: 'b', arguments: '{}' },
+      { type: 'function_call_output', call_id: 'c1', output: 'out1' },
+      { role: 'user', content: 'notice' },
+      { type: 'function_call_output', call_id: 'c2', output: 'out2' }
+    ]
+  });
+  for (const body of [irToChatBody(ir, 'gpt-4o')]) {
+    const shape = body.messages.map(m => m.role === 'tool' ? `tool:${m.content}` : `${m.role}`);
+    assert.deepEqual(shape, ['user', 'assistant', 'tool:out1', 'tool:out2', 'user']);
+  }
+  const anth = irToAnthropicBody(ir, 'claude-x');
+  const results = anth.messages[2].content.filter(b => b.type === 'tool_result').map(b => JSON.stringify(b.content));
+  assert.ok(results.every(r => !r.includes('unavailable')), `real outputs replaced: ${results}`);
+});
+
+test('a tool output that carries a file or an image never reaches the model as base64 text', () => {
+  // The-NeXT-AI/ai-gateway#28: a 5.9 MB image serialized as text became 4.1M tokens.
+  const blob = 'QUFB'.repeat(5000);
+  const fromResponses = responsesToIR({
+    model: 'x', input: [
+      { type: 'function_call', call_id: 'c1', name: 'shot', arguments: '{}' },
+      { type: 'function_call_output', call_id: 'c1', output: [
+        { type: 'input_image', image_url: `data:image/png;base64,${blob}` },
+        { type: 'input_file', filename: 'a.pdf', file_data: `data:application/pdf;base64,${blob}` }] }
+    ]
+  });
+  const fromAnthropic = anthropicToIR({
+    model: 'x', messages: [
+      { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'read', input: {} }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: [
+        { type: 'document', source: { type: 'base64', media_type: 'application/pdf', data: blob } }] }] }
+    ]
+  });
+  for (const [name, ir] of [['responses', fromResponses], ['anthropic', fromAnthropic]]) {
+    const tool = ir.messages.find(m => m.role === 'tool');
+    assert.ok(!tool.content.includes(blob), `${name}: tool text carries the base64`);
+  }
+  const tool = fromResponses.messages.find(m => m.role === 'tool');
+  assert.match(tool.content, /a\.pdf/);
+  assert.equal(tool.images?.[0]?.image_url?.url, `data:image/png;base64,${blob}`);
+});
+
+test('irToAnthropicBody: a whitespace-only text block is blank too', () => {
+  // Anthropic: "text content blocks must contain non-whitespace text".
+  const ir = anthropicToIR({ model: 'x', max_tokens: 10, messages: [{ role: 'user', content: [{ type: 'text', text: ' \n' }, { type: 'text', text: 'hi' }] }] });
+  const body = irToAnthropicBody(ir, 'claude');
+  assert.ok(body.messages.every(m => m.content.every(b => b.type !== 'text' || b.text.trim())), JSON.stringify(body.messages));
+});

package/tests/shim.test.mjs

@@ -119,6 +119,18 @@ test('shim never recurses into itself', (t) => {
   assert.match(out, /ARGS=x/);
 });
 
+test('two switcher shims on PATH never call each other', (t) => {
+  // A test HOME's shim ahead of the account's own shim: each dropped only its own directory, so they
+  // found each other forever, and every hop built a new CA bundle (2026-10-13: 702 files in 2 minutes).
+  if (process.platform === 'win32') return t.skip('posix only');
+  const other = fs.mkdtempSync(path.join(SCRATCH, 'shimother-'));
+  fs.copyFileSync(path.join(RENDER_DIR, 'claude'), path.join(other, 'claude'));
+  fs.chmodSync(path.join(other, 'claude'), 0o755);
+  const fake = makeFakeBin('claude');
+  const out = runShim('claude', ['x'], { active: true, fakeDir: other, extraPath: `${fake}:/usr/bin:/bin` });
+  assert.match(out, /ARGS=x/);
+});
+
 test('shim fails loudly (127) when the real binary is missing', (t) => {
   if (process.platform === 'win32') return t.skip('posix only');
   const empty = fs.mkdtempSync(path.join(SCRATCH, 'shimempty-'));