@ai-sdk/openai 2.0.0-canary.7 → 2.0.0-canary.9

package/dist/internal/index.mjs

@@ -515,13 +515,13 @@ var OpenAIChatLanguageModel = class {
         }
         baseArgs.max_tokens = void 0;
       }
-    } else if (this.modelId.startsWith("gpt-4o-search-preview")) {
+    } else if (this.modelId.startsWith("gpt-4o-search-preview") || this.modelId.startsWith("gpt-4o-mini-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."
+          details: "temperature is not supported for the search preview models and has been removed."
         });
       }
     }
@@ -544,7 +544,7 @@ var OpenAIChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const { args: body, warnings } = this.getArgs(options);
     const {
       responseHeaders,
@@ -564,10 +564,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 : 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;
@@ -582,21 +595,11 @@ var OpenAIChatLanguageModel = class {
       providerMetadata.openai.cachedPromptTokens = promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens;
     }
     return {
-      text: choice.message.content != null ? { type: "text", text: choice.message.content } : void 0,
-      toolCalls: (_c = choice.message.tool_calls) == null ? void 0 : _c.map((toolCall) => {
-        var _a2;
-        return {
-          type: "tool-call",
-          toolCallType: "function",
-          toolCallId: (_a2 = toolCall.id) != null ? _a2 : generateId(),
-          toolName: toolCall.function.name,
-          args: toolCall.function.arguments
-        };
-      }),
+      content,
       finishReason: mapOpenAIFinishReason(choice.finish_reason),
       usage: {
-        inputTokens: (_e = (_d = response.usage) == null ? void 0 : _d.prompt_tokens) != null ? _e : void 0,
-        outputTokens: (_g = (_f = response.usage) == null ? void 0 : _f.completion_tokens) != null ? _g : void 0
+        inputTokens: (_f = (_e = response.usage) == null ? void 0 : _e.prompt_tokens) != null ? _f : void 0,
+        outputTokens: (_h = (_g = response.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : void 0
       },
       request: { body },
       response: {
@@ -644,6 +647,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) {
@@ -801,8 +807,7 @@ var OpenAIChatLanguageModel = class {
         })
       ),
       request: { body },
-      response: { headers: responseHeaders },
-      warnings
+      response: { headers: responseHeaders }
     };
   }
 };
@@ -903,7 +908,7 @@ var openaiChatChunkSchema = z3.union([
   openaiErrorDataSchema
 ]);
 function isReasoningModel(modelId) {
-  return modelId === "o1" || modelId.startsWith("o1-") || modelId === "o3" || modelId.startsWith("o3-");
+  return modelId.startsWith("o");
 }
 function isAudioModel(modelId) {
   return modelId.startsWith("gpt-4o-audio-preview");
@@ -1134,7 +1139,7 @@ var OpenAICompletionLanguageModel = class {
     });
     const choice = response.choices[0];
     return {
-      text: { type: "text", text: choice.text },
+      content: [{ type: "text", text: choice.text }],
       usage: {
         inputTokens: response.usage.prompt_tokens,
         outputTokens: response.usage.completion_tokens
@@ -1182,6 +1187,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";
@@ -1233,9 +1241,8 @@ var OpenAICompletionLanguageModel = class {
           }
         })
       ),
-      response: { headers: responseHeaders },
-      warnings,
-      request: { body: JSON.stringify(body) }
+      request: { body },
+      response: { headers: responseHeaders }
     };
   }
 };
@@ -1624,16 +1631,120 @@ var openaiTranscriptionResponseSchema = z7.object({
   ).nullish()
 });
 
-// src/responses/openai-responses-language-model.ts
+// src/openai-speech-model.ts
 import {
   combineHeaders as combineHeaders6,
-  createEventSourceResponseHandler as createEventSourceResponseHandler3,
-  createJsonResponseHandler as createJsonResponseHandler6,
-  generateId as generateId2,
+  createBinaryResponseHandler,
   parseProviderOptions as parseProviderOptions3,
   postJsonToApi as postJsonToApi5
 } from "@ai-sdk/provider-utils";
 import { z as z8 } from "zod";
