llm-switcher 1.2.12 → 1.3.1

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,
@@ -10,7 +10,8 @@ import {
   buildResponsesMessage, createUpstreamNormalizer as makeNormalizer, emitUpstreamBody,
   isAntigravityModel, smartUsage,
   createChatStream, buildChatMessage, chatFinish, anthropicStopReason,
-  smartText, smartReasoning, sanitizeJsonSchema, normalizeUpstream, buildVertexMessage
+  smartText, smartReasoning, sanitizeJsonSchema, normalizeUpstream, buildVertexMessage,
+  createCodeAssistStream
 } from '../formats.mjs';
 import { assertValidAnthropicEvents } from './helpers.mjs';
 
@@ -832,3 +833,83 @@ 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']);
+});
+
+test('Code Assist stream: a chunk is wrapped with a trace id, an error is sent bare as Code Assist does', () => {
+  const out = [];
+  const stream = createCodeAssistStream((event, data) => out.push(data), 'gemini-3.8-flash-high');
+  stream.text('hi');
+  stream.error('upstream broke');
+  const chunk = out.find(d => d.response);
+  assert.equal(typeof chunk.traceId, 'string');
+  assert.match(chunk.response.responseId, /^agy-/);
+  const err = out.at(-1);
+  assert.deepEqual(Object.keys(err), ['error'], 'an error is not wrapped in response/traceId');
+  assert.equal(err.error.status, 'INTERNAL');
+  assert.equal(err.error.message, 'upstream broke');
+});

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