@jacobbd/relay-ai 0.7.0 → 0.7.2

package/dist/cli.js

@@ -17,6 +17,7 @@ import {
   appendCodexBodyDump,
   authenticateProvider,
   buildAntigravityChildEnv,
+  buildAntigravityRoutes,
   buildAppCatalogFile,
   buildCatalogFile,
   buildCatalogRoutes,
@@ -25,6 +26,8 @@ import {
   buildCodexAppRootConfig,
   buildHttpProxyRoutes,
   buildImportProviderList,
+  buildListExperimentsResponse,
+  buildListModelConfigsResponse,
   buildVertexRuntimeConfig,
   cachedModelToLocal,
   catalogEntryFromModel,
@@ -42,6 +45,7 @@ import {
   effectiveProviderBaseUrl,
   effortProviderOptions,
   encodeToolUseId,
+  evaluateAgySwitchCompatibility,
   extractApiKey,
   favoriteProviderDisplayName,
   fetchAnthropicModels,
@@ -56,6 +60,8 @@ import {
   fmtProvider,
   fmtProviderBracket,
   fmtUrl,
+  formatAnthropicModelEntry,
+  formatAnthropicModelList,
   formatCodexModelLabel,
   formatRegistryAuthLabel,
   formatUpdateNotification,
@@ -73,6 +79,7 @@ import {
   hasApplicationDefaultCredentials,
   httpProxyModelId,
   injectClaudeIdentity,
+  injectRelayModels,
   isClaudeAppRunning,
   isCodexAppRunning,
   isFreeStatus,
@@ -92,6 +99,7 @@ import {
   makeRouteResolver,
   makeTraceLogger,
   maxToolsForNpm,
+  meetsContextFloor,
   migrateGlobalOpencodeCredential,
   migrateLegacyCloudProviders,
   modelSelectOption,
@@ -137,6 +145,7 @@ import {
   resolveProviderTemplate,
   resolveProvidersForDisplay,
   resolveRefreshCredential,
+  resolveRelayCatalogSlots,
   routableModelsForTarget,
   routeLookupIds,
   runServerCommand,
@@ -165,14 +174,14 @@ import {
   validateCustomEndpointUrl,
   writeSecureLogLine,
   zenRegistryStub
-} from "./chunk-IYYLLN5T.js";
+} from "./chunk-LNQ46VW7.js";
 import {
   filterTemplates,
   init_provider_templates,
   listAddableTemplates,
   listSupportedTemplates,
   listVisibleOAuthTemplates
-} from "./chunk-EJONCU3B.js";
+} from "./chunk-HXGZ4CTV.js";
 
 // src/cli.ts
 import pc12 from "picocolors";
@@ -208,12 +217,12 @@ function findOpencodeBinary() {
       stdio: ["pipe", "pipe", "pipe"]
     });
     const lines = result.trim().split("\n").map((l) => l.trim()).filter(Boolean);
-    const path2 = (isWindows ? lines.find((l) => l.toLowerCase().endsWith(".cmd")) : null) ?? lines[0];
-    if (path2) return path2;
+    const path3 = (isWindows ? lines.find((l) => l.toLowerCase().endsWith(".cmd")) : null) ?? lines[0];
+    if (path3) return path3;
   } catch {
   }
-  for (const path2 of OPENCODE_FALLBACK_PATHS) {
-    if (existsSync(path2)) return path2;
+  for (const path3 of OPENCODE_FALLBACK_PATHS) {
+    if (existsSync(path3)) return path3;
   }
   return null;
 }
@@ -589,7 +598,7 @@ async function resolveOrCollectApiKey(simulate = false, trace = false) {
   if (isLinux && !simulate) {
     secretServiceAvailable = await isSecretServiceAvailable();
   }
-  const { display, path: path2 } = detectShellProfile();
+  const { display, path: path3 } = detectShellProfile();
   const saveOptions = (() => {
     if (isMac) {
       return [
@@ -648,9 +657,9 @@ async function resolveOrCollectApiKey(simulate = false, trace = false) {
     if (await saveToCredentialStore(trimmedKey)) {
       try {
         const autoLoadLine = `export OPENCODE_API_KEY="$(security find-generic-password -s relay-ai -a ${GLOBAL_OPENCODE_KEYRING_ACCOUNT} -w 2>/dev/null)"`;
-        const existing = existsSync2(path2) ? readFileSync(path2, "utf8") : "";
+        const existing = existsSync2(path3) ? readFileSync(path3, "utf8") : "";
         if (!existing.includes(autoLoadLine)) {
-          appendFileSync(path2, `
+          appendFileSync(path3, `
 # relay-ai: load API key from macOS Keychain
 ${autoLoadLine}
 `);
@@ -685,9 +694,9 @@ ${autoLoadLine}
     }
   } else if (saveChoice === "profile") {
     try {
-      if (!existsSync2(path2)) appendFileSync(path2, "");
+      if (!existsSync2(path3)) appendFileSync(path3, "");
       const escapedKey = trimmedKey.replace(/'/g, "'\\''");
-      appendFileSync(path2, `
+      appendFileSync(path3, `
 export OPENCODE_API_KEY='${escapedKey}'
 `);
       p.log.success(`Key saved to ${display} \u2014 active now and in all future terminals.`);
@@ -1538,7 +1547,16 @@ async function runTemplateAddFlow() {
     ]);
   }
   let baseUrlOverride;
-  if (template.urlPrompt) {
+  if (template.accountIdPrompt) {
+    const accountInput = await p5.text({
+      message: template.accountIdPrompt,
+      placeholder: "e.g. 4ff191dac2d0bd7538cb1c9126594de3",
+      validate: (v) => v.trim() ? void 0 : "Account ID is required"
+    });
+    if (p5.isCancel(accountInput)) return 0;
+    const accountId = String(accountInput).trim();
+    baseUrlOverride = template.defaultBaseUrl?.replace("{ACCOUNT_ID}", accountId);
+  } else if (template.urlPrompt) {
     const urlInput = await p5.text({
       message: template.urlPrompt,
       initialValue: template.defaultBaseUrl,
@@ -3796,11 +3814,11 @@ function ownedOverlayPaths(env = process.env) {
   }
   return paths;
 }
-function atomicWriteFile(path2, content) {
-  mkdirSync(dirname(path2), { recursive: true });
-  const tmp = `${path2}.tmp.${process.pid}`;
+function atomicWriteFile(path3, content) {
+  mkdirSync(dirname(path3), { recursive: true });
+  const tmp = `${path3}.tmp.${process.pid}`;
   writeFileSync(tmp, content, "utf8");
-  renameSync(tmp, path2);
+  renameSync(tmp, path3);
 }
 function rotateBackups(filePath, env = process.env) {
   if (!existsSync3(filePath)) return;
@@ -3818,24 +3836,24 @@ function rotateBackups(filePath, env = process.env) {
     }
   }
 }
-function writeOverlayFile(path2, content, env = process.env) {
-  rotateBackups(path2, env);
-  atomicWriteFile(path2, content);
+function writeOverlayFile(path3, content, env = process.env) {
+  rotateBackups(path3, env);
+  atomicWriteFile(path3, content);
 }
 function readSessionLock(env = process.env) {
-  const path2 = getSessionLockPath(env);
-  if (!existsSync3(path2)) return null;
+  const path3 = getSessionLockPath(env);
+  if (!existsSync3(path3)) return null;
   try {
-    const parsed = JSON.parse(readFileSync2(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path3, "utf8"));
     if (typeof parsed.pid === "number" && typeof parsed.startedAt === "string") return parsed;
   } catch {
   }
   return null;
 }
 function writeSessionLock(lock, env = process.env) {
-  const path2 = getSessionLockPath(env);
+  const path3 = getSessionLockPath(env);
   mkdirSync(getRelayAiCodexDir(env), { recursive: true });
-  atomicWriteFile(path2, `${JSON.stringify(lock, null, 2)}
+  atomicWriteFile(path3, `${JSON.stringify(lock, null, 2)}
 `);
 }
 function isProcessAlive(pid) {
@@ -3852,11 +3870,11 @@ function isConcurrentSession(lock) {
 }
 function restoreCodexOverlay(env = process.env) {
   const removed = [];
-  for (const path2 of ownedOverlayPaths(env)) {
-    if (!existsSync3(path2)) continue;
+  for (const path3 of ownedOverlayPaths(env)) {
+    if (!existsSync3(path3)) continue;
     try {
-      rmSync(path2, { force: true });
-      removed.push(path2);
+      rmSync(path3, { force: true });
+      removed.push(path3);
     } catch {
     }
   }
@@ -4003,16 +4021,16 @@ function findCodexBinary() {
 }
 function selectCodexBinary(candidates, exists, canRun) {
   const seen = /* @__PURE__ */ new Set();
-  for (const path2 of candidates) {
-    if (!path2 || seen.has(path2)) continue;
-    seen.add(path2);
-    if (exists(path2) && canRun(path2)) return path2;
+  for (const path3 of candidates) {
+    if (!path3 || seen.has(path3)) continue;
+    seen.add(path3);
+    if (exists(path3) && canRun(path3)) return path3;
   }
   return null;
 }
-function canRunCodexBinary(path2) {
+function canRunCodexBinary(path3) {
   try {
-    execFileSync(path2, ["--version"], {
+    execFileSync(path3, ["--version"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 5e3,
@@ -6468,655 +6486,6 @@ function formatCloudCodeChunk(opts) {
   };
 }
 
-// src/antigravity/slot-registry.ts
-var AGY_SLOT_VALIDATION_SOURCE = "AGY CLI 1.0.10 / Antigravity IDE 2.1.1 fixture capture 2026-06-23";
-var AGY_NATIVE_SLOT_REGISTRY = [
-  {
-    slotId: "gemini-3.5-flash-low",
-    model: "MODEL_PLACEHOLDER_M20",
-    role: "agent-switch",
-    status: "validated",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "gemini-3.5-flash-extra-low",
-    model: "MODEL_PLACEHOLDER_M187",
-    role: "agent-switch",
-    status: "validated",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "gemini-3.1-pro-low",
-    model: "MODEL_PLACEHOLDER_M36",
-    role: "agent-switch",
-    status: "validated",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "gemini-pro-agent",
-    model: "MODEL_PLACEHOLDER_M16",
-    role: "agent-switch",
-    status: "validated",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "claude-sonnet-4-6",
-    model: "MODEL_PLACEHOLDER_M35",
-    role: "agent-switch",
-    status: "validated",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "claude-opus-4-6-thinking",
-    model: "MODEL_PLACEHOLDER_M26",
-    role: "agent-switch",
-    status: "validated",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "gpt-oss-120b-medium",
-    model: "MODEL_OPENAI_GPT_OSS_120B_MEDIUM",
-    role: "agent-switch",
-    status: "validated",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "gemini-3-flash-agent",
-    model: "MODEL_PLACEHOLDER_M132",
-    role: "cascade-plan",
-    status: "reserved",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE,
-    notes: "Visible in agentModelSorts, but reserved for cascade plan construction."
-  },
-  {
-    slotId: "gemini-2.5-flash",
-    model: "MODEL_GOOGLE_GEMINI_2_5_FLASH",
-    role: "cascade-intent",
-    status: "reserved",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "gemini-2.5-flash-lite",
-    model: "MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE",
-    role: "cascade-fallback",
-    status: "reserved",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "gemini-3.1-pro-high",
-    model: "MODEL_PLACEHOLDER_M37",
-    role: "agent-switch",
-    status: "candidate",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE,
-    notes: "Model-shaped fixture entry; requires live switching proof before promotion."
-  },
-  {
-    slotId: "gemini-2.5-pro",
-    model: "MODEL_GOOGLE_GEMINI_2_5_PRO",
-    role: "agent-switch",
-    status: "candidate",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE,
-    notes: "Model-shaped fixture entry; requires live switching proof before promotion."
-  },
-  {
-    slotId: "gemini-2.5-flash-thinking",
-    model: "MODEL_GOOGLE_GEMINI_2_5_FLASH_THINKING",
-    role: "agent-switch",
-    status: "candidate",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE,
-    notes: "Model-shaped fixture entry; requires live switching proof before promotion."
-  },
-  {
-    slotId: "gemini-3-flash",
-    model: "MODEL_PLACEHOLDER_M18",
-    role: "command",
-    status: "candidate",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE,
-    notes: "Command model in the fixture; not switch-safe without live proof."
-  },
-  {
-    slotId: "gemini-3.1-flash-lite",
-    model: "MODEL_PLACEHOLDER_M50",
-    role: "cascade-checkpoint",
-    status: "candidate",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE,
-    notes: "Checkpoint/search/commit slot; route as helper until live proof exists."
-  },
-  {
-    slotId: "gemini-3.1-flash-image",
-    model: "MODEL_PLACEHOLDER_M21",
-    role: "image",
-    status: "candidate",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE,
-    notes: "Image generation slot; not switch-safe without live proof."
-  },
-  {
-    slotId: "tab_jump_flash_lite_preview",
-    model: "MODEL_PLACEHOLDER_M28",
-    role: "tab",
-    status: "unsafe",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "tab_flash_lite_preview",
-    model: "MODEL_PLACEHOLDER_M19",
-    role: "tab",
-    status: "unsafe",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "chat_20706",
-    model: "MODEL_CHAT_20706",
-    role: "chat",
-    status: "unsafe",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  },
-  {
-    slotId: "chat_23310",
-    model: "MODEL_CHAT_23310",
-    role: "chat",
-    status: "unsafe",
-    validatedWith: AGY_SLOT_VALIDATION_SOURCE
-  }
-];
-var KNOWN_COMPATIBLE_AGY_VERSIONS = /* @__PURE__ */ new Set(["1.0.10"]);
-var KNOWN_INCOMPATIBLE_AGY_VERSIONS = /* @__PURE__ */ new Set(["1.0.9"]);
-function withFixtureModel(definition, model) {
-  return model === definition.model ? definition : { ...definition, model };
-}
-function assertNoDuplicateSwitchEnums(fixture, definitions) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const definition of definitions) {
-    if (definition.status !== "validated") continue;
-    const actualModel = fixture.models[definition.slotId]?.model;
-    if (!actualModel) continue;
-    const previousSlotId = seen.get(actualModel);
-    if (previousSlotId) {
-      throw new Error(
-        `Duplicate AGY switch slot enum ${actualModel}: ${previousSlotId} and ${definition.slotId}`
-      );
-    }
-    seen.set(actualModel, definition.slotId);
-  }
-}
-function validateAgySlotRegistry(fixture) {
-  assertNoDuplicateSwitchEnums(fixture, AGY_NATIVE_SLOT_REGISTRY);
-  const switchSlots = [];
-  const reservedSlots = [];
-  const candidateSlots = [];
-  const warnings = [];
-  for (const definition of AGY_NATIVE_SLOT_REGISTRY) {
-    const entry = fixture.models[definition.slotId];
-    if (!entry) {
-      if (definition.status === "validated" || definition.status === "reserved") {
-        warnings.push(`AGY slot ${definition.slotId} missing from fixture`);
-      }
-      continue;
-    }
-    if (entry.model !== definition.model) {
-      warnings.push(
-        `AGY slot ${definition.slotId} expected ${definition.model} but fixture has ${entry.model}`
-      );
-      continue;
-    }
-    if (definition.status === "validated") {
-      switchSlots.push(withFixtureModel(definition, entry.model));
-    } else if (definition.status === "reserved") {
-      reservedSlots.push(withFixtureModel(definition, entry.model));
-    } else if (definition.status === "candidate") {
-      candidateSlots.push(withFixtureModel(definition, entry.model));
-    }
-  }
-  return { switchSlots, reservedSlots, candidateSlots, warnings };
-}
-function getValidatedAgySwitchSlots(fixture) {
-  return validateAgySlotRegistry(fixture).switchSlots;
-}
-function evaluateAgySwitchCompatibility(opts) {
-  const validation = validateAgySlotRegistry(opts.fixture);
-  const shapeMatches = validation.warnings.length === 0 && validation.switchSlots.length > 0;
-  const warnings = [];
-  if (opts.versionReadError) {
-    warnings.push(`Could not read agy --version (${opts.versionReadError}); validating AGY fixture shape instead.`);
-  }
-  if (opts.version && KNOWN_INCOMPATIBLE_AGY_VERSIONS.has(opts.version)) {
-    return {
-      mode: "single-model",
-      validatedSwitchSlotCount: validation.switchSlots.length,
-      warnings: [
-        ...warnings,
-        `Known-incompatible AGY version ${opts.version}; falling back to single-model mode.`
-      ]
-    };
-  }
-  if (!shapeMatches) {
-    return {
-      mode: "single-model",
-      validatedSwitchSlotCount: validation.switchSlots.length,
-      warnings: [
-        ...warnings,
-        ...validation.warnings,
-        "AGY fixture shape does not match the validated slot registry; falling back to single-model mode."
-      ]
-    };
-  }
-  if (opts.version && !KNOWN_COMPATIBLE_AGY_VERSIONS.has(opts.version)) {
-    warnings.push(`Unvalidated AGY version ${opts.version}; fixture shape matches, so multi-model switching remains enabled.`);
-  } else if (!opts.version && !opts.versionReadError) {
-    warnings.push("AGY version is unknown; fixture shape matches, so multi-model switching remains enabled.");
-  }
-  return {
-    mode: "multi-model",
-    validatedSwitchSlotCount: validation.switchSlots.length,
-    warnings
-  };
-}
-
-// src/antigravity/catalog.ts
-var RELAY_CASCADE_PLAN_MODEL = "MODEL_PLACEHOLDER_M132";
-var RELAY_AGENT_PLACEHOLDER = "MODEL_PLACEHOLDER_M20";
-var RELAY_CASCADE_CHECKPOINT_MODEL = "MODEL_PLACEHOLDER_M50";
-var RELAY_CASCADE_INTENT_MODEL = "MODEL_GOOGLE_GEMINI_2_5_FLASH";
-var RELAY_CASCADE_ANCHOR_ID = "gemini-3.5-flash-low";
-var RELAY_CASCADE_PLAN_ANCHOR_ID = "gemini-3-flash-agent";
-var RELAY_CASCADE_FALLBACK_ID = "gemini-2.5-flash-lite";
-var RELAY_CASCADE_INTENT_MODEL_ID = "gemini-2.5-flash";
-function withCascadeCheckpointer(entry, maxTokenLimit = 128e3) {
-  const tokenThreshold = Math.min(5e4, Math.floor(maxTokenLimit * 0.75));
-  const existingModelExperiments = entry.modelExperiments;
-  entry.modelExperiments = {
-    ...existingModelExperiments,
-    experiments: {
-      ...existingModelExperiments?.experiments ?? {},
-      CASCADE_USE_EXPERIMENT_CHECKPOINTER: {
-        stringValue: JSON.stringify({
-          strategy: "CHECKPOINT_STRATEGY_SAME_MODEL",
-          max_token_limit: String(maxTokenLimit),
-          token_threshold: String(tokenThreshold),
-          max_overhead_ratio: "0.15",
-          moving_window_size: "1",
-          enabled: true,
-          max_output_tokens: "16384",
-          checkpoint_model: RELAY_CASCADE_CHECKPOINT_MODEL,
-          use_last_planner_model: true,
-          is_sync: true,
-          max_user_requests: 10,
-          include_last_user_message: true,
-          include_conversation_log: false,
-          include_running_task_snapshots: true,
-          include_subagent_snapshots: true,
-          include_artifact_snapshots: true,
-          retry_config: {
-            max_retries: 0,
-            initial_sleep_duration_ms: 1e3,
-            exponential_multiplier: 2,
-            include_error_feedback: false
-          }
-        })
-      }
-    }
-  };
-  return entry;
-}
-function applyRouteContextBounds(entry, route) {
-  const maxTokenLimit = route.contextWindow ?? 128e3;
-  const maxOutputTokens = Math.min(entry.maxOutputTokens ?? 65536, maxTokenLimit);
-  const checkpointTokenLimit = Math.min(
-    128e3,
-    Math.max(1, maxTokenLimit - maxOutputTokens)
-  );
-  entry.maxTokens = maxTokenLimit;
-  entry.maxOutputTokens = maxOutputTokens;
-  return withCascadeCheckpointer(entry, checkpointTokenLimit);
-}
-var RELAY_CASCADE_FALLBACK_ENTRY = withCascadeCheckpointer({
-  displayName: "Gemini 3.1 Flash Lite",
-  model: "MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE",
-  apiProvider: "API_PROVIDER_GOOGLE_GEMINI",
-  modelProvider: "MODEL_PROVIDER_GOOGLE",
-  tokenizerType: "LLAMA_WITH_SPECIAL",
-  maxTokens: 1048576,
-  maxOutputTokens: 65535,
-  quotaInfo: { remainingFraction: 1 }
-});
-var RELAY_CASCADE_INTENT_MODEL_ENTRY = withCascadeCheckpointer({
-  ...RELAY_CASCADE_FALLBACK_ENTRY,
-  model: RELAY_CASCADE_INTENT_MODEL
-});
-function planRelayCatalogSlots(catalog, routes, templateKey) {
-  const validation = validateAgySlotRegistry(catalog);
-  const switchSlots = getValidatedAgySwitchSlots(catalog);
-  const templateSlot = switchSlots.find((slot) => slot.slotId === templateKey);
-  const orderedSlots = templateSlot ? [templateSlot, ...switchSlots.filter((slot) => slot.slotId !== templateKey)] : switchSlots;
-  if (routes.length > 0 && orderedSlots.length === 0) {
-    throw new Error("No validated AGY switch slots are available for the selected launch route");
-  }
-  const switchableRoutes = routes.slice(0, orderedSlots.length);
-  const skippedRoutes = routes.slice(orderedSlots.length);
-  const slots = switchableRoutes.map((route, index) => ({
-    slotId: orderedSlots[index].slotId,
-    route
-  }));
-  return {
-    slots,
-    switchableRoutes,
-    skippedRoutes,
-    validation
-  };
-}
-function resolveRelayCatalogSlots(catalog, routes, templateKey) {
-  return planRelayCatalogSlots(catalog, routes, templateKey).slots;
-}
-function buildRelayCatalogEntry(route, template) {
-  const entry = structuredClone(template);
-  entry.displayName = route.displayName;
-  entry.model = template.model ?? RELAY_AGENT_PLACEHOLDER;
-  entry.requestedModelId = route.catalogId;
-  entry.modelVersion = route.catalogId;
-  entry.modelVersionId = route.catalogId;
-  entry.quotaInfo = { remainingFraction: 1, resetTime: "2026-06-23T02:00:57Z" };
-  return applyRouteContextBounds(entry, route);
-}
-function buildRelayCatalogSlotEntry(route, template) {
-  const entry = structuredClone(template);
-  entry.displayName = route.displayName;
-  entry.quotaInfo = { remainingFraction: 1, resetTime: "2026-06-23T02:00:57Z" };
-  delete entry.requestedModelId;
-  delete entry.modelVersion;
-  delete entry.modelVersionId;
-  delete entry.isInternal;
-  return applyRouteContextBounds(entry, route);
-}
-function injectRelayModels(fixture, routes, templateKey) {
-  const result = structuredClone(fixture);
-  const template = fixture.models[templateKey];
-  if (!template) {
-    throw new Error(`Template model "${templateKey}" not found in catalog fixture`);
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const route of routes) {
-    if (seen.has(route.catalogId)) {
-      throw new Error(`Catalog ID collision: ${route.catalogId}`);
-    }
-    if (fixture.models[route.catalogId]) {
-      throw new Error(`Catalog ID collision with native model: ${route.catalogId}`);
-    }
-    seen.add(route.catalogId);
-  }
-  if (routes.length > 0) {
-    result.models[RELAY_CASCADE_ANCHOR_ID] ??= structuredClone(template);
-    result.models[RELAY_CASCADE_FALLBACK_ID] ??= structuredClone(RELAY_CASCADE_FALLBACK_ENTRY);
-    result.models[RELAY_CASCADE_INTENT_MODEL_ID] ??= structuredClone(RELAY_CASCADE_INTENT_MODEL_ENTRY);
-    if (!result.models[RELAY_CASCADE_PLAN_ANCHOR_ID]) {
-      const planAnchor = withCascadeCheckpointer(structuredClone(template));
-      planAnchor.model = RELAY_CASCADE_PLAN_MODEL;
-      result.models[RELAY_CASCADE_PLAN_ANCHOR_ID] = planAnchor;
-    }
-    const slotPlan = planRelayCatalogSlots(result, routes, templateKey);
-    const slots = slotPlan.slots;
-    for (const { slotId, route } of slots) {
-      const slotTemplate = result.models[slotId] ?? template;
-      if (result.models[slotId]) {
-        result.models[slotId] = buildRelayCatalogSlotEntry(route, slotTemplate);
-      }
-      result.models[route.catalogId] = buildRelayCatalogEntry(route, slotTemplate);
-    }
-    result.defaultAgentModelId = slots[0]?.slotId ?? RELAY_CASCADE_ANCHOR_ID;
-    result.agentModelSorts = [
-      {
-        displayName: "Recommended",
-        groups: [{
-          modelIds: slots.map((slot) => slot.slotId)
-        }]
-      }
-    ];
-    return result;
-  }
-  if (!result.agentModelSorts?.[0]?.groups?.[0]) {
-    result.agentModelSorts = [
-      {
-        displayName: "Recommended",
-        groups: [{ modelIds: [] }]
-      }
-    ];
-  }
-  return result;
-}
-function buildAntigravityRoutes(resolvedFavorites, maxRoutes = MAX_MODEL_CATALOG) {
-  const routes = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const fav of resolvedFavorites) {
-    if (routes.length >= maxRoutes) break;
-    const favModel = fav.model;
-    const modelId = favModel.id;
-    const catalogId = `relay-ai__${fav.providerId}__${modelId}`;
-    if (seen.has(catalogId)) continue;
-    seen.add(catalogId);
-    const npm = favModel.npm || "@ai-sdk/openai-compatible";
-    const upstreamModelId = favModel.upstreamModelId || modelId;
-    const baseURL = favModel.apiBaseUrl || favModel.completionsUrl || void 0;
-    const contextWindow = favModel.contextWindow;
-    const modelFormat = favModel.modelFormat;
-    routes.push({
-      catalogId,
-      providerId: fav.providerId,
-      providerName: fav.providerName,
-      modelId,
-      upstreamModelId,
-      displayName: `${favModel.name} (Relay)`,
-      ...modelFormat ? { modelFormat } : {},
-      npm,
-      apiKey: fav.apiKey,
-      ...fav.authType ? { authType: fav.authType } : {},
-      ...fav.oauthAccountId ? { oauthAccountId: fav.oauthAccountId } : {},
-      ...fav.providerData ? { providerData: fav.providerData } : {},
-      baseURL,
-      contextWindow
-    });
-  }
-  return applyUniqueAntigravityRouteLabels(routes);
-}
-function routeBaseModelName(route) {
-  const relayMatch = route.displayName.match(/^(.*) \(Relay(?: - .*)?\)$/);
-  return relayMatch?.[1] ?? route.displayName;
-}
-function authKindLabel(route) {
-  if (route.authType === "oauth") return "OAuth";
-  if (route.authType === "api") return "API key";
-  if (route.authType === "none") return "local";
-  return "provider";
-}
-function duplicateCounts(values) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    counts.set(value, (counts.get(value) ?? 0) + 1);
-  }
-  return counts;
-}
-function assertUniqueRouteDisplayNames(routes) {
-  const counts = duplicateCounts(routes.map((route) => route.displayName));
-  const duplicate = [...counts.entries()].find(([, count]) => count > 1);
-  if (duplicate) {
-    throw new Error(`Duplicate AGY model label after disambiguation: ${duplicate[0]}`);
-  }
-}
-function applyUniqueAntigravityRouteLabels(routes) {
-  const baseNames = routes.map(routeBaseModelName);
-  const baseNameCounts = duplicateCounts(baseNames);
-  const upstreamCounts = duplicateCounts(routes.map((route) => route.upstreamModelId));
-  const providerNameCounts = duplicateCounts(routes.map((route) => route.providerName));
-  const labeled = routes.map((route, index) => {
-    const baseName = baseNames[index];
-    const needsSuffix = (baseNameCounts.get(baseName) ?? 0) > 1 || (upstreamCounts.get(route.upstreamModelId) ?? 0) > 1;
-    if (!needsSuffix) {
-      return { ...route, displayName: `${baseName} (Relay)` };
-    }
-    const providerName = route.providerName || route.providerId;
-    const providerSuffix = (providerNameCounts.get(providerName) ?? 0) > 1 ? `${providerName} ${authKindLabel(route)}` : providerName;
-    return {
-      ...route,
-      displayName: `${baseName} (Relay - ${providerSuffix})`
-    };
-  });
-  const firstPassCounts = duplicateCounts(labeled.map((route) => route.displayName));
-  const withProviderIds = labeled.map((route) => {
-    if ((firstPassCounts.get(route.displayName) ?? 0) <= 1) return route;
-    return {
-      ...route,
-      displayName: route.displayName.replace(/\)$/, ` - ${route.providerId})`)
-    };
-  });
-  assertUniqueRouteDisplayNames(withProviderIds);
-  return withProviderIds;
-}
-function routeLabels(routes) {
-  assertUniqueRouteDisplayNames(routes);
-  const labels = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    labels.set(route.catalogId, route.displayName);
-  }
-  return labels;
-}
-function buildClientModelConfigData(routes, catalog, templateKey = RELAY_CASCADE_ANCHOR_ID, precomputedSlots) {
-  const catalogRoutes = routes.slice(0, MAX_MODEL_CATALOG);
-  const slots = precomputedSlots ?? (catalog ? resolveRelayCatalogSlots(catalog, catalogRoutes, templateKey) : catalogRoutes.map((route) => ({ slotId: route.catalogId, route })));
-  const labels = routeLabels(catalogRoutes);
-  const clientModelConfigs = slots.map(({ slotId, route }) => {
-    const entry = catalog?.models[slotId] ?? catalog?.models[route.catalogId] ?? catalog?.models[RELAY_CASCADE_ANCHOR_ID];
-    const label = labels.get(route.catalogId) ?? route.displayName;
-    return {
-      label,
-      modelOrAlias: {
-        alias: slotId,
-        choice: { case: "alias", value: slotId }
-      },
-      disabled: false,
-      supportedMimeTypes: entry?.supportedMimeTypes ?? {},
-      quotaInfo: entry?.quotaInfo ?? { remainingFraction: 1 },
-      tagTitle: entry?.tagTitle,
-      tagDescription: entry?.tagDescription,
-      supportsThoughtCirculation: entry?.supportsThoughtCirculation ?? false
-    };
-  });
-  return {
-    clientModelConfigs,
-    clientModelSorts: [
-      {
-        name: "Recommended",
-        groups: [
-          {
-            groupName: "",
-            modelLabels: clientModelConfigs.map((config) => config.label)
-          }
-        ]
-      }
-    ],
-    defaultOverrideModelConfig: clientModelConfigs[0] ?? {}
-  };
-}
-function buildListModelConfigsResponse(routes, catalog, templateKey = RELAY_CASCADE_ANCHOR_ID) {
-  const catalogRoutes = routes.slice(0, MAX_MODEL_CATALOG);
-  const slots = catalog ? resolveRelayCatalogSlots(catalog, catalogRoutes, templateKey) : catalogRoutes.map((route) => ({ slotId: route.catalogId, route }));
-  const config = slots.map(({ slotId }) => ({
-    requestedModelId: slotId,
-    planModel: RELAY_CASCADE_PLAN_MODEL,
-    requestedModel: catalog?.models[slotId]?.model ?? RELAY_AGENT_PLACEHOLDER
-  }));
-  return {
-    ...buildClientModelConfigData(routes, catalog, templateKey, slots),
-    allowedModelConfigs: config,
-    defaultAgentModelConfig: config[0] ?? {}
-  };
-}
-var CURRENT_EXPERIMENT_IDS = [
-  105979552,
-  105979574,
-  106015351,
-  105979579,
-  105867471,
-  105979530,
-  105995634,
-  106121401,
-  106100625,
-  104638466,
-  101868197,
-  104817729,
-  105695344,
-  106064591,
-  104913215,
-  106324349,
-  106309078,
-  105821930,
-  104922093,
-  103012598,
-  106143956,
-  105856899,
-  106312323,
-  106064030,
-  105746183,
-  105757908,
-  104892493,
-  105822886,
-  105785683,
-  105721273,
-  105897325,
-  105658071,
-  106240758,
-  105943702,
-  106106760,
-  106283618,
-  105620019,
-  106038160,
-  106309520,
-  106281951,
-  106264532,
-  106222835,
-  106094629,
-  105887313,
-  105849474,
-  106032303,
-  106228452,
-  106113900,
-  106121607,
-  105979531,
-  105979553,
-  106015328,
-  105867469,
-  105979517,
-  106121399,
-  106100654,
-  104638459,
-  101551624,
-  104673683,
-  105695346,
-  106064590,
-  104913210,
-  105821928,
-  104922082,
-  103012592,
-  106064028,
-  105746181,
-  104892490,
-  105822881,
-  105721268,
-  105895316,
-  105658068,
-  106240748,
-  105943694,
-  106283614,
-  105620012,
-  106038153,
-  105887311,
-  106032301,
-  106113877,
-  106121604
-];
-function buildListExperimentsResponse() {
-  return {
-    experimentIds: [...CURRENT_EXPERIMENT_IDS]
-  };
-}
-
 // src/antigravity/fixtures/loadCodeAssist.json
 var loadCodeAssist_default = {
   currentTier: {
@@ -8551,6 +7920,22 @@ function respondJson(res, status, data) {
   });
   res.end(body);
 }
+function parsePseudoToolCall(text4, knownToolNames) {
+  const trimmed = text4.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+  try {
+    const obj = JSON.parse(trimmed);
+    if (obj && typeof obj === "object") {
+      const name = obj.name || obj.type === "function" && typeof obj.function === "object" && obj.function?.name || obj.function_name;
+      if (typeof name === "string" && knownToolNames.has(name)) {
+        const args = obj.parameters || obj.arguments || obj.args || typeof obj.function === "object" && obj.function?.parameters || {};
+        return { name, args: typeof args === "object" && args ? args : {} };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 async function handleStreamingRequest(res, route, providerOptions, parsed, log14, options = {}) {
   const sdkParams = applyClaudeCodeOAuthIdentity(route, translateRequest(parsed, {
     ...options.requestOptions,
@@ -8589,8 +7974,39 @@ async function handleStreamingRequest(res, route, providerOptions, parsed, log14
   };
   const thinkFilter = createThinkFilter();
   const toolCallBuffers = /* @__PURE__ */ new Map();
+  const knownToolNames = new Set(Object.keys(sdkParams.tools ?? {}));
   let responseReasoning = "";
   let sawToolCall = false;
+  let textBuffer = "";
+  let bufferingJsonText = false;
+  const flushBufferedText = () => {
+    if (!textBuffer) return;
+    startSse();
+    const chunk = formatCloudCodeChunk({
+      text: textBuffer,
+      modelVersion: route.catalogId,
+      responseId
+    });
+    res.write(`data: ${JSON.stringify(chunk)}
+
+`);
+    textBuffer = "";
+    bufferingJsonText = false;
+  };
+  const emitPseudoToolCall = (pseudoTool) => {
+    sawToolCall = true;
+    startSse();
+    const chunk = formatCloudCodeChunk({
+      functionCall: { name: pseudoTool.name, args: normalizeFunctionCallArgs(pseudoTool.args) },
+      modelVersion: route.catalogId,
+      responseId
+    });
+    res.write(`data: ${JSON.stringify(chunk)}
+
+`);
+    textBuffer = "";
+    bufferingJsonText = false;
+  };
   for await (const part of fullStream) {
     const p15 = part;
     if (p15.type === "reasoning-delta" || p15.type === "reasoning") {
@@ -8607,15 +8023,27 @@ async function handleStreamingRequest(res, route, providerOptions, parsed, log14
       }
       if (text4) {
         log14(`[gateway] text-delta: ${JSON.stringify(text4.slice(0, 500))}`);
-        startSse();
-        const chunk = formatCloudCodeChunk({
-          text: text4,
-          modelVersion: route.catalogId,
-          responseId
-        });
-        res.write(`data: ${JSON.stringify(chunk)}
+        if (!bufferingJsonText && (textBuffer + text4).trimStart().startsWith("{")) {
+          bufferingJsonText = true;
+        }
+        if (bufferingJsonText) {
+          textBuffer += text4;
+          const pseudoTool = textBuffer.trimEnd().endsWith("}") ? parsePseudoToolCall(textBuffer, knownToolNames) : null;
+          if (pseudoTool) {
+            log14(`[gateway] parsed pseudo tool-call from text: ${pseudoTool.name}`);
+            emitPseudoToolCall(pseudoTool);
+          }
+        } else {
+          startSse();
+          const chunk = formatCloudCodeChunk({
+            text: text4,
+            modelVersion: route.catalogId,
+            responseId
+          });
+          res.write(`data: ${JSON.stringify(chunk)}
 
 `);
+        }
       }
     } else if (p15.type === "tool-input-start") {
       const id = p15.id ?? p15.toolCallId;
@@ -8647,6 +8075,15 @@ async function handleStreamingRequest(res, route, providerOptions, parsed, log14
 `);
     } else if (p15.type === "finish") {
       log14(`[gateway] finish: ${p15.finishReason ?? "unknown"}`);
+      if (textBuffer) {
+        const pseudoTool = parsePseudoToolCall(textBuffer, knownToolNames);
+        if (pseudoTool) {
+          log14(`[gateway] parsed pseudo tool-call on finish: ${pseudoTool.name}`);
+          emitPseudoToolCall(pseudoTool);
+        } else {
+          flushBufferedText();
+        }
+      }
       startSse();
       const reason = mapFinishReason2(p15.finishReason ?? "");
       const chunk = formatCloudCodeChunk({
@@ -8664,6 +8101,7 @@ async function handleStreamingRequest(res, route, providerOptions, parsed, log14
     } else if (p15.type === "error") {
       const message = formatUpstreamError(p15.error);
       log14(`[gateway] stream provider error: ${message}`);
+      flushBufferedText();
       emitStreamError(res, route, responseId, message, startSse);
       break;
     } else if (p15.type === "reasoning-start" || p15.type === "reasoning-end") {
@@ -8773,10 +8211,17 @@ async function resolveAntigravityLaunchRoutes(opts) {
     maxRoutes,
     { dropEmptyApiKey: true, trackCapacitySkipped: true }
   );
+  const tooSmall = resolved.slice(1).filter(
+    (entry) => !meetsContextFloor("antigravity", entry.model.contextWindow)
+  );
+  const launchable = resolved.filter((entry) => !tooSmall.includes(entry));
   return {
-    routes: buildAntigravityRoutes(resolved, maxRoutes),
+    routes: buildAntigravityRoutes(launchable, maxRoutes),
     apiKey,
-    droppedFavorites,
+    droppedFavorites: [
+      ...droppedFavorites,
+      ...tooSmall.map((entry) => ({ providerId: entry.providerId, modelId: entry.model.id }))
+    ],
     capacitySkippedFavorites
   };
 }
@@ -8805,12 +8250,12 @@ function findAntigravityCliBinary() {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const path2 = result.trim().split("\n")[0]?.trim();
-    if (path2) return path2;
+    const path3 = result.trim().split("\n")[0]?.trim();
+    if (path3) return path3;
   } catch {
   }
-  for (const path2 of FALLBACK_PATHS) {
-    if (existsSync6(path2)) return path2;
+  for (const path3 of FALLBACK_PATHS) {
+    if (existsSync6(path3)) return path3;
   }
   return null;
 }
@@ -8906,9 +8351,35 @@ function prepareIdeProfile(profileDir, gatewayUrl) {
 }
 
 // src/antigravity/launch-ide.ts
+var LINUX_APP_PROFILE_DIR = join7(homedir7(), ".relay-ai", "antigravity", "app-profile");
+var LINUX_IDE_PROFILE_DIR = join7(homedir7(), ".relay-ai", "antigravity", "profile");
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+function linuxAntigravityBinary() {
+  const candidates = [
+    "/usr/share/antigravity/antigravity",
+    "/opt/antigravity/antigravity",
+    join7(homedir7(), ".local", "share", "antigravity", "antigravity")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync7(candidate)) return candidate;
+  }
+  return null;
+}
+function linuxKillByProfile(profileDir, signal) {
+  const output = defaultProcessList();
+  for (const line of output.split("\n")) {
+    if (!line.includes(`--user-data-dir=${profileDir}`)) continue;
+    const pid = Number.parseInt(line.trim().split(/\s+/)[0] ?? "", 10);
+    if (Number.isFinite(pid) && pid > 0) {
+      try {
+        process.kill(pid, signal);
+      } catch {
+      }
+    }
+  }
+}
 function runPowerShell(script) {
   return execSync4(`powershell.exe -NoProfile -Command ${JSON.stringify(script)}`, {
     encoding: "utf8",
@@ -8944,9 +8415,10 @@ function winForceQuitProcess(exeName, profileDir) {
   }
 }
 function defaultProcessList() {
-  if (process.platform !== "darwin") return "";
+  const psArgs = process.platform === "linux" ? ["-eo", "pid=,args="] : ["-axo", "pid=,command="];
+  if (process.platform !== "darwin" && process.platform !== "linux") return "";
   try {
-    return execFileSync3("ps", ["-axo", "pid=,command="], {
+    return execFileSync3("ps", psArgs, {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024 * 4
@@ -8958,11 +8430,17 @@ function defaultProcessList() {
 function isAntigravityIdeRunning(profileDir, processList = defaultProcessList) {
   if (process.platform === "win32") return winIsProcessRunningForProfile("Antigravity IDE.exe", profileDir);
   const output = processList();
+  if (process.platform === "linux") {
+    return output.split("\n").some((line) => line.includes(`--user-data-dir=${profileDir}`));
+  }
   return output.split("\n").some((line) => line.includes("Antigravity IDE.app") && line.includes(`--user-data-dir=${profileDir}`));
 }
 function isAntigravityAppRunning(profileDir, processList = defaultProcessList) {
   if (process.platform === "win32") return winIsProcessRunningForProfile("Antigravity.exe", profileDir);
   const output = processList();
+  if (process.platform === "linux") {
+    return output.split("\n").some((line) => line.includes(`--user-data-dir=${profileDir}`));
+  }
   return output.split("\n").some((line) => line.includes("Antigravity.app") && line.includes(`--user-data-dir=${profileDir}`));
 }
 async function waitForAntigravityIdeQuit(profileDir, options = {}) {
@@ -8987,15 +8465,21 @@ async function waitForAntigravityAppQuit(profileDir, options = {}) {
 }
 function forceQuitAntigravityIde(profileDir) {
   if (process.platform === "win32") winForceQuitProcess("Antigravity IDE.exe", profileDir);
+  else if (process.platform === "linux") linuxKillByProfile(profileDir, "SIGKILL");
 }
 function forceQuitAntigravityApp(profileDir) {
   if (process.platform === "win32") winForceQuitProcess("Antigravity.exe", profileDir);
+  else if (process.platform === "linux") linuxKillByProfile(profileDir, "SIGKILL");
 }
 function quitAntigravityIdeGracefully() {
   if (process.platform === "win32") {
     winQuitProcess("Antigravity IDE.exe");
     return;
   }
+  if (process.platform === "linux") {
+    linuxKillByProfile(LINUX_IDE_PROFILE_DIR, "SIGTERM");
+    return;
+  }
   if (process.platform !== "darwin") return;
   try {
     execFileSync3("osascript", ["-e", 'tell application "Antigravity IDE" to quit'], {
@@ -9012,6 +8496,10 @@ function quitAntigravityAppGracefully() {
     winQuitProcess("Antigravity.exe");
     return;
   }
+  if (process.platform === "linux") {
+    linuxKillByProfile(LINUX_APP_PROFILE_DIR, "SIGTERM");
+    return;
+  }
   if (process.platform !== "darwin") return;
   try {
     execFileSync3("osascript", ["-e", 'tell application "Antigravity" to quit'], {
@@ -9031,6 +8519,7 @@ function findAntigravityAppBinary() {
     const winPath = join7(localAppData, "Programs", "Antigravity", "Antigravity.exe");
     return existsSync7(winPath) ? winPath : null;
   }
+  if (process.platform === "linux") return linuxAntigravityBinary();
   if (process.platform !== "darwin") return null;
   const defaultPath = "/Applications/Antigravity.app/Contents/MacOS/Antigravity";
   if (existsSync7(defaultPath)) return defaultPath;
@@ -9046,6 +8535,7 @@ function findAntigravityIdeBinary() {
     const winPath = join7(localAppData, "Programs", "Antigravity IDE", "Antigravity IDE.exe");
     return existsSync7(winPath) ? winPath : null;
   }
+  if (process.platform === "linux") return linuxAntigravityBinary();
   if (process.platform !== "darwin") return null;
   const defaultPath = "/Applications/Antigravity IDE.app/Contents/Resources/app/bin/antigravity-ide";
   if (existsSync7(defaultPath)) return defaultPath;
@@ -9063,8 +8553,8 @@ function launchAntigravityApp(env, profileDir, gatewayUrl, extraArgs) {
     };
     const binaryPath = findAntigravityAppBinary();
     if (!binaryPath) {
-      console.error('Antigravity app bundle not found at "/Applications/Antigravity.app".');
-      console.error("Please make sure Antigravity is installed on your Mac.");
+      console.error("Antigravity app not found.");
+      console.error("Please make sure Antigravity is installed.");
       settle(127);
       return;
     }
@@ -9074,7 +8564,12 @@ function launchAntigravityApp(env, profileDir, gatewayUrl, extraArgs) {
       ...extraArgs
     ];
     const child = spawn5(binaryPath, args, {
-      stdio: "inherit",
+      // GUI app: don't inherit the terminal's stdio (its Electron logs would
+      // corrupt relay's interactive prompts) and detach into its own process
+      // group so a Ctrl+C meant for the relay gateway doesn't also kill the app
+      // mid-render. Mirrors the Claude Desktop launcher.
+      stdio: "ignore",
+      detached: true,
       env
     });
     child.on("spawn", () => {
@@ -9093,8 +8588,8 @@ function launchAntigravityIde(env, profileDir, gatewayUrl, extraArgs) {
   return new Promise((resolve2) => {
     const binaryPath = findAntigravityIdeBinary();
     if (!binaryPath) {
-      console.error('Antigravity IDE app bundle not found at "/Applications/Antigravity IDE.app".');
-      console.error("Please make sure Antigravity IDE is installed on your Mac.");
+      console.error("Antigravity IDE not found.");
+      console.error("Please make sure Antigravity IDE is installed.");
       resolve2(127);
       return;
     }
@@ -9106,7 +8601,12 @@ function launchAntigravityIde(env, profileDir, gatewayUrl, extraArgs) {
       ...extraArgs
     ];
     const child = spawn5(binaryPath, args, {
-      stdio: "inherit",
+      // GUI app: don't inherit the terminal's stdio (its Electron logs would
+      // corrupt relay's interactive prompts) and detach into its own process
+      // group so a Ctrl+C meant for the relay gateway doesn't also kill the app
+      // mid-render. Mirrors the Claude Desktop launcher.
+      stdio: "ignore",
+      detached: true,
       env
     });
     child.on("exit", (code) => {
@@ -9613,9 +9113,9 @@ function applyRestoreNumber(config, key, had, value) {
     delete config[key];
   }
 }
-function readCodexConfigText(path2 = getCodexConfigPath()) {
-  if (!existsSync8(path2)) return "";
-  return readFileSync3(path2, "utf8");
+function readCodexConfigText(path3 = getCodexConfigPath()) {
+  if (!existsSync8(path3)) return "";
+  return readFileSync3(path3, "utf8");
 }
 function parseCodexConfig(text4) {
   if (!text4.trim()) return {};
@@ -9823,10 +9323,10 @@ function getAppCatalogPath(providerId, env = process.env) {
   return join10(getRelayAiCodexDir(env), `app-models-${providerId}.json`);
 }
 function readAppSessionLock(env = process.env) {
-  const path2 = getAppSessionLockPath(env);
-  if (!existsSync9(path2)) return null;
+  const path3 = getAppSessionLockPath(env);
+  if (!existsSync9(path3)) return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path3, "utf8"));
     if (typeof parsed.pid === "number" && typeof parsed.startedAt === "string") return parsed;
   } catch {
   }
@@ -9837,14 +9337,14 @@ function writeAppSessionLock(lock, env = process.env) {
 `);
 }
 function clearAppSessionLock(env = process.env) {
-  const path2 = getAppSessionLockPath(env);
-  if (existsSync9(path2)) rmSync4(path2, { force: true });
+  const path3 = getAppSessionLockPath(env);
+  if (existsSync9(path3)) rmSync4(path3, { force: true });
 }
 function readAppRestoreState(env = process.env) {
-  const path2 = getAppRestoreStatePath(env);
-  if (!existsSync9(path2)) return null;
+  const path3 = getAppRestoreStatePath(env);
+  if (!existsSync9(path3)) return null;
   try {
-    return JSON.parse(readFileSync4(path2, "utf8"));
+    return JSON.parse(readFileSync4(path3, "utf8"));
   } catch {
     return null;
   }
@@ -9855,8 +9355,8 @@ function writeAppRestoreState(state, env = process.env) {
 `);
 }
 function clearAppRestoreState(env = process.env) {
-  const path2 = getAppRestoreStatePath(env);
-  if (existsSync9(path2)) rmSync4(path2, { force: true });
+  const path3 = getAppRestoreStatePath(env);
+  if (existsSync9(path3)) rmSync4(path3, { force: true });
 }
 function backupConfigToml(env = process.env) {
   const configPath = getCodexConfigPath();
@@ -9886,10 +9386,10 @@ function ownedAppCatalogPaths(env = process.env) {
 }
 function removeAppCatalogs(env = process.env) {
   const removed = [];
-  for (const path2 of ownedAppCatalogPaths(env)) {
+  for (const path3 of ownedAppCatalogPaths(env)) {
     try {
-      rmSync4(path2, { force: true });
-      removed.push(path2);
+      rmSync4(path3, { force: true });
+      removed.push(path3);
     } catch {
     }
   }
@@ -10530,6 +10030,9 @@ function getClaudeDesktopHome() {
   if (process.platform === "win32") {
     return join11(process.env.LOCALAPPDATA || join11(homedir9(), "AppData", "Local"), "Claude-3p");
   }
+  if (process.platform === "linux") {
+    return join11(process.env.XDG_CONFIG_HOME || join11(homedir9(), ".config"), "Claude-3p");
+  }
   return join11(homedir9(), "Library", "Application Support", "Claude-3p");
 }
 function getConfigLibraryPath() {
@@ -10734,10 +10237,10 @@ function getSessionLockPath2() {
   return join12(getClaudeDesktopHome(), ".relay-ai.lock");
 }
 function inspectSessionLock() {
-  const path2 = getSessionLockPath2();
-  if (!existsSync11(path2)) return { status: "missing" };
+  const path3 = getSessionLockPath2();
+  if (!existsSync11(path3)) return { status: "missing" };
   try {
-    const parsed = JSON.parse(readFileSync6(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path3, "utf8"));
     if (typeof parsed.pid === "number" && typeof parsed.startedAt === "string" && typeof parsed.uuid === "string" && typeof parsed.proxyPort === "number") {
       return { status: "valid", lock: parsed };
     }
@@ -10746,13 +10249,13 @@ function inspectSessionLock() {
   return { status: "unreadable" };
 }
 function writeSessionLock2(lock) {
-  const path2 = getSessionLockPath2();
-  const tempPath = `${path2}.tmp.${process.pid}`;
-  mkdirSync6(dirname4(path2), { recursive: true });
+  const path3 = getSessionLockPath2();
+  const tempPath = `${path3}.tmp.${process.pid}`;
+  mkdirSync6(dirname4(path3), { recursive: true });
   try {
     writeFileSync5(tempPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
-    renameSync2(tempPath, path2);
+    renameSync2(tempPath, path3);
   } finally {
     try {
       rmSync5(tempPath, { force: true });
@@ -10903,7 +10406,7 @@ ${pc11.bold("Description:")}
   Keep this terminal open while using Claude.
 
 ${pc11.bold("Platforms:")}
-  macOS and Windows. Linux is not supported.
+  macOS, Windows, and Linux.
 
 ${pc11.bold("Cleanup:")}
   Ctrl+C stops the proxy and restores your previous Claude config.
@@ -11652,26 +11155,61 @@ function printAiInstallResult(result) {
   console.error(`relay-ai agent skill target version: v${result.version}`);
   if (result.installed.length > 0) {
     console.error(`Installed ${result.installed.length} new skill(s):`);
-    for (const path2 of result.installed) console.error(`  \u2713 ${path2}`);
+    for (const path3 of result.installed) console.error(`  \u2713 ${path3}`);
   }
   if (result.updated.length > 0) {
     console.error(`Updated ${result.updated.length} skill(s):`);
-    for (const { path: path2, fromVersion } of result.updated) {
+    for (const { path: path3, fromVersion } of result.updated) {
       const from = fromVersion ? `v${fromVersion}` : "unknown";
-      console.error(`  \u2713 ${path2} (${from} \u2192 v${result.version})`);
+      console.error(`  \u2713 ${path3} (${from} \u2192 v${result.version})`);
     }
   }
   if (result.skipped.length > 0) {
     console.error(`Skipped ${result.skipped.length} (already v${result.version}):`);
-    for (const path2 of result.skipped) console.error(`  \xB7 ${path2}`);
+    for (const path3 of result.skipped) console.error(`  \xB7 ${path3}`);
   }
   if (result.failed.length > 0) {
     console.error(`Failed ${result.failed.length}:`);
-    for (const path2 of result.failed) console.error(`  \u2717 ${path2}`);
+    for (const path3 of result.failed) console.error(`  \u2717 ${path3}`);
   }
   return result.failed.length > 0 ? 1 : 0;
 }
 
+// src/http-proxy/discovery-cache.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os from "os";
+
+// src/http-proxy/anthropic-host.ts
+var ANTHROPIC_UPSTREAM_HOST = "api.anthropic.com";
+var RELAY_SENTINEL_HOST = "api.anthropic.com.relay.invalid";
+var RELAY_BASE_URL = `https://${RELAY_SENTINEL_HOST}`;
+
+// src/http-proxy/discovery-cache.ts
+var GATEWAY_DISCOVERY_BASE_URL = RELAY_BASE_URL;
+var CACHE_FILE = "gateway-models.json";
+function cachePath(baseEnv) {
+  const claudeDir = baseEnv["CLAUDE_CONFIG_DIR"]?.trim() || path2.join(os.homedir(), ".claude");
+  return path2.join(claudeDir, "cache", CACHE_FILE);
+}
+function writeGatewayDiscoveryCache(baseEnv, routes) {
+  try {
+    const models = routes.filter((route) => Boolean(route.gatewayAliasId)).map((route) => formatAnthropicModelEntry(
+      route.gatewayAliasId,
+      route.displayName,
+      route.contextWindow
+    ));
+    const file = cachePath(baseEnv);
+    fs2.mkdirSync(path2.dirname(file), { recursive: true });
+    fs2.writeFileSync(
+      file,
+      JSON.stringify({ baseUrl: GATEWAY_DISCOVERY_BASE_URL, fetchedAt: Date.now(), models }),
+      { encoding: "utf8", mode: 384 }
+    );
+  } catch {
+  }
+}
+
 // src/http-proxy/env.ts
 var PROXY_ENV_NAMES = [
   "HTTPS_PROXY",
@@ -11753,6 +11291,8 @@ function buildHttpProxyChildEnv(baseEnv, proxyUrl, caCertPath) {
     if (name === "ANTHROPIC_API_KEY" || name === "ANTHROPIC_AUTH_TOKEN") continue;
     delete env[name];
   }
+  env["ANTHROPIC_BASE_URL"] = RELAY_BASE_URL;
+  env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1";
   return env;
 }
 
@@ -11761,14 +11301,14 @@ import { randomBytes, randomUUID as randomUUID3 } from "crypto";
 import {
   chmodSync,
   existsSync as existsSync13,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readFileSync as readFileSync8,
   readdirSync as readdirSync3,
   rmSync as rmSync6,
   statSync as statSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname5, join as join14, resolve } from "path";
+import { dirname as dirname6, join as join15, resolve } from "path";
 import forge from "node-forge";
 var SESSION_ROOT = "http-proxy-sessions";
 var OWNER_FILE = "owner.pid";
@@ -11788,15 +11328,15 @@ function processIsRunning(pid) {
   }
 }
 function cleanupStaleHttpProxySessions(appHome = getAppHome()) {
-  const root = join14(appHome, SESSION_ROOT);
+  const root = join15(appHome, SESSION_ROOT);
   if (!existsSync13(root)) return;
   const now = Date.now();
   for (const name of readdirSync3(root)) {
-    const sessionDir = join14(root, name);
+    const sessionDir = join15(root, name);
     try {
       const stat = statSync2(sessionDir);
       if (!stat.isDirectory()) continue;
-      const ownerPath = join14(sessionDir, OWNER_FILE);
+      const ownerPath = join15(sessionDir, OWNER_FILE);
       if (!existsSync13(ownerPath)) {
         if (now - stat.mtimeMs > MID_CREATION_GRACE_MS) {
           rmSync6(sessionDir, { recursive: true, force: true });
@@ -11819,13 +11359,13 @@ function cleanupStaleHttpProxySessions(appHome = getAppHome()) {
 }
 function createHttpProxyCertificates(appHome = getAppHome()) {
   cleanupStaleHttpProxySessions(appHome);
-  const root = join14(appHome, SESSION_ROOT);
-  mkdirSync8(root, { recursive: true, mode: 448 });
+  const root = join15(appHome, SESSION_ROOT);
+  mkdirSync9(root, { recursive: true, mode: 448 });
   chmodSync(root, 448);
-  const sessionDir = join14(root, randomUUID3());
-  mkdirSync8(sessionDir, { mode: 448 });
+  const sessionDir = join15(root, randomUUID3());
+  mkdirSync9(sessionDir, { mode: 448 });
   chmodSync(sessionDir, 448);
-  writeFileSync7(join14(sessionDir, OWNER_FILE), `${process.pid}
+  writeFileSync8(join15(sessionDir, OWNER_FILE), `${process.pid}
 `, { mode: 384 });
   try {
     const caKeys = forge.pki.rsa.generateKeyPair(2048);
@@ -11849,19 +11389,19 @@ function createHttpProxyCertificates(appHome = getAppHome()) {
     server.serialNumber = serialNumber();
     server.validity.notBefore = new Date(Date.now() - 6e4);
     server.validity.notAfter = new Date(Date.now() + 48 * 60 * 60 * 1e3);
-    server.setSubject([{ name: "commonName", value: "api.anthropic.com" }]);
+    server.setSubject([{ name: "commonName", value: RELAY_SENTINEL_HOST }]);
     server.setIssuer(ca.subject.attributes);
     server.setExtensions([
       { name: "basicConstraints", cA: false, critical: true },
       { name: "keyUsage", digitalSignature: true, keyEncipherment: true, critical: true },
       { name: "extKeyUsage", serverAuth: true },
-      { name: "subjectAltName", altNames: [{ type: 2, value: "api.anthropic.com" }] },
+      { name: "subjectAltName", altNames: [{ type: 2, value: RELAY_SENTINEL_HOST }] },
       { name: "subjectKeyIdentifier" }
     ]);
     server.sign(caKeys.privateKey, forge.md.sha256.create());
     const caCert = forge.pki.certificateToPem(ca);
-    const caCertPath = join14(sessionDir, "relay-ai-ca.pem");
-    writeFileSync7(caCertPath, caCert, { encoding: "utf8", mode: 384 });
+    const caCertPath = join15(sessionDir, "relay-ai-ca.pem");
+    writeFileSync8(caCertPath, caCert, { encoding: "utf8", mode: 384 });
     chmodSync(caCertPath, 384);
     let cleaned = false;
     const cleanupOnExit = () => {
@@ -11906,8 +11446,8 @@ function createHttpProxyCaBundle(relayCaCertPath, additionalCaCertPath) {
   const relayCa = readFileSync8(relayCaCertPath, "utf8").trimEnd();
   const additionalCa = readFileSync8(additionalCaCertPath, "utf8").trim();
   if (!additionalCa) return relayCaCertPath;
-  const combinedPath = join14(dirname5(relayCaCertPath), "combined-ca.pem");
-  writeFileSync7(
+  const combinedPath = join15(dirname6(relayCaCertPath), "combined-ca.pem");
+  writeFileSync8(
     combinedPath,
     `${relayCa}
 ${additionalCa}
@@ -11928,6 +11468,20 @@ import { URL as URL2 } from "url";
 // src/anthropic-endpoints.ts
 var MESSAGE_PATH = "/v1/messages";
 var COUNT_TOKENS_PATH = "/v1/messages/count_tokens";
+var MODELS_PATH = "/v1/models";
+function anthropicModelsEndpoint(url) {
+  if (!url) return null;
+  try {
+    const pathname = new URL(url, "http://relay.local").pathname;
+    if (pathname === MODELS_PATH || pathname === `${MODELS_PATH}/`) return "list";
+    if (pathname.startsWith(`${MODELS_PATH}/`)) {
+      const id = decodeURIComponent(pathname.slice(MODELS_PATH.length + 1));
+      if (id) return { id };
+    }
+  } catch {
+  }
+  return null;
+}
 function anthropicMessagesEndpoint(url) {
   if (!url) return null;
   try {
@@ -11958,7 +11512,7 @@ function estimateAnthropicInputTokens(body) {
 }
 
 // src/http-proxy/server.ts
-var ANTHROPIC_HOST = "api.anthropic.com";
+var ANTHROPIC_HOST = RELAY_SENTINEL_HOST;
 var MAX_BODY_BYTES = 50 * 1024 * 1024;
 var PROXY_USERNAME = "relay-ai";
 function authorityParts(authority) {
@@ -12032,15 +11586,29 @@ function readRawBody(req) {
     req.once("error", fail);
   });
 }
-function requestHeadersWithoutProxyHeaders(req) {
+function requestHeadersWithoutProxyHeaders(req, hostOverride) {
   const headers = [];
   for (let index = 0; index < req.rawHeaders.length; index += 2) {
     const name = req.rawHeaders[index];
     if (/^proxy-(authorization|connection)$/i.test(name)) continue;
+    if (hostOverride && /^host$/i.test(name)) {
+      headers.push(name, hostOverride);
+      continue;
+    }
     headers.push(name, req.rawHeaders[index + 1] ?? "");
   }
   return headers;
 }
+function restoreBillingCch(headers) {
+  for (let index = 0; index < headers.length; index += 2) {
+    if (!/^x-anthropic-billing-header$/i.test(headers[index])) continue;
+    const value = headers[index + 1] ?? "";
+    if (/(?:^|;)\s*cch=/.test(value)) break;
+    headers[index + 1] = `${value.replace(/;?\s*$/, "")}; cch=00000;`;
+    break;
+  }
+  return headers;
+}
 function copyResponse(upstream, res) {
   res.writeHead(upstream.statusCode ?? 502, upstream.statusMessage, upstream.rawHeaders);
   upstream.once("error", (error) => res.destroy(error));
@@ -12061,7 +11629,7 @@ function forwardRawRequest(req, res, rawBody, origin, rejectUnauthorized) {
       port: origin.port || void 0,
       method: req.method,
       path: req.url,
-      headers: requestHeadersWithoutProxyHeaders(req),
+      headers: restoreBillingCch(requestHeadersWithoutProxyHeaders(req, ANTHROPIC_UPSTREAM_HOST)),
       ...origin.protocol === "https:" ? { rejectUnauthorized } : {}
     }, (upstreamRes) => {
       copyResponse(upstreamRes, res);
@@ -12117,6 +11685,40 @@ function forwardToAdapter(req, res, rawBody, adapter) {
     upstream.end(rawBody);
   });
 }
+function fetchUpstreamModelsList(req, origin, rejectUnauthorized) {
+  return new Promise((resolve2) => {
+    const transport = origin.protocol === "https:" ? https : http2;
+    const rawHeaders = requestHeadersWithoutProxyHeaders(req, ANTHROPIC_UPSTREAM_HOST);
+    const headers = ["accept-encoding", "identity"];
+    for (let i = 0; i < rawHeaders.length; i += 2) {
+      const name = rawHeaders[i];
+      if (/^accept-encoding$/i.test(name)) continue;
+      headers.push(name, rawHeaders[i + 1] ?? "");
+    }
+    const upstream = transport.request({
+      protocol: origin.protocol,
+      hostname: origin.hostname,
+      port: origin.port || void 0,
+      method: "GET",
+      path: req.url,
+      headers,
+      ...origin.protocol === "https:" ? { rejectUnauthorized } : {}
+    }, (upstreamRes) => {
+      const chunks = [];
+      upstreamRes.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+      upstreamRes.once("end", () => {
+        resolve2({
+          statusCode: upstreamRes.statusCode ?? 500,
+          headers: upstreamRes.headers,
+          body: Buffer.concat(chunks)
+        });
+      });
+      upstreamRes.once("error", () => resolve2(null));
+    });
+    upstream.once("error", () => resolve2(null));
+    upstream.end();
+  });
+}
 function forwardPlainHttp(req, res) {
   let target;
   try {
@@ -12155,6 +11757,9 @@ async function startHttpProxy(options) {
   const routesById = /* @__PURE__ */ new Map();
   for (const route of options.routes) {
     for (const id of routeLookupIds(route.aliasId)) routesById.set(id, route);
+    if (route.gatewayAliasId) {
+      for (const id of routeLookupIds(route.gatewayAliasId)) routesById.set(id, route);
+    }
   }
   const anthropicOrigin = new URL2(options.anthropicOrigin ?? "https://api.anthropic.com");
   if (anthropicOrigin.protocol !== "http:" && anthropicOrigin.protocol !== "https:") {
@@ -12189,6 +11794,75 @@ async function startHttpProxy(options) {
       }
       return;
     }
+    const modelsEndpoint = anthropicModelsEndpoint(req.url);
+    if (req.method === "GET" && modelsEndpoint && options.routes.length > 0) {
+      if (modelsEndpoint === "list") {
+        const upstreamResult = await fetchUpstreamModelsList(
+          req,
+          anthropicOrigin,
+          options.anthropicRejectUnauthorized ?? true
+        );
+        const relayEntries = options.routes.filter((r) => Boolean(r.gatewayAliasId)).map((r) => formatAnthropicModelEntry(
+          r.gatewayAliasId,
+          r.displayName,
+          r.contextWindow
+        ));
+        if (upstreamResult && upstreamResult.statusCode === 200) {
+          try {
+            const parsed = JSON.parse(upstreamResult.body.toString("utf8"));
+            if (Array.isArray(parsed.data)) {
+              const existingIds = new Set(parsed.data.map((m) => String(m.id ?? "")));
+              for (const entry of relayEntries) {
+                if (!existingIds.has(entry.id)) {
+                  parsed.data.push(entry);
+                }
+              }
+              const responseBuffer = Buffer.from(JSON.stringify(parsed));
+              const headers = { ...upstreamResult.headers };
+              delete headers["content-length"];
+              delete headers["content-encoding"];
+              headers["content-type"] = "application/json";
+              headers["content-length"] = String(responseBuffer.length);
+              res.writeHead(200, headers);
+              res.end(responseBuffer);
+              return;
+            }
+          } catch {
+          }
+        }
+        const fallbackList = formatAnthropicModelList(
+          options.routes.map((r) => ({
+            id: r.gatewayAliasId ?? r.aliasId,
+            name: r.displayName,
+            contextWindow: r.contextWindow
+          }))
+        );
+        const buffer = Buffer.from(JSON.stringify(fallbackList));
+        res.writeHead(200, {
+          "content-type": "application/json",
+          "content-length": String(buffer.length)
+        });
+        res.end(buffer);
+        return;
+      }
+      if (typeof modelsEndpoint === "object" && modelsEndpoint.id) {
+        const matched = routesById.get(modelsEndpoint.id);
+        if (matched) {
+          const entry = formatAnthropicModelEntry(
+            matched.gatewayAliasId ?? matched.aliasId,
+            matched.displayName,
+            matched.contextWindow
+          );
+          const buffer = Buffer.from(JSON.stringify(entry));
+          res.writeHead(200, {
+            "content-type": "application/json",
+            "content-length": String(buffer.length)
+          });
+          res.end(buffer);
+          return;
+        }
+      }
+    }
     const endpoint = anthropicMessagesEndpoint(req.url);
     if (req.method === "POST" && endpoint) {
       let parsed = null;
@@ -12390,6 +12064,7 @@ async function launchClaudeWithHttpProxy(options, dependencies = defaultDependen
       proxy.handle.proxyUrl,
       proxy.handle.caCertPath
     );
+    writeGatewayDiscoveryCache(options.baseEnv, proxy.loaded.routes);
     const exitCode = await dependencies.launch(
       childEnv,
       proxy.startingModel,
@@ -13763,7 +13438,7 @@ Options:
   --trace    Write debug logs under ~/.relay-ai/logs/`);
       return 0;
     }
-    const { runUiCommand } = await import("./ui-command-3CWMSARO.js");
+    const { runUiCommand } = await import("./ui-command-5VEFZ5GM.js");
     return runUiCommand({ trace: parsed.trace, serverMode: parsed.uiServerMode });
   }
   if (parsed.command === "models") {