llm-switcher 1.3.8 → 1.4.1

package/tests/formats.test.mjs

@@ -11,7 +11,8 @@ import {
   isAntigravityModel, smartUsage,
   createChatStream, buildChatMessage, chatFinish, anthropicStopReason,
   smartText, smartReasoning, sanitizeJsonSchema, normalizeUpstream, buildVertexMessage,
-  createCodeAssistStream
+  createCodeAssistStream,
+  budgetToEffort, effortToBudget, normalizeEffort, capEffort, EFFORT_LEVELS
 } from '../formats.mjs';
 import { assertValidAnthropicEvents } from './helpers.mjs';
 
@@ -913,3 +914,99 @@ test('Code Assist stream: a chunk is wrapped with a trace id, an error is sent b
   assert.equal(err.error.status, 'INTERNAL');
   assert.equal(err.error.message, 'upstream broke');
 });
+
+// ---- thinking: one ladder, both directions ----
+//
+// Codex sends reasoning.effort, an OpenAI strict upstream names four levels, Anthropic speaks
+// budget_tokens or output_config.effort, and Gemini speaks thinkingBudget with a ceiling. The same
+// level has to survive each hop, and no hop may quietly ask for less than the client did.
+
+test('the effort ladder is ordered, and a level round-trips through its budget', () => {
+  assert.deepEqual([...EFFORT_LEVELS], ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+  for (const level of ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']) {
+    assert.equal(budgetToEffort(effortToBudget(level)), level, `${level} must survive its own budget`);
+  }
+  // The budgets the gateway has always read a request as. Claude Code sends a budget on every
+  // request, so a boundary that moved would hand it a different level.
+  assert.equal(effortToBudget('low'), 1024);
+  assert.equal(effortToBudget('medium'), 2048);
+  assert.equal(effortToBudget('high'), 8000);
+  assert.equal(budgetToEffort(1024), 'low');
+  assert.equal(budgetToEffort(2048), 'medium');
+  assert.equal(budgetToEffort(3000), 'medium');
+  assert.equal(budgetToEffort(10000), 'high');
+  assert.equal(budgetToEffort(31999), 'xhigh', 'a 32K thinking budget is above high');
+  assert.equal(budgetToEffort(0), 'minimal', 'and a budget below the floor is still a level');
+});
+
+test('an unknown or missing effort is medium, and none stays none', () => {
+  assert.equal(normalizeEffort(undefined), 'medium');
+  assert.equal(normalizeEffort(''), 'medium');
+  assert.equal(normalizeEffort('Extreme'), 'medium');
+  assert.equal(normalizeEffort('XHIGH'), 'xhigh', 'the level is case-insensitive');
+  assert.equal(normalizeEffort('none'), 'none', 'none is a level the ladder names');
+  // `none` is the one level that means thinking off, and both client vocabularies say it that way.
+  assert.deepEqual(responsesToIR({ model: 'm', reasoning: { effort: 'none' }, input: [] }).thinking, { type: 'disabled' });
+  assert.deepEqual(anthropicToIR({ model: 'm', messages: [], output_config: { effort: 'none' } }).thinking, { type: 'disabled' });
+});
+
+test('capEffort asks a narrower target for the deepest level it names, never for less', () => {
+  const openai = ['minimal', 'low', 'medium', 'high'];
+  assert.equal(capEffort('medium', openai), 'medium');
+  assert.equal(capEffort('xhigh', openai), 'high', 'xhigh becomes the top level OpenAI names, not medium');
+  assert.equal(capEffort('max', openai), 'high');
+  assert.equal(capEffort('ultra', openai), 'high');
+  assert.equal(capEffort('minimal', openai), 'minimal');
+  assert.equal(capEffort('high', EFFORT_LEVELS), 'high', 'a target that names the whole ladder is untouched');
+  assert.equal(capEffort('ultra', EFFORT_LEVELS), 'ultra');
+  assert.equal(capEffort('ultra'), 'ultra', 'no list means no ceiling');
+});
+
+// Codex -> OpenAI Chat: the level travels, and a strict upstream gets the top level it names.
+test('Codex reasoning.effort reaches OpenAI Chat, and a strict upstream keeps the depth', () => {
+  const at = effort => responsesToIR({ model: 'gpt-5.6-sol', reasoning: { effort }, input: [{ role: 'user', content: 'hi' }] });
+  assert.equal(irToChatBody(at('xhigh'), 'gpt-5.6-sol', { thinkingMode: 'native' }).reasoning_effort, 'high',
+    'a strict OpenAI upstream names no xhigh, so it is asked for high');
+  assert.equal(irToChatBody(at('high'), 'gpt-5.6-sol', { thinkingMode: 'native' }).reasoning_effort, 'high');
+  assert.equal(irToChatBody(at('minimal'), 'gpt-5.6-sol', { thinkingMode: 'native' }).reasoning_effort, 'minimal');
+  // A gateway that forwards the object keeps the whole ladder: intact and 9Router accept it.
+  assert.equal(irToChatBody(at('ultra'), 'gpt-5.6-sol').reasoning_effort, 'ultra');
+  assert.equal(irToChatBody(at('xhigh'), 'gpt-5.6-sol').reasoning_effort, 'xhigh');
+  assert.equal(irToChatBody(at('none'), 'gpt-5.6-sol', { thinkingMode: 'native' }).reasoning_effort, undefined,
+    'none is thinking off, not a level to send');
+});
+
+// Codex -> Anthropic: a level with no budget becomes the level Anthropic names, and a client that
+// sent budget_tokens keeps its budget instead of having it restated.
+test('a level reaches Anthropic as output_config.effort, from either client vocabulary', () => {
+  const at = payload => irToAnthropicBody(anthropicToIR(payload), 'claude-opus-4-6');
+  // Anthropic client, effort only, no thinking object.
+  assert.equal(at({ model: 'x', max_tokens: 8000, messages: [{ role: 'user', content: 'hi' }], output_config: { effort: 'xhigh' } }).output_config.effort, 'xhigh');
+  assert.equal(at({ model: 'x', max_tokens: 8000, messages: [{ role: 'user', content: 'hi' }], output_config: { effort: 'none' } }).thinking, undefined,
+    'effort none is thinking off, so the turn is not asked to think');
+  // Codex client: the parser stands a budget behind the level, so Anthropic gets the budget.
+  const codex = irToAnthropicBody(responsesToIR({ model: 'x', max_output_tokens: 200000, reasoning: { effort: 'xhigh' }, input: [{ role: 'user', content: 'hi' }] }), 'claude-opus-4-6');
+  assert.equal(codex.thinking.budget_tokens, 16000, 'the level becomes the budget Anthropic takes');
+
+  const fromBudget = at({ model: 'x', max_tokens: 64000, messages: [{ role: 'user', content: 'hi' }], thinking: { type: 'enabled', budget_tokens: 31999 } });
+  assert.equal(fromBudget.output_config, undefined, 'a budget already said it in Anthropic own words');
+  assert.equal(fromBudget.thinking.budget_tokens, 31999);
+});
+
+// Anthropic/Vertex speak budgets, and Gemini refuses a budget above its ceiling rather than trimming.
+test('a level becomes the budget each API speaks, and Gemini gets one it accepts', () => {
+  const budgetOf = (effort, format) => emitUpstreamBody(format,
+    responsesToIR({ model: 'm', max_output_tokens: 200000, reasoning: { effort }, input: [{ role: 'user', content: 'hi' }] }), 'm').thinking?.budget_tokens;
+  assert.equal(budgetOf('high', 'anthropic'), 8000);
+  assert.equal(budgetOf('xhigh', 'anthropic'), 16000);
+  assert.equal(budgetOf('ultra', 'anthropic'), 65536);
+  const geminiOf = effort => irToVertexBody(
+    responsesToIR({ model: 'm', reasoning: { effort }, input: [{ role: 'user', content: 'hi' }] }), 'm').generationConfig.thinkingConfig.thinkingBudget;
+  assert.equal(geminiOf('high'), 8000);
+  // max and ultra are above the ceiling Gemini takes, and it refuses rather than trims.
+  assert.equal(geminiOf('max'), 32768);
+  assert.equal(geminiOf('ultra'), 32768);
+  assert.equal(irToVertexBody(anthropicToIR({ model: 'm', max_tokens: 200000, messages: [{ role: 'user', content: 'hi' }], thinking: { type: 'enabled', budget_tokens: 100000 } }), 'm').generationConfig.thinkingConfig.thinkingBudget, 32768);
+  // Anthropic keeps the budget it was given, only under max_tokens as its own rule requires.
+  assert.equal(irToAnthropicBody(anthropicToIR({ model: 'm', max_tokens: 200000, messages: [{ role: 'user', content: 'hi' }], thinking: { type: 'enabled', budget_tokens: 100000 } }), 'm').thinking.budget_tokens, 100000);
+});

package/tests/gateway.e2e.test.mjs

@@ -77,6 +77,15 @@ function startUpstream() {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         return res.end(JSON.stringify({ id, owned_by: id.split('/')[0], ...(id.startsWith('claude/') ? { bifrost_ua: 'claude-cli/' } : {}) }));
       }
+      // A provider list with real windows: a 1M model that also names the point to compress at,
+      // and a smaller one. A model the list says nothing of keeps the catalog template.
+      if (req.method === 'GET' && req.url.startsWith('/chat/v1/models')) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ data: [
+          { id: 'gpt-5.6-sol', context_length: 1048576, compact_window: 272000 },
+          { id: 'up-opus', context_length: 200000 }
+        ] }));
+      }
       if (req.url.startsWith('/intact/v1/messages')) {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         return res.end(JSON.stringify({ id: 'msg_n', type: 'message', role: 'assistant', model: json.model, content: [{ type: 'text', text: 'bifrost ok' }], stop_reason: 'end_turn', usage: { input_tokens: 3, output_tokens: 2 } }));
@@ -213,7 +222,7 @@ before(async () => {
       chat: { name: 'Mock Chat', mode: 'convert', tool: 'claude', outFormat: 'openai-chat', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-chat', defaultModels: models },
       vtx: { name: 'Mock Vertex', mode: 'convert', inFormat: 'auto', outFormat: 'vertex', baseURL: `${base}/vtx`, apiKey: 'sk-secret-vtx', defaultModels: models },
       agmock: { name: 'Mock AG via chat', mode: 'convert', inFormat: 'responses', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-ag', defaultModels: { main: 'ag/mock-flash', review: 'ag/mock-review', subagent: 'ag/mock-low' } },
-      pub: { name: 'Mock Public', mode: 'convert', inFormat: 'responses', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-pub', publicModels: ['gpt-5.6-sol', 'gpt-5.2'], defaultModels: { main: 'ag/mock-flash' }, model1M: { main: true } },
+      pub: { name: 'Mock Public', mode: 'convert', inFormat: 'responses', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-pub', publicModels: ['gpt-5.6-sol', 'gpt-5.2'], defaultModels: { main: 'ag/mock-flash' } },
       roles: { name: 'Mock Public Roles', mode: 'convert', inFormat: 'responses', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-roles', publicModels: ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'], defaultModels: { main: 'ag/mock-flash', review: 'ag/mock-review', subagent: 'ag/mock-low' } },
       native: { name: 'Mock Strict OpenAI', mode: 'convert', inFormat: 'auto', outFormat: 'openai-chat', thinkingMode: 'native', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-native', defaultModels: models },
       intactcc: { name: 'Mock intact', mode: 'convert', tool: 'claude', outFormat: 'openai-chat', thinkingMode: 'off', baseURL: `${base}/intact/v1`, apiKey: 'sk-intact-user', defaultModels: { opus: 'claude/claude-opus-5', sonnet: 'gem/flash', haiku: 'claude/claude-haiku-4-5', fable: 'gem/flash' } },
@@ -1166,17 +1175,22 @@ test('Codex WS: a client half-close aborts the running turn', async () => {
   assert.ok(await until(() => hangState.slowAborted, 2000), 'the upstream turn kept running');
 });
 
-test('/v1/models windows follow model1M and the entry comes from codex-catalog-template.json', async () => {
+// The window /v1/models serves is the model's own: the whole one as max_context_window, the
+// window to compress at as context_window. Nothing is hardcoded, so a model the profile's list
+// names nothing keeps the template's window.
+test('/v1/models serves the real window of each model, and the template only as a fallback', async () => {
   const template = JSON.parse(fs.readFileSync(path.join(ROOT, 'codex-catalog-template.json'), 'utf8'));
   const pub = await (await fetch(url('/v1/models'), { headers: { 'x-llm-profile': 'pub' } })).json();
-  const win = Object.fromEntries(pub.models.map(m => [m.slug, m.context_window]));
-  assert.deepEqual(win, { 'gpt-5.6-sol': 1000000, 'gpt-5.2': template.context_window });
+  const bySlug = Object.fromEntries(pub.models.map(m => [m.slug, m]));
+  assert.equal(bySlug['gpt-5.6-sol'].max_context_window, 1048576, 'a model with a 1M window gets 1M');
+  assert.equal(bySlug['gpt-5.6-sol'].context_window, 272000, 'and still compacts at its own threshold');
+  assert.equal(bySlug['gpt-5.2'].context_window, template.context_window, 'a model the list says nothing of keeps the template');
+  assert.equal(bySlug['gpt-5.2'].max_context_window, template.max_context_window);
   for (const m of pub.models) assert.equal(m.description, template.description);
-  const one = await (await fetch(url('/v1/models/gpt-5.2'), { headers: { 'x-llm-profile': 'pub' } })).json();
-  assert.equal(one.context_window, template.context_window);
-  assert.equal(one.id, 'gpt-5.2');
-  const main = await (await fetch(url('/v1/models/gpt-5.6-sol'), { headers: { 'x-llm-profile': 'pub' } })).json();
-  assert.equal(main.context_window, 1000000);
+  const one = await (await fetch(url('/v1/models/gpt-5.6-sol'), { headers: { 'x-llm-profile': 'pub' } })).json();
+  assert.equal(one.context_window, 272000);
+  assert.equal(one.max_context_window, 1048576);
+  assert.equal(one.id, 'gpt-5.6-sol');
 });
 
 // ---- Admin API: stale dashboard writes, control characters, key destination (F06, F33, keeper next-time) ----

package/tests/helpers.mjs

@@ -1,24 +1,24 @@
-import assert from 'node:assert/strict';
-
-// Validate an Anthropic event sequence: indexes increase in start order, deltas only target an open block.
-export function assertValidAnthropicEvents(events) {
-  const open = new Set();
-  const seen = new Set();
-  let expectedNext = 0;
-  for (const { event, data } of events) {
-    if (event === 'content_block_start') {
-      assert.equal(data.index, expectedNext, `block index must be sequential (got ${data.index}, want ${expectedNext})`);
-      assert.ok(!seen.has(data.index), `index ${data.index} reused`);
-      seen.add(data.index);
-      open.add(data.index);
-      expectedNext++;
-    } else if (event === 'content_block_delta') {
-      assert.ok(open.has(data.index), `delta for block ${data.index} which is not open`);
-    } else if (event === 'content_block_stop') {
-      assert.ok(open.has(data.index), `stop for block ${data.index} which is not open`);
-      open.delete(data.index);
-    } else if (event === 'message_stop') {
-      assert.equal(open.size, 0, 'all blocks must be closed before message_stop');
-    }
-  }
-}
+import assert from 'node:assert/strict';
+
+// Validate an Anthropic event sequence: indexes increase in start order, deltas only target an open block.
+export function assertValidAnthropicEvents(events) {
+  const open = new Set();
+  const seen = new Set();
+  let expectedNext = 0;
+  for (const { event, data } of events) {
+    if (event === 'content_block_start') {
+      assert.equal(data.index, expectedNext, `block index must be sequential (got ${data.index}, want ${expectedNext})`);
+      assert.ok(!seen.has(data.index), `index ${data.index} reused`);
+      seen.add(data.index);
+      open.add(data.index);
+      expectedNext++;
+    } else if (event === 'content_block_delta') {
+      assert.ok(open.has(data.index), `delta for block ${data.index} which is not open`);
+    } else if (event === 'content_block_stop') {
+      assert.ok(open.has(data.index), `stop for block ${data.index} which is not open`);
+      open.delete(data.index);
+    } else if (event === 'message_stop') {
+      assert.equal(open.size, 0, 'all blocks must be closed before message_stop');
+    }
+  }
+}

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