@caspian2026/agent-sdk 0.0.7 → 0.0.9

package/dist/{chunk-mw1kpeg9.js → chunk-2nrarbza.js}

@@ -1,828 +1,430 @@
 // @bun
 import {
-  __esm
+  createAssistantAPIErrorMessage,
+  createUserMessage,
+  extractDiscoveredToolNames,
+  getEmptyToolPermissionContext,
+  init_Tool,
+  init_api,
+  init_messages1 as init_messages,
+  init_toolSearch,
+  isDeferredToolsDeltaEnabled,
+  isToolSearchEnabled,
+  normalizeContentFromAPI,
+  normalizeMessagesForAPI,
+  toolMatchesName,
+  toolToAPISchema
+} from "./chunk-93vwm44t.js";
+import"./chunk-mcws22k3.js";
+import"./chunk-jzthz1bx.js";
+import"./chunk-rz94yg8c.js";
+import"./chunk-hwfknpxv.js";
+import"./chunk-1gx78081.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-54wn2jdr.js";
+import"./chunk-wkt2q02c.js";
+import"./chunk-87xg6yb4.js";
+import"./chunk-2yxqz99n.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-sdfvr9ps.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-xswyz2es.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-b6prbsae.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-68ffk5qa.js";
+import {
+  addToTotalSessionCost,
+  init_cost_tracker
+} from "./chunk-ratnrv9v.js";
+import {
+  calculateUSDCost,
+  getModelMaxOutputTokens,
+  init_context,
+  init_modelCost
+} from "./chunk-7cje7scj.js";
+import {
+  getProxyFetchOptions,
+  init_proxy
+} from "./chunk-7krg0dkt.js";
+import {
+  TOOL_SEARCH_TOOL_NAME,
+  formatDeferredToolLine,
+  init_prompt,
+  isDeferredTool
+} from "./chunk-kxrrtr3p.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-6wzg2hpc.js";
+import"./chunk-9w114071.js";
+import"./chunk-3pzwd6qq.js";
+import"./chunk-2vteceqh.js";
+import"./chunk-xeb6075z.js";
+import"./chunk-nrjtxhyr.js";
+import"./chunk-v4t6dyyh.js";
+import"./chunk-2vbash3m.js";
+import"./chunk-bzatg35k.js";
+import"./chunk-qctsv1d7.js";
+import"./chunk-p4196wzm.js";
+import"./chunk-7hrmxpha.js";
+import"./chunk-6nsd9606.js";
+import"./chunk-rkv8bdtr.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-z6wm96eh.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-1v01c96r.js";
+import"./chunk-8b2y3x7a.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-cexw1jmv.js";
+import"./chunk-j35mw64g.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-c7jwbe76.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-7sgtxrsc.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-x8d2ehd7.js";
+import"./chunk-3e28fvn0.js";
+import"./chunk-kjqyhxz7.js";
+import"./chunk-4ayjwyqj.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-40s88wdg.js";
+import"./chunk-5cxjxxx8.js";
+import"./chunk-s8kj6ajy.js";
+import"./chunk-qcrpqjya.js";
+import"./chunk-skp5w8bq.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-pd2vy8hx.js";
+import {
+  init_envUtils,
+  isEnvDefinedFalsy,
+  isEnvTruthy
+} from "./chunk-nsc89h0n.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-k8vp0atq.js";
+import"./chunk-vf612n57.js";
+import"./chunk-07069jq1.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-55raexh7.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-b0kf00ff.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm,
+  __require
 } from "./chunk-qp2qdcda.js";
 
-// src/services/api/openai/convertMessages.ts
-function anthropicMessagesToOpenAI(messages, systemPrompt, options) {
-  const result = [];
-  const enableThinking = options?.enableThinking ?? false;
-  const systemText = systemPromptToText(systemPrompt);
-  if (systemText) {
-    result.push({
-      role: "system",
-      content: systemText
-    });
-  }
-  const turnBoundaries = new Set;
-  if (enableThinking) {
-    let hasSeenAssistant = false;
-    for (let i = 0;i < messages.length; i++) {
-      const msg = messages[i];
-      if (msg.type === "assistant") {
-        hasSeenAssistant = true;
-      }
-      if (msg.type === "user" && hasSeenAssistant) {
-        const content = msg.message.content;
-        const startsNewUserTurn = typeof content === "string" ? content.length > 0 : Array.isArray(content) && content.some((b) => typeof b === "string" || b && typeof b === "object" && ("type" in b) && b.type !== "tool_result");
-        if (startsNewUserTurn) {
-          turnBoundaries.add(i);
-        }
-      }
-    }
-  }
-  for (let i = 0;i < messages.length; i++) {
-    const msg = messages[i];
-    switch (msg.type) {
-      case "user":
-        result.push(...convertInternalUserMessage(msg));
-        break;
-      case "assistant":
-        const preserveReasoning = enableThinking && !isBeforeAnyTurnBoundary(i, turnBoundaries);
-        result.push(...convertInternalAssistantMessage(msg, preserveReasoning));
-        break;
-      default:
-        break;
-    }
-  }
-  return result;
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/tslib.mjs
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
 }
-function systemPromptToText(systemPrompt) {
-  if (!systemPrompt || systemPrompt.length === 0)
-    return "";
-  return systemPrompt.filter(Boolean).join(`
-
-`);
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 }
-function isBeforeAnyTurnBoundary(i, boundaries) {
-  for (const b of boundaries) {
-    if (i < b)
-      return true;
+var init_tslib = () => {};
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/utils/uuid.mjs
+var uuid4 = function() {
+  const { crypto: crypto2 } = globalThis;
+  if (crypto2?.randomUUID) {
+    uuid4 = crypto2.randomUUID.bind(crypto2);
+    return crypto2.randomUUID();
   }
-  return false;
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto2 ? () => crypto2.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
+  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16));
+};
+var init_uuid = () => {};
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/errors.mjs
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && (("name" in err) && err.name === "AbortError" || ("message" in err) && String(err.message).includes("FetchRequestCanceledException"));
 }
