llm-switcher 1.2.0 → 1.2.3

package/tests/blindfold-e2e.test.mjs

@@ -150,7 +150,7 @@ async function startInterceptor({ port, gatewayPort, config, upstreamPort }) {
   child.stdout.on('data', (d) => output.push(String(d)));
   child.stderr.on('data', (d) => output.push(String(d)));
   const stop = async () => {
-    if (child.exitCode !== null) return;
+    if (child.exitCode !== null || child.signalCode !== null) return;
     child.kill();
     await once(child, 'exit').catch(() => {});
   };
@@ -181,7 +181,7 @@ async function startGateway(t, port, cfgPath) {
   child.stdout.on('data', (d) => { log += d; });
   child.stderr.on('data', (d) => { log += d; });
   const stop = async () => {
-    if (child.exitCode !== null) return;
+    if (child.exitCode !== null || child.signalCode !== null) return;
     child.kill();
     await once(child, 'exit').catch(() => {});
   };

package/tests/blindfold-task5.test.mjs

@@ -113,7 +113,7 @@ async function startInterceptor({ port, gatewayPort, config, activeTools = 'clau
   child.stderr.on('data', (d) => output.push(String(d)));
 
   const stop = async () => {
-    if (child.exitCode !== null) return;
+    if (child.exitCode !== null || child.signalCode !== null) return;
     child.kill();
     await once(child, 'exit').catch(() => {});
   };

package/tests/blindfold.task3.test.mjs

@@ -126,7 +126,7 @@ async function startInterceptor({ port, gatewayPort, config, activeTools = 'clau
   child.stderr.on('data', (d) => output.push(String(d)));
 
   const stop = async () => {
-    if (child.exitCode !== null) return;   // already gone: waiting for 'exit' would never resolve
+    if (child.exitCode !== null || child.signalCode !== null) return;   // already gone: waiting for 'exit' would never resolve
     child.kill();
     await once(child, 'exit').catch(() => {});
   };
@@ -650,7 +650,7 @@ test('R3b: an interceptor from 1.1.11 proves the old way and is replaced, not tr
   `;
   const legacy = spawn(process.execPath, ['--input-type=module', '-e', legacySrc], { stdio: ['ignore', 'pipe', 'pipe'] });
   t.after(async () => {
-    if (legacy.exitCode !== null) return;
+    if (legacy.exitCode !== null || legacy.signalCode !== null) return;
     legacy.kill();
     await once(legacy, 'exit').catch(() => {});
   });

package/tests/blindfold.wire.test.mjs

@@ -53,7 +53,9 @@ async function startInterceptor() {
   const port = await freePort();
   const child = spawn(process.execPath, [path.join(ROOT, 'blindfold', 'blindfold.mjs'),
     '--port', String(port), '--gateway-port', String(gatewayPort), '--certs', certDir,
-    '--capture', captureDir, '--token-file', path.join(dir, 'admin.token')], { stdio: ['ignore', 'pipe', 'pipe'] });
+    '--capture', captureDir, '--token-file', path.join(dir, 'admin.token'),
+    // Since R3 only the paths of an active tool reach the gateway; everything else passes through.
+    '--active-tools', 'codex'], { stdio: ['ignore', 'pipe', 'pipe'] });
   let out = '';
   child.stdout.on('data', d => { out += d; });
   child.stderr.on('data', d => { out += d; });

package/tests/catalog.test.mjs

@@ -14,6 +14,8 @@ import {
   refreshCatalog,
   detectToolVersion,
   checkVersionAndRefresh,
+  readLocalToolModels,
+  syncLocalCatalog,
   BASELINE_MODELS
 } from '../catalog.mjs';
 
@@ -124,24 +126,120 @@ test('detectToolVersion extracts semantic version from various User-Agent string
   assert.equal(detectToolVersion({}), '');
 });
 
-test('checkVersionAndRefresh records new version and triggers update only on version bumps', async () => {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-bump-test-'));
-  try {
-    // Initial request from version 1.1.0
-    checkVersionAndRefresh('claude', { 'user-agent': 'claude-cli/1.1.0' }, tmp);
-    const cat1 = loadCatalogCache(tmp);
-    assert.equal(cat1.claude.lastSeenVersion, '1.1.0');
-
-    // Repeated request from the same version 1.1.0 -> no change, no duplicate trigger
-    checkVersionAndRefresh('claude', { 'user-agent': 'claude-cli/1.1.0' }, tmp);
-    const cat2 = loadCatalogCache(tmp);
-    assert.equal(cat2.claude.lastSeenVersion, '1.1.0');
-
-    // Tool updates to version 1.2.0 -> version bump detected and saved
-    checkVersionAndRefresh('claude', { 'user-agent': 'claude-cli/1.2.0' }, tmp);
-    const cat3 = loadCatalogCache(tmp);
-    assert.equal(cat3.claude.lastSeenVersion, '1.2.0');
-  } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
+// Local model lists that the tools write themselves, in the formats of Codex and Claude Code.
+function writeToolCaches(root, { codex = ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'], claude = ['claude-opus-5-5', 'claude-sonnet-5-5'] } = {}) {
+  const codexHome = path.join(root, 'codex');
+  const claudeDir = path.join(root, 'claude');
+  fs.mkdirSync(codexHome, { recursive: true });
+  fs.mkdirSync(path.join(claudeDir, 'cache', 'model-catalog'), { recursive: true });
+  if (codex) {
+    fs.writeFileSync(path.join(codexHome, 'models_cache.json'), JSON.stringify({
+      fetched_at: '2026-09-29T01:00:00Z', client_version: '0.158.0',
+      models: codex.map(slug => ({ slug, display_name: slug, context_window: 1000000, visibility: 'list' }))
+    }));
+  }
+  if (claude) {
+    // An older file with another list: the newest fetchedAt wins.
+    fs.writeFileSync(path.join(claudeDir, 'cache', 'model-catalog', 'old.json'), JSON.stringify({
+      version: 2, fetchedAt: 1000, catalog: { surface: 'cc', config: { models: [{ id: 'claude-opus-4-6', name: 'Opus 4.6' }] } }
+    }));
+    fs.writeFileSync(path.join(claudeDir, 'cache', 'model-catalog', 'new.json'), JSON.stringify({
+      version: 2, fetchedAt: 2000, catalog: { surface: 'cc', config: { models: claude.map(id => ({ id, name: id })) } }
+    }));
   }
+  return { codexHome, claudeDir };
+}
+
+function failingFetch(t) {
+  const realFetch = globalThis.fetch;
+  let calls = 0;
+  globalThis.fetch = async () => { calls++; return new Response('{}', { status: 401 }); };
+  t.after(() => { globalThis.fetch = realFetch; });
+  return () => calls;
+}
+
+test('readLocalToolModels reads the model lists that Codex and Claude Code keep on disk', (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-local-models-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const sources = writeToolCaches(root);
+
+  const codex = readLocalToolModels('codex', sources);
+  assert.deepEqual(codex.models.map(m => [m.id, m.role]), [['gpt-5.6-sol', 'main'], ['gpt-5.6-terra', 'review'], ['gpt-5.6-luna', 'subagent']]);
+  assert.equal(codex.version, '0.158.0');
+
+  const claude = readLocalToolModels('claude', sources);
+  assert.deepEqual(claude.models.map(m => [m.id, m.tier]), [['claude-opus-5-5', 'opus'], ['claude-sonnet-5-5', 'sonnet']]);
+
+  const empty = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-no-models-'));
+  t.after(() => fs.rmSync(empty, { recursive: true, force: true }));
+  assert.equal(readLocalToolModels('codex', { codexHome: empty, claudeDir: empty }), null);
+  assert.equal(readLocalToolModels('claude', { codexHome: empty, claudeDir: empty }), null);
+});
+
+test('refreshCatalog takes the local lists and drops the built-in names', async (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-refresh-local-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const sources = writeToolCaches(root);
+  const calls = failingFetch(t);
+
+  const cache = await refreshCatalog(root, { sources });
+  assert.deepEqual(cache.codex.models.map(m => m.id), ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna']);
+  assert.deepEqual(cache.claude.models.map(m => m.id), ['claude-opus-5-5', 'claude-sonnet-5-5']);
+  assert.equal(calls(), 0, 'a local list needs no network call');
+});
+
+test('checkVersionAndRefresh records a version only after the catalog for it is refreshed', async (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-bump-test-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  failingFetch(t);
+
+  // No local list and a failing official list: nothing is refreshed, so the version stays unseen.
+  const none = { codexHome: path.join(root, 'none'), claudeDir: path.join(root, 'none') };
+  checkVersionAndRefresh('codex', { 'user-agent': 'codex_cli_rs/0.158.0 (Mac OS)' }, root, undefined, none);
+  await new Promise(r => setTimeout(r, 50));
+  assert.equal(loadCatalogCache(root).codex.lastSeenVersion, undefined, 'a failed refresh is tried again');
+
+  // Codex wrote its list: the next request refreshes and records the version.
+  const sources = writeToolCaches(root, { codex: ['gpt-5.7-sol'] });
+  checkVersionAndRefresh('codex', { 'user-agent': 'codex_cli_rs/0.158.0 (Mac OS)' }, root, undefined, sources);
+  await new Promise(r => setTimeout(r, 50));
+  const after = loadCatalogCache(root);
+  assert.equal(after.codex.lastSeenVersion, '0.158.0');
+  assert.deepEqual(after.codex.models.map(m => m.id), ['gpt-5.7-sol']);
+});
+
+// A profile key belongs to that profile's baseURL. The official model lists may see it only when
+// the profile itself points at the official host.
+test('refreshCatalog sends a profile key only to the host of that profile', async (t) => {
+  const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-catalog-keys-'));
+  const realFetch = globalThis.fetch;
+  const sent = [];
+  globalThis.fetch = async (url, init = {}) => {
+    const h = init.headers || {};
+    sent.push({ host: new URL(url).host, auth: h.authorization || h['x-api-key'] || '' });
+    return new Response('{}', { status: 401 });
+  };
+  t.after(() => { globalThis.fetch = realFetch; fs.rmSync(stateDir, { recursive: true, force: true }); });
+
+  await refreshCatalog(stateDir, {
+    claudeProfile: { baseURL: 'https://gateway.example/v1', apiKey: 'sk-third-party' },
+    codexProfile: { baseURL: 'https://api.openai.com/v1', apiKey: 'sk-openai' },
+    sources: { codexHome: stateDir, claudeDir: stateDir }
+  });
+  assert.deepEqual(sent.find(s => s.host === 'api.anthropic.com').auth, '', 'a third-party key never reaches Anthropic');
+  assert.deepEqual(sent.find(s => s.host === 'api.openai.com').auth, 'Bearer sk-openai', 'an OpenAI profile key reaches OpenAI');
+});
+
+// Codex can update and rewrite its list without one request through the gateway.
+test('syncLocalCatalog picks up a list that a tool rewrote, with no network call', (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-sync-local-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const calls = failingFetch(t);
+  assert.deepEqual(loadCatalogCache(root).codex.models.map(m => m.id).includes('gpt-6-sol'), true, 'starts from the built-in list');
+
+  const sources = writeToolCaches(root, { codex: ['gpt-5.7-sol', 'gpt-5.7-luna'] });
+  const synced = syncLocalCatalog(root, sources);
+  assert.deepEqual(synced.codex.models.map(m => m.id), ['gpt-5.7-sol', 'gpt-5.7-luna']);
+  assert.deepEqual(loadCatalogCache(root).codex.models.map(m => m.id), ['gpt-5.7-sol', 'gpt-5.7-luna'], 'saved to disk');
+  assert.equal(calls(), 0);
 });

package/tests/classifier.test.mjs

@@ -0,0 +1,210 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import {
+  heuristicClassify,
+  findJevKey,
+  classifyPrompt,
+  checkSemanticEquivalence,
+  DEFAULT_JEV_URL,
+  OPENROUTER_JEV_URL,
+} from '../classifier.mjs';
+
+function createServer(handler) {
+  const server = http.createServer(handler);
+  return new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address();
+      resolve({
+        url: `http://127.0.0.1:${addr.port}`,
+        close: () => new Promise((res) => server.close(res)),
+      });
+    });
+    server.on('error', reject);
+  });
+}
+
+describe('classifier module', () => {
+  describe('heuristicClassify', () => {
+    it('classifies complex tasks to opus', () => {
+      assert.equal(heuristicClassify('Design the system architecture for high throughput'), 'opus');
+      assert.equal(heuristicClassify('Find race condition in concurrent worker pool'), 'opus');
+      assert.equal(heuristicClassify('Conduct a security audit of our auth boundary'), 'opus');
+    });
+
+    it('classifies simple short tasks to haiku', () => {
+      assert.equal(heuristicClassify('Fix typo in comment'), 'haiku');
+      assert.equal(heuristicClassify('Format json output to string'), 'haiku');
+      assert.equal(heuristicClassify('Extract date from this line'), 'haiku');
+    });
+
+    it('defaults general programming tasks to sonnet', () => {
+      assert.equal(heuristicClassify('Refactor this helper function to accept options object and write tests'), 'sonnet');
+    });
+  });
+
+  describe('findJevKey', () => {
+    it('resolves TYPESAFE_API_KEY first', () => {
+      const res = findJevKey({ TYPESAFE_API_KEY: 'ts_key', JEV_API_KEY: 'jev_key' });
+      assert.deepEqual(res, { key: 'ts_key', source: 'typesafe' });
+    });
+
+    it('resolves JEV_API_KEY when TYPESAFE_API_KEY is absent', () => {
+      const res = findJevKey({ JEV_API_KEY: 'jev_key' });
+      assert.deepEqual(res, { key: 'jev_key', source: 'openrouter' });
+    });
+
+    it('returns null on empty env', () => {
+      assert.equal(findJevKey({}), null);
+    });
+  });
+
+  describe('classifyPrompt', () => {
+    it('returns heuristic tier with reason no-key when no key is present', async () => {
+      const res = await classifyPrompt({
+        prompt: 'Design architecture for database',
+        env: {},
+      });
+      assert.equal(res.tier, 'opus');
+      assert.equal(res.source, 'heuristic');
+      assert.equal(res.reason, 'no-key');
+    });
+
+    it('calls Jev endpoint and parses choice response', async () => {
+      let receivedAuth = null;
+      let receivedBody = null;
+
+      const server = await createServer(async (req, res) => {
+        receivedAuth = req.headers.authorization;
+        const chunks = [];
+        for await (const chunk of req) chunks.push(chunk);
+        receivedBody = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            model: 'jev-latest',
+            answers: {
+              recommended_tier: {
+                choice: 'haiku',
+                confidence: 0.94,
+                distribution: { haiku: 0.94, sonnet: 0.05, opus: 0.01 },
+              },
+            },
+          }),
+        );
+      });
+
+      try {
+        const res = await classifyPrompt({
+          prompt: 'Translate hello to French',
+          apiKey: 'test-ts-key',
+          url: server.url,
+        });
+
+        assert.equal(res.tier, 'haiku');
+        assert.equal(res.confidence, 0.94);
+        assert.equal(res.source, 'jev');
+        assert.equal(res.model, 'jev-latest');
+        assert.equal(receivedAuth, 'Bearer test-ts-key');
+        assert.equal(receivedBody.state, 'Translate hello to French');
+        assert.ok('recommended_tier' in receivedBody.questions);
+      } finally {
+        await server.close();
+      }
+    });
+
+    it('falls back gracefully to heuristic on HTTP error', async () => {
+      const server = await createServer((req, res) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'internal error' }));
+      });
+
+      try {
+        const res = await classifyPrompt({
+          prompt: 'Fix typo',
+          apiKey: 'key',
+          url: server.url,
+        });
+
+        assert.equal(res.tier, 'haiku');
+        assert.equal(res.source, 'heuristic');
+        assert.equal(res.reason, 'http-500');
+      } finally {
+        await server.close();
+      }
+    });
+
+    it('falls back gracefully to heuristic on timeout', async () => {
+      const server = await createServer((req, res) => {
+        // Hang indefinitely
+      });
+
+      try {
+        const res = await classifyPrompt({
+          prompt: 'Fix typo',
+          apiKey: 'key',
+          url: server.url,
+          timeoutMs: 50,
+        });
+
+        assert.equal(res.tier, 'haiku');
+        assert.equal(res.source, 'heuristic');
+        assert.equal(res.reason, 'timeout');
+      } finally {
+        await server.close();
+      }
+    });
+  });
+
+  describe('checkSemanticEquivalence', () => {
+    it('returns exact-match immediately when strings match', async () => {
+      const res = await checkSemanticEquivalence({
+        candidate: 'What is Node.js?',
+        target: 'What is Node.js?',
+      });
+      assert.equal(res.equivalent, true);
+      assert.equal(res.confidence, 1.0);
+      assert.equal(res.reason, 'exact-match');
+    });
+
+    it('bypasses immediately with false when no key is configured', async () => {
+      const res = await checkSemanticEquivalence({
+        candidate: 'Say hello',
+        target: 'Greet me',
+        env: {},
+      });
+      assert.equal(res.equivalent, false);
+      assert.equal(res.reason, 'no-key-fallback-bypass');
+    });
+
+    it('evaluates Noul probability from Jev and confirms equivalence >= 0.85', async () => {
+      const server = await createServer(async (req, res) => {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            model: 'jev-latest',
+            answers: {
+              is_equivalent: 0.92,
+            },
+          }),
+        );
+      });
+
+      try {
+        const res = await checkSemanticEquivalence({
+          candidate: 'How do I read a file in Node?',
+          target: 'Read file contents in NodeJS',
+          apiKey: 'test-key',
+          url: server.url,
+        });
+
+        assert.equal(res.equivalent, true);
+        assert.equal(res.confidence, 0.92);
+        assert.equal(res.reason, 'jev-confirmed');
+      } finally {
+        await server.close();
+      }
+    });
+  });
+});

