llm-switcher 1.6.4 → 1.6.6

package/tests/gateway.e2e.test.mjs

@@ -95,6 +95,19 @@ function startUpstream() {
         return res.end(JSON.stringify({ id: 'c1', object: 'chat.completion', model: json.model, choices: [{ index: 0, message: { role: 'assistant', content: 'converted ok' }, finish_reason: 'stop' }], usage: { prompt_tokens: 1, completion_tokens: 1 } }));
       }
       if (req.url.startsWith('/chat/v1/chat/completions')) {
+        if (lastUser.includes('TOOL_ALIAS_REPLAY')) {
+          const reference = json.messages.find(m => m.role === 'tool');
+          const name = JSON.parse(reference.content).tool_name;
+          if (!json.tools.some(t => t.function.name === name)) {
+            return sse(res, [{ error: { message: `upstream called undeclared tool '${name}'`, type: 'server_error' } }]);
+          }
+          return sse(res, [
+            { choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: 'console1', type: 'function', function: { name, arguments: '{"pageSize":0}' } }] } }] },
+            { choices: [{ index: 0, delta: { tool_calls: [{ index: 1, id: 'search2', type: 'function', function: { name: 'ToolSearch', arguments: '{"query":"select:' } }] } }] },
+            { choices: [{ index: 0, delta: { tool_calls: [{ index: 1, function: { arguments: `${name}","max_results":5}` } }] } }] },
+            { choices: [{ index: 0, delta: {}, finish_reason: 'tool_calls' }], usage: { prompt_tokens: 10, completion_tokens: 15 } }
+          ], { raw: ['data: [DONE]\n\n'] });
+        }
         if (lastUser.includes('RATE_LIMIT')) {
           res.writeHead(429, { 'Content-Type': 'application/json', 'retry-after': '7' });
           return res.end(JSON.stringify({ error: { message: 'slow down' } }));
@@ -650,6 +663,40 @@ test('Bifrost stays off for a model that is not a Claude Code account', async ()
   assert.equal(received.at(-1).url, '/intact/v1/chat/completions');
 });
 
