@ai-sdk/openai 2.0.0-canary.6 → 2.0.0-canary.8

package/dist/internal/index.js

@@ -25,6 +25,7 @@ __export(internal_exports, {
   OpenAIEmbeddingModel: () => OpenAIEmbeddingModel,
   OpenAIImageModel: () => OpenAIImageModel,
   OpenAIResponsesLanguageModel: () => OpenAIResponsesLanguageModel,
+  OpenAISpeechModel: () => OpenAISpeechModel,
   OpenAITranscriptionModel: () => OpenAITranscriptionModel,
   modelMaxImagesPerCall: () => modelMaxImagesPerCall,
   openaiProviderOptions: () => openaiProviderOptions
@@ -583,10 +584,23 @@ var OpenAIChatLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { messages: rawPrompt, ...rawSettings } = body;
     const choice = response.choices[0];
-    const completionTokenDetails = (_a = response.usage) == null ? void 0 : _a.completion_tokens_details;
-    const promptTokenDetails = (_b = response.usage) == null ? void 0 : _b.prompt_tokens_details;
+    const content = [];
+    const text = choice.message.content;
+    if (text != null && text.length > 0) {
+      content.push({ type: "text", text });
+    }
+    for (const toolCall of (_a = choice.message.tool_calls) != null ? _a : []) {
+      content.push({
+        type: "tool-call",
+        toolCallType: "function",
+        toolCallId: (_b = toolCall.id) != null ? _b : (0, import_provider_utils3.generateId)(),
+        toolName: toolCall.function.name,
+        args: toolCall.function.arguments
+      });
+    }
+    const completionTokenDetails = (_c = response.usage) == null ? void 0 : _c.completion_tokens_details;
+    const promptTokenDetails = (_d = response.usage) == null ? void 0 : _d.prompt_tokens_details;
     const providerMetadata = { openai: {} };
     if ((completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens) != null) {
       providerMetadata.openai.reasoningTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens;
@@ -601,16 +615,7 @@ var OpenAIChatLanguageModel = class {
       providerMetadata.openai.cachedPromptTokens = promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens;
     }
     return {
-      text: (_c = choice.message.content) != null ? _c : void 0,
-      toolCalls: (_d = choice.message.tool_calls) == null ? void 0 : _d.map((toolCall) => {
-        var _a2;
-        return {
-          toolCallType: "function",
-          toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils3.generateId)(),
-          toolName: toolCall.function.name,
-          args: toolCall.function.arguments
-        };
-      }),
+      content,
       finishReason: mapOpenAIFinishReason(choice.finish_reason),
       usage: {
         inputTokens: (_f = (_e = response.usage) == null ? void 0 : _e.prompt_tokens) != null ? _f : void 0,
@@ -662,6 +667,9 @@ var OpenAIChatLanguageModel = class {
     return {
       stream: response.pipeThrough(
         new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
           transform(chunk, controller) {
             var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
             if (!chunk.success) {
@@ -714,8 +722,8 @@ var OpenAIChatLanguageModel = class {
             const delta = choice.delta;
             if (delta.content != null) {
               controller.enqueue({
-                type: "text-delta",
-                textDelta: delta.content
+                type: "text",
+                text: delta.content
               });
             }
             const mappedLogprobs = mapOpenAIChatLogProbsOutput(
@@ -819,8 +827,7 @@ var OpenAIChatLanguageModel = class {
         })
       ),
       request: { body },
-      response: { headers: responseHeaders },
-      warnings
+      response: { headers: responseHeaders }
     };
   }
 };
@@ -1144,7 +1151,7 @@ var OpenAICompletionLanguageModel = class {
     });
     const choice = response.choices[0];
     return {
-      text: choice.text,
+      content: [{ type: "text", text: choice.text }],
       usage: {
         inputTokens: response.usage.prompt_tokens,
         outputTokens: response.usage.completion_tokens
@@ -1192,6 +1199,9 @@ var OpenAICompletionLanguageModel = class {
     return {
       stream: response.pipeThrough(
         new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
           transform(chunk, controller) {
             if (!chunk.success) {
               finishReason = "error";
@@ -1221,8 +1231,8 @@ var OpenAICompletionLanguageModel = class {
             }
             if ((choice == null ? void 0 : choice.text) != null) {
               controller.enqueue({
-                type: "text-delta",
-                textDelta: choice.text
+                type: "text",
+                text: choice.text
               });
             }
             const mappedLogprobs = mapOpenAICompletionLogProbs(
@@ -1243,9 +1253,8 @@ var OpenAICompletionLanguageModel = class {
           }
         })
       ),
-      response: { headers: responseHeaders },
-      warnings,
-      request: { body: JSON.stringify(body) }
+      request: { body },
+      response: { headers: responseHeaders }
     };
   }
 };
@@ -1300,7 +1309,7 @@ var import_provider_utils5 = require("@ai-sdk/provider-utils");
 var import_zod5 = require("zod");
 var OpenAIEmbeddingModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
     this.modelId = modelId;
     this.settings = settings;
     this.config = config;
@@ -1329,7 +1338,11 @@ var OpenAIEmbeddingModel = class {
         values
       });
     }
-    const { responseHeaders, value: response } = await (0, import_provider_utils5.postJsonToApi)({
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await (0, import_provider_utils5.postJsonToApi)({
       url: this.config.url({
         path: "/embeddings",
         modelId: this.modelId
@@ -1352,7 +1365,7 @@ var OpenAIEmbeddingModel = class {
     return {
       embeddings: response.data.map((item) => item.embedding),
       usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
-      rawResponse: { headers: responseHeaders }
+      response: { headers: responseHeaders, body: rawValue }
     };
   }
 };
@@ -1448,7 +1461,7 @@ var openaiImageResponseSchema = import_zod6.z.object({
 // src/openai-transcription-model.ts
 var import_provider_utils7 = require("@ai-sdk/provider-utils");
 var import_zod7 = require("zod");
-var OpenAIProviderOptionsSchema = import_zod7.z.object({
+var openAIProviderOptionsSchema = import_zod7.z.object({
   include: import_zod7.z.array(import_zod7.z.string()).nullish(),
   language: import_zod7.z.string().nullish(),
   prompt: import_zod7.z.string().nullish(),
@@ -1533,7 +1546,7 @@ var OpenAITranscriptionModel = class {
     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)]);
@@ -1614,9 +1627,108 @@ var openaiTranscriptionResponseSchema = import_zod7.z.object({
   ).nullish()
 });
 
-// src/responses/openai-responses-language-model.ts
+// src/openai-speech-model.ts
 var import_provider_utils8 = require("@ai-sdk/provider-utils");
 var import_zod8 = require("zod");
+var OpenAIProviderOptionsSchema = import_zod8.z.object({
+  instructions: import_zod8.z.string().nullish(),
+  speed: import_zod8.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_utils9 = require("@ai-sdk/provider-utils");
+var import_zod9 = require("zod");
 
 // src/responses/convert-to-openai-responses-messages.ts
 var import_provider6 = require("@ai-sdk/provider");
@@ -1876,7 +1988,7 @@ var OpenAIResponsesLanguageModel = class {
       systemMessageMode: modelConfig.systemMessageMode
     });
     warnings.push(...messageWarnings);
-    const openaiOptions = (0, import_provider_utils8.parseProviderOptions)({
+    const openaiOptions = (0, import_provider_utils9.parseProviderOptions)({
       provider: "openai",
       providerOptions,
       schema: openaiResponsesProviderOptionsSchema
@@ -1951,95 +2063,109 @@ var OpenAIResponsesLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const { args: body, warnings } = this.getArgs(options);
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils8.postJsonToApi)({
+    } = await (0, import_provider_utils9.postJsonToApi)({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils8.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils9.combineHeaders)(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils8.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()
+      successfulResponseHandler: (0, import_provider_utils9.createJsonResponseHandler)(
+        import_zod9.z.object({
+          id: import_zod9.z.string(),
+          created_at: import_zod9.z.number(),
+          model: import_zod9.z.string(),
+          output: import_zod9.z.array(
+            import_zod9.z.discriminatedUnion("type", [
+              import_zod9.z.object({
+                type: import_zod9.z.literal("message"),
+                role: import_zod9.z.literal("assistant"),
+                content: import_zod9.z.array(
+                  import_zod9.z.object({
+                    type: import_zod9.z.literal("output_text"),
+                    text: import_zod9.z.string(),
+                    annotations: import_zod9.z.array(
+                      import_zod9.z.object({
+                        type: import_zod9.z.literal("url_citation"),
+                        start_index: import_zod9.z.number(),
+                        end_index: import_zod9.z.number(),
+                        url: import_zod9.z.string(),
+                        title: import_zod9.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_zod9.z.object({
+                type: import_zod9.z.literal("function_call"),
+                call_id: import_zod9.z.string(),
+                name: import_zod9.z.string(),
+                arguments: import_zod9.z.string()
               }),
-              import_zod8.z.object({
-                type: import_zod8.z.literal("web_search_call")
+              import_zod9.z.object({
+                type: import_zod9.z.literal("web_search_call")
               }),
-              import_zod8.z.object({
-                type: import_zod8.z.literal("computer_call")
+              import_zod9.z.object({
+                type: import_zod9.z.literal("computer_call")
               }),
-              import_zod8.z.object({
-                type: import_zod8.z.literal("reasoning")
+              import_zod9.z.object({
+                type: import_zod9.z.literal("reasoning")
               })
             ])
           ),
-          incomplete_details: import_zod8.z.object({ reason: import_zod8.z.string() }).nullable(),
+          incomplete_details: import_zod9.z.object({ reason: import_zod9.z.string() }).nullable(),
           usage: usageSchema
         })
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const outputTextElements = response.output.filter((output) => output.type === "message").flatMap((output) => output.content).filter((content) => content.type === "output_text");
-    const toolCalls = response.output.filter((output) => output.type === "function_call").map((output) => ({
-      toolCallType: "function",
-      toolCallId: output.call_id,
-      toolName: output.name,
-      args: output.arguments
-    }));
+    const content = [];
+    for (const part of response.output) {
+      switch (part.type) {
+        case "message": {
+          for (const contentPart of part.content) {
+            content.push({
+              type: "text",
+              text: contentPart.text
+            });
+            for (const annotation of contentPart.annotations) {
+              content.push({
+                type: "source",
+                sourceType: "url",
+                id: (_c = (_b = (_a = this.config).generateId) == null ? void 0 : _b.call(_a)) != null ? _c : (0, import_provider_utils9.generateId)(),
+                url: annotation.url,
+                title: annotation.title
+              });
+            }
+          }
+          break;
+        }
+        case "function_call": {
+          content.push({
+            type: "tool-call",
+            toolCallType: "function",
+            toolCallId: part.call_id,
+            toolName: part.name,
+            args: part.arguments
+          });
+          break;
+        }
+      }
+    }
     return {
-      text: outputTextElements.map((content) => content.text).join("\n"),
-      sources: outputTextElements.flatMap(
-        (content) => content.annotations.map((annotation) => {
-          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_utils8.generateId)(),
-            url: annotation.url,
-            title: annotation.title
-          };
-        })
-      ),
+      content,
       finishReason: mapOpenAIResponseFinishReason({
-        finishReason: (_a = response.incomplete_details) == null ? void 0 : _a.reason,
-        hasToolCalls: toolCalls.length > 0
+        finishReason: (_d = response.incomplete_details) == null ? void 0 : _d.reason,
+        hasToolCalls: content.some((part) => part.type === "tool-call")
       }),
-      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
       usage: {
         inputTokens: response.usage.input_tokens,
         outputTokens: response.usage.output_tokens
@@ -2055,8 +2181,8 @@ var OpenAIResponsesLanguageModel = class {
       providerMetadata: {
         openai: {
           responseId: response.id,
-          cachedPromptTokens: (_c = (_b = response.usage.input_tokens_details) == null ? void 0 : _b.cached_tokens) != null ? _c : null,
-          reasoningTokens: (_e = (_d = response.usage.output_tokens_details) == null ? void 0 : _d.reasoning_tokens) != null ? _e : null
+          cachedPromptTokens: (_f = (_e = response.usage.input_tokens_details) == null ? void 0 : _e.cached_tokens) != null ? _f : null,
+          reasoningTokens: (_h = (_g = response.usage.output_tokens_details) == null ? void 0 : _g.reasoning_tokens) != null ? _h : null
         }
       },
       warnings
@@ -2064,18 +2190,18 @@ var OpenAIResponsesLanguageModel = class {
   }
   async doStream(options) {
     const { args: body, warnings } = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils8.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils9.postJsonToApi)({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils8.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils9.combineHeaders)(this.config.headers(), options.headers),
       body: {
         ...body,
         stream: true
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils8.createEventSourceResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils9.createEventSourceResponseHandler)(
         openaiResponsesChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -2095,6 +2221,9 @@ var OpenAIResponsesLanguageModel = class {
     return {
       stream: response.pipeThrough(
         new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
           transform(chunk, controller) {
             var _a, _b, _c, _d, _e, _f, _g, _h;
             if (!chunk.success) {
@@ -2138,8 +2267,8 @@ var OpenAIResponsesLanguageModel = class {
               });
             } else if (isTextDeltaChunk(value)) {
               controller.enqueue({
-                type: "text-delta",
-                textDelta: value.delta
+                type: "text",
+                text: value.delta
               });
             } else if (isResponseOutputItemDoneChunk(value) && value.item.type === "function_call") {
               ongoingToolCalls[value.output_index] = void 0;
@@ -2163,12 +2292,10 @@ var OpenAIResponsesLanguageModel = class {
             } else if (isResponseAnnotationAddedChunk(value)) {
               controller.enqueue({
                 type: "source",
-                source: {
-                  sourceType: "url",
-                  id: (_h = (_g = (_f = self.config).generateId) == null ? void 0 : _g.call(_f)) != null ? _h : (0, import_provider_utils8.generateId)(),
-                  url: value.annotation.url,
-                  title: value.annotation.title
-                }
+                sourceType: "url",
+                id: (_h = (_g = (_f = self.config).generateId) == null ? void 0 : _g.call(_f)) != null ? _h : (0, import_provider_utils9.generateId)(),
+                url: value.annotation.url,
+                title: value.annotation.title
               });
             }
           },
@@ -2191,84 +2318,83 @@ var OpenAIResponsesLanguageModel = class {
         })
       ),
       request: { body },
-      response: { headers: responseHeaders },
-      warnings
+      response: { headers: responseHeaders }
     };
   }
 };
-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 usageSchema = import_zod9.z.object({
+  input_tokens: import_zod9.z.number(),
+  input_tokens_details: import_zod9.z.object({ cached_tokens: import_zod9.z.number().nullish() }).nullish(),
+  output_tokens: import_zod9.z.number(),
+  output_tokens_details: import_zod9.z.object({ reasoning_tokens: import_zod9.z.number().nullish() }).nullish()
 });
-var textDeltaChunkSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("response.output_text.delta"),
-  delta: import_zod8.z.string()
+var textDeltaChunkSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("response.output_text.delta"),
+  delta: import_zod9.z.string()
 });
-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(),
+var responseFinishedChunkSchema = import_zod9.z.object({
+  type: import_zod9.z.enum(["response.completed", "response.incomplete"]),
+  response: import_zod9.z.object({
+    incomplete_details: import_zod9.z.object({ reason: import_zod9.z.string() }).nullish(),
     usage: usageSchema
   })
 });
-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 responseCreatedChunkSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("response.created"),
+  response: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    created_at: import_zod9.z.number(),
+    model: import_zod9.z.string()
   })
 });
-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")
+var responseOutputItemDoneSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("response.output_item.done"),
+  output_index: import_zod9.z.number(),
+  item: import_zod9.z.discriminatedUnion("type", [
+    import_zod9.z.object({
+      type: import_zod9.z.literal("message")
     }),
-    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")
+    import_zod9.z.object({
+      type: import_zod9.z.literal("function_call"),
+      id: import_zod9.z.string(),
+      call_id: import_zod9.z.string(),
+      name: import_zod9.z.string(),
+      arguments: import_zod9.z.string(),
+      status: import_zod9.z.literal("completed")
     })
   ])
 });
-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 responseFunctionCallArgumentsDeltaSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("response.function_call_arguments.delta"),
+  item_id: import_zod9.z.string(),
+  output_index: import_zod9.z.number(),
+  delta: import_zod9.z.string()
 });
-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")
+var responseOutputItemAddedSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("response.output_item.added"),
+  output_index: import_zod9.z.number(),
+  item: import_zod9.z.discriminatedUnion("type", [
+    import_zod9.z.object({
+      type: import_zod9.z.literal("message")
     }),
-    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()
+    import_zod9.z.object({
+      type: import_zod9.z.literal("function_call"),
+      id: import_zod9.z.string(),
+      call_id: import_zod9.z.string(),
+      name: import_zod9.z.string(),
+      arguments: import_zod9.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 responseAnnotationAddedSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("response.output_text.annotation.added"),
+  annotation: import_zod9.z.object({
+    type: import_zod9.z.literal("url_citation"),
+    url: import_zod9.z.string(),
+    title: import_zod9.z.string()
   })
 });
-var openaiResponsesChunkSchema = import_zod8.z.union([
+var openaiResponsesChunkSchema = import_zod9.z.union([
   textDeltaChunkSchema,
   responseFinishedChunkSchema,
   responseCreatedChunkSchema,
@@ -2276,7 +2402,7 @@ var openaiResponsesChunkSchema = import_zod8.z.union([
   responseFunctionCallArgumentsDeltaSchema,
   responseOutputItemAddedSchema,
   responseAnnotationAddedSchema,
-  import_zod8.z.object({ type: import_zod8.z.string() }).passthrough()
+  import_zod9.z.object({ type: import_zod9.z.string() }).passthrough()
   // fallback for unknown chunks
 ]);
 function isTextDeltaChunk(chunk) {
@@ -2321,15 +2447,15 @@ function getResponsesModelConfig(modelId) {
     requiredAutoTruncation: false
   };
 }
-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()
+var openaiResponsesProviderOptionsSchema = import_zod9.z.object({
+  metadata: import_zod9.z.any().nullish(),
+  parallelToolCalls: import_zod9.z.boolean().nullish(),
+  previousResponseId: import_zod9.z.string().nullish(),
+  store: import_zod9.z.boolean().nullish(),
+  user: import_zod9.z.string().nullish(),
+  reasoningEffort: import_zod9.z.string().nullish(),
+  strictSchemas: import_zod9.z.boolean().nullish(),
+  instructions: import_zod9.z.string().nullish()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2338,6 +2464,7 @@ var openaiResponsesProviderOptionsSchema = import_zod8.z.object({
   OpenAIEmbeddingModel,
   OpenAIImageModel,
   OpenAIResponsesLanguageModel,
+  OpenAISpeechModel,
   OpenAITranscriptionModel,
   modelMaxImagesPerCall,
   openaiProviderOptions