llm-switcher 1.6.5 → 1.6.6

package/tests/tool-repair.test.mjs

@@ -2,9 +2,9 @@
 // declared. Sources for every name here are collected in docs/tool-vocabulary.md.
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { createToolVocab, NULL_TOOL_VOCAB, tokenize, sanitizeToolName } from '../toolvocab.mjs';
+import { createToolVocab, NULL_TOOL_VOCAB, tokenize, sanitizeToolName, toolNameMapForIR } from '../toolvocab.mjs';
 import {
-  anthropicToIR, responsesToIR, irToChatBody, buildAnthropicMessage, buildChatMessage, buildResponsesMessage,
+  anthropicToIR, responsesToIR, irToChatBody, irToAnthropicBody, irToVertexBody, buildAnthropicMessage, buildChatMessage, buildResponsesMessage,
   createAnthropicStream, createChatStream, createResponsesStream
 } from '../formats.mjs';
 
@@ -17,6 +17,123 @@ const claudeTools = () => anthropicToIR({
   ]
 });
 
+const consoleTool = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+const networkTool = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_network_requests';
+
+function toolSearchHistory(extraTools = []) {
+  return anthropicToIR({
+    model: 'claude-opus-5-5', system: `Inspect errors with ${consoleTool} and ${networkTool}.`,
+    messages: [
+      { role: 'user', content: 'Inspect console errors.' },
+      { role: 'assistant', content: [{ type: 'tool_use', id: 'search1', name: 'ToolSearch', input: { query: `select:${consoleTool},${networkTool}`, max_results: 5 } }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'search1', content: [
+        { type: 'tool_reference', tool_name: consoleTool }, { type: 'tool_reference', tool_name: networkTool }
+      ] }] }
+    ],
+    tools: [
+      { name: 'ToolSearch', description: `Find tools such as ${consoleTool}.`, input_schema: { type: 'object', properties: { query: { type: 'string' }, max_results: { type: 'number' } } } },
+      ...[consoleTool, networkTool, ...extraTools].map(name => ({ name, input_schema: { type: 'object', properties: { pageSize: { type: 'integer' } } } }))
+    ]
+  });
+}
+
+test('ToolSearch references, query history and instructions agree with declared aliases across upstream formats', () => {
+  const ir = toolSearchHistory();
+  const original = JSON.stringify(ir);
+  for (const [emit, model, opts] of [
+    [irToChatBody, 'zencore/space-bunny-free', {}],
+    [irToChatBody, 'zencore/space-bunny-free', { thinkingMode: 'off' }],
+    [irToChatBody, 'zencore/space-bunny-free', { thinkingMode: 'native' }],
+    [irToAnthropicBody, 'claude-opus-5-5', {}],
+    [irToVertexBody, 'gemini-3.8-flash', {}]
+  ]) {
+    const body = emit(ir, model, opts);
+    const serialized = JSON.stringify(body);
+    const names = toolNameMapForIR(ir, { allowHyphens: emit !== irToVertexBody });
+    for (const name of [consoleTool, networkTool]) {
+      assert.ok(serialized.includes(names.name(name)), 'model sees the declared alias');
+      assert.ok(!serialized.includes(name), 'original no longer competes with the alias');
+    }
+    assert.equal(JSON.stringify(ir), original, 'conversion never mutates caller history');
+  }
+});
+
+test('ToolSearch instructions use collision-resolved aliases instead of the reserved original name', () => {
+  const reserved = sanitizeToolName(consoleTool);
+  const ir = toolSearchHistory([reserved]);
+  const names = toolNameMapForIR(ir);
+  assert.notEqual(names.name(consoleTool), reserved);
+  const body = irToChatBody(ir, 'zencore/space-bunny-free');
+  assert.equal(body.tools.find(t => t.function.name === reserved).function.name, reserved);
+  const references = body.messages.find(m => m.role === 'tool').content.split('\n').map(JSON.parse);
+  assert.equal(references[0].tool_name, names.name(consoleTool));
+  assert.ok(body.messages[0].content.includes(names.name(consoleTool)));
+  const notice = irToChatBody({ ...ir, system: '' }, 'x').messages[0].content;
+  assert.ok(notice.includes(names.name(consoleTool)), 'notice uses the collision-resolved declaration too');
+  const vocab = createToolVocab(ir.tools);
+  const response = buildAnthropicMessage({ model: 'x', tools: [{ name: 'ToolSearch', args: JSON.stringify({ query: `select:${names.name(consoleTool)},${reserved}` }) }], vocab });
+  assert.equal(response.content[0].input.query, `select:${consoleTool},${reserved}`);
+});
+
+test('only structured references and ToolSearch queries change; caller data, schemas and unknown tools survive', () => {
+  const ir = toolSearchHistory();
+  const unknown = 'mcp__not_declared__inspect';
+  ir.messages[0].content = `User data mentions ${consoleTool}.`;
+  ir.messages[1].toolCalls.push({ id: 'data1', name: consoleTool, args: { pageSize: 0, query: consoleTool } });
+  ir.messages.push({ role: 'tool', toolCallId: 'data1', content: `Log contains ${consoleTool}.` });
+  ir.messages[2].toolResultParts.push({ type: 'tool_reference', tool_name: unknown });
+  ir.tools[1].parameters.properties.query = { type: 'string', const: consoleTool };
+  const body = irToChatBody(ir, 'x');
+  assert.equal(body.messages.find(m => m.role === 'user').content, ir.messages[0].content);
+  assert.equal(body.messages.find(m => m.tool_call_id === 'data1').content, `Log contains ${consoleTool}.`);
+  const calls = body.messages.find(m => m.tool_calls).tool_calls;
+  assert.deepEqual(JSON.parse(calls[1].function.arguments), { pageSize: 0, query: consoleTool });
+  assert.equal(JSON.parse(calls[0].function.arguments).max_results, 5);
+  assert.ok(body.messages.find(m => m.tool_call_id === 'search1').content.includes(unknown));
+  assert.equal(body.tools[1].function.parameters.properties.query.const, consoleTool);
+  const vocab = createToolVocab(ir.tools);
+  assert.equal(vocab.name(unknown), unknown);
+  const malformed = '{"query":"select:';
+  assert.equal(vocab.args('ToolSearch', malformed), malformed);
+});
+
+test('fragmented streamed ToolSearch queries restore original names before the client executes them', () => {
+  const ir = toolSearchHistory();
+  const vocab = createToolVocab(ir.tools);
+  const args = JSON.stringify({ query: `select:${sanitizeToolName(consoleTool)},${sanitizeToolName(networkTool)}`, max_results: 5 });
+  for (const create of [createAnthropicStream, createChatStream, createResponsesStream]) {
+    const events = [];
+    const renderer = create((event, data) => events.push({ event, data }), 'x', { vocab });
+    renderer.start();
+    renderer.tool({ index: 0, id: 'search2', name: 'ToolSearch', args: '' });
+    for (let i = 0; i < args.length; i += 7) renderer.tool({ index: 0, args: args.slice(i, i + 7) });
+    renderer.finish('tool_calls', { hasTools: true });
+    let restored;
+    if (create === createAnthropicStream) restored = events.filter(e => e.data?.delta?.type === 'input_json_delta').map(e => e.data.delta.partial_json).join('');
+    else if (create === createChatStream) restored = events.flatMap(e => e.data?.choices?.[0]?.delta?.tool_calls || []).map(c => c.function?.arguments || '').join('');
+    else restored = events.find(e => e.event === 'response.output_item.done').data.item.arguments;
+    assert.deepEqual(JSON.parse(restored), { query: `select:${consoleTool},${networkTool}`, max_results: 5 });
+  }
+  const argsUnrelated = JSON.stringify({ query: sanitizeToolName(consoleTool) });
+  assert.equal(vocab.args(consoleTool, argsUnrelated), argsUnrelated, 'other tools keep their arguments');
+});
+
+test('repairing one parallel Chat ToolSearch call never flushes another unfinished query', () => {
+  const vocab = createToolVocab(toolSearchHistory().tools);
+  const events = [];
+  const renderer = createChatStream((event, data) => events.push(data), 'x', { vocab });
+  renderer.start();
+  renderer.tool({ index: 0, name: 'ToolSearch', args: '{"query":"select:' });
+  renderer.tool({ index: 1, name: 'ToolSearch', args: JSON.stringify({ query: `select:${sanitizeToolName(networkTool)}` }) });
+  renderer.tool({ index: 0, args: `${sanitizeToolName(consoleTool)}"}` });
+  renderer.finish('tool_calls');
+  for (const [index, original] of [[0, consoleTool], [1, networkTool]]) {
+    const args = events.flatMap(e => e.choices?.[0]?.delta?.tool_calls || [])
+      .filter(c => c.index === index).map(c => c.function?.arguments || '').join('');
+    assert.equal(JSON.parse(args).query, `select:${original}`);
+  }
+});
+
 // A model that answers `read` when the caller declared `Read` ends the turn with
 // "No such tool available: read". The name comes back in the caller's words.
 test('a name the model reached for comes back in the caller own words', () => {

package/tests/update.test.mjs

@@ -184,7 +184,7 @@ test('a release on npm is installed before the checkout is asked at all', async
   const r = await applyUpdate({ root: fx.install, registryUrl: await registry(t, '1.0.1'), run: recording(calls) });
 
   const order = calls.map(c => c[0]);
-  assert.deepEqual(order.slice(0, 2), ['npm', 'git'], `npm first, then the checkout: ${order.join(' ')}`);
+  assert.deepEqual(order.slice(0, 2), [process.platform === 'win32' ? 'cmd.exe' : 'npm', 'git'], `npm first, then the checkout: ${order.join(' ')}`);
   assert.deepEqual(calls[0].slice(-3), ['install', '-g', 'llm-switcher@1.0.1']);
   // npm put the release in the global prefix, which is not this directory, so the checkout is what
   // moved -- and that is the version this gateway runs, which is the only reason the pull happened.
@@ -226,7 +226,7 @@ test('an npm install that fails does not stop a checkout from updating', async (
   const logs = [];
   // npm refuses the version a fixture registry names, the way a real registry would.
   const run = async (cmd, args, opts) => {
-    if (cmd === 'npm') throw new Error('npm install failed: notarget No matching version found');
+    if (cmd === 'npm' || cmd === 'cmd.exe') throw new Error('npm install failed: notarget No matching version found');
     return recording([])(cmd, args, opts);
   };
   const r = await applyUpdate({ root: fx.install, registryUrl: await registry(t, '1.0.1'), run, logger: m => logs.push(m) });

package/tests/upstream-stream.test.mjs

@@ -0,0 +1,30 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readUpstreamPayloads } from '../upstream-stream.mjs';
+
+async function collect(text, widths = [1, 3, 7]) {
+  const bytes = Buffer.from(text); let offset = 0, i = 0;
+  const body = new ReadableStream({ pull(controller) {
+    if (offset === bytes.length) return controller.close();
+    const end = Math.min(bytes.length, offset + widths[i++ % widths.length]);
+    controller.enqueue(bytes.subarray(offset, end)); offset = end;
+  } });
+  const values = [];
+  for await (const value of readUpstreamPayloads({ body })) values.push(value);
+  return values;
+}
+test('multiline SSE joins data fields across CRLF, byte chunks and UTF-8', async () => {
+  const text = ': ping\r\nevent: message\r\nid: 1\r\nretry: 1000\r\ndata: {"choices":\r\ndata: [{"delta":{"content":"giữ ngữ cảnh"}}]}\r\n\r\ndata: [DONE]\r\n\r\n';
+  assert.deepEqual(await collect(text), [{ choices: [{ delta: { content: 'giữ ngữ cảnh' } }] }]);
+});
+test('Vertex JSON lines and final SSE event without delimiter both survive', async () => {
+  assert.deepEqual(await collect('{"one":1}\n{"two":2}'), [{ one: 1 }, { two: 2 }]);
+  assert.deepEqual(await collect('data: {"one":1}'), [{ one: 1 }]);
+});
+test('malformed JSON is surfaced and stopping consumption cancels the upstream', async () => {
+  await assert.rejects(collect('data: {"partial":\n\n'), SyntaxError);
+  let canceled = false;
+  const body = new ReadableStream({ start(c) { c.enqueue(Buffer.from('data: {"one":1}\n\n')); }, cancel() { canceled = true; } });
+  for await (const item of readUpstreamPayloads({ body })) { assert.equal(item.one, 1); break; }
+  assert.equal(canceled, true);
+});

package/toolvocab.mjs

@@ -220,7 +220,55 @@ export function sanitizeToolName(name, { allowHyphens = true } = {}) {
  *
  * A list with no tools, or one where nothing can be confused, leaves every call untouched.
  */
-export function createToolVocab(declared) {
+export function createToolNameMap(names, options = {}) {
+  const originals = [...new Set(names.filter(n => typeof n === 'string' && n))].sort();
+  const forward = new Map();
+  const reverse = new Map();
+  // Reserve unchanged names before allocating aliases, independent of declaration order.
+  for (const name of originals) {
+    if (sanitizeToolName(name, options) === name) { forward.set(name, name); reverse.set(name, name); }
+  }
+  for (const name of originals) {
+    if (forward.has(name)) continue;
+    const base = sanitizeToolName(name, options);
+    let alias = base;
+    for (let salt = 0; reverse.has(alias); salt++) {
+      const hash = crypto.createHash('sha256').update(`${name}\0${salt}`).digest('hex').slice(0, 12);
+      alias = `${base.slice(0, 51)}_${hash}`;
+    }
+    forward.set(name, alias); reverse.set(alias, name);
+  }
+  return { forward, reverse, name: n => forward.get(n) || sanitizeToolName(n, options) };
+}
+
+export function toolNameMapForIR(ir, options = {}) {
+  const names = [...(ir.tools || []).map(t => t.name),
+    ...(ir.messages || []).flatMap(m => [...(m.toolCalls || []).map(t => t.name), ...(m.name ? [m.name] : [])]),
+    ...(ir.toolChoice?.name ? [ir.toolChoice.name] : [])];
+  return createToolNameMap(names, options);
+}
+
+// Rewrite exact name mentions once, using the same collision-resolved map as declarations.
+// A longer identifier containing a name is not a mention of that tool.
+export function rewriteToolNameMentions(text, names) {
+  if (typeof text !== 'string') return text;
+  const changed = [...names].filter(([from, to]) => from && from !== to);
+  if (!changed.length) return text;
+  const lookup = new Map(changed);
+  const alternatives = changed.map(([from]) => from).sort((a, b) => b.length - a.length)
+    .map(n => n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  const pattern = new RegExp(`(?<![A-Za-z0-9_-])(?:${alternatives.join('|')})(?![A-Za-z0-9_-])`, 'g');
+  return text.replace(pattern, name => lookup.get(name));
+}
+
+// Only ToolSearch's query names other tools. Arbitrary tool arguments are caller data.
+export function rewriteToolSearchArgs(name, args, names) {
+  if (name !== 'ToolSearch' || !args || typeof args !== 'object' || Array.isArray(args) || typeof args.query !== 'string') return args;
+  const query = rewriteToolNameMentions(args.query, names);
+  return query === args.query ? args : { ...args, query };
+}
+
+export function createToolVocab(declared, { allowHyphens = true, names = [] } = {}) {
   // Only a tool the caller executes can be a rename target. A tool the provider runs answers in
   // band and its result reaches the caller without the caller executing anything; handing such a
   // call back as a client tool moves the work, silently, to the machine the user is sitting at.
@@ -229,17 +277,12 @@ export function createToolVocab(declared) {
   const byName = new Map();
   const candidates = [];
   const shortenedToOriginal = new Map();
+  const aliases = createToolNameMap([...tools.map(t => t.name), ...names], { allowHyphens });
 
   for (const t of tools) {
     const caps = capabilitiesOf(t.name);
-    const safeChat = sanitizeToolName(t.name, { allowHyphens: true });
-    const safeVertex = sanitizeToolName(t.name, { allowHyphens: false });
-    if (safeChat !== t.name) {
-      shortenedToOriginal.set(safeChat, t.name);
-    }
-    if (safeVertex !== t.name) {
-      shortenedToOriginal.set(safeVertex, t.name);
-    }
+    const alias = aliases.forward.get(t.name);
+    if (alias !== t.name) shortenedToOriginal.set(alias, t.name);
     const entry = { tool: t, name: t.name, namespace: namespaceOf(t.name), caps };
     // Keyed by the exact spelling: a client checks tool names exactly, so `read` is not the same
     // tool as `Read` to it, and that difference is the whole reason this layer exists.
@@ -283,7 +326,7 @@ export function createToolVocab(declared) {
 
   function args(upstream, argsJson) {
     const fixedName = name(upstream);
-    if (!useful && !shortenedToOriginal.has(String(upstream || ''))) return argsJson;
+    if (!useful && !shortenedToOriginal.has(String(upstream || '')) && !needsArgsRewrite(upstream)) return argsJson;
     const target = byName.get(fixedName);
     if (!target) return argsJson;
     let parsed;
@@ -292,15 +335,20 @@ export function createToolVocab(declared) {
     } catch {
       return argsJson;   // a truncated payload is passed through: changing bytes helps nobody
     }
-    const repaired = repairArgs(parsed, target.tool);
+    const repaired = rewriteToolSearchArgs(fixedName, repairArgs(parsed, target.tool), shortenedToOriginal);
     if (repaired === parsed) return argsJson;
     return JSON.stringify(repaired);
   }
 
+  function needsArgsRewrite(upstream) {
+    return name(upstream) === 'ToolSearch' && byName.has('ToolSearch') && shortenedToOriginal.size > 0;
+  }
+
   return {
     name,
     args,
     isShortened,
+    needsArgsRewrite,
     /** Both halves at once, for a call that is already whole. */
     repair(upstream, argsJson) {
       const fixedName = name(upstream);

package/upstream-stream.mjs

@@ -0,0 +1,37 @@
+// SSE dispatches one event at a blank line; data fields are joined with newlines.
+// Vertex also sends bare JSON lines. Keep both framings without parsing data fields separately.
+export async function* readUpstreamPayloads(upstreamRes) {
+  const reader = upstreamRes.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '', data = [], finished = false;
+  const parse = value => {
+    const text = value.trim();
+    if (!text || text === '[DONE]') return null;
+    return JSON.parse(text);
+  };
+  function line(value) {
+    if (value.endsWith('\r')) value = value.slice(0, -1);
+    if (!value) { const payload = data.join('\n'); data = []; return parse(payload); }
+    if (value.startsWith('data:')) { data.push(value.slice(5).replace(/^ /, '')); return null; }
+    if (value.startsWith('{') && !data.length) return parse(value);
+    return null;
+  }
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) { finished = true; buffer += decoder.decode(); break; }
+      buffer += decoder.decode(chunk.value, { stream: true });
+      let newline;
+      while ((newline = buffer.indexOf('\n')) !== -1) {
+        const payload = line(buffer.slice(0, newline)); buffer = buffer.slice(newline + 1);
+        if (payload) yield payload;
+      }
+    }
+    if (buffer) { const payload = line(buffer); if (payload) yield payload; }
+    // Tolerate an upstream's missing final blank line; completion is validated by the caller.
+    const tail = parse(data.join('\n')); if (tail) yield tail;
+  } finally {
+    if (!finished) await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}