@jacobbd/relay-ai 0.9.1 → 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.1",
+  version: "0.9.3",
   publishConfig: {
     access: "public"
   },
@@ -288,7 +288,320 @@ async function refreshOpenAiAccessToken(refreshToken) {
 
 // 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 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 {
+    ...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 text = messageText(item);
+  if (!text) 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: text },
+    { 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;
@@ -346,10 +659,14 @@ function createResponsesWebSocketFetch(wsUrl, log) {
     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;
@@ -367,13 +684,12 @@ function createResponsesWebSocketFetch(wsUrl, log) {
         };
         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();
@@ -389,28 +705,31 @@ function createResponsesWebSocketFetch(wsUrl, log) {
         socket.on("message", (data) => {
           const text = Array.isArray(data) ? Buffer.concat(data).toString("utf8") : data.toString("utf8");
           frameCount += 1;
-          if (frameCount <= 3) debug(`frame#${frameCount}: ${text.slice(0, 200)}`);
           let event;
           try {
             event = JSON.parse(text);
           } catch {
+            debug(`frame#${frameCount} non-json chars=${text.length}`);
             controller.enqueue(encoder.encode(`data: ${text.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();
@@ -694,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"];
@@ -709,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;
@@ -723,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");
@@ -755,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);
 }
@@ -790,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);
@@ -811,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" }
       };
     }
@@ -855,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),
@@ -936,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 {
@@ -1151,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
 };
@@ -1182,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) {
@@ -1219,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, {
@@ -1235,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" };
     }
@@ -1513,6 +2187,12 @@ var SCOPES = [
 ].join(" ");
 var ANTIGRAVITY_VERSION = "4.2.0";
 var ANTIGRAVITY_USER_AGENT = `vscode/1.X.X (Antigravity/${ANTIGRAVITY_VERSION})`;
+var ANTIGRAVITY_BASE_URLS = [
+  "https://daily-cloudcode-pa.googleapis.com",
+  "https://cloudcode-pa.googleapis.com",
+  "https://daily-cloudcode-pa.sandbox.googleapis.com"
+];
+var ANTIGRAVITY_API_VERSION = "v1internal";
 async function refreshAntigravityToken(refreshToken) {
   return postOAuthRefresh(
     TOKEN_URL3,
@@ -2401,7 +3081,244 @@ function providerRefreshToken(providerId, authType, authRef) {
   return () => forceRefreshProviderCredential(providerId, authRef ?? oauthAuthRef(providerId));
 }
 
+// src/core/antigravity-model.ts
+import { randomUUID as randomUUID2 } from "crypto";
+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;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (isWrappedCloudCodeBody(parsed)) {
+      return JSON.stringify(parsed.response);
+    }
+  } catch {
+  }
+  return payload;
+}
+function unwrapCloudCodeJsonBody(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (isWrappedCloudCodeBody(parsed)) {
+      return JSON.stringify(parsed.response);
+    }
+  } catch {
+  }
+  return text;
+}
+function consumeCloudCodeSseBuffer(buffer) {
+  const separator = /\r?\n\r?\n/;
+  let rest = buffer;
+  let emitted = "";
+  while (true) {
+    const match = separator.exec(rest);
+    if (!match || match.index === void 0) break;
+    const rawEvent = rest.slice(0, match.index);
+    const sep = match[0];
+    rest = rest.slice(match.index + sep.length);
+    emitted += transformSseEvent(rawEvent) + sep;
+  }
+  return { emitted, rest };
+}
+function createCloudCodeSseUnwrapper() {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let pending = "";
+  return new TransformStream({
+    transform(chunk, controller) {
+      pending += decoder.decode(chunk, { stream: true });
+      const { emitted, rest } = consumeCloudCodeSseBuffer(pending);
+      pending = rest;
+      if (emitted) controller.enqueue(encoder.encode(emitted));
+    },
+    flush(controller) {
+      pending += decoder.decode();
+      if (!pending) return;
+      const { emitted, rest } = consumeCloudCodeSseBuffer(pending);
+      const tail = emitted + (rest ? transformSseEvent(rest) : "");
+      if (tail) controller.enqueue(encoder.encode(tail));
+    }
+  });
+}
+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");
+    const signal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+    const geminiBody = await readJsonBody(input, init);
+    const envelope = {
+      project: options.projectId,
+      requestId: randomUUID2(),
+      model: options.modelId,
+      userAgent: ANTIGRAVITY_USER_AGENT,
+      requestType: "agent",
+      enabledCreditTypes: ["GOOGLE_ONE_AI"],
+      request: geminiBody
+    };
+    const body = JSON.stringify(envelope);
+    const bodyByteLength = Buffer.byteLength(body, "utf8");
+    const upstreamUrls = streaming ? STREAM_URLS : UNARY_URLS;
+    const doFetch = fetchImpl ?? ((input2, init2) => globalThis.fetch(input2, init2));
+    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 {
+          debug(`request ${where} kind=${streaming ? "stream" : "unary"} payloadBytes=${bodyByteLength}`);
+          response2 = await send(url2, token);
+        } catch (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);
+  };
+}
+async function createAntigravityCloudCodeModel(options) {
+  const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+  const google = createGoogleGenerativeAI({
+    apiKey: "relay-cloud-code",
+    baseURL: SDK_BASE_URL,
+    fetch: createCloudCodeFetch(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";
+}
+function transformSseEvent(event) {
+  return event.replace(/^(data:[ \t]*)(.*)$/gm, (_all, prefix, payload) => `${prefix}${unwrapCloudCodeSsePayload(payload)}`);
+}
+function requestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+async function readJsonBody(input, init) {
+  const body = init?.body;
+  if (typeof body === "string") return JSON.parse(body);
+  if (body instanceof Uint8Array) return JSON.parse(new TextDecoder().decode(body));
+  if (body instanceof ArrayBuffer) return JSON.parse(new TextDecoder().decode(body));
+  const request = input instanceof Request ? input.clone() : new Request(input, init);
+  return request.json();
+}
+async function adaptUpstreamResponse(upstream, streaming) {
+  const fallbackType = streaming ? "text/event-stream" : "application/json";
+  const contentType = upstream.headers.get("content-type") ?? fallbackType;
+  const headers = new Headers({ "Content-Type": contentType });
+  if (!upstream.ok) {
+    const errBody = await upstream.text();
+    return new Response(errBody, {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers
+    });
+  }
+  if (streaming) {
+    const body = upstream.body ? upstream.body.pipeThrough(createCloudCodeSseUnwrapper()) : null;
+    return new Response(body, {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers
+    });
+  }
+  const text = await upstream.text();
+  headers.set("Content-Type", "application/json");
+  return new Response(unwrapCloudCodeJsonBody(text), { status: 200, headers });
+}
+function isAbortError(err, signal) {
+  if (signal?.aborted) return true;
+  return !!err && typeof err === "object" && err.name === "AbortError";
+}
+function abortError(signal, cause) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  if (cause instanceof Error) return cause;
+  return new DOMException("This operation was aborted", "AbortError");
+}
+
 // src/core/model.ts
+function isAntigravityCloudCodeRoute(provider, model) {
+  return provider.id === "antigravity" && provider.authType === "oauth" && model.modelFormat === "cloud-code";
+}
 function findRoute(registry, providerId, modelId, routeId) {
   const provider = registry.providers.find((p) => p.id === providerId);
   if (!provider) {
@@ -2442,10 +3359,40 @@ async function resolveCredential(provider, routeId) {
     );
   }
 }
-async function createRelayModel(routeId) {
+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);
+    const projectId = typeof providerData2?.projectId === "string" ? providerData2.projectId.trim() : "";
+    if (!projectId) {
+      throw new RelayCoreError(
+        "CREDENTIAL_UNAVAILABLE",
+        `Provider "${provider.name}" is missing project metadata \u2014 re-authenticate in relay-ai ui.`,
+        { providerId: provider.id, routeId }
+      );
+    }
+    try {
+      return await finish(await createAntigravityCloudCodeModel({
+        modelId: model.upstreamModelId ?? model.id,
+        accessToken: apiKey2,
+        projectId,
+        refreshToken: providerRefreshToken(provider.id, provider.authType, provider.authRef),
+        ...options?.onDebug ? { onDebug: options.onDebug } : {}
+      }));
+    } catch (err) {
+      if (isRelayCoreError(err)) throw err;
+      throw new RelayCoreError(
+        "PROVIDER_LOAD_FAILED",
+        `Failed to construct model "${modelId}" for provider "${provider.name}".`,
+        { providerId, routeId, cause: err }
+      );
+    }
+  }
   const npm = model.npm ?? provider.api.npm;
   if (!npm) {
     throw new RelayCoreError("UNSUPPORTED_MODEL", `Model "${modelId}" has no SDK provider package \u2014 refresh the provider's models in relay-ai ui.`, { providerId, routeId });
@@ -2469,10 +3416,11 @@ async function createRelayModel(routeId) {
     headers: provider.api.headers,
     refreshToken: providerRefreshToken(provider.id, provider.authType, provider.authRef),
     useResponsesLite: model.useResponsesLite,
-    preferWebSockets: model.preferWebSockets
+    preferWebSockets: model.preferWebSockets,
+    ...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(