llm-switcher 1.6.5 → 1.6.7

package/tests/goalcheck.test.mjs

@@ -0,0 +1,312 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  GOAL_CHECK_DEFAULTS,
+  goalCheckPolicy,
+  validateGoalCheckPatch,
+  redactGoalCheck,
+  isGoalEvaluatorRequest,
+  extractStoppingCondition,
+  buildBoundedEvidence,
+  buildJevQuestions,
+  combineVerdicts,
+  parseEvaluatorVerdict,
+  redactSecrets
+} from '../goalcheck.mjs';
+
+import {
+  resolveJevTarget,
+  extractScoreFromAnswer
+} from '../goalcheck-call.mjs';
+
+test('goalcheck: policy defaults and bounded values', () => {
+  const p = goalCheckPolicy({});
+  assert.equal(p.enabled, false);
+  assert.equal(p.backend, 'jev');
+  assert.equal(p.model, 'typesafe/jev-latest');
+  assert.equal(p.completeMin, 0.90);
+  assert.equal(p.evidenceMin, 0.85);
+  assert.equal(p.unfinishedMax, 0.10);
+  assert.equal(p.timeoutMs, 8000);
+  assert.equal(p.totalTimeoutMs, 25000);
+  assert.equal(p.maxStateChars, 60000);
+
+  // Clamping
+  const clamped = goalCheckPolicy({
+    goalCheck: {
+      completeMin: 1.5,
+      evidenceMin: -0.2,
+      unfinishedMax: 2.0,
+      timeoutMs: 100, // min 500
+      totalTimeoutMs: 200000, // max 120000
+      maxStateChars: 100 // min 500
+    }
+  });
+  assert.equal(clamped.completeMin, 1.0);
+  assert.equal(clamped.evidenceMin, 0.0);
+  assert.equal(clamped.unfinishedMax, 1.0);
+  assert.equal(clamped.timeoutMs, 500);
+  assert.equal(clamped.totalTimeoutMs, 120000);
+  assert.equal(clamped.maxStateChars, 500);
+});
+
+test('goalcheck: patch validation', () => {
+  assert.match(validateGoalCheckPatch(null), /must be an object/);
+  assert.match(validateGoalCheckPatch({ unknownField: true }), /unknown goal check field/);
+  assert.match(validateGoalCheckPatch({ enabled: 'yes' }), /enabled must be a boolean/);
+  assert.match(validateGoalCheckPatch({ completeMin: 1.2 }), /completeMin must be a number from 0 to 1/);
+  assert.match(validateGoalCheckPatch({ completeMin: -0.1 }), /completeMin must be a number from 0 to 1/);
+  assert.match(validateGoalCheckPatch({ timeoutMs: 100 }), /timeoutMs must be an integer from 500 to 60000/);
+  assert.match(validateGoalCheckPatch({ baseURL: 'ftp://bad' }), /baseURL must start with http/);
+
+  // While disabled, empty model or url is allowed
+  assert.equal(validateGoalCheckPatch({ enabled: false, model: '' }), '');
+
+  // Enabling without model is rejected
+  assert.match(validateGoalCheckPatch({ enabled: true, model: '' }), /model cannot be empty/);
+
+  // Valid patch
+  assert.equal(validateGoalCheckPatch({
+    enabled: true,
+    model: 'typesafe/jev-latest',
+    baseURL: 'https://api.example.com/v1',
+    completeMin: 0.88
+  }), '');
+});
+
+test('goalcheck: redaction', () => {
+  const policy = { enabled: true, apiKey: 'secret-key-123', model: 'typesafe/jev-latest' };
+  const redacted = redactGoalCheck(policy);
+  assert.equal(redacted.apiKey, '__LLM_SWITCHER_KEEP_KEY__');
+  assert.equal(redacted.hasApiKey, true);
+
+  const noKey = redactGoalCheck({ enabled: false, apiKey: '' });
+  assert.equal(noKey.apiKey, '');
+  assert.equal(noKey.hasApiKey, false);
+});
+
+test('goalcheck: evaluator request detection', () => {
+  const validEvaluatorPayload = {
+    system: 'You are evaluating a stop-condition hook in Claude Code. Read the conversation transcript carefully...',
+    messages: [
+      { role: 'user', content: 'Fix the bug in auth.js' },
+      { role: 'assistant', content: 'Fixed in commit 123' },
+      {
+        role: 'user',
+        content: 'Based on the conversation transcript above, has the following stopping condition been satisfied? Answer based on transcript evidence only.\n\nCondition: Fix the bug in auth.js'
+      }
+    ],
+    tools: []
+  };
+
+  const res = isGoalEvaluatorRequest('anthropic', validEvaluatorPayload, { 'user-agent': 'claude-cli/2.1.295' });
+  assert.equal(res.isEvaluator, true);
+  assert.equal(res.isSupported, true);
+  assert.equal(res.condition, 'Fix the bug in auth.js');
+
+  // Normal request without stop-hook system prompt
+  const normalPayload = {
+    system: 'You are Claude, a helpful AI assistant.',
+    messages: [{ role: 'user', content: 'What is the goal of AI?' }]
+  };
+  assert.deepEqual(isGoalEvaluatorRequest('anthropic', normalPayload), { isEvaluator: false, isSupported: false });
+
+  // Non-anthropic client
+  assert.deepEqual(isGoalEvaluatorRequest('responses', validEvaluatorPayload), { isEvaluator: false, isSupported: false });
+
+  // Evaluator template but with execution tools -> recognized but unsupported shape
+  const toolPayload = { ...validEvaluatorPayload, tools: [{ name: 'bash', description: 'run' }] };
+  const toolRes = isGoalEvaluatorRequest('anthropic', toolPayload);
+  assert.equal(toolRes.isEvaluator, true);
+  assert.equal(toolRes.isSupported, false);
+});
+
+test('goalcheck: extract stopping condition', () => {
+  const payload = {
+    messages: [
+      { role: 'user', content: 'Earlier chat' },
+      { role: 'user', content: 'Based on transcript...\n\nCondition: Ensure all unit tests pass with 0 failures.' }
+    ]
+  };
+  assert.equal(extractStoppingCondition(payload), 'Ensure all unit tests pass with 0 failures.');
+});
+
+test('goalcheck: bounded evidence building and secret redaction', () => {
+  const payload = {
+    messages: [
+      { role: 'user', content: 'Please deploy using key sk-1234567890abcdef1234' },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'Running test suite' },
+          { type: 'tool_use', id: 'call_1', name: 'bash', input: { command: 'npm test' } }
+        ]
+      },
+      {
+        role: 'user',
+        content: [
+          { type: 'tool_result', tool_use_id: 'call_1', content: 'Pass: 167 tests', is_error: false }
+        ]
+      },
+      {
+        role: 'user',
+        content: 'Based on transcript...\n\nCondition: Tests must pass'
+      }
+    ]
+  };
+
+  const ev = buildBoundedEvidence(payload, 5000);
+  assert.equal(ev.stateTooLarge, false);
+  assert.ok(ev.state.includes('STOPPING CONDITION:\n\nTests must pass'));
+  assert.ok(ev.state.includes('[Tool Call call_1]: bash({"command":"npm test"})'));
+  assert.ok(ev.state.includes('[Tool Result call_1]: is_error=false\nPass: 167 tests'));
+  // Secret should be redacted
+  assert.ok(!ev.state.includes('sk-1234567890abcdef1234'));
+  assert.ok(ev.state.includes('[REDACTED_SECRET]'));
+
+  // Test size overflow
+  const evSmall = buildBoundedEvidence(payload, 100);
+  assert.equal(evSmall.stateTooLarge, true);
+  assert.ok(evSmall.chars > 100);
+});
+
+test('goalcheck: parseEvaluatorVerdict', () => {
+  assert.deepEqual(parseEvaluatorVerdict('{"ok": true, "reason": "all fixed"}'), {
+    ok: true,
+    reason: 'all fixed',
+    impossible: false
+  });
+
+  assert.deepEqual(parseEvaluatorVerdict('```json\n{"ok": false, "reason": "test failed", "impossible": true}\n```'), {
+    ok: false,
+    reason: 'test failed',
+    impossible: true
+  });
+
+  assert.deepEqual(parseEvaluatorVerdict('malformed non-json text'), {
+    malformed: true,
+    raw: 'malformed non-json text'
+  });
+});
+
+test('goalcheck: combineVerdicts decision matrix', () => {
+  const thresholds = { completeMin: 0.90, evidenceMin: 0.85, unfinishedMax: 0.10 };
+
+  // 1. Native rejected
+  const nativeFalse = combineVerdicts({
+    nativeVerdict: { ok: false, reason: 'missing file' },
+    jevResult: { ok: true, scores: { complete: 0.99, evidence: 0.99, unfinished: 0.01 } },
+    thresholds
+  });
+  assert.equal(nativeFalse.ok, false);
+  assert.equal(nativeFalse.reason, 'missing file');
+  assert.equal(nativeFalse.verdictType, 'Blocked');
+
+  // 2. Native impossible
+  const nativeImp = combineVerdicts({
+    nativeVerdict: { ok: false, impossible: true, reason: 'unsolvable' },
+    jevResult: null,
+    thresholds
+  });
+  assert.equal(nativeImp.ok, false);
+  assert.equal(nativeImp.impossible, true);
+  assert.equal(nativeImp.verdictType, 'Blocked');
+
+  // 3. Native unavailable / malformed
+  const nativeBad = combineVerdicts({
+    nativeVerdict: { malformed: true },
+    jevResult: { ok: true },
+    thresholds
+  });
+  assert.equal(nativeBad.ok, false);
+  assert.equal(nativeBad.verdictType, 'Unavailable');
+
+  // 4. Native ok: true AND Jev passes all 3 thresholds
+  const bothPass = combineVerdicts({
+    nativeVerdict: { ok: true, reason: 'tests passed' },
+    jevResult: { ok: true, scores: { complete: 0.95, evidence: 0.92, unfinished: 0.04 } },
+    thresholds
+  });
+  assert.equal(bothPass.ok, true);
+  assert.equal(bothPass.verdictType, 'Allowed');
+  assert.equal(bothPass.reason, 'tests passed');
+
+  // 5. Native ok: true BUT Jev complete fails
+  const completeFail = combineVerdicts({
+    nativeVerdict: { ok: true, reason: 'audit pass claimed' },
+    jevResult: { ok: true, scores: { complete: 0.14, evidence: 0.88, unfinished: 0.63 } },
+    thresholds
+  });
+  assert.equal(completeFail.ok, false);
+  assert.equal(completeFail.verdictType, 'Blocked');
+  assert.match(completeFail.reason, /complete=0.14 < min 0.90/);
+  assert.match(completeFail.reason, /unfinished=0.63 > max 0.10/);
+
+  // 6. Native ok: true BUT Jev state too large
+  const stateLarge = combineVerdicts({
+    nativeVerdict: { ok: true, reason: 'done' },
+    jevResult: { stateTooLarge: true, chars: 70000, maxChars: 60000 },
+    thresholds
+  });
+  assert.equal(stateLarge.ok, false);
+  assert.equal(stateLarge.verdictType, 'Insufficient evidence');
+
+  // 7. Native ok: true BUT Jev HTTP/network error
+  const jevErr = combineVerdicts({
+    nativeVerdict: { ok: true, reason: 'done' },
+    jevResult: { ok: false, reason: 'http-502', message: 'HTTP 502 Bad Gateway' },
+    thresholds
+  });
+  assert.equal(jevErr.ok, false);
+  assert.equal(jevErr.verdictType, 'Unavailable');
+
+  // 8. Native ok: true BUT Jev score NaN or missing
+  const jevNaN = combineVerdicts({
+    nativeVerdict: { ok: true, reason: 'done' },
+    jevResult: { ok: true, scores: { complete: Number.NaN, evidence: 0.9, unfinished: 0.05 } },
+    thresholds
+  });
+  assert.equal(jevNaN.ok, false);
+  assert.equal(jevNaN.verdictType, 'Unavailable');
+});
+
+test('goalcheck-call: target resolution and score extraction', () => {
+  const profiles = {
+    'intact-claude': {
+      baseURL: 'https://intact.example.com/v1',
+      apiKey: 'intact-key-xyz'
+    }
+  };
+
+  // From sourceProfile
+  const t1 = resolveJevTarget({ sourceProfile: 'intact-claude', model: 'typesafe/jev-latest' }, profiles);
+  assert.equal(t1.url, 'https://intact.example.com/v1/systemone');
+  assert.equal(t1.apiKey, 'intact-key-xyz');
+  assert.equal(t1.model, 'typesafe/jev-latest');
+
+  // Override baseURL and key
+  const t2 = resolveJevTarget({
+    baseURL: 'https://custom.provider.com/api',
+    apiKey: 'custom-key',
+    model: 'typesafe/jev-custom'
+  }, profiles);
+  assert.equal(t2.url, 'https://custom.provider.com/api/systemone');
+  assert.equal(t2.apiKey, 'custom-key');
+  assert.equal(t2.model, 'typesafe/jev-custom');
+
+  // Full decisionEndpoint override
+  const t3 = resolveJevTarget({
+    decisionEndpoint: 'https://alpha.decision.org/judge',
+    apiKey: 'k'
+  });
+  assert.equal(t3.url, 'https://alpha.decision.org/judge');
+
+  // Score extraction
+  assert.equal(extractScoreFromAnswer({ noul: 0.85 }), 0.85);
+  assert.equal(extractScoreFromAnswer({ score: 0.72 }), 0.72);
+  assert.equal(extractScoreFromAnswer({ probabilities: { yes: 0.93 } }), 0.93);
+  assert.equal(extractScoreFromAnswer({ choice: 'yes', confidence: 0.89 }), 0.89);
+  assert.equal(extractScoreFromAnswer({ choice: 'no', confidence: 0.80 }), 0.20);
+  assert.ok(Number.isNaN(extractScoreFromAnswer({ invalid: true })));
+});

