llm-switcher 1.1.6 → 1.1.8

package/README.md

@@ -191,7 +191,16 @@ flowchart LR
 
 ---
 
-## Changes in 1.1.6
+## Changes in 1.1.8
+
+- **Claude Code tools.** A tool schema value of `0`, `false`, `""` or `null` (for example `minimum: 0`) became an empty object schema. Gemini refused every Claude Code request with HTTP 400 "Starting an object on a scalar field". These values now stay as they are.
+- **Shim PATH order.** If the shim folder is on `PATH` but after the real `claude` or `codex`, `switch shim status` and `switch doctor` now tell you to put the export line last in your shell files.
+
+### Changes in 1.1.7
+
+- **Codex tools.** With `publicModels` set, Codex lost its tools and ended after one answer. The model catalog copied the metadata of a real OpenAI model, which puts Codex in the "Responses Lite" form. The catalog now keeps Codex in its direct tool mode, and the gateway also reads tools that arrive as an `additional_tools` input item.
+
+### Changes in 1.1.6
 
 - **Codex over WebSocket.** The gateway keeps the turns of each WebSocket session. A turn that sends `previous_response_id` gets the earlier turns back, so Codex no longer loses the task after the first tool call. An unknown id fails the turn with `previous_response_not_found`.
 - **Codex warmup.** A `response.create` frame with `generate: false` gets a local answer. It no longer spends a model call.

package/README.vi.md

@@ -191,7 +191,16 @@ flowchart LR
 
 ---
 
-## Thay đổi trong bản 1.1.6
+## Thay đổi trong bản 1.1.8
+
+- **Tool của Claude Code.** Giá trị `0`, `false`, `""` hoặc `null` trong schema của tool (ví dụ `minimum: 0`) bị đổi thành schema object rỗng. Gemini từ chối mọi request của Claude Code với HTTP 400 "Starting an object on a scalar field". Giờ các giá trị này được giữ nguyên.
+- **Thứ tự PATH của shim.** Nếu thư mục shim có trong `PATH` nhưng đứng sau `claude` hoặc `codex` thật, `switch shim status` và `switch doctor` giờ chỉ cách sửa: đặt dòng export ở cuối các file cấu hình shell.
+
+### Thay đổi trong bản 1.1.7
+
+- **Tool của Codex.** Khi có `publicModels`, Codex mất hết tool và dừng sau một câu trả lời. Model catalog chép metadata của một model OpenAI thật, và metadata này đưa Codex sang dạng "Responses Lite". Giờ catalog giữ Codex ở chế độ tool trực tiếp, và gateway cũng đọc tool gửi đến dưới dạng input item `additional_tools`.
+
+### Thay đổi trong bản 1.1.6
 
 - **Codex qua WebSocket.** Gateway giữ các lượt của mỗi phiên WebSocket. Lượt nào gửi `previous_response_id` sẽ nhận lại các lượt trước, nên Codex không còn mất nhiệm vụ sau lần gọi tool đầu tiên. Id không tồn tại làm lượt đó lỗi với `previous_response_not_found`.
 - **Warmup của Codex.** Frame `response.create` có `generate: false` được trả lời ngay tại máy. Frame này không còn tốn một lần gọi model.

package/formats.mjs