+test('ToolSearch replay calls declared upstream aliases and restores original tool names and queries to Claude', async () => {
+  const name = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+  const res = await post('/v1/messages', {
+    model: 'claude-opus-4-6', max_tokens: 256, stream: true, system: `Use ${name} to inspect errors.`,
+    tools: [
+      { name: 'ToolSearch', input_schema: { type: 'object', properties: { query: { type: 'string' }, max_results: { type: 'integer' } } } },
+      { name, input_schema: { type: 'object', properties: { pageSize: { type: 'integer' } } } }
+    ],
+    messages: [
+      { role: 'user', content: 'Inspect errors.' },
+      { role: 'assistant', content: [{ type: 'tool_use', id: 'search1', name: 'ToolSearch', input: { query: `select:${name}` } }] },
+      { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: 'search1', content: [{ type: 'tool_reference', tool_name: name }] },
+        { type: 'text', text: 'TOOL_ALIAS_REPLAY' }
+      ] }
+    ]
+  });
+  assert.equal(res.status, 200);
+  const events = parseSSE(await res.text());
+  assertValidAnthropicEvents(events);
+  assert.ok(events.some(e => e.event === 'message_stop'));
+  assert.ok(!events.some(e => e.event === 'error'));
+  const starts = events.filter(e => e.data?.content_block?.type === 'tool_use');
+  assert.deepEqual(starts.map(e => e.data.content_block.name), [name, 'ToolSearch']);
+  const args = start => JSON.parse(events.filter(e => e.data?.index === start.data.index && e.data?.delta?.type === 'input_json_delta').map(e => e.data.delta.partial_json).join(''));
+  assert.deepEqual(args(starts[0]), { pageSize: 0 });
+  assert.deepEqual(args(starts[1]), { query: `select:${name}`, max_results: 5 });
+  const up = received.at(-1).body;
+  const alias = up.tools.find(t => t.function.name !== 'ToolSearch').function.name;
+  assert.equal(alias.length, 64);
+  assert.ok(!JSON.stringify(up.messages).includes(name));
+  assert.equal(JSON.parse(up.messages.find(m => m.tool_calls).tool_calls[0].function.arguments).query, `select:${alias}`);
+});
+
 test('Bifrost stays off for a client that is not Claude Code', async () => {
   await post('/v1/messages', { model: 'claude-opus-4-6', max_tokens: 10, messages: [{ role: 'user', content: 'hi' }] },
     { 'x-llm-profile': 'intactcc', 'user-agent': 'some-sdk/1.0' });

package/tests/state.test.mjs

@@ -139,7 +139,7 @@ test('computeLaunchState derives launch state per target profile, not from one g
   const names = (pairs) => pairs.map(([k]) => k).sort();
   // R2: exactly these names, each tool in its own file. Nothing here names an endpoint, a
   // model or a context window, so no tool can be reconfigured and none can capture the other.
-  assert.deepEqual(names(st.envClaude), ['HTTPS_PROXY', 'NO_PROXY', 'https_proxy', 'no_proxy']);
+  assert.deepEqual(names(st.envClaude), ['CLAUDE_CODE_TETHER_LIVE', 'HTTPS_PROXY', 'NO_PROXY', 'https_proxy', 'no_proxy']);
   assert.deepEqual(names(st.envCodex),
     ['CODEX_CA_CERTIFICATE', 'HTTPS_PROXY', 'NO_PROXY', 'https_proxy', 'no_proxy']);
   // The proxy is the interceptor, not the gateway itself (R3).
@@ -261,6 +261,10 @@ test('every active tool is routed through the interceptor with only the variable
   for (const [label, pairs] of [['claude', st.envClaude], ['codex', st.envCodex]]) {
     for (const [k, v] of pairs) {
       assert.ok(!/_URL$|BASE_URL/.test(k), `${label}: ${k} would print an override banner`);
+      if (k === 'CLAUDE_CODE_TETHER_LIVE') {
+        assert.equal(v, '0', `${label}: tether must be disabled`);
+        continue;
+      }
       assert.ok(!/MODEL|CONTEXT|WINDOW|CLAUDE_CODE_|OPENAI_/.test(k), `${label}: ${k} names a model`);
       assert.ok(typeof v === 'string' && v.length > 0, `${label}: ${k} must have a value`);
     }
@@ -382,6 +386,7 @@ test('the launch state writes no 1M tag or model variable, whatever model1M says
     const st = computeLaunchState(cfg, 4000);
     assert.equal(st.active, true, 'the profile is active whatever it marks 1M');
     for (const [k] of [...st.envClaude, ...st.envCodex]) {
+      if (k === 'CLAUDE_CODE_TETHER_LIVE') continue;
       assert.ok(!/ANTHROPIC|CLAUDE_CODE|OPENAI_|MODEL|1M|CONTEXT|WINDOW/.test(k),
         `${k} must not be written for ${JSON.stringify(model1M)}`);
     }

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 } 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', () => {
@@ -278,3 +395,112 @@ test('the notice and the think guide coexist', () => {
   assert.ok(sys.includes('<think> and </think>'), `the think guide is missing: ${sys}`);
   assert.match(sys, /use exactly these names/i);
 });
+
+// Tool names longer than 64 characters (e.g. MCP plugin tools) must be sanitized for OpenAI/Gemini
+// APIs (<= 64 chars, ^[a-zA-Z0-9_-]{1,64}$) and mapped back in responses.
+test('sanitizeToolName: enforces 1-64 character length and valid identifier charset', () => {
+  assert.equal(sanitizeToolName('Bash'), 'Bash');
+  assert.equal(sanitizeToolName('Read'), 'Read');
+  assert.equal(sanitizeToolName('mcp__github__create_issue'), 'mcp__github__create_issue');
+
+  const name64 = 'a'.repeat(64);
+  assert.equal(sanitizeToolName(name64), name64);
+
+  // Exact problematic tool from chrome-devtools MCP (70 chars)
+  const chromeDevToolsTool = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+  assert.equal(chromeDevToolsTool.length, 70);
+  const sanitized = sanitizeToolName(chromeDevToolsTool);
+  assert.ok(sanitized.length <= 64, `length must be <= 64, got ${sanitized.length}`);
+  assert.equal(sanitized.length, 64);
+  assert.match(sanitized, /^[a-zA-Z0-9_-]{1,64}$/);
+  assert.ok(sanitized.startsWith('mcp__plugin_chrome-devtools-mcp_'));
+  assert.ok(sanitized.endsWith('_list_console_messages'));
+
+  // Another long tool with different suffix gets a distinct hash
+  const networkTool = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_network_requests';
+  const sanitizedNetwork = sanitizeToolName(networkTool);
+  assert.equal(sanitizedNetwork.length, 64);
+  assert.notEqual(sanitized, sanitizedNetwork);
+
+  // allowHyphens: false for Vertex/Gemini
+  const vertexSanitized = sanitizeToolName(chromeDevToolsTool, { allowHyphens: false });
+  assert.equal(vertexSanitized.length, 64);
+  assert.match(vertexSanitized, /^[a-zA-Z_][a-zA-Z0-9_]*$/);
+  assert.ok(!vertexSanitized.includes('-'));
+});
+
+test('createToolVocab: round-trips >64 char tool names back to client declared name', () => {
+  const longName = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+  const ir = anthropicToIR({
+    model: 'claude-opus-4-6', messages: [{ role: 'user', content: 'check console' }],
+    tools: [
+      { name: longName, input_schema: { properties: { count: { type: 'number' } } } }
+    ]
+  });
+
+  const vocab = createToolVocab(ir.tools);
+  const upstreamSafe = sanitizeToolName(longName);
+  assert.notEqual(upstreamSafe, longName);
+  assert.equal(upstreamSafe.length, 64);
+
+  // Model answers with the sanitized name -> vocab recovers original declared name
+  assert.equal(vocab.name(upstreamSafe), longName);
+  assert.ok(vocab.isShortened(upstreamSafe));
+
+  // Streaming does not hold arguments for shortened names (they keep caller's schema)
+  const deltas = [];
+  const renderer = createAnthropicStream((event, data) => deltas.push({ event, data }), 'claude-opus-4-6', { vocab });
+  renderer.start();
+  renderer.tool({ index: 0, id: 'call_1', name: upstreamSafe, args: '{"count": 10}' });
+  renderer.finish('stop');
+
+  const startBlock = deltas.find(d => d.event === 'content_block_start');
+  assert.equal(startBlock.data.content_block.name, longName);
+
+  const jsonDelta = deltas.find(d => d.event === 'content_block_delta' && d.data.delta.type === 'input_json_delta');
+  assert.ok(jsonDelta, 'input_json_delta should be emitted');
+  assert.equal(jsonDelta.data.delta.partial_json, '{"count": 10}');
+
+  // Non-streaming builder also restores the original name
+  const msg = buildAnthropicMessage({
+    model: 'claude-opus-4-6',
+    tools: [{ index: 0, id: 'call_1', name: upstreamSafe, args: '{"count": 10}' }],
+    finish: 'tool_calls',
+    vocab
+  });
+  const toolUse = msg.content.find(c => c.type === 'tool_use');
+  assert.equal(toolUse.name, longName);
+});
+
+test('irToChatBody: serializes long tool names, assistant history, and toolChoice within 64 chars', () => {
+  const longName = 'mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages';
+  const ir = anthropicToIR({
+    model: 'gpt-4o',
+    messages: [
+      { role: 'user', content: 'first turn' },
+      { role: 'assistant', content: [{ type: 'tool_use', id: 'call_1', name: longName, input: { count: 5 } }] },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'call_1', content: 'ok' }] }
+    ],
+    tools: [
+      { name: longName, input_schema: { properties: { count: { type: 'number' } } } }
+    ]
+  });
+  ir.toolChoice = { name: longName };
+
+  const body = irToChatBody(ir, 'gpt-4o');
+
+  // Declared tools must have <=64 char function names matching regex
+  assert.ok(body.tools && body.tools.length === 1);
+  const toolFn = body.tools[0].function;
+  assert.ok(toolFn.name.length <= 64);
+  assert.match(toolFn.name, /^[a-zA-Z0-9_-]{1,64}$/);
+  assert.equal(toolFn.name, sanitizeToolName(longName));
+
+  // Assistant turn in history must have its tool call name shortened too
+  const asstMsg = body.messages.find(m => m.role === 'assistant');
+  assert.ok(asstMsg && asstMsg.tool_calls && asstMsg.tool_calls.length === 1);
+  assert.equal(asstMsg.tool_calls[0].function.name, sanitizeToolName(longName));
+
+  // toolChoice must be shortened
+  assert.equal(body.tool_choice.function.name, sanitizeToolName(longName));
+});

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

@@ -1,3 +1,5 @@
+import crypto from 'node:crypto';
+
 // Writing a tool call back in the vocabulary the client declared.
 //
 // A tool name is not an identifier an API checks. The client sends its tools, the model answers
@@ -191,13 +193,82 @@ function repairArgs(args, tool) {
   return out;
 }
 
+/**
+ * Sanitize a tool name to conform to upstream API length and character constraints.
+ * OpenAI Chat: 1-64 letters, digits, underscores or hyphens (^[a-zA-Z0-9_-]{1,64}$).
+ * Vertex AI / Gemini: 1-64 alphanumeric or underscore (^[a-zA-Z_][a-zA-Z0-9_]*$).
+ * If length > 64, preserves a 32-char head, 22-char tail, and embeds an 8-char sha256 hash.
+ */
+export function sanitizeToolName(name, { allowHyphens = true } = {}) {
+  if (typeof name !== 'string' || !name) return 'tool';
+  const pattern = allowHyphens ? /[^a-zA-Z0-9_-]/g : /[^a-zA-Z0-9_]/g;
+  let cleaned = name.replace(pattern, '_');
+  if (!allowHyphens && /^[0-9]/.test(cleaned)) {
+    cleaned = `_${cleaned}`;
+  }
+  if (cleaned.length <= 64 && cleaned === name) return name;
+  if (cleaned.length <= 64) return cleaned;
+  const hash = crypto.createHash('sha256').update(name).digest('hex').slice(0, 8);
+  const head = cleaned.slice(0, 32);
+  const tail = cleaned.slice(-22);
+  return `${head}_${hash}_${tail}`;
+}
+
 /**
  * The vocabulary one request declared. `declared` is the client's own tool list, as `ir.tools` holds
  * it: `{ name, parameters }`, the same names and schemas the client will check the call against.
  *
  * 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.
@@ -205,8 +276,13 @@ export function createToolVocab(declared) {
     .filter(t => t && typeof t.name === 'string' && t.name && t.side !== 'provider');
   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 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.
@@ -217,11 +293,17 @@ export function createToolVocab(declared) {
   // there is no second answer to pick between, so the call stands and the client reports it.
   const useful = candidates.length >= 2 && candidates.some(c => c.caps.size > 0);
 
+  function isShortened(upstream) {
+    const raw = String(upstream || '');
+    return shortenedToOriginal.has(raw);
+  }
+
   function name(upstream) {
-    if (!useful) return upstream;
     const raw = String(upstream || '');
     if (!raw || raw === 'tool') return upstream;
+    if (shortenedToOriginal.has(raw)) return shortenedToOriginal.get(raw);
     if (byName.has(raw)) return upstream;                 // already the client's own name
+    if (!useful) return upstream;
     const ns = namespaceOf(raw);
     if (ns) return upstream;                              // a server's tool never becomes a local one
     const want = capabilitiesOf(raw);
@@ -243,8 +325,9 @@ export function createToolVocab(declared) {
   }
 
   function args(upstream, argsJson) {
-    if (!useful) return argsJson;
-    const target = byName.get(name(upstream));
+    const fixedName = name(upstream);
+    if (!useful && !shortenedToOriginal.has(String(upstream || '')) && !needsArgsRewrite(upstream)) return argsJson;
+    const target = byName.get(fixedName);
     if (!target) return argsJson;
     let parsed;
     try {
@@ -252,21 +335,32 @@ 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);
-      return { name: fixedName, args: args(fixedName, argsJson), renamed: fixedName !== upstream };
+      return { name: fixedName, args: args(upstream, argsJson), renamed: fixedName !== upstream };
     }
   };
 }
 
 /** A vocabulary that never rewrites anything, for a request that declared no tools. */
-export const NULL_TOOL_VOCAB = Object.freeze({ name: n => n, args: (n, a) => a, repair: (n, a) => ({ name: n, args: a, renamed: false }) });
+export const NULL_TOOL_VOCAB = Object.freeze({
+  name: n => n,
+  args: (n, a) => a,
+  isShortened: () => false,
+  repair: (n, a) => ({ name: n, args: a, renamed: false })
+});

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();
+  }
+}