@jacobbd/relay-ai 0.2.3 → 0.2.5

package/dist/cli.js

@@ -76,7 +76,7 @@ function classifyModelFormat(modelId, providerNpm) {
   if (lower.startsWith("gemini-")) return "unsupported";
   return "openai";
 }
-var VERSION = "0.2.3";
+var VERSION = "0.2.5";
 
 // src/provider-factory.ts
 var RESPONSES_ONLY_PREFIXES = [
@@ -196,11 +196,15 @@ var OPENAI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh"];
 var GEMINI_EFFORT_LEVELS = ["low", "medium", "high"];
 var MISTRAL_EFFORT_LEVELS = ["high", "off"];
 var XAI_EFFORT_LEVELS = ["none", "low", "medium", "high"];
+var OPENROUTER_EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"];
 var DEEPSEEK_EFFORT_LEVELS = ["high", "max", "off"];
 var EMPTY_REASONING = {
   levels: [],
   defaultLevel: "",
-  supportsSummaries: false
+  supportsSummaries: false,
+  mode: "none",
+  source: "none",
+  confidence: "inferred"
 };
 var EFFORT_DESCRIPTIONS = {
   off: "Turn off extended reasoning",
@@ -257,6 +261,41 @@ function isDeepSeekReasoningModel(modelId) {
   const lower = modelId.toLowerCase();
   return lower === "deepseek-v4-flash" || lower === "deepseek-v4-pro" || lower.startsWith("deepseek-v4-flash-") || lower.startsWith("deepseek-v4-pro-") || lower === "deepseek-reasoner" || lower === "deepseek-chat";
 }
+function hasSupportedParameter(metadata, param) {
+  return (metadata?.supportedParameters ?? []).some((p19) => p19 === param);
+}
+function isOpenRouterRoute(npm, metadata) {
+  return npm === "@openrouter/ai-sdk-provider" || metadata?.providerId === "openrouter" || metadata?.apiBaseUrl?.includes("openrouter.ai") === true;
+}
+function openRouterReasoningCapabilities(metadata) {
+  if (metadata?.supportedParameters && !hasSupportedParameter(metadata, "reasoning")) {
+    return {
+      ...EMPTY_REASONING,
+      source: "provider-metadata",
+      confidence: "documented"
+    };
+  }
+  if (hasSupportedParameter(metadata, "reasoning")) {
+    return {
+      levels: [...OPENROUTER_EFFORT_LEVELS],
+      defaultLevel: "medium",
+      supportsSummaries: false,
+      mode: "controllable",
+      source: "provider-metadata",
+      confidence: "documented",
+      wireFormat: { kind: "openrouter-reasoning" }
+    };
+  }
+  if (metadata?.reasoning) {
+    return {
+      ...EMPTY_REASONING,
+      mode: "internal-only",
+      source: "model-metadata",
+      confidence: "inferred"
+    };
+  }
+  return EMPTY_REASONING;
+}
 function mapCodexEffortToDeepSeek(effort) {
   switch (effort) {
     case "off":
@@ -356,40 +395,81 @@ function mapCodexEffortToGeminiBudget(effort) {
   if (!level) return void 0;
   return GEMINI_25_BUDGETS[level];
 }
-function getReasoningCapabilities(npm, modelId) {
+function getReasoningCapabilities(npm, modelId, metadata) {
   const id = modelId.toLowerCase();
+  if (isOpenRouterRoute(npm, metadata)) {
+    return openRouterReasoningCapabilities(metadata);
+  }
   if (npm === "@ai-sdk/anthropic" || id.startsWith("claude-")) {
-    if (isClaudeReasoningModel(modelId)) {
-      return { levels: [...ANTHROPIC_EFFORT_LEVELS], defaultLevel: "high", supportsSummaries: true };
+    const isClaude = isClaudeReasoningModel(modelId);
+    if (isClaude || metadata?.reasoning) {
+      return {
+        levels: [...ANTHROPIC_EFFORT_LEVELS],
+        defaultLevel: "high",
+        supportsSummaries: true,
+        mode: "controllable",
+        source: isClaude ? "provider-rule" : "model-metadata",
+        confidence: isClaude ? "documented" : "inferred",
+        wireFormat: { kind: "anthropic-thinking" }
+      };
     }
     return EMPTY_REASONING;
   }
   if (npm === "@ai-sdk/openai" || npm === "@ai-sdk/azure") {
-    if (modelPrefersResponsesApi(modelId)) {
+    const prefersResponses = modelPrefersResponsesApi(modelId);
+    if (prefersResponses || metadata?.reasoning) {
       return {
         levels: [...OPENAI_EFFORT_LEVELS],
         defaultLevel: "medium",
-        supportsSummaries: true
+        supportsSummaries: true,
+        mode: "controllable",
+        source: prefersResponses ? "provider-rule" : "model-metadata",
+        confidence: prefersResponses ? "documented" : "inferred",
+        wireFormat: { kind: "openai-reasoning-effort" }
       };
     }
     return EMPTY_REASONING;
   }
   if (npm === "@ai-sdk/google" || id.startsWith("gemini-")) {
     if (isGeminiReasoningModel(modelId)) {
-      return { levels: [...GEMINI_EFFORT_LEVELS], defaultLevel: "medium", supportsSummaries: true };
+      return {
+        levels: [...GEMINI_EFFORT_LEVELS],
+        defaultLevel: "medium",
+        supportsSummaries: true,
+        mode: "controllable",
+        source: "provider-rule",
+        confidence: "documented",
+        wireFormat: { kind: "google-thinking-config" }
+      };
     }
     return EMPTY_REASONING;
   }
   if (npm === "@ai-sdk/mistral") {
     if (isMistralReasoningModel(modelId)) {
-      return { levels: [...MISTRAL_EFFORT_LEVELS], defaultLevel: "high", supportsSummaries: false };
+      return {
+        levels: [...MISTRAL_EFFORT_LEVELS],
+        defaultLevel: "high",
+        supportsSummaries: false,
+        mode: "controllable",
+        source: "provider-rule",
+        confidence: "documented",
+        wireFormat: { kind: "mistral-reasoning-effort" }
+      };
     }
     return EMPTY_REASONING;
   }
   if (npm === "@ai-sdk/xai") {
     if (isXaiReasoningEffortModel(modelId)) {
       const levels = modelPrefersResponsesApi(modelId) ? ["low", "medium", "high", "xhigh"] : [...XAI_EFFORT_LEVELS];
-      return { levels, defaultLevel: "low", supportsSummaries: true };
+      return {
+        levels,
+        defaultLevel: "low",
+        supportsSummaries: true,
+        mode: "controllable",
+        source: "provider-rule",
+        confidence: "documented",
+        wireFormat: { kind: "openai-reasoning-effort" }
+      };
     }
     return EMPTY_REASONING;
   }
@@ -397,7 +477,44 @@ function getReasoningCapabilities(npm, modelId) {
     return {
       levels: [...DEEPSEEK_EFFORT_LEVELS],
       defaultLevel: "high",
-      supportsSummaries: true
+      supportsSummaries: true,
+      mode: "controllable",
+      source: "provider-rule",
+      confidence: "documented",
+      wireFormat: { kind: "deepseek-thinking" }
+    };
+  }
+  if (hasSupportedParameter(metadata, "reasoning_effort")) {
+    return {
+      levels: ["low", "medium", "high", "xhigh"],
+      defaultLevel: "medium",
+      supportsSummaries: false,
+      mode: "controllable",
+      source: "provider-metadata",
+      confidence: "documented",
+      wireFormat: { kind: "openai-reasoning-effort" }
+    };
+  }
+  if (hasSupportedParameter(metadata, "reasoning")) {
+    return {
+      levels: [...OPENROUTER_EFFORT_LEVELS],
+      defaultLevel: "medium",
+      supportsSummaries: false,
+      mode: "controllable",
+      source: "provider-metadata",
+      confidence: "documented",
+      wireFormat: { kind: "openrouter-reasoning" }
+    };
+  }
+  if (metadata?.reasoning) {
+    return {
+      levels: ["low", "medium", "high"],
+      defaultLevel: "medium",
+      supportsSummaries: false,
+      mode: "controllable",
+      source: "model-metadata",
+      confidence: "inferred",
+      wireFormat: { kind: "openai-reasoning-effort" }
     };
   }
   return EMPTY_REASONING;
@@ -408,8 +525,15 @@ function buildCodexReasoningLevels(capabilities) {
     description: EFFORT_DESCRIPTIONS[effort] ?? effort
   }));
 }
-function effortProviderOptions(npm, effort, modelId) {
+function effortProviderOptions(npm, effort, modelId, metadata) {
   if (!effort) return void 0;
+  if (isOpenRouterRoute(npm, metadata)) {
+    const caps = openRouterReasoningCapabilities(metadata);
+    if (caps.mode !== "controllable") return void 0;
+    const allowed = new Set(OPENROUTER_EFFORT_LEVELS);
+    const mapped = allowed.has(effort) ? effort : effort === "max" ? "xhigh" : void 0;
+    return mapped ? { openrouter: { reasoning: { effort: mapped, exclude: false } } } : void 0;
+  }
   if (npm === "@ai-sdk/openai" || npm === "@ai-sdk/azure") {
     if (!modelId || !modelPrefersResponsesApi(modelId)) return void 0;
     const reasoningEffort = mapCodexEffortToOpenAI(effort);
@@ -420,13 +544,14 @@ function effortProviderOptions(npm, effort, modelId) {
     const reasoningEffort = mapCodexEffortToXai(effort);
     return reasoningEffort ? { xai: { reasoningEffort } } : void 0;
   }
-  if (npm === "@ai-sdk/anthropic") {
+  if (npm === "@ai-sdk/anthropic" || npm === VERTEX_ANTHROPIC_NPM) {
+    if (!modelId || !isClaudeReasoningModel(modelId)) return void 0;
     const mapped = mapCodexEffortToAnthropic(effort);
     return mapped ? { anthropic: { thinking: { type: "adaptive", effort: mapped } } } : void 0;
   }
   if (npm === "@ai-sdk/google") {
-    const id2 = modelId ?? "";
-    if (isGemini3Model(id2)) {
+    const id = modelId ?? "";
+    if (isGemini3Model(id)) {
       const thinkingLevel = mapCodexEffortToGeminiLevel(effort);
       return thinkingLevel ? { google: { thinkingConfig: { thinkingLevel, includeThoughts: true } } } : void 0;
     }
@@ -438,9 +563,21 @@ function effortProviderOptions(npm, effort, modelId) {
     const reasoningEffort = effort === "off" || effort === "none" ? "none" : "high";
     return { mistral: { reasoningEffort } };
   }
-  const id = (modelId ?? "").toLowerCase();
-  if (isDeepSeekReasoningModel(id)) {
-    return deepSeekEffortProviderOptions(effort);
+  if (npm === "@ai-sdk/openai-compatible" || npm === "@ai-sdk/openai") {
+    if (!modelId) return void 0;
+    if (isDeepSeekReasoningModel(modelId)) {
+      return deepSeekEffortProviderOptions(effort);
+    }
+    if (hasSupportedParameter(metadata, "reasoning_effort")) {
+      const reasoningEffort = mapCodexEffortToOpenAI(effort);
+      return reasoningEffort ? { openai: { reasoningEffort }, openaiCompatible: { reasoningEffort }, "openai-compatible": { reasoningEffort } } : void 0;
+    }
+    if (hasSupportedParameter(metadata, "reasoning")) {
+      const allowed = new Set(OPENROUTER_EFFORT_LEVELS);
+      const mapped = allowed.has(effort) ? effort : effort === "max" ? "xhigh" : void 0;
+      return mapped ? { openrouter: { reasoning: { effort: mapped, exclude: false } } } : void 0;
+    }
+    return void 0;
   }
   return void 0;
 }
@@ -1576,14 +1713,19 @@ function resolveBaseURL(model, provider) {
 }
 function resolveCodexRoute(provider, model, apiKey) {
   const upstreamModelId2 = model.upstreamModelId || model.id;
+  const inferredNpm = model.modelFormat === "anthropic" ? "@ai-sdk/anthropic" : "@ai-sdk/openai-compatible";
+  const isZenGo = provider.id === "zen" || provider.id === "go";
   const base = {
-    npm: model.npm ?? (model.modelFormat === "anthropic" ? "@ai-sdk/anthropic" : "@ai-sdk/openai-compatible"),
+    npm: isZenGo ? inferredNpm : model.npm ?? inferredNpm,
     baseURL: resolveBaseURL(model, provider),
     upstreamModelId: upstreamModelId2,
     apiKey,
     contextWindow: model.contextWindow,
     modelId: model.id,
-    providerId: provider.id
+    providerId: provider.id,
+    supportedParameters: model.supportedParameters,
+    reasoning: model.reasoning,
+    interleavedReasoningField: model.interleavedReasoningField
   };
   if (provider.id === "openai" && model.modelFormat === "openai") {
     return { tier: "direct", ...base };
@@ -1607,7 +1749,10 @@ function buildCodexProxyRoutesForProvider(provider, apiKey, selectedModelId, age
       apiKey: route.apiKey,
       baseURL: route.baseURL,
       upstreamModelId: route.upstreamModelId,
-      providerId: route.providerId
+      providerId: route.providerId,
+      supportedParameters: route.supportedParameters,
+      reasoning: route.reasoning,
+      interleavedReasoningField: route.interleavedReasoningField
     };
   });
 }
@@ -1665,8 +1810,8 @@ function buildCodexAppRootConfig(spec) {
 // src/codex/catalog.ts
 var DEFAULT_CONTEXT = 128e3;
 var CODEX_NO_REASONING_EFFORT = "none";
-function codexCatalogReasoningFields(npm, wireId) {
-  const reasoning = getReasoningCapabilities(npm, wireId);
+function codexCatalogReasoningFields(npm, wireId, metadata) {
+  const reasoning = getReasoningCapabilities(npm, wireId, metadata);
   if (reasoning.levels.length > 0) {
     return {
       supported_reasoning_levels: buildCodexReasoningLevels(reasoning),
@@ -1677,9 +1822,7 @@ function codexCatalogReasoningFields(npm, wireId) {
   }
   return {
     supported_reasoning_levels: buildCodexReasoningLevels({
-      levels: [CODEX_NO_REASONING_EFFORT],
-      defaultLevel: CODEX_NO_REASONING_EFFORT,
-      supportsSummaries: false
+      levels: [CODEX_NO_REASONING_EFFORT]
     }),
     default_reasoning_level: CODEX_NO_REASONING_EFFORT,
     supports_reasoning_summaries: false,
@@ -1709,7 +1852,12 @@ function catalogEntryFromModel(model, providerName, priority, appCatalog = false
   const context = model.contextWindow ?? DEFAULT_CONTEXT;
   const label = formatCodexModelLabel(model);
   const wireId = model.upstreamModelId ?? model.id;
-  const reasoningFields = codexCatalogReasoningFields(model.npm ?? "", wireId);
+  const reasoningFields = codexCatalogReasoningFields(model.npm ?? "", wireId, {
+    apiBaseUrl: model.apiBaseUrl,
+    supportedParameters: model.supportedParameters,
+    reasoning: model.reasoning,
+    interleavedReasoningField: model.interleavedReasoningField
+  });
   return {
     slug,
     display_name: label,
@@ -2984,7 +3132,10 @@ function normalizeProviders(raw, opts) {
         npm: model.api?.npm,
         apiBaseUrl: model.api?.url,
         cost: model.cost,
-        contextWindow: resolveContextWindow(model.id, model.limit?.context)
+        contextWindow: resolveContextWindow(model.id, model.limit?.context),
+        supportedParameters: model.supportedParameters ?? model.supported_parameters,
+        reasoning: model.reasoning,
+        interleavedReasoningField: model.interleaved?.field
       });
     }
     if (models.length === 0) continue;
@@ -3123,7 +3274,10 @@ function modelToCached(model) {
     cost: model.cost,
     modelFormat: model.modelFormat,
     npm: model.npm,
-    apiUrl: model.apiBaseUrl
+    apiUrl: model.apiBaseUrl,
+    supportedParameters: model.supportedParameters,
+    reasoning: model.reasoning,
+    interleavedReasoningField: model.interleavedReasoningField
   };
 }
 function localProviderToRegistry(provider, opts) {
@@ -3293,7 +3447,8 @@ function parseModelList(body, npm) {
       brand: deriveBrand(family),
       contextWindow: resolveContextWindow(id),
       modelFormat: format,
-      npm
+      npm,
+      supportedParameters: Array.isArray(row.supported_parameters) ? row.supported_parameters : void 0
     });
   }
   return models;
@@ -3818,6 +3973,24 @@ var PROVIDER_TEMPLATES = [
     supported: false,
     unsupportedReason: "Uses gcloud Application Default Credentials \u2014 not supported via API key import."
   },
+  {
+    id: "zen",
+    name: "OpenCode Zen",
+    authType: "api",
+    npm: "@ai-sdk/openai-compatible",
+    signupUrl: "https://opencode.ai/auth",
+    modelSource: "zen-go-api",
+    supported: true
+  },
+  {
+    id: "go",
+    name: "OpenCode Go",
+    authType: "api",
+    npm: "@ai-sdk/openai-compatible",
+    signupUrl: "https://opencode.ai/auth",
+    modelSource: "zen-go-api",
+    supported: true
+  },
   // OAuth-gated subscription providers — use relay-ai providers auth <id> to sign in
   {
     id: "github-copilot",
@@ -3847,14 +4020,6 @@ function filterTemplates(templates, query) {
     (t) => t.id.toLowerCase().includes(q) || t.name.toLowerCase().includes(q) || t.npm.toLowerCase().includes(q)
   );
 }
-function matchesOpenCodeCloudSearch(query) {
-  const q = query.trim().toLowerCase();
-  if (!q) return false;
-  if (q.includes("opencode") || q.includes("open code")) return true;
-  if (q === "zen" || q === "go") return true;
-  if (q.includes("zen ") || q.startsWith("zen/") || q.endsWith(" zen")) return true;
-  return false;
-}
 
 // src/registry/resolve-template.ts
 var TEMPLATE_ID_ALIASES = {
@@ -3955,8 +4120,20 @@ async function validateImportKey(lp, entry) {
     }
     return reject("invalid-key", "No API base URL \u2014 cannot verify key.");
   }
+  let safeBaseUrl = baseUrl;
+  const configuredUrl = entry.api.url?.trim();
+  const templateDefault = catalogTemplate?.defaultBaseUrl?.trim();
+  if (configuredUrl && configuredUrl !== templateDefault) {
+    const urlCheck = await validateCustomEndpointUrl(baseUrl, {
+      allowInsecureLocal: catalogTemplate?.apiKeyOptional === true
+    });
+    if (!urlCheck.ok || !urlCheck.normalizedUrl) {
+      return reject("invalid-key", `${urlCheck.error ?? "Invalid API base URL."} ${urlCheck.hint ?? ""}`.trim());
+    }
+    safeBaseUrl = urlCheck.normalizedUrl;
+  }
   if (npm === "@ai-sdk/anthropic") {
-    const result2 = await fetchAnthropicModels(baseUrl, key);
+    const result2 = await fetchAnthropicModels(safeBaseUrl, key);
     if (result2.error) {
       return reject(
         placeholder ? "placeholder-key" : "invalid-key",
@@ -3965,8 +4142,8 @@ async function validateImportKey(lp, entry) {
     }
     return { canImport: true };
   }
-  const template = catalogTemplate ?? syntheticTemplate(entry, baseUrl);
-  const result = await fetchTemplateModels(template, key, baseUrl);
+  const template = catalogTemplate ?? syntheticTemplate(entry, safeBaseUrl);
+  const result = await fetchTemplateModels(template, key, safeBaseUrl);
   if (result.error) {
     return reject(
       placeholder ? "placeholder-key" : "invalid-key",
@@ -4076,6 +4253,11 @@ async function importFromOpencode(options = {}) {
         continue;
       }
     }
+    const saved = isOAuth ? await saveOAuthKey(lp.id, oauth) : await saveProviderKey(lp);
+    if (!saved) {
+      skipped.push({ id: lp.id, name: lp.name, reason: "credential-save-failed" });
+      continue;
+    }
     if (existingIdx >= 0) {
       registry.providers[existingIdx] = { ...entry, addedAt: registry.providers[existingIdx].addedAt };
     } else {
@@ -4083,11 +4265,8 @@ async function importFromOpencode(options = {}) {
     }
     imported.push(entry);
     importedIds.add(lp.id);
-    const saved = isOAuth ? await saveOAuthKey(lp.id, oauth) : await saveProviderKey(lp);
-    if (saved) {
-      keysSaved += 1;
-      if (isOAuth) oauthImported += 1;
-    }
+    keysSaved += 1;
+    if (isOAuth) oauthImported += 1;
   }
   const alreadyReportedIds = new Set(skipped.map((s) => s.id));
   const registryProviderIds = new Set(registry.providers.map((p19) => p19.id));
@@ -4588,10 +4767,13 @@ function upstreamModelId(model) {
   const id = model.upstreamModelId ?? model.id;
   return id.replace(/\[1m\]$/i, "");
 }
+function isOpenAIChatCompletionsModel(model) {
+  return model.modelFormat === "openai" && (!!model.completionsUrl || model.sourceBackend === "zen" || model.sourceBackend === "go");
+}
 function formatOpenAIModels(models) {
   return {
     object: "list",
-    data: models.map((model) => ({
+    data: models.filter(isOpenAIChatCompletionsModel).map((model) => ({
       id: model.id,
       object: "model",
       created: CREATED_AT_UNIX,
@@ -4623,20 +4805,24 @@ function extractBearerToken(value) {
 }
 
 // src/upstream-forward.ts
-function anthropicUpstreamHeaders(apiKey, stream = false) {
+function anthropicUpstreamHeaders(apiKey, stream = false, inboundBeta) {
   const key = sanitizeCredential(apiKey) ?? apiKey.trim();
-  return {
+  const headers = {
     "Content-Type": "application/json",
     "anthropic-version": "2023-06-01",
     Authorization: `Bearer ${key}`,
     "x-api-key": key,
     ...stream ? { Accept: "text/event-stream" } : {}
   };
+  if (inboundBeta) {
+    headers["anthropic-beta"] = inboundBeta;
+  }
+  return headers;
 }
-async function postJsonUpstream(url, body, apiKey) {
+async function postJsonUpstream(url, body, apiKey, inboundBeta) {
   const response = await fetch(url, {
     method: "POST",
-    headers: anthropicUpstreamHeaders(apiKey, false),
+    headers: anthropicUpstreamHeaders(apiKey, false, inboundBeta),
     body: JSON.stringify(body)
   });
   const text5 = await response.text();
@@ -4656,12 +4842,12 @@ var UpstreamUnreachableError = class extends Error {
     this.name = "UpstreamUnreachableError";
   }
 };
-async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWantsStream) {
+async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWantsStream, inboundBeta) {
   let upstreamRes;
   try {
     upstreamRes = await fetch(messagesUrl, {
       method: "POST",
-      headers: anthropicUpstreamHeaders(apiKey, clientWantsStream),
+      headers: anthropicUpstreamHeaders(apiKey, clientWantsStream, inboundBeta),
       body: JSON.stringify(body)
     });
   } catch (err) {
@@ -4687,20 +4873,19 @@ async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWant
     res.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "Upstream returned empty response body" } }));
     return;
   }
-  let json;
+  const text5 = await upstreamRes.text();
   try {
-    json = await upstreamRes.json();
+    JSON.parse(text5);
   } catch {
     res.writeHead(502, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "Upstream response was not valid JSON" } }));
     return;
   }
-  const payload = JSON.stringify(json);
   res.writeHead(200, {
     "Content-Type": "application/json",
-    "Content-Length": Buffer.byteLength(payload).toString()
+    "Content-Length": Buffer.byteLength(text5).toString()
   });
-  res.end(payload);
+  res.end(text5);
 }
 
 // src/sdk-adapter.ts
@@ -4717,7 +4902,7 @@ function silenceSdkWarnings() {
   sdkWarningsSilenced = true;
   globalThis.AI_SDK_LOG_WARNINGS = false;
 }
-var TOOL_USE_SIG_SEP = "::ts::";
+var TOOL_USE_SIG_SEP = "__ts__";
 function parseToolArguments(value) {
   if (value === null || value === void 0) return {};
   if (typeof value === "object" && !Array.isArray(value)) return value;
@@ -4740,15 +4925,26 @@ data: ${JSON.stringify(data)}
 `;
 }
 function splitToolUseId(id) {
-  const sep = id.lastIndexOf(TOOL_USE_SIG_SEP);
-  if (sep === -1) return { rawId: id };
-  return {
-    rawId: id.slice(0, sep),
-    thoughtSignature: id.slice(sep + TOOL_USE_SIG_SEP.length)
-  };
+  let sep = id.lastIndexOf(TOOL_USE_SIG_SEP);
+  if (sep !== -1) {
+    return {
+      rawId: id.slice(0, sep),
+      thoughtSignature: Buffer.from(id.slice(sep + TOOL_USE_SIG_SEP.length), "base64url").toString("utf8")
+    };
+  }
+  sep = id.lastIndexOf("::ts::");
+  if (sep !== -1) {
+    return {
+      rawId: id.slice(0, sep),
+      thoughtSignature: id.slice(sep + 6)
+    };
+  }
+  return { rawId: id };
 }
 function encodeToolUseId(rawId, thoughtSignature) {
-  return thoughtSignature ? `${rawId}${TOOL_USE_SIG_SEP}${thoughtSignature}` : rawId;
+  if (!thoughtSignature) return rawId;
+  const encoded = Buffer.from(thoughtSignature, "utf8").toString("base64url");
+  return `${rawId}${TOOL_USE_SIG_SEP}${encoded}`;
 }
 function serializeToolResultContent(content) {
   return typeof content === "string" ? content : JSON.stringify(content);
@@ -4950,7 +5146,7 @@ function translateRequest(body, npm, options) {
   const effort = anthropicEffortFromRequest(body) ?? options?.defaultEffort;
   const providerOptions = deepMergeProviderOptions(
     thinkingProviderOptions(npm),
-    effortProviderOptions(npm, effort, body.model)
+    effortProviderOptions(npm, effort, body.model, options?.reasoningMetadata)
   );
   return {
     system,
@@ -5133,7 +5329,7 @@ async function generateAnthropicResponse(model, params, modelId) {
       ...r.text ? [{ type: "text", text: r.text }] : [],
       ...r.toolCalls.map((tc) => ({
         type: "tool_use",
-        id: tc.toolCallId,
+        id: encodeToolUseId(tc.toolCallId, grabRoundTripSignature(tc)),
         name: tc.toolName,
         input: tc.input
       }))
@@ -5259,11 +5455,13 @@ function startProxyCatalog(routes, defaultAliasId, debug = false) {
         return;
       }
       if (route.modelFormat === "anthropic") {
+        const betaHeaderRaw = req.headers["anthropic-beta"];
+        const inboundBeta = Array.isArray(betaHeaderRaw) ? betaHeaderRaw.join(",") : betaHeaderRaw;
         const forwardBody = { ...anthropicBody, model: route.realModelId };
         const targetUrl = `${upstreamUrl}/v1/messages`;
         plog(() => `anthropic-passthrough: model=${route.realModelId}, stream=${clientWantsStream}`);
         try {
-          await relayAnthropicMessages(res, targetUrl, forwardBody, apiKey, clientWantsStream);
+          await relayAnthropicMessages(res, targetUrl, forwardBody, apiKey, clientWantsStream, inboundBeta);
         } catch (err) {
           const message = err instanceof UpstreamUnreachableError ? err.message : String(err);
           plog(() => `anthropic-passthrough error: ${message}`);
@@ -5272,7 +5470,15 @@ function startProxyCatalog(routes, defaultAliasId, debug = false) {
         return;
       }
       if (isSdkMigratedNpm(route.npm)) {
-        const params = translateRequest(anthropicBody, route.npm);
+        const params = translateRequest(anthropicBody, route.npm, {
+          reasoningMetadata: {
+            providerId: route.providerId,
+            apiBaseUrl: route.baseURL,
+            supportedParameters: route.supportedParameters,
+            reasoning: route.reasoning,
+            interleavedReasoningField: route.interleavedReasoningField
+          }
+        });
         plog(
           () => `sdk: npm=${route.npm} model=${route.realModelId}, stream=${clientWantsStream}, tools=${anthropicBody.tools?.length ?? 0}, msgs=${params.messages.length}`
         );
@@ -5349,7 +5555,11 @@ function startProxy(completionsUrl, modelId, debug = false, contextWindow, sdk)
     modelFormat: "openai",
     contextWindow,
     npm: sdk?.npm,
-    baseURL: sdk?.baseURL
+    baseURL: sdk?.baseURL,
+    providerId: sdk?.providerId,
+    supportedParameters: sdk?.supportedParameters,
+    reasoning: sdk?.reasoning,
+    interleavedReasoningField: sdk?.interleavedReasoningField
   }], clientModelId, debug);
 }
 
@@ -5366,7 +5576,11 @@ function localModelToRoute(lp, model) {
     modelFormat: model.modelFormat,
     contextWindow: model.contextWindow,
     npm: model.npm,
-    baseURL: model.apiBaseUrl
+    baseURL: model.apiBaseUrl,
+    providerId: lp.id,
+    supportedParameters: model.supportedParameters,
+    reasoning: model.reasoning,
+    interleavedReasoningField: model.interleavedReasoningField
   };
 }
 function zenGoModelToRoute(model, apiKey) {
@@ -5384,7 +5598,8 @@ function zenGoModelToRoute(model, apiKey) {
     // openai-format Zen/Go models route through the SDK (openai-compatible);
     // anthropic models stay direct passthrough (no npm).
     npm: isAnthropic ? void 0 : "@ai-sdk/openai-compatible",
-    baseURL: isAnthropic ? void 0 : `${backend.baseUrl}/v1`
+    baseURL: isAnthropic ? void 0 : `${backend.baseUrl}/v1`,
+    providerId: model.sourceBackend
   };
 }
 function makeRouteResolver(localProviders, zenModels, goModels, zenGoApiKey) {
@@ -5554,6 +5769,7 @@ function cachedModelToLocal(cached, provider) {
   const apiUrl = cached.apiUrl ?? provider.api.url ?? "";
   const endpoint = resolveEndpoint(npm, apiUrl);
   if (endpoint === null) return null;
+  const modelsDev = findModelsDevModel(provider.id, cached.id);
   const { id, upstreamModelId: upstreamModelId2 } = normalizeGoogleModelId(cached.id, npm);
   const normalizedUpstream = normalizeGoogleModelId(cached.upstreamModelId ?? cached.id, npm).upstreamModelId;
   const family = npm === "@ai-sdk/google" ? id.split(/[-/:]/)[0] ?? id : cached.family ?? "";
@@ -5569,7 +5785,10 @@ function cachedModelToLocal(cached, provider) {
     npm: npm || void 0,
     apiBaseUrl: apiUrl || void 0,
     cost: cached.cost,
-    contextWindow: cached.contextWindow ?? resolveContextWindow(id)
+    contextWindow: cached.contextWindow ?? resolveContextWindow(id),
+    supportedParameters: cached.supportedParameters,
+    reasoning: cached.reasoning ?? modelsDev?.reasoning,
+    interleavedReasoningField: cached.interleavedReasoningField ?? modelsDev?.interleaved?.field
   };
 }
 function materializeOne(provider, resolveCredential, agent) {
@@ -5770,7 +5989,10 @@ function localProvidersToServerModels(localProviders) {
       npm: model.modelFormat === "openai" ? model.npm || "@ai-sdk/openai-compatible" : model.npm,
       apiBaseUrl: model.apiBaseUrl,
       apiKey: provider.apiKey,
-      contextWindow: model.contextWindow
+      contextWindow: model.contextWindow,
+      supportedParameters: model.supportedParameters,
+      reasoning: model.reasoning,
+      interleavedReasoningField: model.interleavedReasoningField
     }))
   );
 }
@@ -5893,11 +6115,18 @@ async function askSaveServerPassword() {
 
 // src/server/router.ts
 import { createServer as createServer2 } from "http";
+function makeServerLog(debugLogPath) {
+  if (!debugLogPath) return () => {
+  };
+  resetTraceLog(debugLogPath);
+  return (msg) => writeSecureLogLine(debugLogPath, typeof msg === "function" ? msg() : msg);
+}
 async function startServer(options) {
   silenceSdkWarnings();
   const languageModelCache = /* @__PURE__ */ new Map();
+  const plog = makeServerLog(options.debugLogPath);
   const server = createServer2((req, res) => {
-    void routeRequest(req, res, options, languageModelCache);
+    void routeRequest(req, res, options, languageModelCache, plog);
   });
   await new Promise((resolve, reject2) => {
     server.once("error", reject2);
@@ -5920,9 +6149,10 @@ async function startServer(options) {
     })
   };
 }
-async function routeRequest(req, res, options, modelCache) {
+async function routeRequest(req, res, options, modelCache, plog) {
   try {
     const pathname = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`).pathname;
+    plog(`${req.method} ${pathname}`);
     if (req.method === "GET" && pathname === "/health") {
       sendJson(res, 200, { ok: true });
       return;
@@ -5944,7 +6174,7 @@ async function routeRequest(req, res, options, modelCache) {
       return;
     }
     if (req.method === "POST" && pathname === "/anthropic/v1/messages") {
-      await handleAnthropicMessages(req, res, options, modelCache);
+      await handleAnthropicMessages(req, res, options, modelCache, plog);
       return;
     }
     if (req.method === "POST" && pathname === "/openai/v1/chat/completions") {
@@ -5956,14 +6186,18 @@ async function routeRequest(req, res, options, modelCache) {
     sendJson(res, 500, { error: { message: err instanceof Error ? err.message : String(err) } });
   }
 }
-async function handleAnthropicMessages(req, res, options, modelCache) {
+async function handleAnthropicMessages(req, res, options, modelCache, plog) {
   const body = await readJson(req);
   if (!body) {
     sendJson(res, 400, { error: { message: "Invalid JSON body" } });
     return;
   }
   const model = lookupModel(res, options.catalog, body.model);
-  if (!model) return;
+  if (!model) {
+    plog(`model not found: ${body.model}`);
+    return;
+  }
+  plog(() => `anthropic-messages model=${body.model} format=${model.modelFormat} npm=${model.npm ?? "none"} stream=${body.stream}`);
   if (model.modelFormat === "anthropic") {
     if (model.baseUrl && !/^https?:\/\//i.test(model.baseUrl)) {
       sendJson(res, 400, { error: { message: `Invalid provider baseUrl: must be http:// or https://` } });
@@ -5971,7 +6205,10 @@ async function handleAnthropicMessages(req, res, options, modelCache) {
     }
     const messagesUrl = model.baseUrl ? `${model.baseUrl}/v1/messages` : `${backendFor(options, model).baseUrl}/v1/messages`;
     const apiKey = model.apiKey ?? options.apiKey;
-    await forwardJson(res, messagesUrl, { ...body, model: upstreamModelId(model) }, apiKey);
+    const betaHeaderRaw = req.headers["anthropic-beta"];
+    const inboundBeta = Array.isArray(betaHeaderRaw) ? betaHeaderRaw.join(",") : betaHeaderRaw;
+    plog(() => `anthropic-passthrough \u2192 ${messagesUrl}`);
+    await forwardJson(res, messagesUrl, { ...body, model: upstreamModelId(model) }, apiKey, inboundBeta);
     return;
   }
   if (model.modelFormat === "openai") {
@@ -5980,22 +6217,32 @@ async function handleAnthropicMessages(req, res, options, modelCache) {
       return;
     }
     const apiKey = model.apiKey ?? options.apiKey;
-    let languageModel = modelCache.get(model.id);
+    const cacheKey = sdkModelCacheKey(model);
+    let languageModel = modelCache.get(cacheKey);
     if (!languageModel) {
       languageModel = await createLanguageModel({
         npm: model.npm,
         modelId: upstreamModelId(model),
         apiKey,
         baseURL: model.apiBaseUrl,
-        providerId: model.sourceBackend,
+        providerId: model.providerId ?? model.sourceBackend,
         vertex: options.vertex
       });
-      modelCache.set(model.id, languageModel);
+      modelCache.set(cacheKey, languageModel);
     }
     const params = translateRequest(body, model.npm, {
-      defaultEffort: anthropicEffortFromRequest(body) ? void 0 : model.defaultEffort
+      defaultEffort: anthropicEffortFromRequest(body) ? void 0 : model.defaultEffort,
+      reasoningMetadata: {
+        providerId: model.providerId,
+        apiBaseUrl: model.apiBaseUrl,
+        supportedParameters: model.supportedParameters,
+        reasoning: model.reasoning,
+        interleavedReasoningField: model.interleavedReasoningField
+      }
     });
     const clientWantsStream = Boolean(body.stream);
+    const responseModelId = options.gateway?.maskGatewayIds ? gatewayDisplayName(model, options.gateway) : typeof body.model === "string" ? body.model : model.id;
+    plog(() => `sdk npm=${model.npm} upstream=${upstreamModelId(model)} responseModel=${responseModelId} stream=${clientWantsStream}`);
     try {
       if (clientWantsStream) {
         res.writeHead(200, {
@@ -6003,12 +6250,10 @@ async function handleAnthropicMessages(req, res, options, modelCache) {
           "Cache-Control": "no-cache",
           "Connection": "keep-alive"
         });
-        const clientModel = typeof body.model === "string" ? body.model : model.id;
-        await streamAnthropicResponse(languageModel, params, clientModel, (chunk) => res.write(chunk));
+        await streamAnthropicResponse(languageModel, params, responseModelId, (chunk) => res.write(chunk));
         res.end();
       } else {
-        const clientModel = typeof body.model === "string" ? body.model : model.id;
-        const anthropicResponse = await generateAnthropicResponse(languageModel, params, clientModel);
+        const anthropicResponse = await generateAnthropicResponse(languageModel, params, responseModelId);
         sendJson(res, 200, anthropicResponse);
       }
     } catch (err) {
@@ -6029,6 +6274,14 @@ async function handleOpenAIChatCompletions(req, res, options) {
   const model = lookupModel(res, options.catalog, body.model);
   if (!model) return;
   if (model.modelFormat === "openai") {
+    if (!isOpenAIChatCompletionsModel(model)) {
+      sendJson(res, 400, {
+        error: {
+          message: `OpenAI chat completions are not available for model: ${model.id}. Use /anthropic/v1/messages.`
+        }
+      });
+      return;
+    }
     if (model.completionsUrl && !/^https?:\/\//i.test(model.completionsUrl)) {
       sendJson(res, 400, { error: { message: `Invalid provider completionsUrl: must be http:// or https://` } });
       return;
@@ -6064,15 +6317,22 @@ function backendFor(options, model) {
   if (model.sourceBackend === "go") return options.backends.go;
   throw new Error(`Provider ${model.sourceBackend} is not a cloud backend \u2014 model must set baseUrl/completionsUrl`);
 }
-async function forwardJson(res, url, body, apiKey) {
-  const upstream = await postJsonUpstream(url, body, apiKey);
+function sdkModelCacheKey(model) {
+  return [
+    model.providerId ?? model.sourceBackend,
+    model.id,
+    upstreamModelId(model),
+    model.npm ?? "",
+    model.apiBaseUrl ?? ""
+  ].join("");
+}
+async function forwardJson(res, url, body, apiKey, inboundBeta) {
+  const upstream = await postJsonUpstream(url, body, apiKey, inboundBeta);
   sendJson(res, upstream.status, upstream.body);
 }
 async function readJson(req) {
   try {
-    const chunks = [];
-    for await (const chunk of req) chunks.push(Buffer.from(chunk));
-    const raw = Buffer.concat(chunks).toString();
+    const raw = await readBody(req);
     return raw ? JSON.parse(raw) : {};
   } catch {
     return null;
@@ -6228,7 +6488,9 @@ function resolveVertexLocation(env = process.env) {
 function defaultAdcCredentialsPath(home = homedir7()) {
   return join10(home, ".config", "gcloud", "application_default_credentials.json");
 }
-function hasApplicationDefaultCredentials(home = homedir7(), adcPath = defaultAdcCredentialsPath(home)) {
+function hasApplicationDefaultCredentials(home = homedir7(), adcPath = defaultAdcCredentialsPath(home), env = process.env) {
+  const explicitPath = env["GOOGLE_APPLICATION_CREDENTIALS"]?.trim();
+  if (explicitPath && existsSync10(explicitPath)) return true;
   return existsSync10(adcPath);
 }
 function loadVertexModelEntries(env = process.env) {
@@ -6259,19 +6521,23 @@ function buildVertexRuntimeConfig(env = process.env) {
   };
 }
 function vertexModelsToServerModels(config) {
-  return config.models.map((model) => ({
-    id: model.id,
-    name: model.display_name,
-    isFree: false,
-    brand: "Anthropic",
-    sourceBackend: "vertex",
-    modelFormat: "openai",
-    upstreamModelId: model.upstream_id ?? model.id,
-    npm: VERTEX_ANTHROPIC_NPM,
-    providerLabel: "Vertex AI",
-    providerId: "vertex",
-    contextWindow: resolveContextWindow(model.id)
-  }));
+  return config.models.map((model) => {
+    const caps = getReasoningCapabilities(VERTEX_ANTHROPIC_NPM, model.upstream_id ?? model.id);
+    return {
+      id: model.id,
+      name: model.display_name,
+      isFree: false,
+      brand: "Anthropic",
+      sourceBackend: "vertex",
+      modelFormat: "openai",
+      upstreamModelId: model.upstream_id ?? model.id,
+      npm: VERTEX_ANTHROPIC_NPM,
+      providerLabel: "Vertex AI",
+      providerId: "vertex",
+      contextWindow: resolveContextWindow(model.id),
+      ...caps.defaultLevel ? { defaultEffort: caps.defaultLevel } : {}
+    };
+  });
 }
 function vertexClientModelLookupCandidates(modelId) {
   const candidates = [modelId];
@@ -6388,7 +6654,13 @@ async function loadServerModels() {
 }
 function enrichServerModelReasoning(model) {
   if (!model.npm || model.modelFormat !== "openai") return model;
-  const caps = getReasoningCapabilities(model.npm, upstreamModelId(model));
+  const caps = getReasoningCapabilities(model.npm, upstreamModelId(model), {
+    providerId: model.providerId,
+    apiBaseUrl: model.apiBaseUrl,
+    supportedParameters: model.supportedParameters,
+    reasoning: model.reasoning,
+    interleavedReasoningField: model.interleavedReasoningField
+  });
   if (!caps.defaultLevel) return model;
   return { ...model, defaultEffort: caps.defaultLevel };
 }
@@ -6974,6 +7246,71 @@ async function pickGlobalFavoriteModel(providers, favorites) {
   }
 }
 
+// src/favorites-resolver.ts
+var ZEN_GO_PROVIDER_NAME = {
+  zen: "OpenCode Zen",
+  go: "OpenCode Go"
+};
+function resolveFavorite(fav, ctx) {
+  if (fav.providerId === "zen" || fav.providerId === "go") {
+    if (!ctx.zenGoApiKey) return void 0;
+    const models = fav.providerId === "zen" ? ctx.zenModels : ctx.goModels;
+    const model = models?.find((m) => m.id === fav.modelId);
+    if (!model) return void 0;
+    return {
+      providerId: fav.providerId,
+      providerName: ZEN_GO_PROVIDER_NAME[fav.providerId],
+      model,
+      apiKey: ctx.zenGoApiKey,
+      sourceBackend: fav.providerId
+    };
+  }
+  if (ctx.findLocalModel) {
+    const found = ctx.findLocalModel(fav.providerId, fav.modelId);
+    if (!found) return void 0;
+    if (ctx.agent && shouldHideModel({ providerId: fav.providerId, modelId: fav.modelId, agent: ctx.agent })) {
+      return void 0;
+    }
+    return {
+      providerId: fav.providerId,
+      providerName: found.provider.name,
+      model: found.model,
+      apiKey: found.provider.apiKey
+    };
+  }
+  return void 0;
+}
+function buildFavoritesList(starting, favorites, ctx, max = 20) {
+  const droppedFavorites = [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  if (starting) {
+    seen.add(`${starting.providerId}::${starting.model.id}`);
+    out.push(starting);
+  }
+  for (const fav of favorites) {
+    if (out.length >= max) break;
+    const key = `${fav.providerId}::${fav.modelId}`;
+    if (seen.has(key)) continue;
+    const resolved = resolveFavorite(fav, ctx);
+    if (!resolved) {
+      droppedFavorites.push(fav);
+      continue;
+    }
+    seen.add(key);
+    out.push(resolved);
+  }
+  return { resolved: out, droppedFavorites };
+}
+function resolveFirstAvailableFavorite(favorites, providers) {
+  for (const fav of favorites) {
+    const provider = providers.find((lp) => lp.id === fav.providerId);
+    const model = provider?.models.find((m) => m.id === fav.modelId);
+    if (provider && model) return { provider, model };
+  }
+  return void 0;
+}
+
 // src/providers-command.ts
 import pc10 from "picocolors";
 import * as p10 from "@clack/prompts";
@@ -7136,18 +7473,35 @@ function modelInfoToCached(m, npm, apiUrl) {
 async function refreshZenGoProvider(provider) {
   const backendId = provider.id === "go" || provider.templateId === "go" ? "go" : "zen";
   const result = await getModels(BACKENDS[backendId]);
-  return result.models.filter((m) => m.modelFormat !== "unsupported").map((m) => modelInfoToCached(m, "@ai-sdk/openai-compatible", `${BACKENDS[backendId].baseUrl}/v1`));
+  return result.models.filter((m) => m.modelFormat !== "unsupported").map((m) => {
+    const isAnthropic = m.modelFormat === "anthropic";
+    const npm = isAnthropic ? "@ai-sdk/anthropic" : "@ai-sdk/openai-compatible";
+    const apiUrl = isAnthropic ? BACKENDS[backendId].baseUrl : `${BACKENDS[backendId].baseUrl}/v1`;
+    return modelInfoToCached(m, npm, apiUrl);
+  });
 }
 async function refreshApiListProvider(provider, apiKey) {
   const npm = provider.api.npm ?? "@ai-sdk/openai-compatible";
   const catalogTemplate = resolveProviderTemplate(provider);
   const baseUrl = effectiveProviderBaseUrl(provider, catalogTemplate);
-  const template = catalogTemplate ?? syntheticTemplate(provider, baseUrl);
   if (!baseUrl) {
     return { models: [], error: "Provider has no API base URL configured." };
   }
+  let safeBaseUrl = baseUrl;
+  const configuredUrl = provider.api.url?.trim();
+  const templateDefault = catalogTemplate?.defaultBaseUrl?.trim();
+  if (configuredUrl && configuredUrl !== templateDefault) {
+    const urlCheck = await validateCustomEndpointUrl(baseUrl, {
+      allowInsecureLocal: catalogTemplate?.apiKeyOptional === true
+    });
+    if (!urlCheck.ok || !urlCheck.normalizedUrl) {
+      return { models: [], error: `${urlCheck.error ?? "Invalid API base URL."} ${urlCheck.hint ?? ""}`.trim() };
+    }
+    safeBaseUrl = urlCheck.normalizedUrl;
+  }
+  const template = catalogTemplate ?? syntheticTemplate(provider, safeBaseUrl);
   if (npm === "@ai-sdk/anthropic") {
-    const fetched2 = await fetchAnthropicModels(baseUrl, apiKey);
+    const fetched2 = await fetchAnthropicModels(safeBaseUrl, apiKey);
     if (fetched2.error || fetched2.models.length === 0) {
       return { models: [], error: fetched2.error ?? "No models returned.", baseUrl: fetched2.baseUrl };
     }
@@ -7156,7 +7510,7 @@ async function refreshApiListProvider(provider, apiKey) {
       baseUrl: fetched2.baseUrl
     };
   }
-  const fetched = await fetchTemplateModels(template, apiKey, baseUrl);
+  const fetched = await fetchTemplateModels(template, apiKey, safeBaseUrl);
   if (fetched.error || fetched.models.length === 0) {
     return { models: [], error: fetched.error ?? "No models returned." };
   }
@@ -7206,7 +7560,10 @@ async function refreshProviderModels(providerId, apiKey, registry = loadRegistry
     if (source === "zen-go-api") {
       models = await refreshZenGoProvider(provider);
     } else {
-      if (isLikelyPlaceholderKey(apiKey)) {
+      const template = resolveProviderTemplate(provider);
+      const keyOptional = template?.apiKeyOptional === true;
+      const effectiveKey = keyOptional && isLikelyPlaceholderKey(apiKey) ? "" : apiKey;
+      if (!keyOptional && isLikelyPlaceholderKey(effectiveKey)) {
         if (cachedModelCount(provider) > 0) {
           return skipWithCachedModels(
             provider,
@@ -7220,7 +7577,7 @@ async function refreshProviderModels(providerId, apiKey, registry = loadRegistry
           reason: "No usable API key \u2014 add the provider via relay-ai providers add with a real key."
         };
       }
-      if (!apiKey) {
+      if (!keyOptional && !effectiveKey) {
         return {
           id: provider.id,
           name: provider.name,
@@ -7228,7 +7585,7 @@ async function refreshProviderModels(providerId, apiKey, registry = loadRegistry
           reason: "API key not available \u2014 cannot refresh models."
         };
       }
-      const fetched = await refreshApiListProvider(provider, apiKey);
+      const fetched = await refreshApiListProvider(provider, effectiveKey ?? "");
       if (fetched.error) {
         if ((fetched.error.includes("rejected") || fetched.error.includes("401") || fetched.error.includes("403")) && cachedModelCount(provider) > 0) {
           return skipWithCachedModels(
@@ -7425,7 +7782,10 @@ async function authenticateProvider(providerId, options = {}) {
   if (!supportsNativeOAuth(providerId)) {
     if (findOpencodeBinary()) {
       const cred2 = await runOpencodeAuthBroker(providerId, { method: options.brokerMethod });
-      await saveProviderCredential(oauthAuthRef(providerId), oauthCredentialToKeychainJson(cred2));
+      const saved2 = await saveProviderCredential(oauthAuthRef(providerId), oauthCredentialToKeychainJson(cred2));
+      if (!saved2) {
+        p9.log.warn("Could not save OAuth tokens to Keychain \u2014 session may not persist.");
+      }
       const registryProvider2 = await upsertOAuthProvider(providerId, cred2);
       return { providerId, credential: cred2, registryProvider: registryProvider2 };
     }
@@ -7547,7 +7907,7 @@ ${pc10.bold("Usage:")}
 ${pc10.bold("Subcommands:")}
   (none)      Provider hub wizard ${pc10.dim("[Phase 1.1]")}
   add         Add a provider (Groq, Mistral, Together AI, \u2026) ${pc10.dim("[Phase 1.1]")}
-  import      Bring settings from OpenCode (one-time) ${pc10.dim("[Phase 1.0]")}
+  import      import providers from 'open code CLI' (one-time) ${pc10.dim("[Phase 1.0]")}
   auth        Sign in with OAuth (xAI, OpenAI ChatGPT) ${pc10.dim("[Phase 2]")}
   list        Show configured providers ${pc10.dim("[Phase 1.0]")}
   remove      Remove a provider by id ${pc10.dim("[Phase 1.1]")}
@@ -7596,7 +7956,7 @@ async function runProvidersImport() {
   );
   if (result.skipped.length > 0) {
     for (const s of result.skipped) {
-      const reason = s.reason === "user-skipped" ? "skipped by you" : s.reason === "conflict-kept" ? "kept your existing config" : s.reason === "oauth-no-token" ? "OAuth provider in OpenCode but not signed in \u2014 run relay-ai providers auth" : s.reason === "no-api-key" ? "no API key in OpenCode \u2014 add key there or use relay-ai providers add" : s.reason === "manual-only" ? "uses gcloud/AWS credentials \u2014 not importable via API key" : s.reason === "placeholder-key" ? "placeholder API key \u2014 provider not imported" : s.reason === "invalid-key" ? "API key failed verification \u2014 provider not imported" : s.reason;
+      const reason = s.reason === "user-skipped" ? "skipped by you" : s.reason === "conflict-kept" ? "kept your existing config" : s.reason === "oauth-no-token" ? "OAuth provider in OpenCode but not signed in \u2014 run relay-ai providers auth" : s.reason === "no-api-key" ? "no API key in OpenCode \u2014 add key there or use relay-ai providers add" : s.reason === "manual-only" ? "uses gcloud/AWS credentials \u2014 not importable via API key" : s.reason === "placeholder-key" ? "placeholder API key \u2014 provider not imported" : s.reason === "invalid-key" ? "API key failed verification \u2014 provider not imported" : s.reason === "credential-save-failed" ? "could not save credential \u2014 provider not imported" : s.reason;
       p10.log.warn(`Skipped ${s.name} (${s.id}): ${reason}`);
     }
   }
@@ -7607,6 +7967,18 @@ async function runProvidersImport() {
       }
     }
   }
+  if (result.imported.length > 0) {
+    const refreshSpinner = p10.spinner();
+    refreshSpinner.start("Fetching model capabilities from providers...");
+    await Promise.all(result.imported.map(async (provider) => {
+      const key = await resolveRefreshCredential(
+        provider,
+        async (pr) => resolveProviderCredential(pr.id, pr.authRef)
+      );
+      await refreshProviderModels(provider.id, key);
+    }));
+    refreshSpinner.stop("Model capabilities refreshed.");
+  }
   return 0;
 }
 async function runProvidersAuth(providerId, method) {
@@ -7696,7 +8068,9 @@ async function runProvidersList() {
 }
 async function pickTemplateFromCatalog() {
   while (true) {
-    const templates = listAddableTemplates(loadRegistry().providers.map((p19) => p19.id));
+    const registry = loadRegistry();
+    const configuredIds = new Set(registry.providers.map((p19) => p19.id));
+    const templates = listAddableTemplates(configuredIds);
     if (templates.length === 0) return null;
     const method = await p10.select({
       message: `Choose a provider (${templates.length} available)`,
@@ -7727,22 +8101,12 @@ async function pickTemplateFromCatalog() {
     const query = String(searchInput);
     const matched = filterTemplates(templates, query);
     if (matched.length === 0) {
-      if (matchesOpenCodeCloudSearch(query)) {
-        p10.log.info(
-          "OpenCode Zen / Go are cloud backends \u2014 not in the Groq/Mistral template list."
-        );
-        const addCloud = await p10.confirm({
-          message: "Add OpenCode Zen / Go with your OpenCode API key?",
-          initialValue: true
-        });
-        if (p10.isCancel(addCloud)) continue;
-        if (addCloud) {
-          await runOpenCodeCloudAddFlow();
-          return null;
-        }
-        continue;
+      const alreadyAdded = filterTemplates(listSupportedTemplates(), query).filter((t) => configuredIds.has(t.id));
+      if (alreadyAdded.length > 0) {
+        p10.log.info(`Already configured: ${alreadyAdded.map((t) => t.name).join(", ")}`);
+      } else {
+        p10.log.warn("No providers match \u2014 try a different search");
       }
-      p10.log.warn("No providers match \u2014 try a different search");
       continue;
     }
     const options = matched.map((t) => ({
@@ -7766,6 +8130,40 @@ async function runTemplateAddFlow() {
   }
   const template = await pickTemplateFromCatalog();
   if (!template) return 0;
+  if (template.modelSource === "zen-go-api") {
+    const existingKey = await readGlobalOpencodeCredential();
+    let apiKey2 = existingKey;
+    if (!apiKey2) {
+      printPanel(pc10.cyan("OpenCode cloud"), [
+        `${pc10.white("Get an API key at:")} ${fmtUrl("https://opencode.ai/auth")}`,
+        `${pc10.dim("Uses OpenCode Zen / Go cloud models \u2014 not the same as importing from the OpenCode CLI.")}`
+      ]);
+      const collected = await resolveOrCollectApiKey(false, false);
+      if (!collected) {
+        p10.cancel("Cancelled.");
+        return 0;
+      }
+      apiKey2 = collected;
+    }
+    await migrateGlobalOpencodeCredential();
+    const spinner10 = p10.spinner();
+    spinner10.start(`Adding ${template.name}...`);
+    const stub = template.id === "zen" ? addZenRegistryStub() : addGoRegistryStub();
+    if (!stub.added && stub.reason) {
+      spinner10.stop("");
+      p10.log.warn(stub.reason);
+      return 0;
+    }
+    const registry = loadRegistry();
+    const refreshResult = await refreshProviderModels(template.id, apiKey2, registry);
+    spinner10.stop("");
+    if (refreshResult.ok) {
+      p10.log.success(`Added ${template.name} \u2014 ${fmtCount(refreshResult.modelCount ?? 0, "model")} updated.`);
+    } else {
+      p10.log.warn(`Added ${template.name}, but model refresh failed: ${refreshResult.reason ?? "Unknown error"}`);
+    }
+    return 0;
+  }
   if (template.signupUrl) {
     printPanel(fmtProvider(template.name), [
       `${pc10.white("Get an API key at:")} ${fmtUrl(template.signupUrl)}`
@@ -7811,66 +8209,6 @@ async function runTemplateAddFlow() {
   logConnected(template.name, result.modelCount ?? 0);
   return 0;
 }
-async function runOpenCodeCloudAddFlow() {
-  const registry = loadRegistry();
-  const hasZen = registry.providers.some((pr) => pr.id === "zen");
-  const hasGo = registry.providers.some((pr) => pr.id === "go");
-  if (hasZen && hasGo) {
-    p10.log.info("OpenCode Zen and Go are already configured.");
-    return 0;
-  }
-  printPanel(pc10.cyan("OpenCode cloud"), [
-    `${pc10.white("Get an API key at:")} ${fmtUrl("https://opencode.ai/auth")}`,
-    `${pc10.dim("Uses OpenCode Zen / Go cloud models \u2014 not the same as importing from the OpenCode CLI.")}`
-  ]);
-  const existingKey = await readGlobalOpencodeCredential();
-  if (!existingKey) {
-    const apiKey = await resolveOrCollectApiKey(false, false);
-    if (!apiKey) {
-      p10.cancel("Cancelled.");
-      return 0;
-    }
-  }
-  await migrateGlobalOpencodeCredential();
-  let pick;
-  if (!hasZen && !hasGo) {
-    const choice = await p10.select({
-      message: "Which OpenCode cloud backend?",
-      options: [
-        { value: "zen", label: "OpenCode Zen", hint: "Free + paid models" },
-        { value: "go", label: "OpenCode Go", hint: "Paid models" },
-        { value: "both", label: "Both Zen and Go", hint: "Same API key" }
-      ]
-    });
-    if (p10.isCancel(choice)) {
-      p10.cancel("Cancelled.");
-      return 0;
-    }
-    pick = choice;
-  } else if (!hasZen) {
-    pick = "zen";
-  } else {
-    pick = "go";
-  }
-  const added = [];
-  if ((pick === "zen" || pick === "both") && !hasZen) {
-    const zen = addZenRegistryStub();
-    if (zen.added) added.push("OpenCode Zen");
-    else if (zen.reason) p10.log.warn(zen.reason);
-  }
-  if ((pick === "go" || pick === "both") && !hasGo) {
-    const go = addGoRegistryStub();
-    if (go.added) added.push("OpenCode Go");
-    else if (go.reason) p10.log.warn(go.reason);
-  }
-  if (added.length === 0) {
-    p10.log.info("Nothing new to add.");
-    return 0;
-  }
-  p10.log.success(`Added ${added.join(" and ")}.`);
-  p10.log.info("Run relay-ai providers refresh-models to cache model lists.");
-  return 0;
-}
 async function runCustomEndpointAddFlow() {
   const kindChoice = await p10.select({
     message: "Custom server type",
@@ -7932,14 +8270,9 @@ async function runProvidersAdd() {
   const registry = loadRegistry();
   const hasOpencode = findOpencodeBinary() !== null;
   const options = [
-    {
-      value: "opencode-cloud",
-      label: "OpenCode Zen / Go (cloud API key)",
-      hint: "Key from opencode.ai/auth \u2014 not in the Groq/Mistral list"
-    },
     {
       value: "import",
-      label: "Bring settings from OpenCode CLI",
+      label: "import providers from 'open code CLI'",
       hint: hasOpencode ? "Import Groq, OpenAI, etc. from your OpenCode config" : "Requires OpenCode CLI"
     }
   ];
@@ -7961,9 +8294,6 @@ async function runProvidersAdd() {
     p10.cancel("Cancelled.");
     return 0;
   }
-  if (choice === "opencode-cloud") {
-    return runOpenCodeCloudAddFlow();
-  }
   if (choice === "import") {
     if (!hasOpencode) {
       p10.log.error("OpenCode CLI not found. Install from https://opencode.ai");
@@ -8008,6 +8338,9 @@ async function runCloudBuiltinDetail(id) {
   printCloudProviderPanel(name);
   return "back";
 }
+function providerHubChoiceValue(entry) {
+  return entry.cloudBuiltin ? `cloud:${entry.cloudBuiltin}` : `provider:${entry.id}`;
+}
 async function runProviderDetail(id) {
   const registry = loadRegistry();
   const provider = registry.providers.find((pr) => pr.id === id);
@@ -8065,23 +8398,24 @@ async function runProvidersHub() {
   const hasOpencode = findOpencodeBinary() !== null;
   while (true) {
     const entries = await resolveProvidersForDisplay();
-    const options = [];
+    const options = [
+      { value: "add", label: pc10.bold("+ Add a provider"), hint: "" }
+    ];
     for (const entry of entries) {
       const hint = entry.id;
-      const value = `provider:${entry.id}`;
+      const value = providerHubChoiceValue(entry);
       options.push({
         value,
         label: providerLabel(entry.name, entry.modelCount, entry.enabled),
         hint
       });
     }
-    options.push({ value: "add", label: "+ Add a provider", hint: "" });
     options.push({ value: "auth-menu", label: "\u2192 Sign in with OAuth (xAI / OpenAI)", hint: "Device code or OpenCode broker" });
     if (entries.length > 0) {
       options.push({ value: "refresh-all", label: "\u21BA Refresh all models", hint: "Update model lists for all providers" });
     }
     if (hasOpencode) {
-      options.push({ value: "import", label: "\u2192 Bring settings from OpenCode CLI", hint: "One-time import" });
+      options.push({ value: "import", label: "\u2192 import providers from 'open code CLI'", hint: "One-time import" });
     }
     options.push({ value: "done", label: "Done", hint: "" });
     const choice = await p10.select({
@@ -8291,12 +8625,12 @@ function translateResponsesTools(tools) {
   }
   return Object.keys(out).length ? out : void 0;
 }
-function translateResponsesRequest(body, npm) {
+function translateResponsesRequest(body, npm, metadata) {
   const { system, messages } = translateResponsesInput(body.input, body.instructions, npm);
   const effort = body.reasoning?.effort;
   const providerOptions = deepMergeProviderOptions(
     thinkingProviderOptions(npm),
-    effortProviderOptions(npm, effort, body.model)
+    effortProviderOptions(npm, effort, body.model, metadata)
   );
   return {
     system,
@@ -8338,11 +8672,9 @@ async function writeResponsesStream(fullStream, modelId, write) {
   let textItemId = null;
   let textOutputIndex = 0;
   let textFull = "";
-  let toolItemId = null;
-  let toolCallId = null;
-  let toolName = null;
-  let toolOutputIndex = 0;
-  let toolArgsFull = "";
+  const toolStates = [];
+  const toolStatesById = /* @__PURE__ */ new Map();
+  let currentToolState = null;
   let reasoningItemId = null;
   let reasoningText = "";
   let reasoningOutputIndex = 0;
@@ -8367,6 +8699,51 @@ async function writeResponsesStream(fullStream, modelId, write) {
     }
     return textItemId;
   };
+  const rememberToolState = (state) => {
+    toolStates.push(state);
+    toolStatesById.set(state.itemId, state);
+    toolStatesById.set(state.callId, state);
+    currentToolState = state;
+    return state;
+  };
+  const createToolState = (rawId, name, signature) => {
+    const itemId = rawId ?? newItemId("fc");
+    const state = rememberToolState({
+      itemId,
+      callId: encodeToolUseId(itemId, signature),
+      name: name ?? "unknown",
+      outputIndex: outputIndex++,
+      args: ""
+    });
+    emit("response.output_item.added", {
+      type: "response.output_item.added",
+      output_index: state.outputIndex,
+      item: {
+        type: "function_call",
+        id: state.itemId,
+        call_id: state.callId,
+        name: state.name,
+        arguments: "",
+        status: "in_progress"
+      }
+    });
+    return state;
+  };
+  const findToolState = (part) => {
+    const key = part.id ?? part.toolCallId;
+    if (key) return toolStatesById.get(key) ?? currentToolState;
+    return currentToolState;
+  };
+  const appendToolArgs = (state, delta) => {
+    if (!delta) return;
+    state.args += delta;
+    emit("response.function_call_arguments.delta", {
+      type: "response.function_call_arguments.delta",
+      item_id: state.itemId,
+      output_index: state.outputIndex,
+      delta
+    });
+  };
   for await (const part of fullStream) {
     switch (part.type) {
       case "reasoning-start":
@@ -8410,64 +8787,20 @@ async function writeResponsesStream(fullStream, modelId, write) {
         break;
       case "tool-input-start": {
         const sig = grabRoundTripSignature(part);
-        toolItemId = part.id ?? newItemId("fc");
-        toolCallId = encodeToolUseId(toolItemId, sig);
-        toolName = part.toolName ?? "unknown";
-        toolArgsFull = "";
-        toolOutputIndex = outputIndex;
-        outputIndex++;
-        emit("response.output_item.added", {
-          type: "response.output_item.added",
-          output_index: toolOutputIndex,
-          item: {
-            type: "function_call",
-            id: toolItemId,
-            call_id: toolCallId,
-            name: toolName,
-            arguments: "",
-            status: "in_progress"
-          }
-        });
+        createToolState(part.id ?? part.toolCallId, part.toolName, sig);
         break;
       }
-      case "tool-input-delta":
-        toolArgsFull += part.delta ?? part.text ?? "";
-        if (toolItemId) {
-          emit("response.function_call_arguments.delta", {
-            type: "response.function_call_arguments.delta",
-            item_id: toolItemId,
-            output_index: toolOutputIndex,
-            delta: part.delta ?? part.text ?? ""
-          });
-        }
+      case "tool-input-delta": {
+        const state = findToolState(part);
+        if (state) appendToolArgs(state, part.delta ?? part.text ?? "");
         break;
+      }
       case "tool-call": {
-        if (!toolItemId) {
-          const sig = grabRoundTripSignature(part);
-          toolItemId = part.toolCallId ?? newItemId("fc");
-          toolCallId = encodeToolUseId(toolItemId, sig);
-          toolName = part.toolName ?? "unknown";
-          toolArgsFull = JSON.stringify(part.input ?? {});
-          toolOutputIndex = outputIndex;
-          outputIndex++;
-          emit("response.output_item.added", {
-            type: "response.output_item.added",
-            output_index: toolOutputIndex,
-            item: {
-              type: "function_call",
-              id: toolItemId,
-              call_id: toolCallId,
-              name: toolName,
-              arguments: "",
-              status: "in_progress"
-            }
-          });
-          emit("response.function_call_arguments.delta", {
-            type: "response.function_call_arguments.delta",
-            item_id: toolItemId,
-            output_index: toolOutputIndex,
-            delta: toolArgsFull
-          });
+        const sig = grabRoundTripSignature(part);
+        const key = part.toolCallId ?? part.id;
+        const state = (key ? toolStatesById.get(key) : void 0) ?? createToolState(key, part.toolName, sig);
+        if (!state.args) {
+          appendToolArgs(state, JSON.stringify(part.input ?? {}));
         }
         break;
       }
@@ -8530,24 +8863,24 @@ async function writeResponsesStream(fullStream, modelId, write) {
     });
     outputItems.unshift(reasoningItem);
   }
-  if (toolItemId && toolCallId && toolName) {
+  for (const tool3 of toolStates) {
     emit("response.function_call_arguments.done", {
       type: "response.function_call_arguments.done",
-      item_id: toolItemId,
-      output_index: toolOutputIndex,
-      arguments: toolArgsFull
+      item_id: tool3.itemId,
+      output_index: tool3.outputIndex,
+      arguments: tool3.args
     });
     const fcItem = {
       type: "function_call",
-      id: toolItemId,
-      call_id: toolCallId,
-      name: toolName,
-      arguments: toolArgsFull,
+      id: tool3.itemId,
+      call_id: tool3.callId,
+      name: tool3.name,
+      arguments: tool3.args,
       status: "completed"
     };
     emit("response.output_item.done", {
       type: "response.output_item.done",
-      output_index: toolOutputIndex,
+      output_index: tool3.outputIndex,
       item: fcItem
     });
     outputItems.push(fcItem);
@@ -8597,10 +8930,11 @@ async function generateResponsesResponse(model, params, modelId) {
     });
   }
   for (const tc of r.toolCalls) {
+    const encodedId = encodeToolUseId(tc.toolCallId, grabRoundTripSignature(tc));
     output.push({
       type: "function_call",
       id: tc.toolCallId,
-      call_id: tc.toolCallId,
+      call_id: encodedId,
       name: tc.toolName,
       arguments: JSON.stringify(tc.input ?? {}),
       status: "completed"
@@ -8748,7 +9082,8 @@ async function startCodexProxy(routes, options = {}) {
       modelId: route.upstreamModelId,
       apiKey: route.apiKey,
       baseURL: route.baseURL,
-      providerId: route.modelId
+      providerId: route.modelId,
+      vertex: route.vertex
     }));
   }
   return new Promise((resolve, reject2) => {
@@ -8831,7 +9166,14 @@ async function startCodexProxy(routes, options = {}) {
         try {
           const params = translateResponsesRequest(
             body,
-            route.npm
+            route.npm,
+            {
+              providerId: route.providerId,
+              apiBaseUrl: route.baseURL,
+              supportedParameters: route.supportedParameters,
+              reasoning: route.reasoning,
+              interleavedReasoningField: route.interleavedReasoningField
+            }
           );
           if (debug) {
             const effort = body.reasoning?.effort;
@@ -8992,13 +9334,8 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function sessionAgeMs(lock) {
-  const started = Date.parse(lock.startedAt);
-  if (Number.isNaN(started)) return Infinity;
-  return Date.now() - started;
-}
 function isConcurrentSession(lock) {
-  return isProcessAlive(lock.pid) && sessionAgeMs(lock) <= STALE_SESSION_MS;
+  return isProcessAlive(lock.pid);
 }
 function restoreCodexOverlay(env = process.env) {
   const removed = [];
@@ -9041,13 +9378,16 @@ function checkSessionLock(isTty, env = process.env) {
 // src/codex/profile.ts
 var CODEX_LAUNCH_SANDBOX = "danger-full-access";
 function profileReasoningLine(effort) {
-  return effort ? `model_reasoning_effort = "${effort}"
+  return effort ? `model_reasoning_effort = ${tomlString(effort)}
 ` : "";
 }
 function profileSandboxLine() {
-  return `sandbox = "${CODEX_LAUNCH_SANDBOX}"
+  return `sandbox = ${tomlString(CODEX_LAUNCH_SANDBOX)}
 `;
 }
+function tomlString(value) {
+  return JSON.stringify(value);
+}
 function buildCodexProfileToml(spec) {
   const { route, proxyPort, catalogPath, modelReasoningEffort } = spec;
   const model = route.modelId;
@@ -9056,26 +9396,26 @@ function buildCodexProfileToml(spec) {
     const envKey = codexProviderEnvKey(route.providerId);
     const baseUrl = route.baseURL ?? "https://api.openai.com/v1";
     return `# Generated by relay-ai \u2014 do not edit
-${profileSandboxLine()}model = "${model}"
-model_provider = "${route.providerId}"
-model_catalog_json = "${catalogPath}"
+${profileSandboxLine()}model = ${tomlString(model)}
+model_provider = ${tomlString(route.providerId)}
+model_catalog_json = ${tomlString(catalogPath)}
 ${reasoning}
 [model_providers.${route.providerId}]
-name = "${route.providerId}"
-base_url = "${baseUrl}"
-env_key = "${envKey}"
+name = ${tomlString(route.providerId)}
+base_url = ${tomlString(baseUrl)}
+env_key = ${tomlString(envKey)}
 wire_api = "responses"
 `;
   }
   const proxyBase = `http://127.0.0.1:${proxyPort}/v1`;
   return `# Generated by relay-ai \u2014 do not edit
-${profileSandboxLine()}model = "${model}"
+${profileSandboxLine()}model = ${tomlString(model)}
 model_provider = "relay-ai-proxy"
-model_catalog_json = "${catalogPath}"
+model_catalog_json = ${tomlString(catalogPath)}
 ${reasoning}
 [model_providers.relay-ai-proxy]
 name = "relay-ai"
-base_url = "${proxyBase}"
+base_url = ${tomlString(proxyBase)}
 env_key = "RELAY_AI_CODEX_KEY"
 wire_api = "responses"
 `;
@@ -9340,7 +9680,13 @@ function buildEntry(r, priority) {
 }
 function defaultReasoningEffortForFavorite(r) {
   const model = enrichFavoriteModel(r);
-  const caps = getReasoningCapabilities(model.npm ?? "", model.upstreamModelId ?? model.id);
+  const caps = getReasoningCapabilities(model.npm ?? "", model.upstreamModelId ?? model.id, {
+    providerId: r.providerId,
+    apiBaseUrl: model.apiBaseUrl,
+    supportedParameters: model.supportedParameters,
+    reasoning: model.reasoning,
+    interleavedReasoningField: model.interleavedReasoningField
+  });
   return caps.levels.length > 0 ? caps.defaultLevel : "none";
 }
 function buildFavoritesAppCatalog(resolved) {
@@ -9356,65 +9702,6 @@ function buildFavoritesAppCatalog(resolved) {
 
 // src/codex/favorites-launch.ts
 import * as p12 from "@clack/prompts";
-
-// src/favorites-resolver.ts
-var ZEN_GO_PROVIDER_NAME = {
-  zen: "OpenCode Zen",
-  go: "OpenCode Go"
-};
-function resolveFavorite(fav, ctx) {
-  if (fav.providerId === "zen" || fav.providerId === "go") {
-    if (!ctx.zenGoApiKey) return void 0;
-    const models = fav.providerId === "zen" ? ctx.zenModels : ctx.goModels;
-    const model = models?.find((m) => m.id === fav.modelId);
-    if (!model) return void 0;
-    return {
-      providerId: fav.providerId,
-      providerName: ZEN_GO_PROVIDER_NAME[fav.providerId],
-      model,
-      apiKey: ctx.zenGoApiKey,
-      sourceBackend: fav.providerId
-    };
-  }
-  if (ctx.findLocalModel) {
-    const found = ctx.findLocalModel(fav.providerId, fav.modelId);
-    if (!found) return void 0;
-    if (ctx.agent && shouldHideModel({ providerId: fav.providerId, modelId: fav.modelId, agent: ctx.agent })) {
-      return void 0;
-    }
-    return {
-      providerId: fav.providerId,
-      providerName: found.provider.name,
-      model: found.model,
-      apiKey: found.provider.apiKey
-    };
-  }
-  return void 0;
-}
-function buildFavoritesList(starting, favorites, ctx, max = 20) {
-  const droppedFavorites = [];
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  if (starting) {
-    seen.add(`${starting.providerId}::${starting.model.id}`);
-    out.push(starting);
-  }
-  for (const fav of favorites) {
-    if (out.length >= max) break;
-    const key = `${fav.providerId}::${fav.modelId}`;
-    if (seen.has(key)) continue;
-    const resolved = resolveFavorite(fav, ctx);
-    if (!resolved) {
-      droppedFavorites.push(fav);
-      continue;
-    }
-    seen.add(key);
-    out.push(resolved);
-  }
-  return { resolved: out, droppedFavorites };
-}
-
-// src/codex/favorites-launch.ts
 function buildCodexProxyRoutesFromResolved(resolved, providersById) {
   return resolved.map((r) => {
     const provider = providersById.get(r.providerId);
@@ -9650,15 +9937,26 @@ ${pc13.bold("Examples:")}
 ${pc13.bold("Favorites:")}
   When you have saved favorites via ${pc13.cyan("relay-ai models")}, the Codex
   picker will show your starting model + favorites for mid-session switching.
-  Zen/Go favorites are skipped \u2014 use ${pc13.cyan("relay-ai claude")} or
-  ${pc13.cyan("relay-ai server")} for those.`;
+  Zen/Go favorites are included when an OpenCode API key is available.`;
 }
 async function writeLaunchArtifacts(route, selectedModel, providerName, proxyPort) {
   const catalogPath = getCatalogOutputPath(route.providerId);
   const catalog = buildCatalogFile([selectedModel], providerName);
   writeOverlayFile(catalogPath, serializeCatalog(catalog));
   const profilePath = getProfileOutputPath();
-  writeOverlayFile(profilePath, buildCodexProfileToml({ route, proxyPort, catalogPath }));
+  const caps = getReasoningCapabilities(route.npm, route.upstreamModelId, {
+    providerId: route.providerId,
+    apiBaseUrl: route.baseURL,
+    supportedParameters: route.supportedParameters,
+    reasoning: route.reasoning,
+    interleavedReasoningField: route.interleavedReasoningField
+  });
+  writeOverlayFile(profilePath, buildCodexProfileToml({
+    route,
+    proxyPort,
+    catalogPath,
+    modelReasoningEffort: caps.defaultLevel || void 0
+  }));
   return { profilePath, catalogPath };
 }
 async function writeFavoritesLaunchArtifacts(resolved, starting, proxyPort) {
@@ -9696,6 +9994,103 @@ function printCodexCleanupReminder(hadProxy) {
   parts.push("If a future session acts stuck: relay-ai codex --restore");
   p13.log.info(parts.join(" "));
 }
+function vertexEntryToLocalModel(entry) {
+  return {
+    id: entry.id,
+    name: entry.display_name,
+    family: "claude",
+    brand: "Anthropic",
+    modelFormat: "openai",
+    upstreamModelId: entry.upstream_id ?? entry.id,
+    baseUrl: "",
+    npm: VERTEX_ANTHROPIC_NPM,
+    contextWindow: resolveContextWindow(entry.id)
+  };
+}
+async function runCodexVertexLaunch(passthroughArgs, trace) {
+  if (!hasApplicationDefaultCredentials()) {
+    p13.log.error("Google Application Default Credentials not found.");
+    p13.log.info("Run: gcloud auth application-default login");
+    return 1;
+  }
+  const config = buildVertexRuntimeConfig();
+  if (!config) {
+    p13.log.error("ANTHROPIC_VERTEX_PROJECT_ID (or GOOGLE_CLOUD_PROJECT) is not set.");
+    p13.log.info("Set your project: export ANTHROPIC_VERTEX_PROJECT_ID=your-project-id");
+    return 1;
+  }
+  let selectedEntry;
+  if (config.models.length === 1) {
+    selectedEntry = config.models[0];
+  } else {
+    const choice = await p13.select({
+      message: "Select a Vertex AI model:",
+      options: config.models.map((m) => ({ value: m, label: m.display_name, hint: m.id }))
+    });
+    if (p13.isCancel(choice)) {
+      p13.cancel("Cancelled.");
+      return 0;
+    }
+    selectedEntry = choice;
+  }
+  process.env["ANTHROPIC_VERTEX_PROJECT_ID"] = config.project;
+  process.env["GOOGLE_CLOUD_LOCATION"] = config.location;
+  const vertexConfig = { project: config.project, location: config.location };
+  const allModels = config.models.map(vertexEntryToLocalModel);
+  const allRoutes = allModels.map((m) => ({
+    modelId: m.id,
+    upstreamModelId: m.upstreamModelId,
+    npm: VERTEX_ANTHROPIC_NPM,
+    apiKey: "",
+    providerId: "vertex",
+    vertex: vertexConfig
+  }));
+  const startingRoute = {
+    tier: "proxy",
+    modelId: selectedEntry.id,
+    upstreamModelId: selectedEntry.upstream_id ?? selectedEntry.id,
+    npm: VERTEX_ANTHROPIC_NPM,
+    apiKey: "",
+    providerId: "vertex"
+  };
+  const debugLogPath = getCodexProxyDebugLogPath();
+  let proxyHandle = null;
+  try {
+    p13.log.info(`Vertex AI \xB7 ${selectedEntry.display_name} \u2014 project: ${config.project} / location: ${config.location}`);
+    proxyHandle = await startCodexProxy(allRoutes, { debug: trace });
+    const proxyPort = proxyHandle.port;
+    const catalogPath = getCatalogOutputPath("vertex");
+    writeOverlayFile(catalogPath, serializeCatalog(buildCatalogFile(allModels, "Vertex AI")));
+    const profilePath = getProfileOutputPath();
+    const caps = getReasoningCapabilities(VERTEX_ANTHROPIC_NPM, selectedEntry.id);
+    writeOverlayFile(profilePath, buildCodexProfileToml({
+      route: startingRoute,
+      proxyPort,
+      catalogPath,
+      modelReasoningEffort: caps.defaultLevel || void 0
+    }));
+    writeSessionLock({
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      profilePath,
+      catalogPaths: [catalogPath],
+      proxyPort
+    });
+    if (!isAgentStdoutMode()) {
+      logProxy(proxyPort);
+      logActiveModel(selectedEntry.display_name, selectedEntry.id);
+      printCodexCliCleanupPanel("relay-ai codex --restore");
+    }
+    const childEnv = buildCodexChildEnv(startingRoute, proxyPort);
+    const exitCode = await launchCodex(selectedEntry.id, childEnv, passthroughArgs);
+    if (trace) printTraceLog(debugLogPath);
+    printCodexCleanupReminder(true);
+    return exitCode;
+  } finally {
+    proxyHandle?.close();
+    restoreCodexOverlay();
+  }
+}
 async function runCodexCommand(codexArgs, trace = false, launch = {}) {
   if (codexArgs.includes("--help") || codexArgs.includes("-h")) {
     console.log(codexHelpText());
@@ -9727,6 +10122,21 @@ async function runCodexCommand(codexArgs, trace = false, launch = {}) {
     p13.log.info(`Debug log: ${debugLogPath}`);
   }
   const isTty = Boolean(process.stdin.isTTY);
+  if (launch.vertex) {
+    if (!configOnly) {
+      const sessionCheck = checkSessionLock(isTty);
+      if (!sessionCheck.ok) {
+        if (sessionCheck.reason === "non_tty") {
+          console.error(pc13.red("relay-ai codex --vertex requires an interactive terminal."));
+          return 1;
+        }
+        console.error(pc13.yellow(`Another relay-ai codex session may be running (pid ${sessionCheck.lock.pid}).`));
+        console.error("Run relay-ai codex --restore to clean up, or wait for it to finish.");
+        return 1;
+      }
+    }
+    return runCodexVertexLaunch(passthroughArgs, trace);
+  }
   const prefs = loadPreferences();
   const launchPlan = planLaunchWizard({
     explicit: { providerId: launch.launchProvider, modelId: launch.launchModel },
@@ -9821,9 +10231,17 @@ Error: ${launchPlan.error}
     const pickedProvider = await pickCodexProvider(compatible, prefs, favoritesActive);
     if (!pickedProvider) return 0;
     if (pickedProvider === "__favorites__") {
-      const fav = favorites[0];
-      activeProvider = compatible.find((p19) => p19.id === fav.providerId);
-      selectedModel = activeProvider.models.find((m) => m.id === fav.modelId);
+      const favoriteProviders = compatible.map((provider) => ({
+        ...provider,
+        models: routableModelsForProvider(provider, "codex")
+      }));
+      const favoriteStart = resolveFirstAvailableFavorite(favorites, favoriteProviders);
+      if (!favoriteStart) {
+        p13.log.warn("No saved Codex favorites are currently available.");
+        return 0;
+      }
+      activeProvider = favoriteStart.provider;
+      selectedModel = favoriteStart.model;
       p13.log.step(`Loaded Favorites Catalog. Starting model: ${selectedModel.name || selectedModel.id} (${activeProvider.name})`);
     } else {
       activeProvider = pickedProvider;
@@ -9895,7 +10313,11 @@ Error: ${launchPlan.error}
         npm: route.npm,
         apiKey: route.apiKey,
         baseURL: route.baseURL,
-        upstreamModelId: route.upstreamModelId
+        upstreamModelId: route.upstreamModelId,
+        providerId: route.providerId,
+        supportedParameters: route.supportedParameters,
+        reasoning: route.reasoning,
+        interleavedReasoningField: route.interleavedReasoningField
       }], { debug: trace });
       proxyPort = proxyHandle.port;
     }
@@ -10053,7 +10475,13 @@ function mergeAppConfig(existing, spec) {
   };
   const existingEffort = typeof out.model_reasoning_effort === "string" ? out.model_reasoning_effort : void 0;
   if (existingEffort !== void 0) {
-    const caps = getReasoningCapabilities(spec.route.npm, spec.route.modelId);
+    const caps = getReasoningCapabilities(spec.route.npm, spec.route.modelId, {
+      providerId: spec.route.providerId,
+      apiBaseUrl: spec.route.baseURL,
+      supportedParameters: spec.route.supportedParameters,
+      reasoning: spec.route.reasoning,
+      interleavedReasoningField: spec.route.interleavedReasoningField
+    });
     if (caps.levels.length === 0 || !caps.levels.includes(existingEffort)) {
       if (caps.levels.length > 0 && caps.defaultLevel) {
         out.model_reasoning_effort = caps.defaultLevel;
@@ -10243,7 +10671,7 @@ function removeAppCatalogs(env = process.env) {
 }
 function restoreCodexAppOverlay(env = process.env) {
   const lock = readAppSessionLock(env);
-  if (lock && isConcurrentSession(lock)) {
+  if (lock && lock.pid !== process.pid && isConcurrentSession(lock)) {
     return {
       restored: false,
       liveSession: true,
@@ -10272,7 +10700,7 @@ function recoverInterruptedCodexAppSession(env = process.env) {
   const lock = readAppSessionLock(env);
   const managed = isAppManagedConfig(readCodexConfigText());
   if (!lock && !managed) return { recovered: false };
-  if (lock && isConcurrentSession(lock)) {
+  if (lock && lock.pid !== process.pid && isConcurrentSession(lock)) {
     return { recovered: false };
   }
   restoreCodexAppOverlay(env);
@@ -10281,7 +10709,7 @@ function recoverInterruptedCodexAppSession(env = process.env) {
 function checkAppSessionLock(isTty, env = process.env) {
   if (!isTty) return { ok: false, reason: "non_tty" };
   const lock = readAppSessionLock(env);
-  if (lock && isConcurrentSession(lock)) {
+  if (lock && lock.pid !== process.pid && isConcurrentSession(lock)) {
     return { ok: false, reason: "concurrent", lock };
   }
   return { ok: true };
@@ -10547,13 +10975,154 @@ ${pc14.bold("Examples:")}
 ${pc14.bold("Favorites:")}
   When you have saved favorites via ${pc14.cyan("relay-ai models")}, the Codex App
   picker will show your starting model + favorites for mid-session switching.
-  Zen/Go favorites are skipped \u2014 use ${pc14.cyan("relay-ai claude")} or
-  ${pc14.cyan("relay-ai server")} for those.`;
+  Zen/Go favorites are included when an OpenCode API key is available.`;
 }
 function providerForCodexPicker(provider) {
   return { ...provider, models: routableModelsForProvider(provider, "codex-app") };
 }
-async function runCodexAppCommand(args) {
+function vertexEntryToLocalModel2(entry) {
+  return {
+    id: entry.id,
+    name: entry.display_name,
+    family: "claude",
+    brand: "Anthropic",
+    modelFormat: "openai",
+    upstreamModelId: entry.upstream_id ?? entry.id,
+    baseUrl: "",
+    npm: VERTEX_ANTHROPIC_NPM,
+    contextWindow: resolveContextWindow(entry.id)
+  };
+}
+async function runCodexAppVertexLaunch(configOnly) {
+  if (!hasApplicationDefaultCredentials()) {
+    p15.log.error("Google Application Default Credentials not found.");
+    p15.log.info("Run: gcloud auth application-default login");
+    return 1;
+  }
+  const config = buildVertexRuntimeConfig();
+  if (!config) {
+    p15.log.error("ANTHROPIC_VERTEX_PROJECT_ID (or GOOGLE_CLOUD_PROJECT) is not set.");
+    p15.log.info("Set your project: export ANTHROPIC_VERTEX_PROJECT_ID=your-project-id");
+    return 1;
+  }
+  let selectedEntry;
+  if (config.models.length === 1) {
+    selectedEntry = config.models[0];
+  } else {
+    const choice = await p15.select({
+      message: "Select a starting Vertex AI model:",
+      options: config.models.map((m) => ({ value: m, label: m.display_name, hint: m.id }))
+    });
+    if (p15.isCancel(choice)) {
+      p15.cancel("Cancelled.");
+      return 0;
+    }
+    selectedEntry = choice;
+  }
+  process.env["ANTHROPIC_VERTEX_PROJECT_ID"] = config.project;
+  process.env["GOOGLE_CLOUD_LOCATION"] = config.location;
+  const vertexConfig = { project: config.project, location: config.location };
+  const vertexModels = config.models.map(vertexEntryToLocalModel2);
+  const catalogPath = getAppCatalogPath("vertex");
+  const route = {
+    tier: "proxy",
+    modelId: selectedEntry.id,
+    upstreamModelId: selectedEntry.upstream_id ?? selectedEntry.id,
+    npm: VERTEX_ANTHROPIC_NPM,
+    apiKey: "",
+    providerId: "vertex"
+  };
+  if (configOnly) {
+    const home = process.env["HOME"] ?? "";
+    const shortenPath = (fp) => home ? fp.replace(home, "~") : fp;
+    console.log("");
+    console.log(pc14.bold(pc14.cyan("  CONFIG PREVIEW \u2014 relay-ai codex-app --vertex")));
+    console.log("");
+    console.log(`  ${pc14.bold("Mode:")}     Vertex AI`);
+    console.log(`  ${pc14.bold("Project:")} ${config.project}`);
+    console.log(`  ${pc14.bold("Location:")} ${config.location}`);
+    console.log(`  ${pc14.bold("Model:")}    ${selectedEntry.display_name}`);
+    console.log(`  ${pc14.bold("Catalog:")} ${vertexModels.length} model${vertexModels.length !== 1 ? "s" : ""} available`);
+    console.log("");
+    console.log(`  ${pc14.bold("Catalog file:")}`);
+    console.log(`    ${pc14.dim(shortenPath(catalogPath))}`);
+    console.log("");
+    console.log(pc14.dim("  No app was launched."));
+    console.log(pc14.dim("  Run ") + pc14.cyan("relay-ai codex-app --vertex") + pc14.dim(" to launch."));
+    console.log("");
+    return 0;
+  }
+  let proxyHandle = null;
+  let sessionActive = false;
+  try {
+    proxyHandle = await startCodexProxy(
+      vertexModels.map((m) => ({
+        modelId: m.id,
+        upstreamModelId: m.upstreamModelId,
+        npm: VERTEX_ANTHROPIC_NPM,
+        apiKey: "",
+        providerId: "vertex",
+        vertex: vertexConfig
+      })),
+      { requireAuth: false }
+    );
+    const proxyPort = proxyHandle.port;
+    const catalogFile = buildAppCatalogFile(vertexModels, "Vertex AI", selectedEntry.id);
+    writeOverlayFile(catalogPath, serializeCatalog(catalogFile));
+    const spec = {
+      route,
+      proxyPort,
+      catalogPath,
+      providerDisplayName: `${selectedEntry.display_name} \xB7 Vertex AI`
+    };
+    saveAppRestoreStateBeforePatch();
+    const backupPath = backupConfigToml();
+    applyAppConfigPatch(spec);
+    writeAppSessionLock({
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      configPath: getCodexConfigPath(),
+      catalogPaths: [catalogPath],
+      restoreStatePath: getAppRestoreStatePath(),
+      backupPath,
+      proxyPort
+    });
+    sessionActive = true;
+    p15.log.info(`Vertex AI \xB7 ${selectedEntry.display_name} \u2014 project: ${config.project} / location: ${config.location}`);
+    logProxy(proxyPort);
+    logActiveModel(selectedEntry.display_name, selectedEntry.id);
+    try {
+      await launchOrRestartCodexApp();
+    } catch (err) {
+      p15.log.warn(String(err instanceof Error ? err.message : err));
+      p15.log.info(codexAppInstallHint());
+    }
+    printCodexAppSessionPanel({
+      modelLabel: selectedEntry.display_name,
+      modelId: selectedEntry.id,
+      providerName: "Vertex AI",
+      restoreCommand: "relay-ai codex-app --restore"
+    });
+    codexAppOutro(selectedEntry.display_name);
+    await waitForShutdown2();
+    console.log("");
+    if (sessionActive) {
+      restoreCodexAppOverlay();
+      sessionActive = false;
+    }
+    if (isCodexAppRunning()) {
+      const shouldClose = await p15.confirm({ message: "Codex Desktop is still running. Close it?" });
+      if (shouldClose && !p15.isCancel(shouldClose)) {
+        quitCodexAppGracefully();
+      }
+    }
+    return 0;
+  } finally {
+    proxyHandle?.close();
+    if (sessionActive) restoreCodexAppOverlay();
+  }
+}
+async function runCodexAppCommand(args, opts = {}) {
   if (args.includes("--help") || args.includes("-h")) {
     console.log(codexAppHelpText());
     return 0;
@@ -10590,6 +11159,9 @@ async function runCodexAppCommand(args) {
       p15.log.warn("Recovered from an interrupted codex-app session (restored Codex config).");
     }
   }
+  if (opts.vertex) {
+    return runCodexAppVertexLaunch(configOnly);
+  }
   const catalogSpinner = p15.spinner();
   catalogSpinner.start("Loading your providers...");
   let catalog;
@@ -10626,9 +11198,14 @@ async function runCodexAppCommand(args) {
     const pickedProvider = await pickCodexProvider(compatible, prefs, favoritesActive);
     if (!pickedProvider) return 0;
     if (pickedProvider === "__favorites__") {
-      const fav = favorites[0];
-      activeProvider = providerForCodexPicker(compatible.find((p19) => p19.id === fav.providerId));
-      selectedModel = activeProvider.models.find((m) => m.id === fav.modelId);
+      const favoriteProviders = compatible.map(providerForCodexPicker);
+      const favoriteStart = resolveFirstAvailableFavorite(favorites, favoriteProviders);
+      if (!favoriteStart) {
+        p15.log.warn("No saved Codex App favorites are currently available.");
+        return 0;
+      }
+      activeProvider = favoriteStart.provider;
+      selectedModel = favoriteStart.model;
       p15.log.step(`Loaded Favorites Catalog. Starting model: ${selectedModel.name || selectedModel.id} (${activeProvider.name})`);
     } else {
       activeProvider = providerForCodexPicker(pickedProvider);
@@ -11203,6 +11780,8 @@ function claudeAppHelpText() {
 
 ${pc15.bold("Usage:")}
   relay-ai claude-app
+  relay-ai claude-app --trace
+  relay-ai claude-app --restore
 
 ${pc15.bold("Description:")}
   Picks a provider and model from ~/.relay-ai/providers.json, patches Claude Desktop config
@@ -11214,6 +11793,7 @@ ${pc15.bold("Platforms:")}
 
 ${pc15.bold("Cleanup:")}
   Ctrl+C stops the proxy and restores your previous Claude config.
+  After a crash: relay-ai claude-app --restore
 `;
 }
 function providerForClaudePicker(provider) {
@@ -11224,6 +11804,14 @@ async function runClaudeAppCommand(args) {
     console.log(claudeAppHelpText());
     return 0;
   }
+  if (args.includes("--restore")) {
+    recoverSession();
+    console.log("Restored Claude Desktop relay-ai config.");
+    return 0;
+  }
+  const trace = args.includes("--trace");
+  const debugLogPath = trace ? getProxyDebugLogPath() : void 0;
+  if (trace) console.log(`Debug log: ${debugLogPath}`);
   try {
     claudeAppSupported();
   } catch (err) {
@@ -11321,7 +11909,8 @@ async function runClaudeAppCommand(args) {
       serverPassword: null,
       catalog: createGatewayModelCatalog(serverModels, { maskGatewayIds: true }),
       backends: BACKENDS,
-      gateway: { maskGatewayIds: true }
+      gateway: { maskGatewayIds: true },
+      debugLogPath
     });
     const uuid = writeRelayAiConfig(proxyHandle.port);
     writeSessionLock2({
@@ -11792,7 +12381,7 @@ PROVIDER / MODEL DISCOVERY FOR ALEF CONFIG
   5. relay-ai --ai  (includes live state section at bottom of output)
 
 ALEF CHECKLIST
-  \u25A1 relay-ai on PATH (npm install -g relay-ai; dev: npm link after builds)
+  \u25A1 relay-ai on PATH (npm install -g @jacobbd/relay-ai; dev: npm link after builds)
   \u25A1 Always pass --provider + --model (or provider__model slug) \u2014 never rely on wizard
   \u25A1 Claude: --output-format stream-json (or json) with -p
   \u25A1 Codex: exec --json (not bare codex exec without --json if parsing stdout)
@@ -11998,6 +12587,7 @@ function parseArgs(args) {
     for (const arg of rest) {
       if (arg === "--help" || arg === "-h") parsed2.showHelp = true;
       else if (arg === "--version" || arg === "-v") parsed2.showVersion = true;
+      else if (arg === "--vertex") parsed2.vertex = true;
     }
     return parsed2;
   }
@@ -12018,6 +12608,10 @@ function parseArgs(args) {
         parsed2.trace = true;
         continue;
       }
+      if (arg === "--vertex") {
+        parsed2.vertex = true;
+        continue;
+      }
       if (arg === "--help" || arg === "-h") {
         parsed2.showHelp = true;
         continue;
@@ -12175,7 +12769,7 @@ ${pc16.bold("Behavior:")}
 ${pc16.bold("Vertex env:")}
   ANTHROPIC_VERTEX_PROJECT_ID or GOOGLE_CLOUD_PROJECT \u2014 your GCP project
   GOOGLE_CLOUD_LOCATION or CLOUD_ML_REGION \u2014 region (default: global)
-  Optional catalog: ~/.relay-ai/vertex-models.json (see vertex-models.example.json)
+  Optional catalog: ~/.relay-ai/vertex-models.json (see assets/vertex-models.example.json)
 
 ${pc16.bold("Endpoints:")}
   Anthropic-compatible:  ANTHROPIC_BASE_URL=http://127.0.0.1:17645/anthropic
@@ -12461,9 +13055,13 @@ Error: ${launchPlan.error}
     }
     const providerChoice = chosen;
     if (providerChoice === "__favorites__") {
-      const fav = favorites[0];
-      activeProvider = allProviders.find((p19) => p19.id === fav.providerId);
-      selectedModel = activeProvider.models.find((m) => m.id === fav.modelId);
+      const favoriteStart = resolveFirstAvailableFavorite(favorites, allProviders);
+      if (!favoriteStart) {
+        p18.log.warn("No saved favorites are currently available.");
+        return 0;
+      }
+      activeProvider = favoriteStart.provider;
+      selectedModel = favoriteStart.model;
       p18.log.step(`Loaded Favorites Catalog. Starting model: ${selectedModel.name || selectedModel.id} (${activeProvider.name})`);
     } else {
       activeProvider = allProviders.find((lp) => lp.id === providerChoice);
@@ -12559,7 +13157,11 @@ Error: ${launchPlan.error}
         {
           npm: selectedModel.npm,
           baseURL: selectedModel.apiBaseUrl,
-          upstreamModelId: selectedModel.upstreamModelId
+          upstreamModelId: selectedModel.upstreamModelId,
+          providerId: activeProvider.id,
+          supportedParameters: selectedModel.supportedParameters,
+          reasoning: selectedModel.reasoning,
+          interleavedReasoningField: selectedModel.interleavedReasoningField
         }
       );
       if (!isAgentStdoutMode()) {
@@ -12659,7 +13261,7 @@ Error: ${parsed.error}
       console.log(VERSION);
       return 0;
     }
-    return runCodexAppCommand(parsed.claudeArgs);
+    return runCodexAppCommand(parsed.claudeArgs, { vertex: parsed.vertex });
   }
   if (parsed.command === "claude-app") {
     if (parsed.showVersion) {
@@ -12679,7 +13281,8 @@ Error: ${parsed.error}
     }
     return runCodexCommand(parsed.claudeArgs, parsed.trace, {
       launchProvider: parsed.launchProvider,
-      launchModel: parsed.launchModel
+      launchModel: parsed.launchModel,
+      vertex: parsed.vertex
     });
   }
   if (parsed.showVersion) {