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

package/dist/internal/index.mjs

@@ -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,16 +595,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 : 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,
@@ -643,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) {
@@ -695,8 +702,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(
@@ -800,8 +807,7 @@ var OpenAIChatLanguageModel = class {
         })
       ),
       request: { body },
-      response: { headers: responseHeaders },
-      warnings
+      response: { headers: responseHeaders }
     };
   }
 };
@@ -1133,7 +1139,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
@@ -1181,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";
@@ -1210,8 +1219,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(
@@ -1232,9 +1241,8 @@ var OpenAICompletionLanguageModel = class {
           }
         })
       ),
-      response: { headers: responseHeaders },
-      warnings,
-      request: { body: JSON.stringify(body) }
+      request: { body },
+      response: { headers: responseHeaders }
     };
   }
 };
@@ -1295,7 +1303,7 @@ import {
 import { z as z5 } from "zod";
 var OpenAIEmbeddingModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
     this.modelId = modelId;
     this.settings = settings;
     this.config = config;
@@ -1324,7 +1332,11 @@ var OpenAIEmbeddingModel = class {
         values
       });
     }
-    const { responseHeaders, value: response } = await postJsonToApi3({
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await postJsonToApi3({
       url: this.config.url({
         path: "/embeddings",
         modelId: this.modelId
@@ -1347,7 +1359,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 }
     };
   }
 };
@@ -1453,7 +1465,7 @@ import {
   postFormDataToApi
 } from "@ai-sdk/provider-utils";
 import { z as z7 } from "zod";
-var OpenAIProviderOptionsSchema = z7.object({
+var openAIProviderOptionsSchema = z7.object({
   include: z7.array(z7.string()).nullish(),
   language: z7.string().nullish(),
   prompt: z7.string().nullish(),
@@ -1538,7 +1550,7 @@ var OpenAITranscriptionModel = class {
     const openAIOptions = parseProviderOptions2({
       provider: "openai",
       providerOptions,
-      schema: OpenAIProviderOptionsSchema
+      schema: openAIProviderOptionsSchema
     });
     const formData = new FormData();
     const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
@@ -1619,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 {
@@ -1892,7 +2008,7 @@ var OpenAIResponsesLanguageModel = class {
       systemMessageMode: modelConfig.systemMessageMode
     });
     warnings.push(...messageWarnings);
-    const openaiOptions = parseProviderOptions3({
+    const openaiOptions = parseProviderOptions4({
       provider: "openai",
       providerOptions,
       schema: openaiResponsesProviderOptionsSchema
@@ -1967,95 +2083,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) => ({
-      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: 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 : 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
@@ -2071,8 +2201,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
@@ -2080,12 +2210,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
@@ -2111,6 +2241,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) {
@@ -2154,8 +2287,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;
@@ -2179,12 +2312,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 : generateId2(),
-                  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 : generateId2(),
+                url: value.annotation.url,
+                title: value.annotation.title
               });
             }
           },
@@ -2207,84 +2338,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,
@@ -2292,7 +2422,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) {
@@ -2337,15 +2467,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,
@@ -2353,6 +2483,7 @@ export {
   OpenAIEmbeddingModel,
   OpenAIImageModel,
   OpenAIResponsesLanguageModel,
+  OpenAISpeechModel,
   OpenAITranscriptionModel,
   modelMaxImagesPerCall,
   openaiProviderOptions