@ai-sdk/openai 1.3.9 → 1.3.11

package/internal/dist/index.js

@@ -25,6 +25,7 @@ __export(internal_exports, {
   OpenAIEmbeddingModel: () => OpenAIEmbeddingModel,
   OpenAIImageModel: () => OpenAIImageModel,
   OpenAIResponsesLanguageModel: () => OpenAIResponsesLanguageModel,
+  OpenAISpeechModel: () => OpenAISpeechModel,
   OpenAITranscriptionModel: () => OpenAITranscriptionModel,
   modelMaxImagesPerCall: () => modelMaxImagesPerCall
 });
@@ -538,6 +539,15 @@ var OpenAIChatLanguageModel = class {
         }
         baseArgs.max_tokens = void 0;
       }
+    } else if (this.modelId.startsWith("gpt-4o-search-preview")) {
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "temperature",
+          details: "temperature is not supported for the gpt-4o-search-preview model and has been removed."
+        });
+      }
     }
     switch (type) {
       case "regular": {
@@ -1606,18 +1616,12 @@ var openaiImageResponseSchema = import_zod5.z.object({
 // src/openai-transcription-model.ts
 var import_provider_utils7 = require("@ai-sdk/provider-utils");
 var import_zod6 = require("zod");
-var OpenAIProviderOptionsSchema = import_zod6.z.object({
-  include: import_zod6.z.array(import_zod6.z.string()).optional().describe(
-    "Additional information to include in the transcription response."
-  ),
-  language: import_zod6.z.string().optional().describe("The language of the input audio in ISO-639-1 format."),
-  prompt: import_zod6.z.string().optional().describe(
-    "An optional text to guide the model's style or continue a previous audio segment."
-  ),
-  temperature: import_zod6.z.number().min(0).max(1).optional().default(0).describe("The sampling temperature, between 0 and 1."),
-  timestampGranularities: import_zod6.z.array(import_zod6.z.enum(["word", "segment"])).optional().default(["segment"]).describe(
-    "The timestamp granularities to populate for this transcription."
-  )
+var openAIProviderOptionsSchema = import_zod6.z.object({
+  include: import_zod6.z.array(import_zod6.z.string()).nullish(),
+  language: import_zod6.z.string().nullish(),
+  prompt: import_zod6.z.string().nullish(),
+  temperature: import_zod6.z.number().min(0).max(1).nullish().default(0),
+  timestampGranularities: import_zod6.z.array(import_zod6.z.enum(["word", "segment"])).nullish().default(["segment"])
 });
 var languageMap = {
   afrikaans: "af",
@@ -1692,11 +1696,12 @@ var OpenAITranscriptionModel = class {
     mediaType,
     providerOptions
   }) {
+    var _a, _b, _c, _d, _e;
     const warnings = [];
     const openAIOptions = (0, import_provider_utils7.parseProviderOptions)({
       provider: "openai",
       providerOptions,
-      schema: OpenAIProviderOptionsSchema
+      schema: openAIProviderOptionsSchema
     });
     const formData = new FormData();
     const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([(0, import_provider_utils7.convertBase64ToUint8Array)(audio)]);
@@ -1704,16 +1709,16 @@ var OpenAITranscriptionModel = class {
     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
+        include: (_a = openAIOptions.include) != null ? _a : void 0,
+        language: (_b = openAIOptions.language) != null ? _b : void 0,
+        prompt: (_c = openAIOptions.prompt) != null ? _c : void 0,
+        temperature: (_d = openAIOptions.temperature) != null ? _d : void 0,
+        timestamp_granularities: (_e = openAIOptions.timestampGranularities) != null ? _e : void 0
       };
       for (const key in transcriptionModelOptions) {
         const value = transcriptionModelOptions[key];
         if (value !== void 0) {
-          formData.append(key, value);
+          formData.append(key, String(value));
         }
       }
     }
@@ -1777,13 +1782,112 @@ var openaiTranscriptionResponseSchema = import_zod6.z.object({
   ).nullish()
 });
 
-// src/responses/openai-responses-language-model.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
+// src/openai-speech-model.ts
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
 var import_zod7 = require("zod");
+var OpenAIProviderOptionsSchema = import_zod7.z.object({
+  instructions: import_zod7.z.string().nullish(),
+  speed: import_zod7.z.number().min(0.25).max(4).default(1).nullish()
+});
+var OpenAISpeechModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v1";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  getArgs({
+    text,
+    voice = "alloy",
+    outputFormat = "mp3",
+    speed,
+    instructions,
+    providerOptions
+  }) {
+    const warnings = [];
+    const openAIOptions = (0, import_provider_utils8.parseProviderOptions)({
+      provider: "openai",
+      providerOptions,
+      schema: OpenAIProviderOptionsSchema
+    });
+    const requestBody = {
+      model: this.modelId,
+      input: text,
+      voice,
+      response_format: "mp3",
+      speed,
+      instructions
+    };
+    if (outputFormat) {
+      if (["mp3", "opus", "aac", "flac", "wav", "pcm"].includes(outputFormat)) {
+        requestBody.response_format = outputFormat;
+      } else {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "outputFormat",
+          details: `Unsupported output format: ${outputFormat}. Using mp3 instead.`
+        });
+      }
+    }
+    if (openAIOptions) {
+      const speechModelOptions = {};
+      for (const key in speechModelOptions) {
+        const value = speechModelOptions[key];
+        if (value !== void 0) {
+          requestBody[key] = value;
+        }
+      }
+    }
+    return {
+      requestBody,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c;
+    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 { requestBody, warnings } = this.getArgs(options);
+    const {
+      value: audio,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await (0, import_provider_utils8.postJsonToApi)({
+      url: this.config.url({
+        path: "/audio/speech",
+        modelId: this.modelId
+      }),
+      headers: (0, import_provider_utils8.combineHeaders)(this.config.headers(), options.headers),
+      body: requestBody,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils8.createBinaryResponseHandler)(),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      audio,
+      warnings,
+      request: {
+        body: JSON.stringify(requestBody)
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+
+// src/responses/openai-responses-language-model.ts
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var import_zod8 = require("zod");
 
 // src/responses/convert-to-openai-responses-messages.ts
 var import_provider7 = require("@ai-sdk/provider");
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
 function convertToOpenAIResponsesMessages({
   prompt,
   systemMessageMode
@@ -1830,7 +1934,7 @@ function convertToOpenAIResponsesMessages({
               case "image": {
                 return {
                   type: "input_image",
-                  image_url: part.image instanceof URL ? part.image.toString() : `data:${(_a = part.mimeType) != null ? _a : "image/jpeg"};base64,${(0, import_provider_utils8.convertUint8ArrayToBase64)(part.image)}`,
+                  image_url: part.image instanceof URL ? part.image.toString() : `data:${(_a = part.mimeType) != null ? _a : "image/jpeg"};base64,${(0, import_provider_utils9.convertUint8ArrayToBase64)(part.image)}`,
                   // OpenAI specific extension: image detail
                   detail: (_c = (_b = part.providerMetadata) == null ? void 0 : _b.openai) == null ? void 0 : _c.imageDetail
                 };
@@ -2066,7 +2170,7 @@ var OpenAIResponsesLanguageModel = class {
       systemMessageMode: modelConfig.systemMessageMode
     });
     warnings.push(...messageWarnings);
-    const openaiOptions = (0, import_provider_utils9.parseProviderOptions)({
+    const openaiOptions = (0, import_provider_utils10.parseProviderOptions)({
       provider: "openai",
       providerOptions: providerMetadata,
       schema: openaiResponsesProviderOptionsSchema
@@ -2186,58 +2290,58 @@ var OpenAIResponsesLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils9.postJsonToApi)({
+    } = await (0, import_provider_utils10.postJsonToApi)({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils9.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils10.combineHeaders)(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils9.createJsonResponseHandler)(
-        import_zod7.z.object({
-          id: import_zod7.z.string(),
-          created_at: import_zod7.z.number(),
-          model: import_zod7.z.string(),
-          output: import_zod7.z.array(
-            import_zod7.z.discriminatedUnion("type", [
-              import_zod7.z.object({
-                type: import_zod7.z.literal("message"),
-                role: import_zod7.z.literal("assistant"),
-                content: import_zod7.z.array(
-                  import_zod7.z.object({
-                    type: import_zod7.z.literal("output_text"),
-                    text: import_zod7.z.string(),
-                    annotations: import_zod7.z.array(
-                      import_zod7.z.object({
-                        type: import_zod7.z.literal("url_citation"),
-                        start_index: import_zod7.z.number(),
-                        end_index: import_zod7.z.number(),
-                        url: import_zod7.z.string(),
-                        title: import_zod7.z.string()
+      successfulResponseHandler: (0, import_provider_utils10.createJsonResponseHandler)(
+        import_zod8.z.object({
+          id: import_zod8.z.string(),
+          created_at: import_zod8.z.number(),
+          model: import_zod8.z.string(),
+          output: import_zod8.z.array(
+            import_zod8.z.discriminatedUnion("type", [
+              import_zod8.z.object({
+                type: import_zod8.z.literal("message"),
+                role: import_zod8.z.literal("assistant"),
+                content: import_zod8.z.array(
+                  import_zod8.z.object({
+                    type: import_zod8.z.literal("output_text"),
+                    text: import_zod8.z.string(),
+                    annotations: import_zod8.z.array(
+                      import_zod8.z.object({
+                        type: import_zod8.z.literal("url_citation"),
+                        start_index: import_zod8.z.number(),
+                        end_index: import_zod8.z.number(),
+                        url: import_zod8.z.string(),
+                        title: import_zod8.z.string()
                       })
                     )
                   })
                 )
               }),
-              import_zod7.z.object({
-                type: import_zod7.z.literal("function_call"),
-                call_id: import_zod7.z.string(),
-                name: import_zod7.z.string(),
-                arguments: import_zod7.z.string()
+              import_zod8.z.object({
+                type: import_zod8.z.literal("function_call"),
+                call_id: import_zod8.z.string(),
+                name: import_zod8.z.string(),
+                arguments: import_zod8.z.string()
               }),
-              import_zod7.z.object({
-                type: import_zod7.z.literal("web_search_call")
+              import_zod8.z.object({
+                type: import_zod8.z.literal("web_search_call")
               }),
-              import_zod7.z.object({
-                type: import_zod7.z.literal("computer_call")
+              import_zod8.z.object({
+                type: import_zod8.z.literal("computer_call")
               }),
-              import_zod7.z.object({
-                type: import_zod7.z.literal("reasoning")
+              import_zod8.z.object({
+                type: import_zod8.z.literal("reasoning")
               })
             ])
           ),
-          incomplete_details: import_zod7.z.object({ reason: import_zod7.z.string() }).nullable(),
+          incomplete_details: import_zod8.z.object({ reason: import_zod8.z.string() }).nullable(),
           usage: usageSchema
         })
       ),
@@ -2258,7 +2362,7 @@ var OpenAIResponsesLanguageModel = class {
           var _a2, _b2, _c2;
           return {
             sourceType: "url",
-            id: (_c2 = (_b2 = (_a2 = this.config).generateId) == null ? void 0 : _b2.call(_a2)) != null ? _c2 : (0, import_provider_utils9.generateId)(),
+            id: (_c2 = (_b2 = (_a2 = this.config).generateId) == null ? void 0 : _b2.call(_a2)) != null ? _c2 : (0, import_provider_utils10.generateId)(),
             url: annotation.url,
             title: annotation.title
           };
@@ -2301,18 +2405,18 @@ var OpenAIResponsesLanguageModel = class {
   }
   async doStream(options) {
     const { args: body, warnings } = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils9.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils10.postJsonToApi)({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils9.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils10.combineHeaders)(this.config.headers(), options.headers),
       body: {
         ...body,
         stream: true
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils9.createEventSourceResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils10.createEventSourceResponseHandler)(
         openaiResponsesChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -2400,7 +2504,7 @@ var OpenAIResponsesLanguageModel = class {
                 type: "source",
                 source: {
                   sourceType: "url",
-                  id: (_h = (_g = (_f = self.config).generateId) == null ? void 0 : _g.call(_f)) != null ? _h : (0, import_provider_utils9.generateId)(),
+                  id: (_h = (_g = (_f = self.config).generateId) == null ? void 0 : _g.call(_f)) != null ? _h : (0, import_provider_utils10.generateId)(),
                   url: value.annotation.url,
                   title: value.annotation.title
                 }
@@ -2435,79 +2539,79 @@ var OpenAIResponsesLanguageModel = class {
     };
   }
 };
-var usageSchema = import_zod7.z.object({
-  input_tokens: import_zod7.z.number(),
-  input_tokens_details: import_zod7.z.object({ cached_tokens: import_zod7.z.number().nullish() }).nullish(),
-  output_tokens: import_zod7.z.number(),
-  output_tokens_details: import_zod7.z.object({ reasoning_tokens: import_zod7.z.number().nullish() }).nullish()
+var usageSchema = import_zod8.z.object({
+  input_tokens: import_zod8.z.number(),
+  input_tokens_details: import_zod8.z.object({ cached_tokens: import_zod8.z.number().nullish() }).nullish(),
+  output_tokens: import_zod8.z.number(),
+  output_tokens_details: import_zod8.z.object({ reasoning_tokens: import_zod8.z.number().nullish() }).nullish()
 });
-var textDeltaChunkSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("response.output_text.delta"),
-  delta: import_zod7.z.string()
+var textDeltaChunkSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("response.output_text.delta"),
+  delta: import_zod8.z.string()
 });
-var responseFinishedChunkSchema = import_zod7.z.object({
-  type: import_zod7.z.enum(["response.completed", "response.incomplete"]),
-  response: import_zod7.z.object({
-    incomplete_details: import_zod7.z.object({ reason: import_zod7.z.string() }).nullish(),
+var responseFinishedChunkSchema = import_zod8.z.object({
+  type: import_zod8.z.enum(["response.completed", "response.incomplete"]),
+  response: import_zod8.z.object({
+    incomplete_details: import_zod8.z.object({ reason: import_zod8.z.string() }).nullish(),
     usage: usageSchema
   })
 });
-var responseCreatedChunkSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("response.created"),
-  response: import_zod7.z.object({
-    id: import_zod7.z.string(),
-    created_at: import_zod7.z.number(),
-    model: import_zod7.z.string()
+var responseCreatedChunkSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("response.created"),
+  response: import_zod8.z.object({
+    id: import_zod8.z.string(),
+    created_at: import_zod8.z.number(),
+    model: import_zod8.z.string()
   })
 });
-var responseOutputItemDoneSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("response.output_item.done"),
-  output_index: import_zod7.z.number(),
-  item: import_zod7.z.discriminatedUnion("type", [
-    import_zod7.z.object({
-      type: import_zod7.z.literal("message")
+var responseOutputItemDoneSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("response.output_item.done"),
+  output_index: import_zod8.z.number(),
+  item: import_zod8.z.discriminatedUnion("type", [
+    import_zod8.z.object({
+      type: import_zod8.z.literal("message")
     }),
-    import_zod7.z.object({
-      type: import_zod7.z.literal("function_call"),
-      id: import_zod7.z.string(),
-      call_id: import_zod7.z.string(),
-      name: import_zod7.z.string(),
-      arguments: import_zod7.z.string(),
-      status: import_zod7.z.literal("completed")
+    import_zod8.z.object({
+      type: import_zod8.z.literal("function_call"),
+      id: import_zod8.z.string(),
+      call_id: import_zod8.z.string(),
+      name: import_zod8.z.string(),
+      arguments: import_zod8.z.string(),
+      status: import_zod8.z.literal("completed")
     })
   ])
 });
-var responseFunctionCallArgumentsDeltaSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("response.function_call_arguments.delta"),
-  item_id: import_zod7.z.string(),
-  output_index: import_zod7.z.number(),
-  delta: import_zod7.z.string()
+var responseFunctionCallArgumentsDeltaSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("response.function_call_arguments.delta"),
+  item_id: import_zod8.z.string(),
+  output_index: import_zod8.z.number(),
+  delta: import_zod8.z.string()
 });
-var responseOutputItemAddedSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("response.output_item.added"),
-  output_index: import_zod7.z.number(),
-  item: import_zod7.z.discriminatedUnion("type", [
-    import_zod7.z.object({
-      type: import_zod7.z.literal("message")
+var responseOutputItemAddedSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("response.output_item.added"),
+  output_index: import_zod8.z.number(),
+  item: import_zod8.z.discriminatedUnion("type", [
+    import_zod8.z.object({
+      type: import_zod8.z.literal("message")
     }),
-    import_zod7.z.object({
-      type: import_zod7.z.literal("function_call"),
-      id: import_zod7.z.string(),
-      call_id: import_zod7.z.string(),
-      name: import_zod7.z.string(),
-      arguments: import_zod7.z.string()
+    import_zod8.z.object({
+      type: import_zod8.z.literal("function_call"),
+      id: import_zod8.z.string(),
+      call_id: import_zod8.z.string(),
+      name: import_zod8.z.string(),
+      arguments: import_zod8.z.string()
     })
   ])
 });
-var responseAnnotationAddedSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("response.output_text.annotation.added"),
-  annotation: import_zod7.z.object({
-    type: import_zod7.z.literal("url_citation"),
-    url: import_zod7.z.string(),
-    title: import_zod7.z.string()
+var responseAnnotationAddedSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("response.output_text.annotation.added"),
+  annotation: import_zod8.z.object({
+    type: import_zod8.z.literal("url_citation"),
+    url: import_zod8.z.string(),
+    title: import_zod8.z.string()
   })
 });
-var openaiResponsesChunkSchema = import_zod7.z.union([
+var openaiResponsesChunkSchema = import_zod8.z.union([
   textDeltaChunkSchema,
   responseFinishedChunkSchema,
   responseCreatedChunkSchema,
@@ -2515,7 +2619,7 @@ var openaiResponsesChunkSchema = import_zod7.z.union([
   responseFunctionCallArgumentsDeltaSchema,
   responseOutputItemAddedSchema,
   responseAnnotationAddedSchema,
-  import_zod7.z.object({ type: import_zod7.z.string() }).passthrough()
+  import_zod8.z.object({ type: import_zod8.z.string() }).passthrough()
   // fallback for unknown chunks
 ]);
 function isTextDeltaChunk(chunk) {
@@ -2560,15 +2664,15 @@ function getResponsesModelConfig(modelId) {
     requiredAutoTruncation: false
   };
 }
-var openaiResponsesProviderOptionsSchema = import_zod7.z.object({
-  metadata: import_zod7.z.any().nullish(),
-  parallelToolCalls: import_zod7.z.boolean().nullish(),
-  previousResponseId: import_zod7.z.string().nullish(),
-  store: import_zod7.z.boolean().nullish(),
-  user: import_zod7.z.string().nullish(),
-  reasoningEffort: import_zod7.z.string().nullish(),
-  strictSchemas: import_zod7.z.boolean().nullish(),
-  instructions: import_zod7.z.string().nullish()
+var openaiResponsesProviderOptionsSchema = import_zod8.z.object({
+  metadata: import_zod8.z.any().nullish(),
+  parallelToolCalls: import_zod8.z.boolean().nullish(),
+  previousResponseId: import_zod8.z.string().nullish(),
+  store: import_zod8.z.boolean().nullish(),
+  user: import_zod8.z.string().nullish(),
+  reasoningEffort: import_zod8.z.string().nullish(),
+  strictSchemas: import_zod8.z.boolean().nullish(),
+  instructions: import_zod8.z.string().nullish()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2577,6 +2681,7 @@ var openaiResponsesProviderOptionsSchema = import_zod7.z.object({
   OpenAIEmbeddingModel,
   OpenAIImageModel,
   OpenAIResponsesLanguageModel,
+  OpenAISpeechModel,
   OpenAITranscriptionModel,
   modelMaxImagesPerCall
 });