llm-switcher 1.6.17 → 1.6.19

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog — LLM Switcher
 
+## 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.
+- **Tool names in the debug log.** With `debug: true`, the proxy now logs the names of the tools it declares upstream and the `tool_choice`, on both the HTTP and the WebSocket route. Before, the log held the first 300 to 500 characters of the body, which never reached `tools`. This is how to tell whether an upstream "undeclared tool" error comes from a missing declaration.
+
 ## Release 1.6.17 — 2026-10-13
 
 - **Documents in a tool result.** A document with a text source, a content source or a URL goes to the model as its text or its URL. Before 1.6.17, it went as a bare `[document]` label. Only base64 data becomes a label, for example `[file: a.pdf]`.

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
     };
   };
@@ -1049,7 +1055,11 @@ function withUpstreamToolNames(ir, names) {
 function hasNativeReasoning(model) {
   // model IDs change often, but all current Opus variants support reasoning.
   const m = String(model || '').toLowerCase();
+  // DeepSeek and Kimi run in thinking mode by default and refuse the next tool step when an earlier
+  // tool-call turn lacks reasoning_content, even if the client (Codex on a continue/compaction turn)
+  // sent no reasoning item with the request.
   return m.includes('thinking') || m.includes('reasoning') || m.includes('reasoner') || m.includes('opus')
+    || m.includes('deepseek') || m.includes('kimi')
     || /(^|[/_.:-])(o[134]|r1|qwq)([/_.:-]|$)/.test(m);
 }
 

package/package.json

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

package/preflight-cache.json

@@ -0,0 +1,11 @@
+{
+  "claude": {
+    "cacheKey": "claude-intact:zencore/space-bunny-free,zencore/muse-spark-1.3-contributor-free",
+    "time": 1792631963371,
+    "lines": [
+      "[llm-switcher] claude -> claude-intact | 127.0.0.1:20142 | zencore/space-bunny-free",
+      "[llm-switcher:preflight] ⚠️ CẢNH BÁO: Model đã setup không còn khả dụng trên provider: 'zencore/space-bunny-free' [slot sonnet], 'zencore/muse-spark-1.3-contributor-free' [slot haiku].",
+      "[llm-switcher:preflight] Gợi ý: Chạy 'switch ui' để cập nhật lại model hợp lệ."
+    ]
+  }
+}

package/proxy.mjs

@@ -1320,6 +1320,7 @@ async function handleConvert(clientFormat, req, res, bodyBuffer, opts = {}) {
     const { url, headers, upBody } = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot, profileKey);
     if (traceId) headers['x-intact-trace'] = traceId;
     debugLog(`[${profileKey}] ${clientFormat} -> ${outFormat} ${url} ::`, JSON.stringify(upBody).slice(0, 500));
+    debugLog(`[${profileKey}] tools declared upstream:`, JSON.stringify((upBody.tools || []).map(t => t.function?.name ?? t.name ?? t.type)), 'tool_choice:', JSON.stringify(upBody.tool_choice ?? null));
 
     let upstreamRes;
     try {
@@ -2592,6 +2593,7 @@ async function handleWsResponseCreate(socket, payload, req, ac, history = null)
     const { url, headers, upBody } = buildUpstreamRequest(profile, outFormat, ir, mappedModel, req, slot, profileKey);
     if (traceId) headers['x-intact-trace'] = traceId;
     debugLog(`[${profileKey}:ws] ${clientFormat} -> ${outFormat} ${url} ::`, JSON.stringify(upBody).slice(0, 300));
+    debugLog(`[${profileKey}:ws] tools declared upstream:`, JSON.stringify((upBody.tools || []).map(t => t.function?.name ?? t.name ?? t.type)), 'tool_choice:', JSON.stringify(upBody.tool_choice ?? null));
 
     let upstreamRes;
     try {

package/tests/formats.test.mjs

@@ -284,6 +284,22 @@ 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' });
+});
+
 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');
@@ -1263,6 +1279,26 @@ test('irToChatBody replays thinking as reasoning_content on tool-call turns', ()
   assert.equal(rb.messages.find(m => m.tool_calls).reasoning_content, 'Plan: run ls');
 });
 
+// Codex continue/compaction turns carry no reasoning item; DeepSeek still answers 400 "reasoning_content must be passed back".
+test('irToChatBody auto mode replays reasoning_content for DeepSeek/Kimi even when the request has no reasoning', () => {
+  const ir = responsesToIR({ model: 'x', input: [
+    { type: 'message', role: 'user', content: 'go' },
+    { type: 'function_call', call_id: 'c1', name: 'exec', arguments: '{}' },
+    { type: 'function_call_output', call_id: 'c1', output: 'ok' },
+    { type: 'message', role: 'user', content: 'continue' }
+  ] });
+  for (const model of ['zencore/deepseek-v4.1-flash-free', 'buddycore/deepseek-v4.1-flash', 'zencore/kimi-k2.7']) {
+    const call = irToChatBody(ir, model, { thinkingMode: 'auto' }).messages.find(m => m.tool_calls);
+    assert.equal(call.reasoning_content, '', model);
+  }
+  for (const model of ['gpt-5', 'zencore/glm-5.3-flash-free']) {
+    const body = irToChatBody(ir, model, { thinkingMode: 'auto' });
+    assert.ok(body.messages.every(m => !('reasoning_content' in m)), model);
+  }
+  const off = irToChatBody(ir, 'zencore/deepseek-v4.1-flash-free', { thinkingMode: 'off' });
+  assert.ok(off.messages.every(m => !('reasoning_content' in m)));
+});
+
 // Strict OpenAI-compatible servers may refuse the extra key, so native mode sends it only on the profile opt-in.
 test('irToChatBody native mode sends no reasoning_content without the profile opt-in', () => {
   const ir = anthropicToIR({ model: 'x', max_tokens: 8000, thinking: { type: 'enabled', budget_tokens: 4000 }, messages: [