@yourgpt/llm-sdk 2.6.0-beta.0 → 2.6.0-beta.2

package/dist/providers/openai/index.js

@@ -1,5 +1,259 @@
 'use strict';
 
+// src/core/tool-output.ts
+var imageTypes = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif"
+]);
+function normalizeToolOutput(value) {
+  const output = value;
+  if (output?.type !== "content" || !Array.isArray(output.content) || !output.content.length) {
+    throw new Error("Tool model output must contain a nonempty content array");
+  }
+  return {
+    type: "content",
+    content: output.content.map((part) => {
+      if (part?.type === "text" && typeof part.text === "string")
+        return { type: "text", text: part.text };
+      if (part?.type !== "image")
+        throw new Error("Unsupported tool output content type");
+      const sources = ["data", "url", "fileId"].filter((key) => key in part);
+      if (sources.length !== 1)
+        throw new Error(
+          "Tool image requires exactly one of data, url, or fileId"
+        );
+      if ("fileId" in part) {
+        if (part.provider !== "openai" || typeof part.fileId !== "string" || !part.fileId.trim())
+          throw new Error(
+            "Tool image file references must name the openai provider and fileId"
+          );
+        return { type: "image", fileId: part.fileId, provider: "openai" };
+      }
+      if ("url" in part) {
+        let url;
+        try {
+          url = new URL(part.url);
+        } catch {
+          throw new Error("Invalid tool image URL");
+        }
+        if (!["https:", "http:"].includes(url.protocol) || url.username || url.password)
+          throw new Error(
+            "Tool image URL must use HTTP(S) without credentials"
+          );
+        return { type: "image", url: url.href };
+      }
+      if (!("data" in part) || !imageTypes.has(part.mediaType))
+        throw new Error("Unsupported tool image media type");
+      let data = part.data instanceof Uint8Array ? Buffer.from(part.data).toString("base64") : part.data;
+      if (typeof data !== "string")
+        throw new Error("Tool image data must be base64 or bytes");
+      if (data.startsWith("data:")) {
+        const match = /^data:([^;,]+);base64,(.+)$/.exec(data);
+        if (!match || match[1] !== part.mediaType)
+          throw new Error(
+            "Tool image data URL media type does not match mediaType"
+          );
+        data = match[2];
+      }
+      if (!data.length || data.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data))
+        throw new Error("Invalid tool image base64 data");
+      if (Buffer.byteLength(data, "base64") > 20 * 1024 * 1024)
+        throw new Error("Tool image exceeds 20 MiB");
+      if (Buffer.from(data, "base64").toString("base64") !== data)
+        throw new Error("Invalid tool image base64 data");
+      return { type: "image", data, mediaType: part.mediaType };
+    })
+  };
+}
+function toolOutputForProvider(value, provider) {
+  const output = normalizeToolOutput(value);
+  return output.content.map((part) => {
+    if (part.type === "text")
+      return {
+        type: provider === "responses" ? "input_text" : "text",
+        text: part.text
+      };
+    if (provider === "unsupported")
+      throw new Error(
+        "Image tool results require OpenAI Responses or Anthropic; this endpoint is not supported"
+      );
+    if ("fileId" in part) {
+      if (provider !== "responses")
+        throw new Error(
+          "OpenAI image file references cannot be sent to another provider"
+        );
+      return { type: "input_image", file_id: part.fileId, detail: "auto" };
+    }
+    if (provider === "responses")
+      return {
+        type: "input_image",
+        image_url: "url" in part ? part.url : `data:${part.mediaType};base64,${part.data}`,
+        detail: "auto"
+      };
+    return {
+      type: "image",
+      source: "url" in part ? { type: "url", url: part.url } : { type: "base64", media_type: part.mediaType, data: part.data }
+    };
+  });
+}
+function textToolOutput(value, fallback) {
+  if (value === void 0) return fallback;
+  return toolOutputForProvider(value, "unsupported").map((part) => part.text).join("\n");
+}
+
+// src/core/openai-parameters.ts
+function capabilities(model) {
+  const gpt = /^gpt-(\d+)(?:\.(\d+))?(?:-(.+))?$/i.exec(model);
+  const major = Number(gpt?.[1] ?? 0);
+  const minor = Number(gpt?.[2] ?? 0);
+  const chat = gpt?.[3]?.startsWith("chat") ?? false;
+  const reasoning = /^o\d+(?:-|$)/i.test(model) || major >= 5 && !chat;
+  const supportsNone = major === 5 && minor >= 1 && !chat || /^gpt-6-(?:sol|luna)(?:-\d{4}-\d{2}-\d{2})?$/i.test(model);
+  return { major, minor, reasoning, supportsNone };
+}
+function requiresOpenAIResponses(model, baseUrl, options = {}) {
+  if (options.parameterPolicy === "passthrough") return false;
+  const c = capabilities(model);
+  if (!c.reasoning || options.reasoningEffort === "none") return false;
+  if (!(c.major >= 6 || c.major === 5 && c.minor >= 4)) return false;
+  if (!baseUrl) return true;
+  try {
+    return new URL(baseUrl).hostname === "api.openai.com";
+  } catch {
+    return false;
+  }
+}
+function buildOpenAIParameters(model, maxTokens, temperature, options = {}, api = "chat") {
+  const c = capabilities(model ?? "");
+  const normalize = options.parameterPolicy !== "passthrough";
+  const effort = options.reasoningEffort;
+  if (normalize && c.reasoning && effort === "none" && !c.supportsNone) {
+    throw new Error(`${model} does not support reasoningEffort: none`);
+  }
+  if (normalize && c.major >= 6 && effort === "minimal") {
+    throw new Error(`${model} does not support reasoningEffort: minimal`);
+  }
+  const result = {
+    [api === "responses" ? "max_output_tokens" : normalize && c.reasoning ? "max_completion_tokens" : "max_tokens"]: maxTokens
+  };
+  if (effort !== void 0) {
+    if (api === "responses") result.reasoning = { effort };
+    else result.reasoning_effort = effort;
+  }
+  if (temperature !== void 0) {
+    if (!normalize || !c.reasoning || effort === "none" && c.supportsNone) {
+      result.temperature = temperature;
+    } else {
+      (options.onWarning ?? console.warn)(
+        `[llm-sdk] ${model}: omitted temperature because reasoning is enabled.`
+      );
+    }
+  }
+  return result;
+}
+
+// src/core/openai-responses.ts
+function resolveOpenAITransport(defaults, overrides) {
+  return {
+    api: overrides?.api ?? defaults.api ?? "auto",
+    responses: defaults.responses !== void 0 || overrides?.responses !== void 0 ? { ...defaults.responses, ...overrides?.responses } : void 0
+  };
+}
+function useOpenAIResponses(model, baseURL, parameters, transport2, hasTools, hasReplay, nativeToolSearch = false) {
+  const api = transport2.api ?? "auto";
+  if (!["auto", "chat", "responses"].includes(api)) {
+    throw new Error(`Unknown OpenAI API selection: ${api}`);
+  }
+  if (api === "chat") {
+    if (transport2.responses !== void 0 || nativeToolSearch) {
+      throw new Error(
+        "Responses options and native tool search require the Responses API"
+      );
+    }
+    return false;
+  }
+  let officialEndpoint = !baseURL;
+  try {
+    officialEndpoint = !baseURL || new URL(baseURL).hostname === "api.openai.com";
+  } catch {
+  }
+  return api === "responses" || transport2.responses !== void 0 || hasReplay && officialEndpoint || nativeToolSearch || hasTools && requiresOpenAIResponses(model, baseURL, parameters);
+}
+function responseMetadata(response) {
+  const output = Array.isArray(response?.output) ? response.output : [];
+  return {
+    openai: {
+      response: {
+        id: response?.id,
+        model: response?.model,
+        status: response?.status,
+        output,
+        usage: response?.usage,
+        store: response?.store,
+        refusals: output.flatMap(
+          (item) => item?.type === "message" && Array.isArray(item.content) ? item.content.filter(
+            (part) => part?.type === "refusal" && typeof part.refusal === "string"
+          ).map((part) => part.refusal) : []
+        )
+      }
+    }
+  };
+}
+function getResponseReplay(metadata) {
+  const response = metadata?.openai?.response;
+  if (response === void 0) return void 0;
+  if (!Array.isArray(response.output) || response.output.some((item) => !item || typeof item.type !== "string")) {
+    throw new Error(
+      "Invalid OpenAI Responses replay metadata: output must contain typed items"
+    );
+  }
+  return response.output;
+}
+
+// src/core/provider-error.ts
+function providerErrorEvent(error, code) {
+  const details = error ?? {};
+  const event = {
+    type: "error",
+    message: error instanceof Error ? error.message : String(error),
+    code,
+    ...typeof details.status === "number" ? { status: details.status } : {},
+    ...typeof details.code === "string" ? { providerCode: details.code } : {},
+    ...typeof details.param === "string" ? { param: details.param } : {},
+    ...typeof details.request_id === "string" ? { requestId: details.request_id } : {}
+  };
+  Object.defineProperty(event, "cause", { value: error, enumerable: false });
+  return event;
+}
+function errorFromEvent(event) {
+  if (event.cause instanceof Error) return event.cause;
+  return Object.assign(new Error(event.message), {
+    status: event.status,
+    code: event.providerCode ?? event.code,
+    param: event.param,
+    request_id: event.requestId
+  });
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  throw error;
+}
+
+// src/core/utils.ts
+function generateId(prefix = "id") {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function generateMessageId() {
+  return generateId("msg");
+}
+function generateToolCallId() {
+  return generateId("call");
+}
+
 // src/adapters/base.ts
 function stringifyForDebug(value) {
   return JSON.stringify(
@@ -106,16 +360,6 @@ function normalizeObjectJsonSchema(schema) {
   }
   return normalized;
 }
-function isOpenAIReasoningModel(modelId) {
-  if (!modelId) return false;
-  return /^(o1|o3|o4|gpt-5)/i.test(modelId);
-}
-function buildOpenAITokenParams(modelId, maxTokens, temperature) {
-  if (isOpenAIReasoningModel(modelId)) {
-    return { max_completion_tokens: maxTokens };
-  }
-  return { max_tokens: maxTokens, temperature };
-}
 function toOpenAIResponseFormat(rf) {
   if (!rf) return void 0;
   if (rf.type === "json_object") return { type: "json_object" };
@@ -200,7 +444,7 @@ function messageToOpenAIContent(message) {
   }
   return blocks;
 }
-function formatMessagesForOpenAI(messages, systemPrompt) {
+function formatMessagesForOpenAI(messages, systemPrompt, preserveProviderMetadata = false) {
   const formatted = [];
   if (systemPrompt) {
     formatted.push({ role: "system", content: systemPrompt });
@@ -218,7 +462,8 @@ function formatMessagesForOpenAI(messages, systemPrompt) {
       const assistantMsg = {
         role: "assistant",
         // Gemini/xAI (OpenAI-compatible) reject content: "" on assistant messages with tool_calls
-        content: hasToolCalls ? msg.content || null : msg.content
+        content: hasToolCalls ? msg.content || null : msg.content,
+        ...preserveProviderMetadata && msg.providerMetadata ? { providerMetadata: msg.providerMetadata } : {}
       };
       if (hasToolCalls) {
         assistantMsg.tool_calls = msg.tool_calls;
@@ -227,7 +472,8 @@ function formatMessagesForOpenAI(messages, systemPrompt) {
     } else if (msg.role === "tool" && msg.tool_call_id) {
       formatted.push({
         role: "tool",
-        content: msg.content ?? "",
+        content: preserveProviderMetadata ? msg.content ?? "" : textToolOutput(msg.modelOutput, msg.content ?? ""),
+        ...preserveProviderMetadata && msg.modelOutput ? { modelOutput: msg.modelOutput } : {},
         tool_call_id: msg.tool_call_id
       });
     }
@@ -235,344 +481,61 @@ function formatMessagesForOpenAI(messages, systemPrompt) {
   return formatted;
 }
 
-// src/providers/openai/provider.ts
-var OPENAI_MODELS = {
-  // GPT-4o series
-  "gpt-4o": { vision: true, tools: true, jsonMode: true, maxTokens: 128e3 },
-  "gpt-5.2": {
-    vision: true,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4o-2024-11-20": {
-    vision: true,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4o-2024-08-06": {
-    vision: true,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  // GPT-4 Turbo
-  "gpt-4-turbo": {
-    vision: true,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4-turbo-preview": {
-    vision: false,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  // GPT-4
-  "gpt-4": { vision: false, tools: true, jsonMode: false, maxTokens: 8192 },
-  "gpt-4-32k": {
-    vision: false,
-    tools: true,
-    jsonMode: false,
-    maxTokens: 32768
-  },
-  // GPT-3.5
-  "gpt-3.5-turbo": {
-    vision: false,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 16385
-  },
-  // O1 series (reasoning)
-  o1: { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 },
-  "o1-mini": { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 },
-  "o1-preview": {
-    vision: true,
-    tools: false,
-    jsonMode: false,
-    maxTokens: 128e3
-  },
-  // O3 series
-  "o3-mini": { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 }
-};
-function openai(modelId, options = {}) {
-  const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
-  const baseURL = options.baseURL ?? "https://api.openai.com/v1";
-  let client = null;
-  async function getClient() {
-    if (!client) {
+// src/adapters/openai.ts
+var OpenAIAdapter = class _OpenAIAdapter {
+  constructor(config) {
+    this.config = config;
+    this.model = config.model || "gpt-4o";
+    this.provider = _OpenAIAdapter.resolveProviderName(config.baseUrl);
+  }
+  static resolveProviderName(baseUrl) {
+    if (!baseUrl) return "openai";
+    if (baseUrl.includes("generativelanguage.googleapis.com")) return "google";
+    if (baseUrl.includes("x.ai")) return "xai";
+    if (baseUrl.includes("azure")) return "azure";
+    if (baseUrl.includes("fireworks.ai")) return "fireworks";
+    return "openai";
+  }
+  async getClient() {
+    if (!this.client) {
       const { default: OpenAI } = await import('openai');
-      client = new OpenAI({
-        apiKey,
-        baseURL,
-        organization: options.organization,
-        defaultHeaders: options.headers
+      this.client = new OpenAI({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl,
+        organization: this.config.organization,
+        defaultHeaders: this.config.headers
       });
     }
-    return client;
+    return this.client;
   }
-  const modelConfig = OPENAI_MODELS[modelId] ?? OPENAI_MODELS["gpt-4o"];
-  return {
-    provider: "openai",
-    modelId,
-    capabilities: {
-      supportsVision: modelConfig.vision,
-      supportsTools: modelConfig.tools,
-      supportsStreaming: true,
-      supportsJsonMode: modelConfig.jsonMode,
-      supportsThinking: false,
-      supportsPDF: false,
-      maxTokens: modelConfig.maxTokens,
-      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
-    },
-    async doGenerate(params) {
-      const client2 = await getClient();
-      const messages = formatMessagesForOpenAI2(params.messages);
-      const response = await client2.chat.completions.create({
-        model: modelId,
-        messages,
-        tools: params.tools,
-        ...buildOpenAITokenParams(
-          modelId,
-          params.maxTokens,
-          params.temperature
-        ),
-        response_format: toOpenAIResponseFormat(params.responseFormat)
-      });
-      const choice = response.choices[0];
-      const message = choice.message;
-      const toolCalls = (message.tool_calls ?? []).map(
-        (tc) => ({
-          id: tc.id,
-          name: tc.function.name,
-          args: JSON.parse(tc.function.arguments || "{}")
-        })
-      );
-      return {
-        text: message.content ?? "",
-        toolCalls,
-        finishReason: mapFinishReason(choice.finish_reason),
-        usage: {
-          promptTokens: response.usage?.prompt_tokens ?? 0,
-          completionTokens: response.usage?.completion_tokens ?? 0,
-          totalTokens: response.usage?.total_tokens ?? 0
-        },
-        rawResponse: response
-      };
-    },
-    async *doStream(params) {
-      const client2 = await getClient();
-      const messages = formatMessagesForOpenAI2(params.messages);
-      const stream = await client2.chat.completions.create({
-        model: modelId,
-        messages,
-        tools: params.tools,
-        ...buildOpenAITokenParams(
-          modelId,
-          params.maxTokens,
-          params.temperature
-        ),
-        response_format: toOpenAIResponseFormat(params.responseFormat),
-        stream: true
-      });
-      let currentToolCall = null;
-      let totalPromptTokens = 0;
-      let totalCompletionTokens = 0;
-      for await (const chunk of stream) {
-        if (params.signal?.aborted) {
-          yield { type: "error", error: new Error("Aborted") };
-          return;
-        }
-        const choice = chunk.choices[0];
-        const delta = choice?.delta;
-        if (delta?.content) {
-          yield { type: "text-delta", text: delta.content };
-        }
-        if (delta?.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            if (tc.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "tool-call",
-                  toolCall: {
-                    id: currentToolCall.id,
-                    name: currentToolCall.name,
-                    args: JSON.parse(currentToolCall.arguments || "{}")
-                  }
-                };
-              }
-              currentToolCall = {
-                id: tc.id,
-                name: tc.function?.name ?? "",
-                arguments: tc.function?.arguments ?? ""
-              };
-            } else if (currentToolCall && tc.function?.arguments) {
-              currentToolCall.arguments += tc.function.arguments;
-            }
-          }
-        }
-        if (choice?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "tool-call",
-              toolCall: {
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: JSON.parse(currentToolCall.arguments || "{}")
-              }
-            };
-            currentToolCall = null;
-          }
-          if (chunk.usage) {
-            totalPromptTokens = chunk.usage.prompt_tokens;
-            totalCompletionTokens = chunk.usage.completion_tokens;
-          }
-          yield {
-            type: "finish",
-            finishReason: mapFinishReason(choice.finish_reason),
-            usage: {
-              promptTokens: totalPromptTokens,
-              completionTokens: totalCompletionTokens,
-              totalTokens: totalPromptTokens + totalCompletionTokens
-            }
-          };
-        }
-      }
-    }
-  };
-}
-function mapFinishReason(reason) {
-  switch (reason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "tool_calls":
-    case "function_call":
-      return "tool-calls";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return "unknown";
-  }
-}
-function formatMessagesForOpenAI2(messages) {
-  return messages.map((msg) => {
-    switch (msg.role) {
-      case "system":
-        return { role: "system", content: msg.content };
-      case "user":
-        if (typeof msg.content === "string") {
-          return { role: "user", content: msg.content };
-        }
-        return {
-          role: "user",
-          content: msg.content.map((part) => {
-            if (part.type === "text") {
-              return { type: "text", text: part.text };
-            }
-            if (part.type === "image") {
-              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
-              return { type: "image_url", image_url: { url, detail: "auto" } };
-            }
-            return { type: "text", text: "" };
-          })
-        };
-      case "assistant":
-        const assistantMsg = {
-          role: "assistant",
-          content: msg.content
-        };
-        if (msg.toolCalls && msg.toolCalls.length > 0) {
-          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.args)
-            }
-          }));
-        }
-        return assistantMsg;
-      case "tool":
-        return {
-          role: "tool",
-          tool_call_id: msg.toolCallId,
-          content: msg.content
-        };
-      default:
-        return msg;
-    }
-  });
-}
-
-// src/core/utils.ts
-function generateId(prefix = "id") {
-  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
-function generateMessageId() {
-  return generateId("msg");
-}
-function generateToolCallId() {
-  return generateId("call");
-}
-
-// src/adapters/openai.ts
-var OpenAIAdapter = class _OpenAIAdapter {
-  constructor(config) {
-    this.config = config;
-    this.model = config.model || "gpt-4o";
-    this.provider = _OpenAIAdapter.resolveProviderName(config.baseUrl);
-  }
-  static resolveProviderName(baseUrl) {
-    if (!baseUrl) return "openai";
-    if (baseUrl.includes("generativelanguage.googleapis.com")) return "google";
-    if (baseUrl.includes("x.ai")) return "xai";
-    if (baseUrl.includes("azure")) return "azure";
-    if (baseUrl.includes("fireworks.ai")) return "fireworks";
-    return "openai";
+  parameterOptions(request) {
+    return {
+      ...this.config,
+      reasoningEffort: request.config?.reasoningEffort ?? this.config.reasoningEffort
+    };
   }
-  async getClient() {
-    if (!this.client) {
-      const { default: OpenAI } = await import('openai');
-      this.client = new OpenAI({
-        apiKey: this.config.apiKey,
-        baseURL: this.config.baseUrl
-      });
-    }
-    return this.client;
+  toolDefinitions(request) {
+    if (request.toolDefinitions?.length) return request.toolDefinitions;
+    return formatTools(request.actions ?? []).map((tool) => ({
+      name: tool.function.name,
+      description: tool.function.description ?? "",
+      location: "server",
+      inputSchema: tool.function.parameters
+    }));
   }
   shouldUseResponsesApi(request) {
-    const hasTools = Array.isArray(request.toolDefinitions) && request.toolDefinitions.length > 0;
-    if (!hasTools) return false;
-    if (request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true && request.providerToolOptions.openai.nativeToolSearch.useResponsesApi !== false) {
-      return true;
-    }
-    return this.requiresResponsesApiForTools(
-      request.config?.model || this.model
+    return useOpenAIResponses(
+      request.config?.model || this.model,
+      this.config.baseUrl,
+      this.parameterOptions(request),
+      resolveOpenAITransport(this.config, request.config?.openai),
+      this.toolDefinitions(request).length > 0,
+      !!(request.rawMessages ?? request.messages)?.some(
+        (message) => message.providerMetadata?.openai?.response
+      ),
+      request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true && request.providerToolOptions.openai.nativeToolSearch.useResponsesApi !== false
     );
   }
-  /**
-   * Whether this model rejects function tools on /v1/chat/completions.
-   *
-   * Applies to OpenAI proper only — the adapter is reused for OpenAI-compatible
-   * providers (Azure, xAI, Google, Fireworks) whose endpoints have no such
-   * restriction and may not implement /v1/responses at all.
-   */
-  requiresResponsesApiForTools(modelId) {
-    if (!modelId) return false;
-    if (!/^gpt-5\.(?:[4-9]|\d{2,})/i.test(modelId)) return false;
-    const baseUrl = this.config.baseUrl;
-    if (!baseUrl) return true;
-    try {
-      return new URL(baseUrl).hostname === "api.openai.com";
-    } catch {
-      return false;
-    }
-  }
   /**
    * Convert one message's content to Responses content parts.
    *
@@ -603,11 +566,11 @@ var OpenAIAdapter = class _OpenAIAdapter {
     });
   }
   buildResponsesInput(request) {
-    const sourceMessages = request.rawMessages && request.rawMessages.length > 0 ? request.rawMessages : formatMessagesForOpenAI(request.messages, void 0);
+    const sourceMessages = request.rawMessages && request.rawMessages.length > 0 ? this.formatRawMessages(request.rawMessages, true) : formatMessagesForOpenAI(request.messages, void 0, true);
     const input = [];
     for (const message of sourceMessages) {
       if (message.role === "system") {
-        if (!request.systemPrompt && message.content) {
+        if (message.content && message.content !== request.systemPrompt) {
           input.push({
             type: "message",
             role: "developer",
@@ -617,6 +580,11 @@ var OpenAIAdapter = class _OpenAIAdapter {
         continue;
       }
       if (message.role === "assistant") {
+        const replay = getResponseReplay(message.providerMetadata);
+        if (replay) {
+          input.push(...replay);
+          continue;
+        }
         const content = this.toResponsesContent(message.content, "assistant");
         if (typeof content === "string" ? content : Array.isArray(content) && content.length > 0) {
           input.push({
@@ -640,7 +608,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
         input.push({
           type: "function_call_output",
           call_id: message.tool_call_id,
-          output: typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? null)
+          output: message.modelOutput ? toolOutputForProvider(message.modelOutput, "responses") : typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? null)
         });
         continue;
       }
@@ -653,6 +621,32 @@ var OpenAIAdapter = class _OpenAIAdapter {
     }
     return input;
   }
+  /** Preserve Copilot screenshot attachments on every OpenAI transport. */
+  formatRawMessages(messages, preserveProviderMetadata = false) {
+    return messages.map((message) => {
+      const { attachments, providerMetadata, modelOutput, ...rest } = message;
+      let content = message.role === "tool" && !preserveProviderMetadata ? textToolOutput(modelOutput, String(message.content ?? "")) : message.content;
+      if (preserveProviderMetadata && modelOutput)
+        rest.modelOutput = modelOutput;
+      if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0 && content === "") {
+        content = null;
+      }
+      if (Array.isArray(attachments) && attachments.length > 0) {
+        const images = attachments.filter((attachment) => attachment && typeof attachment === "object").map(
+          (attachment) => attachmentToOpenAIImage(attachment)
+        ).filter((image) => image !== null);
+        if (images.length > 0) {
+          const parts = Array.isArray(content) ? content : content ? [{ type: "text", text: content }] : [];
+          content = [...parts, ...images];
+        }
+      }
+      return {
+        ...rest,
+        content,
+        ...preserveProviderMetadata && providerMetadata ? { providerMetadata } : {}
+      };
+    });
+  }
   /**
    * Build the web_search tool for the Responses API, or undefined when web
    * search is off.
@@ -731,20 +725,25 @@ var OpenAIAdapter = class _OpenAIAdapter {
       ).map((part) => part.text) : []
     ).join("") : "";
     const content = textFromOutput || (typeof response?.output_text === "string" ? response.output_text : "");
-    const toolCalls = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "function_call").map((item) => ({
-      id: item.call_id ?? item.id ?? generateToolCallId(),
-      name: item.name,
-      args: (() => {
-        try {
-          return JSON.parse(item.arguments ?? "{}");
-        } catch {
-          return {};
-        }
-      })()
-    })) : [];
+    const seenCallIds = /* @__PURE__ */ new Set();
+    const toolCalls = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "function_call").map((item) => {
+      if (typeof item.call_id !== "string" || !item.call_id || typeof item.name !== "string" || !item.name || typeof item.arguments !== "string" || item.status && item.status !== "completed") {
+        throw new Error("Responses contains an incomplete function call");
+      }
+      if (seenCallIds.has(item.call_id))
+        throw new Error("Responses contains duplicate function call IDs");
+      seenCallIds.add(item.call_id);
+      const args = JSON.parse(item.arguments);
+      if (!args || typeof args !== "object" || Array.isArray(args))
+        throw new Error(
+          "Responses function arguments must be a JSON object"
+        );
+      return { id: item.call_id, name: item.name, args };
+    }) : [];
     return {
       content,
       toolCalls,
+      providerMetadata: responseMetadata(response),
       usage: response?.usage ? {
         promptTokens: response.usage.input_tokens ?? 0,
         completionTokens: response.usage.output_tokens ?? 0,
@@ -755,6 +754,17 @@ var OpenAIAdapter = class _OpenAIAdapter {
   }
   buildResponsesPayload(request, stream) {
     const openaiToolOptions = request.providerToolOptions?.openai;
+    const options = resolveOpenAITransport(
+      this.config,
+      request.config?.openai
+    ).responses;
+    const parameters = buildOpenAIParameters(
+      request.config?.model || this.model,
+      request.config?.maxTokens ?? this.config.maxTokens,
+      request.config?.temperature ?? this.config.temperature,
+      this.parameterOptions(request),
+      "responses"
+    );
     const responsesTextFormat = toOpenAIResponsesTextFormat(
       request.config?.responseFormat
     );
@@ -764,18 +774,32 @@ var OpenAIAdapter = class _OpenAIAdapter {
       instructions: request.systemPrompt,
       input: this.buildResponsesInput(request),
       tools: this.buildResponsesTools(
-        request.toolDefinitions ?? [],
+        this.toolDefinitions(request),
         request.providerToolOptions?.openai?.nativeToolSearch?.enabled === true,
         this.buildResponsesWebSearchTool(request)
       ),
-      tool_choice: openaiToolOptions?.toolChoice === "required" ? "required" : openaiToolOptions?.toolChoice === "auto" ? "auto" : void 0,
+      tool_choice: openaiToolOptions?.toolChoice,
       parallel_tool_calls: openaiToolOptions?.parallelToolCalls,
-      // Reasoning models reject `temperature` outright — sending it would swap one
-      // 400 for another. isOpenAIReasoningModel already encodes that family test.
-      ...isOpenAIReasoningModel(modelIdForPayload) ? {} : {
-        temperature: request.config?.temperature ?? this.config.temperature
-      },
-      max_output_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+      ...parameters,
+      ...options?.reasoningSummary ? {
+        reasoning: {
+          ...parameters.reasoning,
+          summary: options.reasoningSummary
+        }
+      } : {},
+      ...options?.store !== void 0 ? { store: options.store } : {},
+      ...options?.previousResponseId !== void 0 ? { previous_response_id: options.previousResponseId } : {},
+      ...options?.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {},
+      ...options?.promptCacheOptions !== void 0 ? { prompt_cache_options: options.promptCacheOptions } : {},
+      ...options?.promptCacheRetention !== void 0 ? { prompt_cache_retention: options.promptCacheRetention } : {},
+      ...options?.store === false || options?.include ? {
+        include: [
+          .../* @__PURE__ */ new Set([
+            ...options?.include ?? [],
+            ...options?.store === false ? ["reasoning.encrypted_content"] : []
+          ])
+        ]
+      } : {},
       ...responsesTextFormat ? { text: { format: responsesTextFormat } } : {},
       stream
     };
@@ -783,10 +807,26 @@ var OpenAIAdapter = class _OpenAIAdapter {
   }
   async completeWithResponses(request) {
     const client = await this.getClient();
+    throwIfAborted(request.signal);
     const payload = this.buildResponsesPayload(request, false);
     logProviderPayload("openai", "request payload", payload, request.debug);
-    const response = await client.responses.create(payload);
+    if (!client.responses?.create)
+      throw new Error(
+        "This OpenAI client does not support Responses; install an openai version with Responses support."
+      );
+    const response = await client.responses.create(payload, {
+      signal: request.signal
+    });
+    throwIfAborted(request.signal);
     logProviderPayload("openai", "response payload", response, request.debug);
+    if (response.status && response.status !== "completed") {
+      throw Object.assign(
+        new Error(
+          response.error?.message ?? `Responses request ${response.status}`
+        ),
+        response.error
+      );
+    }
     return this.parseResponsesResult(response);
   }
   /**
@@ -804,13 +844,30 @@ var OpenAIAdapter = class _OpenAIAdapter {
    */
   async *streamWithResponses(request) {
     const client = await this.getClient();
+    throwIfAborted(request.signal);
     const payload = this.buildResponsesPayload(request, true);
     logProviderPayload("openai", "request payload", payload, request.debug);
-    const stream = await client.responses.create(payload);
+    if (!client.responses?.create)
+      throw new Error(
+        "This OpenAI client does not support Responses; install an openai version with Responses support."
+      );
+    const stream = await client.responses.create(payload, {
+      signal: request.signal
+    });
     const toolCalls = /* @__PURE__ */ new Map();
     let usage;
     const citations = [];
+    let completed = false;
+    let terminalResponse;
+    let responseIdentity = {};
+    const outputItems = /* @__PURE__ */ new Map();
+    let streamedText = "";
     function* flushToolCalls() {
+      for (const call of toolCalls.values()) {
+        if (!call.name)
+          throw new Error("Responses tool call is missing its name");
+        JSON.parse(call.arguments || "{}");
+      }
       for (const call of toolCalls.values()) {
         yield { type: "action:start", id: call.id, name: call.name };
         yield { type: "action:args", id: call.id, args: call.arguments };
@@ -819,19 +876,38 @@ var OpenAIAdapter = class _OpenAIAdapter {
       toolCalls.clear();
     }
     for await (const event of stream) {
-      if (request.signal?.aborted) break;
+      throwIfAborted(request.signal);
       logProviderPayload("openai", "stream chunk", event, request.debug);
+      if (completed)
+        throw new Error("Responses stream emitted an event after completion");
       const index = event?.output_index ?? 0;
       switch (event?.type) {
+        case "response.created":
+          responseIdentity = {
+            id: event.response?.id,
+            model: event.response?.model
+          };
+          break;
+        case "response.output_item.done":
+          if (event.item) outputItems.set(index, event.item);
+          if (event.item?.type === "function_call") {
+            toolCalls.set(index, {
+              id: event.item.call_id,
+              name: event.item.name,
+              arguments: event.item.arguments
+            });
+          }
+          break;
         case "response.output_text.delta":
           if (event.delta) {
+            streamedText += event.delta;
             yield { type: "message:delta", content: event.delta };
           }
           break;
         case "response.output_item.added":
           if (event.item?.type === "function_call") {
             toolCalls.set(index, {
-              id: event.item.call_id ?? event.item.id ?? generateToolCallId(),
+              id: event.item.call_id ?? "",
               name: event.item.name ?? "",
               arguments: event.item.arguments ?? ""
             });
@@ -849,8 +925,11 @@ var OpenAIAdapter = class _OpenAIAdapter {
           }
           break;
         }
-        case "response.completed":
-        case "response.incomplete": {
+        case "response.completed": {
+          if (event.response?.status && event.response.status !== "completed")
+            throw new Error(`Responses stream ${event.response.status}`);
+          completed = true;
+          terminalResponse = { ...responseIdentity, ...event.response };
           const found = this.collectResponsesCitations(
             event.response?.output,
             citations.length
@@ -866,21 +945,88 @@ var OpenAIAdapter = class _OpenAIAdapter {
           }
           break;
         }
-        case "error":
-        case "response.failed":
+        case "response.incomplete":
           throw new Error(
-            event.message ?? event.response?.error?.message ?? "Responses stream failed"
+            `Responses stream incomplete: ${event.response?.incomplete_details?.reason ?? "unknown reason"}`
+          );
+        case "error":
+        case "response.failed": {
+          const details = event.response?.error ?? event;
+          throw Object.assign(
+            new Error(details.message ?? "Responses stream failed"),
+            {
+              code: details.code,
+              param: details.param,
+              status: details.status
+            }
           );
+        }
+      }
+    }
+    throwIfAborted(request.signal);
+    if (!completed)
+      throw new Error("Responses stream ended without a completed response");
+    const output = terminalResponse.output?.length ? terminalResponse.output : [...outputItems.entries()].sort(([a], [b]) => a - b).map(([, item]) => item);
+    if (output.some((item) => item.type === "function_call"))
+      toolCalls.clear();
+    for (const [index, item] of output.entries()) {
+      if (item.type === "function_call") {
+        toolCalls.set(index, {
+          id: item.call_id,
+          name: item.name,
+          arguments: item.arguments
+        });
       }
     }
+    const uniqueCalls = /* @__PURE__ */ new Map();
+    for (const call of toolCalls.values()) {
+      if (!call.id || !call.name)
+        throw new Error("Responses stream contains an incomplete tool call");
+      uniqueCalls.set(call.id, call);
+    }
+    toolCalls.clear();
+    [...uniqueCalls.values()].forEach(
+      (call, index) => toolCalls.set(index, call)
+    );
+    if (!output.length && toolCalls.size) {
+      for (const call of toolCalls.values())
+        output.push({
+          type: "function_call",
+          call_id: call.id,
+          name: call.name,
+          arguments: call.arguments
+        });
+    }
+    if (!output.length && streamedText)
+      output.push({
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: streamedText, annotations: [] }]
+      });
+    terminalResponse.output = output;
+    const finalText = this.parseResponsesResult(terminalResponse).content;
+    if (finalText.startsWith(streamedText) && finalText.length > streamedText.length) {
+      yield {
+        type: "message:delta",
+        content: finalText.slice(streamedText.length)
+      };
+    }
     yield* flushToolCalls();
     if (citations.length > 0) {
       yield { type: "citation", citations: deduplicateCitations(citations) };
     }
-    yield { type: "message:end" };
-    yield { type: "done", usage };
+    yield {
+      type: "message:end",
+      providerMetadata: responseMetadata(terminalResponse)
+    };
+    yield {
+      type: "done",
+      usage,
+      providerMetadata: responseMetadata(terminalResponse)
+    };
   }
   async *stream(request) {
+    throwIfAborted(request.signal);
     if (this.shouldUseResponsesApi(request)) {
       const messageId2 = generateMessageId();
       yield { type: "message:start", id: messageId2 };
@@ -888,47 +1034,14 @@ var OpenAIAdapter = class _OpenAIAdapter {
         yield* this.streamWithResponses(request);
         return;
       } catch (error) {
-        yield {
-          type: "error",
-          message: error instanceof Error ? error.message : "Unknown error",
-          code: "OPENAI_RESPONSES_ERROR"
-        };
+        yield providerErrorEvent(error, "OPENAI_RESPONSES_ERROR");
         return;
       }
     }
     const client = await this.getClient();
     let messages;
     if (request.rawMessages && request.rawMessages.length > 0) {
-      const processedMessages = request.rawMessages.map((msg) => {
-        if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0 && msg.content === "") {
-          return { ...msg, content: null };
-        }
-        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
-        if (hasAttachments) {
-          const content = [];
-          if (msg.content) {
-            content.push({ type: "text", text: msg.content });
-          }
-          for (const attachment of msg.attachments) {
-            if (attachment.type === "image") {
-              let imageUrl;
-              if (attachment.url) {
-                imageUrl = attachment.url;
-              } else if (attachment.data) {
-                imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
-              } else {
-                continue;
-              }
-              content.push({
-                type: "image_url",
-                image_url: { url: imageUrl, detail: "auto" }
-              });
-            }
-          }
-          return { ...msg, content, attachments: void 0 };
-        }
-        return msg;
-      });
+      const processedMessages = this.formatRawMessages(request.rawMessages);
       if (request.systemPrompt) {
         const hasSystem = processedMessages.some((m) => m.role === "system");
         if (!hasSystem) {
@@ -948,7 +1061,16 @@ var OpenAIAdapter = class _OpenAIAdapter {
         request.systemPrompt
       );
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : [];
+    const tools = request.toolDefinitions?.length ? request.toolDefinitions.filter((tool) => tool.available !== false).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: normalizeObjectJsonSchema(
+          tool.inputSchema
+        )
+      }
+    })) : formatTools(request.actions ?? []);
     const webSearchConfig = request.webSearch ?? this.config.webSearch;
     if (webSearchConfig) {
       const webSearchTool = {
@@ -977,26 +1099,28 @@ var OpenAIAdapter = class _OpenAIAdapter {
         tools: tools.length > 0 ? tools : void 0,
         tool_choice: tools.length > 0 ? toolChoice : void 0,
         parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
-        ...buildOpenAITokenParams(
+        ...buildOpenAIParameters(
           modelIdForPayload,
           request.config?.maxTokens ?? this.config.maxTokens,
-          request.config?.temperature ?? this.config.temperature
+          request.config?.temperature ?? this.config.temperature,
+          this.parameterOptions(request)
         ),
         response_format: toOpenAIResponseFormat(request.config?.responseFormat),
         stream: true,
         stream_options: { include_usage: true }
       };
       logProviderPayload("openai", "request payload", payload, request.debug);
-      const stream = await client.chat.completions.create(payload);
-      let currentToolCall = null;
+      const stream = await client.chat.completions.create(payload, {
+        signal: request.signal
+      });
+      const toolCalls = /* @__PURE__ */ new Map();
+      let finishReason;
       const collectedCitations = [];
       let citationIndex = 0;
       let usage;
       for await (const chunk of stream) {
         logProviderPayload("openai", "stream chunk", chunk, request.debug);
-        if (request.signal?.aborted) {
-          break;
-        }
+        throwIfAborted(request.signal);
         const delta = chunk.choices[0]?.delta;
         const choice = chunk.choices[0];
         if (delta?.content) {
@@ -1019,38 +1143,19 @@ var OpenAIAdapter = class _OpenAIAdapter {
             }
           }
         }
-        if (delta?.tool_calls) {
-          for (const toolCall of delta.tool_calls) {
-            if (toolCall.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "action:args",
-                  id: currentToolCall.id,
-                  args: currentToolCall.arguments
-                };
-                yield {
-                  type: "action:end",
-                  id: currentToolCall.id,
-                  name: currentToolCall.name
-                };
-              }
-              const tcExtraContent = toolCall.extra_content;
-              currentToolCall = {
-                id: toolCall.id,
-                name: toolCall.function?.name || "",
-                arguments: toolCall.function?.arguments || "",
-                ...tcExtraContent ? { extra_content: tcExtraContent } : {}
-              };
-              yield {
-                type: "action:start",
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                ...currentToolCall.extra_content ? { extra_content: currentToolCall.extra_content } : {}
-              };
-            } else if (currentToolCall && toolCall.function?.arguments) {
-              currentToolCall.arguments += toolCall.function.arguments;
-            }
-          }
+        for (const part of delta?.tool_calls ?? []) {
+          const index = part.index ?? 0;
+          const call = toolCalls.get(index) ?? {
+            id: "",
+            name: "",
+            arguments: ""
+          };
+          if (part.id) call.id = part.id;
+          if (part.function?.name) call.name += part.function.name;
+          if (part.function?.arguments)
+            call.arguments += part.function.arguments;
+          if (part.extra_content) call.extra_content = part.extra_content;
+          toolCalls.set(index, call);
         }
         if (chunk.usage) {
           usage = {
@@ -1059,21 +1164,28 @@ var OpenAIAdapter = class _OpenAIAdapter {
             total_tokens: chunk.usage.total_tokens
           };
         }
-        if (choice?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "action:args",
-              id: currentToolCall.id,
-              args: currentToolCall.arguments
-            };
-            yield {
-              type: "action:end",
-              id: currentToolCall.id,
-              name: currentToolCall.name
-            };
-            currentToolCall = null;
-          }
-        }
+        if (choice?.finish_reason) finishReason = choice.finish_reason;
+      }
+      throwIfAborted(request.signal);
+      if (!finishReason)
+        throw new Error("OpenAI stream ended without a finish reason");
+      if (toolCalls.size && !["tool_calls", "function_call"].includes(finishReason)) {
+        throw new Error("OpenAI stream ended with incomplete tool calls");
+      }
+      for (const call of toolCalls.values()) {
+        if (!call.id || !call.name)
+          throw new Error("OpenAI stream contains an incomplete tool call");
+        JSON.parse(call.arguments || "{}");
+      }
+      for (const call of toolCalls.values()) {
+        yield {
+          type: "action:start",
+          id: call.id,
+          name: call.name,
+          ...call.extra_content ? { extra_content: call.extra_content } : {}
+        };
+        yield { type: "action:args", id: call.id, args: call.arguments };
+        yield { type: "action:end", id: call.id, name: call.name };
       }
       if (collectedCitations.length > 0) {
         const uniqueCitations = deduplicateCitations(collectedCitations);
@@ -1082,26 +1194,18 @@ var OpenAIAdapter = class _OpenAIAdapter {
       yield { type: "message:end" };
       yield { type: "done", usage };
     } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: `${this.provider.toUpperCase()}_ERROR`
-      };
+      yield providerErrorEvent(error, `${this.provider.toUpperCase()}_ERROR`);
     }
   }
   async complete(request) {
+    throwIfAborted(request.signal);
     if (this.shouldUseResponsesApi(request)) {
       return this.completeWithResponses(request);
     }
     const client = await this.getClient();
     let messages;
     if (request.rawMessages && request.rawMessages.length > 0) {
-      const sanitized = request.rawMessages.map((msg) => {
-        if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0 && msg.content === "") {
-          return { ...msg, content: null };
-        }
-        return msg;
-      });
+      const sanitized = this.formatRawMessages(request.rawMessages);
       if (request.systemPrompt && !sanitized.some((message2) => message2.role === "system")) {
         messages = [
           { role: "system", content: request.systemPrompt },
@@ -1116,7 +1220,16 @@ var OpenAIAdapter = class _OpenAIAdapter {
         request.systemPrompt
       );
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : [];
+    const tools = request.toolDefinitions?.length ? request.toolDefinitions.filter((tool) => tool.available !== false).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: normalizeObjectJsonSchema(
+          tool.inputSchema
+        )
+      }
+    })) : formatTools(request.actions ?? []);
     const openaiToolOptions = request.providerToolOptions?.openai;
     const toolChoice = openaiToolOptions?.toolChoice && typeof openaiToolOptions.toolChoice === "object" ? {
       type: "function",
@@ -1131,16 +1244,19 @@ var OpenAIAdapter = class _OpenAIAdapter {
       tools: tools.length > 0 ? tools : void 0,
       tool_choice: tools.length > 0 ? toolChoice : void 0,
       parallel_tool_calls: tools.length > 0 ? openaiToolOptions?.parallelToolCalls : void 0,
-      ...buildOpenAITokenParams(
+      ...buildOpenAIParameters(
         modelIdForCompletePayload,
         request.config?.maxTokens ?? this.config.maxTokens,
-        request.config?.temperature ?? this.config.temperature
+        request.config?.temperature ?? this.config.temperature,
+        this.parameterOptions(request)
       ),
       response_format: toOpenAIResponseFormat(request.config?.responseFormat),
       stream: false
     };
     logProviderPayload("openai", "request payload", payload, request.debug);
-    const response = await client.chat.completions.create(payload);
+    const response = await client.chat.completions.create(payload, {
+      signal: request.signal
+    });
     logProviderPayload("openai", "response payload", response, request.debug);
     const choice = response.choices?.[0];
     const message = choice?.message;
@@ -1190,6 +1306,411 @@ function createOpenAIAdapter(config) {
   return new OpenAIAdapter(config);
 }
 
+// src/providers/openai/provider.ts
+var OPENAI_MODELS = {
+  // GPT-4o series
+  "gpt-4o": { vision: true, tools: true, jsonMode: true, maxTokens: 128e3 },
+  "gpt-5.2": {
+    vision: true,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4o-2024-11-20": {
+    vision: true,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4o-2024-08-06": {
+    vision: true,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  // GPT-4 Turbo
+  "gpt-4-turbo": {
+    vision: true,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4-turbo-preview": {
+    vision: false,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  // GPT-4
+  "gpt-4": { vision: false, tools: true, jsonMode: false, maxTokens: 8192 },
+  "gpt-4-32k": {
+    vision: false,
+    tools: true,
+    jsonMode: false,
+    maxTokens: 32768
+  },
+  // GPT-3.5
+  "gpt-3.5-turbo": {
+    vision: false,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 16385
+  },
+  // O1 series (reasoning)
+  o1: { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 },
+  "o1-mini": { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 },
+  "o1-preview": {
+    vision: true,
+    tools: false,
+    jsonMode: false,
+    maxTokens: 128e3
+  },
+  // O3 series
+  "o3-mini": { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 }
+};
+function openai(modelId, options = {}) {
+  const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+  const baseURL = options.baseURL ?? "https://api.openai.com/v1";
+  let client = null;
+  async function getClient() {
+    if (!client) {
+      const { default: OpenAI } = await import('openai');
+      client = new OpenAI({
+        apiKey,
+        baseURL,
+        organization: options.organization,
+        defaultHeaders: options.headers
+      });
+    }
+    return client;
+  }
+  function parameterOptions(params) {
+    return {
+      ...options,
+      reasoningEffort: params.reasoningEffort ?? options.reasoningEffort
+    };
+  }
+  function useResponses(params) {
+    return useOpenAIResponses(
+      modelId,
+      baseURL,
+      parameterOptions(params),
+      resolveOpenAITransport(options, params.openai),
+      !!params.tools?.length,
+      params.messages.some(
+        (message) => message.role === "assistant" && !!message.providerMetadata?.openai?.response
+      )
+    );
+  }
+  const responsesAdapter = new OpenAIAdapter({
+    ...options,
+    apiKey: apiKey ?? "",
+    model: modelId,
+    baseUrl: baseURL
+  });
+  function responsesRequest(params) {
+    return {
+      messages: [],
+      rawMessages: formatMessagesForOpenAI2(params.messages, true),
+      toolDefinitions: params.tools?.map((raw) => {
+        const tool = raw;
+        if (tool.type !== "function")
+          throw new Error(
+            "Only function tools are supported by this OpenAI generation path"
+          );
+        return {
+          name: tool.function.name,
+          description: tool.function.description ?? "",
+          location: "server",
+          inputSchema: tool.function.parameters
+        };
+      }),
+      config: {
+        openai: {
+          ...resolveOpenAITransport(options, params.openai),
+          api: "responses"
+        },
+        temperature: params.temperature,
+        maxTokens: params.maxTokens,
+        responseFormat: params.responseFormat,
+        reasoningEffort: parameterOptions(params).reasoningEffort
+      },
+      signal: params.signal
+    };
+  }
+  const modelConfig = OPENAI_MODELS[modelId] ?? OPENAI_MODELS["gpt-4o"];
+  return {
+    provider: "openai",
+    modelId,
+    capabilities: {
+      supportsVision: modelConfig.vision,
+      supportsTools: modelConfig.tools,
+      supportsStreaming: true,
+      supportsJsonMode: modelConfig.jsonMode,
+      supportsThinking: false,
+      supportsPDF: false,
+      maxTokens: modelConfig.maxTokens,
+      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
+    },
+    async doGenerate(params) {
+      throwIfAborted(params.signal);
+      if (useResponses(params)) {
+        const result = await responsesAdapter.complete(
+          responsesRequest(params)
+        );
+        return {
+          text: result.content,
+          toolCalls: result.toolCalls,
+          finishReason: result.toolCalls.length ? "tool-calls" : result.providerMetadata?.openai?.response?.refusals.length ? "content-filter" : "stop",
+          usage: result.usage ?? {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+          },
+          rawResponse: result.rawResponse,
+          providerMetadata: result.providerMetadata
+        };
+      }
+      const client2 = await getClient();
+      const messages = formatMessagesForOpenAI2(params.messages);
+      const response = await client2.chat.completions.create(
+        {
+          model: modelId,
+          messages,
+          tools: params.tools,
+          ...buildOpenAIParameters(
+            modelId,
+            params.maxTokens,
+            params.temperature,
+            parameterOptions(params)
+          ),
+          response_format: toOpenAIResponseFormat(params.responseFormat)
+        },
+        { signal: params.signal }
+      );
+      const choice = response.choices[0];
+      const message = choice.message;
+      const toolCalls = (message.tool_calls ?? []).map(
+        (tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          args: JSON.parse(tc.function.arguments || "{}")
+        })
+      );
+      return {
+        text: message.content ?? "",
+        toolCalls,
+        finishReason: mapFinishReason(choice.finish_reason),
+        usage: {
+          promptTokens: response.usage?.prompt_tokens ?? 0,
+          completionTokens: response.usage?.completion_tokens ?? 0,
+          totalTokens: response.usage?.total_tokens ?? 0
+        },
+        rawResponse: response
+      };
+    },
+    async *doStream(params) {
+      throwIfAborted(params.signal);
+      if (useResponses(params)) {
+        const calls2 = /* @__PURE__ */ new Map();
+        let hasTools = false;
+        for await (const event of responsesAdapter.stream(
+          responsesRequest(params)
+        )) {
+          switch (event.type) {
+            case "message:delta":
+              yield { type: "text-delta", text: event.content };
+              break;
+            case "action:start":
+              calls2.set(event.id, { name: event.name, args: "" });
+              break;
+            case "action:args": {
+              const call = calls2.get(event.id);
+              if (call) call.args += event.args;
+              break;
+            }
+            case "action:end": {
+              const call = calls2.get(event.id);
+              if (!call)
+                throw new Error("Responses tool call has no matching start");
+              hasTools = true;
+              yield {
+                type: "tool-call",
+                toolCall: {
+                  id: event.id,
+                  name: call.name,
+                  args: JSON.parse(call.args || "{}")
+                }
+              };
+              calls2.delete(event.id);
+              break;
+            }
+            case "error":
+              throw errorFromEvent(event);
+            case "done":
+              yield {
+                type: "finish",
+                finishReason: hasTools ? "tool-calls" : event.providerMetadata?.openai?.response?.refusals.length ? "content-filter" : "stop",
+                providerMetadata: event.providerMetadata,
+                usage: {
+                  promptTokens: event.usage?.prompt_tokens ?? 0,
+                  completionTokens: event.usage?.completion_tokens ?? 0,
+                  totalTokens: event.usage?.total_tokens ?? 0
+                }
+              };
+              break;
+          }
+        }
+        return;
+      }
+      const client2 = await getClient();
+      const messages = formatMessagesForOpenAI2(params.messages);
+      const stream = await client2.chat.completions.create(
+        {
+          model: modelId,
+          messages,
+          tools: params.tools,
+          ...buildOpenAIParameters(
+            modelId,
+            params.maxTokens,
+            params.temperature,
+            parameterOptions(params)
+          ),
+          response_format: toOpenAIResponseFormat(params.responseFormat),
+          stream: true,
+          stream_options: { include_usage: true }
+        },
+        { signal: params.signal }
+      );
+      const toolCalls = /* @__PURE__ */ new Map();
+      let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+      let finishReason;
+      for await (const chunk of stream) {
+        throwIfAborted(params.signal);
+        if (chunk.usage) {
+          usage = {
+            promptTokens: chunk.usage.prompt_tokens ?? 0,
+            completionTokens: chunk.usage.completion_tokens ?? 0,
+            totalTokens: chunk.usage.total_tokens ?? (chunk.usage.prompt_tokens ?? 0) + (chunk.usage.completion_tokens ?? 0)
+          };
+        }
+        const choice = chunk.choices?.[0];
+        if (choice?.delta?.content)
+          yield { type: "text-delta", text: choice.delta.content };
+        for (const part of choice?.delta?.tool_calls ?? []) {
+          const index = part.index ?? 0;
+          const call = toolCalls.get(index) ?? {
+            id: "",
+            name: "",
+            arguments: ""
+          };
+          if (part.id) call.id = part.id;
+          if (part.function?.name) call.name += part.function.name;
+          if (part.function?.arguments)
+            call.arguments += part.function.arguments;
+          toolCalls.set(index, call);
+        }
+        if (choice?.finish_reason)
+          finishReason = mapFinishReason(choice.finish_reason);
+      }
+      throwIfAborted(params.signal);
+      if (!finishReason)
+        throw new Error("OpenAI stream ended without a finish reason");
+      const calls = [...toolCalls.values()].map((call) => {
+        if (!call.id || !call.name)
+          throw new Error("OpenAI stream contains an incomplete tool call");
+        return {
+          id: call.id,
+          name: call.name,
+          args: JSON.parse(call.arguments || "{}")
+        };
+      });
+      if (calls.length && finishReason !== "tool-calls")
+        throw new Error("OpenAI stream ended with incomplete tool calls");
+      for (const toolCall of calls) yield { type: "tool-call", toolCall };
+      yield { type: "finish", finishReason, usage };
+    }
+  };
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "unknown";
+  }
+}
+function formatMessagesForOpenAI2(messages, responses = false) {
+  return messages.map((msg) => {
+    switch (msg.role) {
+      case "system":
+        return { role: "system", content: msg.content };
+      case "user":
+        if (typeof msg.content === "string") {
+          return { role: "user", content: msg.content };
+        }
+        return {
+          role: "user",
+          content: msg.content.map((part) => {
+            if (part.type === "text") {
+              return { type: "text", text: part.text };
+            }
+            if (part.type === "image") {
+              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
+              const url = /^(data:|https?:\/\/)/.test(imageData) ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
+              return { type: "image_url", image_url: { url, detail: "auto" } };
+            }
+            if (part.type === "file") {
+              if (!responses)
+                throw new Error(
+                  "File inputs require the Responses API on this OpenAI path"
+                );
+              return /^https?:\/\//.test(part.data) ? { type: "input_file", file_url: part.data } : {
+                type: "input_file",
+                filename: part.filename ?? "document.pdf",
+                file_data: part.data.startsWith("data:") ? part.data : `data:${part.mimeType};base64,${part.data}`
+              };
+            }
+            throw new Error("Unsupported OpenAI message content");
+          })
+        };
+      case "assistant":
+        const assistantMsg = {
+          role: "assistant",
+          content: msg.content,
+          ...responses && msg.providerMetadata ? { providerMetadata: msg.providerMetadata } : {}
+        };
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }));
+        }
+        return assistantMsg;
+      case "tool":
+        return {
+          role: "tool",
+          tool_call_id: msg.toolCallId,
+          content: responses ? msg.content : textToolOutput(msg.modelOutput, msg.content),
+          ...responses && msg.modelOutput ? { modelOutput: msg.modelOutput } : {}
+        };
+      default:
+        return msg;
+    }
+  });
+}
+
 // src/providers/types.ts
 function createCallableProvider(providerFn, properties) {
   Object.defineProperty(providerFn, "name", {
@@ -1206,6 +1727,394 @@ function createCallableProvider(providerFn, properties) {
   return providerFn;
 }
 
+// src/core/audio.ts
+var audioErrorMarker = /* @__PURE__ */ Symbol.for("@yourgpt/llm-sdk/AudioAPIError");
+var _a;
+var AudioAPIError = class extends Error {
+  constructor(message, code, status, requestId) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this[_a] = true;
+    this.name = "AudioAPIError";
+  }
+  static [(_a = audioErrorMarker, Symbol.hasInstance)](value) {
+    return !!value && typeof value === "object" && value[audioErrorMarker] === true;
+  }
+};
+
+// src/providers/openai/audio.ts
+var formats = {
+  mp3: "audio/mpeg",
+  opus: "audio/ogg",
+  aac: "audio/aac",
+  flac: "audio/flac",
+  wav: "audio/wav",
+  pcm: "audio/pcm"
+};
+var extensions = {
+  "audio/mpeg": "mp3",
+  "audio/mp3": "mp3",
+  "audio/mp4": "m4a",
+  "video/mp4": "mp4",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/webm": "webm",
+  "video/webm": "webm",
+  "audio/ogg": "ogg",
+  "audio/flac": "flac",
+  "audio/x-flac": "flac"
+};
+var MAX_AUDIO = 25e6;
+function hasAudioHeader(data, format) {
+  const head = Buffer.from(data.subarray(0, 12)).toString("latin1");
+  if (format === "wav")
+    return head.startsWith("RIFF") && head.slice(8, 12) === "WAVE";
+  if (format === "mp3" || format === "mpeg" || format === "mpga")
+    return head.startsWith("ID3") || data[0] === 255 && (data[1] & 224) === 224;
+  if (format === "opus" || format === "ogg") return head.startsWith("OggS");
+  if (format === "flac") return head.startsWith("fLaC");
+  if (format === "aac") return data[0] === 255 && (data[1] & 246) === 240;
+  if (format === "webm")
+    return data[0] === 26 && data[1] === 69 && data[2] === 223 && data[3] === 163;
+  if (format === "m4a" || format === "mp4") return head.slice(4, 8) === "ftyp";
+  return format === "pcm" && data.length > 0 && data.length % 2 === 0;
+}
+function invalid(message) {
+  throw new AudioAPIError(message, "invalid_input");
+}
+function unsupported(message) {
+  throw new AudioAPIError(message, "unsupported_option");
+}
+function providerOptions(value, allowed) {
+  for (const [provider, options] of Object.entries(value ?? {})) {
+    if (provider !== "openai")
+      unsupported(
+        `Provider options for ${provider} cannot be used with OpenAI audio`
+      );
+    for (const key of Object.keys(options))
+      if (!allowed.includes(key))
+        unsupported(`Unsupported OpenAI audio option: ${key}`);
+  }
+  return value?.openai ?? {};
+}
+async function readBody(response, limit) {
+  if (Number(response.headers.get("content-length")) > limit) {
+    await response.body?.cancel();
+    throw new AudioAPIError(
+      "Audio API response exceeds the size limit",
+      "invalid_response"
+    );
+  }
+  const reader = response.body?.getReader();
+  if (!reader) return new Uint8Array();
+  const chunks = [];
+  let length = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.length;
+      if (length > limit) {
+        await reader.cancel();
+        throw new AudioAPIError(
+          "Audio API response exceeds the size limit",
+          "invalid_response"
+        );
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const data = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    data.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return data;
+}
+function transport(config) {
+  return async (path, body, signal) => {
+    signal?.throwIfAborted();
+    const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) invalid("OpenAI audio requires an API key on the server");
+    const headers = {
+      Authorization: `Bearer ${apiKey}`
+    };
+    if (typeof body === "string") headers["Content-Type"] = "application/json";
+    if (config.organization)
+      headers["OpenAI-Organization"] = config.organization;
+    if (config.project) headers["OpenAI-Project"] = config.project;
+    let response;
+    try {
+      response = await (config.fetch ?? globalThis.fetch)(
+        `${(config.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "")}${path}`,
+        { method: "POST", headers, body, signal, redirect: "error" }
+      );
+    } catch {
+      signal?.throwIfAborted();
+      throw new AudioAPIError("OpenAI audio request failed", "network_error");
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new AudioAPIError(
+        `OpenAI audio request failed (HTTP ${response.status})`,
+        "provider_error",
+        response.status,
+        response.headers.get("x-request-id") ?? void 0
+      );
+    }
+    return response;
+  };
+}
+function openaiSpeech(modelId = "gpt-4o-mini-tts", config = {}) {
+  const request = transport(config);
+  return {
+    provider: "openai",
+    modelId,
+    async doGenerate(options) {
+      const {
+        text,
+        voice = "alloy",
+        outputFormat = "mp3",
+        speed,
+        instructions,
+        signal
+      } = options;
+      signal?.throwIfAborted();
+      providerOptions(options.providerOptions, []);
+      if (typeof text !== "string" || !text.trim() || text.length > 4096)
+        invalid("Speech text must contain 1\u20134096 characters");
+      if (!Object.prototype.hasOwnProperty.call(formats, outputFormat))
+        unsupported("Unsupported OpenAI speech output format");
+      if (typeof voice !== "string" || !voice.trim())
+        invalid("Speech voice must not be empty");
+      if (speed !== void 0 && (!Number.isFinite(speed) || speed < 0.25 || speed > 4))
+        invalid("Speech speed must be between 0.25 and 4");
+      if (instructions !== void 0) {
+        if (typeof instructions !== "string" || instructions.length > 4096)
+          invalid(
+            "Speech instructions must be a string of at most 4096 characters"
+          );
+        if (modelId === "tts-1" || modelId === "tts-1-hd")
+          unsupported("Instructions are not supported by tts-1 or tts-1-hd");
+      }
+      const response = await request(
+        "/audio/speech",
+        JSON.stringify({
+          model: modelId,
+          input: text,
+          voice,
+          response_format: outputFormat,
+          speed,
+          instructions
+        }),
+        signal
+      );
+      const mediaType = response.headers.get("content-type")?.split(";")[0].trim();
+      if (mediaType && !mediaType.startsWith("audio/") && mediaType !== "application/octet-stream") {
+        await response.body?.cancel();
+        throw new AudioAPIError(
+          "Speech endpoint returned a non-audio response",
+          "invalid_response"
+        );
+      }
+      const data = await readBody(response, MAX_AUDIO);
+      signal?.throwIfAborted();
+      if (!data.length || !hasAudioHeader(data, outputFormat))
+        throw new AudioAPIError(
+          "Speech endpoint returned empty or invalid audio",
+          "invalid_response"
+        );
+      return {
+        audio: {
+          uint8Array: data,
+          get base64() {
+            return Buffer.from(data).toString("base64");
+          },
+          mediaType: formats[outputFormat],
+          format: outputFormat
+        },
+        warnings: [],
+        response: {
+          provider: "openai",
+          modelId,
+          requestId: response.headers.get("x-request-id") ?? void 0,
+          status: response.status
+        }
+      };
+    }
+  };
+}
+async function audioBytes(options) {
+  const blob = typeof Blob !== "undefined" && options.audio instanceof Blob ? options.audio : void 0;
+  if (blob && blob.size > MAX_AUDIO)
+    invalid("Transcription file exceeds 25 MB");
+  const declared = options.mediaType?.split(";")[0].trim();
+  const blobType = blob?.type.split(";")[0].trim();
+  if (declared && blobType && declared !== blobType)
+    invalid("Transcription mediaType does not match the Blob type");
+  const mediaType = declared || blobType || "";
+  const extension = extensions[mediaType];
+  if (!extension)
+    unsupported(
+      "Unsupported transcription media type; provide an encoded audio file"
+    );
+  let bytes;
+  if (blob) bytes = new Uint8Array(await blob.arrayBuffer());
+  else if (options.audio instanceof Uint8Array) bytes = options.audio;
+  else if (options.audio instanceof ArrayBuffer)
+    bytes = new Uint8Array(options.audio);
+  else if (typeof options.audio === "string") {
+    const base64 = options.audio;
+    if (base64.length > MAX_AUDIO * 4 / 3 + 4)
+      invalid("Transcription file exceeds 25 MB");
+    if (!base64 || base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(base64))
+      invalid(
+        "Audio must be bytes, a Blob, or valid base64; URLs are not fetched"
+      );
+    bytes = Buffer.from(base64, "base64");
+    if (Buffer.from(bytes).toString("base64") !== base64)
+      invalid("Invalid audio base64");
+  } else invalid("Audio must be bytes, a Blob, or base64");
+  if (!bytes.length || bytes.length > MAX_AUDIO)
+    invalid("Transcription file must contain 1 byte to 25 MB");
+  if (!hasAudioHeader(bytes, extension))
+    invalid("Audio header does not match the declared media type");
+  return { bytes, mediaType, extension };
+}
+function openaiTranscription(modelId = "gpt-4o-mini-transcribe", config = {}) {
+  const request = transport(config);
+  return {
+    provider: "openai",
+    modelId,
+    async doTranscribe(options) {
+      options.signal?.throwIfAborted();
+      if (modelId.includes("realtime"))
+        unsupported(
+          "Realtime models require a realtime session; use a file transcription model"
+        );
+      const opts = providerOptions(options.providerOptions, [
+        "timestampGranularities",
+        "includeLogprobs",
+        "chunkingStrategy"
+      ]);
+      const timestamps = opts.timestampGranularities;
+      if (timestamps !== void 0 && (!Array.isArray(timestamps) || !timestamps.length || timestamps.some((x) => x !== "word" && x !== "segment")))
+        invalid("timestampGranularities must contain word or segment");
+      if (timestamps !== void 0 && modelId !== "whisper-1")
+        unsupported("Timestamp granularities require whisper-1");
+      if (opts.includeLogprobs !== void 0 && typeof opts.includeLogprobs !== "boolean")
+        invalid("includeLogprobs must be boolean");
+      if (opts.includeLogprobs && !/^gpt-4o-(mini-)?transcribe(?:-\d{4}-\d{2}-\d{2})?$/.test(modelId))
+        unsupported(
+          "Log probabilities require a supported gpt-4o transcription model"
+        );
+      const diarize = modelId === "gpt-4o-transcribe-diarize";
+      if (opts.chunkingStrategy !== void 0 && opts.chunkingStrategy !== "auto")
+        unsupported("Only automatic audio chunking is supported");
+      if (diarize && options.prompt !== void 0)
+        unsupported("Prompts are not supported by the diarization model");
+      if (options.language !== void 0 && !/^[a-z]{2}$/.test(options.language))
+        invalid("language must be a two-letter ISO-639-1 code");
+      if (options.prompt !== void 0 && typeof options.prompt !== "string")
+        invalid("Transcription prompt must be a string");
+      const { bytes, mediaType, extension } = await audioBytes(options);
+      options.signal?.throwIfAborted();
+      const fileName = options.filename ?? `audio.${extension}`;
+      if (!/^[^/\\\r\n\x00]+\.[a-z0-9]+$/i.test(fileName))
+        invalid("Transcription filename must be a filename with an extension");
+      const allowedExt = mediaType === "audio/mpeg" ? ["mp3", "mpeg", "mpga"] : mediaType === "audio/mp4" ? ["m4a", "mp4"] : [extension];
+      if (!allowedExt.includes(fileName.split(".").at(-1).toLowerCase()))
+        invalid("Transcription filename extension does not match mediaType");
+      const form = new FormData();
+      form.append(
+        "file",
+        new Blob([new Uint8Array(bytes)], { type: mediaType }),
+        fileName
+      );
+      form.append("model", modelId);
+      form.append(
+        "response_format",
+        diarize ? "diarized_json" : timestamps ? "verbose_json" : "json"
+      );
+      if (options.language) form.append("language", options.language);
+      if (options.prompt) form.append("prompt", options.prompt);
+      if (timestamps)
+        for (const value2 of timestamps)
+          form.append("timestamp_granularities[]", value2);
+      if (opts.includeLogprobs) form.append("include[]", "logprobs");
+      if (diarize || opts.chunkingStrategy)
+        form.append("chunking_strategy", "auto");
+      const response = await request(
+        "/audio/transcriptions",
+        form,
+        options.signal
+      );
+      let value;
+      try {
+        value = JSON.parse(
+          Buffer.from(await readBody(response, 5 * 1024 * 1024)).toString(
+            "utf8"
+          )
+        );
+      } catch (error) {
+        options.signal?.throwIfAborted();
+        if (error instanceof AudioAPIError) throw error;
+        throw new AudioAPIError(
+          "Transcription endpoint returned invalid JSON",
+          "invalid_response"
+        );
+      }
+      options.signal?.throwIfAborted();
+      if (!value || typeof value.text !== "string")
+        throw new AudioAPIError(
+          "Transcription response is missing text",
+          "invalid_response"
+        );
+      function timed(items, word = false) {
+        if (items === void 0) return void 0;
+        if (!Array.isArray(items) || items.some(
+          (x) => !x || typeof x[word ? "word" : "text"] !== "string" || !Number.isFinite(x.start) || !Number.isFinite(x.end) || x.start < 0 || x.end < x.start
+        ))
+          throw new AudioAPIError(
+            "Invalid transcription timestamps",
+            "invalid_response"
+          );
+        return items.map(
+          (x) => word ? { word: x.word, start: x.start, end: x.end } : {
+            text: x.text,
+            start: x.start,
+            end: x.end,
+            ...typeof x.speaker === "string" ? { speaker: x.speaker } : {}
+          }
+        );
+      }
+      return {
+        text: value.text,
+        language: typeof value.language === "string" ? value.language : void 0,
+        durationSeconds: typeof value.duration === "number" ? value.duration : void 0,
+        segments: timed(value.segments),
+        words: timed(value.words, true),
+        usage: value.usage,
+        providerMetadata: {
+          openai: { ...value.logprobs ? { logprobs: value.logprobs } : {} }
+        },
+        warnings: [],
+        response: {
+          provider: "openai",
+          modelId,
+          status: response.status,
+          requestId: response.headers.get("x-request-id") ?? void 0
+        }
+      };
+    }
+  };
+}
+
 // src/providers/openai/index.ts
 var OPENAI_MODELS2 = {
   // GPT-4o series
@@ -1320,7 +2229,12 @@ function createOpenAI(config = {}) {
     return createOpenAIAdapter({
       apiKey,
       model: modelId,
-      baseUrl: config.baseUrl
+      baseUrl: config.baseUrl,
+      reasoningEffort: config.reasoningEffort,
+      api: config.api,
+      responses: config.responses,
+      parameterPolicy: config.parameterPolicy,
+      onWarning: config.onWarning
     });
   };
   const getCapabilities = (modelId) => {
@@ -1352,5 +2266,7 @@ exports.createOpenAI = createOpenAI;
 exports.createOpenAIModel = openai;
 exports.createOpenAIProvider = createOpenAIProvider;
 exports.openai = openai;
+exports.openaiSpeech = openaiSpeech;
+exports.openaiTranscription = openaiTranscription;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map