llm-switcher 1.2.0 → 1.2.3

package/tests/lifecycle.test.mjs

@@ -54,16 +54,16 @@ function envFor(ws) {
   return { ...process.env, HOME: path.join(ws.dir, 'home'), USERPROFILE: path.join(ws.dir, 'home'), LLM_SWITCHER_CONFIG: ws.cfgPath, LLM_SWITCHER_STATE_DIR: ws.dir, LLM_SWITCHER_BLINDFOLD_CERTS: ws.certDir, CLAUDE_CONFIG_DIR: ws.claudeDir, LLM_SWITCHER_PORT: '', PORT: '' };
 }
 
-function writeConfig(ws, gwPort, bfPort, activeResponses = null) {
+// The 1.2 schema: one pointer per tool and one interceptor port for the whole config. A file in the
+// older schema is migrated on load, which rewrites it and breaks every "changes nothing" assertion.
+function writeConfig(ws, gwPort, bfPort, activeCodex = null) {
   fs.writeFileSync(ws.cfgPath, JSON.stringify({
     port: gwPort,
-    activeProfiles: { anthropic: null, responses: activeResponses, 'openai-chat': null, vertex: null },
+    blindfold: { port: bfPort },
+    activeProfiles: { claude: null, codex: activeCodex },
     profiles: {
-      plain: { name: 'Plain', mode: 'convert', inFormat: 'auto', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { opus: 'o' } },
-      bf: {
-        name: 'Blindfold', mode: 'convert', inFormat: 'responses', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k',
-        defaultModels: { main: 'm' }, blindfold: true, blindfoldPort: bfPort
-      }
+      plain: { name: 'Plain', mode: 'convert', tool: 'claude', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { opus: 'o' } },
+      bf: { name: 'Blindfold', mode: 'convert', tool: 'codex', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { main: 'm' } }
     }
   }, null, 2), { mode: 0o600 });
 }
@@ -121,7 +121,7 @@ test('the gateway proves its identity to a fresh challenge; a replayed /health i
     const body = await (await fetch(`http://127.0.0.1:${gwPort}/health?challenge=abc`)).json();
     // The proof binds the role, the port it answers on and its pid, so it cannot be relayed or edited.
     assert.equal(body.port, gwPort);
-    assert.equal(body.proof, crypto.createHmac('sha256', token(ws)).update(['gateway', gwPort, body.pid, '', '', '', 'abc'].join('|')).digest('hex'));
+    assert.equal(body.proof, crypto.createHmac('sha256', token(ws)).update(['gateway', gwPort, body.pid, '', '', 'abc'].join('|')).digest('hex'));
     assert.equal(await probe(ws, `s.probeGateway(${gwPort})`), 'ours');
     assert.equal(await probe(ws, `s.probeGateway(${replayPort})`), 'foreign');
     assert.equal(await probe(ws, `s.probeGateway(${await freePort()})`), 'free');
@@ -210,18 +210,21 @@ test('the gateway owns the interceptor: dashboard changes, a lost interceptor an
   let gw = await startGateway(ws, gwPort);
   const bfState = () => probe(ws, `s.probeBlindfold(${bfPort})`);
   try {
-    // 1. the dashboard turns blindfold on for the Codex target
-    const on = await api(ws, gwPort, '/api/switch', { target: 'responses', profile: 'bf' });
+    // 1. the dashboard turns Codex on
+    const on = await api(ws, gwPort, '/api/switch', { target: 'codex', profile: 'bf' });
     assert.equal(on.success, true, JSON.stringify(on));
     let st = await waitFor(async () => { const s = await bfState(); return s.state === 'ours' && s; });
     assert.equal(st.gatewayPort, gwPort);
-    assert.equal(st.prefix, '/backend-api/codex');
+    assert.equal(st.activeTools, 'codex');
 
-    // 2. the dashboard changes the prefix: the interceptor is respawned with it
-    const saved = await api(ws, gwPort, '/api/save-profile', { key: 'bf', profile: { blindfoldPrefix: '/backend-api/codex2' } });
-    assert.notEqual(saved.success, false, JSON.stringify(saved));
-    st = await waitFor(async () => { const s = await bfState(); return s.prefix === '/backend-api/codex2' && s; });
-    assert.equal(st.prefix, '/backend-api/codex2');
+    // 2. the dashboard turns Claude on as well: the running interceptor takes the new tool set in place
+    const both = await api(ws, gwPort, '/api/switch', { target: 'claude', profile: 'plain' });
+    assert.notEqual(both.success, false, JSON.stringify(both));
+    st = await waitFor(async () => { const s = await bfState(); return s.activeTools === 'claude,codex' && s; });
+    assert.equal(st.activeTools, 'claude,codex');
+    await api(ws, gwPort, '/api/switch', { target: 'claude', profile: null });
+    st = await waitFor(async () => { const s = await bfState(); return s.activeTools === 'codex' && s; });
+    assert.equal(st.activeTools, 'codex');
 
     // 3. the interceptor dies; a sync brings it back
     process.kill(st.pid, 'SIGTERM');
@@ -238,31 +241,30 @@ test('the gateway owns the interceptor: dashboard changes, a lost interceptor an
     st = await waitFor(async () => { const s = await bfState(); return s.state === 'ours' && s; });
     assert.equal(st.gatewayPort, gwPort, 'the gateway starts the interceptor at boot');
 
-    // 5. a foreign process on the new interceptor port: the caller sees the failure
+    // 5. config.json names an interceptor port that a foreign process holds: a dashboard change fails
     const squatter = net.createServer(s => s.end());
     const squatPort = await new Promise(r => squatter.listen(0, '127.0.0.1', () => r(squatter.address().port)));
+    const good = fs.readFileSync(ws.cfgPath);
     try {
+      fs.writeFileSync(ws.cfgPath, JSON.stringify({ ...JSON.parse(good), blindfold: { port: squatPort } }, null, 2), { mode: 0o600 });
+      const edited = fs.readFileSync(ws.cfgPath);
       const badRes = await fetch(`http://127.0.0.1:${gwPort}/api/save-profile`, {
         method: 'POST', headers: { 'Content-Type': 'application/json', 'x-llm-switcher-token': token(ws) },
-        body: JSON.stringify({ key: 'bf', profile: { blindfoldPort: squatPort } })
+        body: JSON.stringify({ key: 'bf', profile: { name: 'Renamed' } })
       });
       assert.equal(badRes.status, 502, 'a failure is not answered with 200');
       const bad = await badRes.json();
       assert.equal(bad.success, false);
       assert.match(bad.error, /held by another process/);
-      const onDisk = JSON.parse(fs.readFileSync(ws.cfgPath, 'utf8')).profiles.bf.blindfoldPort;
-      assert.equal(onDisk, bfPort, 'a refused change is not saved, so HTTPS_PROXY never points at the squatter');
+      assert.deepEqual(fs.readFileSync(ws.cfgPath), edited, 'a refused change is not saved');
       assert.equal((await bfState()).state, 'ours', 'the working interceptor stays up');
-      const status = await fetch(`http://127.0.0.1:${gwPort}/api/status`, { headers: { 'x-llm-switcher-token': token(ws) } }).then(r => r.json());
-      assert.equal(status.config.profiles.bf.blindfoldPort, bfPort, 'the gateway does not keep the refused change in memory');
     } finally {
       squatter.close();
+      fs.writeFileSync(ws.cfgPath, good, { mode: 0o600 });
     }
 
     // 6. turning the Codex target off stops the interceptor
-    await api(ws, gwPort, '/api/save-profile', { key: 'bf', profile: { blindfoldPort: bfPort } });
-    await waitFor(async () => (await bfState()).state === 'ours');
-    await api(ws, gwPort, '/api/switch', { target: 'responses', profile: null });
+    await api(ws, gwPort, '/api/switch', { target: 'codex', profile: null });
     assert.equal(await waitFor(async () => (await bfState()).state === 'free'), true);
   } finally {
     try { const s = await bfState(); if (s.state === 'ours') process.kill(s.pid, 'SIGTERM'); } catch {}
@@ -276,32 +278,42 @@ test('the gateway owns the interceptor: dashboard changes, a lost interceptor an
 test('concurrent admin changes: a refused change never reaches disk, and no accepted change is lost', { skip: !HAS_OPENSSL && 'posix + openssl' }, async () => {
   const ws = makeWorkspace({ certs: true });
   const gwPort = await freePort();
-  const bfPort = await freePort();
-  writeConfig(ws, gwPort, bfPort, 'bf');
-  const launch = snapshotLaunchFiles(ws.dir);
-  const gw = await startGateway(ws, gwPort);
+  let bfPort;
   // A squatter that accepts and never answers keeps the identity probe waiting.
   const silent = net.createServer(() => {});
   const silentPort = await new Promise(r => silent.listen(0, '127.0.0.1', () => r(silent.address().port)));
+  writeConfig(ws, gwPort, silentPort);
+  const launch = snapshotLaunchFiles(ws.dir);
+  const gw = await startGateway(ws, gwPort);
   try {
-    await waitFor(async () => (await probe(ws, `s.probeBlindfold(${bfPort})`)).state === 'ours');
-    const post = (body) => fetch(`http://127.0.0.1:${gwPort}/api/save-profile`, {
+    const post = (p, body) => fetch(`http://127.0.0.1:${gwPort}${p}`, {
       method: 'POST', headers: { 'Content-Type': 'application/json', 'x-llm-switcher-token': token(ws) }, body: JSON.stringify(body)
     });
-    const refused = post({ key: 'bf', profile: { blindfoldPort: silentPort } });
+    // Turning Codex on waits for the silent port and is refused; the rename that arrives meanwhile is kept.
+    const refused = post('/api/switch', { target: 'codex', profile: 'bf' });
     await new Promise(r => setTimeout(r, 300));
-    const other = post({ key: 'plain', profile: { name: 'Renamed' } });
+    const other = post('/api/save-profile', { key: 'plain', profile: { name: 'Renamed' } });
     const [a, b] = await Promise.all([refused, other]);
     assert.equal(a.status, 502);
     assert.equal(b.status, 200);
-    const onDisk = JSON.parse(fs.readFileSync(ws.cfgPath, 'utf8'));
-    assert.equal(onDisk.profiles.bf.blindfoldPort, bfPort, 'the refused port is not saved by the other request');
+    let onDisk = JSON.parse(fs.readFileSync(ws.cfgPath, 'utf8'));
+    assert.equal(onDisk.activeProfiles.codex, null, 'the refused switch is not saved by the other request');
     assert.equal(onDisk.profiles.plain.name, 'Renamed');
 
+    // A usable interceptor port, and Codex on, for the second half. Chosen only now: other test files
+    // run at the same time, and a port picked seconds earlier can be taken in between.
+    bfPort = await freePort();
+    onDisk.blindfold = { port: bfPort };
+    fs.writeFileSync(ws.cfgPath, JSON.stringify(onDisk, null, 2), { mode: 0o600 });
+    const on = await post('/api/switch', { target: 'codex', profile: 'bf' });
+    assert.equal(on.status, 200, await on.text());
+    await waitFor(async () => (await probe(ws, `s.probeBlindfold(${bfPort})`)).state === 'ours');
+    const postProfile = (body) => post('/api/save-profile', body);
+
     // Two accepted changes to the active profile: the one that saves last keeps the other.
     const [c, d] = await Promise.all([
-      post({ key: 'bf', profile: { name: 'First' } }),
-      post({ key: 'bf', profile: { defaultModels: { main: 'm2' } } })
+      postProfile({ key: 'bf', profile: { name: 'First' } }),
+      postProfile({ key: 'bf', profile: { defaultModels: { main: 'm2' } } })
     ]);
     assert.equal(c.status, 200);
     assert.equal(d.status, 200);

package/tests/live-optimizer-interop.mjs

@@ -1,205 +1,205 @@
-// LIVE test: requires a running gateway (switch on) and a real upstream (costs tokens).
-// Offline test, no network needed: npm test
-const GATEWAY_PORT = Number(process.env.LLM_SWITCHER_PORT) || 3456;
-const BASE_URL = `http://127.0.0.1:${GATEWAY_PORT}`;
-
-console.log('================================================================');
-console.log('  LLM SWITCHER — TOKEN OPTIMIZER INTEROPERABILITY TEST SUITE   ');
-console.log('  Simulating failure modes from Headroom, RTK, and Ponytail    ');
-console.log('================================================================\n');
-
-let passed = 0;
-let failed = 0;
-
-async function runTest(name, fn) {
-  process.stdout.write(`[TEST] ${name}... `);
-  const t0 = Date.now();
-  try {
-    const detail = await fn();
-    console.log(`PASS (${Date.now() - t0}ms)`);
-    if (detail) console.log(`       ↳ ${detail}`);
-    passed++;
-  } catch (err) {
-    console.log(`FAIL (${Date.now() - t0}ms)`);
-    console.log(`       ↳ ERROR: ${err.message}`);
-    failed++;
-  }
-}
-
-// -----------------------------------------------------------------------------
-// TEST 1: Headroom Failure Mode — Orphaned tool_result
-// When Headroom prunes history to save tokens, it drops the assistant tool_use turn.
-// Anthropic strictly throws: 400 invalid_request_error: 'tool_use_id does not correspond to any tool_use'
-// LLM Switcher Healer Engine: Repairs orphaned result into context text -> 200 OK
-// -----------------------------------------------------------------------------
-await runTest('Headroom Simulation: Orphaned tool_result turn', async () => {
-  const payload = {
-    model: 'claude-opus-4-6',
-    max_tokens: 40,
-    messages: [
-      { role: 'user', content: 'Context turn before pruning' },
-      {
-        role: 'user',
-        content: [
-          { type: 'tool_result', tool_use_id: 'headroom_pruned_call_99', content: 'Database query result: 42 rows found' },
-          { type: 'text', text: 'Reply: healed successfully' }
-        ]
-      }
-    ],
-    stream: false
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    const err = await res.text();
-    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
-  }
-  const json = await res.json();
-  const text = json.content?.map(c => c.text).join('') || '';
-  return `Healed orphaned tool_result. Response HTTP 200: "${text.slice(0, 50).replace(/\n/g, ' ')}..."`;
-});
-
-// -----------------------------------------------------------------------------
-// TEST 2: Headroom Failure Mode — Consecutive User turns (Roles must alternate)
-// When Headroom collapses history, multiple user turns occur back-to-back.
-// Anthropic strictly throws: 400 invalid_request_error: 'roles must alternate'
-// LLM Switcher Healer Engine: Merges consecutive same-role turns -> 200 OK
-// -----------------------------------------------------------------------------
-await runTest('Headroom Simulation: Consecutive User turns (Role alternation violation)', async () => {
-  const payload = {
-    model: 'claude-opus-4-6',
-    max_tokens: 30,
-    messages: [
-      { role: 'user', content: 'User message turn 1' },
-      { role: 'user', content: 'User message turn 2 (no assistant in between)' },
-      { role: 'user', content: 'User message turn 3: reply pong' }
-    ],
-    stream: false
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    const err = await res.text();
-    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
-  }
-  const json = await res.json();
-  return `Merged consecutive turns seamlessly. Stop reason: ${json.stop_reason}`;
-});
-
-// -----------------------------------------------------------------------------
-// TEST 3: Headroom / RTK Failure Mode — Stripped Thinking Parameter
-// Optimizer stripped the 'thinking' object to reduce tokens.
-// LLM Switcher Thinking Guard: Detects reasoning model (ag/claude-opus-4-6-thinking)
-// and restores thinking.budget_tokens automatically -> thinking_delta emitted!
-// -----------------------------------------------------------------------------
-await runTest('Thinking Guard: Restoring stripped thinking parameter on reasoning models', async () => {
-  const payload = {
-    model: 'claude-opus-4-6',
-    max_tokens: 200,
-    // Note: NO thinking parameter included (simulating optimizer stripping it)
-    messages: [
-      { role: 'user', content: 'Solve step by step: what is 17 * 23? Show reasoning.' }
-    ],
-    stream: true
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    throw new Error(`Expected HTTP 200, got ${res.status}`);
-  }
-
-  const text = await res.text();
-  const hasThinkingDelta = text.includes('thinking_delta');
-  const hasSignatureDelta = text.includes('signature_delta');
-  const hasTextDelta = text.includes('text_delta');
-
-  if (!hasThinkingDelta) {
-    throw new Error('Thinking Guard failed: thinking_delta was NOT emitted in stream!');
-  }
-
-  return `Automatically restored thinking: thinking_delta=${hasThinkingDelta}, signature_delta=${hasSignatureDelta}, text_delta=${hasTextDelta}`;
-});
-
-// -----------------------------------------------------------------------------
-// TEST 4: RTK & Intermediary Headers Passthrough
-// RTK / tracing tools inject headers: x-rtk-version, traceparent, x-request-id.
-// LLM Switcher: Transparently preserves all tracking headers without rejection.
-// -----------------------------------------------------------------------------
-await runTest('RTK Intermediary: Custom headers and traceparent passthrough', async () => {
-  const payload = {
-    model: 'claude-opus-4-6',
-    max_tokens: 20,
-    messages: [{ role: 'user', content: 'ping' }],
-    stream: false
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'anthropic-version': '2023-06-01',
-      'x-rtk-version': '0.37.2',
-      'x-optimizer-id': 'rtk-cli-hook',
-      'traceparent': '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01'
-    },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    throw new Error(`Expected HTTP 200, got ${res.status}`);
-  }
-  return `Headers accepted cleanly with HTTP 200 OK`;
-});
-
-// -----------------------------------------------------------------------------
-// TEST 5: OpenAI Chat Healer Mode — Orphaned Tool Result in Chat Completions
-// Same test but over /v1/chat/completions: tool role message without prior tool_calls assistant message.
-// OpenAI API strictly throws: 400 'messages with role tool must be a response to a preceding message with tool_calls'
-// LLM Switcher: Converts orphaned tool to user text message -> 200 OK
-// -----------------------------------------------------------------------------
-await runTest('OpenAI Chat Healer: Orphaned role tool without preceding assistant tool_calls', async () => {
-  const payload = {
-    model: 'ag/gpt-oss-120b-medium',
-    max_tokens: 30,
-    messages: [
-      { role: 'user', content: 'Turn 1 context' },
-      { role: 'tool', tool_call_id: 'orphaned_chat_call_77', content: 'Tool execution logs: OK' },
-      { role: 'user', content: 'reply pong' }
-    ],
-    stream: false
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    const err = await res.text();
-    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
-  }
-  const json = await res.json();
-  return `Chat Healer rescued orphaned tool role. Stop reason: ${json.choices?.[0]?.finish_reason}`;
-});
-
-console.log('\n================================================================');
-console.log(`  TEST RESULTS: ${passed} PASSED / ${failed} FAILED               `);
-console.log('================================================================\n');
-
-process.exit(failed ? 1 : 0);
+// LIVE test: requires a running gateway (switch on) and a real upstream (costs tokens).
+// Offline test, no network needed: npm test
+const GATEWAY_PORT = Number(process.env.LLM_SWITCHER_PORT) || 3456;
+const BASE_URL = `http://127.0.0.1:${GATEWAY_PORT}`;
+
+console.log('================================================================');
+console.log('  LLM SWITCHER — TOKEN OPTIMIZER INTEROPERABILITY TEST SUITE   ');
+console.log('  Simulating failure modes from Headroom, RTK, and Ponytail    ');
+console.log('================================================================\n');
+
+let passed = 0;
+let failed = 0;
+
+async function runTest(name, fn) {
+  process.stdout.write(`[TEST] ${name}... `);
+  const t0 = Date.now();
+  try {
+    const detail = await fn();
+    console.log(`PASS (${Date.now() - t0}ms)`);
+    if (detail) console.log(`       ↳ ${detail}`);
+    passed++;
+  } catch (err) {
+    console.log(`FAIL (${Date.now() - t0}ms)`);
+    console.log(`       ↳ ERROR: ${err.message}`);
+    failed++;
+  }
+}
+
+// -----------------------------------------------------------------------------
+// TEST 1: Headroom Failure Mode — Orphaned tool_result
+// When Headroom prunes history to save tokens, it drops the assistant tool_use turn.
+// Anthropic strictly throws: 400 invalid_request_error: 'tool_use_id does not correspond to any tool_use'
+// LLM Switcher Healer Engine: Repairs orphaned result into context text -> 200 OK
+// -----------------------------------------------------------------------------
+await runTest('Headroom Simulation: Orphaned tool_result turn', async () => {
+  const payload = {
+    model: 'claude-opus-4-6',
+    max_tokens: 40,
+    messages: [
+      { role: 'user', content: 'Context turn before pruning' },
+      {
+        role: 'user',
+        content: [
+          { type: 'tool_result', tool_use_id: 'headroom_pruned_call_99', content: 'Database query result: 42 rows found' },
+          { type: 'text', text: 'Reply: healed successfully' }
+        ]
+      }
+    ],
+    stream: false
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/messages`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    const err = await res.text();
+    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
+  }
+  const json = await res.json();
+  const text = json.content?.map(c => c.text).join('') || '';
+  return `Healed orphaned tool_result. Response HTTP 200: "${text.slice(0, 50).replace(/\n/g, ' ')}..."`;
+});
+
+// -----------------------------------------------------------------------------
+// TEST 2: Headroom Failure Mode — Consecutive User turns (Roles must alternate)
+// When Headroom collapses history, multiple user turns occur back-to-back.
+// Anthropic strictly throws: 400 invalid_request_error: 'roles must alternate'
+// LLM Switcher Healer Engine: Merges consecutive same-role turns -> 200 OK
+// -----------------------------------------------------------------------------
+await runTest('Headroom Simulation: Consecutive User turns (Role alternation violation)', async () => {
+  const payload = {
+    model: 'claude-opus-4-6',
+    max_tokens: 30,
+    messages: [
+      { role: 'user', content: 'User message turn 1' },
+      { role: 'user', content: 'User message turn 2 (no assistant in between)' },
+      { role: 'user', content: 'User message turn 3: reply pong' }
+    ],
+    stream: false
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/messages`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    const err = await res.text();
+    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
+  }
+  const json = await res.json();
+  return `Merged consecutive turns seamlessly. Stop reason: ${json.stop_reason}`;
+});
+
+// -----------------------------------------------------------------------------
+// TEST 3: Headroom / RTK Failure Mode — Stripped Thinking Parameter
+// Optimizer stripped the 'thinking' object to reduce tokens.
+// LLM Switcher Thinking Guard: Detects reasoning model (ag/claude-opus-4-6-thinking)
+// and restores thinking.budget_tokens automatically -> thinking_delta emitted!
+// -----------------------------------------------------------------------------
+await runTest('Thinking Guard: Restoring stripped thinking parameter on reasoning models', async () => {
+  const payload = {
+    model: 'claude-opus-4-6',
+    max_tokens: 200,
+    // Note: NO thinking parameter included (simulating optimizer stripping it)
+    messages: [
+      { role: 'user', content: 'Solve step by step: what is 17 * 23? Show reasoning.' }
+    ],
+    stream: true
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/messages`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    throw new Error(`Expected HTTP 200, got ${res.status}`);
+  }
+
+  const text = await res.text();
+  const hasThinkingDelta = text.includes('thinking_delta');
+  const hasSignatureDelta = text.includes('signature_delta');
+  const hasTextDelta = text.includes('text_delta');
+
+  if (!hasThinkingDelta) {
+    throw new Error('Thinking Guard failed: thinking_delta was NOT emitted in stream!');
+  }
+
+  return `Automatically restored thinking: thinking_delta=${hasThinkingDelta}, signature_delta=${hasSignatureDelta}, text_delta=${hasTextDelta}`;
+});
+
+// -----------------------------------------------------------------------------
+// TEST 4: RTK & Intermediary Headers Passthrough
+// RTK / tracing tools inject headers: x-rtk-version, traceparent, x-request-id.
+// LLM Switcher: Transparently preserves all tracking headers without rejection.
+// -----------------------------------------------------------------------------
+await runTest('RTK Intermediary: Custom headers and traceparent passthrough', async () => {
+  const payload = {
+    model: 'claude-opus-4-6',
+    max_tokens: 20,
+    messages: [{ role: 'user', content: 'ping' }],
+    stream: false
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/messages`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'anthropic-version': '2023-06-01',
+      'x-rtk-version': '0.37.2',
+      'x-optimizer-id': 'rtk-cli-hook',
+      'traceparent': '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01'
+    },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    throw new Error(`Expected HTTP 200, got ${res.status}`);
+  }
+  return `Headers accepted cleanly with HTTP 200 OK`;
+});
+
+// -----------------------------------------------------------------------------
+// TEST 5: OpenAI Chat Healer Mode — Orphaned Tool Result in Chat Completions
+// Same test but over /v1/chat/completions: tool role message without prior tool_calls assistant message.
+// OpenAI API strictly throws: 400 'messages with role tool must be a response to a preceding message with tool_calls'
+// LLM Switcher: Converts orphaned tool to user text message -> 200 OK
+// -----------------------------------------------------------------------------
+await runTest('OpenAI Chat Healer: Orphaned role tool without preceding assistant tool_calls', async () => {
+  const payload = {
+    model: 'ag/gpt-oss-120b-medium',
+    max_tokens: 30,
+    messages: [
+      { role: 'user', content: 'Turn 1 context' },
+      { role: 'tool', tool_call_id: 'orphaned_chat_call_77', content: 'Tool execution logs: OK' },
+      { role: 'user', content: 'reply pong' }
+    ],
+    stream: false
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    const err = await res.text();
+    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
+  }
+  const json = await res.json();
+  return `Chat Healer rescued orphaned tool role. Stop reason: ${json.choices?.[0]?.finish_reason}`;
+});
+
+console.log('\n================================================================');
+console.log(`  TEST RESULTS: ${passed} PASSED / ${failed} FAILED               `);
+console.log('================================================================\n');
+
+process.exit(failed ? 1 : 0);

package/tests/make-certs.test.mjs

@@ -0,0 +1,22 @@
+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 { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HAS_OPENSSL = process.platform !== 'win32' && fs.existsSync('/usr/bin/openssl');
+
+// LibreSSL names the -CAcreateserial file after the CA path cut at its first dot, so a
+// directory such as /Users/first.last sent the serial file to /Users/first.srl.
+test('make-certs.sh builds the certificates under a path that contains a dot', { skip: !HAS_OPENSSL && 'posix + openssl' }, (t) => {
+  // The first dot of the whole path is in `first.last`, so a stray serial file lands in `dir` as first.srl.
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmswcerts'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const out = path.join(dir, 'first.last', 'certs');
+  execFileSync('bash', [path.join(ROOT, 'blindfold', 'make-certs.sh'), out], { stdio: 'pipe' });
+  for (const f of ['ca.pem', 'ca.key', 'leaf.pem', 'leaf.key']) assert.ok(fs.existsSync(path.join(out, f)), `${f} is missing`);
+  assert.deepEqual(fs.readdirSync(dir), ['first.last'], 'no serial file outside the output directory');
+});

package/tests/real-user-sim.test.mjs

@@ -130,6 +130,8 @@ before(async () => {
   proxyPort = await freePort();
   blindfoldPort = await freePort();
   tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-sim-'));
+  // Blindfold mode needs a CA. Without its own directory the gateway reads the certificates of the checkout.
+  execFileSync('bash', [path.join(ROOT, 'blindfold', 'make-certs.sh'), path.join(tmpDir, 'certs')], { stdio: 'ignore' });
 
   const base = `http://127.0.0.1:${upstreamPort}`;
   const models = { opus: 'up-opus', sonnet: 'up-sonnet', haiku: 'up-haiku', fable: 'up-fable' };
@@ -150,6 +152,7 @@ before(async () => {
       ...process.env,
       LLM_SWITCHER_CONFIG: path.join(tmpDir, 'config.json'),
       LLM_SWITCHER_STATE_DIR: tmpDir,
+      LLM_SWITCHER_BLINDFOLD_CERTS: path.join(tmpDir, 'certs'),
       CLAUDE_CONFIG_DIR: path.join(tmpDir, 'claude'),
       LLM_SWITCHER_PORT: ''
     },