llm-switcher 1.2.12 → 1.3.0

package/tests/agy.unit.test.mjs

@@ -0,0 +1,190 @@
+// Unit tests for the Antigravity CLI (agy) in the launch state, the shims and the launch hook.
+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';
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'llm-switcher-agy-unit-'));
+process.env.LLM_SWITCHER_STATE_DIR = tmp;
+process.env.LLM_SWITCHER_CONFIG = path.join(tmp, 'config.json');
+const s = await import('../state.mjs');
+const shim = await import('../shim.mjs');
+const plugin = await import('../plugin.mjs');
+
+const cfgWith = (active) => ({
+  activeProfiles: { claude: null, codex: null, agy: null, ...active },
+  profiles: { pool: { name: 'pool', tool: 'agy', baseURL: 'https://intact.example/v1', apiKey: 'k', defaultModels: { main: 'antigravity/*' } } }
+});
+
+test('agy alone gets CLOUD_CODE_URL and starts no interceptor', () => {
+  const st = s.computeLaunchState(cfgWith({ agy: 'pool' }), 3456);
+  assert.equal(st.active, true);
+  assert.equal(st.blindfold, null);
+  assert.deepEqual(st.envAgy, [['CLOUD_CODE_URL', 'http://127.0.0.1:3456']]);
+  assert.deepEqual(st.envClaude, []);
+  assert.match(st.routeAgy, /^agy -> pool \| intact\.example \| antigravity\/\*/);
+});
+
+test('agy off writes no agy variables', () => {
+  const st = s.computeLaunchState(cfgWith({}), 3456);
+  assert.equal(st.active, false);
+  assert.deepEqual(st.envAgy, []);
+  assert.equal(st.routeAgy, '');
+});
+
+test('only an agy profile serves agy, and the old single pointer never turns agy on', () => {
+  assert.equal(s.profileAcceptsTarget({ tool: 'agy' }, 'agy'), true);
+  assert.equal(s.profileAcceptsTarget({ inFormat: 'auto' }, 'agy'), false);
+  assert.equal(s.profileAcceptsTarget({ tool: 'agy' }, 'claude'), false);
+  assert.equal(s.getActiveMap({ activeProfile: 'legacy' }).agy, null);
+  assert.deepEqual(s.modelSlotsForProfile({ tool: 'agy' }), ['main']);
+});
+
+test('the launch files of agy are written and emptied with the others', () => {
+  s.applyLaunchState(cfgWith({ agy: 'pool' }), 3456);
+  assert.match(fs.readFileSync(s.paths.envAgySh, 'utf8'), /export CLOUD_CODE_URL='http:\/\/127\.0\.0\.1:3456'/);
+  assert.match(fs.readFileSync(s.paths.envAgyCmd, 'utf8'), /SET "CLOUD_CODE_URL=http:\/\/127\.0\.0\.1:3456"/);
+  assert.ok(fs.existsSync(s.paths.activeFlag));
+  s.emptyToolEnvFiles('agy');
+  assert.equal(fs.readFileSync(s.paths.envAgySh, 'utf8'), '');
+  assert.equal(fs.readFileSync(s.paths.routeAgy, 'utf8'), '');
+  s.applyLaunchState(cfgWith({ agy: 'pool' }), 3456);
+  s.clearLaunchState(3456);
+  assert.equal(fs.readFileSync(s.paths.envAgyCmd, 'utf8'), '');
+  assert.equal(fs.existsSync(s.paths.activeFlag), false);
+});
+
+test('the agy shim reads only its own files, takes no CA, and scrubs a stale gateway URL only while off', () => {
+  const win = shim.renderShim('agy', 'win32');
+  assert.match(win, /env-agy\.cmd/);
+  assert.match(win, /route-agy\.txt/);
+  assert.doesNotMatch(win, /env-claude|NODE_EXTRA_CA_CERTS|STATE_HELPER/);
+  assert.match(win, /if not "%TOOL_ACTIVE%"=="1" if defined CLOUD_CODE_URL call :SCRUB_URL CLOUD_CODE_URL/);
+  assert.match(win, /where agy\.exe/);
+  const posix = shim.renderShim('agy', 'linux');
+  assert.match(posix, /env-agy\.sh/);
+  assert.doesNotMatch(posix, /export NODE_EXTRA_CA_CERTS/);
+  assert.match(posix, /if \[ "\$TOOL_ACTIVE" != "1" \] && \[ -n "\$_u" \]; then/);
+  assert.match(shim.renderShim('claude', 'win32'), /NODE_EXTRA_CA_CERTS/, 'Claude keeps its CA block');
+  assert.equal(shim.routeEvidence('agy', ' CLOUD_CODE_URL=http://127.0.0.1:3456 PATH=x'), true);
+});
+
+test('the agy hook is merged into hooks.json, unquoted, and removed without touching other hooks', () => {
+  const agyHome = path.join(tmp, 'agy');
+  fs.mkdirSync(agyHome, { recursive: true });
+  const file = path.join(agyHome, 'hooks.json');
+  fs.writeFileSync(file, JSON.stringify({ 'lint-checker': { PostToolUse: [] } }));
+  const opts = { agyHome, claudeSkillsDir: path.join(tmp, 'skills'), codexHome: path.join(tmp, 'codex') };
+  const r = plugin.installPlugin(opts, 'test');
+  assert.ok(r.installed.includes('agy'), JSON.stringify(r));
+  const doc = JSON.parse(fs.readFileSync(file, 'utf8'));
+  assert.ok(doc['lint-checker'], 'another hook stays');
+  const cmd = doc[plugin.AGY_HOOK_NAME].SessionStart[0].command;
+  assert.match(cmd, /^node \S+\/hook-status\.mjs agy$/);
+  assert.doesNotMatch(cmd, /["\\]/, 'agy keeps quotes literally, so the command has none');
+  assert.equal(plugin.pluginStatus(opts).agy.installed, true);
+  plugin.uninstallPlugin(opts);
+  assert.deepEqual(Object.keys(JSON.parse(fs.readFileSync(file, 'utf8'))), ['lint-checker']);
+  assert.equal(plugin.agyHookCommand('C:/Program Files/x/hook-status.mjs'), null, 'a path with a space cannot be run by agy');
+});
+
+test.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
+
+test('the launch files of every tool stay out of git and out of the npm package', () => {
+  const ignored = fs.readFileSync(new URL('../.gitignore', import.meta.url), 'utf8').split(/\r?\n/);
+  for (const tool of s.TOOLS) {
+    for (const f of [`env-${tool}.cmd`, `env-${tool}.sh`, `route-${tool}.txt`]) {
+      assert.ok(ignored.includes(f), `${f} must be ignored: it holds this machine's route`);
+    }
+  }
+});
+
+test('migration keeps the agy pointer and renames every pointer of a command-word profile', () => {
+  const mig = (cfg) => s.migrateConfigInMemory(cfg).config.activeProfiles;
+  assert.equal(mig({ profiles: { old: { baseURL: 'x' }, a: { tool: 'agy', baseURL: 'x' } }, activeProfiles: { claude: null, codex: null, agy: 'a' } }).agy, 'a');
+  assert.equal(mig({ profiles: { agy: { tool: 'claude', baseURL: 'x' } }, activeProfiles: { claude: 'agy' } }).claude, 'agy-profile');
+  assert.equal(mig({ profiles: { agy: { tool: 'agy', baseURL: 'x' } }, activeProfiles: { agy: 'agy' } }).agy, 'agy-profile');
+  assert.equal(mig({ profiles: { agy: { tool: 'codex', baseURL: 'x' } }, activeProfiles: { codex: 'agy' } }).codex, 'agy-profile');
+  assert.equal(mig({ profiles: { c: { tool: 'claude', baseURL: 'x' } }, activeProfiles: { agy: 'c' } }).agy, null);
+});
+
+test('every target alias of the switch command is a reserved command word', () => {
+  // A word that is not reserved can also be a profile key, and then `switch <word>` is ambiguous.
+  const src = fs.readFileSync(new URL('../switch.mjs', import.meta.url), 'utf8');
+  const literal = src.match(/const TARGET_ALIASES = (\{[^}]*\})/)[1];
+  const aliases = Function(`return ${literal}`)();
+  for (const key of Object.keys(aliases)) assert.ok(s.COMMAND_WORDS.has(key), `${key} is not in COMMAND_WORDS`);
+});
+
+const pluginDirs = (name) => {
+  const root = path.join(tmp, name);
+  const opts = { agyHome: path.join(root, 'agy'), claudeSkillsDir: path.join(root, 'skills'), codexHome: path.join(root, 'codex') };
+  for (const d of Object.values(opts)) fs.mkdirSync(d, { recursive: true });
+  return opts;
+};
+
+test('a hook script path with a space skips agy, and the other tools still install', () => {
+  const opts = { ...pluginDirs('space'), hookScript: path.join(tmp, 'Program Files', 'hook-status.mjs') };
+  const r = plugin.installPlugin(opts);
+  assert.deepEqual(r.installed.sort(), ['claude', 'codex']);
+  assert.deepEqual(r.failed, []);
+  assert.equal(r.skipped.length, 1);
+  assert.equal(r.skipped[0].tool, 'agy');
+  assert.match(r.skipped[0].reason, /space/);
+  assert.equal(fs.existsSync(path.join(opts.agyHome, 'hooks.json')), false);
+});
+
+test('an agy hooks.json whose root is not an object is left exactly as it is', () => {
+  for (const body of ['[{"a":1}]', '"text"', '7']) {
+    const opts = pluginDirs(`root-${body.length}`);
+    const file = path.join(opts.agyHome, 'hooks.json');
+    fs.writeFileSync(file, body);
+    const inst = plugin.installPlugin(opts);
+    assert.equal(inst.failed.find(f => f.tool === 'agy')?.tool, 'agy', `install ${body}`);
+    assert.equal(fs.readFileSync(file, 'utf8'), body);
+    const un = plugin.uninstallPlugin(opts);
+    assert.ok(un.installed.includes('agy') && !un.failed.length, `uninstall ${body}: our hook cannot be there`);
+    assert.equal(fs.readFileSync(file, 'utf8'), body);
+  }
+});
+
+test('a tool whose install throws is reported, and the other tools still install', () => {
+  const opts = pluginDirs('throws');
+  // A directory where the file must go makes the write throw.
+  fs.mkdirSync(path.join(opts.codexHome, 'hooks.json'));
+  const r = plugin.installPlugin(opts);
+  assert.ok(r.installed.includes('claude') && r.installed.includes('agy'), JSON.stringify(r));
+  assert.equal(r.failed.find(f => f.tool === 'codex')?.tool, 'codex');
+});
+
+test('plugin status names an agy hooks.json that does not parse', () => {
+  const opts = pluginDirs('status-broken');
+  fs.writeFileSync(path.join(opts.agyHome, 'hooks.json'), '{ broken');
+  const st = plugin.pluginStatus(opts).agy;
+  assert.equal(st.installed, false);
+  assert.match(st.error, /parse/);
+  fs.writeFileSync(path.join(opts.agyHome, 'hooks.json'), '[]');
+  assert.match(plugin.pluginStatus(opts).agy.error, /object/);
+});
+
+test('the agy launch hook warns when agy is routed and no gateway answers, and is silent when it is not routed', async () => {
+  const { spawnSync } = await import('node:child_process');
+  const net = await import('node:net');
+  const closed = await new Promise((resolve) => { const sv = net.createServer().listen(0, '127.0.0.1', () => { const { port } = sv.address(); sv.close(() => resolve(port)); }); });
+  const run = () => spawnSync(process.execPath, [new URL('../hook-status.mjs', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1'), 'agy'], {
+    env: { ...process.env, LLM_SWITCHER_STATE_DIR: tmp, LLM_SWITCHER_CONFIG: path.join(tmp, 'config.json'), LLM_SWITCHER_PORT: String(closed) },
+    encoding: 'utf8'
+  });
+  fs.writeFileSync(s.paths.routeAgy, 'agy -> pool | intact.example | antigravity/*');
+  fs.writeFileSync(s.paths.activeFlag, '1');
+  try {
+    const warned = JSON.parse(run().stdout);
+    assert.match(warned.systemMessage, /^WARNING: .*agy -> pool/);
+    fs.writeFileSync(s.paths.routeAgy, '');
+    assert.deepEqual(JSON.parse(run().stdout), {});
+  } finally {
+    fs.rmSync(s.paths.routeAgy, { force: true });
+    fs.rmSync(s.paths.activeFlag, { force: true });
+  }
+});

package/tests/dashboard.e2e.test.mjs

@@ -7,11 +7,11 @@ import assert from 'node:assert/strict';
 import { launchBrowser, skipReason } from './cdp.mjs';
 import { startDashboardFixture } from './dashboard-fixture.mjs';
 
-const TOOLS = ['claude', 'codex'];
-const LABEL = { claude: 'Claude', codex: 'Codex' };
+const TOOLS = ['claude', 'codex', 'agy'];
+const LABEL = { claude: 'Claude', codex: 'Codex', agy: 'agy' };
 const MASKED = '__LLM_SWITCHER_KEEP_KEY__';
 // A profile's `tool` in config.json is one tool, or nothing for a profile that serves both.
-const VALID_TOOLS = [undefined, null, 'claude', 'codex'];
+const VALID_TOOLS = [undefined, null, 'claude', 'codex', 'agy'];
 
 describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
   let fx, browser, page;
@@ -59,8 +59,8 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
   const readScreen = () => page.evaluate(`(() => {
     const text = id => document.getElementById(id)?.textContent.trim();
     return {
-      badges: { claude: text('badge-slot-claude'), codex: text('badge-slot-codex') },
-      selects: { claude: document.getElementById('select-slot-claude').value, codex: document.getElementById('select-slot-codex').value },
+      badges: { claude: text('badge-slot-claude'), codex: text('badge-slot-codex'), agy: text('badge-slot-agy') },
+      selects: { claude: document.getElementById('select-slot-claude').value, codex: document.getElementById('select-slot-codex').value, agy: document.getElementById('select-slot-agy').value },
       aside: text('status-aside-indicator'),
       cards: [...document.querySelectorAll('#profiles-grid .pcard')].map(c => ({
         key: c.querySelector('.mono.faint').textContent.trim(),
@@ -75,8 +75,8 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
     const active = cfg.activeProfiles;
     const on = TOOLS.filter(t => active[t]);
     return {
-      badges: { claude: active.claude || 'OFF', codex: active.codex || 'OFF' },
-      selects: { claude: active.claude || '', codex: active.codex || '' },
+      badges: { claude: active.claude || 'OFF', codex: active.codex || 'OFF', agy: active.agy || 'OFF' },
+      selects: { claude: active.claude || '', codex: active.codex || '', agy: active.agy || '' },
       aside: on.length ? `Active (${on.length})` : 'Idle',
       cards: Object.keys(cfg.profiles).map(key => {
         const tools = TOOLS.filter(t => active[t] === key);
@@ -100,7 +100,8 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
   async function expectScreenMatchesDisk(step, opts) {
     const cfg = fx.config();
     const served = (await fx.api('/api/status')).json;
-    assert.deepEqual(served.activeProfiles, cfg.activeProfiles, `${step}: the gateway reports routes that are not on disk`);
+    // A config written before agy existed has no agy key: on disk that means agy is off.
+    assert.deepEqual(served.activeProfiles, { agy: null, ...cfg.activeProfiles }, `${step}: the gateway reports routes that are not on disk`);
     assert.deepEqual(await readScreen(), expectedScreen(cfg), `${step}: the page and the file disagree`);
     expectQuiet(step, opts);
   }
@@ -139,22 +140,22 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
     it('turns one profile off and on again for the tool it serves, and leaves the other tool alone', async () => {
       await act(() => page.click(switchOf('intact-claude')));
       assert.match(await toast(), /intact-claude deactivated/);
-      assert.deepEqual(fx.config().activeProfiles, { claude: null, codex: 'intact-codex' });
+      assert.deepEqual(fx.config().activeProfiles, { claude: null, codex: 'intact-codex', agy: null });
       await expectScreenMatchesDisk('claude profile off');
 
       await act(() => page.click(switchOf('intact-claude')));
       assert.match(await toast(), /intact-claude activated/);
-      assert.deepEqual(fx.config().activeProfiles, { claude: 'intact-claude', codex: 'intact-codex' });
+      assert.deepEqual(fx.config().activeProfiles, { claude: 'intact-claude', codex: 'intact-codex', agy: null });
       await expectScreenMatchesDisk('claude profile back on');
     });
 
     it('turns a profile that serves both tools on for both, and off again', async () => {
       await act(() => page.click(switchOf('shared')));
-      assert.deepEqual(fx.config().activeProfiles, { claude: 'shared', codex: 'shared' });
+      assert.deepEqual(fx.config().activeProfiles, { claude: 'shared', codex: 'shared', agy: null });
       await expectScreenMatchesDisk('shared on');
 
       await act(() => page.click(switchOf('shared')));
-      assert.deepEqual(fx.config().activeProfiles, { claude: null, codex: null });
+      assert.deepEqual(fx.config().activeProfiles, { claude: null, codex: null, agy: null });
       await expectScreenMatchesDisk('shared off');
     });
 
@@ -173,11 +174,11 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
   describe('the route list of each tool', () => {
     it('sets a route for one tool and can return it to the official endpoint', async () => {
       await act(() => page.select('#select-slot-claude', 'shared'));
-      assert.deepEqual(fx.config().activeProfiles, { claude: 'shared', codex: 'intact-codex' });
+      assert.deepEqual(fx.config().activeProfiles, { claude: 'shared', codex: 'intact-codex', agy: null });
       await expectScreenMatchesDisk('claude to shared');
 
       await act(() => page.select('#select-slot-codex', ''));
-      assert.deepEqual(fx.config().activeProfiles, { claude: 'shared', codex: null });
+      assert.deepEqual(fx.config().activeProfiles, { claude: 'shared', codex: null, agy: null });
       await expectScreenMatchesDisk('codex to official');
     });
 
@@ -191,7 +192,7 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
   describe('the buttons that turn every route off and on', () => {
     it('"Use official endpoints" in the page header turns every route off', async () => {
       await act(() => page.clickText('#ph-actions button', 'Use official endpoints'));
-      assert.deepEqual(fx.config().activeProfiles, { claude: null, codex: null });
+      assert.deepEqual(fx.config().activeProfiles, { claude: null, codex: null, agy: null });
       await expectScreenMatchesDisk('all off');
       const labels = await page.evaluate(`[...document.querySelectorAll('#ph-actions button')].map(b => b.textContent.trim())`);
       assert.deepEqual(labels, ['+ Add Profile', 'Activate compatible routes', 'Refresh']);
@@ -200,13 +201,13 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
     it('turning every route off and on again gives each tool its route back', async () => {
       await act(() => page.clickText('#ph-actions button', 'Use official endpoints'));
       await act(() => page.clickText('#ph-actions button', 'Activate compatible routes'));
-      assert.deepEqual(fx.config().activeProfiles, { claude: 'intact-claude', codex: 'intact-codex' }, 'off and on lost a route');
+      assert.deepEqual(fx.config().activeProfiles, { claude: 'intact-claude', codex: 'intact-codex', agy: null }, 'off and on lost a route');
       await expectScreenMatchesDisk('off and on');
     });
 
     it('"Toggle All" in the sidebar does the same as the header button', async () => {
       await act(() => page.click('.prefs button.btn-outline'));
-      assert.deepEqual(fx.config().activeProfiles, { claude: null, codex: null });
+      assert.deepEqual(fx.config().activeProfiles, { claude: null, codex: null, agy: null });
       await expectScreenMatchesDisk('sidebar toggle');
     });
   });

package/tests/formats.test.mjs

@@ -2,7 +2,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
-  anthropicToIR, responsesToIR,
+  anthropicToIR, responsesToIR, codeAssistToIR,
   healToolPairs, irToChatBody, irToAnthropicBody, irToVertexBody, toGeminiSchema,
   createUpstreamNormalizer, createCollector, createThinkTagSplitter,
   createAnthropicStream, createResponsesStream, createVertexStream,
@@ -832,3 +832,69 @@ test('structured output: Responses text.format keeps name and strict; JSON mode
   assert.equal(irToChatBody(txt, 'm').response_format, undefined);
   assert.equal(irToVertexBody(txt, 'm').generationConfig, undefined);
 });
+
+// ---- Code Assist (Antigravity CLI) input ----
+const ca = (contents, request = {}) => codeAssistToIR({ model: 'm', request: { contents, ...request } });
+const call = (name, id) => ({ functionCall: { ...(id ? { id } : {}), name, args: {} } });
+const resp = (name, id, output = 'r') => ({ functionResponse: { ...(id ? { id } : {}), name, response: { output } } });
+const toolMsgs = (ir) => ir.messages.filter(m => m.role === 'tool');
+
+test('codeAssistToIR: an answered id leaves the queue, so a later id-less result pairs with its own call', () => {
+  const ir = ca([
+    { role: 'user', parts: [{ text: 'go' }] },
+    { role: 'model', parts: [call('f', 'x')] }, { role: 'model', parts: [resp('f', 'x')] },
+    { role: 'model', parts: [call('f')] }, { role: 'model', parts: [resp('f')] }
+  ]);
+  const generated = ir.messages.find(m => m.role === 'assistant' && m.toolCalls?.[0]?.id !== 'x').toolCalls[0].id;
+  assert.deepEqual(toolMsgs(ir).map(m => m.toolCallId), ['x', generated]);
+});
+
+test('codeAssistToIR: two id-less parallel calls of one name pair first in, first out', () => {
+  const ir = ca([{ role: 'user', parts: [{ text: 'go' }] }, { role: 'model', parts: [call('f'), call('f')] }, { role: 'user', parts: [resp('f', null, 'a'), resp('f', null, 'b')] }]);
+  const ids = ir.messages.find(m => m.role === 'assistant').toolCalls.map(c => c.id);
+  assert.deepEqual(toolMsgs(ir).map(m => [m.toolCallId, m.content]), [[ids[0], 'a'], [ids[1], 'b']]);
+});
+
+test('codeAssistToIR: two id-less orphans of one name get distinct ids', () => {
+  const ir = ca([{ role: 'user', parts: [{ text: 'go' }] }, { role: 'user', parts: [resp('f'), resp('f')] }]);
+  const ids = toolMsgs(ir).map(m => m.toolCallId);
+  assert.equal(ids.length, 2);
+  assert.notEqual(ids[0], ids[1]);
+});
+
+test('codeAssistToIR: an unknown explicit id does not consume the open call of that name', () => {
+  const ir = ca([{ role: 'user', parts: [{ text: 'go' }] }, { role: 'model', parts: [call('f')] }, { role: 'model', parts: [resp('f', 'zzz')] }, { role: 'model', parts: [resp('f')] }]);
+  assert.deepEqual(toolMsgs(ir).map(m => m.toolCallId), ['zzz', 'call_agy_0_f']);
+});
+
+test('codeAssistToIR: thought parts stay out of the text', () => {
+  const ir = ca([{ role: 'user', parts: [{ text: 'q' }] }, { role: 'model', parts: [{ text: 'secret', thought: true }, { text: 'answer' }] }]);
+  assert.equal(ir.messages[1].content, 'answer');
+});
+
+test('codeAssistToIR: nested schema types are lowered', () => {
+  const ir = ca([{ role: 'user', parts: [{ text: 'q' }] }], { tools: [{ functionDeclarations: [{ name: 't', parameters: {
+    type: 'OBJECT', properties: { list: { type: 'ARRAY', items: { type: 'STRING' } }, pick: { anyOf: [{ type: 'INTEGER' }, { type: 'BOOLEAN' }] } }
+  } }] }] });
+  const p = ir.tools[0].parameters;
+  assert.equal(p.type, 'object');
+  assert.equal(p.properties.list.type, 'array');
+  assert.equal(p.properties.list.items.type, 'string');
+  assert.ok(JSON.stringify(p.properties.pick).includes('"integer"'));
+});
+
+test('codeAssistToIR: each thinkingConfig form maps to ir.thinking', () => {
+  const think = (thinkingConfig) => ca([{ role: 'user', parts: [{ text: 'q' }] }], { generationConfig: { thinkingConfig } }).thinking;
+  assert.deepEqual(think({ thinkingBudget: 0 }), { type: 'disabled' });
+  assert.equal(think({ thinkingBudget: 4000 }).type, 'enabled');
+  assert.equal(think({ thinkingLevel: 'HIGH' }).effort, 'high');
+  assert.deepEqual(think({ includeThoughts: true, thinkingBudget: -1 }), { type: 'enabled', budget: 2048 });
+});
+
+test('codeAssistToIR: generation parameters map to ir.params', () => {
+  const ir = ca([{ role: 'user', parts: [{ text: 'q' }] }], { generationConfig: { maxOutputTokens: 900, temperature: 0.2, topP: 0.9, stopSequences: ['END'] } });
+  assert.equal(ir.params.maxTokens, 900);
+  assert.equal(ir.params.temperature, 0.2);
+  assert.equal(ir.params.topP, 0.9);
+  assert.deepEqual(ir.params.stop, ['END']);
+});

package/tests/gateway.e2e.test.mjs

@@ -616,6 +616,24 @@ test('Bifrost: Claude Code to a Claude Code account on intact changes only the k
   assert.equal(logs[0].outFormat, 'bifrost');
 });
 
+// intact pins a conversation to one account by this header, so its prompt cache hits and a
+// compacted conversation can move. Every route that reaches intact must carry it.
+test('The Claude Code session id reaches the upstream on every route', async () => {
+  const routes = [
+    { name: 'direct', model: 'claude-opus-4-6', profile: 'ant', ua: 'claude-cli/2.1.300 (external, cli)', url: '/ant/' },
+    { name: 'convert', model: 'claude-sonnet-5', profile: 'intactcc', ua: 'claude-cli/2.1.300 (external, cli)', url: '/intact/v1/chat/completions' },
+    { name: 'bifrost', model: 'claude-opus-4-6', profile: 'intactcc', ua: 'claude-cli/2.1.300 (external, cli)', url: '/intact/v1/messages' }
+  ];
+  for (const r of routes) {
+    const res = await post('/v1/messages', { model: r.model, max_tokens: 10, messages: [{ role: 'user', content: 'hi' }] },
+      { 'x-llm-profile': r.profile, 'user-agent': r.ua, 'x-claude-code-session-id': `sess-${r.name}` });
+    assert.equal(res.status, 200, r.name);
+    const up = received.at(-1);
+    assert.ok(up.url.startsWith(r.url), `${r.name} went to ${up.url}`);
+    assert.equal(up.headers['x-claude-code-session-id'], `sess-${r.name}`, `${r.name} dropped the session id`);
+  }
+});
+
 test('Bifrost stays off for a model that is not a Claude Code account', async () => {
   const res = await post('/v1/messages', { model: 'claude-sonnet-5', max_tokens: 10, messages: [{ role: 'user', content: 'hi' }] },
     { 'x-llm-profile': 'intactcc', 'user-agent': 'claude-cli/2.1.300 (external, cli)' });
@@ -1279,7 +1297,7 @@ test('/api/switch deactivate: the dashboard payload works, the CLI payload works
     // What the dashboard sends: the profile in `profile`, a boolean in `deactivate`.
     const dash = await post('/api/switch', { profile: 'chat', deactivate: true });
     assert.equal(dash.status, 200);
-    assert.deepEqual((await dash.json()).activeProfiles, { claude: null, codex: null });
+    assert.deepEqual((await dash.json()).activeProfiles, { claude: null, codex: null, agy: null });
 
     // The same profile is now inactive, so asking again must not report success.
     const again = await post('/api/switch', { profile: 'chat', deactivate: true });
@@ -1290,7 +1308,7 @@ test('/api/switch deactivate: the dashboard payload works, the CLI payload works
     assert.equal((await post('/api/switch', { profile: 'chat' })).status, 200);
     const cli = await post('/api/switch', { deactivate: 'chat' });
     assert.equal(cli.status, 200);
-    assert.deepEqual((await cli.json()).activeProfiles, { claude: null, codex: null });
+    assert.deepEqual((await cli.json()).activeProfiles, { claude: null, codex: null, agy: null });
 
     // `deactivate: true` with no profile names nothing.
     assert.equal((await post('/api/switch', { deactivate: true })).status, 400);

package/tests/mcp.test.mjs

@@ -115,15 +115,15 @@ test('routeEvidence does not take the shim --config arguments for an environment
 
 // ==================== Task 5 ====================
 
-// The gateway stands between two tools and nothing else. An agent that is offered the retired
+// The gateway stands between three tools and nothing else. An agent that is offered the retired
 // names would be told they worked, then fail at the gateway.
-test('R6: switcher_switch_profile accepts claude and codex targets and rejects legacy targets', async (t) => {
+test('R6: switcher_switch_profile accepts claude, codex and agy targets and rejects legacy targets', async (t) => {
   const [list] = await mcpCall(t, {}, [{ method: 'tools/list' }]);
   const def = list.result.tools.find(x => x.name === 'switcher_switch_profile');
   assert.ok(def, 'the tool is advertised');
-  assert.deepEqual(def.inputSchema.properties.target.enum, ['claude', 'codex']);
-  assert.match(def.inputSchema.properties.target.description, /"claude" \(Claude Code\) or "codex" \(Codex\)/);
-  assert.match(def.description, /Claude Code \(claude\) or Codex \(codex\)/);
+  assert.deepEqual(def.inputSchema.properties.target.enum, ['claude', 'codex', 'agy']);
+  assert.match(def.inputSchema.properties.target.description, /"claude" \(Claude Code\), "codex" \(Codex\) or "agy" \(Antigravity CLI\)/);
+  assert.match(def.description, /Claude Code \(claude\), Codex \(codex\) or the Antigravity CLI \(agy\)/);
   // openai and vertex are not tools a caller may name, so they are not in the schema at all.
   assert.ok(!JSON.stringify(def).includes('openai'), 'no retired target in the schema');
   assert.ok(!JSON.stringify(def).includes('vertex'), 'no retired target in the schema');

package/tests/plugin.test.mjs

@@ -20,9 +20,11 @@ function dirs(t) {
   t.after(() => fs.rmSync(home, { recursive: true, force: true }));
   const claudeSkillsDir = path.join(home, '.claude', 'skills');
   const codexHome = path.join(home, '.codex');
+  // Every tool gets a home of its own here: a test must never write the hooks of this machine.
+  const agyHome = path.join(home, '.gemini', 'antigravity-cli');
   fs.mkdirSync(claudeSkillsDir, { recursive: true });
   fs.mkdirSync(codexHome, { recursive: true });
-  return { home, claudeSkillsDir, codexHome, opts: { claudeSkillsDir, codexHome } };
+  return { home, claudeSkillsDir, codexHome, agyHome, opts: { claudeSkillsDir, codexHome, agyHome } };
 }
 
 const readJson = (f) => JSON.parse(fs.readFileSync(f, 'utf8'));
@@ -55,7 +57,7 @@ test('install writes a plugin for Claude Code and a hooks file for Codex, and re
   const { claudeSkillsDir, codexHome, opts } = dirs(t);
   const first = installPlugin(opts);
   assert.deepEqual(first.failed, [], 'nothing failed');
-  assert.deepEqual(first.installed.sort(), ['claude', 'codex']);
+  assert.deepEqual(first.installed.sort(), ['agy', 'claude', 'codex']);
 
   const manifest = path.join(claudeSkillsDir, 'llm-switcher-status', '.claude-plugin', 'plugin.json');
   assert.ok(fs.existsSync(manifest), 'the manifest is what makes the folder a plugin');

package/tests/shim.test.mjs

@@ -452,3 +452,168 @@ test('the Windows shim raises the toast only while this tool is routed', (t) =>
   assert.match(off.out, /ran/);
   assert.equal(off.asked, '', 'a tool that is off raises no toast');
 });
+
+test('shim status follows the Windows lookup: an .exe earlier on PATH wins over the shim', () => {
+  const dirA = fs.mkdtempSync(path.join(STATE, 'real-'));
+  const shimDir = fs.mkdtempSync(path.join(STATE, 'shim-'));
+  fs.writeFileSync(path.join(dirA, 'agy.exe'), '');
+  fs.writeFileSync(path.join(shimDir, 'agy.cmd'), '');
+  const opts = { pathEnv: [dirA, shimDir].join(';'), shimDir, platform: 'win32', pathExt: '.COM;.EXE;.BAT;.CMD' };
+  const st = shimStatus(['agy'], opts);
+  assert.equal(st.shims[0].effective, path.join(dirA, 'agy.exe'));
+  assert.equal(st.shims[0].active, false, 'the real agy.exe runs first, so the shim is not active');
+  const fixed = shimStatus(['agy'], { ...opts, pathEnv: [shimDir, dirA].join(';') });
+  assert.equal(fixed.shims[0].active, true);
+});
+
+// ---- agy: the shim proves the gateway before it hands over CLOUD_CODE_URL -----------------------
+// agy sends its Google token in clear text to CLOUD_CODE_URL. A process that took the gateway port
+// must therefore never receive it: the shim asks for the identity proof first.
+const { identityProof } = await import(pathToFileURL(path.join(ROOT, 'state.mjs')).href);
+const AGY_TOKEN = 'a'.repeat(64);
+// Outside STATE: the other tests empty STATE file by file.
+const AGY_CONFIG_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'agyconfig-'));
+const AGY_CONFIG = path.join(AGY_CONFIG_DIR, 'config.json');
+test.after(() => fs.rmSync(AGY_CONFIG_DIR, { recursive: true, force: true }));
+fs.writeFileSync(path.join(path.dirname(AGY_CONFIG), 'admin.token'), AGY_TOKEN);
+const VERIFY = path.join(ROOT, 'verify-gateway.mjs');
+// Async on purpose: the /health listener lives in this process, and a spawnSync would block it.
+const { spawn: spawnAsync } = await import('node:child_process');
+function runAsync(cmd, args, opts) {
+  return new Promise((resolve) => {
+    const child = spawnAsync(cmd, args, opts);
+    let out = '', err = '';
+    child.stdout?.on('data', d => { out += d; });
+    child.stderr?.on('data', d => { err += d; });
+    const timer = setTimeout(() => child.kill(), 30000);
+    child.on('close', (status) => { clearTimeout(timer); resolve({ status, stdout: out, stderr: err }); });
+  });
+}
+const NOTICE = /did not prove it is this switcher/;
+
+// A /health listener: 'real' signs like this gateway, 'forged' sends a wrong proof, 'silent' never answers.
+async function agyListener(kind) {
+  const http = await import('node:http');
+  const net = await import('node:net');
+  const server = kind === 'silent'
+    ? net.createServer((sock) => sock.on('error', () => {}))
+    : http.createServer((req, res) => {
+      const port = server.address().port;
+      const nonce = new URL(req.url, 'http://x').searchParams.get('challenge');
+      const proof = kind === 'real' ? identityProof(nonce, { role: 'gateway', port, pid: 4242 }, AGY_TOKEN) : 'forged';
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ status: 'ok', proxy: 'llm-switcher', port, pid: 4242, proof }));
+    });
+  await new Promise(r => server.listen(0, '127.0.0.1', r));
+  return server;
+}
+
+async function runAgyWindowsShim(port) {
+  const shimDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyshim-'));
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyfake-'));
+  fs.writeFileSync(path.join(fakeDir, 'agy.cmd'), '@echo off\r\necho CCU=[%CLOUD_CODE_URL%]\r\n');
+  for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });
+  fs.writeFileSync(path.join(STATE, 'active.flag'), 'active');
+  fs.writeFileSync(path.join(STATE, 'env-agy.cmd'), `SET "CLOUD_CODE_URL=http://127.0.0.1:${port}"\r\n`);
+  const shim = path.join(shimDir, 'agy.cmd');
+  fs.writeFileSync(shim, renderShim('agy', 'win32'), 'utf8');
+  const started = Date.now();
+  const child = await runAsync('cmd.exe', ['/d', '/c', shim], {
+    env: { ...process.env, LLM_SWITCHER_CONFIG: AGY_CONFIG, PATH: [fakeDir, shimDir, path.join(process.env.SystemRoot, 'System32'), path.dirname(process.execPath)].join(path.delimiter) }
+  });
+  fs.rmSync(shimDir, { recursive: true, force: true });
+  fs.rmSync(fakeDir, { recursive: true, force: true });
+  return { out: child.stdout || '', err: child.stderr || '', ms: Date.now() - started };
+}
+
+for (const [kind, routed] of [['forged', false], ['silent', false], ['real', true]]) {
+  test(`the Windows agy shim with a ${kind} listener on the gateway port ${routed ? 'keeps' : 'drops'} CLOUD_CODE_URL`, async (t) => {
+    if (process.platform !== 'win32') return t.skip('cmd.exe only');
+    const server = await agyListener(kind);
+    t.after(() => server.close());
+    const port = server.address().port;
+    const { out, err, ms } = await runAgyWindowsShim(port);
+    if (routed) {
+      assert.match(out, new RegExp(`CCU=\\[http://127\\.0\\.0\\.1:${port}\\]`));
+      assert.doesNotMatch(err, NOTICE);
+    } else {
+      assert.match(out, /CCU=\[\]/, 'the token must not go to a port that did not prove itself');
+      assert.match(err, NOTICE);
+    }
+    assert.ok(ms < 8000, `the shim took ${ms} ms`);
+  });
+}
+
+for (const [kind, routed] of [['forged', false], ['silent', false], ['real', true]]) {
+  test(`the POSIX agy shim with a ${kind} listener on the gateway port ${routed ? 'keeps' : 'drops'} CLOUD_CODE_URL`, async (t) => {
+    if (process.platform === 'win32') return t.skip('posix only');
+    const server = await agyListener(kind);
+    t.after(() => server.close());
+    const port = server.address().port;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyposix-'));
+    fs.writeFileSync(path.join(dir, 'agy'), '#!/usr/bin/env bash\necho "CCU=[${CLOUD_CODE_URL:-}]"\n');
+    fs.chmodSync(path.join(dir, 'agy'), 0o755);
+    for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });
+    fs.writeFileSync(path.join(STATE, 'active.flag'), 'active');
+    fs.writeFileSync(path.join(STATE, 'env-agy.sh'), `export CLOUD_CODE_URL='http://127.0.0.1:${port}'\n`);
+    const started = Date.now();
+    const out = await runAsync(path.join(RENDER_DIR, 'agy'), [], {
+      env: { ...process.env, LLM_SWITCHER_CONFIG: AGY_CONFIG, PATH: [RENDER_DIR, dir, '/usr/bin:/bin', NODE_DIR].join(path.delimiter) }
+    });
+    fs.rmSync(dir, { recursive: true, force: true });
+    if (routed) {
+      assert.match(out.stdout, new RegExp(`CCU=\\[http://127\\.0\\.0\\.1:${port}\\]`));
+      assert.doesNotMatch(out.stderr, NOTICE);
+    } else {
+      assert.match(out.stdout, /CCU=\[\]/);
+      assert.match(out.stderr, NOTICE);
+    }
+    assert.ok(Date.now() - started < 8000, `the shim took ${Date.now() - started} ms`);
+  });
+}
+
+test('verify-gateway accepts only 127.0.0.1 with a real port, whatever listens', async (t) => {
+  const server = await agyListener('real');
+  t.after(() => server.close());
+  const port = server.address().port;
+  const run = async (u) => (await runAsync(process.execPath, [VERIFY, u], { env: { ...process.env, LLM_SWITCHER_CONFIG: AGY_CONFIG } })).status;
+  assert.equal(await run(`http://127.0.0.1:${port}`), 0, 'the real gateway passes');
+  assert.notEqual(await run('http://127.0.0.1/'), 0, 'no port');
+  assert.notEqual(await run(`http://localhost:${port}`), 0, 'localhost can resolve to ::1, which the probe never checked');
+  assert.notEqual(await run(`http://other.example:${port}`), 0);
+  assert.notEqual(await run('not a url'), 0);
+});
+
+// While agy is off, a gateway address left in the shell from an earlier run is the switcher's own
+// value and goes; an address the person set for another host is theirs and stays.
+for (const [value, kept] of [['http://127.0.0.1:3456', false], ['https://cloudcode.corp.example', true]]) {
+  test(`the Windows agy shim, with agy off, ${kept ? 'keeps' : 'scrubs'} CLOUD_CODE_URL=${value}`, async (t) => {
+    if (process.platform !== 'win32') return t.skip('cmd.exe only');
+    const shimDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyoff-'));
+    const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyofffake-'));
+    t.after(() => { fs.rmSync(shimDir, { recursive: true, force: true }); fs.rmSync(fakeDir, { recursive: true, force: true }); });
+    fs.writeFileSync(path.join(fakeDir, 'agy.cmd'), '@echo off\r\necho CCU=[%CLOUD_CODE_URL%]\r\n');
+    for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });
+    const shim = path.join(shimDir, 'agy.cmd');
+    fs.writeFileSync(shim, renderShim('agy', 'win32'), 'utf8');
+    const out = await runAsync('cmd.exe', ['/d', '/c', shim], {
+      env: { ...process.env, CLOUD_CODE_URL: value, LLM_SWITCHER_CONFIG: AGY_CONFIG, PATH: [fakeDir, shimDir, path.join(process.env.SystemRoot, 'System32'), path.dirname(process.execPath)].join(path.delimiter) }
+    });
+    assert.ok(out.stdout.includes(`CCU=[${kept ? value : ''}]`), out.stdout);
+    assert.doesNotMatch(out.stderr, NOTICE, 'no gateway check runs while agy is off');
+  });
+
+  test(`the POSIX agy shim, with agy off, ${kept ? 'keeps' : 'scrubs'} CLOUD_CODE_URL=${value}`, async (t) => {
+    if (process.platform === 'win32') return t.skip('posix only');
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyoffposix-'));
+    t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+    fs.writeFileSync(path.join(dir, 'agy'), '#!/usr/bin/env bash\necho "CCU=[${CLOUD_CODE_URL:-}]"\n');
+    fs.chmodSync(path.join(dir, 'agy'), 0o755);
+    for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });
+    const out = await runAsync(path.join(RENDER_DIR, 'agy'), [], {
+      env: { ...process.env, CLOUD_CODE_URL: value, LLM_SWITCHER_CONFIG: AGY_CONFIG, PATH: [RENDER_DIR, dir, '/usr/bin:/bin', NODE_DIR].join(path.delimiter) }
+    });
+    assert.ok(out.stdout.includes(`CCU=[${kept ? value : ''}]`), out.stdout);
+    assert.doesNotMatch(out.stderr, NOTICE);
+  });
+}