llm-switcher 1.6.19 → 1.6.20

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog — LLM Switcher
 
+## Release 1.6.20 — 2026-10-22
+
+- **Earlier calls to a tool the request does not declare stay as text.** Codex runs its shell through a freeform `exec` tool and keeps sending the calls it made, while a later request may declare only `exec_command`. The model read the history as its own vocabulary and answered `exec`, a tool the caller cannot run, and the upstream refused it as `undeclared tool 'exec'`. `irToChatBody` now writes such a call as `[earlier call to \`exec\`: ...]` with its result as a user message, and leaves every call to a declared tool as a real call, so a call and its result are never split. Through llm-switcher, intact and zencore with 6 to 22 earlier `exec` calls: 10 of 12 requests refused before, 0 of 12 after.
+
 ## Release 1.6.19 — 2026-10-22
 
 - **A streamed tool call no longer starts with `{}`.** The first chunk of a streamed call names the tool and carries no arguments. `smartToolCalls` filled in `{}` there, and the pieces that followed were glued on, giving `{}{"cmd":...}`. Codex stored that item and sent it back as history on the next turn, and zencore refused it with `upstream arguments do not match schema of tool 'exec_command'`. The first turn worked, so the failure only showed from the second turn on. Through a Codex-shaped loop of several turns, 6 of 7 turns failed before and 0 of 10 after.

package/formats.mjs

@@ -1203,8 +1203,21 @@ function irToChatBody(ir, model, opts = {}) {
   if (toolNotice) systemText = systemText ? `${systemText}\n\n${toolNotice}` : toolNotice;
   if (systemText.trim()) messages.push({ role: 'system', content: systemText });
 
+  // An earlier call to a tool this request no longer declares stays in the conversation as text. Codex
+  // runs its shell through a freeform `exec` tool and keeps sending the calls it made, while a later
+  // request may declare only `exec_command`. The model reads the history as its own vocabulary and
+  // answers `exec` again, a tool the caller cannot run; and a strict upstream refuses the history
+  // outright. As text the model keeps what happened and has no tool of that name to copy.
+  const declaredNames = new Set((ir.tools || []).map(t => toolName(t.name)));
+  const demoted = new Set();
   for (const m of healToolPairs(ir.messages)) {
     if (m.role === 'tool') {
+      if (demoted.has(m.toolCallId)) {
+        flushImages();
+        messages.push({ role: 'user', content: `[result of the earlier call]\n${m.content ?? ''}` });
+        if (m.images?.length) pendingImages.push({ type: 'text', text: `Images returned by tool call ${m.toolCallId}:` }, ...m.images);
+        continue;
+      }
       messages.push({ role: 'tool', tool_call_id: m.toolCallId, content: m.content ?? '' });
       if (m.images?.length) pendingImages.push({ type: 'text', text: `Images returned by tool call ${m.toolCallId}:` }, ...m.images);
       continue;
@@ -1212,8 +1225,23 @@ function irToChatBody(ir, model, opts = {}) {
     flushImages();
     const out = { role: m.role === 'assistant' ? 'assistant' : 'user' };
     if (m.content !== undefined) out.content = m.content;
-    if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
-      out.tool_calls = m.toolCalls.map(tc => {
+    let calls = m.role === 'assistant' && Array.isArray(m.toolCalls) ? m.toolCalls : [];
+    if (calls.length && declaredNames.size) {
+      const keep = [];
+      const notes = [];
+      for (const tc of calls) {
+        if (declaredNames.has(toolName(tc.name))) { keep.push(tc); continue; }
+        if (tc.id) demoted.add(tc.id);
+        notes.push(`[earlier call to \`${tc.name}\`: ${stringifyArgs(tc.args).slice(0, 4000)}]`);
+      }
+      if (notes.length) {
+        const text = typeof out.content === 'string' ? out.content : '';
+        out.content = (text ? `${text}\n` : '') + notes.join('\n');
+        calls = keep;
+      }
+    }
+    if (calls.length) {
+      out.tool_calls = calls.map(tc => {
         const call = { id: tc.id, type: 'function', function: { name: toolName(tc.name), arguments: stringifyArgs(tc.args) } };
         const sig = tc.sig || lookupToolSignature(tc.id);
         if (sig) call.extra_content = { google: { thought_signature: sig } };

package/package.json

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

package/tests/formats.test.mjs

@@ -300,6 +300,45 @@ test('a streamed tool call that opens with no arguments does not start with {}',
   assert.deepEqual(JSON.parse(args), { cmd: 'ls' });
 });
 
+// Codex runs its shell through a freeform `exec` tool and keeps sending the calls it made, while a later request
+// may declare only exec_command. The model copies the history's vocabulary and answers `exec`, which the caller
+// cannot run. The earlier call and its result stay in the conversation as text.
+test('irToChatBody turns earlier calls to a tool the request does not declare into text', () => {
+  const S = { type: 'string' };
+  const ir = responsesToIR({ model: 'x', tools: [
+    { type: 'function', name: 'exec_command', description: 'run', parameters: { type: 'object', properties: { cmd: S }, required: ['cmd'] } }
+  ], input: [
+    { type: 'message', role: 'user', content: 'look' },
+    { type: 'custom_tool_call', call_id: 'c1', name: 'exec', input: 'text(await tools.exec_command({cmd:"ls"}));' },
+    { type: 'custom_tool_call_output', call_id: 'c1', output: 'a b' },
+    { type: 'function_call', call_id: 'f1', name: 'exec_command', arguments: '{"cmd":"pwd"}' },
+    { type: 'function_call_output', call_id: 'f1', output: '/repo' },
+    { type: 'message', role: 'user', content: 'again' }
+  ] });
+  const msgs = irToChatBody(ir, 'zencore/deepseek-v4.1-flash-free', { thinkingMode: 'auto' }).messages;
+  const calls = msgs.flatMap(m => m.tool_calls || []);
+  assert.deepEqual(calls.map(c => c.function.name), ['exec_command']);
+  const note = msgs.find(m => m.role === 'assistant' && !m.tool_calls);
+  assert.match(note.content, /^\[earlier call to `exec`: .*tools\.exec_command/);
+  assert.ok(msgs.some(m => m.role === 'user' && m.content === '[result of the earlier call]\na b'));
+  // The declared call keeps its result as a real tool message, so the pair is never split.
+  assert.deepEqual(msgs.filter(m => m.role === 'tool').map(m => m.tool_call_id), ['f1']);
+});
+
+test('irToChatBody leaves a history of declared tools alone', () => {
+  const ir = responsesToIR({ model: 'x', tools: [
+    { type: 'function', name: 'exec_command', description: 'run', parameters: { type: 'object', properties: { cmd: { type: 'string' } } } }
+  ], input: [
+    { type: 'message', role: 'user', content: 'go' },
+    { type: 'function_call', call_id: 'f1', name: 'exec_command', arguments: '{"cmd":"pwd"}' },
+    { type: 'function_call_output', call_id: 'f1', output: '/repo' }
+  ] });
+  const msgs = irToChatBody(ir, 'gpt-5', { thinkingMode: 'auto' }).messages;
+  assert.equal(msgs.filter(m => m.tool_calls).length, 1);
+  assert.equal(msgs.filter(m => m.role === 'tool').length, 1);
+  assert.ok(!msgs.some(m => typeof m.content === 'string' && m.content.includes('earlier call')));
+});
+
 test('Responses renderer: emits output_item.done for every item with full content', () => {
   const events = [];
   const r = createResponsesStream((event, data) => events.push({ event, data }), 'm');