package/tests/codex-daemon.test.mjs

@@ -0,0 +1,92 @@
+// The interactive Codex TUI talks to a shared app-server daemon that keeps the environment it started
+// with. A change of the Codex route must restart it, or the TUI keeps calling the old destination.
+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';
+
+// Temporary HOME and state dir before the import, so nothing here can reach the real Codex daemon.
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-codex-daemon-'));
+process.env.HOME = path.join(root, 'home');
+process.env.LLM_SWITCHER_STATE_DIR = path.join(root, 'state');
+delete process.env.CODEX_HOME;
+fs.mkdirSync(process.env.LLM_SWITCHER_STATE_DIR, { recursive: true });
+const { restartCodexDaemon, applyLaunchState, clearLaunchState, emptyToolEnvFiles, STATE_DIR } = await import('../state.mjs');
+test.after(() => fs.rmSync(root, { recursive: true, force: true }));
+
+// A machine where the codex shim routes through `stateDir` and a daemon is running.
+function machine(stateDir) {
+  const home = fs.mkdtempSync(path.join(root, 'm-'));
+  const codexHome = path.join(home, '.codex');
+  const bin = path.join(codexHome, 'packages', 'app-server-daemon', 'current', 'bin', 'codex');
+  fs.mkdirSync(path.dirname(bin), { recursive: true });
+  fs.writeFileSync(bin, '');
+  fs.mkdirSync(path.join(codexHome, 'app-server-control'), { recursive: true });
+  fs.writeFileSync(path.join(codexHome, 'app-server-control', 'app-server-control.sock'), '');
+  fs.mkdirSync(path.join(home, '.llm-switcher', 'bin'), { recursive: true });
+  fs.writeFileSync(path.join(home, '.llm-switcher', 'bin', 'codex'), `#!/usr/bin/env bash\nSWITCHER_DIR="${stateDir}"\n`);
+  const calls = [];
+  const spawnFn = (cmd, args, opts) => { calls.push({ cmd, args, env: opts.env }); return { unref() {}, on() {} }; };
+  return { home, codexHome, bin, calls, spawnFn };
+}
+
+const ROUTE = [['HTTPS_PROXY', 'http://127.0.0.1:3457'], ['https_proxy', 'http://127.0.0.1:3457'],
+  ['NO_PROXY', '127.0.0.1,localhost'], ['no_proxy', '127.0.0.1,localhost'], ['CODEX_CA_CERTIFICATE', '/ca.pem']];
+
+test('a route change restarts the running daemon with the new Codex variables', () => {
+  const m = machine('/switcher/state');
+  const r = restartCodexDaemon(ROUTE, { home: m.home, codexHome: m.codexHome, stateDir: '/switcher/state', spawnFn: m.spawnFn, baseEnv: { PATH: '/bin' } });
+  assert.equal(r.restarted, true);
+  assert.equal(m.calls.length, 1);
+  assert.equal(m.calls[0].cmd, m.bin);
+  assert.deepEqual(m.calls[0].args, ['app-server', 'daemon', 'restart']);
+  assert.equal(m.calls[0].env.HTTPS_PROXY, 'http://127.0.0.1:3457');
+  assert.equal(m.calls[0].env.CODEX_CA_CERTIFICATE, '/ca.pem');
+  assert.equal(m.calls[0].env.PATH, '/bin');
+});
+
+test('switching Codex off restarts the daemon without the switcher variables, and keeps the user\'s own proxy', () => {
+  const m = machine('/switcher/state');
+  const baseEnv = { HTTPS_PROXY: 'http://127.0.0.1:3457', https_proxy: 'http://proxy.corp:8080', CODEX_CA_CERTIFICATE: '/ca.pem', NO_PROXY: '127.0.0.1,localhost' };
+  restartCodexDaemon([], { home: m.home, codexHome: m.codexHome, stateDir: '/switcher/state', spawnFn: m.spawnFn, baseEnv, ca: '/ca.pem' });
+  const env = m.calls[0].env;
+  assert.equal(env.HTTPS_PROXY, undefined, 'the loopback interceptor is removed');
+  assert.equal(env.CODEX_CA_CERTIFICATE, undefined, 'the switcher CA is removed');
+  assert.equal(env.https_proxy, 'http://proxy.corp:8080', 'a proxy the user set is kept');
+});
+
+test('no restart when the codex shim routes through another state dir, or no daemon runs', () => {
+  const other = machine('/another/install');
+  assert.equal(restartCodexDaemon(ROUTE, { home: other.home, codexHome: other.codexHome, stateDir: '/switcher/state', spawnFn: other.spawnFn }).restarted, false);
+  assert.equal(other.calls.length, 0);
+
+  const idle = machine('/switcher/state');
+  fs.rmSync(path.join(idle.codexHome, 'app-server-control', 'app-server-control.sock'));
+  assert.equal(restartCodexDaemon(ROUTE, { home: idle.home, codexHome: idle.codexHome, stateDir: '/switcher/state', spawnFn: idle.spawnFn }).restarted, false);
+  assert.equal(idle.calls.length, 0, 'a daemon that does not run is not started');
+});
+
+test('applyLaunchState reports a Codex route change only when env-codex changes', () => {
+  assert.ok(STATE_DIR.startsWith(root), 'the test writes only its own launch files');
+  const cfg = {
+    port: 3456, blindfold: { port: 3457 }, activeProfiles: { claude: null, codex: 'cx' },
+    profiles: { cx: { name: 'Cx', mode: 'convert', tool: 'codex', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { main: 'm' } } }
+  };
+  assert.equal(applyLaunchState(cfg, 3456).codexRouteChanged, true, 'first activation');
+  assert.equal(applyLaunchState(cfg, 3456).codexRouteChanged, false, 'same route again');
+  assert.equal(applyLaunchState({ ...cfg, activeProfiles: { claude: null, codex: null } }, 3456).codexRouteChanged, true, 'switched off');
+});
+
+test('switch off, for all tools or for Codex alone, also reports the Codex route change', () => {
+  const cfg = {
+    port: 3456, blindfold: { port: 3457 }, activeProfiles: { claude: null, codex: 'cx' },
+    profiles: { cx: { name: 'Cx', mode: 'convert', tool: 'codex', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { main: 'm' } } }
+  };
+  applyLaunchState(cfg, 3456);
+  assert.equal(clearLaunchState(3456).codexRouteChanged, true);
+  assert.equal(clearLaunchState(3456).codexRouteChanged, false, 'already off');
+  applyLaunchState(cfg, 3456);
+  assert.equal(emptyToolEnvFiles('codex').codexRouteChanged, true);
+  assert.equal(emptyToolEnvFiles('claude').codexRouteChanged, false);
+});

