@ai-sdk/openai 2.0.0-canary.1 → 2.0.0-canary.3

package/dist/index.mjs

@@ -23,7 +23,6 @@ import { z as z2 } from "zod";
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
-import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
 function convertToOpenAIChatMessages({
   prompt,
   useLegacyFunctionCalling = false,
@@ -67,55 +66,65 @@ function convertToOpenAIChatMessages({
         messages.push({
           role: "user",
           content: content.map((part, index) => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             switch (part.type) {
               case "text": {
                 return { type: "text", text: part.text };
               }
-              case "image": {
-                return {
-                  type: "image_url",
-                  image_url: {
-                    url: part.image instanceof URL ? part.image.toString() : `data:${(_a = part.mimeType) != null ? _a : "image/jpeg"};base64,${convertUint8ArrayToBase64(part.image)}`,
-                    // OpenAI specific extension: image detail
-                    detail: (_c = (_b = part.providerMetadata) == null ? void 0 : _b.openai) == null ? void 0 : _c.imageDetail
-                  }
-                };
-              }
               case "file": {
-                if (part.data instanceof URL) {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: "'File content parts with URL data' functionality not supported."
-                  });
-                }
-                switch (part.mimeType) {
-                  case "audio/wav": {
-                    return {
-                      type: "input_audio",
-                      input_audio: { data: part.data, format: "wav" }
-                    };
-                  }
-                  case "audio/mp3":
-                  case "audio/mpeg": {
-                    return {
-                      type: "input_audio",
-                      input_audio: { data: part.data, format: "mp3" }
-                    };
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${part.data}`,
+                      // OpenAI specific extension: image detail
+                      detail: (_b = (_a = part.providerOptions) == null ? void 0 : _a.openai) == null ? void 0 : _b.imageDetail
+                    }
+                  };
+                } else if (part.mediaType.startsWith("audio/")) {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "audio file parts with URLs"
+                    });
                   }
-                  case "application/pdf": {
-                    return {
-                      type: "file",
-                      file: {
-                        filename: (_d = part.filename) != null ? _d : `part-${index}.pdf`,
-                        file_data: `data:application/pdf;base64,${part.data}`
-                      }
-                    };
+                  switch (part.mediaType) {
+                    case "audio/wav": {
+                      return {
+                        type: "input_audio",
+                        input_audio: { data: part.data, format: "wav" }
+                      };
+                    }
+                    case "audio/mp3":
+                    case "audio/mpeg": {
+                      return {
+                        type: "input_audio",
+                        input_audio: { data: part.data, format: "mp3" }
+                      };
+                    }
+                    default: {
+                      throw new UnsupportedFunctionalityError({
+                        functionality: `audio content parts with media type ${part.mediaType}`
+                      });
+                    }
                   }
-                  default: {
+                } else if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
                     throw new UnsupportedFunctionalityError({
-                      functionality: `File content part type ${part.mimeType} in user messages`
+                      functionality: "PDF file parts with URLs"
                     });
                   }
+                  return {
+                    type: "file",
+                    file: {
+                      filename: (_c = part.filename) != null ? _c : `part-${index}.pdf`,
+                      file_data: `data:application/pdf;base64,${part.data}`
+                    }
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
                 }
               }
             }
@@ -259,17 +268,16 @@ import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 function prepareTools({
-  mode,
+  tools,
+  toolChoice,
   useLegacyFunctionCalling = false,
   structuredOutputs
 }) {
-  var _a;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   if (tools == null) {
-    return { tools: void 0, tool_choice: void 0, toolWarnings };
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
-  const toolChoice = mode.toolChoice;
   if (useLegacyFunctionCalling) {
     const openaiFunctions = [];
     for (const tool of tools) {
@@ -329,18 +337,18 @@ function prepareTools({
     }
   }
   if (toolChoice == null) {
-    return { tools: openaiTools2, tool_choice: void 0, toolWarnings };
+    return { tools: openaiTools2, toolChoice: void 0, toolWarnings };
   }
   const type = toolChoice.type;
   switch (type) {
     case "auto":
     case "none":
     case "required":
-      return { tools: openaiTools2, tool_choice: type, toolWarnings };
+      return { tools: openaiTools2, toolChoice: type, toolWarnings };
     case "tool":
       return {
         tools: openaiTools2,
-        tool_choice: {
+        toolChoice: {
           type: "function",
           function: {
             name: toolChoice.toolName
@@ -351,7 +359,7 @@ function prepareTools({
     default: {
       const _exhaustiveCheck = type;
       throw new UnsupportedFunctionalityError2({
-        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+        functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
   }
@@ -382,7 +390,6 @@ var OpenAIChatLanguageModel = class {
     return !this.settings.downloadImages;
   }
   getArgs({
-    mode,
     prompt,
     maxTokens,
     temperature,
@@ -393,10 +400,11 @@ var OpenAIChatLanguageModel = class {
     stopSequences,
     responseFormat,
     seed,
-    providerMetadata
+    tools,
+    toolChoice,
+    providerOptions
   }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const type = mode.type;
+    var _a, _b, _c, _d, _e, _f, _g;
     const warnings = [];
     if (topK != null) {
       warnings.push({
@@ -445,6 +453,7 @@ var OpenAIChatLanguageModel = class {
       top_p: topP,
       frequency_penalty: frequencyPenalty,
       presence_penalty: presencePenalty,
+      // TODO improve below:
       response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs && responseFormat.schema != null ? {
         type: "json_schema",
         json_schema: {
@@ -458,11 +467,11 @@ var OpenAIChatLanguageModel = class {
       seed,
       // openai specific settings:
       // TODO remove in next major version; we auto-map maxTokens now
-      max_completion_tokens: (_b = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _b.maxCompletionTokens,
-      store: (_c = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _c.store,
-      metadata: (_d = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _d.metadata,
-      prediction: (_e = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _e.prediction,
-      reasoning_effort: (_g = (_f = providerMetadata == null ? void 0 : providerMetadata.openai) == null ? void 0 : _f.reasoningEffort) != null ? _g : this.settings.reasoningEffort,
+      max_completion_tokens: (_b = providerOptions == null ? void 0 : providerOptions.openai) == null ? void 0 : _b.maxCompletionTokens,
+      store: (_c = providerOptions == null ? void 0 : providerOptions.openai) == null ? void 0 : _c.store,
+      metadata: (_d = providerOptions == null ? void 0 : providerOptions.openai) == null ? void 0 : _d.metadata,
+      prediction: (_e = providerOptions == null ? void 0 : providerOptions.openai) == null ? void 0 : _e.prediction,
+      reasoning_effort: (_g = (_f = providerOptions == null ? void 0 : providerOptions.openai) == null ? void 0 : _f.reasoningEffort) != null ? _g : this.settings.reasoningEffort,
       // messages:
       messages
     };
@@ -527,81 +536,28 @@ var OpenAIChatLanguageModel = class {
         baseArgs.max_tokens = void 0;
       }
     }
-    switch (type) {
-      case "regular": {
-        const { tools, tool_choice, functions, function_call, toolWarnings } = prepareTools({
-          mode,
-          useLegacyFunctionCalling,
-          structuredOutputs: this.supportsStructuredOutputs
-        });
-        return {
-          args: {
-            ...baseArgs,
-            tools,
-            tool_choice,
-            functions,
-            function_call
-          },
-          warnings: [...warnings, ...toolWarnings]
-        };
-      }
-      case "object-json": {
-        return {
-          args: {
-            ...baseArgs,
-            response_format: this.supportsStructuredOutputs && mode.schema != null ? {
-              type: "json_schema",
-              json_schema: {
-                schema: mode.schema,
-                strict: true,
-                name: (_h = mode.name) != null ? _h : "response",
-                description: mode.description
-              }
-            } : { type: "json_object" }
-          },
-          warnings
-        };
-      }
-      case "object-tool": {
-        return {
-          args: useLegacyFunctionCalling ? {
-            ...baseArgs,
-            function_call: {
-              name: mode.tool.name
-            },
-            functions: [
-              {
-                name: mode.tool.name,
-                description: mode.tool.description,
-                parameters: mode.tool.parameters
-              }
-            ]
-          } : {
-            ...baseArgs,
-            tool_choice: {
-              type: "function",
-              function: { name: mode.tool.name }
-            },
-            tools: [
-              {
-                type: "function",
-                function: {
-                  name: mode.tool.name,
-                  description: mode.tool.description,
-                  parameters: mode.tool.parameters,
-                  strict: this.supportsStructuredOutputs ? true : void 0
-                }
-              }
-            ]
-          },
-          warnings
-        };
-      }
-      default: {
-        const _exhaustiveCheck = type;
-        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
-      }
-    }
+    const {
+      tools: openaiTools2,
+      toolChoice: openaiToolChoice,
+      functions,
+      function_call,
+      toolWarnings
+    } = prepareTools({
+      tools,
+      toolChoice,
+      useLegacyFunctionCalling,
+      structuredOutputs: this.supportsStructuredOutputs
+    });
+    return {
+      args: {
+        ...baseArgs,
+        tools: openaiTools2,
+        tool_choice: openaiToolChoice,
+        functions,
+        function_call
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
   }
   async doGenerate(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -1068,9 +1024,6 @@ var reasoningModels = {
 };
 
 // src/openai-completion-language-model.ts
-import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
-} from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders2,
   createEventSourceResponseHandler as createEventSourceResponseHandler2,
@@ -1114,13 +1067,8 @@ function convertToOpenAICompletionPrompt({
             case "text": {
               return part.text;
             }
-            case "image": {
-              throw new UnsupportedFunctionalityError4({
-                functionality: "images"
-              });
-            }
           }
-        }).join("");
+        }).filter(Boolean).join("");
         text += `${user}:
 ${userMessage}
 
@@ -1193,7 +1141,6 @@ var OpenAICompletionLanguageModel = class {
     return this.config.provider;
   }
   getArgs({
-    mode,
     inputFormat,
     prompt,
     maxTokens,
@@ -1204,16 +1151,19 @@ var OpenAICompletionLanguageModel = class {
     presencePenalty,
     stopSequences: userStopSequences,
     responseFormat,
+    tools,
+    toolChoice,
     seed
   }) {
-    var _a;
-    const type = mode.type;
     const warnings = [];
     if (topK != null) {
-      warnings.push({
-        type: "unsupported-setting",
-        setting: "topK"
-      });
+      warnings.push({ type: "unsupported-setting", setting: "topK" });
+    }
+    if (tools == null ? void 0 : tools.length) {
+      warnings.push({ type: "unsupported-setting", setting: "tools" });
+    }
+    if (toolChoice != null) {
+      warnings.push({ type: "unsupported-setting", setting: "toolChoice" });
     }
     if (responseFormat != null && responseFormat.type !== "text") {
       warnings.push({
@@ -1224,56 +1174,30 @@ var OpenAICompletionLanguageModel = class {
     }
     const { prompt: completionPrompt, stopSequences } = convertToOpenAICompletionPrompt({ prompt, inputFormat });
     const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
-    const baseArgs = {
-      // model id:
-      model: this.modelId,
-      // model specific settings:
-      echo: this.settings.echo,
-      logit_bias: this.settings.logitBias,
-      logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : void 0 : void 0,
-      suffix: this.settings.suffix,
-      user: this.settings.user,
-      // standardized settings:
-      max_tokens: maxTokens,
-      temperature,
-      top_p: topP,
-      frequency_penalty: frequencyPenalty,
-      presence_penalty: presencePenalty,
-      seed,
-      // prompt:
-      prompt: completionPrompt,
-      // stop sequences:
-      stop: stop.length > 0 ? stop : void 0
+    return {
+      args: {
+        // model id:
+        model: this.modelId,
+        // model specific settings:
+        echo: this.settings.echo,
+        logit_bias: this.settings.logitBias,
+        logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : void 0 : void 0,
+        suffix: this.settings.suffix,
+        user: this.settings.user,
+        // standardized settings:
+        max_tokens: maxTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        seed,
+        // prompt:
+        prompt: completionPrompt,
+        // stop sequences:
+        stop: stop.length > 0 ? stop : void 0
+      },
+      warnings
     };
-    switch (type) {
-      case "regular": {
-        if ((_a = mode.tools) == null ? void 0 : _a.length) {
-          throw new UnsupportedFunctionalityError5({
-            functionality: "tools"
-          });
-        }
-        if (mode.toolChoice) {
-          throw new UnsupportedFunctionalityError5({
-            functionality: "toolChoice"
-          });
-        }
-        return { args: baseArgs, warnings };
-      }
-      case "object-json": {
-        throw new UnsupportedFunctionalityError5({
-          functionality: "object-json mode"
-        });
-      }
-      case "object-tool": {
-        throw new UnsupportedFunctionalityError5({
-          functionality: "object-tool mode"
-        });
-      }
-      default: {
-        const _exhaustiveCheck = type;
-        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
-      }
-    }
   }
   async doGenerate(options) {
     const { args, warnings } = this.getArgs(options);
@@ -1632,22 +1556,201 @@ var openaiTools = {
   webSearchPreview: webSearchPreviewTool
 };
 
-// src/responses/openai-responses-language-model.ts
+// src/openai-transcription-model.ts
 import {
   combineHeaders as combineHeaders5,
-  createEventSourceResponseHandler as createEventSourceResponseHandler3,
+  convertBase64ToUint8Array,
   createJsonResponseHandler as createJsonResponseHandler5,
-  generateId as generateId2,
   parseProviderOptions,
-  postJsonToApi as postJsonToApi5
+  postFormDataToApi
 } from "@ai-sdk/provider-utils";
 import { z as z7 } from "zod";
+var OpenAIProviderOptionsSchema = z7.object({
+  include: z7.array(z7.string()).optional().describe(
+    "Additional information to include in the transcription response."
+  ),
+  language: z7.string().optional().describe("The language of the input audio in ISO-639-1 format."),
+  prompt: z7.string().optional().describe(
+    "An optional text to guide the model's style or continue a previous audio segment."
+  ),
+  temperature: z7.number().min(0).max(1).optional().default(0).describe("The sampling temperature, between 0 and 1."),
+  timestampGranularities: z7.array(z7.enum(["word", "segment"])).optional().default(["segment"]).describe(
+    "The timestamp granularities to populate for this transcription."
+  )
+});
+var languageMap = {
+  afrikaans: "af",
+  arabic: "ar",
+  armenian: "hy",
+  azerbaijani: "az",
+  belarusian: "be",
+  bosnian: "bs",
+  bulgarian: "bg",
+  catalan: "ca",
+  chinese: "zh",
+  croatian: "hr",
+  czech: "cs",
+  danish: "da",
+  dutch: "nl",
+  english: "en",
+  estonian: "et",
+  finnish: "fi",
+  french: "fr",
+  galician: "gl",
+  german: "de",
+  greek: "el",
+  hebrew: "he",
+  hindi: "hi",
+  hungarian: "hu",
+  icelandic: "is",
+  indonesian: "id",
+  italian: "it",
+  japanese: "ja",
+  kannada: "kn",
+  kazakh: "kk",
+  korean: "ko",
+  latvian: "lv",
+  lithuanian: "lt",
+  macedonian: "mk",
+  malay: "ms",
+  marathi: "mr",
+  maori: "mi",
+  nepali: "ne",
+  norwegian: "no",
+  persian: "fa",
+  polish: "pl",
+  portuguese: "pt",
+  romanian: "ro",
+  russian: "ru",
+  serbian: "sr",
+  slovak: "sk",
+  slovenian: "sl",
+  spanish: "es",
+  swahili: "sw",
+  swedish: "sv",
+  tagalog: "tl",
+  tamil: "ta",
+  thai: "th",
+  turkish: "tr",
+  ukrainian: "uk",
+  urdu: "ur",
+  vietnamese: "vi",
+  welsh: "cy"
+};
+var OpenAITranscriptionModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v1";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  getArgs({
+    audio,
+    mediaType,
+    providerOptions
+  }) {
+    const warnings = [];
+    const openAIOptions = parseProviderOptions({
+      provider: "openai",
+      providerOptions,
+      schema: OpenAIProviderOptionsSchema
+    });
+    const formData = new FormData();
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
+    formData.append("model", this.modelId);
+    formData.append("file", new File([blob], "audio", { type: mediaType }));
+    if (openAIOptions) {
+      const transcriptionModelOptions = {
+        include: openAIOptions.include,
+        language: openAIOptions.language,
+        prompt: openAIOptions.prompt,
+        temperature: openAIOptions.temperature,
+        timestamp_granularities: openAIOptions.timestampGranularities
+      };
+      for (const key in transcriptionModelOptions) {
+        const value = transcriptionModelOptions[key];
+        if (value !== void 0) {
+          formData.append(key, value);
+        }
+      }
+    }
+    return {
+      formData,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const { formData, warnings } = this.getArgs(options);
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postFormDataToApi({
+      url: this.config.url({
+        path: "/audio/transcriptions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders5(this.config.headers(), options.headers),
+      formData,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler5(
+        openaiTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const language = response.language != null && response.language in languageMap ? languageMap[response.language] : void 0;
+    return {
+      text: response.text,
+      segments: (_e = (_d = response.words) == null ? void 0 : _d.map((word) => ({
+        text: word.word,
+        startSecond: word.start,
+        endSecond: word.end
+      }))) != null ? _e : [],
+      language,
+      durationInSeconds: (_f = response.duration) != null ? _f : void 0,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+var openaiTranscriptionResponseSchema = z7.object({
+  text: z7.string(),
+  language: z7.string().nullish(),
+  duration: z7.number().nullish(),
+  words: z7.array(
+    z7.object({
+      word: z7.string(),
+      start: z7.number(),
+      end: z7.number()
+    })
+  ).nullish()
+});
+
+// src/responses/openai-responses-language-model.ts
+import {
+  combineHeaders as combineHeaders6,
+  createEventSourceResponseHandler as createEventSourceResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler6,
+  generateId as generateId2,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi5
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod";
 
 // src/responses/convert-to-openai-responses-messages.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError6
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
 } from "@ai-sdk/provider";
-import { convertUint8ArrayToBase64 as convertUint8ArrayToBase642 } from "@ai-sdk/provider-utils";
 function convertToOpenAIResponsesMessages({
   prompt,
   systemMessageMode
@@ -1686,38 +1789,35 @@ function convertToOpenAIResponsesMessages({
         messages.push({
           role: "user",
           content: content.map((part, index) => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             switch (part.type) {
               case "text": {
                 return { type: "input_text", text: part.text };
               }
-              case "image": {
-                return {
-                  type: "input_image",
-                  image_url: part.image instanceof URL ? part.image.toString() : `data:${(_a = part.mimeType) != null ? _a : "image/jpeg"};base64,${convertUint8ArrayToBase642(part.image)}`,
-                  // OpenAI specific extension: image detail
-                  detail: (_c = (_b = part.providerMetadata) == null ? void 0 : _b.openai) == null ? void 0 : _c.imageDetail
-                };
-              }
               case "file": {
-                if (part.data instanceof URL) {
-                  throw new UnsupportedFunctionalityError6({
-                    functionality: "File URLs in user messages"
-                  });
-                }
-                switch (part.mimeType) {
-                  case "application/pdf": {
-                    return {
-                      type: "input_file",
-                      filename: (_d = part.filename) != null ? _d : `part-${index}.pdf`,
-                      file_data: `data:application/pdf;base64,${part.data}`
-                    };
-                  }
-                  default: {
-                    throw new UnsupportedFunctionalityError6({
-                      functionality: "Only PDF files are supported in user messages"
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "input_image",
+                    image_url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${part.data}`,
+                    // OpenAI specific extension: image detail
+                    detail: (_b = (_a = part.providerOptions) == null ? void 0 : _a.openai) == null ? void 0 : _b.imageDetail
+                  };
+                } else if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError5({
+                      functionality: "PDF file parts with URLs"
                     });
                   }
+                  return {
+                    type: "input_file",
+                    filename: (_c = part.filename) != null ? _c : `part-${index}.pdf`,
+                    file_data: `data:application/pdf;base64,${part.data}`
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError5({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
                 }
               }
             }
@@ -1787,19 +1887,18 @@ function mapOpenAIResponseFinishReason({
 
 // src/responses/openai-responses-prepare-tools.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError7
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError6
 } from "@ai-sdk/provider";
 function prepareResponsesTools({
-  mode,
+  tools,
+  toolChoice,
   strict
 }) {
-  var _a;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   if (tools == null) {
-    return { tools: void 0, tool_choice: void 0, toolWarnings };
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
-  const toolChoice = mode.toolChoice;
   const openaiTools2 = [];
   for (const tool of tools) {
     switch (tool.type) {
@@ -1832,37 +1931,24 @@ function prepareResponsesTools({
     }
   }
   if (toolChoice == null) {
-    return { tools: openaiTools2, tool_choice: void 0, toolWarnings };
+    return { tools: openaiTools2, toolChoice: void 0, toolWarnings };
   }
   const type = toolChoice.type;
   switch (type) {
     case "auto":
     case "none":
     case "required":
-      return { tools: openaiTools2, tool_choice: type, toolWarnings };
-    case "tool": {
-      if (toolChoice.toolName === "web_search_preview") {
-        return {
-          tools: openaiTools2,
-          tool_choice: {
-            type: "web_search_preview"
-          },
-          toolWarnings
-        };
-      }
+      return { tools: openaiTools2, toolChoice: type, toolWarnings };
+    case "tool":
       return {
         tools: openaiTools2,
-        tool_choice: {
-          type: "function",
-          name: toolChoice.toolName
-        },
+        toolChoice: toolChoice.toolName === "web_search_preview" ? { type: "web_search_preview" } : { type: "function", name: toolChoice.toolName },
         toolWarnings
       };
-    }
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError7({
-        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+      throw new UnsupportedFunctionalityError6({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
   }
@@ -1880,7 +1966,6 @@ var OpenAIResponsesLanguageModel = class {
     return this.config.provider;
   }
   getArgs({
-    mode,
     maxTokens,
     temperature,
     stopSequences,
@@ -1890,24 +1975,19 @@ var OpenAIResponsesLanguageModel = class {
     frequencyPenalty,
     seed,
     prompt,
-    providerMetadata,
+    providerOptions,
+    tools,
+    toolChoice,
     responseFormat
   }) {
-    var _a, _b, _c;
+    var _a, _b;
     const warnings = [];
     const modelConfig = getResponsesModelConfig(this.modelId);
-    const type = mode.type;
     if (topK != null) {
-      warnings.push({
-        type: "unsupported-setting",
-        setting: "topK"
-      });
+      warnings.push({ type: "unsupported-setting", setting: "topK" });
     }
     if (seed != null) {
-      warnings.push({
-        type: "unsupported-setting",
-        setting: "seed"
-      });
+      warnings.push({ type: "unsupported-setting", setting: "seed" });
     }
     if (presencePenalty != null) {
       warnings.push({
@@ -1922,19 +2002,16 @@ var OpenAIResponsesLanguageModel = class {
       });
     }
     if (stopSequences != null) {
-      warnings.push({
-        type: "unsupported-setting",
-        setting: "stopSequences"
-      });
+      warnings.push({ type: "unsupported-setting", setting: "stopSequences" });
     }
     const { messages, warnings: messageWarnings } = convertToOpenAIResponsesMessages({
       prompt,
       systemMessageMode: modelConfig.systemMessageMode
     });
     warnings.push(...messageWarnings);
-    const openaiOptions = parseProviderOptions({
+    const openaiOptions = parseProviderOptions2({
       provider: "openai",
-      providerOptions: providerMetadata,
+      providerOptions,
       schema: openaiResponsesProviderOptionsSchema
     });
     const isStrict = (_a = openaiOptions == null ? void 0 : openaiOptions.strictSchemas) != null ? _a : true;
@@ -1988,62 +2065,23 @@ var OpenAIResponsesLanguageModel = class {
         });
       }
     }
-    switch (type) {
-      case "regular": {
-        const { tools, tool_choice, toolWarnings } = prepareResponsesTools({
-          mode,
-          strict: isStrict
-          // TODO support provider options on tools
-        });
-        return {
-          args: {
-            ...baseArgs,
-            tools,
-            tool_choice
-          },
-          warnings: [...warnings, ...toolWarnings]
-        };
-      }
-      case "object-json": {
-        return {
-          args: {
-            ...baseArgs,
-            text: {
-              format: mode.schema != null ? {
-                type: "json_schema",
-                strict: isStrict,
-                name: (_c = mode.name) != null ? _c : "response",
-                description: mode.description,
-                schema: mode.schema
-              } : { type: "json_object" }
-            }
-          },
-          warnings
-        };
-      }
-      case "object-tool": {
-        return {
-          args: {
-            ...baseArgs,
-            tool_choice: { type: "function", name: mode.tool.name },
-            tools: [
-              {
-                type: "function",
-                name: mode.tool.name,
-                description: mode.tool.description,
-                parameters: mode.tool.parameters,
-                strict: isStrict
-              }
-            ]
-          },
-          warnings
-        };
-      }
-      default: {
-        const _exhaustiveCheck = type;
-        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
-      }
-    }
+    const {
+      tools: openaiTools2,
+      toolChoice: openaiToolChoice,
+      toolWarnings
+    } = prepareResponsesTools({
+      tools,
+      toolChoice,
+      strict: isStrict
+    });
+    return {
+      args: {
+        ...baseArgs,
+        tools: openaiTools2,
+        tool_choice: openaiToolChoice
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
   }
   async doGenerate(options) {
     var _a, _b, _c, _d, _e;
@@ -2057,53 +2095,53 @@ var OpenAIResponsesLanguageModel = class {
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: combineHeaders5(this.config.headers(), options.headers),
+      headers: combineHeaders6(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler5(
-        z7.object({
-          id: z7.string(),
-          created_at: z7.number(),
-          model: z7.string(),
-          output: z7.array(
-            z7.discriminatedUnion("type", [
-              z7.object({
-                type: z7.literal("message"),
-                role: z7.literal("assistant"),
-                content: z7.array(
-                  z7.object({
-                    type: z7.literal("output_text"),
-                    text: z7.string(),
-                    annotations: z7.array(
-                      z7.object({
-                        type: z7.literal("url_citation"),
-                        start_index: z7.number(),
-                        end_index: z7.number(),
-                        url: z7.string(),
-                        title: z7.string()
+      successfulResponseHandler: createJsonResponseHandler6(
+        z8.object({
+          id: z8.string(),
+          created_at: z8.number(),
+          model: z8.string(),
+          output: z8.array(
+            z8.discriminatedUnion("type", [
+              z8.object({
+                type: z8.literal("message"),
+                role: z8.literal("assistant"),
+                content: z8.array(
+                  z8.object({
+                    type: z8.literal("output_text"),
+                    text: z8.string(),
+                    annotations: z8.array(
+                      z8.object({
+                        type: z8.literal("url_citation"),
+                        start_index: z8.number(),
+                        end_index: z8.number(),
+                        url: z8.string(),
+                        title: z8.string()
                       })
                     )
                   })
                 )
               }),
-              z7.object({
-                type: z7.literal("function_call"),
-                call_id: z7.string(),
-                name: z7.string(),
-                arguments: z7.string()
+              z8.object({
+                type: z8.literal("function_call"),
+                call_id: z8.string(),
+                name: z8.string(),
+                arguments: z8.string()
               }),
-              z7.object({
-                type: z7.literal("web_search_call")
+              z8.object({
+                type: z8.literal("web_search_call")
               }),
-              z7.object({
-                type: z7.literal("computer_call")
+              z8.object({
+                type: z8.literal("computer_call")
               }),
-              z7.object({
-                type: z7.literal("reasoning")
+              z8.object({
+                type: z8.literal("reasoning")
               })
             ])
           ),
-          incomplete_details: z7.object({ reason: z7.string() }).nullable(),
+          incomplete_details: z8.object({ reason: z8.string() }).nullable(),
           usage: usageSchema
         })
       ),
@@ -2172,7 +2210,7 @@ var OpenAIResponsesLanguageModel = class {
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: combineHeaders5(this.config.headers(), options.headers),
+      headers: combineHeaders6(this.config.headers(), options.headers),
       body: {
         ...body,
         stream: true
@@ -2301,79 +2339,79 @@ var OpenAIResponsesLanguageModel = class {
     };
   }
 };
-var usageSchema = z7.object({
-  input_tokens: z7.number(),
-  input_tokens_details: z7.object({ cached_tokens: z7.number().nullish() }).nullish(),
-  output_tokens: z7.number(),
-  output_tokens_details: z7.object({ reasoning_tokens: z7.number().nullish() }).nullish()
+var usageSchema = z8.object({
+  input_tokens: z8.number(),
+  input_tokens_details: z8.object({ cached_tokens: z8.number().nullish() }).nullish(),
+  output_tokens: z8.number(),
+  output_tokens_details: z8.object({ reasoning_tokens: z8.number().nullish() }).nullish()
 });
-var textDeltaChunkSchema = z7.object({
-  type: z7.literal("response.output_text.delta"),
-  delta: z7.string()
+var textDeltaChunkSchema = z8.object({
+  type: z8.literal("response.output_text.delta"),
+  delta: z8.string()
 });
-var responseFinishedChunkSchema = z7.object({
-  type: z7.enum(["response.completed", "response.incomplete"]),
-  response: z7.object({
-    incomplete_details: z7.object({ reason: z7.string() }).nullish(),
+var responseFinishedChunkSchema = z8.object({
+  type: z8.enum(["response.completed", "response.incomplete"]),
+  response: z8.object({
+    incomplete_details: z8.object({ reason: z8.string() }).nullish(),
     usage: usageSchema
   })
 });
-var responseCreatedChunkSchema = z7.object({
-  type: z7.literal("response.created"),
-  response: z7.object({
-    id: z7.string(),
-    created_at: z7.number(),
-    model: z7.string()
+var responseCreatedChunkSchema = z8.object({
+  type: z8.literal("response.created"),
+  response: z8.object({
+    id: z8.string(),
+    created_at: z8.number(),
+    model: z8.string()
   })
 });
-var responseOutputItemDoneSchema = z7.object({
-  type: z7.literal("response.output_item.done"),
-  output_index: z7.number(),
-  item: z7.discriminatedUnion("type", [
-    z7.object({
-      type: z7.literal("message")
+var responseOutputItemDoneSchema = z8.object({
+  type: z8.literal("response.output_item.done"),
+  output_index: z8.number(),
+  item: z8.discriminatedUnion("type", [
+    z8.object({
+      type: z8.literal("message")
     }),
-    z7.object({
-      type: z7.literal("function_call"),
-      id: z7.string(),
-      call_id: z7.string(),
-      name: z7.string(),
-      arguments: z7.string(),
-      status: z7.literal("completed")
+    z8.object({
+      type: z8.literal("function_call"),
+      id: z8.string(),
+      call_id: z8.string(),
+      name: z8.string(),
+      arguments: z8.string(),
+      status: z8.literal("completed")
     })
   ])
 });
-var responseFunctionCallArgumentsDeltaSchema = z7.object({
-  type: z7.literal("response.function_call_arguments.delta"),
-  item_id: z7.string(),
-  output_index: z7.number(),
-  delta: z7.string()
+var responseFunctionCallArgumentsDeltaSchema = z8.object({
+  type: z8.literal("response.function_call_arguments.delta"),
+  item_id: z8.string(),
+  output_index: z8.number(),
+  delta: z8.string()
 });
-var responseOutputItemAddedSchema = z7.object({
-  type: z7.literal("response.output_item.added"),
-  output_index: z7.number(),
-  item: z7.discriminatedUnion("type", [
-    z7.object({
-      type: z7.literal("message")
+var responseOutputItemAddedSchema = z8.object({
+  type: z8.literal("response.output_item.added"),
+  output_index: z8.number(),
+  item: z8.discriminatedUnion("type", [
+    z8.object({
+      type: z8.literal("message")
     }),
-    z7.object({
-      type: z7.literal("function_call"),
-      id: z7.string(),
-      call_id: z7.string(),
-      name: z7.string(),
-      arguments: z7.string()
+    z8.object({
+      type: z8.literal("function_call"),
+      id: z8.string(),
+      call_id: z8.string(),
+      name: z8.string(),
+      arguments: z8.string()
     })
   ])
 });
-var responseAnnotationAddedSchema = z7.object({
-  type: z7.literal("response.output_text.annotation.added"),
-  annotation: z7.object({
-    type: z7.literal("url_citation"),
-    url: z7.string(),
-    title: z7.string()
+var responseAnnotationAddedSchema = z8.object({
+  type: z8.literal("response.output_text.annotation.added"),
+  annotation: z8.object({
+    type: z8.literal("url_citation"),
+    url: z8.string(),
+    title: z8.string()
   })
 });
-var openaiResponsesChunkSchema = z7.union([
+var openaiResponsesChunkSchema = z8.union([
   textDeltaChunkSchema,
   responseFinishedChunkSchema,
   responseCreatedChunkSchema,
@@ -2381,7 +2419,7 @@ var openaiResponsesChunkSchema = z7.union([
   responseFunctionCallArgumentsDeltaSchema,
   responseOutputItemAddedSchema,
   responseAnnotationAddedSchema,
-  z7.object({ type: z7.string() }).passthrough()
+  z8.object({ type: z8.string() }).passthrough()
   // fallback for unknown chunks
 ]);
 function isTextDeltaChunk(chunk) {
@@ -2426,15 +2464,15 @@ function getResponsesModelConfig(modelId) {
     requiredAutoTruncation: false
   };
 }
-var openaiResponsesProviderOptionsSchema = z7.object({
-  metadata: z7.any().nullish(),
-  parallelToolCalls: z7.boolean().nullish(),
-  previousResponseId: z7.string().nullish(),
-  store: z7.boolean().nullish(),
-  user: z7.string().nullish(),
-  reasoningEffort: z7.string().nullish(),
-  strictSchemas: z7.boolean().nullish(),
-  instructions: z7.string().nullish()
+var openaiResponsesProviderOptionsSchema = z8.object({
+  metadata: z8.any().nullish(),
+  parallelToolCalls: z8.boolean().nullish(),
+  previousResponseId: z8.string().nullish(),
+  store: z8.boolean().nullish(),
+  user: z8.string().nullish(),
+  reasoningEffort: z8.string().nullish(),
+  strictSchemas: z8.boolean().nullish(),
+  instructions: z8.string().nullish()
 });
 
 // src/openai-provider.ts
@@ -2479,6 +2517,12 @@ function createOpenAI(options = {}) {
     headers: getHeaders,
     fetch: options.fetch
   });
+  const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
+    provider: `${providerName}.transcription`,
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
   const createLanguageModel = (modelId, settings) => {
     if (new.target) {
       throw new Error(
@@ -2513,6 +2557,8 @@ function createOpenAI(options = {}) {
   provider.textEmbeddingModel = createEmbeddingModel;
   provider.image = createImageModel;
   provider.imageModel = createImageModel;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
   provider.tools = openaiTools;
   return provider;
 }