@@ -253,22 +253,24 @@ function smartDelta(choice) {
 const SCHEMA_MAPS = new Set(['properties', 'patternProperties', '$defs', 'definitions']);
 
 function sanitizeJsonSchema(schema) {
-  if (!schema) return { type: 'object', properties: {} };
-  if (typeof schema === 'string') {
-    return schema;
-  }
-  if (typeof schema !== 'object') return schema;
-  if (Array.isArray(schema)) return schema.map(sanitizeJsonSchema);
+  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.
+function sanitizeSchemaNode(schema) {
+  if (schema === null || typeof schema !== 'object') return schema;
+  if (Array.isArray(schema)) return schema.map(sanitizeSchemaNode);
   const clean = {};
   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;
     // 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, sanitizeJsonSchema(sub)]));
+      clean[k] = Object.fromEntries(Object.entries(v).map(([name, sub]) => [name, sanitizeSchemaNode(sub)]));
       continue;
     }
-    clean[k] = sanitizeJsonSchema(v);
+    clean[k] = sanitizeSchemaNode(v);
   }
   if (!clean.type && clean.properties) {
     clean.type = 'object';
@@ -612,6 +614,8 @@ function responsesToIR(payload) {
     else ir.messages.push({ role: 'assistant', toolCalls: [call] });
   };
 
+  // Responses Lite sends the tools as an input item, not in payload.tools.
+  const toolList = Array.isArray(payload.tools) ? [...payload.tools] : [];
   const input = payload.input;
   if (typeof input === 'string' && input) {
     ir.messages.push({ role: 'user', content: input });
@@ -655,14 +659,19 @@ function responsesToIR(payload) {
         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) });
+      } else if (item.type === 'additional_tools' && Array.isArray(item.tools)) {
+        toolList.push(...item.tools);
       }
     }
   }
 