-function convertInternalUserMessage(msg) {
-  const result = [];
-  const content = msg.message.content;
-  if (typeof content === "string") {
-    result.push({
-      role: "user",
-      content
-    });
-  } else if (Array.isArray(content)) {
-    const textParts = [];
-    const toolResults = [];
-    const imageParts = [];
-    for (const block of content) {
-      if (typeof block === "string") {
-        textParts.push(block);
-      } else if (block.type === "text") {
-        textParts.push(block.text);
-      } else if (block.type === "tool_result") {
-        toolResults.push(block);
-      } else if (block.type === "image") {
-        const imagePart = convertImageBlockToOpenAI(block);
-        if (imagePart) {
-          imageParts.push(imagePart);
-        }
-      }
-    }
-    for (const tr of toolResults) {
-      result.push(convertToolResult(tr));
-    }
-    if (imageParts.length > 0) {
-      const multiContent = [];
-      if (textParts.length > 0) {
-        multiContent.push({ type: "text", text: textParts.join(`
-`) });
+var castToError = (err) => {
+  if (err instanceof Error)
+    return err;
+  if (typeof err === "object" && err !== null) {
+    try {
+      if (Object.prototype.toString.call(err) === "[object Error]") {
+        const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
+        if (err.stack)
+          error.stack = err.stack;
+        if (err.cause && !error.cause)
+          error.cause = err.cause;
+        if (err.name)
+          error.name = err.name;
+        return error;
       }
-      multiContent.push(...imageParts);
-      result.push({
-        role: "user",
-        content: multiContent
-      });
-    } else if (textParts.length > 0) {
-      result.push({
-        role: "user",
-        content: textParts.join(`
-`)
-      });
-    }
-  }
-  return result;
-}
-function convertToolResult(block) {
-  let content;
-  if (typeof block.content === "string") {
-    content = block.content;
-  } else if (Array.isArray(block.content)) {
-    content = block.content.map((c) => {
-      if (typeof c === "string")
-        return c;
-      if ("text" in c)
-        return c.text;
-      return "";
-    }).filter(Boolean).join(`
-`);
-  } else {
-    content = "";
+    } catch {}
+    try {
+      return new Error(JSON.stringify(err));
+    } catch {}
   }
-  return {
-    role: "tool",
-    tool_call_id: block.tool_use_id,
-    content
+  return new Error(err);
+};
+var init_errors = () => {};
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/core/error.mjs
+var OpenAIError, APIError, APIUserAbortError, APIConnectionError, APIConnectionTimeoutError, BadRequestError, AuthenticationError, PermissionDeniedError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, LengthFinishReasonError, ContentFilterFinishReasonError, InvalidWebhookSignatureError;
+var init_error = __esm(() => {
+  init_errors();
+  OpenAIError = class OpenAIError extends Error {
   };
-}
-function convertInternalAssistantMessage(msg, preserveReasoning = false) {
-  const content = msg.message.content;
-  if (typeof content === "string") {
-    return [
-      {
-        role: "assistant",
-        content
+  APIError = class APIError extends OpenAIError {
+    constructor(status, error, message, headers) {
+      super(`${APIError.makeMessage(status, error, message)}`);
+      this.status = status;
+      this.headers = headers;
+      this.requestID = headers?.get("x-request-id");
+      this.error = error;
+      const data = error;
+      this.code = data?.["code"];
+      this.param = data?.["param"];
+      this.type = data?.["type"];
+    }
+    static makeMessage(status, error, message) {
+      const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+      if (status && msg) {
+        return `${status} ${msg}`;
       }
-    ];
-  }
-  if (!Array.isArray(content)) {
-    return [
-      {
-        role: "assistant",
-        content: ""
+      if (status) {
+        return `${status} status code (no body)`;
       }
-    ];
-  }
-  const textParts = [];
-  const toolCalls = [];
-  const reasoningParts = [];
-  for (const block of content) {
-    if (typeof block === "string") {
-      textParts.push(block);
-    } else if (block.type === "text") {
-      textParts.push(block.text);
-    } else if (block.type === "tool_use") {
-      const tu = block;
-      toolCalls.push({
-        id: tu.id,
-        type: "function",
-        function: {
-          name: tu.name,
-          arguments: typeof tu.input === "string" ? tu.input : JSON.stringify(tu.input)
-        }
-      });
-    } else if (block.type === "thinking" && preserveReasoning) {
-      const thinkingText = block.thinking;
-      if (typeof thinkingText === "string" && thinkingText) {
-        reasoningParts.push(thinkingText);
+      if (msg) {
+        return msg;
       }
+      return "(no status code or body)";
+    }
+    static generate(status, errorResponse, message, headers) {
+      if (!status || !headers) {
+        return new APIConnectionError({ message, cause: castToError(errorResponse) });
+      }
+      const error = errorResponse?.["error"];
+      if (status === 400) {
+        return new BadRequestError(status, error, message, headers);
+      }
+      if (status === 401) {
+        return new AuthenticationError(status, error, message, headers);
+      }
+      if (status === 403) {
+        return new PermissionDeniedError(status, error, message, headers);
+      }
+      if (status === 404) {
+        return new NotFoundError(status, error, message, headers);
+      }
+      if (status === 409) {
+        return new ConflictError(status, error, message, headers);
+      }
+      if (status === 422) {
+        return new UnprocessableEntityError(status, error, message, headers);
+      }
+      if (status === 429) {
+        return new RateLimitError(status, error, message, headers);
+      }
+      if (status >= 500) {
+        return new InternalServerError(status, error, message, headers);
+      }
+      return new APIError(status, error, message, headers);
     }
-  }
-  const result = {
-    role: "assistant",
-    content: textParts.length > 0 ? textParts.join(`
-`) : null,
-    ...toolCalls.length > 0 && { tool_calls: toolCalls },
-    ...reasoningParts.length > 0 && { reasoning_content: reasoningParts.join(`
-`) }
   };
-  return [result];
+  APIUserAbortError = class APIUserAbortError extends APIError {
+    constructor({ message } = {}) {
+      super(undefined, undefined, message || "Request was aborted.", undefined);
+    }
+  };
+  APIConnectionError = class APIConnectionError extends APIError {
+    constructor({ message, cause }) {
+      super(undefined, undefined, message || "Connection error.", undefined);
+      if (cause)
+        this.cause = cause;
+    }
+  };
+  APIConnectionTimeoutError = class APIConnectionTimeoutError extends APIConnectionError {
+    constructor({ message } = {}) {
+      super({ message: message ?? "Request timed out." });
+    }
+  };
+  BadRequestError = class BadRequestError extends APIError {
+  };
+  AuthenticationError = class AuthenticationError extends APIError {
+  };
+  PermissionDeniedError = class PermissionDeniedError extends APIError {
+  };
+  NotFoundError = class NotFoundError extends APIError {
+  };
+  ConflictError = class ConflictError extends APIError {
+  };
+  UnprocessableEntityError = class UnprocessableEntityError extends APIError {
+  };
+  RateLimitError = class RateLimitError extends APIError {
+  };
+  InternalServerError = class InternalServerError extends APIError {
+  };
+  LengthFinishReasonError = class LengthFinishReasonError extends OpenAIError {
+    constructor() {
+      super(`Could not parse response content as the length limit was reached`);
+    }
+  };
+  ContentFilterFinishReasonError = class ContentFilterFinishReasonError extends OpenAIError {
+    constructor() {
+      super(`Could not parse response content as the request was rejected by the content filter`);
+    }
+  };
+  InvalidWebhookSignatureError = class InvalidWebhookSignatureError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+});
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/utils/values.mjs
+function maybeObj(x) {
+  if (typeof x !== "object") {
+    return {};
+  }
+  return x ?? {};
 }
-function convertImageBlockToOpenAI(block) {
-  const source = block.source;
-  if (!source)
+function isEmptyObj(obj) {
+  if (!obj)
+    return true;
+  for (const _k in obj)
+    return false;
+  return true;
+}
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isObj(obj) {
+  return obj != null && typeof obj === "object" && !Array.isArray(obj);
+}
+var startsWithSchemeRegexp, isAbsoluteURL = (url) => {
+  return startsWithSchemeRegexp.test(url);
+}, isArray = (val) => (isArray = Array.isArray, isArray(val)), isReadonlyArray, validatePositiveInteger = (name, n) => {
+  if (typeof n !== "number" || !Number.isInteger(n)) {
+    throw new OpenAIError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new OpenAIError(`${name} must be a positive integer`);
+  }
+  return n;
+}, safeJSON = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return;
+  }
+};
+var init_values = __esm(() => {
+  init_error();
+  startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+  isReadonlyArray = isArray;
+});
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/utils/sleep.mjs
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var init_sleep = () => {};
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/version.mjs
+var VERSION = "6.33.0";
+var init_version = () => {};
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/detect-platform.mjs
+function getDetectedPlatform() {
+  if (typeof Deno !== "undefined" && Deno.build != null) {
+    return "deno";
+  }
+  if (typeof EdgeRuntime !== "undefined") {
+    return "edge";
+  }
+  if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") {
+    return "node";
+  }
+  return "unknown";
+}
+function getBrowserInfo() {
+  if (typeof navigator === "undefined" || !navigator) {
     return null;
-  if (source.type === "base64" && typeof source.data === "string") {
-    const mediaType = source.media_type || "image/png";
+  }
+  const browserPatterns = [
+    { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }
+  ];
+  for (const { key, pattern } of browserPatterns) {
+    const match = pattern.exec(navigator.userAgent);
+    if (match) {
+      const major = match[1] || 0;
+      const minor = match[2] || 0;
+      const patch = match[3] || 0;
+      return { browser: key, version: `${major}.${minor}.${patch}` };
+    }
+  }
+  return null;
+}
+var isRunningInBrowser = () => {
+  return typeof window !== "undefined" && typeof window.document !== "undefined" && typeof navigator !== "undefined";
+}, getPlatformProperties = () => {
+  const detectedPlatform = getDetectedPlatform();
+  if (detectedPlatform === "deno") {
     return {
-      type: "image_url",
-      image_url: {
-        url: `data:${mediaType};base64,${source.data}`
-      }
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": normalizePlatform(Deno.build.os),
+      "X-Stainless-Arch": normalizeArch(Deno.build.arch),
+      "X-Stainless-Runtime": "deno",
+      "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown"
     };
   }
-  if (source.type === "url" && typeof source.url === "string") {
+  if (typeof EdgeRuntime !== "undefined") {
     return {
-      type: "image_url",
-      image_url: {
-        url: source.url
-      }
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": "Unknown",
+      "X-Stainless-Arch": `other:${EdgeRuntime}`,
+      "X-Stainless-Runtime": "edge",
+      "X-Stainless-Runtime-Version": globalThis.process.version
     };
   }
-  return null;
-}
-var init_convertMessages = () => {};
-
-// src/services/api/openai/convertTools.ts
-function anthropicToolsToOpenAI(tools) {
-  return tools.filter((tool) => {
-    const toolType = tool.type;
-    return tool.type === "custom" || !("type" in tool) || toolType !== "server";
-  }).map((tool) => {
-    const anyTool = tool;
-    const name = anyTool.name || "";
-    const description = anyTool.description || "";
-    const inputSchema = anyTool.input_schema;
+  if (detectedPlatform === "node") {
     return {
-      type: "function",
-      function: {
-        name,
-        description,
-        parameters: sanitizeJsonSchema(inputSchema || { type: "object", properties: {} })
-      }
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"),
+      "X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"),
+      "X-Stainless-Runtime": "node",
+      "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown"
     };
-  });
-}
-function sanitizeJsonSchema(schema) {
-  if (!schema || typeof schema !== "object")
-    return schema;
-  const result = { ...schema };
-  if ("const" in result) {
-    result.enum = [result.const];
-    delete result.const;
   }
-  const objectKeys = ["properties", "definitions", "$defs", "patternProperties"];
-  for (const key of objectKeys) {
-    const nested = result[key];
-    if (nested && typeof nested === "object") {
-      const sanitized = {};
-      for (const [k, v] of Object.entries(nested)) {
-        sanitized[k] = v && typeof v === "object" ? sanitizeJsonSchema(v) : v;
-      }
-      result[key] = sanitized;
-    }
-  }
-  const singleKeys = ["items", "additionalProperties", "not", "if", "then", "else", "contains", "propertyNames"];
-  for (const key of singleKeys) {
-    const nested = result[key];
-    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
-      result[key] = sanitizeJsonSchema(nested);
-    }
-  }
-  const arrayKeys = ["anyOf", "oneOf", "allOf"];
-  for (const key of arrayKeys) {
-    const nested = result[key];
-    if (Array.isArray(nested)) {
-      result[key] = nested.map((item) => item && typeof item === "object" ? sanitizeJsonSchema(item) : item);
-    }
-  }
-  return result;
-}
-function anthropicToolChoiceToOpenAI(toolChoice) {
-  if (!toolChoice || typeof toolChoice !== "object")
-    return;
-  const tc = toolChoice;
-  const type = tc.type;
-  switch (type) {
-    case "auto":
-      return "auto";
-    case "any":
-      return "required";
-    case "tool":
-      return {
-        type: "function",
-        function: { name: tc.name }
-      };
-    default:
-      return;
-  }
-}
-var init_convertTools = () => {};
-
-// src/services/api/openai/streamAdapter.ts
-import { randomUUID } from "crypto";
-async function* adaptOpenAIStreamToAnthropic(stream, model) {
-  const messageId = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
-  let started = false;
-  let currentContentIndex = -1;
-  const toolBlocks = new Map;
-  let thinkingBlockOpen = false;
-  let textBlockOpen = false;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let cachedReadTokens = 0;
-  const openBlockIndices = new Set;
-  let pendingFinishReason = null;
-  let pendingHasToolCalls = false;
-  for await (const chunk of stream) {
-    const choice = chunk.choices?.[0];
-    const delta = choice?.delta;
-    if (chunk.usage) {
-      inputTokens = chunk.usage.prompt_tokens ?? inputTokens;
-      outputTokens = chunk.usage.completion_tokens ?? outputTokens;
-      const details = chunk.usage.prompt_tokens_details;
-      if (details?.cached_tokens != null) {
-        cachedReadTokens = details.cached_tokens;
-      }
-    }
-    if (!started) {
-      started = true;
-      yield {
-        type: "message_start",
-        message: {
-          id: messageId,
-          type: "message",
-          role: "assistant",
-          content: [],
-          model,
-          stop_reason: null,
-          stop_sequence: null,
-          usage: {
-            input_tokens: inputTokens,
-            output_tokens: 0,
-            cache_creation_input_tokens: 0,
-            cache_read_input_tokens: cachedReadTokens
-          }
-        }
-      };
-    }
-    if (!delta)
-      continue;
-    const reasoningContent = delta.reasoning_content;
-    if (reasoningContent != null && reasoningContent !== "") {
-      if (!thinkingBlockOpen) {
-        currentContentIndex++;
-        thinkingBlockOpen = true;
-        openBlockIndices.add(currentContentIndex);
-        yield {
-          type: "content_block_start",
-          index: currentContentIndex,
-          content_block: {
-            type: "thinking",
-            thinking: "",
-            signature: ""
-          }
-        };
-      }
-      yield {
-        type: "content_block_delta",
-        index: currentContentIndex,
-        delta: {
-          type: "thinking_delta",
-          thinking: reasoningContent
-        }
-      };
-    }
-    if (delta.content != null && delta.content !== "") {
-      if (!textBlockOpen) {
-        if (thinkingBlockOpen) {
-          yield {
-            type: "content_block_stop",
-            index: currentContentIndex
-          };
-          openBlockIndices.delete(currentContentIndex);
-          thinkingBlockOpen = false;
-        }
-        currentContentIndex++;
-        textBlockOpen = true;
-        openBlockIndices.add(currentContentIndex);
-        yield {
-          type: "content_block_start",
-          index: currentContentIndex,
-          content_block: {
-            type: "text",
-            text: ""
-          }
-        };
-      }
-      yield {
-        type: "content_block_delta",
-        index: currentContentIndex,
-        delta: {
-          type: "text_delta",
-          text: delta.content
-        }
-      };
-    }
-    if (delta.tool_calls) {
-      for (const tc of delta.tool_calls) {
-        const tcIndex = tc.index;
-        if (!toolBlocks.has(tcIndex)) {
-          if (thinkingBlockOpen) {
-            yield {
-              type: "content_block_stop",
-              index: currentContentIndex
-            };
-            openBlockIndices.delete(currentContentIndex);
-            thinkingBlockOpen = false;
-          }
-          if (textBlockOpen) {
-            yield {
-              type: "content_block_stop",
-              index: currentContentIndex
-            };
-            openBlockIndices.delete(currentContentIndex);
-            textBlockOpen = false;
-          }
-          currentContentIndex++;
-          const toolId = tc.id || `toolu_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
-          const toolName = tc.function?.name || "";
-          toolBlocks.set(tcIndex, {
-            contentIndex: currentContentIndex,
-            id: toolId,
-            name: toolName,
-            arguments: ""
-          });
-          openBlockIndices.add(currentContentIndex);
-          yield {
-            type: "content_block_start",
-            index: currentContentIndex,
-            content_block: {
-              type: "tool_use",
-              id: toolId,
-              name: toolName,
-              input: {}
-            }
-          };
-        }
-        const argFragment = tc.function?.arguments;
-        if (argFragment) {
-          toolBlocks.get(tcIndex).arguments += argFragment;
-          yield {
-            type: "content_block_delta",
-            index: toolBlocks.get(tcIndex).contentIndex,
-            delta: {
-              type: "input_json_delta",
-              partial_json: argFragment
-            }
-          };
-        }
-      }
-    }
-    if (choice?.finish_reason) {
-      if (thinkingBlockOpen) {
-        yield {
-          type: "content_block_stop",
-          index: currentContentIndex
-        };
-        openBlockIndices.delete(currentContentIndex);
-        thinkingBlockOpen = false;
-      }
-      if (textBlockOpen) {
-        yield {
-          type: "content_block_stop",
-          index: currentContentIndex
-        };
-        openBlockIndices.delete(currentContentIndex);
-        textBlockOpen = false;
-      }
-      for (const [, block] of toolBlocks) {
-        if (openBlockIndices.has(block.contentIndex)) {
-          yield {
-            type: "content_block_stop",
-            index: block.contentIndex
-          };
-          openBlockIndices.delete(block.contentIndex);
-        }
-      }
-      pendingFinishReason = choice.finish_reason;
-      pendingHasToolCalls = toolBlocks.size > 0;
-    }
-  }
-  for (const idx of openBlockIndices) {
-    yield {
-      type: "content_block_stop",
-      index: idx
-    };
-  }
-  if (pendingFinishReason !== null) {
-    const stopReason = pendingFinishReason === "length" ? "max_tokens" : pendingHasToolCalls ? "tool_use" : mapFinishReason(pendingFinishReason);
-    yield {
-      type: "message_delta",
-      delta: {
-        stop_reason: stopReason,
-        stop_sequence: null
-      },
-      usage: {
-        input_tokens: inputTokens,
-        output_tokens: outputTokens,
-        cache_read_input_tokens: cachedReadTokens,
-        cache_creation_input_tokens: 0
-      }
-    };
-    yield {
-      type: "message_stop"
-    };
-  }
-}
-function mapFinishReason(reason) {
-  switch (reason) {
-    case "stop":
-      return "end_turn";
-    case "tool_calls":
-      return "tool_use";
-    case "length":
-      return "max_tokens";
-    case "content_filter":
-      return "end_turn";
-    default:
-      return "end_turn";
-  }
-}
-var init_streamAdapter = () => {};
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/tslib.mjs
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-  if (kind === "m")
-    throw new TypeError("Private method is not writable");
-  if (kind === "a" && !f)
-    throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-    throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
-}
-function __classPrivateFieldGet(receiver, state, kind, f) {
-  if (kind === "a" && !f)
-    throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-    throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-var init_tslib = () => {};
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/utils/uuid.mjs
-var uuid4 = function() {
-  const { crypto: crypto2 } = globalThis;
-  if (crypto2?.randomUUID) {
-    uuid4 = crypto2.randomUUID.bind(crypto2);
-    return crypto2.randomUUID();
-  }
-  const u8 = new Uint8Array(1);
-  const randomByte = crypto2 ? () => crypto2.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
-  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16));
-};
-var init_uuid = () => {};
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/errors.mjs
-function isAbortError(err) {
-  return typeof err === "object" && err !== null && (("name" in err) && err.name === "AbortError" || ("message" in err) && String(err.message).includes("FetchRequestCanceledException"));
-}
-var castToError = (err) => {
-  if (err instanceof Error)
-    return err;
-  if (typeof err === "object" && err !== null) {
-    try {
-      if (Object.prototype.toString.call(err) === "[object Error]") {
-        const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
-        if (err.stack)
-          error.stack = err.stack;
-        if (err.cause && !error.cause)
-          error.cause = err.cause;
-        if (err.name)
-          error.name = err.name;
-        return error;
-      }
-    } catch {}
-    try {
-      return new Error(JSON.stringify(err));
-    } catch {}
-  }
-  return new Error(err);
-};
-var init_errors = () => {};
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/core/error.mjs
-var OpenAIError, APIError, APIUserAbortError, APIConnectionError, APIConnectionTimeoutError, BadRequestError, AuthenticationError, PermissionDeniedError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, LengthFinishReasonError, ContentFilterFinishReasonError, InvalidWebhookSignatureError;
-var init_error = __esm(() => {
-  init_errors();
-  OpenAIError = class OpenAIError extends Error {
-  };
-  APIError = class APIError extends OpenAIError {
-    constructor(status, error, message, headers) {
-      super(`${APIError.makeMessage(status, error, message)}`);
-      this.status = status;
-      this.headers = headers;
-      this.requestID = headers?.get("x-request-id");
-      this.error = error;
-      const data = error;
-      this.code = data?.["code"];
-      this.param = data?.["param"];
-      this.type = data?.["type"];
-    }
-    static makeMessage(status, error, message) {
-      const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
-      if (status && msg) {
-        return `${status} ${msg}`;
-      }
-      if (status) {
-        return `${status} status code (no body)`;
-      }
-      if (msg) {
-        return msg;
-      }
-      return "(no status code or body)";
-    }
-    static generate(status, errorResponse, message, headers) {
-      if (!status || !headers) {
-        return new APIConnectionError({ message, cause: castToError(errorResponse) });
-      }
-      const error = errorResponse?.["error"];
-      if (status === 400) {
-        return new BadRequestError(status, error, message, headers);
-      }
-      if (status === 401) {
-        return new AuthenticationError(status, error, message, headers);
-      }
-      if (status === 403) {
-        return new PermissionDeniedError(status, error, message, headers);
-      }
-      if (status === 404) {
-        return new NotFoundError(status, error, message, headers);
-      }
-      if (status === 409) {
-        return new ConflictError(status, error, message, headers);
-      }
-      if (status === 422) {
-        return new UnprocessableEntityError(status, error, message, headers);
-      }
-      if (status === 429) {
-        return new RateLimitError(status, error, message, headers);
-      }
-      if (status >= 500) {
-        return new InternalServerError(status, error, message, headers);
-      }
-      return new APIError(status, error, message, headers);
-    }
-  };
-  APIUserAbortError = class APIUserAbortError extends APIError {
-    constructor({ message } = {}) {
-      super(undefined, undefined, message || "Request was aborted.", undefined);
-    }
-  };
-  APIConnectionError = class APIConnectionError extends APIError {
-    constructor({ message, cause }) {
-      super(undefined, undefined, message || "Connection error.", undefined);
-      if (cause)
-        this.cause = cause;
-    }
-  };
-  APIConnectionTimeoutError = class APIConnectionTimeoutError extends APIConnectionError {
-    constructor({ message } = {}) {
-      super({ message: message ?? "Request timed out." });
-    }
-  };
-  BadRequestError = class BadRequestError extends APIError {
-  };
-  AuthenticationError = class AuthenticationError extends APIError {
-  };
-  PermissionDeniedError = class PermissionDeniedError extends APIError {
-  };
-  NotFoundError = class NotFoundError extends APIError {
-  };
-  ConflictError = class ConflictError extends APIError {
-  };
-  UnprocessableEntityError = class UnprocessableEntityError extends APIError {
-  };
-  RateLimitError = class RateLimitError extends APIError {
-  };
-  InternalServerError = class InternalServerError extends APIError {
-  };
-  LengthFinishReasonError = class LengthFinishReasonError extends OpenAIError {
-    constructor() {
-      super(`Could not parse response content as the length limit was reached`);
-    }
-  };
-  ContentFilterFinishReasonError = class ContentFilterFinishReasonError extends OpenAIError {
-    constructor() {
-      super(`Could not parse response content as the request was rejected by the content filter`);
-    }
-  };
-  InvalidWebhookSignatureError = class InvalidWebhookSignatureError extends Error {
-    constructor(message) {
-      super(message);
-    }
-  };
-});
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/utils/values.mjs
-function maybeObj(x) {
-  if (typeof x !== "object") {
-    return {};
-  }
-  return x ?? {};
-}
-function isEmptyObj(obj) {
-  if (!obj)
-    return true;
-  for (const _k in obj)
-    return false;
-  return true;
-}
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-}
-function isObj(obj) {
-  return obj != null && typeof obj === "object" && !Array.isArray(obj);
-}
-var startsWithSchemeRegexp, isAbsoluteURL = (url) => {
-  return startsWithSchemeRegexp.test(url);
-}, isArray = (val) => (isArray = Array.isArray, isArray(val)), isReadonlyArray, validatePositiveInteger = (name, n) => {
-  if (typeof n !== "number" || !Number.isInteger(n)) {
-    throw new OpenAIError(`${name} must be an integer`);
-  }
-  if (n < 0) {
-    throw new OpenAIError(`${name} must be a positive integer`);
-  }
-  return n;
-}, safeJSON = (text) => {
-  try {
-    return JSON.parse(text);
-  } catch (err) {
-    return;
-  }
-};
-var init_values = __esm(() => {
-  init_error();
-  startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
-  isReadonlyArray = isArray;
-});
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/utils/sleep.mjs
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var init_sleep = () => {};
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/version.mjs
-var VERSION = "6.33.0";
-var init_version = () => {};
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/internal/detect-platform.mjs
-function getDetectedPlatform() {
-  if (typeof Deno !== "undefined" && Deno.build != null) {
-    return "deno";
-  }
-  if (typeof EdgeRuntime !== "undefined") {
-    return "edge";
-  }
-  if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") {
-    return "node";
-  }
-  return "unknown";
-}
-function getBrowserInfo() {
-  if (typeof navigator === "undefined" || !navigator) {
-    return null;
-  }
-  const browserPatterns = [
-    { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
-    { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
-    { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
-    { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
-    { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
-    { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }
-  ];
-  for (const { key, pattern } of browserPatterns) {
-    const match = pattern.exec(navigator.userAgent);
-    if (match) {
-      const major = match[1] || 0;
-      const minor = match[2] || 0;
-      const patch = match[3] || 0;
-      return { browser: key, version: `${major}.${minor}.${patch}` };
-    }
-  }
-  return null;
-}
-var isRunningInBrowser = () => {
-  return typeof window !== "undefined" && typeof window.document !== "undefined" && typeof navigator !== "undefined";
-}, getPlatformProperties = () => {
-  const detectedPlatform = getDetectedPlatform();
-  if (detectedPlatform === "deno") {
-    return {
-      "X-Stainless-Lang": "js",
-      "X-Stainless-Package-Version": VERSION,
-      "X-Stainless-OS": normalizePlatform(Deno.build.os),
-      "X-Stainless-Arch": normalizeArch(Deno.build.arch),
-      "X-Stainless-Runtime": "deno",
-      "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown"
-    };
-  }
-  if (typeof EdgeRuntime !== "undefined") {
-    return {
-      "X-Stainless-Lang": "js",
-      "X-Stainless-Package-Version": VERSION,
-      "X-Stainless-OS": "Unknown",
-      "X-Stainless-Arch": `other:${EdgeRuntime}`,
-      "X-Stainless-Runtime": "edge",
-      "X-Stainless-Runtime-Version": globalThis.process.version
-    };
-  }
-  if (detectedPlatform === "node") {
-    return {
-      "X-Stainless-Lang": "js",
-      "X-Stainless-Package-Version": VERSION,
-      "X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"),
-      "X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"),
-      "X-Stainless-Runtime": "node",
-      "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown"
-    };
-  }
-  const browserInfo = getBrowserInfo();
-  if (browserInfo) {
-    return {
-      "X-Stainless-Lang": "js",
-      "X-Stainless-Package-Version": VERSION,
-      "X-Stainless-OS": "Unknown",
-      "X-Stainless-Arch": "unknown",
-      "X-Stainless-Runtime": `browser:${browserInfo.browser}`,
-      "X-Stainless-Runtime-Version": browserInfo.version
-    };
+  const browserInfo = getBrowserInfo();
+  if (browserInfo) {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": "Unknown",
+      "X-Stainless-Arch": "unknown",
+      "X-Stainless-Runtime": `browser:${browserInfo.browser}`,
+      "X-Stainless-Runtime-Version": browserInfo.version
+    };
   }
   return {
     "X-Stainless-Lang": "js",
@@ -2157,7 +1759,7 @@ var init_path = __esm(() => {
 
 // node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/chat/completions/messages.mjs
 var Messages;
-var init_messages = __esm(() => {
+var init_messages2 = __esm(() => {
   init_resource();
   init_pagination();
   init_path();
@@ -3423,8 +3025,8 @@ var init_ChatCompletionStreamingRunner = __esm(() => {
 var Completions;
 var init_completions = __esm(() => {
   init_resource();
-  init_messages();
-  init_messages();
+  init_messages2();
+  init_messages2();
   init_pagination();
   init_path();
   init_ChatCompletionRunner();
@@ -3496,7 +3098,7 @@ var init_chat = __esm(() => {
 // node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/chat/completions/index.mjs
 var init_completions2 = __esm(() => {
   init_completions();
-  init_messages();
+  init_messages2();
   init_completions();
 });
 
@@ -3838,7 +3440,7 @@ var init_chatkit = __esm(() => {
 
 // node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/beta/threads/messages.mjs
 var Messages2;
-var init_messages2 = __esm(() => {
+var init_messages3 = __esm(() => {
   init_resource();
   init_pagination();
   init_headers();
@@ -4608,8 +4210,8 @@ var init_runs = __esm(() => {
 var Threads2;
 var init_threads2 = __esm(() => {
   init_resource();
-  init_messages2();
-  init_messages2();
+  init_messages3();
+  init_messages3();
   init_runs();
   init_runs();
   init_headers();
@@ -6247,649 +5849,1579 @@ var init_videos = __esm(() => {
     edit(body, options) {
       return this._client.post("/videos/edits", multipartFormRequestOptions({ body, ...options }, this._client));
     }
-    extend(body, options) {
-      return this._client.post("/videos/extensions", multipartFormRequestOptions({ body, ...options }, this._client));
+    extend(body, options) {
+      return this._client.post("/videos/extensions", multipartFormRequestOptions({ body, ...options }, this._client));
+    }
+    getCharacter(characterID, options) {
+      return this._client.get(path`/videos/characters/${characterID}`, options);
+    }
+    remix(videoID, body, options) {
+      return this._client.post(path`/videos/${videoID}/remix`, maybeMultipartFormRequestOptions({ body, ...options }, this._client));
+    }
+  };
+});
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/webhooks/webhooks.mjs
+var _Webhooks_instances, _Webhooks_validateSecret, _Webhooks_getRequiredHeader, Webhooks;
+var init_webhooks = __esm(() => {
+  init_tslib();
+  init_error2();
+  init_resource();
+  init_headers();
+  Webhooks = class Webhooks extends APIResource {
+    constructor() {
+      super(...arguments);
+      _Webhooks_instances.add(this);
+    }
+    async unwrap(payload, headers, secret = this._client.webhookSecret, tolerance = 300) {
+      await this.verifySignature(payload, headers, secret, tolerance);
+      return JSON.parse(payload);
+    }
+    async verifySignature(payload, headers, secret = this._client.webhookSecret, tolerance = 300) {
+      if (typeof crypto === "undefined" || typeof crypto.subtle.importKey !== "function" || typeof crypto.subtle.verify !== "function") {
+        throw new Error("Webhook signature verification is only supported when the `crypto` global is defined");
+      }
+      __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_validateSecret).call(this, secret);
+      const headersObj = buildHeaders([headers]).values;
+      const signatureHeader = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-signature");
+      const timestamp = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-timestamp");
+      const webhookId = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-id");
+      const timestampSeconds = parseInt(timestamp, 10);
+      if (isNaN(timestampSeconds)) {
+        throw new InvalidWebhookSignatureError("Invalid webhook timestamp format");
+      }
+      const nowSeconds = Math.floor(Date.now() / 1000);
+      if (nowSeconds - timestampSeconds > tolerance) {
+        throw new InvalidWebhookSignatureError("Webhook timestamp is too old");
+      }
+      if (timestampSeconds > nowSeconds + tolerance) {
+        throw new InvalidWebhookSignatureError("Webhook timestamp is too new");
+      }
+      const signatures = signatureHeader.split(" ").map((part) => part.startsWith("v1,") ? part.substring(3) : part);
+      const decodedSecret = secret.startsWith("whsec_") ? Buffer.from(secret.replace("whsec_", ""), "base64") : Buffer.from(secret, "utf-8");
+      const signedPayload = webhookId ? `${webhookId}.${timestamp}.${payload}` : `${timestamp}.${payload}`;
+      const key = await crypto.subtle.importKey("raw", decodedSecret, { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
+      for (const signature of signatures) {
+        try {
+          const signatureBytes = Buffer.from(signature, "base64");
+          const isValid = await crypto.subtle.verify("HMAC", key, signatureBytes, new TextEncoder().encode(signedPayload));
+          if (isValid) {
+            return;
+          }
+        } catch {
+          continue;
+        }
+      }
+      throw new InvalidWebhookSignatureError("The given webhook signature does not match the expected signature");
+    }
+  };
+  _Webhooks_instances = new WeakSet, _Webhooks_validateSecret = function _Webhooks_validateSecret2(secret) {
+    if (typeof secret !== "string" || secret.length === 0) {
+      throw new Error(`The webhook secret must either be set using the env var, OPENAI_WEBHOOK_SECRET, on the client class, OpenAI({ webhookSecret: '123' }), or passed to this function`);
+    }
+  }, _Webhooks_getRequiredHeader = function _Webhooks_getRequiredHeader2(headers, name) {
+    if (!headers) {
+      throw new Error(`Headers are required`);
+    }
+    const value = headers.get(name);
+    if (value === null || value === undefined) {
+      throw new Error(`Missing required header: ${name}`);
+    }
+    return value;
+  };
+});
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/webhooks/index.mjs
+var init_webhooks2 = __esm(() => {
+  init_webhooks();
+});
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/webhooks.mjs
+var init_webhooks3 = __esm(() => {
+  init_webhooks2();
+});
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/index.mjs
+var init_resources = __esm(() => {
+  init_audio();
+  init_batches();
+  init_beta();
+  init_completions3();
+  init_containers();
+  init_conversations();
+  init_embeddings();
+  init_evals();
+  init_files2();
+  init_fine_tuning();
+  init_graders2();
+  init_images();
+  init_models();
+  init_moderations();
+  init_realtime2();
+  init_responses();
+  init_skills();
+  init_uploads3();
+  init_vector_stores();
+  init_videos();
+  init_webhooks3();
+  init_chat2();
+  init_shared();
+});
+
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/client.mjs
+class OpenAI {
+  constructor({ baseURL = readEnv("OPENAI_BASE_URL"), apiKey = readEnv("OPENAI_API_KEY"), organization = readEnv("OPENAI_ORG_ID") ?? null, project = readEnv("OPENAI_PROJECT_ID") ?? null, webhookSecret = readEnv("OPENAI_WEBHOOK_SECRET") ?? null, ...opts } = {}) {
+    _OpenAI_instances.add(this);
+    _OpenAI_encoder.set(this, undefined);
+    this.completions = new Completions2(this);
+    this.chat = new Chat(this);
+    this.embeddings = new Embeddings(this);
+    this.files = new Files2(this);
+    this.images = new Images(this);
+    this.audio = new Audio(this);
+    this.moderations = new Moderations(this);
+    this.models = new Models(this);
+    this.fineTuning = new FineTuning(this);
+    this.graders = new Graders2(this);
+    this.vectorStores = new VectorStores(this);
+    this.webhooks = new Webhooks(this);
+    this.beta = new Beta(this);
+    this.batches = new Batches(this);
+    this.uploads = new Uploads(this);
+    this.responses = new Responses(this);
+    this.realtime = new Realtime2(this);
+    this.conversations = new Conversations(this);
+    this.evals = new Evals(this);
+    this.containers = new Containers(this);
+    this.skills = new Skills(this);
+    this.videos = new Videos(this);
+    if (apiKey === undefined) {
+      throw new OpenAIError("Missing credentials. Please pass an `apiKey`, or set the `OPENAI_API_KEY` environment variable.");
+    }
+    const options = {
+      apiKey,
+      organization,
+      project,
+      webhookSecret,
+      ...opts,
+      baseURL: baseURL || `https://api.openai.com/v1`
+    };
+    if (!options.dangerouslyAllowBrowser && isRunningInBrowser()) {
+      throw new OpenAIError(`It looks like you're running in a browser-like environment.
+
+This is disabled by default, as it risks exposing your secret API credentials to attackers.
+If you understand the risks and have appropriate mitigations in place,
+you can set the \`dangerouslyAllowBrowser\` option to \`true\`, e.g.,
+
+new OpenAI({ apiKey, dangerouslyAllowBrowser: true });
+
+https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety
+`);
+    }
+    this.baseURL = options.baseURL;
+    this.timeout = options.timeout ?? _a2.DEFAULT_TIMEOUT;
+    this.logger = options.logger ?? console;
+    const defaultLogLevel = "warn";
+    this.logLevel = defaultLogLevel;
+    this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("OPENAI_LOG"), "process.env['OPENAI_LOG']", this) ?? defaultLogLevel;
+    this.fetchOptions = options.fetchOptions;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.fetch = options.fetch ?? getDefaultFetch();
+    __classPrivateFieldSet(this, _OpenAI_encoder, FallbackEncoder, "f");
+    this._options = options;
+    this.apiKey = typeof apiKey === "string" ? apiKey : "Missing Key";
+    this.organization = organization;
+    this.project = project;
+    this.webhookSecret = webhookSecret;
+  }
+  withOptions(options) {
+    const client = new this.constructor({
+      ...this._options,
+      baseURL: this.baseURL,
+      maxRetries: this.maxRetries,
+      timeout: this.timeout,
+      logger: this.logger,
+      logLevel: this.logLevel,
+      fetch: this.fetch,
+      fetchOptions: this.fetchOptions,
+      apiKey: this.apiKey,
+      organization: this.organization,
+      project: this.project,
+      webhookSecret: this.webhookSecret,
+      ...options
+    });
+    return client;
+  }
+  defaultQuery() {
+    return this._options.defaultQuery;
+  }
+  validateHeaders({ values: values2, nulls }) {
+    return;
+  }
+  async authHeaders(opts) {
+    return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
+  }
+  stringifyQuery(query2) {
+    return stringifyQuery(query2);
+  }
+  getUserAgent() {
+    return `${this.constructor.name}/JS ${VERSION}`;
+  }
+  defaultIdempotencyKey() {
+    return `stainless-node-retry-${uuid4()}`;
+  }
+  makeStatusError(status, error2, message, headers) {
+    return APIError.generate(status, error2, message, headers);
+  }
+  async _callApiKey() {
+    const apiKey = this._options.apiKey;
+    if (typeof apiKey !== "function")
+      return false;
+    let token;
+    try {
+      token = await apiKey();
+    } catch (err) {
+      if (err instanceof OpenAIError)
+        throw err;
+      throw new OpenAIError(`Failed to get token from 'apiKey' function: ${err.message}`, { cause: err });
+    }
+    if (typeof token !== "string" || !token) {
+      throw new OpenAIError(`Expected 'apiKey' function argument to return a string but it returned ${token}`);
     }
-    getCharacter(characterID, options) {
-      return this._client.get(path`/videos/characters/${characterID}`, options);
+    this.apiKey = token;
+    return true;
+  }
+  buildURL(path2, query2, defaultBaseURL) {
+    const baseURL = !__classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
+    const url = isAbsoluteURL(path2) ? new URL(path2) : new URL(baseURL + (baseURL.endsWith("/") && path2.startsWith("/") ? path2.slice(1) : path2));
+    const defaultQuery = this.defaultQuery();
+    const pathQuery = Object.fromEntries(url.searchParams);
+    if (!isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) {
+      query2 = { ...pathQuery, ...defaultQuery, ...query2 };
     }
-    remix(videoID, body, options) {
-      return this._client.post(path`/videos/${videoID}/remix`, maybeMultipartFormRequestOptions({ body, ...options }, this._client));
+    if (typeof query2 === "object" && query2 && !Array.isArray(query2)) {
+      url.search = this.stringifyQuery(query2);
     }
-  };
-});
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/webhooks/webhooks.mjs
-var _Webhooks_instances, _Webhooks_validateSecret, _Webhooks_getRequiredHeader, Webhooks;
-var init_webhooks = __esm(() => {
-  init_tslib();
-  init_error2();
-  init_resource();
-  init_headers();
-  Webhooks = class Webhooks extends APIResource {
-    constructor() {
-      super(...arguments);
-      _Webhooks_instances.add(this);
+    return url.toString();
+  }
+  async prepareOptions(options) {
+    await this._callApiKey();
+  }
+  async prepareRequest(request, { url, options }) {}
+  get(path2, opts) {
+    return this.methodRequest("get", path2, opts);
+  }
+  post(path2, opts) {
+    return this.methodRequest("post", path2, opts);
+  }
+  patch(path2, opts) {
+    return this.methodRequest("patch", path2, opts);
+  }
+  put(path2, opts) {
+    return this.methodRequest("put", path2, opts);
+  }
+  delete(path2, opts) {
+    return this.methodRequest("delete", path2, opts);
+  }
+  methodRequest(method, path2, opts) {
+    return this.request(Promise.resolve(opts).then((opts2) => {
+      return { method, path: path2, ...opts2 };
+    }));
+  }
+  request(options, remainingRetries = null) {
+    return new APIPromise(this, this.makeRequest(options, remainingRetries, undefined));
+  }
+  async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
+    const options = await optionsInput;
+    const maxRetries = options.maxRetries ?? this.maxRetries;
+    if (retriesRemaining == null) {
+      retriesRemaining = maxRetries;
     }
-    async unwrap(payload, headers, secret = this._client.webhookSecret, tolerance = 300) {
-      await this.verifySignature(payload, headers, secret, tolerance);
-      return JSON.parse(payload);
+    await this.prepareOptions(options);
+    const { req, url, timeout } = await this.buildRequest(options, {
+      retryCount: maxRetries - retriesRemaining
+    });
+    await this.prepareRequest(req, { url, options });
+    const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0");
+    const retryLogStr = retryOfRequestLogID === undefined ? "" : `, retryOf: ${retryOfRequestLogID}`;
+    const startTime = Date.now();
+    loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({
+      retryOfRequestLogID,
+      method: options.method,
+      url,
+      options,
+      headers: req.headers
+    }));
+    if (options.signal?.aborted) {
+      throw new APIUserAbortError;
     }
-    async verifySignature(payload, headers, secret = this._client.webhookSecret, tolerance = 300) {
-      if (typeof crypto === "undefined" || typeof crypto.subtle.importKey !== "function" || typeof crypto.subtle.verify !== "function") {
-        throw new Error("Webhook signature verification is only supported when the `crypto` global is defined");
+    const controller = new AbortController;
+    const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+    const headersTime = Date.now();
+    if (response instanceof globalThis.Error) {
+      const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+      if (options.signal?.aborted) {
+        throw new APIUserAbortError;
       }
-      __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_validateSecret).call(this, secret);
-      const headersObj = buildHeaders([headers]).values;
-      const signatureHeader = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-signature");
-      const timestamp = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-timestamp");
-      const webhookId = __classPrivateFieldGet(this, _Webhooks_instances, "m", _Webhooks_getRequiredHeader).call(this, headersObj, "webhook-id");
-      const timestampSeconds = parseInt(timestamp, 10);
-      if (isNaN(timestampSeconds)) {
-        throw new InvalidWebhookSignatureError("Invalid webhook timestamp format");
+      const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : ""));
+      if (retriesRemaining) {
+        loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`);
+        loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({
+          retryOfRequestLogID,
+          url,
+          durationMs: headersTime - startTime,
+          message: response.message
+        }));
+        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
       }
-      const nowSeconds = Math.floor(Date.now() / 1000);
-      if (nowSeconds - timestampSeconds > tolerance) {
-        throw new InvalidWebhookSignatureError("Webhook timestamp is too old");
+      loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`);
+      loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({
+        retryOfRequestLogID,
+        url,
+        durationMs: headersTime - startTime,
+        message: response.message
+      }));
+      if (isTimeout) {
+        throw new APIConnectionTimeoutError;
       }
-      if (timestampSeconds > nowSeconds + tolerance) {
-        throw new InvalidWebhookSignatureError("Webhook timestamp is too new");
+      throw new APIConnectionError({ cause: response });
+    }
+    const specialHeaders = [...response.headers.entries()].filter(([name]) => name === "x-request-id").map(([name, value]) => ", " + name + ": " + JSON.stringify(value)).join("");
+    const responseInfo = `[${requestLogID}${retryLogStr}${specialHeaders}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`;
+    if (!response.ok) {
+      const shouldRetry = await this.shouldRetry(response);
+      if (retriesRemaining && shouldRetry) {
+        const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`;
+        await CancelReadableStream(response.body);
+        loggerFor(this).info(`${responseInfo} - ${retryMessage2}`);
+        loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails({
+          retryOfRequestLogID,
+          url: response.url,
+          status: response.status,
+          headers: response.headers,
+          durationMs: headersTime - startTime
+        }));
+        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
       }
-      const signatures = signatureHeader.split(" ").map((part) => part.startsWith("v1,") ? part.substring(3) : part);
-      const decodedSecret = secret.startsWith("whsec_") ? Buffer.from(secret.replace("whsec_", ""), "base64") : Buffer.from(secret, "utf-8");
-      const signedPayload = webhookId ? `${webhookId}.${timestamp}.${payload}` : `${timestamp}.${payload}`;
-      const key = await crypto.subtle.importKey("raw", decodedSecret, { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
-      for (const signature of signatures) {
-        try {
-          const signatureBytes = Buffer.from(signature, "base64");
-          const isValid = await crypto.subtle.verify("HMAC", key, signatureBytes, new TextEncoder().encode(signedPayload));
-          if (isValid) {
-            return;
-          }
-        } catch {
-          continue;
-        }
+      const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
+      loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+      const errText = await response.text().catch((err2) => castToError(err2).message);
+      const errJSON = safeJSON(errText);
+      const errMessage = errJSON ? undefined : errText;
+      loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+        retryOfRequestLogID,
+        url: response.url,
+        status: response.status,
+        headers: response.headers,
+        message: errMessage,
+        durationMs: Date.now() - startTime
+      }));
+      const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+      throw err;
+    }
+    loggerFor(this).info(responseInfo);
+    loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
+      retryOfRequestLogID,
+      url: response.url,
+      status: response.status,
+      headers: response.headers,
+      durationMs: headersTime - startTime
+    }));
+    return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
+  }
+  getAPIList(path2, Page2, opts) {
+    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path2, ...opts2 })) : { method: "get", path: path2, ...opts });
+  }
+  requestAPIList(Page2, options) {
+    const request = this.makeRequest(options, null, undefined);
+    return new PagePromise(this, request, Page2);
+  }
+  async fetchWithTimeout(url, init, ms, controller) {
+    const { signal, method, ...options } = init || {};
+    const abort = this._makeAbort(controller);
+    if (signal)
+      signal.addEventListener("abort", abort, { once: true });
+    const timeout = setTimeout(abort, ms);
+    const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body;
+    const fetchOptions = {
+      signal: controller.signal,
+      ...isReadableBody ? { duplex: "half" } : {},
+      method: "GET",
+      ...options
+    };
+    if (method) {
+      fetchOptions.method = method.toUpperCase();
+    }
+    try {
+      return await this.fetch.call(undefined, url, fetchOptions);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async shouldRetry(response) {
+    const shouldRetryHeader = response.headers.get("x-should-retry");
+    if (shouldRetryHeader === "true")
+      return true;
+    if (shouldRetryHeader === "false")
+      return false;
+    if (response.status === 408)
+      return true;
+    if (response.status === 409)
+      return true;
+    if (response.status === 429)
+      return true;
+    if (response.status >= 500)
+      return true;
+    return false;
+  }
+  async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
+    let timeoutMillis;
+    const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms");
+    if (retryAfterMillisHeader) {
+      const timeoutMs = parseFloat(retryAfterMillisHeader);
+      if (!Number.isNaN(timeoutMs)) {
+        timeoutMillis = timeoutMs;
       }
-      throw new InvalidWebhookSignatureError("The given webhook signature does not match the expected signature");
     }
-  };
-  _Webhooks_instances = new WeakSet, _Webhooks_validateSecret = function _Webhooks_validateSecret2(secret) {
-    if (typeof secret !== "string" || secret.length === 0) {
-      throw new Error(`The webhook secret must either be set using the env var, OPENAI_WEBHOOK_SECRET, on the client class, OpenAI({ webhookSecret: '123' }), or passed to this function`);
+    const retryAfterHeader = responseHeaders?.get("retry-after");
+    if (retryAfterHeader && !timeoutMillis) {
+      const timeoutSeconds = parseFloat(retryAfterHeader);
+      if (!Number.isNaN(timeoutSeconds)) {
+        timeoutMillis = timeoutSeconds * 1000;
+      } else {
+        timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+      }
     }
-  }, _Webhooks_getRequiredHeader = function _Webhooks_getRequiredHeader2(headers, name) {
-    if (!headers) {
-      throw new Error(`Headers are required`);
+    if (timeoutMillis === undefined) {
+      const maxRetries = options.maxRetries ?? this.maxRetries;
+      timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
     }
-    const value = headers.get(name);
-    if (value === null || value === undefined) {
-      throw new Error(`Missing required header: ${name}`);
+    await sleep(timeoutMillis);
+    return this.makeRequest(options, retriesRemaining - 1, requestLogID);
+  }
+  calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+    const initialRetryDelay = 0.5;
+    const maxRetryDelay = 8;
+    const numRetries = maxRetries - retriesRemaining;
+    const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
+    const jitter = 1 - Math.random() * 0.25;
+    return sleepSeconds * jitter * 1000;
+  }
+  async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+    const options = { ...inputOptions };
+    const { method, path: path2, query: query2, defaultBaseURL } = options;
+    const url = this.buildURL(path2, query2, defaultBaseURL);
+    if ("timeout" in options)
+      validatePositiveInteger("timeout", options.timeout);
+    options.timeout = options.timeout ?? this.timeout;
+    const { bodyHeaders, body } = this.buildBody({ options });
+    const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
+    const req = {
+      method,
+      headers: reqHeaders,
+      ...options.signal && { signal: options.signal },
+      ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" },
+      ...body && { body },
+      ...this.fetchOptions ?? {},
+      ...options.fetchOptions ?? {}
+    };
+    return { req, url, timeout: options.timeout };
+  }
+  async buildHeaders({ options, method, bodyHeaders, retryCount }) {
+    let idempotencyHeaders = {};
+    if (this.idempotencyHeader && method !== "get") {
+      if (!options.idempotencyKey)
+        options.idempotencyKey = this.defaultIdempotencyKey();
+      idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
     }
-    return value;
-  };
-});
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/webhooks/index.mjs
-var init_webhooks2 = __esm(() => {
-  init_webhooks();
-});
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/webhooks.mjs
-var init_webhooks3 = __esm(() => {
-  init_webhooks2();
-});
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/resources/index.mjs
-var init_resources = __esm(() => {
-  init_audio();
+    const headers = buildHeaders([
+      idempotencyHeaders,
+      {
+        Accept: "application/json",
+        "User-Agent": this.getUserAgent(),
+        "X-Stainless-Retry-Count": String(retryCount),
+        ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1000)) } : {},
+        ...getPlatformHeaders(),
+        "OpenAI-Organization": this.organization,
+        "OpenAI-Project": this.project
+      },
+      await this.authHeaders(options),
+      this._options.defaultHeaders,
+      bodyHeaders,
+      options.headers
+    ]);
+    this.validateHeaders(headers);
+    return headers.values;
+  }
+  _makeAbort(controller) {
+    return () => controller.abort();
+  }
+  buildBody({ options: { body, headers: rawHeaders } }) {
+    if (!body) {
+      return { bodyHeaders: undefined, body: undefined };
+    }
+    const headers = buildHeaders([rawHeaders]);
+    if (ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && headers.values.has("content-type") || globalThis.Blob && body instanceof globalThis.Blob || body instanceof FormData || body instanceof URLSearchParams || globalThis.ReadableStream && body instanceof globalThis.ReadableStream) {
+      return { bodyHeaders: undefined, body };
+    } else if (typeof body === "object" && ((Symbol.asyncIterator in body) || (Symbol.iterator in body) && ("next" in body) && typeof body.next === "function")) {
+      return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
+    } else if (typeof body === "object" && headers.values.get("content-type") === "application/x-www-form-urlencoded") {
+      return {
+        bodyHeaders: { "content-type": "application/x-www-form-urlencoded" },
+        body: this.stringifyQuery(body)
+      };
+    } else {
+      return __classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers });
+    }
+  }
+}
+var _OpenAI_instances, _a2, _OpenAI_encoder, _OpenAI_baseURLOverridden;
+var init_client = __esm(() => {
+  init_tslib();
+  init_uuid();
+  init_values();
+  init_sleep();
+  init_errors();
+  init_detect_platform();
+  init_shims();
+  init_request_options();
+  init_query();
+  init_version();
+  init_error();
+  init_pagination();
+  init_uploads2();
+  init_resources();
+  init_api_promise();
   init_batches();
-  init_beta();
   init_completions3();
-  init_containers();
-  init_conversations();
   init_embeddings();
-  init_evals();
   init_files2();
-  init_fine_tuning();
-  init_graders2();
   init_images();
   init_models();
   init_moderations();
+  init_videos();
+  init_audio();
+  init_beta();
+  init_chat();
+  init_containers();
+  init_conversations();
+  init_evals();
+  init_fine_tuning();
+  init_graders2();
   init_realtime2();
   init_responses();
   init_skills();
   init_uploads3();
   init_vector_stores();
-  init_videos();
-  init_webhooks3();
-  init_chat2();
-  init_shared();
+  init_webhooks();
+  init_detect_platform();
+  init_headers();
+  init_env();
+  init_log();
+  init_values();
+  _a2 = OpenAI, _OpenAI_encoder = new WeakMap, _OpenAI_instances = new WeakSet, _OpenAI_baseURLOverridden = function _OpenAI_baseURLOverridden2() {
+    return this.baseURL !== "https://api.openai.com/v1";
+  };
+  OpenAI.OpenAI = _a2;
+  OpenAI.DEFAULT_TIMEOUT = 600000;
+  OpenAI.OpenAIError = OpenAIError;
+  OpenAI.APIError = APIError;
+  OpenAI.APIConnectionError = APIConnectionError;
+  OpenAI.APIConnectionTimeoutError = APIConnectionTimeoutError;
+  OpenAI.APIUserAbortError = APIUserAbortError;
+  OpenAI.NotFoundError = NotFoundError;
+  OpenAI.ConflictError = ConflictError;
+  OpenAI.RateLimitError = RateLimitError;
+  OpenAI.BadRequestError = BadRequestError;
+  OpenAI.AuthenticationError = AuthenticationError;
+  OpenAI.InternalServerError = InternalServerError;
+  OpenAI.PermissionDeniedError = PermissionDeniedError;
+  OpenAI.UnprocessableEntityError = UnprocessableEntityError;
+  OpenAI.InvalidWebhookSignatureError = InvalidWebhookSignatureError;
+  OpenAI.toFile = toFile;
+  OpenAI.Completions = Completions2;
+  OpenAI.Chat = Chat;
+  OpenAI.Embeddings = Embeddings;
+  OpenAI.Files = Files2;
+  OpenAI.Images = Images;
+  OpenAI.Audio = Audio;
+  OpenAI.Moderations = Moderations;
+  OpenAI.Models = Models;
+  OpenAI.FineTuning = FineTuning;
+  OpenAI.Graders = Graders2;
+  OpenAI.VectorStores = VectorStores;
+  OpenAI.Webhooks = Webhooks;
+  OpenAI.Beta = Beta;
+  OpenAI.Batches = Batches;
+  OpenAI.Uploads = Uploads;
+  OpenAI.Responses = Responses;
+  OpenAI.Realtime = Realtime2;
+  OpenAI.Conversations = Conversations;
+  OpenAI.Evals = Evals;
+  OpenAI.Containers = Containers;
+  OpenAI.Skills = Skills;
+  OpenAI.Videos = Videos;
 });
 
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/client.mjs
-class OpenAI {
-  constructor({ baseURL = readEnv("OPENAI_BASE_URL"), apiKey = readEnv("OPENAI_API_KEY"), organization = readEnv("OPENAI_ORG_ID") ?? null, project = readEnv("OPENAI_PROJECT_ID") ?? null, webhookSecret = readEnv("OPENAI_WEBHOOK_SECRET") ?? null, ...opts } = {}) {
-    _OpenAI_instances.add(this);
-    _OpenAI_encoder.set(this, undefined);
-    this.completions = new Completions2(this);
-    this.chat = new Chat(this);
-    this.embeddings = new Embeddings(this);
-    this.files = new Files2(this);
-    this.images = new Images(this);
-    this.audio = new Audio(this);
-    this.moderations = new Moderations(this);
-    this.models = new Models(this);
-    this.fineTuning = new FineTuning(this);
-    this.graders = new Graders2(this);
-    this.vectorStores = new VectorStores(this);
-    this.webhooks = new Webhooks(this);
-    this.beta = new Beta(this);
-    this.batches = new Batches(this);
-    this.uploads = new Uploads(this);
-    this.responses = new Responses(this);
-    this.realtime = new Realtime2(this);
-    this.conversations = new Conversations(this);
-    this.evals = new Evals(this);
-    this.containers = new Containers(this);
-    this.skills = new Skills(this);
-    this.videos = new Videos(this);
-    if (apiKey === undefined) {
-      throw new OpenAIError("Missing credentials. Please pass an `apiKey`, or set the `OPENAI_API_KEY` environment variable.");
-    }
-    const options = {
-      apiKey,
-      organization,
-      project,
-      webhookSecret,
-      ...opts,
-      baseURL: baseURL || `https://api.openai.com/v1`
-    };
-    if (!options.dangerouslyAllowBrowser && isRunningInBrowser()) {
-      throw new OpenAIError(`It looks like you're running in a browser-like environment.
-
-This is disabled by default, as it risks exposing your secret API credentials to attackers.
-If you understand the risks and have appropriate mitigations in place,
-you can set the \`dangerouslyAllowBrowser\` option to \`true\`, e.g.,
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/azure.mjs
+var _deployments_endpoints;
+var init_azure = __esm(() => {
+  init_headers();
+  init_error2();
+  init_utils2();
+  init_client();
+  _deployments_endpoints = new Set([
+    "/completions",
+    "/chat/completions",
+    "/embeddings",
+    "/audio/transcriptions",
+    "/audio/translations",
+    "/audio/speech",
+    "/images/generations",
+    "/batches",
+    "/images/edits"
+  ]);
+});
 
-new OpenAI({ apiKey, dangerouslyAllowBrowser: true });
+// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/index.mjs
+var init_openai = __esm(() => {
+  init_client();
+  init_uploads2();
+  init_api_promise();
+  init_client();
+  init_pagination();
+  init_error();
+  init_azure();
+});
 
-https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety
-`);
-    }
-    this.baseURL = options.baseURL;
-    this.timeout = options.timeout ?? _a2.DEFAULT_TIMEOUT;
-    this.logger = options.logger ?? console;
-    const defaultLogLevel = "warn";
-    this.logLevel = defaultLogLevel;
-    this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("OPENAI_LOG"), "process.env['OPENAI_LOG']", this) ?? defaultLogLevel;
-    this.fetchOptions = options.fetchOptions;
-    this.maxRetries = options.maxRetries ?? 2;
-    this.fetch = options.fetch ?? getDefaultFetch();
-    __classPrivateFieldSet(this, _OpenAI_encoder, FallbackEncoder, "f");
-    this._options = options;
-    this.apiKey = typeof apiKey === "string" ? apiKey : "Missing Key";
-    this.organization = organization;
-    this.project = project;
-    this.webhookSecret = webhookSecret;
+// src/services/api/openai/client.ts
+function getOpenAIClient(options) {
+  if (cachedClient)
+    return cachedClient;
+  const apiKey = process.env.OPENAI_API_KEY || "";
+  const baseURL = process.env.OPENAI_BASE_URL;
+  const client = new OpenAI({
+    apiKey,
+    ...baseURL && { baseURL },
+    maxRetries: options?.maxRetries ?? 0,
+    timeout: parseInt(process.env.API_TIMEOUT_MS || String(600 * 1000), 10),
+    dangerouslyAllowBrowser: true,
+    ...process.env.OPENAI_ORG_ID && { organization: process.env.OPENAI_ORG_ID },
+    ...process.env.OPENAI_PROJECT_ID && { project: process.env.OPENAI_PROJECT_ID },
+    fetchOptions: getProxyFetchOptions({ forAnthropicAPI: false }),
+    ...options?.fetchOverride && { fetch: options.fetchOverride }
+  });
+  if (!options?.fetchOverride) {
+    cachedClient = client;
   }
-  withOptions(options) {
-    const client = new this.constructor({
-      ...this._options,
-      baseURL: this.baseURL,
-      maxRetries: this.maxRetries,
-      timeout: this.timeout,
-      logger: this.logger,
-      logLevel: this.logLevel,
-      fetch: this.fetch,
-      fetchOptions: this.fetchOptions,
-      apiKey: this.apiKey,
-      organization: this.organization,
-      project: this.project,
-      webhookSecret: this.webhookSecret,
-      ...options
+  return client;
+}
+var cachedClient = null;
+var init_client2 = __esm(() => {
+  init_openai();
+  init_proxy();
+});
+
+// src/services/api/openai/convertMessages.ts
+function anthropicMessagesToOpenAI(messages, systemPrompt, options) {
+  const result = [];
+  const enableThinking = options?.enableThinking ?? false;
+  const systemText = systemPromptToText(systemPrompt);
+  if (systemText) {
+    result.push({
+      role: "system",
+      content: systemText
     });
-    return client;
-  }
-  defaultQuery() {
-    return this._options.defaultQuery;
-  }
-  validateHeaders({ values: values2, nulls }) {
-    return;
   }
-  async authHeaders(opts) {
-    return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
-  }
-  stringifyQuery(query2) {
-    return stringifyQuery(query2);
-  }
-  getUserAgent() {
-    return `${this.constructor.name}/JS ${VERSION}`;
+  const turnBoundaries = new Set;
+  if (enableThinking) {
+    let hasSeenAssistant = false;
+    for (let i = 0;i < messages.length; i++) {
+      const msg = messages[i];
+      if (msg.type === "assistant") {
+        hasSeenAssistant = true;
+      }
+      if (msg.type === "user" && hasSeenAssistant) {
+        const content = msg.message.content;
+        const startsNewUserTurn = typeof content === "string" ? content.length > 0 : Array.isArray(content) && content.some((b) => typeof b === "string" || b && typeof b === "object" && ("type" in b) && b.type !== "tool_result");
+        if (startsNewUserTurn) {
+          turnBoundaries.add(i);
+        }
+      }
+    }
   }
-  defaultIdempotencyKey() {
-    return `stainless-node-retry-${uuid4()}`;
+  for (let i = 0;i < messages.length; i++) {
+    const msg = messages[i];
+    switch (msg.type) {
+      case "user":
+        result.push(...convertInternalUserMessage(msg));
+        break;
+      case "assistant":
+        const preserveReasoning = enableThinking && !isBeforeAnyTurnBoundary(i, turnBoundaries);
+        result.push(...convertInternalAssistantMessage(msg, preserveReasoning));
+        break;
+      default:
+        break;
+    }
   }
-  makeStatusError(status, error2, message, headers) {
-    return APIError.generate(status, error2, message, headers);
+  return result;
+}
+function systemPromptToText(systemPrompt) {
+  if (!systemPrompt || systemPrompt.length === 0)
+    return "";
+  return systemPrompt.filter(Boolean).join(`
+
+`);
+}
+function isBeforeAnyTurnBoundary(i, boundaries) {
+  for (const b of boundaries) {
+    if (i < b)
+      return true;
   }
-  async _callApiKey() {
-    const apiKey = this._options.apiKey;
-    if (typeof apiKey !== "function")
-      return false;
-    let token;
-    try {
-      token = await apiKey();
-    } catch (err) {
-      if (err instanceof OpenAIError)
-        throw err;
-      throw new OpenAIError(`Failed to get token from 'apiKey' function: ${err.message}`, { cause: err });
-    }
-    if (typeof token !== "string" || !token) {
-      throw new OpenAIError(`Expected 'apiKey' function argument to return a string but it returned ${token}`);
+  return false;
+}
+function convertInternalUserMessage(msg) {
+  const result = [];
+  const content = msg.message.content;
+  if (typeof content === "string") {
+    result.push({
+      role: "user",
+      content
+    });
+  } else if (Array.isArray(content)) {
+    const textParts = [];
+    const toolResults = [];
+    const imageParts = [];
+    for (const block of content) {
+      if (typeof block === "string") {
+        textParts.push(block);
+      } else if (block.type === "text") {
+        textParts.push(block.text);
+      } else if (block.type === "tool_result") {
+        toolResults.push(block);
+      } else if (block.type === "image") {
+        const imagePart = convertImageBlockToOpenAI(block);
+        if (imagePart) {
+          imageParts.push(imagePart);
+        }
+      }
     }
-    this.apiKey = token;
-    return true;
-  }
-  buildURL(path2, query2, defaultBaseURL) {
-    const baseURL = !__classPrivateFieldGet(this, _OpenAI_instances, "m", _OpenAI_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-    const url = isAbsoluteURL(path2) ? new URL(path2) : new URL(baseURL + (baseURL.endsWith("/") && path2.startsWith("/") ? path2.slice(1) : path2));
-    const defaultQuery = this.defaultQuery();
-    const pathQuery = Object.fromEntries(url.searchParams);
-    if (!isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) {
-      query2 = { ...pathQuery, ...defaultQuery, ...query2 };
+    for (const tr of toolResults) {
+      result.push(convertToolResult(tr));
     }
-    if (typeof query2 === "object" && query2 && !Array.isArray(query2)) {
-      url.search = this.stringifyQuery(query2);
+    if (imageParts.length > 0) {
+      const multiContent = [];
+      if (textParts.length > 0) {
+        multiContent.push({ type: "text", text: textParts.join(`
+`) });
+      }
+      multiContent.push(...imageParts);
+      result.push({
+        role: "user",
+        content: multiContent
+      });
+    } else if (textParts.length > 0) {
+      result.push({
+        role: "user",
+        content: textParts.join(`
+`)
+      });
     }
-    return url.toString();
-  }
-  async prepareOptions(options) {
-    await this._callApiKey();
-  }
-  async prepareRequest(request, { url, options }) {}
-  get(path2, opts) {
-    return this.methodRequest("get", path2, opts);
-  }
-  post(path2, opts) {
-    return this.methodRequest("post", path2, opts);
-  }
-  patch(path2, opts) {
-    return this.methodRequest("patch", path2, opts);
   }
-  put(path2, opts) {
-    return this.methodRequest("put", path2, opts);
-  }
-  delete(path2, opts) {
-    return this.methodRequest("delete", path2, opts);
+  return result;
+}
+function convertToolResult(block) {
+  let content;
+  if (typeof block.content === "string") {
+    content = block.content;
+  } else if (Array.isArray(block.content)) {
+    content = block.content.map((c) => {
+      if (typeof c === "string")
+        return c;
+      if ("text" in c)
+        return c.text;
+      return "";
+    }).filter(Boolean).join(`
+`);
+  } else {
+    content = "";
   }
-  methodRequest(method, path2, opts) {
-    return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path2, ...opts2 };
-    }));
+  return {
+    role: "tool",
+    tool_call_id: block.tool_use_id,
+    content
+  };
+}
+function convertInternalAssistantMessage(msg, preserveReasoning = false) {
+  const content = msg.message.content;
+  if (typeof content === "string") {
+    return [
+      {
+        role: "assistant",
+        content
+      }
+    ];
   }
-  request(options, remainingRetries = null) {
-    return new APIPromise(this, this.makeRequest(options, remainingRetries, undefined));
+  if (!Array.isArray(content)) {
+    return [
+      {
+        role: "assistant",
+        content: ""
+      }
+    ];
   }
-  async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
-    const options = await optionsInput;
-    const maxRetries = options.maxRetries ?? this.maxRetries;
-    if (retriesRemaining == null) {
-      retriesRemaining = maxRetries;
-    }
-    await this.prepareOptions(options);
-    const { req, url, timeout } = await this.buildRequest(options, {
-      retryCount: maxRetries - retriesRemaining
-    });
-    await this.prepareRequest(req, { url, options });
-    const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0");
-    const retryLogStr = retryOfRequestLogID === undefined ? "" : `, retryOf: ${retryOfRequestLogID}`;
-    const startTime = Date.now();
-    loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({
-      retryOfRequestLogID,
-      method: options.method,
-      url,
-      options,
-      headers: req.headers
-    }));
-    if (options.signal?.aborted) {
-      throw new APIUserAbortError;
+  const textParts = [];
+  const toolCalls = [];
+  const reasoningParts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      textParts.push(block);
+    } else if (block.type === "text") {
+      textParts.push(block.text);
+    } else if (block.type === "tool_use") {
+      const tu = block;
+      toolCalls.push({
+        id: tu.id,
+        type: "function",
+        function: {
+          name: tu.name,
+          arguments: typeof tu.input === "string" ? tu.input : JSON.stringify(tu.input)
+        }
+      });
+    } else if (block.type === "thinking" && preserveReasoning) {
+      const thinkingText = block.thinking;
+      if (typeof thinkingText === "string" && thinkingText) {
+        reasoningParts.push(thinkingText);
+      }
     }
-    const controller = new AbortController;
-    const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
-    const headersTime = Date.now();
-    if (response instanceof globalThis.Error) {
-      const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
-      if (options.signal?.aborted) {
-        throw new APIUserAbortError;
+  }
+  const result = {
+    role: "assistant",
+    content: textParts.length > 0 ? textParts.join(`
+`) : null,
+    ...toolCalls.length > 0 && { tool_calls: toolCalls },
+    ...reasoningParts.length > 0 && { reasoning_content: reasoningParts.join(`
+`) }
+  };
+  return [result];
+}
+function convertImageBlockToOpenAI(block) {
+  const source = block.source;
+  if (!source)
+    return null;
+  if (source.type === "base64" && typeof source.data === "string") {
+    const mediaType = source.media_type || "image/png";
+    return {
+      type: "image_url",
+      image_url: {
+        url: `data:${mediaType};base64,${source.data}`
       }
-      const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : ""));
-      if (retriesRemaining) {
-        loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`);
-        loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({
-          retryOfRequestLogID,
-          url,
-          durationMs: headersTime - startTime,
-          message: response.message
-        }));
-        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
+    };
+  }
+  if (source.type === "url" && typeof source.url === "string") {
+    return {
+      type: "image_url",
+      image_url: {
+        url: source.url
       }
-      loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`);
-      loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({
-        retryOfRequestLogID,
-        url,
-        durationMs: headersTime - startTime,
-        message: response.message
-      }));
-      if (isTimeout) {
-        throw new APIConnectionTimeoutError;
+    };
+  }
+  return null;
+}
+var init_convertMessages = () => {};
+
+// src/services/api/openai/convertTools.ts
+function anthropicToolsToOpenAI(tools) {
+  return tools.filter((tool) => {
+    const toolType = tool.type;
+    return tool.type === "custom" || !("type" in tool) || toolType !== "server";
+  }).map((tool) => {
+    const anyTool = tool;
+    const name = anyTool.name || "";
+    const description = anyTool.description || "";
+    const inputSchema = anyTool.input_schema;
+    return {
+      type: "function",
+      function: {
+        name,
+        description,
+        parameters: sanitizeJsonSchema(inputSchema || { type: "object", properties: {} })
       }
-      throw new APIConnectionError({ cause: response });
-    }
-    const specialHeaders = [...response.headers.entries()].filter(([name]) => name === "x-request-id").map(([name, value]) => ", " + name + ": " + JSON.stringify(value)).join("");
-    const responseInfo = `[${requestLogID}${retryLogStr}${specialHeaders}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`;
-    if (!response.ok) {
-      const shouldRetry = await this.shouldRetry(response);
-      if (retriesRemaining && shouldRetry) {
-        const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`;
-        await CancelReadableStream(response.body);
-        loggerFor(this).info(`${responseInfo} - ${retryMessage2}`);
-        loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails({
-          retryOfRequestLogID,
-          url: response.url,
-          status: response.status,
-          headers: response.headers,
-          durationMs: headersTime - startTime
-        }));
-        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
+    };
+  });
+}
+function sanitizeJsonSchema(schema) {
+  if (!schema || typeof schema !== "object")
+    return schema;
+  const result = { ...schema };
+  if ("const" in result) {
+    result.enum = [result.const];
+    delete result.const;
+  }
+  const objectKeys = ["properties", "definitions", "$defs", "patternProperties"];
+  for (const key of objectKeys) {
+    const nested = result[key];
+    if (nested && typeof nested === "object") {
+      const sanitized = {};
+      for (const [k, v] of Object.entries(nested)) {
+        sanitized[k] = v && typeof v === "object" ? sanitizeJsonSchema(v) : v;
       }
-      const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
-      loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
-      const errText = await response.text().catch((err2) => castToError(err2).message);
-      const errJSON = safeJSON(errText);
-      const errMessage = errJSON ? undefined : errText;
-      loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
-        retryOfRequestLogID,
-        url: response.url,
-        status: response.status,
-        headers: response.headers,
-        message: errMessage,
-        durationMs: Date.now() - startTime
-      }));
-      const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
-      throw err;
+      result[key] = sanitized;
     }
-    loggerFor(this).info(responseInfo);
-    loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
-      retryOfRequestLogID,
-      url: response.url,
-      status: response.status,
-      headers: response.headers,
-      durationMs: headersTime - startTime
-    }));
-    return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
-  getAPIList(path2, Page2, opts) {
-    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path2, ...opts2 })) : { method: "get", path: path2, ...opts });
+  const singleKeys = ["items", "additionalProperties", "not", "if", "then", "else", "contains", "propertyNames"];
+  for (const key of singleKeys) {
+    const nested = result[key];
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+      result[key] = sanitizeJsonSchema(nested);
+    }
   }
-  requestAPIList(Page2, options) {
-    const request = this.makeRequest(options, null, undefined);
-    return new PagePromise(this, request, Page2);
+  const arrayKeys = ["anyOf", "oneOf", "allOf"];
+  for (const key of arrayKeys) {
+    const nested = result[key];
+    if (Array.isArray(nested)) {
+      result[key] = nested.map((item) => item && typeof item === "object" ? sanitizeJsonSchema(item) : item);
+    }
   }
-  async fetchWithTimeout(url, init, ms, controller) {
-    const { signal, method, ...options } = init || {};
-    const abort = this._makeAbort(controller);
-    if (signal)
-      signal.addEventListener("abort", abort, { once: true });
-    const timeout = setTimeout(abort, ms);
-    const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body;
-    const fetchOptions = {
-      signal: controller.signal,
-      ...isReadableBody ? { duplex: "half" } : {},
-      method: "GET",
-      ...options
-    };
-    if (method) {
-      fetchOptions.method = method.toUpperCase();
+  return result;
+}
+function anthropicToolChoiceToOpenAI(toolChoice) {
+  if (!toolChoice || typeof toolChoice !== "object")
+    return;
+  const tc = toolChoice;
+  const type = tc.type;
+  switch (type) {
+    case "auto":
+      return "auto";
+    case "any":
+      return "required";
+    case "tool":
+      return {
+        type: "function",
+        function: { name: tc.name }
+      };
+    default:
+      return;
+  }
+}
+var init_convertTools = () => {};
+
+// src/services/api/openai/streamAdapter.ts
+import { randomUUID } from "crypto";
+async function* adaptOpenAIStreamToAnthropic(stream, model) {
+  const messageId = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  let started = false;
+  let currentContentIndex = -1;
+  const toolBlocks = new Map;
+  let thinkingBlockOpen = false;
+  let textBlockOpen = false;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cachedReadTokens = 0;
+  const openBlockIndices = new Set;
+  let pendingFinishReason = null;
+  let pendingHasToolCalls = false;
+  for await (const chunk of stream) {
+    const choice = chunk.choices?.[0];
+    const delta = choice?.delta;
+    if (chunk.usage) {
+      inputTokens = chunk.usage.prompt_tokens ?? inputTokens;
+      outputTokens = chunk.usage.completion_tokens ?? outputTokens;
+      const details = chunk.usage.prompt_tokens_details;
+      if (details?.cached_tokens != null) {
+        cachedReadTokens = details.cached_tokens;
+      }
     }
-    try {
-      return await this.fetch.call(undefined, url, fetchOptions);
-    } finally {
-      clearTimeout(timeout);
+    if (!started) {
+      started = true;
+      yield {
+        type: "message_start",
+        message: {
+          id: messageId,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model,
+          stop_reason: null,
+          stop_sequence: null,
+          usage: {
+            input_tokens: inputTokens,
+            output_tokens: 0,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: cachedReadTokens
+          }
+        }
+      };
     }
-  }
-  async shouldRetry(response) {
-    const shouldRetryHeader = response.headers.get("x-should-retry");
-    if (shouldRetryHeader === "true")
-      return true;
-    if (shouldRetryHeader === "false")
-      return false;
-    if (response.status === 408)
-      return true;
-    if (response.status === 409)
-      return true;
-    if (response.status === 429)
-      return true;
-    if (response.status >= 500)
-      return true;
-    return false;
-  }
-  async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
-    let timeoutMillis;
-    const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms");
-    if (retryAfterMillisHeader) {
-      const timeoutMs = parseFloat(retryAfterMillisHeader);
-      if (!Number.isNaN(timeoutMs)) {
-        timeoutMillis = timeoutMs;
+    if (!delta)
+      continue;
+    const reasoningContent = delta.reasoning_content;
+    if (reasoningContent != null && reasoningContent !== "") {
+      if (!thinkingBlockOpen) {
+        currentContentIndex++;
+        thinkingBlockOpen = true;
+        openBlockIndices.add(currentContentIndex);
+        yield {
+          type: "content_block_start",
+          index: currentContentIndex,
+          content_block: {
+            type: "thinking",
+            thinking: "",
+            signature: ""
+          }
+        };
       }
+      yield {
+        type: "content_block_delta",
+        index: currentContentIndex,
+        delta: {
+          type: "thinking_delta",
+          thinking: reasoningContent
+        }
+      };
     }
-    const retryAfterHeader = responseHeaders?.get("retry-after");
-    if (retryAfterHeader && !timeoutMillis) {
-      const timeoutSeconds = parseFloat(retryAfterHeader);
-      if (!Number.isNaN(timeoutSeconds)) {
-        timeoutMillis = timeoutSeconds * 1000;
-      } else {
-        timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+    if (delta.content != null && delta.content !== "") {
+      if (!textBlockOpen) {
+        if (thinkingBlockOpen) {
+          yield {
+            type: "content_block_stop",
+            index: currentContentIndex
+          };
+          openBlockIndices.delete(currentContentIndex);
+          thinkingBlockOpen = false;
+        }
+        currentContentIndex++;
+        textBlockOpen = true;
+        openBlockIndices.add(currentContentIndex);
+        yield {
+          type: "content_block_start",
+          index: currentContentIndex,
+          content_block: {
+            type: "text",
+            text: ""
+          }
+        };
+      }
+      yield {
+        type: "content_block_delta",
+        index: currentContentIndex,
+        delta: {
+          type: "text_delta",
+          text: delta.content
+        }
+      };
+    }
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const tcIndex = tc.index;
+        if (!toolBlocks.has(tcIndex)) {
+          if (thinkingBlockOpen) {
+            yield {
+              type: "content_block_stop",
+              index: currentContentIndex
+            };
+            openBlockIndices.delete(currentContentIndex);
+            thinkingBlockOpen = false;
+          }
+          if (textBlockOpen) {
+            yield {
+              type: "content_block_stop",
+              index: currentContentIndex
+            };
+            openBlockIndices.delete(currentContentIndex);
+            textBlockOpen = false;
+          }
+          currentContentIndex++;
+          const toolId = tc.id || `toolu_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+          const toolName = tc.function?.name || "";
+          toolBlocks.set(tcIndex, {
+            contentIndex: currentContentIndex,
+            id: toolId,
+            name: toolName,
+            arguments: ""
+          });
+          openBlockIndices.add(currentContentIndex);
+          yield {
+            type: "content_block_start",
+            index: currentContentIndex,
+            content_block: {
+              type: "tool_use",
+              id: toolId,
+              name: toolName,
+              input: {}
+            }
+          };
+        }
+        const argFragment = tc.function?.arguments;
+        if (argFragment) {
+          toolBlocks.get(tcIndex).arguments += argFragment;
+          yield {
+            type: "content_block_delta",
+            index: toolBlocks.get(tcIndex).contentIndex,
+            delta: {
+              type: "input_json_delta",
+              partial_json: argFragment
+            }
+          };
+        }
       }
     }
-    if (timeoutMillis === undefined) {
-      const maxRetries = options.maxRetries ?? this.maxRetries;
-      timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+    if (choice?.finish_reason) {
+      if (thinkingBlockOpen) {
+        yield {
+          type: "content_block_stop",
+          index: currentContentIndex
+        };
+        openBlockIndices.delete(currentContentIndex);
+        thinkingBlockOpen = false;
+      }
+      if (textBlockOpen) {
+        yield {
+          type: "content_block_stop",
+          index: currentContentIndex
+        };
+        openBlockIndices.delete(currentContentIndex);
+        textBlockOpen = false;
+      }
+      for (const [, block] of toolBlocks) {
+        if (openBlockIndices.has(block.contentIndex)) {
+          yield {
+            type: "content_block_stop",
+            index: block.contentIndex
+          };
+          openBlockIndices.delete(block.contentIndex);
+        }
+      }
+      pendingFinishReason = choice.finish_reason;
+      pendingHasToolCalls = toolBlocks.size > 0;
     }
-    await sleep(timeoutMillis);
-    return this.makeRequest(options, retriesRemaining - 1, requestLogID);
   }
-  calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
-    const initialRetryDelay = 0.5;
-    const maxRetryDelay = 8;
-    const numRetries = maxRetries - retriesRemaining;
-    const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
-    const jitter = 1 - Math.random() * 0.25;
-    return sleepSeconds * jitter * 1000;
+  for (const idx of openBlockIndices) {
+    yield {
+      type: "content_block_stop",
+      index: idx
+    };
   }
-  async buildRequest(inputOptions, { retryCount = 0 } = {}) {
-    const options = { ...inputOptions };
-    const { method, path: path2, query: query2, defaultBaseURL } = options;
-    const url = this.buildURL(path2, query2, defaultBaseURL);
-    if ("timeout" in options)
-      validatePositiveInteger("timeout", options.timeout);
-    options.timeout = options.timeout ?? this.timeout;
-    const { bodyHeaders, body } = this.buildBody({ options });
-    const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
-    const req = {
-      method,
-      headers: reqHeaders,
-      ...options.signal && { signal: options.signal },
-      ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" },
-      ...body && { body },
-      ...this.fetchOptions ?? {},
-      ...options.fetchOptions ?? {}
+  if (pendingFinishReason !== null) {
+    const stopReason = pendingFinishReason === "length" ? "max_tokens" : pendingHasToolCalls ? "tool_use" : mapFinishReason(pendingFinishReason);
+    yield {
+      type: "message_delta",
+      delta: {
+        stop_reason: stopReason,
+        stop_sequence: null
+      },
+      usage: {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        cache_read_input_tokens: cachedReadTokens,
+        cache_creation_input_tokens: 0
+      }
+    };
+    yield {
+      type: "message_stop"
     };
-    return { req, url, timeout: options.timeout };
   }
-  async buildHeaders({ options, method, bodyHeaders, retryCount }) {
-    let idempotencyHeaders = {};
-    if (this.idempotencyHeader && method !== "get") {
-      if (!options.idempotencyKey)
-        options.idempotencyKey = this.defaultIdempotencyKey();
-      idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "tool_calls":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "content_filter":
+      return "end_turn";
+    default:
+      return "end_turn";
+  }
+}
+var init_streamAdapter = () => {};
+
+// src/services/api/openai/modelMapping.ts
+function getModelFamily(model) {
+  if (/haiku/i.test(model))
+    return "haiku";
+  if (/opus/i.test(model))
+    return "opus";
+  if (/sonnet/i.test(model))
+    return "sonnet";
+  return null;
+}
+function resolveOpenAIModel(anthropicModel) {
+  if (process.env.OPENAI_MODEL) {
+    return process.env.OPENAI_MODEL;
+  }
+  const cleanModel = anthropicModel.replace(/\[1m\]$/, "");
+  const family = getModelFamily(cleanModel);
+  if (family) {
+    const openaiEnvVar = `OPENAI_DEFAULT_${family.toUpperCase()}_MODEL`;
+    const openaiOverride = process.env[openaiEnvVar];
+    if (openaiOverride)
+      return openaiOverride;
+    const anthropicEnvVar = `ANTHROPIC_DEFAULT_${family.toUpperCase()}_MODEL`;
+    const anthropicOverride = process.env[anthropicEnvVar];
+    if (anthropicOverride)
+      return anthropicOverride;
+  }
+  return DEFAULT_MODEL_MAP[cleanModel] ?? cleanModel;
+}
+var DEFAULT_MODEL_MAP;
+var init_modelMapping = __esm(() => {
+  DEFAULT_MODEL_MAP = {
+    "claude-sonnet-4-20250514": "gpt-4o",
+    "claude-sonnet-4-5-20250929": "gpt-4o",
+    "claude-sonnet-4-6": "gpt-4o",
+    "claude-opus-4-20250514": "o3",
+    "claude-opus-4-1-20250805": "o3",
+    "claude-opus-4-5-20251101": "o3",
+    "claude-opus-4-6": "o3",
+    "claude-haiku-4-5-20251001": "gpt-4o-mini",
+    "claude-3-5-haiku-20241022": "gpt-4o-mini",
+    "claude-3-7-sonnet-20250219": "gpt-4o",
+    "claude-3-5-sonnet-20241022": "gpt-4o"
+  };
+});
+
+// src/services/api/openai/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function isOpenAIThinkingEnabled(model) {
+  if (isEnvDefinedFalsy(process.env.OPENAI_ENABLE_THINKING))
+    return false;
+  if (isEnvTruthy(process.env.OPENAI_ENABLE_THINKING))
+    return true;
+  const modelLower = model.toLowerCase();
+  return modelLower.includes("deepseek");
+}
+function buildOpenAIRequestBody(params) {
+  const { model, messages, tools, toolChoice, enableThinking, maxTokens, temperatureOverride } = params;
+  return {
+    model,
+    messages,
+    max_tokens: maxTokens,
+    ...tools.length > 0 && {
+      tools,
+      ...toolChoice && { tool_choice: toolChoice }
+    },
+    stream: true,
+    stream_options: { include_usage: true },
+    ...enableThinking && {
+      thinking: { type: "enabled" },
+      enable_thinking: true,
+      chat_template_kwargs: { thinking: true }
+    },
+    ...!enableThinking && temperatureOverride !== undefined && {
+      temperature: temperatureOverride
     }
-    const headers = buildHeaders([
-      idempotencyHeaders,
-      {
-        Accept: "application/json",
-        "User-Agent": this.getUserAgent(),
-        "X-Stainless-Retry-Count": String(retryCount),
-        ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1000)) } : {},
-        ...getPlatformHeaders(),
-        "OpenAI-Organization": this.organization,
-        "OpenAI-Project": this.project
+  };
+}
+function resolveOpenAIMaxTokens(upperLimit, maxOutputTokensOverride) {
+  return maxOutputTokensOverride ?? (process.env.OPENAI_MAX_TOKENS ? parseInt(process.env.OPENAI_MAX_TOKENS, 10) || undefined : undefined) ?? (process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS ? parseInt(process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS, 10) || undefined : undefined) ?? upperLimit;
+}
+function prependDeferredToolListIfNeeded(messages, tools, deferredToolNames, useToolSearch) {
+  if (!useToolSearch || isDeferredToolsDeltaEnabled())
+    return messages;
+  const deferredToolList = tools.filter((tool) => deferredToolNames.has(tool.name)).map(formatDeferredToolLine).sort().join(`
+`);
+  if (!deferredToolList)
+    return messages;
+  return [
+    createUserMessage({
+      content: `<available-deferred-tools>
+${deferredToolList}
+</available-deferred-tools>`,
+      isMeta: true
+    }),
+    ...messages
+  ];
+}
+function isOpenAIConvertibleMessage(msg) {
+  return msg.type === "assistant" || msg.type === "user";
+}
+function assembleFinalAssistantOutputs(params) {
+  const { partialMessage, contentBlocks, tools, agentId, usage, stopReason, maxTokens } = params;
+  const outputs = [];
+  const allBlocks = Object.keys(contentBlocks).sort((a, b) => Number(a) - Number(b)).map((k) => contentBlocks[Number(k)]).filter(Boolean);
+  if (allBlocks.length > 0) {
+    outputs.push({
+      message: {
+        ...partialMessage,
+        content: normalizeContentFromAPI(allBlocks, tools, agentId),
+        usage,
+        stop_reason: stopReason,
+        stop_sequence: null
       },
-      await this.authHeaders(options),
-      this._options.defaultHeaders,
-      bodyHeaders,
-      options.headers
-    ]);
-    this.validateHeaders(headers);
-    return headers.values;
+      requestId: undefined,
+      type: "assistant",
+      uuid: randomUUID2(),
+      timestamp: new Date().toISOString()
+    });
   }
-  _makeAbort(controller) {
-    return () => controller.abort();
+  if (stopReason === "max_tokens") {
+    outputs.push(createAssistantAPIErrorMessage({
+      content: `Output truncated: response exceeded the ${maxTokens} token limit. ` + `Set OPENAI_MAX_TOKENS or CLAUDE_CODE_MAX_OUTPUT_TOKENS to override.`,
+      apiError: "max_output_tokens",
+      error: "max_output_tokens"
+    }));
   }
-  buildBody({ options: { body, headers: rawHeaders } }) {
-    if (!body) {
-      return { bodyHeaders: undefined, body: undefined };
+  return outputs;
+}
+async function* queryModelOpenAI(messages, systemPrompt, tools, signal, options) {
+  try {
+    const openaiModel = resolveOpenAIModel(options.model);
+    const messagesForAPI = normalizeMessagesForAPI(messages, tools);
+    const useToolSearch = await isToolSearchEnabled(options.model, tools, options.getToolPermissionContext || (async () => getEmptyToolPermissionContext()), options.agents || [], options.querySource);
+    const deferredToolNames = new Set;
+    if (useToolSearch) {
+      for (const t of tools) {
+        if (isDeferredTool(t))
+          deferredToolNames.add(t.name);
+      }
+    }
+    let filteredTools = tools;
+    if (useToolSearch && deferredToolNames.size > 0) {
+      const discoveredToolNames = extractDiscoveredToolNames(messages);
+      filteredTools = tools.filter((tool) => {
+        if (!deferredToolNames.has(tool.name))
+          return true;
+        if (toolMatchesName(tool, TOOL_SEARCH_TOOL_NAME))
+          return true;
+        return discoveredToolNames.has(tool.name);
+      });
     }
-    const headers = buildHeaders([rawHeaders]);
-    if (ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && headers.values.has("content-type") || globalThis.Blob && body instanceof globalThis.Blob || body instanceof FormData || body instanceof URLSearchParams || globalThis.ReadableStream && body instanceof globalThis.ReadableStream) {
-      return { bodyHeaders: undefined, body };
-    } else if (typeof body === "object" && ((Symbol.asyncIterator in body) || (Symbol.iterator in body) && ("next" in body) && typeof body.next === "function")) {
-      return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
-    } else if (typeof body === "object" && headers.values.get("content-type") === "application/x-www-form-urlencoded") {
-      return {
-        bodyHeaders: { "content-type": "application/x-www-form-urlencoded" },
-        body: this.stringifyQuery(body)
-      };
+    const toolSchemas = await Promise.all(filteredTools.map((tool) => toolToAPISchema(tool, {
+      getToolPermissionContext: options.getToolPermissionContext,
+      tools,
+      agents: options.agents,
+      allowedAgentTypes: options.allowedAgentTypes,
+      model: options.model,
+      deferLoading: useToolSearch && deferredToolNames.has(tool.name)
+    })));
+    const standardTools = toolSchemas.filter((t) => {
+      const anyT = t;
+      return anyT.type !== "advisor_20260301" && anyT.type !== "computer_20250124";
+    });
+    const enableThinking = isOpenAIThinkingEnabled(openaiModel);
+    const openAIConvertibleMessages = messagesForAPI.filter(isOpenAIConvertibleMessage);
+    const messagesWithDeferredToolList = prependDeferredToolListIfNeeded(openAIConvertibleMessages, tools, deferredToolNames, useToolSearch);
+    const openaiMessages = anthropicMessagesToOpenAI(messagesWithDeferredToolList, systemPrompt, { enableThinking });
+    const openaiTools = anthropicToolsToOpenAI(standardTools);
+    const openaiToolChoice = anthropicToolChoiceToOpenAI(options.toolChoice);
+    if (useToolSearch) {
+      const includedDeferredTools = filteredTools.filter((t) => deferredToolNames.has(t.name)).length;
+      logForDebugging(`[OpenAI] Tool search enabled: ${includedDeferredTools}/${deferredToolNames.size} deferred tools included, total tools=${openaiTools.length}`);
     } else {
-      return __classPrivateFieldGet(this, _OpenAI_encoder, "f").call(this, { body, headers });
+      logForDebugging(`[OpenAI] Tool search disabled, total tools=${openaiTools.length}`);
+    }
+    const { upperLimit } = getModelMaxOutputTokens(openaiModel);
+    const maxTokens = resolveOpenAIMaxTokens(upperLimit, options.maxOutputTokensOverride);
+    const client = getOpenAIClient({
+      maxRetries: 0,
+      fetchOverride: options.fetchOverride,
+      source: options.querySource
+    });
+    const debugTimestamp = Date.now();
+    const debugRequestData = {
+      model: openaiModel,
+      systemPrompt_text: systemPrompt.join(`
+
+`),
+      openai_messages_preview: openaiMessages.slice(0, 3).map((m) => ({
+        role: m.role,
+        content_preview: typeof m.content === "string" ? m.content.substring(0, 500) : JSON.stringify(m.content)?.substring(0, 500)
+      })),
+      tools_names: openaiTools.map((t) => t.function?.name ?? t.name)
+    };
+    logForDebugging(`[OpenAI] Calling model=${openaiModel}, messages=${openaiMessages.length}, tools=${openaiTools.length}, thinking=${enableThinking}`);
+    const requestBody = buildOpenAIRequestBody({
+      model: openaiModel,
+      messages: openaiMessages,
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      enableThinking,
+      maxTokens,
+      temperatureOverride: options.temperatureOverride
+    });
+    const stream = await client.chat.completions.create(requestBody, { signal });
+    const adaptedStream = adaptOpenAIStreamToAnthropic(stream, openaiModel);
+    const contentBlocks = {};
+    const collectedMessages = [];
+    let partialMessage;
+    let stopReason = null;
+    let usage = {
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_creation_input_tokens: 0,
+      cache_read_input_tokens: 0
+    };
+    let ttftMs = 0;
+    const start = Date.now();
+    for await (const event of adaptedStream) {
+      switch (event.type) {
+        case "message_start": {
+          partialMessage = event.message;
+          ttftMs = Date.now() - start;
+          if (event.message?.usage) {
+            usage = {
+              ...usage,
+              ...event.message.usage
+            };
+          }
+          break;
+        }
+        case "content_block_start": {
+          const idx = event.index;
+          const cb = event.content_block;
+          if (cb.type === "tool_use") {
+            contentBlocks[idx] = { ...cb, input: "" };
+          } else if (cb.type === "text") {
+            contentBlocks[idx] = { ...cb, text: "" };
+          } else if (cb.type === "thinking") {
+            contentBlocks[idx] = { ...cb, thinking: "", signature: "" };
+          } else {
+            contentBlocks[idx] = { ...cb };
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const idx = event.index;
+          const delta = event.delta;
+          const block = contentBlocks[idx];
+          if (!block)
+            break;
+          if (delta.type === "text_delta") {
+            block.text = (block.text || "") + delta.text;
+          } else if (delta.type === "input_json_delta") {
+            block.input = (block.input || "") + delta.partial_json;
+          } else if (delta.type === "thinking_delta") {
+            block.thinking = (block.thinking || "") + delta.thinking;
+          } else if (delta.type === "signature_delta") {
+            block.signature = delta.signature;
+          }
+          break;
+        }
+        case "content_block_stop": {
+          break;
+        }
+        case "message_delta": {
+          const deltaUsage = event.usage;
+          if (deltaUsage) {
+            usage = { ...usage, ...deltaUsage };
+          }
+          if (event.delta?.stop_reason != null) {
+            stopReason = event.delta.stop_reason;
+          }
+          break;
+        }
+        case "message_stop": {
+          if (partialMessage) {
+            for (const output of assembleFinalAssistantOutputs({
+              partialMessage,
+              contentBlocks,
+              tools,
+              agentId: options.agentId,
+              usage,
+              stopReason,
+              maxTokens
+            })) {
+              if (output.type === "assistant") {
+                collectedMessages.push(output);
+              }
+              yield output;
+            }
+            partialMessage = null;
+          }
+          if (usage.input_tokens + usage.output_tokens > 0) {
+            const costUSD = calculateUSDCost(openaiModel, usage);
+            addToTotalSessionCost(costUSD, usage, options.model);
+          }
+          break;
+        }
+      }
+      yield {
+        type: "stream_event",
+        event,
+        ...event.type === "message_start" ? { ttftMs } : undefined
+      };
+    }
+    if (partialMessage) {
+      for (const output of assembleFinalAssistantOutputs({
+        partialMessage,
+        contentBlocks,
+        tools,
+        agentId: options.agentId,
+        usage,
+        stopReason,
+        maxTokens
+      })) {
+        yield output;
+      }
     }
+    try {
+      const { writeFileSync, mkdirSync } = await import("fs");
+      const { join } = await import("path");
+      const { tmpdir } = await import("os");
+      const debugDir = join(tmpdir(), "claude-code-debug");
+      mkdirSync(debugDir, { recursive: true });
+      const debugFile = join(debugDir, `openai-${debugTimestamp}.json`);
+      const allBlocks = Object.keys(contentBlocks).sort((a, b) => Number(a) - Number(b)).map((k) => contentBlocks[Number(k)]).filter(Boolean);
+      const debugPayload = {
+        timestamp: new Date(debugTimestamp).toISOString(),
+        model: openaiModel,
+        request: debugRequestData,
+        response: {
+          stop_reason: stopReason,
+          usage,
+          content_blocks: allBlocks.map((b) => {
+            if (b.type === "text")
+              return { type: "text", text: b.text };
+            if (b.type === "thinking")
+              return { type: "thinking", thinking_preview: b.thinking?.substring(0, 200) };
+            if (b.type === "tool_use")
+              return { type: "tool_use", name: b.name, input_preview: typeof b.input === "string" ? b.input.substring(0, 500) : b.input };
+            return { type: b.type };
+          }),
+          duration_ms: Date.now() - start
+        }
+      };
+      writeFileSync(debugFile, JSON.stringify(debugPayload, null, 2), "utf-8");
+      logForDebugging(`[DEBUG] OpenAI request+response dumped to ${debugFile}`);
+    } catch (e) {
+      logForDebugging(`[DEBUG] Failed to dump OpenAI debug file: ${e}`);
+    }
+  } catch (error2) {
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+    logForDebugging(`[OpenAI] Error: ${errorMessage}`, { level: "error" });
+    yield createAssistantAPIErrorMessage({
+      content: `API Error: ${errorMessage}`,
+      apiError: "api_error",
+      error: error2 instanceof Error ? error2 : new Error(String(error2))
+    });
   }
 }
-var _OpenAI_instances, _a2, _OpenAI_encoder, _OpenAI_baseURLOverridden;
-var init_client = __esm(() => {
-  init_tslib();
-  init_uuid();
-  init_values();
-  init_sleep();
-  init_errors();
-  init_detect_platform();
-  init_shims();
-  init_request_options();
-  init_query();
-  init_version();
-  init_error();
-  init_pagination();
-  init_uploads2();
-  init_resources();
-  init_api_promise();
-  init_batches();
-  init_completions3();
-  init_embeddings();
-  init_files2();
-  init_images();
-  init_models();
-  init_moderations();
-  init_videos();
-  init_audio();
-  init_beta();
-  init_chat();
-  init_containers();
-  init_conversations();
-  init_evals();
-  init_fine_tuning();
-  init_graders2();
-  init_realtime2();
-  init_responses();
-  init_skills();
-  init_uploads3();
-  init_vector_stores();
-  init_webhooks();
-  init_detect_platform();
-  init_headers();
-  init_env();
-  init_log();
-  init_values();
-  _a2 = OpenAI, _OpenAI_encoder = new WeakMap, _OpenAI_instances = new WeakSet, _OpenAI_baseURLOverridden = function _OpenAI_baseURLOverridden2() {
-    return this.baseURL !== "https://api.openai.com/v1";
-  };
-  OpenAI.OpenAI = _a2;
-  OpenAI.DEFAULT_TIMEOUT = 600000;
-  OpenAI.OpenAIError = OpenAIError;
-  OpenAI.APIError = APIError;
-  OpenAI.APIConnectionError = APIConnectionError;
-  OpenAI.APIConnectionTimeoutError = APIConnectionTimeoutError;
-  OpenAI.APIUserAbortError = APIUserAbortError;
-  OpenAI.NotFoundError = NotFoundError;
-  OpenAI.ConflictError = ConflictError;
-  OpenAI.RateLimitError = RateLimitError;
-  OpenAI.BadRequestError = BadRequestError;
-  OpenAI.AuthenticationError = AuthenticationError;
-  OpenAI.InternalServerError = InternalServerError;
-  OpenAI.PermissionDeniedError = PermissionDeniedError;
-  OpenAI.UnprocessableEntityError = UnprocessableEntityError;
-  OpenAI.InvalidWebhookSignatureError = InvalidWebhookSignatureError;
-  OpenAI.toFile = toFile;
-  OpenAI.Completions = Completions2;
-  OpenAI.Chat = Chat;
-  OpenAI.Embeddings = Embeddings;
-  OpenAI.Files = Files2;
-  OpenAI.Images = Images;
-  OpenAI.Audio = Audio;
-  OpenAI.Moderations = Moderations;
-  OpenAI.Models = Models;
-  OpenAI.FineTuning = FineTuning;
-  OpenAI.Graders = Graders2;
-  OpenAI.VectorStores = VectorStores;
-  OpenAI.Webhooks = Webhooks;
-  OpenAI.Beta = Beta;
-  OpenAI.Batches = Batches;
-  OpenAI.Uploads = Uploads;
-  OpenAI.Responses = Responses;
-  OpenAI.Realtime = Realtime2;
-  OpenAI.Conversations = Conversations;
-  OpenAI.Evals = Evals;
-  OpenAI.Containers = Containers;
-  OpenAI.Skills = Skills;
-  OpenAI.Videos = Videos;
-});
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/azure.mjs
-var _deployments_endpoints;
-var init_azure = __esm(() => {
-  init_headers();
-  init_error2();
-  init_utils2();
-  init_client();
-  _deployments_endpoints = new Set([
-    "/completions",
-    "/chat/completions",
-    "/embeddings",
-    "/audio/transcriptions",
-    "/audio/translations",
-    "/audio/speech",
-    "/images/generations",
-    "/batches",
-    "/images/edits"
-  ]);
-});
-
-// node_modules/.bun/openai@6.33.0+e0f88c919211175f/node_modules/openai/index.mjs
-var init_openai = __esm(() => {
-  init_client();
-  init_uploads2();
-  init_api_promise();
-  init_client();
-  init_pagination();
-  init_error();
-  init_azure();
+var init_openai2 = __esm(() => {
+  init_client2();
+  init_convertMessages();
+  init_convertTools();
+  init_streamAdapter();
+  init_modelMapping();
+  init_messages();
+  init_api();
+  init_Tool();
+  init_debug();
+  init_cost_tracker();
+  init_modelCost();
+  init_envUtils();
+  init_context();
+  init_messages();
+  init_toolSearch();
+  init_prompt();
 });
+init_openai2();
 
-export { OpenAI, init_openai, anthropicMessagesToOpenAI, init_convertMessages, anthropicToolsToOpenAI, anthropicToolChoiceToOpenAI, init_convertTools, adaptOpenAIStreamToAnthropic, init_streamAdapter };
+export {
+  resolveOpenAIMaxTokens,
+  queryModelOpenAI,
+  isOpenAIThinkingEnabled,
+  buildOpenAIRequestBody
+};