llm-switcher 1.3.7 → 1.4.0

package/tests/dashboard.e2e.test.mjs

@@ -480,20 +480,19 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
       assert.equal(models.haiku, 'my-own-model');
     });
 
-    it('locks the 1M box for a model under 1M, and saves the box for a model that has it', async () => {
+    it('shows the window each listed model has, and offers no window switch', async () => {
       await act(() => editProfile('intact-claude'));
       await act(() => tab('models'));
       await page.waitFor(`document.querySelector('#models-status')?.dataset.state === 'ready'`, 'the model list');
       await page.type('#p-sonnet', 'up-alpha');    // window 200000
-      assert.equal(await page.evaluate(`document.getElementById('p-sonnet-1m').disabled`), true, 'the box is free for a 200K model');
-      assert.match(await page.text('#p-sonnet-1m-note'), /200K.*under 1M/);
+      assert.match(await page.text('#p-sonnet-note'), /200K context/);
       await page.type('#p-opus', 'up-beta');       // window 1000000
-      assert.equal(await page.evaluate(`document.getElementById('p-opus-1m').disabled`), false);
-      await page.click('label:has(#p-opus-1m)');
-      assert.equal(await page.evaluate(`document.getElementById('p-opus-1m').checked`), true);
+      assert.match(await page.text('#p-opus-note'), /1M context/);
+      assert.equal(await page.evaluate(`document.querySelectorAll('#slot-fields input[type=checkbox]').length`), 0, 'no window switch is offered');
       await act(() => saveForm());
-      assert.equal(profiles()['intact-claude'].model1M?.opus, true);
-      assert.notEqual(profiles()['intact-claude'].model1M?.sonnet, true);
+      const saved = profiles()['intact-claude'];
+      assert.equal(saved.defaultModels.opus, 'up-beta');
+      assert.equal(saved.model1M, undefined, 'and nothing window-shaped is saved');
     });
 
     it('says why the list did not load and loads it on Retry', async () => {
@@ -508,7 +507,7 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
       assert.equal(await modelsStatus(), '3 models');
     });
 
-    it('clears a model slot and a 1M box that the person emptied', async () => {
+    it('clears a model slot the person emptied, and drops the retired 1M flags', async () => {
       const cfg = fx.config();
       cfg.profiles['intact-claude'].model1M = { opus: true };
       fx.writeConfig(cfg);
@@ -517,14 +516,12 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
       await act(() => tab('models'));
       await page.waitFor(`document.querySelector('#models-status')?.dataset.state === 'ready'`, 'the model list');
       await page.type('#p-sonnet', '');
-      await page.key('Escape');    // the list of suggestions covers the boxes below until it closes
-      await page.click('label:has(#p-opus-1m)');
-      assert.equal(await page.evaluate(`document.getElementById('p-opus-1m').checked`), false);
+      await page.key('Escape');    // the list of suggestions covers the row below until it closes
       await act(() => saveForm());
       const saved = profiles()['intact-claude'];
       assert.equal(saved.defaultModels.sonnet, undefined, 'the emptied slot came back');
       assert.equal(saved.defaultModels.opus, 'up-opus');
-      assert.ok(!saved.model1M?.opus, 'the unticked 1M box came back');
+      assert.equal(saved.model1M, undefined, 'the retired flags are not written back');
     });
 
     it('shows the slots of the tool that the profile serves', async () => {

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