-  if (Array.isArray(payload.tools) && payload.tools.length) {
+  if (toolList.length) {
     ir.toolMeta = {};
     const addTool = (t, namespace) => {
       if (!t || typeof t !== 'object') return;
+      // A tool in both payload.tools and an additional_tools item is sent once: upstreams refuse duplicate names.
+      if (t.name && t.type !== 'namespace' && ir.toolMeta[responsesToolName(namespace, t.name)]) return;
+      if (t.type === 'local_shell' && ir.toolMeta.local_shell) return;
       if (t.type === 'namespace' && Array.isArray(t.tools)) {
         for (const inner of t.tools) addTool(inner, t.name);
         return;
@@ -681,7 +690,7 @@ function responsesToIR(payload) {
       }
       // web_search / file_search / tool_search / image_generation...: hosted tools, skipped.
     };
-    for (const t of payload.tools) addTool(t, null);
+    for (const t of toolList) addTool(t, null);
   }
 
   const tc = payload.tool_choice;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code, Codex, OpenAI and Gemini clients",
   "keywords": [
     "llm",

package/shim.mjs

@@ -233,6 +233,15 @@ export function suggestedRcFiles(platform = process.platform) {
   return [path.join(home, '.profile')];
 }
 
+// The shim is on PATH but behind the real binary: a line that runs later prepends another directory
+// (npm-global, Homebrew). Login shells read the profile file, interactive shells the rc file.
+export function pathOrderHint(platform = process.platform) {
+  const files = suggestedRcFiles(platform);
+  if (!files.length) return [`Run this command, then open a new terminal: ${pathExportLine(platform)}`];
+  return [`Put this line LAST in ${files.join(' and ')}, after every other PATH line, then open a new terminal:`,
+    `    ${pathExportLine(platform)}`];
+}
+
 /**
  * Check whether running CLI processes have the gateway env.
  * This is the hardest failure to spot: a `claude` session opened BEFORE the gateway

package/state.mjs

@@ -346,8 +346,12 @@ export function buildCodexCatalog(profile) {
 
 // One catalog entry. The catalog file and the gateway's /v1/models both use it, so they cannot drift.
 export function codexModelEntry(name, is1M) {
+  // The template copies a real OpenAI model. Its Responses Lite and code modes send the tools in a
+  // form made for OpenAI's own tools, and an upstream then gets none (LS-5).
+  const { tool_mode, ...template } = structuredClone(codexCatalogTemplate() || {});
   return {
-    ...structuredClone(codexCatalogTemplate() || {}),
+    ...template,
+    use_responses_lite: false,
     slug: name,
     display_name: name,
     ...(is1M ? { context_window: 1000000, max_context_window: 1000000 } : {})

package/switch.mjs

@@ -13,7 +13,7 @@ import {
 } from './state.mjs';
 import { runProbe, runCheck } from './contract.mjs';
 import {
-  SHIM_DIR, installShims, uninstallShims, shimStatus, pathExportLine,
+  SHIM_DIR, installShims, uninstallShims, shimStatus, pathExportLine, pathOrderHint,
   suggestedRcFiles, auditRunningProcesses
 } from './shim.mjs';
 import {
@@ -739,6 +739,7 @@ async function manageShim(action = 'status') {
     if (s.active) console.log(`[PASS] ${s.name}: shim active → ${s.effective}`);
     else console.log(`[WARN] ${s.name}: shim installed but '${s.name}' resolves to ${s.effective || '(not found)'} — PATH order wrong`);
   }
+  if (st.onPath && st.shims.some(s => s.installed && !s.active)) for (const line of pathOrderHint()) console.log(`       ${line}`);
 
   const audit = auditActiveClis();
   if (!audit.supported) console.log('\n[INFO] The running-session check is not supported on Windows.');
@@ -832,6 +833,7 @@ async function runDoctor() {
     else if (!s.active) warn(`[WARN] '${s.name}' resolves to ${s.effective || '(not found)'} instead of the shim — PATH order wrong.`);
     else console.log(`[PASS] '${s.name}' routed through shim.`);
   }
+  if (sh.onPath && sh.shims.some(s => s.installed && !s.active)) for (const line of pathOrderHint()) console.log(`       ${line}`);
 
   // 7. Running processes missing env => those sessions call the provider directly
   const audit = auditActiveClis();

package/tests/formats.test.mjs

@@ -792,3 +792,26 @@ test('allowed_tools that matches no declared tool gives a request without tools,
     }
   }
 });
+
+test('responsesToIR reads additional_tools items and sends a tool once', () => {
+  const tool = { type: 'function', name: 'exec_command', parameters: { type: 'object' } };
+  const ir = responsesToIR({ model: 'm', tools: [tool], input: [{ type: 'additional_tools', role: 'developer', tools: [tool, { type: 'custom', name: 'apply_patch' }] }] });
+  assert.deepEqual(ir.tools.map(t => t.name), ['exec_command', 'apply_patch']);
+  assert.equal(ir.messages.length, 0, 'the item is not a message');
+});
+
+// ISS-CC-LS-001: a falsy value inside a schema (minimum: 0, additionalProperties: false) is a value,
+// not a missing schema. Gemini refuses an object where it expects a number.
+test('tool schemas keep 0, false, "" and null values', () => {
+  const schema = { type: 'object', additionalProperties: false, properties: {
+    total: { type: 'integer', minimum: 0, maximum: 9007199254740991 },
+    tags: { type: 'array', minItems: 0, items: { type: 'string', default: '' } },
+    note: { type: ['string', 'null'], default: null } } };
+  const ir = responsesToIR({ model: 'm', input: 'hi', tools: [{ type: 'function', name: 'f', parameters: schema }] });
+  const p = ir.tools[0].parameters;
+  assert.equal(p.additionalProperties, false);
+  assert.equal(p.properties.total.minimum, 0);
+  assert.equal(p.properties.tags.minItems, 0);
+  assert.equal(p.properties.tags.items.default, '');
+  assert.equal(p.properties.note.default, null);
+});

package/tests/gateway.e2e.test.mjs

@@ -845,6 +845,26 @@ test('Codex WS: a generate:false warmup is answered locally, never sent upstream
   ws.socket.destroy();
 });
 
+// LS-5: in the Responses Lite form Codex sends its tools as an additional_tools input item of the
+// warmup, not as a tools field. The next turn must reach upstream with those tools.
+test('Codex WS: tools sent as an additional_tools item reach upstream', async () => {
+  const ws = await rawWs();
+  ws.socket.write(clientFrame(1, JSON.stringify({ type: 'response.create', model: 'main', generate: false, input: [
+    { type: 'additional_tools', id: 'at_1', role: 'developer', tools: [
+      { type: 'function', name: 'exec_command', description: 'Run a command', parameters: { type: 'object', properties: { cmd: { type: 'string' } } } },
+      { type: 'custom', name: 'apply_patch', description: 'Patch files' }] },
+    { type: 'message', role: 'developer', content: [{ type: 'input_text', text: 'You are a coding agent.' }] }] })));
+  assert.ok(await until(() => ws.messages.some(m => m.type === 'response.completed')), 'the warmup completes');
+  const warmId = ws.messages.find(m => m.type === 'response.completed').response.id;
+  const before = received.length;
+  ws.socket.write(clientFrame(1, JSON.stringify({ type: 'response.create', model: 'main', previous_response_id: warmId,
+    input: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'fix calc.py' }] }] })));
+  assert.ok(await until(() => received.length > before && ws.messages.filter(m => m.type === 'response.completed' || m.type === 'response.failed').length === 2), 'turn 2 ends');
+  const sent = JSON.stringify(received.slice(before).at(-1).body);
+  assert.ok(sent.includes('exec_command') && sent.includes('apply_patch'), `the tools are lost: ${sent.slice(0, 400)}`);
+  ws.socket.destroy();
+});
+
 test('Codex WS: a mid-stream error is logged with its text', async () => {
   const ws = await rawWs();
   ws.socket.write(clientFrame(1, JSON.stringify({ type: 'response.create', model: 'main', input: 'MID_STREAM_ERROR over ws' })));

package/tests/shim.test.mjs

@@ -19,7 +19,7 @@ const ROOT = path.resolve(__dirname, '..');
 const STATE = fs.mkdtempSync(path.join(os.tmpdir(), 'shimstate-'));
 process.env.LLM_SWITCHER_STATE_DIR = STATE;
 
-const { SHIM_DIR, SHIMMED, pathExportLine, suggestedRcFiles, shimStatus, renderShim } =
+const { SHIM_DIR, SHIMMED, pathExportLine, pathOrderHint, suggestedRcFiles, shimStatus, renderShim } =
   await import(pathToFileURL(path.join(ROOT, 'shim.mjs')).href);
 
 // The behavioural tests run the CURRENT template, rendered into a temp dir. Running the copy
@@ -226,3 +226,19 @@ test('the POSIX shims source launch files only when this account owns them', ()
     }
   }
 });
+
+// ISS-CC-LS-002: on zsh a later line in .zshrc or .zprofile can prepend npm-global or Homebrew
+// ahead of the shim. The hint names both files and says the line must come last.
+test('pathOrderHint tells a zsh user to put the export last in .zshrc and .zprofile', () => {
+  const shell = process.env.SHELL;
+  process.env.SHELL = '/bin/zsh';
+  try {
+    const text = pathOrderHint('darwin').join('\n');
+    assert.match(text, /LAST/);
+    assert.match(text, /\.zshrc/);
+    assert.match(text, /\.zprofile/);
+    assert.ok(text.includes(pathExportLine('darwin')));
+  } finally {
+    if (shell === undefined) delete process.env.SHELL; else process.env.SHELL = shell;
+  }
+});

package/tests/state.test.mjs

@@ -699,3 +699,13 @@ test('an empty launch lock is held, not taken over', async (t) => {
   assert.ok(waited >= 100 && waited < 4000, `the writer waited ${waited} ms`);
   assert.equal(fs.existsSync(lock), false);
 });
+
+// LS-5: the template copies a real OpenAI model that runs Codex in Responses Lite and code mode.
+// Those modes send the tools in a form made for OpenAI's own tools, so every entry turns them off.
+test('buildCodexCatalog entries keep Codex in its direct tool mode', () => {
+  const catalog = buildCodexCatalog({ inFormat: 'responses', publicModels: ['gpt-5.6-sol'] });
+  for (const entry of catalog.models) {
+    assert.equal(entry.use_responses_lite, false);
+    assert.equal(Object.hasOwn(entry, 'tool_mode'), false);
+  }
+});