llm-switcher 1.2.12 → 1.3.1

package/formats.mjs

@@ -5,7 +5,7 @@
 //
 //   client --parse--> IR --emit--> upstream --events--> client
 //
-// Client (input)  : anthropic | openai-chat | responses (Codex) | vertex
+// Client (input)  : anthropic (Claude Code) | responses (Codex) | codeassist (Antigravity CLI)
 // Upstream (out)  : openai-chat | anthropic | vertex
 //
 // IR shape:
@@ -663,16 +663,111 @@ function responsesToIR(payload) {
   return ir;
 }
 
-// R5: two inputs, one per tool — `anthropic` for Claude Code, `responses` for Codex. The
-// openai-chat and vertex routes were removed with their parsers; a format that reaches here
-// anyway is an error, never a silent fallback to another protocol (a different API key!).
-// The UPSTREAM formats are a different axis and are untouched: emitUpstreamBody still speaks
-// openai-chat, anthropic and vertex to whatever provider the profile points at.
+// The Antigravity CLI (agy) wraps a Gemini request in a Code Assist envelope:
+// {project, requestId, request: {contents, systemInstruction, tools, generationConfig}, model}.
+// The CLI names every function call, and gives a tool result back as {"output": "<text>"} in a
+// turn of either role, so the result is matched by id, never by its position.
+function codeAssistToIR(envelope) {
+  const req = envelope?.request || {};
+  const ir = baseIR();
+  ir.model = envelope?.model || '';
+
+  const sys = req.systemInstruction?.parts;
+  if (Array.isArray(sys)) ir.system = sys.map(p => p.text || '').filter(Boolean).join('\n\n');
+
+  // An id the CLI omitted is made up per name, and its result takes the oldest open id of that name.
+  // A result that names its id closes that id, so a later id-less result never takes it again.
+  const pendingByName = new Map();
+  let callSeq = 0;
+  let orphanSeq = 0;
+  for (const c of Array.isArray(req.contents) ? req.contents : []) {
+    const parts = Array.isArray(c?.parts) ? c.parts : [];
+    const texts = [];
+    const toolCalls = [];
+    for (const p of parts) {
+      if (!p || typeof p !== 'object') continue;
+      if (typeof p.text === 'string' && p.text && p.thought !== true) texts.push(p.text);
+      if (p.functionCall) {
+        const name = p.functionCall.name || '';
+        const id = p.functionCall.id || `call_agy_${callSeq++}_${name}`;
+        if (!pendingByName.has(name)) pendingByName.set(name, []);
+        pendingByName.get(name).push(id);
+        const sig = p.thoughtSignature || null;
+        rememberToolSignature(id, sig);
+        toolCalls.push({ id, name, args: p.functionCall.args ?? {}, sig });
+      }
+      if (p.functionResponse) {
+        const fr = p.functionResponse;
+        const name = fr.name || '';
+        const queue = pendingByName.get(name) || [];
+        let id = fr.id;
+        if (id) {
+          const at = queue.indexOf(id);
+          if (at >= 0) queue.splice(at, 1);
+        } else {
+          id = queue.length ? queue.shift() : `call_agy_orphan_${orphanSeq++}_${name}`;
+        }
+        const out = fr.response?.output ?? fr.response;
+        ir.messages.push({ role: 'tool', toolCallId: id, name: name || null, content: typeof out === 'string' ? out : JSON.stringify(out ?? '') });
+      }
+    }
+    if (c.role === 'model') {
+      const msg = { role: 'assistant' };
+      if (texts.length) msg.content = texts.join('');
+      if (toolCalls.length) msg.toolCalls = toolCalls;
+      if (msg.content !== undefined || msg.toolCalls) ir.messages.push(msg);
+    } else if (texts.length) {
+      ir.messages.push({ role: 'user', content: texts.join('') });
+    }
+  }
+
+  const fns = (req.tools || []).flatMap(t => t.functionDeclarations || []);
+  if (fns.length) {
+    ir.tools = fns.filter(f => f.name).map(f => ({
+      name: f.name, description: f.description || '',
+      parameters: sanitizeJsonSchema(lowerSchemaTypes(f.parameters || {}))
+    }));
+  }
+
+  const gc = req.generationConfig || {};
+  if (typeof gc.maxOutputTokens === 'number') ir.params.maxTokens = gc.maxOutputTokens;
+  if (typeof gc.temperature === 'number') ir.params.temperature = gc.temperature;
+  if (typeof gc.topP === 'number') ir.params.topP = gc.topP;
+  if (Array.isArray(gc.stopSequences)) ir.params.stop = stopList(gc.stopSequences);
+  const th = gc.thinkingConfig;
+  if (th && typeof th === 'object') {
+    if (th.thinkingBudget === 0) ir.thinking = { type: 'disabled' };
+    else if (th.thinkingBudget > 0) ir.thinking = { type: 'enabled', budget: clampBudget(th.thinkingBudget) };
+    else if (th.thinkingLevel) ir.thinking = { type: 'enabled', budget: effortToBudget(String(th.thinkingLevel).toLowerCase()), effort: String(th.thinkingLevel).toLowerCase() };
+    else if (th.includeThoughts) ir.thinking = { type: 'enabled', budget: 2048 };
+  }
+  return ir;
+}
+
+// The CLI writes Gemini schema types in upper case (OBJECT, STRING); JSON Schema wants lower case.
+function lowerSchemaTypes(schema) {
+  if (Array.isArray(schema)) return schema.map(lowerSchemaTypes);
+  if (!schema || typeof schema !== 'object') return schema;
+  const out = {};
+  for (const [k, v] of Object.entries(schema)) {
+    out[k] = k === 'type' && typeof v === 'string' ? v.toLowerCase()
+      : k === 'properties' && v && typeof v === 'object' ? Object.fromEntries(Object.entries(v).map(([pk, pv]) => [pk, lowerSchemaTypes(pv)]))
+        : (k === 'items' || k === 'anyOf' || k === 'oneOf' || k === 'allOf') ? lowerSchemaTypes(v) : v;
+  }
+  return out;
+}
+
+// R5: one input per tool — `anthropic` for Claude Code, `responses` for Codex, `codeassist` for
+// the Antigravity CLI. The openai-chat and vertex routes were removed with their parsers; a format
+// that reaches here anyway is an error, never a silent fallback to another protocol (a different
+// API key!). The UPSTREAM formats are a different axis: emitUpstreamBody still speaks openai-chat,
+// anthropic and vertex to whatever provider the profile points at.
 function parseToIR(clientFormat, payload) {
   switch (clientFormat) {
     case 'anthropic': return anthropicToIR(payload);
     case 'responses': return responsesToIR(payload);
-    default: throw new Error(`Unsupported input format: ${clientFormat}. Only anthropic (Claude Code) and responses (Codex) accept requests.`);
+    case 'codeassist': return codeAssistToIR(payload);
+    default: throw new Error(`Unsupported input format: ${clientFormat}. Only anthropic (Claude Code), responses (Codex) and codeassist (agy) accept requests.`);
   }
 }
 
