@jacobbd/relay-ai 0.9.2 → 0.9.4

package/dist/{chunk-GQCFLSEM.js → chunk-KDIY732Q.js}

@@ -2,7 +2,7 @@
 import {
   getTemplateById,
   init_provider_templates
-} from "./chunk-Q2FTCICO.js";
+} from "./chunk-NYKVDBQC.js";
 
 // src/constants.ts
 import { homedir } from "os";
@@ -11,7 +11,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@jacobbd/relay-ai",
-  version: "0.9.2",
+  version: "0.9.4",
   publishConfig: {
     access: "public"
   },
@@ -385,9 +385,7 @@ function createResponsesLiteNormalizeState() {
     textDeltaForwarded: false,
     messageAddedIds: /* @__PURE__ */ new Set(),
     messageDoneIds: /* @__PURE__ */ new Set(),
-    functionAddedIndexes: /* @__PURE__ */ new Set(),
-    functionDeltaIndexes: /* @__PURE__ */ new Set(),
-    functionDoneCallIds: /* @__PURE__ */ new Set()
+    functionCalls: []
   };
 }
 function nextId(state, prefix) {
@@ -411,20 +409,92 @@ function normalizeErrorEvent(event) {
     }
   };
 }
-function normalizeFunctionItem(item, state, forDone = false) {
-  const callId = asString(item.call_id) ?? asString(item.id) ?? nextId(state, "call");
-  const id = asString(item.id) ?? nextId(state, "fc");
-  state.lastFunctionItemId = id;
+function resolveFunctionCall(state, hint) {
+  if (hint.callId) {
+    const byCallId = state.functionCalls.find((entry2) => entry2.callId === hint.callId);
+    if (byCallId) return byCallId;
+  }
+  if (hint.itemId) {
+    const byItemId = state.functionCalls.find((entry2) => entry2.itemId === hint.itemId);
+    if (byItemId) return byItemId;
+  }
+  if (hint.outputIndex !== void 0) {
+    const open4 = [...state.functionCalls].reverse().find((entry2) => entry2.outputIndex === hint.outputIndex && !entry2.done && !(hint.callId && entry2.callId !== hint.callId));
+    if (open4) return open4;
+  }
+  if (hint.callId === void 0 && hint.itemId === void 0 && hint.outputIndex === void 0 && state.lastFunctionCall) {
+    return state.lastFunctionCall;
+  }
+  const entry = {
+    itemId: hint.itemId ?? nextId(state, "fc"),
+    callId: hint.callId ?? hint.itemId ?? nextId(state, "call"),
+    name: "",
+    args: "",
+    upstream: {},
+    outputIndex: hint.outputIndex ?? state.lastOutputIndex,
+    added: false,
+    deltaForwarded: false,
+    doneSeen: false,
+    done: false
+  };
+  state.functionCalls.push(entry);
+  return entry;
+}
+function absorbFunctionItem(entry, item, authoritative) {
+  entry.upstream = { ...entry.upstream, ...item };
+  const name = asString(item.name);
+  if (name) entry.name = name;
+  const callId = asString(item.call_id);
+  if (callId) entry.callId = callId;
+  if (authoritative && typeof item.arguments === "string") entry.upstreamArgs = item.arguments;
+}
+function resolveFunctionArgs(entry) {
+  if (entry.upstreamArgs) return entry.upstreamArgs;
+  if (entry.args) return entry.args;
+  return entry.upstreamArgs;
+}
+function functionItemPayload(entry, extra) {
   return {
-    ...item,
+    ...entry.upstream,
     type: "function_call",
-    id,
-    call_id: callId,
-    name: asString(item.name) ?? "",
-    arguments: typeof item.arguments === "string" ? item.arguments : "",
-    ...forDone ? { status: "completed" } : {}
+    id: entry.itemId,
+    call_id: entry.callId,
+    name: entry.name,
+    ...extra
+  };
+}
+function functionAddedEvent(entry) {
+  entry.added = true;
+  return {
+    type: "response.output_item.added",
+    output_index: entry.outputIndex,
+    item: functionItemPayload(entry, { arguments: "" })
+  };
+}
+function functionDoneEvent(entry, args) {
+  entry.done = true;
+  return {
+    type: "response.output_item.done",
+    output_index: entry.outputIndex,
+    item: functionItemPayload(entry, { arguments: args, status: "completed" })
   };
 }
+function completeFunctionCall(entry, args) {
+  if (entry.done) return [];
+  const events = [];
+  if (!entry.added) events.push(functionAddedEvent(entry));
+  if (!entry.deltaForwarded && args.length > 0) {
+    entry.deltaForwarded = true;
+    events.push({
+      type: "response.function_call_arguments.delta",
+      item_id: entry.itemId,
+      output_index: entry.outputIndex,
+      delta: args
+    });
+  }
+  events.push(functionDoneEvent(entry, args));
+  return events;
+}
 function messageText(item) {
   if (typeof item.text === "string") return item.text;
   if (!Array.isArray(item.content)) return "";
@@ -451,47 +521,43 @@ function synthesizeMessage(item, outputIndex, state) {
   ];
 }
 function synthesizeFunctionCall(item, outputIndex, state) {
-  const normalized = normalizeFunctionItem(item, state);
-  const callId = String(normalized.call_id);
-  if (state.functionDoneCallIds.has(callId)) return [];
-  const events = [];
-  if (!state.functionAddedIndexes.has(outputIndex)) {
-    events.push({
-      type: "response.output_item.added",
-      output_index: outputIndex,
-      item: { ...normalized, arguments: "" }
-    });
-    state.functionAddedIndexes.add(outputIndex);
-  }
-  if (!state.functionDeltaIndexes.has(outputIndex) && typeof normalized.arguments === "string" && normalized.arguments.length > 0) {
-    events.push({
-      type: "response.function_call_arguments.delta",
-      item_id: normalized.id,
-      output_index: outputIndex,
-      delta: normalized.arguments
-    });
-    state.functionDeltaIndexes.add(outputIndex);
-  }
-  events.push({
-    type: "response.output_item.done",
-    output_index: outputIndex,
-    item: { ...normalized, status: "completed" }
+  const entry = resolveFunctionCall(state, {
+    itemId: asString(item.id),
+    callId: asString(item.call_id),
+    outputIndex
   });
-  state.functionDoneCallIds.add(callId);
-  state.lastOutputIndex = outputIndex;
-  return events;
+  absorbFunctionItem(entry, item, true);
+  state.lastFunctionCall = entry;
+  state.lastOutputIndex = entry.outputIndex;
+  const args = resolveFunctionArgs(entry);
+  if (args === void 0) {
+    entry.doneSeen = true;
+    return [];
+  }
+  return completeFunctionCall(entry, args);
 }
 function recoverFromCompletedOutput(response, state) {
-  if (!Array.isArray(response.output)) return [];
   const recovered = [];
-  response.output.forEach((item, index) => {
-    if (!isRecord(item) || typeof item.type !== "string") return;
-    if (item.type === "message" && !state.textDeltaForwarded) {
-      recovered.push(...synthesizeMessage(item, index, state));
-    } else if (item.type === "function_call") {
-      recovered.push(...synthesizeFunctionCall(item, index, state));
-    }
-  });
+  if (Array.isArray(response.output)) {
+    response.output.forEach((item, index) => {
+      if (!isRecord(item) || typeof item.type !== "string") return;
+      if (item.type === "message" && !state.textDeltaForwarded) {
+        recovered.push(...synthesizeMessage(item, index, state));
+      } else if (item.type === "function_call") {
+        recovered.push(...synthesizeFunctionCall(item, index, state));
+      }
+    });
+  }
+  for (const entry of state.functionCalls) {
+    if (entry.done || !entry.doneSeen) continue;
+    recovered.push(normalizeErrorEvent({
+      error: {
+        type: "invalid_response",
+        code: "incomplete_function_call",
+        message: `Provider ended the response without arguments for function call "${entry.callId}"${entry.name ? ` (${entry.name})` : ""}.`
+      }
+    }));
+  }
   return recovered;
 }
 function normalizeResponsesLiteEvent(event, state) {
@@ -507,19 +573,40 @@ function normalizeResponsesLiteEvent(event, state) {
       return [{ ...event, output_index: outputIndex, item: { ...event.item, id } }];
     }
     if (event.item.type === "function_call") {
-      const item = normalizeFunctionItem(event.item, state);
-      state.functionAddedIndexes.add(outputIndex);
-      return [{ ...event, output_index: outputIndex, item }];
+      const entry = resolveFunctionCall(state, {
+        itemId: asString(event.item.id),
+        callId: asString(event.item.call_id),
+        outputIndex
+      });
+      absorbFunctionItem(entry, event.item, false);
+      entry.outputIndex = outputIndex;
+      entry.added = true;
+      state.lastFunctionCall = entry;
+      return [{ ...event, output_index: outputIndex, item: functionItemPayload(entry, { arguments: "" }) }];
     }
     return [{ ...event, output_index: outputIndex }];
   }
   if (event.type === "response.output_item.done" && isRecord(event.item)) {
     const outputIndex = typeof event.output_index === "number" ? event.output_index : state.lastOutputIndex;
     if (event.item.type === "function_call") {
-      const item = normalizeFunctionItem(event.item, state, true);
-      const callId = String(item.call_id);
-      state.functionDoneCallIds.add(callId);
-      return [{ ...event, output_index: outputIndex, item }];
+      const entry = resolveFunctionCall(state, {
+        itemId: asString(event.item.id),
+        callId: asString(event.item.call_id),
+        outputIndex
+      });
+      absorbFunctionItem(entry, event.item, true);
+      entry.outputIndex = outputIndex;
+      entry.doneSeen = true;
+      state.lastFunctionCall = entry;
+      state.lastOutputIndex = outputIndex;
+      const args = resolveFunctionArgs(entry);
+      if (args === void 0 || !entry.name) return [];
+      if (entry.done) return [];
+      const events = [];
+      if (!entry.added) events.push(functionAddedEvent(entry));
+      events.push({ ...event, output_index: outputIndex, item: functionItemPayload(entry, { arguments: args, status: "completed" }) });
+      entry.done = true;
+      return events;
     }
     if (event.item.type === "message") {
       const id = asString(event.item.id) ?? state.lastMessageItemId ?? nextId(state, "msg");
@@ -546,12 +633,16 @@ function normalizeResponsesLiteEvent(event, state) {
     return events;
   }
   if (event.type === "response.function_call_arguments.delta") {
-    const itemId = asString(event.item_id) ?? state.lastFunctionItemId ?? nextId(state, "fc");
-    const outputIndex = typeof event.output_index === "number" ? event.output_index : state.lastOutputIndex;
-    state.lastFunctionItemId = itemId;
-    state.lastOutputIndex = outputIndex;
-    state.functionDeltaIndexes.add(outputIndex);
-    return [{ ...event, item_id: itemId, output_index: outputIndex, delta: typeof event.delta === "string" ? event.delta : "" }];
+    const entry = resolveFunctionCall(state, {
+      itemId: asString(event.item_id),
+      outputIndex: typeof event.output_index === "number" ? event.output_index : void 0
+    });
+    const delta = typeof event.delta === "string" ? event.delta : "";
+    entry.args += delta;
+    entry.deltaForwarded = true;
+    state.lastFunctionCall = entry;
+    state.lastOutputIndex = entry.outputIndex;
+    return [{ ...event, item_id: entry.itemId, output_index: entry.outputIndex, delta }];
   }
   if (event.type === "response.completed" || event.type === "response.incomplete") {
     const response = isRecord(event.response) ? event.response : {};
@@ -1051,10 +1142,11 @@ async function createLanguageModel(spec) {
   return model;
 }
 var ANTHROPIC_EFFORT_LEVELS = ["low", "medium", "high"];
-var OPENAI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh"];
+var OPENAI_EFFORT_LEVELS = ["low", "medium", "high"];
 var GEMINI_EFFORT_LEVELS = ["low", "medium", "high"];
 var MISTRAL_EFFORT_LEVELS = ["high", "off"];
-var XAI_EFFORT_LEVELS = ["none", "low", "medium", "high"];
+var XAI_CHAT_EFFORT_LEVELS = ["low", "high"];
+var XAI_RESPONSES_EFFORT_LEVELS = ["low", "medium", "high"];
 var OPENROUTER_EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"];
 var DEEPSEEK_EFFORT_LEVELS = ["high", "max", "off"];
 var GLM_52_EFFORT_LEVELS = ["high", "xhigh"];
@@ -1225,7 +1317,50 @@ function mapCodexEffortToAnthropic(effort) {
       return void 0;
   }
 }
-function mapCodexEffortToOpenAI(effort) {
+var OPENAI_MODEL_REASONING = {
+  "gpt-5-pro": { levels: ["high"], defaultLevel: "high" },
+  "gpt-5.1": { levels: ["none", "low", "medium", "high"], defaultLevel: "none" },
+  "gpt-5.1-codex-max": { levels: ["low", "medium", "high", "xhigh"], defaultLevel: "medium" },
+  "gpt-5.2": { levels: ["none", "low", "medium", "high", "xhigh"], defaultLevel: "none" },
+  "gpt-5.2-codex": { levels: ["low", "medium", "high", "xhigh"], defaultLevel: "medium" },
+  "gpt-5.2-pro": { levels: ["medium", "high", "xhigh"], defaultLevel: "medium" },
+  "gpt-5.3-codex": { levels: ["low", "medium", "high", "xhigh"], defaultLevel: "medium" },
+  "gpt-5.4": { levels: ["none", "low", "medium", "high", "xhigh"], defaultLevel: "none" },
+  "gpt-5.4-mini": { levels: ["none", "low", "medium", "high", "xhigh"], defaultLevel: "none" },
+  "gpt-5.4-nano": { levels: ["none", "low", "medium", "high", "xhigh"], defaultLevel: "none" },
+  "gpt-5.4-pro": { levels: ["medium", "high", "xhigh"], defaultLevel: "medium" },
+  "gpt-5.5": { levels: ["none", "low", "medium", "high", "xhigh"], defaultLevel: "medium" },
+  "gpt-5.5-pro": { levels: ["medium", "high", "xhigh"], defaultLevel: "high" },
+  "gpt-5.6": { levels: ["none", "low", "medium", "high", "xhigh", "max"], defaultLevel: "medium" },
+  "gpt-5.6-luna": { levels: ["none", "low", "medium", "high", "xhigh", "max"], defaultLevel: "medium" },
+  "gpt-5.6-sol": { levels: ["none", "low", "medium", "high", "xhigh", "max"], defaultLevel: "medium" },
+  "gpt-5.6-terra": { levels: ["none", "low", "medium", "high", "xhigh", "max"], defaultLevel: "medium" }
+};
+var OPENAI_NON_REASONING_MODELS = /* @__PURE__ */ new Set([
+  "chat-latest",
+  "gpt-5-chat-latest",
+  "gpt-5.1-chat-latest",
+  "gpt-5.2-chat-latest",
+  "gpt-5.3-chat-latest"
+]);
+var OPENAI_DATED_SNAPSHOT_SUFFIX = /-\d{4}-\d{2}-\d{2}$/;
+function canonicalOpenAiModelId(modelId, metadata) {
+  return (metadata?.upstreamModelId ?? modelId ?? "").toLowerCase();
+}
+function openAiReasoningProfile(modelId, metadata) {
+  const id = canonicalOpenAiModelId(modelId, metadata);
+  if (!id) return void 0;
+  return OPENAI_MODEL_REASONING[id] ?? OPENAI_MODEL_REASONING[id.replace(OPENAI_DATED_SNAPSHOT_SUFFIX, "")];
+}
+function openAiModelReasons(modelId, metadata) {
+  const id = canonicalOpenAiModelId(modelId, metadata);
+  if (OPENAI_NON_REASONING_MODELS.has(id.replace(OPENAI_DATED_SNAPSHOT_SUFFIX, ""))) return false;
+  return !!openAiReasoningProfile(modelId, metadata) || modelPrefersResponsesApi(id) || !!metadata?.reasoning;
+}
+function mapCodexEffortToOpenAI(effort, allowed) {
+  return allowed.includes(effort) ? effort : void 0;
+}
+function mapCodexEffortToOpenAICompatible(effort) {
   if (effort === "xhigh") return "high";
   const allowed = ["low", "medium", "high"];
   return allowed.includes(effort) ? effort : void 0;
@@ -1241,16 +1376,12 @@ function mapCodexEffortToGlm52(effort) {
       return void 0;
   }
 }
-function mapCodexEffortToXai(effort) {
+function mapCodexEffortToXai(effort, supportsMedium) {
   switch (effort) {
-    case "none":
-    case "minimal":
-      return void 0;
-    // xAI SDK only accepts 'low'|'high'; omit param for 'none'
     case "low":
-    case "medium":
       return "low";
-    // 'medium' has no xAI equivalent — nearest valid value
+    case "medium":
+      return supportsMedium ? "medium" : void 0;
     case "high":
     case "xhigh":
     case "max":
@@ -1282,7 +1413,31 @@ function mapCodexEffortToGeminiBudget(effort) {
   if (!level) return void 0;
   return GEMINI_25_BUDGETS[level];
 }
+function withMappableLevels(caps, npm, modelId, metadata) {
+  if (caps.mode !== "controllable") return caps;
+  const seen = /* @__PURE__ */ new Set();
+  const levels = caps.levels.filter((level) => {
+    const mapped = effortProviderOptions(npm, level, modelId, metadata);
+    if (mapped === void 0) return false;
+    const wire = JSON.stringify(mapped);
+    if (seen.has(wire)) return false;
+    seen.add(wire);
+    return true;
+  });
+  if (levels.length === caps.levels.length) return caps;
+  if (levels.length === 0) {
+    return { ...caps, levels: [], defaultLevel: "", mode: "internal-only" };
+  }
+  return {
+    ...caps,
+    levels,
+    defaultLevel: levels.includes(caps.defaultLevel) ? caps.defaultLevel : levels[levels.length - 1]
+  };
+}
 function getReasoningCapabilities(npm, modelId, metadata) {
+  return withMappableLevels(resolveRawReasoningCapabilities(npm, modelId, metadata), npm, modelId, metadata);
+}
+function resolveRawReasoningCapabilities(npm, modelId, metadata) {
   const id = modelId.toLowerCase();
   if (isOpenRouterRoute(npm, metadata)) {
     return openRouterReasoningCapabilities(metadata);
@@ -1303,15 +1458,18 @@ function getReasoningCapabilities(npm, modelId, metadata) {
     return EMPTY_REASONING;
   }
   if (npm === "@ai-sdk/openai" || npm === "@ai-sdk/azure") {
-    const prefersResponses = modelPrefersResponsesApi(modelId);
-    if (prefersResponses || metadata?.reasoning) {
+    const canonicalId = canonicalOpenAiModelId(modelId, metadata);
+    const profile = openAiReasoningProfile(modelId, metadata);
+    const prefersResponses = modelPrefersResponsesApi(canonicalId);
+    if (openAiModelReasons(modelId, metadata) && shouldUseOpenAiResponsesEndpoint(canonicalId)) {
+      const levels = profile?.levels ?? [...OPENAI_EFFORT_LEVELS];
       return {
-        levels: [...OPENAI_EFFORT_LEVELS],
-        defaultLevel: "medium",
+        levels: [...levels],
+        defaultLevel: profile?.defaultLevel ?? (levels.includes("medium") ? "medium" : levels[levels.length - 1]),
         supportsSummaries: true,
+        source: profile || prefersResponses ? "provider-rule" : "model-metadata",
+        confidence: profile || prefersResponses ? "documented" : "inferred",
         mode: "controllable",
-        source: prefersResponses ? "provider-rule" : "model-metadata",
-        confidence: prefersResponses ? "documented" : "inferred",
         wireFormat: { kind: "openai-reasoning-effort" }
       };
     }
@@ -1347,7 +1505,7 @@ function getReasoningCapabilities(npm, modelId, metadata) {
   }
   if (npm === "@ai-sdk/xai") {
     if (isXaiReasoningEffortModel(modelId)) {
-      const levels = modelPrefersResponsesApi(modelId) ? ["low", "medium", "high", "xhigh"] : [...XAI_EFFORT_LEVELS];
+      const levels = modelPrefersResponsesApi(modelId) ? [...XAI_RESPONSES_EFFORT_LEVELS] : [...XAI_CHAT_EFFORT_LEVELS];
       return {
         levels,
         defaultLevel: xaiDefaultReasoningEffort(modelId),
@@ -1444,13 +1602,15 @@ function effortProviderOptions(npm, effort, modelId, metadata) {
     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);
+    if (!modelId || !shouldUseOpenAiResponsesEndpoint(canonicalOpenAiModelId(modelId, metadata))) return void 0;
+    if (!openAiModelReasons(modelId, metadata)) return void 0;
+    const allowed = openAiReasoningProfile(modelId, metadata)?.levels ?? OPENAI_EFFORT_LEVELS;
+    const reasoningEffort = mapCodexEffortToOpenAI(effort, allowed);
     return reasoningEffort ? { openai: { reasoningEffort } } : void 0;
   }
   if (npm === "@ai-sdk/xai") {
     if (!modelId || !isXaiReasoningEffortModel(modelId)) return void 0;
-    const reasoningEffort = mapCodexEffortToXai(effort);
+    const reasoningEffort = mapCodexEffortToXai(effort, modelPrefersResponsesApi(modelId));
     return reasoningEffort ? { xai: { reasoningEffort } } : void 0;
   }
   if (npm === "@ai-sdk/anthropic" || npm === VERTEX_ANTHROPIC_NPM) {
@@ -1478,7 +1638,7 @@ function effortProviderOptions(npm, effort, modelId, metadata) {
       return deepSeekEffortProviderOptions(effort);
     }
     if (isKimiReasoningModel(modelId)) {
-      const reasoningEffort = mapCodexEffortToOpenAI(effort);
+      const reasoningEffort = mapCodexEffortToOpenAICompatible(effort);
       if (reasoningEffort) {
         const key = metadata?.providerId ? toCamelCase(metadata.providerId) : "openaiCompatible";
         return { [key]: { reasoningEffort } };
@@ -1494,7 +1654,7 @@ function effortProviderOptions(npm, effort, modelId, metadata) {
       return void 0;
     }
     if (hasSupportedParameter(metadata, "reasoning_effort")) {
-      const reasoningEffort = mapCodexEffortToOpenAI(effort);
+      const reasoningEffort = mapCodexEffortToOpenAICompatible(effort);
       return reasoningEffort ? { openai: { reasoningEffort }, openaiCompatible: { reasoningEffort } } : void 0;
     }
     if (hasSupportedParameter(metadata, "reasoning")) {
@@ -3586,8 +3746,11 @@ function buildChildEnv(baseUrl, model, apiKey, proxyPort, contextWindow2, enable
   env["ANTHROPIC_API_KEY"] = apiKey;
   const bareModel = stripOneMContextSuffix(model);
   env["ANTHROPIC_MODEL"] = claudeCodeClientModelId(model, contextWindow2);
-  env["CLAUDE_CODE_MAX_CONTEXT_TOKENS"] = String(resolveContextWindow(bareModel, contextWindow2));
+  if (!enableGatewayDiscovery) {
+    env["CLAUDE_CODE_MAX_CONTEXT_TOKENS"] = String(resolveContextWindow(bareModel, contextWindow2));
+  }
   if (enableGatewayDiscovery) {
+    delete env["CLAUDE_CODE_MAX_CONTEXT_TOKENS"];
     env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1";
   }
   applyClaudeCodeThirdPartyCompat(env);
@@ -6929,8 +7092,8 @@ function anthropicError(res, status, message) {
   });
 }
 function aliasModelId(realId, providerId) {
-  if (realId.startsWith("claude-")) return realId;
   const sanitized = providerId.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (realId.startsWith("claude-") && !sanitized.startsWith("custom-")) return realId;
   return `anthropic-${sanitized}__${realId}`;
 }
 function buildProxySubagentModelRouting(routes, parentRoute) {
@@ -9244,6 +9407,80 @@ function goRegistryStub() {
   };
 }
 
+// src/registry/fetch-anthropic-models.ts
+async function fetchAnthropicModels(baseUrl, apiKey, extraHeaders) {
+  const root = baseUrl.replace(/\/v1\/?$/, "").replace(/\/$/, "");
+  const modelsUrl2 = `${root}/v1/models`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const response = await fetch(modelsUrl2, {
+      method: "GET",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        Accept: "application/json",
+        ...extraHeaders
+      },
+      redirect: "manual",
+      signal: controller.signal
+    });
+    let logTrace;
+    if (process.env.RELAY_AI_TRACE === "1") {
+      logTrace = makeTraceLogger(getProviderDebugLogPath());
+    }
+    const rawBodyText = await response.text().catch(() => "");
+    if (logTrace) {
+      logTrace(`[fetchAnthropicModels] HTTP ${response.status} from ${modelsUrl2}`);
+      logTrace(`[fetchAnthropicModels] Body: ${rawBodyText}`);
+    }
+    if (response.ok) {
+      let json = {};
+      try {
+        if (rawBodyText.trim()) {
+          json = JSON.parse(rawBodyText);
+        }
+      } catch {
+      }
+      const models = [];
+      for (const row of json.data ?? []) {
+        const id = row.id?.trim();
+        if (!id) continue;
+        models.push({
+          id,
+          name: row.name?.trim() || id,
+          upstreamModelId: id,
+          family: id.split("-")[0] ?? id,
+          brand: deriveBrand(id),
+          contextWindow: resolveContextWindow(id),
+          modelFormat: "anthropic",
+          npm: "@ai-sdk/anthropic",
+          apiUrl: root
+        });
+      }
+      if (models.length > 0) return { models, baseUrl: root };
+    }
+    if (response.status === 401 || response.status === 403) {
+      return { models: [], baseUrl: root, error: "API key was rejected.", hint: "Check your Anthropic-compatible API key." };
+    }
+    return {
+      models: [],
+      baseUrl: root,
+      error: `Could not list models (HTTP ${response.status}).`,
+      hint: "Verify the base URL supports Anthropic-compatible /v1/models or try the OpenAI-compatible option instead."
+    };
+  } catch {
+    return {
+      models: [],
+      baseUrl: root,
+      error: "Could not reach the Anthropic-compatible server.",
+      hint: "Check the base URL and that the server is running."
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/registry/fetch-template-models.ts
 var TEST_TIMEOUT_MS = 1e4;
 function modelFormatForNpm(npm) {
@@ -9604,77 +9841,28 @@ function npmForKind(kind) {
 function modelFormatForKind(kind) {
   return kind === "anthropic" ? "anthropic" : "openai";
 }
-async function fetchAnthropicModels(baseUrl, apiKey, extraHeaders) {
-  const root = baseUrl.replace(/\/v1\/?$/, "").replace(/\/$/, "");
-  const modelsUrl2 = `${root}/v1/models`;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 1e4);
-  try {
-    const response = await fetch(modelsUrl2, {
-      method: "GET",
-      headers: {
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01",
-        Accept: "application/json",
-        ...extraHeaders
-      },
-      redirect: "manual",
-      signal: controller.signal
-    });
-    let logTrace;
-    if (process.env.RELAY_AI_TRACE === "1") {
-      logTrace = makeTraceLogger(getProviderDebugLogPath());
-    }
-    const rawBodyText = await response.text().catch(() => "");
-    if (logTrace) {
-      logTrace(`[fetchAnthropicModels] HTTP ${response.status} from ${modelsUrl2}`);
-      logTrace(`[fetchAnthropicModels] Body: ${rawBodyText}`);
-    }
-    if (response.ok) {
-      let json = {};
-      try {
-        if (rawBodyText.trim()) {
-          json = JSON.parse(rawBodyText);
-        }
-      } catch {
-      }
-      const models = [];
-      for (const row of json.data ?? []) {
-        const id = row.id?.trim();
-        if (!id) continue;
-        models.push({
-          id,
-          name: row.name?.trim() || id,
-          upstreamModelId: id,
-          family: id.split("-")[0] ?? id,
-          brand: deriveBrand(id),
-          contextWindow: resolveContextWindow(id),
-          modelFormat: "anthropic",
-          npm: "@ai-sdk/anthropic",
-          apiUrl: root
-        });
-      }
-      if (models.length > 0) return { models, baseUrl: root };
-    }
-    if (response.status === 401 || response.status === 403) {
-      return { models: [], baseUrl: root, error: "API key was rejected.", hint: "Check your Anthropic-compatible API key." };
-    }
-    return {
-      models: [],
-      baseUrl: root,
-      error: `Could not list models (HTTP ${response.status}).`,
-      hint: "Verify the base URL supports Anthropic-compatible /v1/models or try the OpenAI-compatible option instead."
-    };
-  } catch {
-    return {
-      models: [],
-      baseUrl: root,
-      error: "Could not reach the Anthropic-compatible server.",
-      hint: "Check the base URL and that the server is running."
-    };
-  } finally {
-    clearTimeout(timer);
+function customEndpointKind(provider) {
+  if (provider.templateId === "custom-anthropic") return "anthropic";
+  if (provider.templateId === "custom-openai") return "openai";
+  return null;
+}
+function sameHeaders(a, b) {
+  const norm = (h) => JSON.stringify(Object.entries(h ?? {}).sort(([x], [y]) => x.localeCompare(y)));
+  return norm(a) === norm(b);
+}
+function compareableUrl(url) {
+  return url.replace(/\/v1\/?$/, "").replace(/\/$/, "");
+}
+async function findDuplicateCustomProvider(registry, normalizedUrl, apiKey, headers) {
+  const target = compareableUrl(normalizedUrl);
+  for (const existing of registry.providers) {
+    if (!customEndpointKind(existing)) continue;
+    if (compareableUrl(existing.api.url ?? "") !== target) continue;
+    if (!sameHeaders(existing.api.headers, headers)) continue;
+    const storedKey = await readStoredProviderCredential(existing.authRef);
+    if ((storedKey ?? "") === apiKey) return existing.id;
   }
+  return null;
 }
 function uniqueProviderId(displayName, registry) {
   let base = customProviderId(displayName);
@@ -9689,6 +9877,25 @@ function uniqueProviderId(displayName, registry) {
   }
   return `${base}-${Date.now()}`;
 }
+async function fetchCustomEndpointModels(input) {
+  if (input.kind === "anthropic") {
+    return fetchAnthropicModels(input.normalizedBaseUrl, input.apiKey, input.headers);
+  }
+  return fetchTemplateModels(
+    {
+      id: input.providerId,
+      name: input.displayName,
+      authType: input.apiKey === "local" ? "none" : "api",
+      npm: npmForKind(input.kind),
+      defaultBaseUrl: input.normalizedBaseUrl,
+      modelSource: "api-list",
+      supported: true
+    },
+    input.apiKey,
+    input.normalizedBaseUrl,
+    input.headers
+  );
+}
 async function addCustomEndpointProvider(input) {
   const urlCheck = await validateCustomEndpointUrl(input.baseUrl, {
     allowInsecureLocal: input.allowInsecureLocal
@@ -9697,29 +9904,34 @@ async function addCustomEndpointProvider(input) {
     return { added: false, error: urlCheck.error, hint: urlCheck.hint };
   }
   const registry = loadRegistry();
-  const providerId = uniqueProviderId(input.displayName.trim(), registry);
-  const npm = npmForKind(input.kind);
   const apiKey = input.apiKey.trim() || "local";
   const headers = input.headers && Object.keys(input.headers).length > 0 ? input.headers : void 0;
-  let fetched;
-  if (input.kind === "anthropic") {
-    fetched = await fetchAnthropicModels(urlCheck.normalizedUrl, apiKey, headers);
-  } else {
-    fetched = await fetchTemplateModels(
-      {
-        id: providerId,
-        name: input.displayName,
-        authType: apiKey === "local" ? "none" : "api",
-        npm,
-        defaultBaseUrl: urlCheck.normalizedUrl,
-        modelSource: "api-list",
-        supported: true
-      },
-      apiKey,
+  if (!input.confirmDuplicate) {
+    const duplicateOf = await findDuplicateCustomProvider(
+      registry,
       urlCheck.normalizedUrl,
+      apiKey,
       headers
     );
+    if (duplicateOf) {
+      return {
+        added: false,
+        duplicateOf,
+        error: `A backend with the same URL, key and headers already exists (${duplicateOf}).`,
+        hint: "Add it anyway to keep both, or cancel."
+      };
+    }
   }
+  const providerId = uniqueProviderId(input.displayName.trim(), registry);
+  const npm = npmForKind(input.kind);
+  const fetched = await fetchCustomEndpointModels({
+    providerId,
+    displayName: input.displayName,
+    kind: input.kind,
+    normalizedBaseUrl: urlCheck.normalizedUrl,
+    apiKey,
+    headers
+  });
   if (fetched.error || fetched.models.length === 0) {
     return { added: false, error: fetched.error ?? "No models returned.", hint: fetched.hint };
   }
@@ -9756,6 +9968,115 @@ async function addCustomEndpointProvider(input) {
   saveRegistry(registry);
   return { added: true, provider: entry, modelCount: fetched.models.length };
 }
+async function updateCustomEndpointProvider(input) {
+  const registry = loadRegistry();
+  const provider = registry.providers.find((pr) => pr.id === input.providerId);
+  if (!provider) {
+    return { updated: false, error: `Provider not found: ${input.providerId}` };
+  }
+  const kind = customEndpointKind(provider);
+  if (!kind) {
+    return {
+      updated: false,
+      error: "Edit is only available for custom backends.",
+      hint: "Template providers can only change their API key."
+    };
+  }
+  const nextName = input.displayName?.trim();
+  let nextBaseUrl = provider.api.url ?? "";
+  let urlChanged = false;
+  const requestedUrl = input.baseUrl?.trim();
+  if (requestedUrl) {
+    const urlCheck = await validateCustomEndpointUrl(requestedUrl, {
+      allowInsecureLocal: input.allowInsecureLocal
+    });
+    if (!urlCheck.ok || !urlCheck.normalizedUrl) {
+      return { updated: false, error: urlCheck.error, hint: urlCheck.hint };
+    }
+    urlChanged = urlCheck.normalizedUrl !== nextBaseUrl;
+    nextBaseUrl = urlCheck.normalizedUrl;
+  }
+  const newKey = input.apiKey?.trim();
+  const headersChanged = input.headers !== void 0 && !sameHeaders(input.headers, provider.api.headers);
+  const nextHeaders = input.headers !== void 0 ? Object.keys(input.headers).length > 0 ? input.headers : void 0 : provider.api.headers;
+  const nameChanged = Boolean(nextName) && nextName !== provider.name;
+  const needsTest = urlChanged || Boolean(newKey) || headersChanged;
+  if (!needsTest) {
+    if (!nameChanged) return { updated: false, error: "Nothing to change." };
+    provider.name = nextName;
+    saveRegistry(registry);
+    return {
+      updated: true,
+      provider,
+      modelCount: provider.modelsCache?.models.length ?? 0
+    };
+  }
+  const apiKey = newKey || await readStoredProviderCredential(provider.authRef) || "";
+  if (!apiKey) {
+    return {
+      updated: false,
+      error: "No stored API key was found for this backend.",
+      hint: "Enter an API key to continue."
+    };
+  }
+  const fetched = await fetchCustomEndpointModels({
+    providerId: provider.id,
+    displayName: nextName || provider.name,
+    kind,
+    normalizedBaseUrl: nextBaseUrl,
+    apiKey,
+    headers: nextHeaders
+  });
+  const testFailed = Boolean(fetched.error) || fetched.models.length === 0;
+  if (testFailed && !input.saveAnyway) {
+    return {
+      updated: false,
+      error: fetched.error ?? "No models returned.",
+      hint: fetched.hint,
+      canSaveAnyway: true
+    };
+  }
+  if (newKey) {
+    const saved = await saveProviderCredential(provider.authRef, newKey);
+    if (!saved) {
+      return {
+        updated: false,
+        error: "Could not save API key to credential store.",
+        hint: "Grant Keychain access, or ensure RELAY_AI_HOME is writable (file fallback)."
+      };
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (nameChanged) provider.name = nextName;
+  const storedBaseUrl = kind === "anthropic" ? nextBaseUrl.replace(/\/v1\/?$/, "").replace(/\/$/, "") : nextBaseUrl;
+  provider.api.url = testFailed ? storedBaseUrl : fetched.baseUrl || storedBaseUrl;
+  if (nextHeaders) provider.api.headers = nextHeaders;
+  else delete provider.api.headers;
+  if (!testFailed) {
+    provider.modelsCache = {
+      fetchedAt: now,
+      models: fetched.models.map((m) => ({
+        ...m,
+        modelFormat: modelFormatForKind(kind),
+        npm: npmForKind(kind),
+        apiUrl: fetched.baseUrl || storedBaseUrl
+      }))
+    };
+    provider.refreshedAt = now;
+  } else if (provider.modelsCache) {
+    provider.modelsCache = {
+      ...provider.modelsCache,
+      models: provider.modelsCache.models.map((m) => ({ ...m, apiUrl: storedBaseUrl }))
+    };
+  }
+  saveRegistry(registry);
+  return {
+    updated: true,
+    provider,
+    modelCount: provider.modelsCache?.models.length ?? 0,
+    ...testFailed ? { modelsStale: true } : {}
+  };
+}
 
 // src/registry/fetch-cline-pass-models.ts
 var REQUEST_TIMEOUT_MS = 1e4;
@@ -10283,7 +10604,7 @@ async function refreshApiListProvider(provider, apiKey) {
   const templateDefault = catalogTemplate?.defaultBaseUrl?.trim();
   if (configuredUrl && configuredUrl !== templateDefault) {
     const urlCheck = await validateCustomEndpointUrl(baseUrl, {
-      allowInsecureLocal: catalogTemplate?.apiKeyOptional === true
+      allowInsecureLocal: catalogTemplate?.apiKeyOptional === true || customEndpointKind(provider) !== null
     });
     if (!urlCheck.ok || !urlCheck.normalizedUrl) {
       return { models: [], error: `${urlCheck.error ?? "Invalid API base URL."} ${urlCheck.hint ?? ""}`.trim() };
@@ -10291,8 +10612,9 @@ async function refreshApiListProvider(provider, apiKey) {
     safeBaseUrl = urlCheck.normalizedUrl;
   }
   const template = catalogTemplate ?? syntheticTemplate(provider, safeBaseUrl);
+  const extraHeaders = provider.api.headers && Object.keys(provider.api.headers).length > 0 ? provider.api.headers : void 0;
   if (npm === "@ai-sdk/anthropic") {
-    const fetched2 = await fetchAnthropicModels(safeBaseUrl, apiKey);
+    const fetched2 = await fetchAnthropicModels(safeBaseUrl, apiKey, extraHeaders);
     if (fetched2.error || fetched2.models.length === 0) {
       return { models: [], error: fetched2.error ?? "No models returned.", baseUrl: fetched2.baseUrl };
     }
@@ -10301,7 +10623,7 @@ async function refreshApiListProvider(provider, apiKey) {
       baseUrl: fetched2.baseUrl
     };
   }
-  const fetched = await fetchTemplateModels(template, apiKey, safeBaseUrl);
+  const fetched = await fetchTemplateModels(template, apiKey, safeBaseUrl, extraHeaders);
   if (fetched.error || fetched.models.length === 0) {
     return { models: [], error: fetched.error ?? "No models returned." };
   }
@@ -12234,7 +12556,7 @@ function removeFavorite(list, fav) {
 // src/favorite-provider-display.ts
 var OAUTH_FAVORITE_NAMES = {
   "claude-code": "Claude Code OAuth (Anthropic subscription)",
-  antigravity: "Antigravity OAuth (Google Cloud Code Assist)",
+  antigravity: "Cloud Code Assist OAuth (Google)",
   "openai-oauth": "OpenAI OAuth (ChatGPT)",
   "xai-oauth": "xAI OAuth (SuperGrok)"
 };
@@ -12437,7 +12759,7 @@ var PROVIDER_DISPLAY = {
   "openai-oauth": OPENAI_DISPLAY,
   "github-copilot": "GitHub Copilot",
   "claude-code": "Claude Code (Anthropic subscription)",
-  antigravity: "Antigravity (Google Cloud Code Assist)",
+  antigravity: "Cloud Code Assist OAuth (Google)",
   "cline-pass": "ClinePass"
 };
 function openBrowser(url) {
@@ -12540,7 +12862,7 @@ async function runNativeBrowserOAuth(providerId) {
       p5.log.info(`Opening: ${pc6.cyan(url)}`);
       spinner3.start("Waiting for authorization\u2026");
     });
-    spinner3.stop(pc6.green("Signed in to Antigravity"));
+    spinner3.stop(pc6.green("Signed in to Cloud Code Assist"));
     const providerData = {};
     if (projectId) providerData.projectId = projectId;
     if (tierId) providerData.tier = tierId;
@@ -13414,14 +13736,13 @@ export {
   makeTraceLogger,
   writeSecureLogLine,
   printTraceLog,
-  fetchTemplateModels,
-  validateCustomEndpointUrl,
   fetchAnthropicModels,
-  addCustomEndpointProvider,
+  fetchTemplateModels,
   resolveProviderTemplate,
   effectiveProviderBaseUrl,
   syntheticTemplate,
   resolveModelSource,
+  validateCustomEndpointUrl,
   readBody,
   extractApiKey,
   sendJson,
@@ -13476,6 +13797,9 @@ export {
   routableModelsForTarget,
   providersForTarget,
   providersForCodexSubagents,
+  customEndpointKind,
+  addCustomEndpointProvider,
+  updateCustomEndpointProvider,
   refreshProviderModels,
   refreshAllProviderModels,
   removeProviderFromRegistry,
@@ -13520,4 +13844,4 @@ export {
   supportsClaudeTransparentMode,
   buildHttpProxyRoutes
 };
-//# sourceMappingURL=chunk-GQCFLSEM.js.map
+//# sourceMappingURL=chunk-KDIY732Q.js.map