+var OpenAIProviderOptionsSchema = z8.object({
+  instructions: z8.string().nullish(),
+  speed: z8.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 = parseProviderOptions3({
+      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 postJsonToApi5({
+      url: this.config.url({
+        path: "/audio/speech",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders6(this.config.headers(), options.headers),
+      body: requestBody,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: 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
+import {
+  combineHeaders as combineHeaders7,
+  createEventSourceResponseHandler as createEventSourceResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler6,
+  generateId as generateId2,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi6
+} from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod";
 
 // src/responses/convert-to-openai-responses-messages.ts
 import {
@@ -1847,6 +1958,7 @@ var OpenAIResponsesLanguageModel = class {
   constructor(modelId, config) {
     this.specificationVersion = "v2";
     this.defaultObjectGenerationMode = "json";
+    this.supportsStructuredOutputs = true;
     this.modelId = modelId;
     this.config = config;
   }
@@ -1897,7 +2009,7 @@ var OpenAIResponsesLanguageModel = class {
       systemMessageMode: modelConfig.systemMessageMode
     });
     warnings.push(...messageWarnings);
-    const openaiOptions = parseProviderOptions3({
+    const openaiOptions = parseProviderOptions4({
       provider: "openai",
       providerOptions,
       schema: openaiResponsesProviderOptionsSchema
@@ -1972,100 +2084,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 postJsonToApi5({
+    } = await postJsonToApi6({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: combineHeaders6(this.config.headers(), options.headers),
+      headers: combineHeaders7(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
       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()
+        z9.object({
+          id: z9.string(),
+          created_at: z9.number(),
+          model: z9.string(),
+          output: z9.array(
+            z9.discriminatedUnion("type", [
+              z9.object({
+                type: z9.literal("message"),
+                role: z9.literal("assistant"),
+                content: z9.array(
+                  z9.object({
+                    type: z9.literal("output_text"),
+                    text: z9.string(),
+                    annotations: z9.array(
+                      z9.object({
+                        type: z9.literal("url_citation"),
+                        start_index: z9.number(),
+                        end_index: z9.number(),
+                        url: z9.string(),
+                        title: z9.string()
                       })
                     )
                   })
                 )
               }),
-              z8.object({
-                type: z8.literal("function_call"),
-                call_id: z8.string(),
-                name: z8.string(),
-                arguments: z8.string()
+              z9.object({
+                type: z9.literal("function_call"),
+                call_id: z9.string(),
+                name: z9.string(),
+                arguments: z9.string()
               }),
-              z8.object({
-                type: z8.literal("web_search_call")
+              z9.object({
+                type: z9.literal("web_search_call")
               }),
-              z8.object({
-                type: z8.literal("computer_call")
+              z9.object({
+                type: z9.literal("computer_call")
               }),
-              z8.object({
-                type: z8.literal("reasoning")
+              z9.object({
+                type: z9.literal("reasoning")
               })
             ])
           ),
-          incomplete_details: z8.object({ reason: z8.string() }).nullable(),
+          incomplete_details: z9.object({ reason: z9.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) => ({
-      type: "tool-call",
-      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 : generateId2(),
+                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: {
-        type: "text",
-        text: outputTextElements.map((content) => content.text).join("\n")
-      },
-      sources: outputTextElements.flatMap(
-        (content) => content.annotations.map((annotation) => {
-          var _a2, _b2, _c2;
-          return {
-            type: "source",
-            sourceType: "url",
-            id: (_c2 = (_b2 = (_a2 = this.config).generateId) == null ? void 0 : _b2.call(_a2)) != null ? _c2 : generateId2(),
-            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
@@ -2081,8 +2202,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
@@ -2090,12 +2211,12 @@ var OpenAIResponsesLanguageModel = class {
   }
   async doStream(options) {
     const { args: body, warnings } = this.getArgs(options);
-    const { responseHeaders, value: response } = await postJsonToApi5({
+    const { responseHeaders, value: response } = await postJsonToApi6({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: combineHeaders6(this.config.headers(), options.headers),
+      headers: combineHeaders7(this.config.headers(), options.headers),
       body: {
         ...body,
         stream: true
@@ -2121,6 +2242,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) {
@@ -2215,84 +2339,83 @@ var OpenAIResponsesLanguageModel = class {
         })
       ),
       request: { body },
-      response: { headers: responseHeaders },
-      warnings
+      response: { headers: responseHeaders }
     };
   }
 };
-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 usageSchema = z9.object({
+  input_tokens: z9.number(),
+  input_tokens_details: z9.object({ cached_tokens: z9.number().nullish() }).nullish(),
+  output_tokens: z9.number(),
+  output_tokens_details: z9.object({ reasoning_tokens: z9.number().nullish() }).nullish()
 });
-var textDeltaChunkSchema = z8.object({
-  type: z8.literal("response.output_text.delta"),
-  delta: z8.string()
+var textDeltaChunkSchema = z9.object({
+  type: z9.literal("response.output_text.delta"),
+  delta: z9.string()
 });
-var responseFinishedChunkSchema = z8.object({
-  type: z8.enum(["response.completed", "response.incomplete"]),
-  response: z8.object({
-    incomplete_details: z8.object({ reason: z8.string() }).nullish(),
+var responseFinishedChunkSchema = z9.object({
+  type: z9.enum(["response.completed", "response.incomplete"]),
+  response: z9.object({
+    incomplete_details: z9.object({ reason: z9.string() }).nullish(),
     usage: usageSchema
   })
 });
-var responseCreatedChunkSchema = z8.object({
-  type: z8.literal("response.created"),
-  response: z8.object({
-    id: z8.string(),
-    created_at: z8.number(),
-    model: z8.string()
+var responseCreatedChunkSchema = z9.object({
+  type: z9.literal("response.created"),
+  response: z9.object({
+    id: z9.string(),
+    created_at: z9.number(),
+    model: z9.string()
   })
 });
-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")
+var responseOutputItemDoneSchema = z9.object({
+  type: z9.literal("response.output_item.done"),
+  output_index: z9.number(),
+  item: z9.discriminatedUnion("type", [
+    z9.object({
+      type: z9.literal("message")
     }),
-    z8.object({
-      type: z8.literal("function_call"),
-      id: z8.string(),
-      call_id: z8.string(),
-      name: z8.string(),
-      arguments: z8.string(),
-      status: z8.literal("completed")
+    z9.object({
+      type: z9.literal("function_call"),
+      id: z9.string(),
+      call_id: z9.string(),
+      name: z9.string(),
+      arguments: z9.string(),
+      status: z9.literal("completed")
     })
   ])
 });
-var responseFunctionCallArgumentsDeltaSchema = z8.object({
-  type: z8.literal("response.function_call_arguments.delta"),
-  item_id: z8.string(),
-  output_index: z8.number(),
-  delta: z8.string()
+var responseFunctionCallArgumentsDeltaSchema = z9.object({
+  type: z9.literal("response.function_call_arguments.delta"),
+  item_id: z9.string(),
+  output_index: z9.number(),
+  delta: z9.string()
 });
-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")
+var responseOutputItemAddedSchema = z9.object({
+  type: z9.literal("response.output_item.added"),
+  output_index: z9.number(),
+  item: z9.discriminatedUnion("type", [
+    z9.object({
+      type: z9.literal("message")
     }),
-    z8.object({
-      type: z8.literal("function_call"),
-      id: z8.string(),
-      call_id: z8.string(),
-      name: z8.string(),
-      arguments: z8.string()
+    z9.object({
+      type: z9.literal("function_call"),
+      id: z9.string(),
+      call_id: z9.string(),
+      name: z9.string(),
+      arguments: z9.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 responseAnnotationAddedSchema = z9.object({
+  type: z9.literal("response.output_text.annotation.added"),
+  annotation: z9.object({
+    type: z9.literal("url_citation"),
+    url: z9.string(),
+    title: z9.string()
   })
 });
-var openaiResponsesChunkSchema = z8.union([
+var openaiResponsesChunkSchema = z9.union([
   textDeltaChunkSchema,
   responseFinishedChunkSchema,
   responseCreatedChunkSchema,
@@ -2300,7 +2423,7 @@ var openaiResponsesChunkSchema = z8.union([
   responseFunctionCallArgumentsDeltaSchema,
   responseOutputItemAddedSchema,
   responseAnnotationAddedSchema,
-  z8.object({ type: z8.string() }).passthrough()
+  z9.object({ type: z9.string() }).passthrough()
   // fallback for unknown chunks
 ]);
 function isTextDeltaChunk(chunk) {
@@ -2345,15 +2468,15 @@ function getResponsesModelConfig(modelId) {
     requiredAutoTruncation: false
   };
 }
-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()
+var openaiResponsesProviderOptionsSchema = z9.object({
+  metadata: z9.any().nullish(),
+  parallelToolCalls: z9.boolean().nullish(),
+  previousResponseId: z9.string().nullish(),
+  store: z9.boolean().nullish(),
+  user: z9.string().nullish(),
+  reasoningEffort: z9.string().nullish(),
+  strictSchemas: z9.boolean().nullish(),
+  instructions: z9.string().nullish()
 });
 export {
   OpenAIChatLanguageModel,
@@ -2361,6 +2484,7 @@ export {
   OpenAIEmbeddingModel,
   OpenAIImageModel,
   OpenAIResponsesLanguageModel,
+  OpenAISpeechModel,
   OpenAITranscriptionModel,
   modelMaxImagesPerCall,
   openaiProviderOptions