package/tests/preflight.test.mjs

@@ -0,0 +1,119 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import http from 'node:http';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const preflightScript = path.join(root, 'preflight-check.mjs');
+const listen = server => new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+
+function runPreflight(tool, dir) {
+  return new Promise((resolve, reject) => {
+    const cp = spawn(process.execPath, [preflightScript, tool, dir], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    let stdout = '';
+    let stderr = '';
+    cp.stdout.on('data', b => stdout += b);
+    cp.stderr.on('data', b => stderr += b);
+    cp.on('close', status => resolve({ status, stdout, stderr }));
+    cp.on('error', reject);
+  });
+}
+
+test('preflight-check: verifies available models, warns on dropped models and invalid keys', async t => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-preflight-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+
+  let mockStatus = 200;
+  let mockModels = [
+    { id: 'zencore/space-bunny-free' },
+    { id: 'zencore/muse-spark-1.3-contributor-free' },
+    { id: 'codex/gpt-6-astra' }
+  ];
+
+  const mockUpstream = http.createServer((req, res) => {
+    if (mockStatus !== 200) {
+      res.statusCode = mockStatus;
+      return res.end('{"error":{"message":"Invalid API key"}}');
+    }
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({ data: mockModels }));
+  });
+  await listen(mockUpstream);
+  t.after(() => mockUpstream.close());
+
+  const port = mockUpstream.address().port;
+  const config = {
+    activeProfiles: { claude: 'mock-prof', codex: 'mock-prof' },
+    profiles: {
+      'mock-prof': {
+        name: 'Mock Provider',
+        baseURL: `http://127.0.0.1:${port}/v1`,
+        apiKey: 'test-key',
+        defaultModels: {
+          sonnet: 'zencore/space-bunny-free',
+          opus: 'zencore/space-bunny-free',
+          haiku: 'zencore/muse-spark-1.3-contributor-free'
+        }
+      }
+    }
+  };
+
+  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify(config, null, 2));
+  fs.writeFileSync(path.join(dir, 'route-claude.txt'), 'claude -> mock-prof | 127.0.0.1 | zencore/space-bunny-free\n');
+
+  // Case 1: All models available -> verified ✓
+  const r1 = await runPreflight('claude', dir);
+  assert.equal(r1.status, 0);
+  assert.match(r1.stdout, /verified ✓/);
+  assert.doesNotMatch(r1.stdout, /CẢNH BÁO/);
+
+  // Case 2: Consecutive call hits cache
+  const r2 = await runPreflight('claude', dir);
+  assert.equal(r2.status, 0);
+  assert.match(r2.stdout, /verified ✓/);
+
+  // Clear cache for next test cases
+  fs.rmSync(path.join(dir, 'preflight-cache.json'), { force: true });
+
+  // Case 3: One model was dropped/deprecated (e.g. haiku set to dropped-model)
+  config.profiles['mock-prof'].defaultModels.haiku = 'zencore/old-dropped-model';
+  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify(config, null, 2));
+
+  const r3 = await runPreflight('claude', dir);
+  assert.equal(r3.status, 0);
+  assert.match(r3.stdout, /CẢNH BÁO/);
+  assert.match(r3.stdout, /old-dropped-model/);
+  assert.match(r3.stdout, /slot haiku/);
+  assert.match(r3.stdout, /switch ui/);
+
+  fs.rmSync(path.join(dir, 'preflight-cache.json'), { force: true });
+
+  // Case 4: API key rejected (401)
+  mockStatus = 401;
+  const r4 = await runPreflight('claude', dir);
+  assert.equal(r4.status, 0);
+  assert.match(r4.stdout, /API key cho profile 'mock-prof' không hợp lệ/);
+  assert.match(r4.stdout, /HTTP 401/);
+
+  fs.rmSync(path.join(dir, 'preflight-cache.json'), { force: true });
+
+  // Case 5: Endpoint unreachable (bad port)
+  config.profiles['mock-prof'].baseURL = 'http://127.0.0.1:1';
+  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify(config, null, 2));
+
+  const r5 = await runPreflight('claude', dir);
+  assert.equal(r5.status, 0);
+  assert.match(r5.stdout, /Không thể kết nối tới endpoint/);
+
+  // Case 6: Tool is off (no route file) -> exits quietly
+  fs.rmSync(path.join(dir, 'route-claude.txt'), { force: true });
+  const r6 = await runPreflight('claude', dir);
+  assert.equal(r6.status, 0);
+  assert.equal(r6.stdout.trim(), '');
+});

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