llm-switcher 1.6.18 → 1.6.20

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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.
+
 ## Release 1.6.18 — 2026-10-22
 
 - **DeepSeek and Kimi on a turn with no reasoning.** `hasNativeReasoning` now matches `deepseek` and `kimi` model ids. Codex sends a continue or compaction turn with no reasoning item, and the proxy took such a model for a non-thinking one. The tool-call turns then went out with no `reasoning_content`, and DeepSeek thinking mode answered 400 "reasoning_content must be passed back". A model that is not a thinking model still gets no field, and `thinkingMode: off` still sends none.

package/formats.mjs

@@ -178,11 +178,17 @@ function smartToolCalls(node) {
     // Follow-up OpenAI stream chunks only carry {index, function:{arguments}} (no name/id):
     // they must still be kept, otherwise all args after the first chunk are lost.
     if (!name && (rawArgs === undefined || rawArgs === null || rawArgs === '')) return null;
+    // The opening chunk of a streamed call names the tool and carries no arguments yet (the
+    // field is absent or null). Filling in "{}" there glues onto the pieces that follow and
+    // yields `{}{"cmd":...}`, which Codex stores and sends back as history. A chunk that has an
+    // index is a stream chunk, so its missing arguments are empty, not an empty object.
+    const opening = (rawArgs === undefined || rawArgs === null) && typeof tc.index === 'number'
+      && tc.function && typeof tc.function === 'object';
     return {
       index: (typeof tc.index === 'number' ? tc.index : idx),
       id: tc.id || fn.id || null,
       name: name || null,
-      args: typeof rawArgs === 'string' ? rawArgs : (name ? JSON.stringify(rawArgs ?? {}) : JSON.stringify(rawArgs)),
+      args: typeof rawArgs === 'string' ? rawArgs : (opening ? '' : (name ? JSON.stringify(rawArgs ?? {}) : JSON.stringify(rawArgs))),
       sig: tc.extra_content?.google?.thought_signature || null
     };
   };
@@ -1197,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;
@@ -1206,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.18",
+  "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

@@ -284,6 +284,61 @@ test('Anthropic renderer: think -> tool -> think -> text produces a valid event
   assert.ok(events.some(e => e.data.delta?.signature === 'lsw1.sig123'), 'foreign signature is wrapped, never passed off as an Anthropic signature');
 });
 
+// A streamed call opens with {id, name} and no arguments. Filling "{}" in there glued onto the pieces that
+// followed and gave `{}{"cmd":...}`, which Codex stored and sent back as history; zencore then refused it.
+test('a streamed tool call that opens with no arguments does not start with {}', () => {
+  const norm = createUpstreamNormalizer();
+  const chunks = [
+    { choices: [{ index: 0, delta: { role: 'assistant', tool_calls: [{ index: 0, id: 'call_1', type: 'function', function: { name: 'exec_command' } }] } }] },
+    { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: '{"cmd"' } }] } }] },
+    { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: ':"ls"}' } }] } }] },
+    { choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }] }
+  ];
+  let args = '';
+  for (const c of chunks) for (const ev of [].concat(norm(c) || [])) for (const t of ev.tools || []) args += t.args;
+  assert.equal(args, '{"cmd":"ls"}');
+  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');