@jacobbd/relay-ai 0.9.2 → 0.9.3

package/dist/core/index.js

@@ -50,7 +50,7 @@ import { join as join2 } from "path";
 // package.json
 var package_default = {
   name: "@jacobbd/relay-ai",
-  version: "0.9.2",
+  version: "0.9.3",
   publishConfig: {
     access: "public"
   },
@@ -328,9 +328,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) {
@@ -354,20 +352,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 open3 = [...state.functionCalls].reverse().find((entry2) => entry2.outputIndex === hint.outputIndex && !entry2.done && !(hint.callId && entry2.callId !== hint.callId));
+    if (open3) return open3;
+  }
+  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 "";
@@ -394,47 +464,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) {
@@ -450,19 +516,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");
@@ -489,12 +576,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 : {};
@@ -922,10 +1013,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"];
@@ -937,6 +1029,15 @@ var EMPTY_REASONING = {
   source: "none",
   confidence: "inferred"
 };
+var GEMINI_25_BUDGETS = {
+  low: 1024,
+  medium: 4096,
+  high: 8192,
+  xhigh: 16384,
+  max: 16384,
+  minimal: 512,
+  none: 0
+};
 function isClaudeReasoningModel(modelId) {
   const lower = modelId.toLowerCase();
   if (!lower.startsWith("claude-")) return false;
@@ -951,6 +1052,10 @@ function isGeminiReasoningModel(modelId) {
   const lower = modelId.toLowerCase();
   return lower.startsWith("gemini-2.5-") || lower.startsWith("gemini-3") || lower.startsWith("gemini-3.");
 }
+function isGemini3Model(modelId) {
+  const lower = modelId.toLowerCase();
+  return lower.startsWith("gemini-3") || lower.startsWith("gemini-3.");
+}
 function isMistralReasoningModel(modelId) {
   const lower = modelId.toLowerCase();
   return lower.startsWith("mistral-") || lower.startsWith("magistral-") || lower.startsWith("ministral-") || lower.includes("reasoning");
@@ -983,6 +1088,9 @@ function isGlm52ReasoningModel(modelId) {
   const lower = modelId.toLowerCase();
   return lower === "glm-5.2" || lower === "z-ai/glm-5.2" || lower === "zai/glm-5.2" || lower === "zai-org/glm-5.2" || lower === "zai-org/glm5.2" || lower === "glm5.2";
 }
+function toCamelCase(str) {
+  return str.replace(/[-_]([a-z])/g, (_, g) => g.toUpperCase());
+}
 function hasSupportedParameter(metadata, param) {
   return (metadata?.supportedParameters ?? []).some((p) => p === param);
 }
@@ -1018,7 +1126,179 @@ function openRouterReasoningCapabilities(metadata) {
   }
   return EMPTY_REASONING;
 }
+function mapCodexEffortToDeepSeek(effort) {
+  switch (effort) {
+    case "off":
+    case "none":
+      return "off";
+    case "low":
+    case "medium":
+    case "high":
+      return "high";
+    case "xhigh":
+    case "max":
+      return "max";
+    default:
+      if (effort === "high" || effort === "max") return effort;
+      return void 0;
+  }
+}
+function deepSeekEffortProviderOptions(effort) {
+  const mapped = mapCodexEffortToDeepSeek(effort);
+  if (!mapped) return void 0;
+  const thinking = { type: mapped === "off" ? "disabled" : "enabled" };
+  const spread = { thinking };
+  if (mapped === "off") {
+    return {
+      deepseek: spread,
+      openaiCompatible: spread
+    };
+  }
+  return {
+    openaiCompatible: { reasoningEffort: mapped, ...spread },
+    deepseek: spread
+  };
+}
+function mapCodexEffortToAnthropic(effort) {
+  switch (effort) {
+    case "none":
+    case "minimal":
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+    case "xhigh":
+    case "max":
+      return effort === "xhigh" ? "high" : effort === "max" ? "max" : "high";
+    default:
+      if (ANTHROPIC_EFFORT_LEVELS.includes(effort)) {
+        return effort;
+      }
+      return void 0;
+  }
+}
+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;
+}
+function mapCodexEffortToGlm52(effort) {
+  switch (effort) {
+    case "high":
+      return "high";
+    case "xhigh":
+    case "max":
+      return "max";
+    default:
+      return void 0;
+  }
+}
+function mapCodexEffortToXai(effort, supportsMedium) {
+  switch (effort) {
+    case "low":
+      return "low";
+    case "medium":
+      return supportsMedium ? "medium" : void 0;
+    case "high":
+    case "xhigh":
+    case "max":
+      return "high";
+    default:
+      return void 0;
+  }
+}
+function mapCodexEffortToGeminiLevel(effort) {
+  switch (effort) {
+    case "none":
+    case "minimal":
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+    case "xhigh":
+    case "max":
+      return "high";
+    default:
+      return GEMINI_EFFORT_LEVELS.includes(effort) ? effort : void 0;
+  }
+}
+function mapCodexEffortToGeminiBudget(effort) {
+  const direct = GEMINI_25_BUDGETS[effort];
+  if (direct !== void 0) return direct > 0 ? direct : void 0;
+  const level = mapCodexEffortToGeminiLevel(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);
@@ -1039,15 +1319,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" }
       };
     }
