@jacobbd/relay-ai 0.9.1 → 0.9.3

package/dist/{chunk-MFKBK6YL.js → chunk-PVGAE7HA.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.1",
+  version: "0.9.3",
   publishConfig: {
     access: "public"
   },
@@ -345,7 +345,320 @@ async function runOpenAiDeviceCodeFlow(onDeviceCode, opts) {
 
 // src/oauth/responses-websocket.ts
 var RESPONSES_LITE_HEADER = "x-openai-internal-codex-responses-lite";
-var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set(["response.completed", "response.failed", "response.incomplete"]);
+var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set(["response.completed", "response.failed", "response.incomplete", "error"]);
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function recordKeys(value) {
+  return isRecord(value) ? Object.keys(value).sort().join(",") : "";
+}
+function summarizeResponsesLiteEvent(event) {
+  if (!isRecord(event)) return `kind=${event == null ? "null" : typeof event}`;
+  const parts = [`type=${typeof event.type === "string" ? event.type : "unknown"}`, `keys=${recordKeys(event)}`];
+  if (typeof event.delta === "string") parts.push(`deltaChars=${event.delta.length}`);
+  if (typeof event.output_index === "number") parts.push(`hasOutputIndex=1`);
+  if (typeof event.item_id === "string") parts.push(`hasItemId=1`);
+  if (isRecord(event.item)) {
+    parts.push(`itemType=${typeof event.item.type === "string" ? event.item.type : "unknown"}`);
+    parts.push(`itemKeys=${recordKeys(event.item)}`);
+    if (typeof event.item.arguments === "string") parts.push(`argumentsChars=${event.item.arguments.length}`);
+  }
+  if (isRecord(event.response)) {
+    parts.push(`responseKeys=${recordKeys(event.response)}`);
+    if (Array.isArray(event.response.output)) {
+      parts.push(`outputCount=${event.response.output.length}`);
+      parts.push(`outputTypes=${event.response.output.map((item) => isRecord(item) && typeof item.type === "string" ? item.type : "unknown").join(",")}`);
+    }
+    if (isRecord(event.response.usage)) parts.push(`usageKeys=${recordKeys(event.response.usage)}`);
+    if (typeof event.response.status === "string") parts.push(`status=${event.response.status}`);
+  }
+  if (isRecord(event.error)) {
+    parts.push(`errorKeys=${recordKeys(event.error)}`);
+    if (typeof event.error.message === "string") parts.push(`messageChars=${event.error.message.length}`);
+  }
+  return parts.join(" ");
+}
+function createResponsesLiteNormalizeState() {
+  return {
+    nextId: 1,
+    lastOutputIndex: 0,
+    textDeltaForwarded: false,
+    messageAddedIds: /* @__PURE__ */ new Set(),
+    messageDoneIds: /* @__PURE__ */ new Set(),
+    functionCalls: []
+  };
+}
+function nextId(state, prefix) {
+  const id = `${prefix}_${state.nextId}`;
+  state.nextId += 1;
+  return id;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function normalizeErrorEvent(event) {
+  const raw = isRecord(event.error) ? event.error : { message: typeof event.error === "string" ? event.error : "upstream error" };
+  return {
+    type: "error",
+    sequence_number: typeof event.sequence_number === "number" ? event.sequence_number : 0,
+    error: {
+      type: asString(raw.type) ?? "server_error",
+      code: asString(raw.code) ?? "unknown",
+      message: asString(raw.message) ?? "upstream error",
+      ...raw.param == null ? {} : { param: raw.param }
+    }
+  };
+}
+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 {
+    ...entry.upstream,
+    type: "function_call",
+    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 "";
+  let out = "";
+  for (const part of item.content) {
+    if (isRecord(part) && typeof part.text === "string" && (part.type === "output_text" || part.type === "text")) {
+      out += part.text;
+    }
+  }
+  return out;
+}
+function synthesizeMessage(item, outputIndex, state) {
+  const text4 = messageText(item);
+  if (!text4) return [];
+  const id = asString(item.id) ?? nextId(state, "msg");
+  state.lastMessageItemId = id;
+  state.textDeltaForwarded = true;
+  state.messageAddedIds.add(id);
+  state.messageDoneIds.add(id);
+  return [
+    { type: "response.output_item.added", output_index: outputIndex, item: { type: "message", id } },
+    { type: "response.output_text.delta", item_id: id, delta: text4 },
+    { type: "response.output_item.done", output_index: outputIndex, item: { type: "message", id } }
+  ];
+}
+function synthesizeFunctionCall(item, outputIndex, state) {
+  const entry = resolveFunctionCall(state, {
+    itemId: asString(item.id),
+    callId: asString(item.call_id),
+    outputIndex
+  });
+  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) {
+  const recovered = [];
+  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) {
+  if (!isRecord(event) || typeof event.type !== "string") return [event];
+  if (event.type === "error") return [normalizeErrorEvent(event)];
+  if (event.type === "response.output_item.added" && isRecord(event.item)) {
+    const outputIndex = typeof event.output_index === "number" ? event.output_index : state.lastOutputIndex;
+    state.lastOutputIndex = outputIndex;
+    if (event.item.type === "message") {
+      const id = asString(event.item.id) ?? nextId(state, "msg");
+      state.lastMessageItemId = id;
+      state.messageAddedIds.add(id);
+      return [{ ...event, output_index: outputIndex, item: { ...event.item, id } }];
+    }
+    if (event.item.type === "function_call") {
+      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 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");
+      state.lastMessageItemId = id;
+      state.messageDoneIds.add(id);
+      return [{ ...event, output_index: outputIndex, item: { ...event.item, id } }];
+    }
+    return [{ ...event, output_index: outputIndex }];
+  }
+  if (event.type === "response.output_text.delta") {
+    const itemId = asString(event.item_id) ?? state.lastMessageItemId ?? nextId(state, "msg");
+    state.lastMessageItemId = itemId;
+    state.textDeltaForwarded = true;
+    const events = [];
+    if (!state.messageAddedIds.has(itemId)) {
+      events.push({
+        type: "response.output_item.added",
+        output_index: state.lastOutputIndex,
+        item: { type: "message", id: itemId }
+      });
+      state.messageAddedIds.add(itemId);
+    }
+    events.push({ ...event, item_id: itemId, delta: typeof event.delta === "string" ? event.delta : "" });
+    return events;
+  }
+  if (event.type === "response.function_call_arguments.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 : {};
+    const recovered = recoverFromCompletedOutput(response, state);
+    if (state.lastMessageItemId && state.textDeltaForwarded && !state.messageDoneIds.has(state.lastMessageItemId)) {
+      recovered.push({
+        type: "response.output_item.done",
+        output_index: state.lastOutputIndex,
+        item: { type: "message", id: state.lastMessageItemId }
+      });
+      state.messageDoneIds.add(state.lastMessageItemId);
+    }
+    return [...recovered, event];
+  }
+  return [event];
+}
 function toHeaderRecord(headers) {
   const out = {};
   if (!headers) return out;
@@ -403,10 +716,14 @@ function createResponsesWebSocketFetch(wsUrl, log7) {
     if (hasResponsesLiteHeader(headers)) {
       payload = applyResponsesLiteShape(payload);
     }
+    debug(
+      `request type=response.create keys=${Object.keys(payload).sort().join(",")} toolCount=${Array.isArray(payload.tools) ? payload.tools.length : 0} store=${String(payload.store)} parallelToolCalls=${String(payload.parallel_tool_calls)} reasoningKeys=${recordKeys(payload.reasoning)}`
+    );
     const outgoing = JSON.stringify({ type: "response.create", ...payload });
     const encoder = new TextEncoder();
     let socket;
     let frameCount = 0;
+    const normalizeState = createResponsesLiteNormalizeState();
     const stream = new ReadableStream({
       start(controller) {
         let closed = false;
@@ -424,13 +741,12 @@ function createResponsesWebSocketFetch(wsUrl, log7) {
         };
         const fail = (message) => {
           if (closed) return;
-          debug(`fail: ${message}`);
+          debug(`fail messageChars=${message.length}`);
           try {
-            controller.enqueue(encoder.encode(
-              `data: ${JSON.stringify({ type: "error", error: { message } })}
+            const [errorEvent] = normalizeResponsesLiteEvent({ type: "error", error: { message } }, normalizeState);
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(errorEvent)}
 
-`
-            ));
+`));
           } catch {
           }
           close();
@@ -446,28 +762,31 @@ function createResponsesWebSocketFetch(wsUrl, log7) {
         socket.on("message", (data) => {
           const text4 = Array.isArray(data) ? Buffer.concat(data).toString("utf8") : data.toString("utf8");
           frameCount += 1;
-          if (frameCount <= 3) debug(`frame#${frameCount}: ${text4.slice(0, 200)}`);
           let event;
           try {
             event = JSON.parse(text4);
           } catch {
+            debug(`frame#${frameCount} non-json chars=${text4.length}`);
             controller.enqueue(encoder.encode(`data: ${text4.replace(/\r?\n/g, " ")}
 
 `));
             return;
           }
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}
+          if (frameCount <= 8) debug(`frame#${frameCount} ${summarizeResponsesLiteEvent(event)}`);
+          for (const next of normalizeResponsesLiteEvent(event, normalizeState)) {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(next)}
 
 `));
-          const type = event.type;
-          if (typeof type === "string" && TERMINAL_EVENT_TYPES.has(type)) {
+          }
+          const type = isRecord(event) && typeof event.type === "string" ? event.type : void 0;
+          if (type && TERMINAL_EVENT_TYPES.has(type)) {
             debug(`terminal event: ${type} (after ${frameCount} frames)`);
             close();
           }
         });
         socket.on("error", (err) => fail(err.message));
         socket.on("close", (code, reason) => {
-          debug(`close code=${code} frames=${frameCount}${reason?.length ? ` reason=${reason.toString("utf8").slice(0, 200)}` : ""}`);
+          debug(`close code=${code} frames=${frameCount}${reason?.length ? ` reasonChars=${reason.length}` : ""}`);
           if (closed) return;
           if (code === 1e3 || code === 1005) {
             close();
@@ -823,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"];
@@ -997,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;
@@ -1013,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":
@@ -1054,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);
@@ -1075,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" }
       };
     }
@@ -1119,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),
@@ -1216,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) {
@@ -1250,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 } };
@@ -1266,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")) {
@@ -2348,7 +2736,7 @@ var ANTIGRAVITY_BASE_URLS = [
   "https://cloudcode-pa.googleapis.com",
   "https://daily-cloudcode-pa.sandbox.googleapis.com"
 ];
-var API_VERSION = "v1internal";
+var ANTIGRAVITY_API_VERSION = "v1internal";
 async function buildAntigravityAuthUrl(redirectUri) {
   const { verifier, challenge } = await generatePkce();
   const state = generateOAuthState();
@@ -2470,7 +2858,7 @@ function resolveAntigravityOnboardTierId(data) {
   return pickTierId(sub.currentTier) ?? "legacy-tier";
 }
 async function loadCodeAssist(accessToken) {
-  const endpoints = ANTIGRAVITY_BASE_URLS.map((b) => `${b}/${API_VERSION}:loadCodeAssist`);
+  const endpoints = ANTIGRAVITY_BASE_URLS.map((b) => `${b}/${ANTIGRAVITY_API_VERSION}:loadCodeAssist`);
   const res = await fetchFirstOk(endpoints, {
     method: "POST",
     headers: apiHeaders(accessToken),
@@ -2487,7 +2875,7 @@ async function loadCodeAssist(accessToken) {
   };
 }
 async function onboardUser(accessToken, tierId, maxAttempts = 10) {
-  const endpoints = ANTIGRAVITY_BASE_URLS.map((b) => `${b}/${API_VERSION}:onboardUser`);
+  const endpoints = ANTIGRAVITY_BASE_URLS.map((b) => `${b}/${ANTIGRAVITY_API_VERSION}:onboardUser`);
   let finalProjectId = "";
   for (let i = 0; i < maxAttempts; i++) {
     const res = await fetchFirstOk(endpoints, {
@@ -4742,7 +5130,7 @@ var SubagentRouteRegistry = class {
 // src/subagent-model-routing.ts
 var CLAUDE_MODEL_FAMILIES = ["sonnet", "opus", "haiku", "fable"];
 var CLAUDE_MODEL_FAMILY_SET = new Set(CLAUDE_MODEL_FAMILIES);
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function claudeModelFamily(modelId) {
@@ -4751,10 +5139,10 @@ function claudeModelFamily(modelId) {
   return CLAUDE_MODEL_FAMILIES.find((family) => normalized.includes(family));
 }
 function isClaudeAgentTool(tool4) {
-  if (tool4.name !== "Agent" || !isRecord(tool4.input_schema)) return false;
+  if (tool4.name !== "Agent" || !isRecord2(tool4.input_schema)) return false;
   const properties = tool4.input_schema.properties;
-  if (!isRecord(properties)) return false;
-  return ["description", "prompt", "subagent_type"].every((name) => isRecord(properties[name]));
+  if (!isRecord2(properties)) return false;
+  return ["description", "prompt", "subagent_type"].every((name) => isRecord2(properties[name]));
 }
 var UnavailableSubagentModelError = class extends Error {
   constructor(selector, routing) {
@@ -4771,7 +5159,7 @@ var UnavailableSubagentModelError = class extends Error {
   statusCode = 400;
 };
 function normalizeClaudeAgentInput(input, routing) {
-  const source = isRecord(input) ? input : {};
+  const source = isRecord2(input) ? input : {};
   const normalized = { ...source };
   if (source.subagent_type === "fork") {
     return { input: normalized, decision: { kind: "fork" } };
@@ -4843,9 +5231,9 @@ function prepareClaudeAgentInput(input, routing) {
   return { input: clientInput, decision };
 }
 function augmentClaudeAgentTool(tool4, routing) {
-  const inputSchema = isRecord(tool4.input_schema) ? tool4.input_schema : {};
-  const properties = isRecord(inputSchema.properties) ? inputSchema.properties : {};
-  const originalModel = isRecord(properties.model) ? properties.model : {};
+  const inputSchema = isRecord2(tool4.input_schema) ? tool4.input_schema : {};
+  const properties = isRecord2(inputSchema.properties) ? inputSchema.properties : {};
+  const originalModel = isRecord2(properties.model) ? properties.model : {};
   const smallCatalog = routing.models.length <= MAX_MODEL_CATALOG;
   const modelProperty = {
     ...originalModel,
@@ -6701,8 +7089,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) {
@@ -9016,6 +9404,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) {
@@ -9376,77 +9838,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);
@@ -9461,6 +9874,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
@@ -9469,29 +9901,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 };
   }
@@ -9528,6 +9965,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;
@@ -10055,7 +10601,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() };
@@ -10063,8 +10609,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 };
     }
@@ -10073,7 +10620,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." };
   }
@@ -12006,7 +12553,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)"
 };
@@ -12209,7 +12756,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) {
@@ -12312,7 +12859,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;
@@ -13186,14 +13733,13 @@ export {
   makeTraceLogger,
   writeSecureLogLine,
   printTraceLog,
-  fetchTemplateModels,
-  validateCustomEndpointUrl,
   fetchAnthropicModels,
-  addCustomEndpointProvider,
+  fetchTemplateModels,
   resolveProviderTemplate,
   effectiveProviderBaseUrl,
   syntheticTemplate,
   resolveModelSource,
+  validateCustomEndpointUrl,
   readBody,
   extractApiKey,
   sendJson,
@@ -13248,6 +13794,9 @@ export {
   routableModelsForTarget,
   providersForTarget,
   providersForCodexSubagents,
+  customEndpointKind,
+  addCustomEndpointProvider,
+  updateCustomEndpointProvider,
   refreshProviderModels,
   refreshAllProviderModels,
   removeProviderFromRegistry,
@@ -13292,4 +13841,4 @@ export {
   supportsClaudeTransparentMode,
   buildHttpProxyRoutes
 };
-//# sourceMappingURL=chunk-MFKBK6YL.js.map
+//# sourceMappingURL=chunk-PVGAE7HA.js.map