package/tests/formats.test.mjs

@@ -802,3 +802,33 @@ test('an empty tool schema is healed, not forwarded as {}', () => {
   );
   assert.deepEqual(body.tools[0].function.parameters, { type: 'object', properties: {} });
 });
+
+// Structured output: a JSON schema the client asks the answer to follow must reach every upstream.
+const TITLE_SCHEMA = { type: 'object', properties: { title: { type: 'string' } }, required: ['title'], additionalProperties: false };
+
+test('structured output: Anthropic output_config.format reaches chat, Anthropic and Vertex upstreams', () => {
+  const ir = anthropicToIR({ model: 'x', max_tokens: 100, messages: [{ role: 'user', content: 'hi' }], tools: [],
+    output_config: { format: { type: 'json_schema', schema: TITLE_SCHEMA } } });
+  assert.deepEqual(irToChatBody(ir, 'm').response_format,
+    { type: 'json_schema', json_schema: { name: 'response', schema: TITLE_SCHEMA } });
+  assert.deepEqual(irToAnthropicBody(ir, 'm').output_config, { format: { type: 'json_schema', schema: TITLE_SCHEMA } });
+  const gc = irToVertexBody(ir, 'm').generationConfig;
+  assert.equal(gc.responseMimeType, 'application/json');
+  assert.deepEqual(gc.responseSchema, toGeminiSchema(TITLE_SCHEMA));
+  // The deprecated top-level field still works.
+  const old = anthropicToIR({ model: 'x', messages: [{ role: 'user', content: 'hi' }], output_format: { type: 'json_schema', schema: TITLE_SCHEMA } });
+  assert.equal(irToChatBody(old, 'm').response_format.json_schema.schema, TITLE_SCHEMA);
+});
+
+test('structured output: Responses text.format keeps name and strict; JSON mode and plain text', () => {
+  const resp = responsesToIR({ model: 'x', input: 'hi', text: { format: { type: 'json_schema', name: 'title', schema: TITLE_SCHEMA, strict: true } } });
+  assert.deepEqual(irToChatBody(resp, 'm').response_format,
+    { type: 'json_schema', json_schema: { name: 'title', schema: TITLE_SCHEMA, strict: true } });
+  const jm = responsesToIR({ model: 'x', input: 'hi', text: { format: { type: 'json_object' } } });
+  assert.deepEqual(irToChatBody(jm, 'm').response_format, { type: 'json_object' });
+  assert.equal(irToVertexBody(jm, 'm').generationConfig.responseMimeType, 'application/json');
+  assert.equal(irToAnthropicBody(jm, 'm').output_config, undefined);
+  const txt = responsesToIR({ model: 'x', input: 'hi', text: { format: { type: 'text' } } });
+  assert.equal(irToChatBody(txt, 'm').response_format, undefined);
+  assert.equal(irToVertexBody(txt, 'm').generationConfig, undefined);
+});

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