@@ -2119,7 +2214,7 @@ function vertexUsage(prompt, completion, cached, reasoning) {
   return u;
 }
 
-function buildVertexMessage({ model, think, text, tools, finish, prompt, completion, cached, reasoning, sig }) {
+function buildVertexMessage({ model, think, text, tools, finish, prompt, completion, cached, reasoning, sig, ids = false }) {
   const parts = [];
   const thinking = (think || []).join('');
   if (thinking) {
@@ -2130,7 +2225,7 @@ function buildVertexMessage({ model, think, text, tools, finish, prompt, complet
   const body = (text || []).join('');
   if (body) parts.push({ text: body });
   for (const tc of (tools || [])) {
-    const part = { functionCall: { name: tc.name || 'tool', args: parseArgs(tc.args) } };
+    const part = { functionCall: { ...(ids && tc.id ? { id: tc.id } : {}), name: tc.name || 'tool', args: parseArgs(tc.args) } };
     const tsig = tc.sig || lookupToolSignature(tc.id);
     if (tsig) part.thoughtSignature = tsig;
     parts.push(part);
@@ -2143,7 +2238,8 @@ function buildVertexMessage({ model, think, text, tools, finish, prompt, complet
   };
 }
 
-function createVertexStream(emit, model) {
+// ids: name each functionCall, as Code Assist does. Plain Vertex has no call id.
+function createVertexStream(emit, model, { ids = false } = {}) {
   const cand = (parts) => emit(null, { candidates: [{ content: { role: 'model', parts }, index: 0 }], modelVersion: model });
   // Tool args arrive from OpenAI/Anthropic as deltas; Vertex needs complete functionCalls -> buffer them, emit at the end.
   const tools = new Map();
@@ -2170,7 +2266,7 @@ function createVertexStream(emit, model) {
       const parts = [...tools.values()]
         .filter(t => t.name)
         .map(t => {
-          const part = { functionCall: { name: t.name, args: parseArgs(t.args || '{}') } };
+          const part = { functionCall: { ...(ids && t.id ? { id: t.id } : {}), name: t.name, args: parseArgs(t.args || '{}') } };
           const tsig = t.sig || lookupToolSignature(t.id);
           if (tsig) part.thoughtSignature = tsig;
           return part;
@@ -2187,12 +2283,31 @@ function createVertexStream(emit, model) {
   };
 }
 
+// --- Code Assist (Antigravity CLI) ---
+// The same Gemini chunks, each inside {"response": ..., "traceId": ...}, with call ids. An error is
+// sent bare, as Code Assist sends one.
+// An id to tell answers apart in a log, not a secret: this module imports nothing.
+function codeAssistTrace() {
+  return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join('');
+}
+
+function createCodeAssistStream(emit, model) {
+  const traceId = codeAssistTrace();
+  const responseId = `agy-${traceId}`;
+  return createVertexStream((e, d) => emit(e, d?.error ? d : { response: { ...d, responseId }, traceId }), model, { ids: true });
+}
+
+function buildCodeAssistMessage(args) {
+  const traceId = codeAssistTrace();
+  return { response: { ...buildVertexMessage({ ...args, ids: true }), responseId: `agy-${traceId}` }, traceId };
+}
+
 export {
   canonFinish, chatFinish, anthropicStopReason,
   smartReasoning, smartText, smartToolCalls, smartUsage, smartFinish,
   firstChoice, smartDelta, sanitizeJsonSchema, toGeminiSchema, splitParts,
   budgetToEffort, effortToBudget, clampBudget, parseArgs, stringifyArgs,
-  anthropicToIR, responsesToIR, parseToIR,
+  anthropicToIR, responsesToIR, codeAssistToIR, parseToIR,
   healToolPairs, healAnthropicPayload, rememberToolSignature, lookupToolSignature, estimateTokens, irToChatBody, irToAnthropicBody, irToVertexBody, emitUpstreamBody,
   normalizeUpstream, createUpstreamNormalizer, createCollector,
   createThinkTagSplitter, splitThinkTags,
@@ -2200,5 +2315,6 @@ export {
   createChatStream, buildChatMessage,
   createResponsesStream, buildResponsesMessage,
   vertexFinish, createVertexStream, buildVertexMessage,
+  createCodeAssistStream, buildCodeAssistMessage,
   isAntigravityModel
 };

package/hook-status.mjs

@@ -3,16 +3,17 @@
 //
 // The shim toast fires only when the shim runs, and that needs the shim directory first on PATH.
 // This runs inside the tool, so it reports even when the launcher is the person's own script. Claude
-// Code and Codex both read one JSON object from stdout and show `systemMessage` to the person.
+// Code, Codex and agy each read one JSON object from stdout and take `systemMessage` from it.
 //
 // Two rules hold, whatever happens:
 //   - It prints exactly one JSON object and exits 0. A hook must never fail a session.
 //   - A tool with no profile gets an empty object. Silence for a tool on its official endpoint.
 //
-// Usage: node hook-status.mjs <claude|codex>
+// Usage: node hook-status.mjs <claude|codex|agy>
 import fs from 'node:fs';
 
-const TOOLS = ['claude', 'codex'];
+const TOOLS = ['claude', 'codex', 'agy'];
+const ROUTE_FILE = { claude: 'routeClaude', codex: 'routeCodex', agy: 'routeAgy' };
 
 const readOrEmpty = (file) => {
   try { return fs.readFileSync(file, 'utf8'); } catch { return ''; }
@@ -25,7 +26,7 @@ async function message(tool) {
 
   // The route file is written with the env file of the same tool, so it is empty exactly when that
   // tool is not routed. One read answers both "is the switcher on" and "is this tool on".
-  const route = readOrEmpty(tool === 'codex' ? s.paths.routeCodex : s.paths.routeClaude).trim();
+  const route = readOrEmpty(s.paths[ROUTE_FILE[tool]]).trim();
   if (!route || !fs.existsSync(s.paths.activeFlag)) return {};
 
   const port = s.resolvePort([], s.loadConfig() || {});

package/mcp.mjs

@@ -80,7 +80,7 @@ async function postSwitch(port, target, profile) {
 const TOOLS = [
   {
     name: 'switcher_status',
-    description: 'Get live status of LLM Switcher gateway: port, the two tool targets (Claude Code, Codex), and the active profile of each.',
+    description: 'Get live status of LLM Switcher gateway: port, the three tool targets (Claude Code, Codex, Antigravity CLI), and the active profile of each.',
     inputSchema: {
       type: 'object',
       properties: {}
@@ -98,14 +98,14 @@ const TOOLS = [
   },
   {
     name: 'switcher_switch_profile',
-    description: 'Programmatically change the active profile for one tool: Claude Code (claude) or Codex (codex).',
+    description: 'Programmatically change the active profile for one tool: Claude Code (claude), Codex (codex) or the Antigravity CLI (agy).',
     inputSchema: {
       type: 'object',
       properties: {
         target: {
           type: 'string',
-          description: 'Tool to switch: "claude" (Claude Code) or "codex" (Codex)',
-          enum: ['claude', 'codex']
+          description: 'Tool to switch: "claude" (Claude Code), "codex" (Codex) or "agy" (Antigravity CLI)',
+          enum: ['claude', 'codex', 'agy']
         },
         profile: {
           type: 'string',
@@ -165,6 +165,7 @@ async function handleToolCall(name, args) {
       `Active Profiles by tool:`,
       `  - Claude Code (/v1/messages)  : [${activeMap.claude || 'OFF'}]`,
       `  - Codex CLI   (/v1/responses) : [${activeMap.codex || 'OFF'}]`,
+      `  - agy CLI     (/v1internal:*) : [${activeMap.agy || 'OFF'}]`,
       '',
       `Available Profiles in config: ${Object.keys(cfg.profiles || {}).join(', ')}`,
       `Dashboard Web UI: http://127.0.0.1:${port}/ui`
@@ -217,7 +218,7 @@ async function handleToolCall(name, args) {
     if (args?.verbose) {
       findings.push('');
       findings.push('--- Routing variables of this process ---');
-      const names = Object.keys(process.env).filter(k => /^(ANTHROPIC_BASE_URL|OPENAI_BASE_URL|HTTPS?_PROXY|https?_proxy|NO_PROXY|no_proxy|CODEX_CA_CERTIFICATE|LLM_SWITCHER_[A-Z0-9_]+)$/.test(k)).sort();
+      const names = Object.keys(process.env).filter(k => /^(ANTHROPIC_BASE_URL|OPENAI_BASE_URL|CLOUD_CODE_URL|HTTPS?_PROXY|https?_proxy|NO_PROXY|no_proxy|CODEX_CA_CERTIFICATE|LLM_SWITCHER_[A-Z0-9_]+)$/.test(k)).sort();
       for (const k of names) findings.push(`${k}=${withoutCredentials(process.env[k])}`);
       if (!names.length) findings.push('(none set)');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.2.12",
+  "version": "1.3.1",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code and Codex, with OpenAI-compatible, Anthropic and Vertex upstreams",
   "keywords": [
     "llm",

package/plugin.mjs

@@ -1,5 +1,5 @@
 // ============================================================
-// plugin.mjs - installs the launch hook into the two coding tools, and edits no configuration.
+// plugin.mjs - installs the launch hook into the coding tools, and edits no configuration.
 //
 // WHY A HOOK AT ALL
 //   The shim raises a notice at launch, but only when the shim runs, and that needs the shim
@@ -38,6 +38,10 @@ export function claudeSkillsDir(env = process.env, home = os.homedir()) {
 export function codexHome(env = process.env, home = os.homedir()) {
   return env.CODEX_HOME || path.join(home, '.codex');
 }
+// The global customization root of the Antigravity CLI.
+export function agyHome(home = os.homedir()) {
+  return path.join(home, '.gemini', 'antigravity-cli');
+}
 
 export function renderClaudePlugin(version = 'dev') {
   return `${JSON.stringify({
@@ -171,24 +175,83 @@ function uninstallCodex(opts) {
   return { ok: true, path: file };
 }
 
+// ---- Antigravity CLI (agy) -------------------------------------------------------------------
+//
+// agy reads hooks.json from its customization root: one key per named hook. It runs a hook command
+// with its quotes kept literally, so the path goes unquoted, with forward slashes. A path with a
+// space cannot be written that way, and then agy is skipped.
+//
+// agy 1.2.14 loads this global file but does not run its hooks; only a workspace's .agents/hooks.json
+// runs (measured 2026-10-03). The entry is ready for a release that runs global hooks. Until then the
+// shim toast is the launch notice for agy.
+export const AGY_HOOK_NAME = 'llm-switcher-status';
+export const AGY_GLOBAL_HOOKS_NOTE = 'agy 1.2.14 loads global hooks but does not run them yet; the shim toast is the notice';
+
+function agyHooksPath(opts) {
+  return path.join(opts.agyHome || agyHome(), 'hooks.json');
+}
+
+export function agyHookCommand(script = HOOK_SCRIPT) {
+  const p = script.split(path.sep).join('/');
+  return /\s/.test(p) ? null : `node ${p} agy`;
+}
+
+const isPlainObject = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+
+// A space in the path is a limit of agy, not a fault: the install is skipped, never failed.
+function installAgy(opts) {
+  const script = opts.hookScript || HOOK_SCRIPT;
+  const command = agyHookCommand(script);
+  if (!command) return { ok: true, skipped: true, reason: `${script} holds a space, and agy cannot run a quoted path` };
+  const file = agyHooksPath(opts);
+  const cur = readJsonFile(file);
+  if (cur.error) return { ok: false, reason: `${file} does not parse: ${cur.error}, so nothing was changed` };
+  if (!cur.missing && !isPlainObject(cur.value)) return { ok: false, reason: `${file} does not hold a JSON object, so nothing was changed` };
+  const doc = cur.missing ? {} : cur.value;
+  doc[AGY_HOOK_NAME] = { SessionStart: [{ type: 'command', command, timeout: 10 }] };
+  writeAtomic(file, `${JSON.stringify(doc, null, 2)}\n`);
+  return { ok: true, path: file };
+}
+
+function uninstallAgy(opts) {
+  const file = agyHooksPath(opts);
+  const cur = readJsonFile(file);
+  if (cur.missing) return { ok: true, path: file, absent: true };
+  if (cur.error) return { ok: false, reason: `${file} does not parse: ${cur.error}, so nothing was changed` };
+  // install never writes into such a file, so the hook cannot be in it.
+  if (!isPlainObject(cur.value)) return { ok: true, path: file, absent: true };
+  const doc = cur.value;
+  if (!Object.hasOwn(doc, AGY_HOOK_NAME)) return { ok: true, path: file, absent: true };
+  delete doc[AGY_HOOK_NAME];
+  // agy has no room for a mark in this file, so it is removed only when nothing else is left in it.
+  if (Object.keys(doc).length === 0) fs.rmSync(file, { force: true });
+  else writeAtomic(file, `${JSON.stringify(doc, null, 2)}\n`);
+  return { ok: true, path: file };
+}
+
 // ---- The three commands ----------------------------------------------------------------------
 
-function summarize(results) {
-  const out = { installed: [], failed: [], paths: {} };
-  for (const [tool, r] of Object.entries(results)) {
-    if (r.ok) out.installed.push(tool); else out.failed.push({ tool, reason: r.reason });
+// Each tool runs on its own: a fault in one file must not stop the other tools.
+function summarize(steps) {
+  const out = { installed: [], skipped: [], failed: [], paths: {} };
+  for (const [tool, step] of Object.entries(steps)) {
+    let r;
+    try { r = step(); } catch (err) { r = { ok: false, reason: err.message }; }
+    if (r.skipped) out.skipped.push({ tool, reason: r.reason });
+    else if (r.ok) out.installed.push(tool);
+    else out.failed.push({ tool, reason: r.reason });
     if (r.path) out.paths[tool] = r.path;
   }
   return out;
 }
 
-/** { installed: ['claude','codex'], failed: [{ tool, reason }], paths: { claude, codex } } */
+/** { installed: ['claude','codex','agy'], skipped: [{ tool, reason }], failed: [{ tool, reason }], paths } */
 export function installPlugin(opts = {}, version = 'dev') {
-  return summarize({ claude: installClaude(opts, version), codex: installCodex(opts) });
+  return summarize({ claude: () => installClaude(opts, version), codex: () => installCodex(opts), agy: () => installAgy(opts) });
 }
 
 export function uninstallPlugin(opts = {}) {
-  return summarize({ claude: uninstallClaude(opts), codex: uninstallCodex(opts) });
+  return summarize({ claude: () => uninstallClaude(opts), codex: () => uninstallCodex(opts), agy: () => uninstallAgy(opts) });
 }
 
 export function pluginStatus(opts = {}) {
@@ -197,8 +260,16 @@ export function pluginStatus(opts = {}) {
   const file = codexHooksPath(opts);
   const codexDoc = readJsonFile(file);
   const codexGroups = Array.isArray(codexDoc.value?.hooks?.SessionStart) ? codexDoc.value.hooks.SessionStart : [];
+  const agyDoc = readJsonFile(agyHooksPath(opts));
   return {
     claude: { installed: claudeManifest.value?.name === PLUGIN_NAME, path: dir, id: `${PLUGIN_NAME}@skills-dir` },
-    codex: { installed: codexGroups.some(isOurs), path: file }
+    codex: { installed: codexGroups.some(isOurs), path: file },
+    agy: {
+      installed: isPlainObject(agyDoc.value) && Boolean(agyDoc.value[AGY_HOOK_NAME]),
+      path: agyHooksPath(opts),
+      note: AGY_GLOBAL_HOOKS_NOTE,
+      ...(agyDoc.error ? { error: `does not parse: ${agyDoc.error}` }
+        : !agyDoc.missing && !isPlainObject(agyDoc.value) ? { error: 'does not hold a JSON object' } : {})
+    }
   };
 }