@@ -1083,7 +1366,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),
@@ -1164,6 +1447,91 @@ function getReasoningCapabilities(npm, modelId, metadata) {
   }
   return EMPTY_REASONING;
 }
+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 || !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, modelPrefersResponsesApi(modelId));
+    return reasoningEffort ? { xai: { reasoningEffort } } : void 0;
+  }
+  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 id = modelId ?? "";
+    if (isGemini3Model(id)) {
+      const thinkingLevel = mapCodexEffortToGeminiLevel(effort);
+      return thinkingLevel ? { google: { thinkingConfig: { thinkingLevel, includeThoughts: true } } } : void 0;
+    }
+    const thinkingBudget = mapCodexEffortToGeminiBudget(effort);
+    return thinkingBudget ? { google: { thinkingConfig: { thinkingBudget, includeThoughts: true } } } : void 0;
+  }
+  if (npm === "@ai-sdk/mistral") {
+    if (!modelId || !isMistralReasoningModel(modelId)) return void 0;
+    const reasoningEffort = effort === "off" || effort === "none" ? "none" : "high";
+    return { mistral: { reasoningEffort } };
+  }
+  if (npm === "@ai-sdk/openai-compatible" || npm === "@ai-sdk/openai") {
+    if (!modelId) return void 0;
+    if (isDeepSeekReasoningModel(modelId)) {
+      return deepSeekEffortProviderOptions(effort);
+    }
+    if (isKimiReasoningModel(modelId)) {
+      const reasoningEffort = mapCodexEffortToOpenAICompatible(effort);
+      if (reasoningEffort) {
+        const key = metadata?.providerId ? toCamelCase(metadata.providerId) : "openaiCompatible";
+        return { [key]: { reasoningEffort } };
+      }
+      return void 0;
+    }
+    if (isGlm52ReasoningModel(modelId)) {
+      const reasoningEffort = mapCodexEffortToGlm52(effort);
+      if (reasoningEffort) {
+        const key = metadata?.providerId ? toCamelCase(metadata.providerId) : "openaiCompatible";
+        return { [key]: { reasoningEffort } };
+      }
+      return void 0;
+    }
+    if (hasSupportedParameter(metadata, "reasoning_effort")) {
+      const reasoningEffort = mapCodexEffortToOpenAICompatible(effort);
+      return reasoningEffort ? { openai: { reasoningEffort }, openaiCompatible: { 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;
+}
+function deepMergeProviderOptions(a, b) {
+  if (!a && !b) return void 0;
+  if (!a) return b;
+  if (!b) return a;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  const out = {};
+  for (const key of keys) {
+    out[key] = { ...a[key] ?? {}, ...b[key] ?? {} };
+  }
+  return out;
+}
 
 // src/registry/io.ts
 import {
@@ -1379,6 +1747,7 @@ var DEFAULT_RETRYABLE = {
   CREDENTIAL_UNAVAILABLE: false,
   OAUTH_REFRESH_FAILED: true,
   UNSUPPORTED_MODEL: false,
+  UNSUPPORTED_REASONING_LEVEL: false,
   UNSUPPORTED_REGISTRY_VERSION: false,
   PROVIDER_LOAD_FAILED: true
 };
@@ -1410,6 +1779,80 @@ function isRelayCoreError(err) {
   return err instanceof RelayCoreError;
 }
 
+// src/core/reasoning.ts
+var RELAY_REASONING_LEVELS = [
+  "off",
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function isRelayReasoningLevel(value) {
+  return typeof value === "string" && RELAY_REASONING_LEVELS.includes(value);
+}
+function reasoningNpmForRoute(provider, model) {
+  if (model.modelFormat === "cloud-code") return "@ai-sdk/google";
+  return model.npm ?? provider.api.npm ?? "";
+}
+function resolveReasoningProviderOptions(level, provider, model, routeId) {
+  if (!isRelayReasoningLevel(level)) {
+    throw new RelayCoreError(
+      "UNSUPPORTED_REASONING_LEVEL",
+      `Unknown reasoning level "${String(level)}" \u2014 expected one of: ${RELAY_REASONING_LEVELS.join(", ")}.`,
+      { providerId: provider.id, routeId }
+    );
+  }
+  const npm = reasoningNpmForRoute(provider, model);
+  const upstreamModelId = model.upstreamModelId ?? model.id;
+  const metadata = {
+    providerId: provider.id,
+    upstreamModelId,
+    ...model.apiUrl ?? provider.api.url ? { apiBaseUrl: model.apiUrl ?? provider.api.url } : {},
+    ...model.supportedParameters ? { supportedParameters: model.supportedParameters } : {},
+    ...model.reasoning !== void 0 ? { reasoning: model.reasoning } : {},
+    ...model.interleavedReasoningField ? { interleavedReasoningField: model.interleavedReasoningField } : {}
+  };
+  const caps = getReasoningCapabilities(npm, upstreamModelId, metadata);
+  if (caps.mode !== "controllable" || !caps.levels.includes(level)) {
+    const available = caps.levels.length > 0 ? caps.levels.join(", ") : "none";
+    throw new RelayCoreError(
+      "UNSUPPORTED_REASONING_LEVEL",
+      `Model "${model.id}" on provider "${provider.name}" does not support reasoning level "${level}" \u2014 available levels: ${available}. See capabilities.reasoningLevels from listRelayModels().`,
+      { providerId: provider.id, routeId }
+    );
+  }
+  const resolved = effortProviderOptions(npm, level, upstreamModelId, metadata);
+  if (!resolved) {
+    throw new RelayCoreError(
+      "UNSUPPORTED_REASONING_LEVEL",
+      `Model "${model.id}" on provider "${provider.name}" advertises reasoning level "${level}" but Relay has no request mapping for it \u2014 this is a relay-ai bug, please report it.`,
+      { providerId: provider.id, routeId }
+    );
+  }
+  return resolved;
+}
+async function withReasoningProviderOptions(model, providerOptions) {
+  const { wrapLanguageModel: wrapLanguageModel2 } = await import("ai");
+  return wrapLanguageModel2({
+    // `LanguageModel` also admits a bare model-id string and the legacy v2
+    // interface; everything Core builds is a concrete current-spec model.
+    model,
+    middleware: {
+      specificationVersion: "v3",
+      transformParams: async ({ params }) => ({
+        ...params,
+        providerOptions: deepMergeProviderOptions(
+          providerOptions,
+          params.providerOptions
+        )
+      })
+    }
+  });
+}
+
 // src/core/route-id.ts
 var SEPARATOR = "::";
 function toRelayRouteId(providerId, modelId) {
@@ -1447,7 +1890,7 @@ function loadCoreRegistry(path) {
 }
 function mapReasoning(provider, model) {
   const base = { tools: "unknown", vision: "unknown" };
-  const npm = model.npm ?? provider.api.npm ?? "";
+  const npm = reasoningNpmForRoute(provider, model);
   const upstreamModelId = model.upstreamModelId ?? model.id;
   try {
     const caps = getReasoningCapabilities(npm, upstreamModelId, {
@@ -1463,13 +1906,16 @@ function mapReasoning(provider, model) {
         return { ...base, reasoning: "none" };
       case "internal-only":
         return { ...base, reasoning: "fixed" };
-      case "controllable":
+      case "controllable": {
+        const levels = caps.levels.filter(isRelayReasoningLevel);
+        if (levels.length === 0) return { ...base, reasoning: "fixed" };
         return {
           ...base,
           reasoning: "adjustable",
-          reasoningLevels: [...caps.levels],
-          defaultReasoningLevel: caps.defaultLevel
+          reasoningLevels: levels,
+          ...isRelayReasoningLevel(caps.defaultLevel) ? { defaultReasoningLevel: caps.defaultLevel } : {}
         };
+      }
       default:
         return { ...base, reasoning: "unknown" };
     }
@@ -2637,10 +3083,21 @@ function providerRefreshToken(providerId, authType, authRef) {
 
 // src/core/antigravity-model.ts
 import { randomUUID as randomUUID2 } from "crypto";
-var CLOUD_CODE_BASE = ANTIGRAVITY_BASE_URLS[0].replace(/\/+$/, "");
-var STREAM_URL = `${CLOUD_CODE_BASE}/${ANTIGRAVITY_API_VERSION}:streamGenerateContent?alt=sse`;
-var UNARY_URL = `${CLOUD_CODE_BASE}/${ANTIGRAVITY_API_VERSION}:generateContent`;
+var CLOUD_CODE_BASES = ANTIGRAVITY_BASE_URLS.map((base) => base.replace(/\/+$/, ""));
+var CLOUD_CODE_BASE = CLOUD_CODE_BASES[0];
+var STREAM_URLS = CLOUD_CODE_BASES.map((base) => `${base}/${ANTIGRAVITY_API_VERSION}:streamGenerateContent?alt=sse`);
+var UNARY_URLS = CLOUD_CODE_BASES.map((base) => `${base}/${ANTIGRAVITY_API_VERSION}:generateContent`);
 var SDK_BASE_URL = `${CLOUD_CODE_BASE}/v1beta`;
+var ENDPOINT_FAILOVER_STATUSES = /* @__PURE__ */ new Set([404, 408, 429]);
+function shouldTryNextEndpoint(status) {
+  return ENDPOINT_FAILOVER_STATUSES.has(status) || status >= 500;
+}
+function discardResponse(response) {
+  try {
+    void response.body?.cancel();
+  } catch {
+  }
+}
 function unwrapCloudCodeSsePayload(payload) {
   const trimmed = payload.trim();
   if (trimmed === "" || trimmed === "[DONE]") return payload;
@@ -2699,6 +3156,12 @@ function createCloudCodeSseUnwrapper() {
 }
 function createCloudCodeFetch(options, fetchImpl) {
   let accessToken = options.accessToken;
+  const debug = (msg) => {
+    try {
+      options.onDebug?.(`cloud-code: ${msg}`);
+    } catch {
+    }
+  };
   return async (input, init) => {
     const url = requestUrl(input);
     const streaming = url.includes("streamGenerateContent");
@@ -2714,35 +3177,66 @@ function createCloudCodeFetch(options, fetchImpl) {
       request: geminiBody
     };
     const body = JSON.stringify(envelope);
-    const upstreamUrl = streaming ? STREAM_URL : UNARY_URL;
+    const bodyByteLength = Buffer.byteLength(body, "utf8");
+    const upstreamUrls = streaming ? STREAM_URLS : UNARY_URLS;
     const doFetch = fetchImpl ?? ((input2, init2) => globalThis.fetch(input2, init2));
-    const send = (token) => doFetch(upstreamUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`,
-        "User-Agent": ANTIGRAVITY_USER_AGENT
-      },
-      body,
-      signal
-    });
-    let response;
-    try {
-      response = await send(accessToken);
-    } catch (err) {
-      if (isAbortError(err, signal)) throw abortError(signal, err);
-      throw err;
-    }
-    if (response.status === 401 && options.refreshToken && !signal?.aborted) {
-      const refreshed = await options.refreshToken().catch(() => null);
-      if (refreshed && refreshed !== accessToken && !signal?.aborted) {
-        accessToken = refreshed;
+    const send = async (url2, token) => {
+      try {
+        return await doFetch(url2, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+            "User-Agent": ANTIGRAVITY_USER_AGENT
+          },
+          body,
+          signal
+        });
+      } catch (err) {
+        if (isAbortError(err, signal)) throw abortError(signal, err);
+        throw err;
+      }
+    };
+    const sendWithFailover = async (token, startIndex = 0) => {
+      let lastError;
+      for (let i = startIndex; i < upstreamUrls.length; i += 1) {
+        const url2 = upstreamUrls[i];
+        const isLast = i === upstreamUrls.length - 1;
+        const where = `endpoint=${i + 1}/${upstreamUrls.length} host=${endpointHost(url2)}`;
+        let response2;
         try {
-          response = await send(accessToken);
+          debug(`request ${where} kind=${streaming ? "stream" : "unary"} payloadBytes=${bodyByteLength}`);
+          response2 = await send(url2, token);
         } catch (err) {
-          if (isAbortError(err, signal)) throw abortError(signal, err);
-          throw err;
+          if (isAbortError(err, signal)) throw err;
+          lastError = err;
+          debug(`network failure ${where} errorName=${errorName(err)}`);
         }
+        if (response2) {
+          if (isLast || !shouldTryNextEndpoint(response2.status)) {
+            debug(`response ${where} status=${response2.status}`);
+            return { response: response2, url: url2, index: i };
+          }
+          discardResponse(response2);
+          lastError = new Error(`Cloud Code Assist endpoint returned ${response2.status}`);
+          debug(`retryable status=${response2.status} ${where} \u2014 trying next endpoint`);
+        }
+        if (signal?.aborted) throw abortError(signal);
+      }
+      throw lastError ?? new Error("All Cloud Code Assist endpoints failed");
+    };
+    const tokenUsed = accessToken;
+    let { response, index: servedByIndex } = await sendWithFailover(tokenUsed);
+    if (response.status === 401 && options.refreshToken && !signal?.aborted) {
+      debug("status=401 \u2014 refreshing credential");
+      const refreshed = await options.refreshToken().catch(() => null);
+      if (refreshed && refreshed !== tokenUsed && !signal?.aborted) {
+        accessToken = refreshed;
+        discardResponse(response);
+        ({ response } = await sendWithFailover(refreshed, servedByIndex));
+        debug(`retry after refresh status=${response.status}`);
+      } else {
+        debug(`refresh did not yield a new credential (refreshed=${refreshed ? "same" : "none"})`);
       }
     }
     return adaptUpstreamResponse(response, streaming);
@@ -2757,6 +3251,17 @@ async function createAntigravityCloudCodeModel(options) {
   });
   return google(options.modelId);
 }
+function endpointHost(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return "unknown";
+  }
+}
+function errorName(err) {
+  if (err instanceof Error) return err.name || "Error";
+  return typeof err;
+}
 function isWrappedCloudCodeBody(parsed) {
   return !!parsed && typeof parsed === "object" && !Array.isArray(parsed) && "response" in parsed && parsed.response !== null && typeof parsed.response === "object";
 }
@@ -2858,6 +3363,8 @@ async function createRelayModel(routeId, options) {
   const { providerId, modelId } = parseRelayRouteId(routeId);
   const registry = loadCoreRegistry();
   const { provider, model } = findRoute(registry, providerId, modelId, routeId);
+  const reasoningOptions = options?.reasoning === void 0 ? void 0 : resolveReasoningProviderOptions(options.reasoning, provider, model, routeId);
+  const finish = (built) => reasoningOptions ? withReasoningProviderOptions(built, reasoningOptions) : Promise.resolve(built);
   if (isAntigravityCloudCodeRoute(provider, model)) {
     const apiKey2 = await resolveCredential(provider, routeId);
     const providerData2 = await resolveProviderOAuthProviderData(provider.authRef);
@@ -2870,12 +3377,13 @@ async function createRelayModel(routeId, options) {
       );
     }
     try {
-      return await createAntigravityCloudCodeModel({
+      return await finish(await createAntigravityCloudCodeModel({
         modelId: model.upstreamModelId ?? model.id,
         accessToken: apiKey2,
         projectId,
-        refreshToken: providerRefreshToken(provider.id, provider.authType, provider.authRef)
-      });
+        refreshToken: providerRefreshToken(provider.id, provider.authType, provider.authRef),
+        ...options?.onDebug ? { onDebug: options.onDebug } : {}
+      }));
     } catch (err) {
       if (isRelayCoreError(err)) throw err;
       throw new RelayCoreError(
@@ -2912,7 +3420,7 @@ async function createRelayModel(routeId, options) {
     ...options?.onDebug ? { onDebug: options.onDebug } : {}
   };
   try {
-    return await createLanguageModel(spec);
+    return await finish(await createLanguageModel(spec));
   } catch (err) {
     if (isRelayCoreError(err)) throw err;
     throw new RelayCoreError(