@ai-sdk/openai 2.0.44 → 2.0.45

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -27,25 +37,24 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/openai-provider.ts
-var import_provider_utils17 = require("@ai-sdk/provider-utils");
+var import_provider_utils30 = require("@ai-sdk/provider-utils");
 
 // src/chat/openai-chat-language-model.ts
 var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
 // src/openai-error.ts
-var import_v4 = require("zod/v4");
+var z = __toESM(require("zod/v4"));
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var openaiErrorDataSchema = import_v4.z.object({
-  error: import_v4.z.object({
-    message: import_v4.z.string(),
+var openaiErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
     // The additional information below is handled loosely to support
     // OpenAI-compatible providers that have slightly different error
     // responses:
-    type: import_v4.z.string().nullish(),
-    param: import_v4.z.any().nullish(),
-    code: import_v4.z.union([import_v4.z.string(), import_v4.z.number()]).nullish()
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
   })
 });
 var openaiFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
@@ -261,95 +270,238 @@ function mapOpenAIFinishReason(finishReason) {
   }
 }
 
+// src/chat/openai-chat-api.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var z2 = __toESM(require("zod/v4"));
+var openaiChatResponseSchema = (0, import_provider_utils3.lazyValidator)(
+  () => (0, import_provider_utils3.zodSchema)(
+    z2.object({
+      id: z2.string().nullish(),
+      created: z2.number().nullish(),
+      model: z2.string().nullish(),
+      choices: z2.array(
+        z2.object({
+          message: z2.object({
+            role: z2.literal("assistant").nullish(),
+            content: z2.string().nullish(),
+            tool_calls: z2.array(
+              z2.object({
+                id: z2.string().nullish(),
+                type: z2.literal("function"),
+                function: z2.object({
+                  name: z2.string(),
+                  arguments: z2.string()
+                })
+              })
+            ).nullish(),
+            annotations: z2.array(
+              z2.object({
+                type: z2.literal("url_citation"),
+                start_index: z2.number(),
+                end_index: z2.number(),
+                url: z2.string(),
+                title: z2.string()
+              })
+            ).nullish()
+          }),
+          index: z2.number(),
+          logprobs: z2.object({
+            content: z2.array(
+              z2.object({
+                token: z2.string(),
+                logprob: z2.number(),
+                top_logprobs: z2.array(
+                  z2.object({
+                    token: z2.string(),
+                    logprob: z2.number()
+                  })
+                )
+              })
+            ).nullish()
+          }).nullish(),
+          finish_reason: z2.string().nullish()
+        })
+      ),
+      usage: z2.object({
+        prompt_tokens: z2.number().nullish(),
+        completion_tokens: z2.number().nullish(),
+        total_tokens: z2.number().nullish(),
+        prompt_tokens_details: z2.object({
+          cached_tokens: z2.number().nullish()
+        }).nullish(),
+        completion_tokens_details: z2.object({
+          reasoning_tokens: z2.number().nullish(),
+          accepted_prediction_tokens: z2.number().nullish(),
+          rejected_prediction_tokens: z2.number().nullish()
+        }).nullish()
+      }).nullish()
+    })
+  )
+);
+var openaiChatChunkSchema = (0, import_provider_utils3.lazyValidator)(
+  () => (0, import_provider_utils3.zodSchema)(
+    z2.union([
+      z2.object({
+        id: z2.string().nullish(),
+        created: z2.number().nullish(),
+        model: z2.string().nullish(),
+        choices: z2.array(
+          z2.object({
+            delta: z2.object({
+              role: z2.enum(["assistant"]).nullish(),
+              content: z2.string().nullish(),
+              tool_calls: z2.array(
+                z2.object({
+                  index: z2.number(),
+                  id: z2.string().nullish(),
+                  type: z2.literal("function").nullish(),
+                  function: z2.object({
+                    name: z2.string().nullish(),
+                    arguments: z2.string().nullish()
+                  })
+                })
+              ).nullish(),
+              annotations: z2.array(
+                z2.object({
+                  type: z2.literal("url_citation"),
+                  start_index: z2.number(),
+                  end_index: z2.number(),
+                  url: z2.string(),
+                  title: z2.string()
+                })
+              ).nullish()
+            }).nullish(),
+            logprobs: z2.object({
+              content: z2.array(
+                z2.object({
+                  token: z2.string(),
+                  logprob: z2.number(),
+                  top_logprobs: z2.array(
+                    z2.object({
+                      token: z2.string(),
+                      logprob: z2.number()
+                    })
+                  )
+                })
+              ).nullish()
+            }).nullish(),
+            finish_reason: z2.string().nullish(),
+            index: z2.number()
+          })
+        ),
+        usage: z2.object({
+          prompt_tokens: z2.number().nullish(),
+          completion_tokens: z2.number().nullish(),
+          total_tokens: z2.number().nullish(),
+          prompt_tokens_details: z2.object({
+            cached_tokens: z2.number().nullish()
+          }).nullish(),
+          completion_tokens_details: z2.object({
+            reasoning_tokens: z2.number().nullish(),
+            accepted_prediction_tokens: z2.number().nullish(),
+            rejected_prediction_tokens: z2.number().nullish()
+          }).nullish()
+        }).nullish()
+      }),
+      openaiErrorDataSchema
+    ])
+  )
+);
+
 // src/chat/openai-chat-options.ts
-var import_v42 = require("zod/v4");
-var openaiChatLanguageModelOptions = import_v42.z.object({
-  /**
-   * Modify the likelihood of specified tokens appearing in the completion.
-   *
-   * Accepts a JSON object that maps tokens (specified by their token ID in
-   * the GPT tokenizer) to an associated bias value from -100 to 100.
-   */
-  logitBias: import_v42.z.record(import_v42.z.coerce.number(), import_v42.z.number()).optional(),
-  /**
-   * Return the log probabilities of the tokens.
-   *
-   * Setting to true will return the log probabilities of the tokens that
-   * were generated.
-   *
-   * Setting to a number will return the log probabilities of the top n
-   * tokens that were generated.
-   */
-  logprobs: import_v42.z.union([import_v42.z.boolean(), import_v42.z.number()]).optional(),
-  /**
-   * Whether to enable parallel function calling during tool use. Default to true.
-   */
-  parallelToolCalls: import_v42.z.boolean().optional(),
-  /**
-   * A unique identifier representing your end-user, which can help OpenAI to
-   * monitor and detect abuse.
-   */
-  user: import_v42.z.string().optional(),
-  /**
-   * Reasoning effort for reasoning models. Defaults to `medium`.
-   */
-  reasoningEffort: import_v42.z.enum(["minimal", "low", "medium", "high"]).optional(),
-  /**
-   * Maximum number of completion tokens to generate. Useful for reasoning models.
-   */
-  maxCompletionTokens: import_v42.z.number().optional(),
-  /**
-   * Whether to enable persistence in responses API.
-   */
-  store: import_v42.z.boolean().optional(),
-  /**
-   * Metadata to associate with the request.
-   */
-  metadata: import_v42.z.record(import_v42.z.string().max(64), import_v42.z.string().max(512)).optional(),
-  /**
-   * Parameters for prediction mode.
-   */
-  prediction: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).optional(),
-  /**
-   * Whether to use structured outputs.
-   *
-   * @default true
-   */
-  structuredOutputs: import_v42.z.boolean().optional(),
-  /**
-   * Service tier for the request.
-   * - 'auto': Default service tier
-   * - 'flex': 50% cheaper processing at the cost of increased latency. Only available for o3 and o4-mini models.
-   * - 'priority': Higher-speed processing with predictably low latency at premium cost. Available for Enterprise customers.
-   *
-   * @default 'auto'
-   */
-  serviceTier: import_v42.z.enum(["auto", "flex", "priority"]).optional(),
-  /**
-   * Whether to use strict JSON schema validation.
-   *
-   * @default false
-   */
-  strictJsonSchema: import_v42.z.boolean().optional(),
-  /**
-   * Controls the verbosity of the model's responses.
-   * Lower values will result in more concise responses, while higher values will result in more verbose responses.
-   */
-  textVerbosity: import_v42.z.enum(["low", "medium", "high"]).optional(),
-  /**
-   * A cache key for prompt caching. Allows manual control over prompt caching behavior.
-   * Useful for improving cache hit rates and working around automatic caching issues.
-   */
-  promptCacheKey: import_v42.z.string().optional(),
-  /**
-   * A stable identifier used to help detect users of your application
-   * that may be violating OpenAI's usage policies. The IDs should be a
-   * string that uniquely identifies each user. We recommend hashing their
-   * username or email address, in order to avoid sending us any identifying
-   * information.
-   */
-  safetyIdentifier: import_v42.z.string().optional()
-});
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var z3 = __toESM(require("zod/v4"));
+var openaiChatLanguageModelOptions = (0, import_provider_utils4.lazyValidator)(
+  () => (0, import_provider_utils4.zodSchema)(
+    z3.object({
+      /**
+       * Modify the likelihood of specified tokens appearing in the completion.
+       *
+       * Accepts a JSON object that maps tokens (specified by their token ID in
+       * the GPT tokenizer) to an associated bias value from -100 to 100.
+       */
+      logitBias: z3.record(z3.coerce.number(), z3.number()).optional(),
+      /**
+       * Return the log probabilities of the tokens.
+       *
+       * Setting to true will return the log probabilities of the tokens that
+       * were generated.
+       *
+       * Setting to a number will return the log probabilities of the top n
+       * tokens that were generated.
+       */
+      logprobs: z3.union([z3.boolean(), z3.number()]).optional(),
+      /**
+       * Whether to enable parallel function calling during tool use. Default to true.
+       */
+      parallelToolCalls: z3.boolean().optional(),
+      /**
+       * A unique identifier representing your end-user, which can help OpenAI to
+       * monitor and detect abuse.
+       */
+      user: z3.string().optional(),
+      /**
+       * Reasoning effort for reasoning models. Defaults to `medium`.
+       */
+      reasoningEffort: z3.enum(["minimal", "low", "medium", "high"]).optional(),
+      /**
+       * Maximum number of completion tokens to generate. Useful for reasoning models.
+       */
+      maxCompletionTokens: z3.number().optional(),
+      /**
+       * Whether to enable persistence in responses API.
+       */
+      store: z3.boolean().optional(),
+      /**
+       * Metadata to associate with the request.
+       */
+      metadata: z3.record(z3.string().max(64), z3.string().max(512)).optional(),
+      /**
+       * Parameters for prediction mode.
+       */
+      prediction: z3.record(z3.string(), z3.any()).optional(),
+      /**
+       * Whether to use structured outputs.
+       *
+       * @default true
+       */
+      structuredOutputs: z3.boolean().optional(),
+      /**
+       * Service tier for the request.
+       * - 'auto': Default service tier
+       * - 'flex': 50% cheaper processing at the cost of increased latency. Only available for o3 and o4-mini models.
+       * - 'priority': Higher-speed processing with predictably low latency at premium cost. Available for Enterprise customers.
+       *
+       * @default 'auto'
+       */
+      serviceTier: z3.enum(["auto", "flex", "priority"]).optional(),
+      /**
+       * Whether to use strict JSON schema validation.
+       *
+       * @default false
+       */
+      strictJsonSchema: z3.boolean().optional(),
+      /**
+       * Controls the verbosity of the model's responses.
+       * Lower values will result in more concise responses, while higher values will result in more verbose responses.
+       */
+      textVerbosity: z3.enum(["low", "medium", "high"]).optional(),
+      /**
+       * A cache key for prompt caching. Allows manual control over prompt caching behavior.
+       * Useful for improving cache hit rates and working around automatic caching issues.
+       */
+      promptCacheKey: z3.string().optional(),
+      /**
+       * A stable identifier used to help detect users of your application
+       * that may be violating OpenAI's usage policies. The IDs should be a
+       * string that uniquely identifies each user. We recommend hashing their
+       * username or email address, in order to avoid sending us any identifying
+       * information.
+       */
+      safetyIdentifier: z3.string().optional()
+    })
+  )
+);
 
 // src/chat/openai-chat-prepare-tools.ts
 var import_provider2 = require("@ai-sdk/provider");
@@ -442,7 +594,7 @@ var OpenAIChatLanguageModel = class {
   }) {
     var _a, _b, _c, _d;
     const warnings = [];
-    const openaiOptions = (_a = await (0, import_provider_utils3.parseProviderOptions)({
+    const openaiOptions = (_a = await (0, import_provider_utils5.parseProviderOptions)({
       provider: "openai",
       providerOptions,
       schema: openaiChatLanguageModelOptions
@@ -621,15 +773,15 @@ var OpenAIChatLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await (0, import_provider_utils5.postJsonToApi)({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
         openaiChatResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -644,7 +796,7 @@ var OpenAIChatLanguageModel = class {
     for (const toolCall of (_a = choice.message.tool_calls) != null ? _a : []) {
       content.push({
         type: "tool-call",
-        toolCallId: (_b = toolCall.id) != null ? _b : (0, import_provider_utils3.generateId)(),
+        toolCallId: (_b = toolCall.id) != null ? _b : (0, import_provider_utils5.generateId)(),
         toolName: toolCall.function.name,
         input: toolCall.function.arguments
       });
@@ -653,7 +805,7 @@ var OpenAIChatLanguageModel = class {
       content.push({
         type: "source",
         sourceType: "url",
-        id: (0, import_provider_utils3.generateId)(),
+        id: (0, import_provider_utils5.generateId)(),
         url: annotation.url,
         title: annotation.title
       });
@@ -699,15 +851,15 @@ var OpenAIChatLanguageModel = class {
         include_usage: true
       }
     };
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils5.postJsonToApi)({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils5.createEventSourceResponseHandler)(
         openaiChatChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -832,14 +984,14 @@ var OpenAIChatLanguageModel = class {
                         delta: toolCall2.function.arguments
                       });
                     }
-                    if ((0, import_provider_utils3.isParsableJson)(toolCall2.function.arguments)) {
+                    if ((0, import_provider_utils5.isParsableJson)(toolCall2.function.arguments)) {
                       controller.enqueue({
                         type: "tool-input-end",
                         id: toolCall2.id
                       });
                       controller.enqueue({
                         type: "tool-call",
-                        toolCallId: (_q = toolCall2.id) != null ? _q : (0, import_provider_utils3.generateId)(),
+                        toolCallId: (_q = toolCall2.id) != null ? _q : (0, import_provider_utils5.generateId)(),
                         toolName: toolCall2.function.name,
                         input: toolCall2.function.arguments
                       });
@@ -860,14 +1012,14 @@ var OpenAIChatLanguageModel = class {
                   id: toolCall.id,
                   delta: (_u = toolCallDelta.function.arguments) != null ? _u : ""
                 });
-                if (((_v = toolCall.function) == null ? void 0 : _v.name) != null && ((_w = toolCall.function) == null ? void 0 : _w.arguments) != null && (0, import_provider_utils3.isParsableJson)(toolCall.function.arguments)) {
+                if (((_v = toolCall.function) == null ? void 0 : _v.name) != null && ((_w = toolCall.function) == null ? void 0 : _w.arguments) != null && (0, import_provider_utils5.isParsableJson)(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-input-end",
                     id: toolCall.id
                   });
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallId: (_x = toolCall.id) != null ? _x : (0, import_provider_utils3.generateId)(),
+                    toolCallId: (_x = toolCall.id) != null ? _x : (0, import_provider_utils5.generateId)(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments
                   });
@@ -880,7 +1032,7 @@ var OpenAIChatLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "url",
-                  id: (0, import_provider_utils3.generateId)(),
+                  id: (0, import_provider_utils5.generateId)(),
                   url: annotation.url,
                   title: annotation.title
                 });
@@ -905,121 +1057,6 @@ var OpenAIChatLanguageModel = class {
     };
   }
 };
-var openaiTokenUsageSchema = import_v43.z.object({
-  prompt_tokens: import_v43.z.number().nullish(),
-  completion_tokens: import_v43.z.number().nullish(),
-  total_tokens: import_v43.z.number().nullish(),
-  prompt_tokens_details: import_v43.z.object({
-    cached_tokens: import_v43.z.number().nullish()
-  }).nullish(),
-  completion_tokens_details: import_v43.z.object({
-    reasoning_tokens: import_v43.z.number().nullish(),
-    accepted_prediction_tokens: import_v43.z.number().nullish(),
-    rejected_prediction_tokens: import_v43.z.number().nullish()
-  }).nullish()
-}).nullish();
-var openaiChatResponseSchema = import_v43.z.object({
-  id: import_v43.z.string().nullish(),
-  created: import_v43.z.number().nullish(),
-  model: import_v43.z.string().nullish(),
-  choices: import_v43.z.array(
-    import_v43.z.object({
-      message: import_v43.z.object({
-        role: import_v43.z.literal("assistant").nullish(),
-        content: import_v43.z.string().nullish(),
-        tool_calls: import_v43.z.array(
-          import_v43.z.object({
-            id: import_v43.z.string().nullish(),
-            type: import_v43.z.literal("function"),
-            function: import_v43.z.object({
-              name: import_v43.z.string(),
-              arguments: import_v43.z.string()
-            })
-          })
-        ).nullish(),
-        annotations: import_v43.z.array(
-          import_v43.z.object({
-            type: import_v43.z.literal("url_citation"),
-            start_index: import_v43.z.number(),
-            end_index: import_v43.z.number(),
-            url: import_v43.z.string(),
-            title: import_v43.z.string()
-          })
-        ).nullish()
-      }),
-      index: import_v43.z.number(),
-      logprobs: import_v43.z.object({
-        content: import_v43.z.array(
-          import_v43.z.object({
-            token: import_v43.z.string(),
-            logprob: import_v43.z.number(),
-            top_logprobs: import_v43.z.array(
-              import_v43.z.object({
-                token: import_v43.z.string(),
-                logprob: import_v43.z.number()
-              })
-            )
-          })
-        ).nullish()
-      }).nullish(),
-      finish_reason: import_v43.z.string().nullish()
-    })
-  ),
-  usage: openaiTokenUsageSchema
-});
-var openaiChatChunkSchema = import_v43.z.union([
-  import_v43.z.object({
-    id: import_v43.z.string().nullish(),
-    created: import_v43.z.number().nullish(),
-    model: import_v43.z.string().nullish(),
-    choices: import_v43.z.array(
-      import_v43.z.object({
-        delta: import_v43.z.object({
-          role: import_v43.z.enum(["assistant"]).nullish(),
-          content: import_v43.z.string().nullish(),
-          tool_calls: import_v43.z.array(
-            import_v43.z.object({
-              index: import_v43.z.number(),
-              id: import_v43.z.string().nullish(),
-              type: import_v43.z.literal("function").nullish(),
-              function: import_v43.z.object({
-                name: import_v43.z.string().nullish(),
-                arguments: import_v43.z.string().nullish()
-              })
-            })
-          ).nullish(),
-          annotations: import_v43.z.array(
-            import_v43.z.object({
-              type: import_v43.z.literal("url_citation"),
-              start_index: import_v43.z.number(),
-              end_index: import_v43.z.number(),
-              url: import_v43.z.string(),
-              title: import_v43.z.string()
-            })
-          ).nullish()
-        }).nullish(),
-        logprobs: import_v43.z.object({
-          content: import_v43.z.array(
-            import_v43.z.object({
-              token: import_v43.z.string(),
-              logprob: import_v43.z.number(),
-              top_logprobs: import_v43.z.array(
-                import_v43.z.object({
-                  token: import_v43.z.string(),
-                  logprob: import_v43.z.number()
-                })
-              )
-            })
-          ).nullish()
-        }).nullish(),
-        finish_reason: import_v43.z.string().nullish(),
-        index: import_v43.z.number()
-      })
-    ),
-    usage: openaiTokenUsageSchema
-  }),
-  openaiErrorDataSchema
-]);
 function isReasoningModel(modelId) {
   return (modelId.startsWith("o") || modelId.startsWith("gpt-5")) && !modelId.startsWith("gpt-5-chat");
 }
@@ -1070,8 +1107,7 @@ var reasoningModels = {
 };
 
 // src/completion/openai-completion-language-model.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
 
 // src/completion/convert-to-openai-completion-prompt.ts
 var import_provider4 = require("@ai-sdk/provider");
@@ -1178,48 +1214,111 @@ function mapOpenAIFinishReason2(finishReason) {
   }
 }
 
+// src/completion/openai-completion-api.ts
+var z4 = __toESM(require("zod/v4"));
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var openaiCompletionResponseSchema = (0, import_provider_utils6.lazyValidator)(
+  () => (0, import_provider_utils6.zodSchema)(
+    z4.object({
+      id: z4.string().nullish(),
+      created: z4.number().nullish(),
+      model: z4.string().nullish(),
+      choices: z4.array(
+        z4.object({
+          text: z4.string(),
+          finish_reason: z4.string(),
+          logprobs: z4.object({
+            tokens: z4.array(z4.string()),
+            token_logprobs: z4.array(z4.number()),
+            top_logprobs: z4.array(z4.record(z4.string(), z4.number())).nullish()
+          }).nullish()
+        })
+      ),
+      usage: z4.object({
+        prompt_tokens: z4.number(),
+        completion_tokens: z4.number(),
+        total_tokens: z4.number()
+      }).nullish()
+    })
+  )
+);
+var openaiCompletionChunkSchema = (0, import_provider_utils6.lazyValidator)(
+  () => (0, import_provider_utils6.zodSchema)(
+    z4.union([
+      z4.object({
+        id: z4.string().nullish(),
+        created: z4.number().nullish(),
+        model: z4.string().nullish(),
+        choices: z4.array(
+          z4.object({
+            text: z4.string(),
+            finish_reason: z4.string().nullish(),
+            index: z4.number(),
+            logprobs: z4.object({
+              tokens: z4.array(z4.string()),
+              token_logprobs: z4.array(z4.number()),
+              top_logprobs: z4.array(z4.record(z4.string(), z4.number())).nullish()
+            }).nullish()
+          })
+        ),
+        usage: z4.object({
+          prompt_tokens: z4.number(),
+          completion_tokens: z4.number(),
+          total_tokens: z4.number()
+        }).nullish()
+      }),
+      openaiErrorDataSchema
+    ])
+  )
+);
+
 // src/completion/openai-completion-options.ts
-var import_v44 = require("zod/v4");
-var openaiCompletionProviderOptions = import_v44.z.object({
-  /**
-  Echo back the prompt in addition to the completion.
-     */
-  echo: import_v44.z.boolean().optional(),
-  /**
-  Modify the likelihood of specified tokens appearing in the completion.
-  
-  Accepts a JSON object that maps tokens (specified by their token ID in
-  the GPT tokenizer) to an associated bias value from -100 to 100. You
-  can use this tokenizer tool to convert text to token IDs. Mathematically,
-  the bias is added to the logits generated by the model prior to sampling.
-  The exact effect will vary per model, but values between -1 and 1 should
-  decrease or increase likelihood of selection; values like -100 or 100
-  should result in a ban or exclusive selection of the relevant token.
-  
-  As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
-  token from being generated.
-   */
-  logitBias: import_v44.z.record(import_v44.z.string(), import_v44.z.number()).optional(),
-  /**
-  The suffix that comes after a completion of inserted text.
-   */
-  suffix: import_v44.z.string().optional(),
-  /**
-  A unique identifier representing your end-user, which can help OpenAI to
-  monitor and detect abuse. Learn more.
-   */
-  user: import_v44.z.string().optional(),
-  /**
-  Return the log probabilities of the tokens. Including logprobs will increase
-  the response size and can slow down response times. However, it can
-  be useful to better understand how the model is behaving.
-  Setting to true will return the log probabilities of the tokens that
-  were generated.
-  Setting to a number will return the log probabilities of the top n
-  tokens that were generated.
-     */
-  logprobs: import_v44.z.union([import_v44.z.boolean(), import_v44.z.number()]).optional()
-});
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
+var z5 = __toESM(require("zod/v4"));
+var openaiCompletionProviderOptions = (0, import_provider_utils7.lazyValidator)(
+  () => (0, import_provider_utils7.zodSchema)(
+    z5.object({
+      /**
+      Echo back the prompt in addition to the completion.
+         */
+      echo: z5.boolean().optional(),
+      /**
+      Modify the likelihood of specified tokens appearing in the completion.
+      
+      Accepts a JSON object that maps tokens (specified by their token ID in
+      the GPT tokenizer) to an associated bias value from -100 to 100. You
+      can use this tokenizer tool to convert text to token IDs. Mathematically,
+      the bias is added to the logits generated by the model prior to sampling.
+      The exact effect will vary per model, but values between -1 and 1 should
+      decrease or increase likelihood of selection; values like -100 or 100
+      should result in a ban or exclusive selection of the relevant token.
+      
+      As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
+      token from being generated.
+       */
+      logitBias: z5.record(z5.string(), z5.number()).optional(),
+      /**
+      The suffix that comes after a completion of inserted text.
+       */
+      suffix: z5.string().optional(),
+      /**
+      A unique identifier representing your end-user, which can help OpenAI to
+      monitor and detect abuse. Learn more.
+       */
+      user: z5.string().optional(),
+      /**
+      Return the log probabilities of the tokens. Including logprobs will increase
+      the response size and can slow down response times. However, it can
+      be useful to better understand how the model is behaving.
+      Setting to true will return the log probabilities of the tokens that
+      were generated.
+      Setting to a number will return the log probabilities of the top n
+      tokens that were generated.
+         */
+      logprobs: z5.union([z5.boolean(), z5.number()]).optional()
+    })
+  )
+);
 
 // src/completion/openai-completion-language-model.ts
 var OpenAICompletionLanguageModel = class {
@@ -1254,12 +1353,12 @@ var OpenAICompletionLanguageModel = class {
   }) {
     const warnings = [];
     const openaiOptions = {
-      ...await (0, import_provider_utils4.parseProviderOptions)({
+      ...await (0, import_provider_utils8.parseProviderOptions)({
         provider: "openai",
         providerOptions,
         schema: openaiCompletionProviderOptions
       }),
-      ...await (0, import_provider_utils4.parseProviderOptions)({
+      ...await (0, import_provider_utils8.parseProviderOptions)({
         provider: this.providerOptionsName,
         providerOptions,
         schema: openaiCompletionProviderOptions
@@ -1315,15 +1414,15 @@ var OpenAICompletionLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils4.postJsonToApi)({
+    } = await (0, import_provider_utils8.postJsonToApi)({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils8.combineHeaders)(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils8.createJsonResponseHandler)(
         openaiCompletionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -1361,15 +1460,15 @@ var OpenAICompletionLanguageModel = class {
         include_usage: true
       }
     };
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils8.postJsonToApi)({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils8.combineHeaders)(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createEventSourceResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils8.createEventSourceResponseHandler)(
         openaiCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -1450,69 +1549,42 @@ var OpenAICompletionLanguageModel = class {
     };
   }
 };
-var usageSchema = import_v45.z.object({
-  prompt_tokens: import_v45.z.number(),
-  completion_tokens: import_v45.z.number(),
-  total_tokens: import_v45.z.number()
-});
-var openaiCompletionResponseSchema = import_v45.z.object({
-  id: import_v45.z.string().nullish(),
-  created: import_v45.z.number().nullish(),
-  model: import_v45.z.string().nullish(),
-  choices: import_v45.z.array(
-    import_v45.z.object({
-      text: import_v45.z.string(),
-      finish_reason: import_v45.z.string(),
-      logprobs: import_v45.z.object({
-        tokens: import_v45.z.array(import_v45.z.string()),
-        token_logprobs: import_v45.z.array(import_v45.z.number()),
-        top_logprobs: import_v45.z.array(import_v45.z.record(import_v45.z.string(), import_v45.z.number())).nullish()
-      }).nullish()
-    })
-  ),
-  usage: usageSchema.nullish()
-});
-var openaiCompletionChunkSchema = import_v45.z.union([
-  import_v45.z.object({
-    id: import_v45.z.string().nullish(),
-    created: import_v45.z.number().nullish(),
-    model: import_v45.z.string().nullish(),
-    choices: import_v45.z.array(
-      import_v45.z.object({
-        text: import_v45.z.string(),
-        finish_reason: import_v45.z.string().nullish(),
-        index: import_v45.z.number(),
-        logprobs: import_v45.z.object({
-          tokens: import_v45.z.array(import_v45.z.string()),
-          token_logprobs: import_v45.z.array(import_v45.z.number()),
-          top_logprobs: import_v45.z.array(import_v45.z.record(import_v45.z.string(), import_v45.z.number())).nullish()
-        }).nullish()
-      })
-    ),
-    usage: usageSchema.nullish()
-  }),
-  openaiErrorDataSchema
-]);
 
 // src/embedding/openai-embedding-model.ts
 var import_provider5 = require("@ai-sdk/provider");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
 
 // src/embedding/openai-embedding-options.ts
-var import_v46 = require("zod/v4");
-var openaiEmbeddingProviderOptions = import_v46.z.object({
-  /**
-  The number of dimensions the resulting output embeddings should have.
-  Only supported in text-embedding-3 and later models.
-     */
-  dimensions: import_v46.z.number().optional(),
-  /**
-  A unique identifier representing your end-user, which can help OpenAI to
-  monitor and detect abuse. Learn more.
-  */
-  user: import_v46.z.string().optional()
-});
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var z6 = __toESM(require("zod/v4"));
+var openaiEmbeddingProviderOptions = (0, import_provider_utils9.lazyValidator)(
+  () => (0, import_provider_utils9.zodSchema)(
+    z6.object({
+      /**
+      The number of dimensions the resulting output embeddings should have.
+      Only supported in text-embedding-3 and later models.
+         */
+      dimensions: z6.number().optional(),
+      /**
+      A unique identifier representing your end-user, which can help OpenAI to
+      monitor and detect abuse. Learn more.
+      */
+      user: z6.string().optional()
+    })
+  )
+);
+
+// src/embedding/openai-embedding-api.ts
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var z7 = __toESM(require("zod/v4"));
+var openaiTextEmbeddingResponseSchema = (0, import_provider_utils10.lazyValidator)(
+  () => (0, import_provider_utils10.zodSchema)(
+    z7.object({
+      data: z7.array(z7.object({ embedding: z7.array(z7.number()) })),
+      usage: z7.object({ prompt_tokens: z7.number() }).nullish()
+    })
+  )
+);
 
 // src/embedding/openai-embedding-model.ts
 var OpenAIEmbeddingModel = class {
@@ -1541,7 +1613,7 @@ var OpenAIEmbeddingModel = class {
         values
       });
     }
-    const openaiOptions = (_a = await (0, import_provider_utils5.parseProviderOptions)({
+    const openaiOptions = (_a = await (0, import_provider_utils11.parseProviderOptions)({
       provider: "openai",
       providerOptions,
       schema: openaiEmbeddingProviderOptions
@@ -1550,12 +1622,12 @@ var OpenAIEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils5.postJsonToApi)({
+    } = await (0, import_provider_utils11.postJsonToApi)({
       url: this.config.url({
         path: "/embeddings",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), headers),
+      headers: (0, import_provider_utils11.combineHeaders)(this.config.headers(), headers),
       body: {
         model: this.modelId,
         input: values,
@@ -1564,7 +1636,7 @@ var OpenAIEmbeddingModel = class {
         user: openaiOptions.user
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils11.createJsonResponseHandler)(
         openaiTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -1577,14 +1649,25 @@ var OpenAIEmbeddingModel = class {
     };
   }
 };
-var openaiTextEmbeddingResponseSchema = import_v47.z.object({
-  data: import_v47.z.array(import_v47.z.object({ embedding: import_v47.z.array(import_v47.z.number()) })),
-  usage: import_v47.z.object({ prompt_tokens: import_v47.z.number() }).nullish()
-});
 
 // src/image/openai-image-model.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
+var import_provider_utils13 = require("@ai-sdk/provider-utils");
+
+// src/image/openai-image-api.ts
+var import_provider_utils12 = require("@ai-sdk/provider-utils");
+var z8 = __toESM(require("zod/v4"));
+var openaiImageResponseSchema = (0, import_provider_utils12.lazyValidator)(
+  () => (0, import_provider_utils12.zodSchema)(
+    z8.object({
+      data: z8.array(
+        z8.object({
+          b64_json: z8.string(),
+          revised_prompt: z8.string().optional()
+        })
+      )
+    })
+  )
+);
 
 // src/image/openai-image-options.ts
 var modelMaxImagesPerCall = {
@@ -1635,12 +1718,12 @@ var OpenAIImageModel = class {
       warnings.push({ type: "unsupported-setting", setting: "seed" });
     }
     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 { value: response, responseHeaders } = await (0, import_provider_utils6.postJsonToApi)({
+    const { value: response, responseHeaders } = await (0, import_provider_utils13.postJsonToApi)({
       url: this.config.url({
         path: "/images/generations",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils6.combineHeaders)(this.config.headers(), headers),
+      headers: (0, import_provider_utils13.combineHeaders)(this.config.headers(), headers),
       body: {
         model: this.modelId,
         prompt,
@@ -1650,7 +1733,7 @@ var OpenAIImageModel = class {
         ...!hasDefaultResponseFormat.has(this.modelId) ? { response_format: "b64_json" } : {}
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils13.createJsonResponseHandler)(
         openaiImageResponseSchema
       ),
       abortSignal,
@@ -1676,36 +1759,43 @@ var OpenAIImageModel = class {
     };
   }
 };
-var openaiImageResponseSchema = import_v48.z.object({
-  data: import_v48.z.array(
-    import_v48.z.object({ b64_json: import_v48.z.string(), revised_prompt: import_v48.z.string().optional() })
-  )
-});
 
 // src/tool/code-interpreter.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_v49 = require("zod/v4");
-var codeInterpreterInputSchema = import_v49.z.object({
-  code: import_v49.z.string().nullish(),
-  containerId: import_v49.z.string()
-});
-var codeInterpreterOutputSchema = import_v49.z.object({
-  outputs: import_v49.z.array(
-    import_v49.z.discriminatedUnion("type", [
-      import_v49.z.object({ type: import_v49.z.literal("logs"), logs: import_v49.z.string() }),
-      import_v49.z.object({ type: import_v49.z.literal("image"), url: import_v49.z.string() })
-    ])
-  ).nullish()
-});
-var codeInterpreterArgsSchema = import_v49.z.object({
-  container: import_v49.z.union([
-    import_v49.z.string(),
-    import_v49.z.object({
-      fileIds: import_v49.z.array(import_v49.z.string()).optional()
+var import_provider_utils14 = require("@ai-sdk/provider-utils");
+var z9 = __toESM(require("zod/v4"));
+var codeInterpreterInputSchema = (0, import_provider_utils14.lazySchema)(
+  () => (0, import_provider_utils14.zodSchema)(
+    z9.object({
+      code: z9.string().nullish(),
+      containerId: z9.string()
     })
-  ]).optional()
-});
-var codeInterpreterToolFactory = (0, import_provider_utils7.createProviderDefinedToolFactoryWithOutputSchema)({
+  )
+);
+var codeInterpreterOutputSchema = (0, import_provider_utils14.lazySchema)(
+  () => (0, import_provider_utils14.zodSchema)(
+    z9.object({
+      outputs: z9.array(
+        z9.discriminatedUnion("type", [
+          z9.object({ type: z9.literal("logs"), logs: z9.string() }),
+          z9.object({ type: z9.literal("image"), url: z9.string() })
+        ])
+      ).nullish()
+    })
+  )
+);
+var codeInterpreterArgsSchema = (0, import_provider_utils14.lazySchema)(
+  () => (0, import_provider_utils14.zodSchema)(
+    z9.object({
+      container: z9.union([
+        z9.string(),
+        z9.object({
+          fileIds: z9.array(z9.string()).optional()
+        })
+      ]).optional()
+    })
+  )
+);
+var codeInterpreterToolFactory = (0, import_provider_utils14.createProviderDefinedToolFactoryWithOutputSchema)({
   id: "openai.code_interpreter",
   name: "code_interpreter",
   inputSchema: codeInterpreterInputSchema,
@@ -1716,71 +1806,85 @@ var codeInterpreter = (args = {}) => {
 };
 
 // src/tool/file-search.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_v410 = require("zod/v4");
-var comparisonFilterSchema = import_v410.z.object({
-  key: import_v410.z.string(),
-  type: import_v410.z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
-  value: import_v410.z.union([import_v410.z.string(), import_v410.z.number(), import_v410.z.boolean()])
+var import_provider_utils15 = require("@ai-sdk/provider-utils");
+var z10 = __toESM(require("zod/v4"));
+var comparisonFilterSchema = z10.object({
+  key: z10.string(),
+  type: z10.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+  value: z10.union([z10.string(), z10.number(), z10.boolean()])
 });
-var compoundFilterSchema = import_v410.z.object({
-  type: import_v410.z.enum(["and", "or"]),
-  filters: import_v410.z.array(
-    import_v410.z.union([comparisonFilterSchema, import_v410.z.lazy(() => compoundFilterSchema)])
+var compoundFilterSchema = z10.object({
+  type: z10.enum(["and", "or"]),
+  filters: z10.array(
+    z10.union([comparisonFilterSchema, z10.lazy(() => compoundFilterSchema)])
   )
 });
-var fileSearchArgsSchema = import_v410.z.object({
-  vectorStoreIds: import_v410.z.array(import_v410.z.string()),
-  maxNumResults: import_v410.z.number().optional(),
-  ranking: import_v410.z.object({
-    ranker: import_v410.z.string().optional(),
-    scoreThreshold: import_v410.z.number().optional()
-  }).optional(),
-  filters: import_v410.z.union([comparisonFilterSchema, compoundFilterSchema]).optional()
-});
-var fileSearchOutputSchema = import_v410.z.object({
-  queries: import_v410.z.array(import_v410.z.string()),
-  results: import_v410.z.array(
-    import_v410.z.object({
-      attributes: import_v410.z.record(import_v410.z.string(), import_v410.z.unknown()),
-      fileId: import_v410.z.string(),
-      filename: import_v410.z.string(),
-      score: import_v410.z.number(),
-      text: import_v410.z.string()
+var fileSearchArgsSchema = (0, import_provider_utils15.lazySchema)(
+  () => (0, import_provider_utils15.zodSchema)(
+    z10.object({
+      vectorStoreIds: z10.array(z10.string()),
+      maxNumResults: z10.number().optional(),
+      ranking: z10.object({
+        ranker: z10.string().optional(),
+        scoreThreshold: z10.number().optional()
+      }).optional(),
+      filters: z10.union([comparisonFilterSchema, compoundFilterSchema]).optional()
     })
-  ).nullable()
-});
-var fileSearch = (0, import_provider_utils8.createProviderDefinedToolFactoryWithOutputSchema)({
+  )
+);
+var fileSearchOutputSchema = (0, import_provider_utils15.lazySchema)(
+  () => (0, import_provider_utils15.zodSchema)(
+    z10.object({
+      queries: z10.array(z10.string()),
+      results: z10.array(
+        z10.object({
+          attributes: z10.record(z10.string(), z10.unknown()),
+          fileId: z10.string(),
+          filename: z10.string(),
+          score: z10.number(),
+          text: z10.string()
+        })
+      ).nullable()
+    })
+  )
+);
+var fileSearch = (0, import_provider_utils15.createProviderDefinedToolFactoryWithOutputSchema)({
   id: "openai.file_search",
   name: "file_search",
-  inputSchema: import_v410.z.object({}),
+  inputSchema: z10.object({}),
   outputSchema: fileSearchOutputSchema
 });
 
 // src/tool/image-generation.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
-var import_v411 = require("zod/v4");
-var imageGenerationArgsSchema = import_v411.z.object({
-  background: import_v411.z.enum(["auto", "opaque", "transparent"]).optional(),
-  inputFidelity: import_v411.z.enum(["low", "high"]).optional(),
-  inputImageMask: import_v411.z.object({
-    fileId: import_v411.z.string().optional(),
-    imageUrl: import_v411.z.string().optional()
-  }).optional(),
-  model: import_v411.z.string().optional(),
-  moderation: import_v411.z.enum(["auto"]).optional(),
-  outputCompression: import_v411.z.number().int().min(0).max(100).optional(),
-  outputFormat: import_v411.z.enum(["png", "jpeg", "webp"]).optional(),
-  quality: import_v411.z.enum(["auto", "low", "medium", "high"]).optional(),
-  size: import_v411.z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
-}).strict();
-var imageGenerationOutputSchema = import_v411.z.object({
-  result: import_v411.z.string()
-});
-var imageGenerationToolFactory = (0, import_provider_utils9.createProviderDefinedToolFactoryWithOutputSchema)({
+var import_provider_utils16 = require("@ai-sdk/provider-utils");
+var z11 = __toESM(require("zod/v4"));
+var imageGenerationArgsSchema = (0, import_provider_utils16.lazySchema)(
+  () => (0, import_provider_utils16.zodSchema)(
+    z11.object({
+      background: z11.enum(["auto", "opaque", "transparent"]).optional(),
+      inputFidelity: z11.enum(["low", "high"]).optional(),
+      inputImageMask: z11.object({
+        fileId: z11.string().optional(),
+        imageUrl: z11.string().optional()
+      }).optional(),
+      model: z11.string().optional(),
+      moderation: z11.enum(["auto"]).optional(),
+      outputCompression: z11.number().int().min(0).max(100).optional(),
+      outputFormat: z11.enum(["png", "jpeg", "webp"]).optional(),
+      partialImages: z11.number().int().min(0).max(3).optional(),
+      quality: z11.enum(["auto", "low", "medium", "high"]).optional(),
+      size: z11.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+    }).strict()
+  )
+);
+var imageGenerationInputSchema = (0, import_provider_utils16.lazySchema)(() => (0, import_provider_utils16.zodSchema)(z11.object({})));
+var imageGenerationOutputSchema = (0, import_provider_utils16.lazySchema)(
+  () => (0, import_provider_utils16.zodSchema)(z11.object({ result: z11.string() }))
+);
+var imageGenerationToolFactory = (0, import_provider_utils16.createProviderDefinedToolFactoryWithOutputSchema)({
   id: "openai.image_generation",
   name: "image_generation",
-  inputSchema: import_v411.z.object({}),
+  inputSchema: imageGenerationInputSchema,
   outputSchema: imageGenerationOutputSchema
 });
 var imageGeneration = (args = {}) => {
@@ -1788,22 +1892,26 @@ var imageGeneration = (args = {}) => {
 };
 
 // src/tool/local-shell.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var import_v412 = require("zod/v4");
-var localShellInputSchema = import_v412.z.object({
-  action: import_v412.z.object({
-    type: import_v412.z.literal("exec"),
-    command: import_v412.z.array(import_v412.z.string()),
-    timeoutMs: import_v412.z.number().optional(),
-    user: import_v412.z.string().optional(),
-    workingDirectory: import_v412.z.string().optional(),
-    env: import_v412.z.record(import_v412.z.string(), import_v412.z.string()).optional()
-  })
-});
-var localShellOutputSchema = import_v412.z.object({
-  output: import_v412.z.string()
-});
-var localShell = (0, import_provider_utils10.createProviderDefinedToolFactoryWithOutputSchema)({
+var import_provider_utils17 = require("@ai-sdk/provider-utils");
+var z12 = __toESM(require("zod/v4"));
+var localShellInputSchema = (0, import_provider_utils17.lazySchema)(
+  () => (0, import_provider_utils17.zodSchema)(
+    z12.object({
+      action: z12.object({
+        type: z12.literal("exec"),
+        command: z12.array(z12.string()),
+        timeoutMs: z12.number().optional(),
+        user: z12.string().optional(),
+        workingDirectory: z12.string().optional(),
+        env: z12.record(z12.string(), z12.string()).optional()
+      })
+    })
+  )
+);
+var localShellOutputSchema = (0, import_provider_utils17.lazySchema)(
+  () => (0, import_provider_utils17.zodSchema)(z12.object({ output: z12.string() }))
+);
+var localShell = (0, import_provider_utils17.createProviderDefinedToolFactoryWithOutputSchema)({
   id: "openai.local_shell",
   name: "local_shell",
   inputSchema: localShellInputSchema,
@@ -1811,103 +1919,121 @@ var localShell = (0, import_provider_utils10.createProviderDefinedToolFactoryWit
 });
 
 // src/tool/web-search.ts
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
-var import_v413 = require("zod/v4");
-var webSearchArgsSchema = import_v413.z.object({
-  filters: import_v413.z.object({
-    allowedDomains: import_v413.z.array(import_v413.z.string()).optional()
-  }).optional(),
-  searchContextSize: import_v413.z.enum(["low", "medium", "high"]).optional(),
-  userLocation: import_v413.z.object({
-    type: import_v413.z.literal("approximate"),
-    country: import_v413.z.string().optional(),
-    city: import_v413.z.string().optional(),
-    region: import_v413.z.string().optional(),
-    timezone: import_v413.z.string().optional()
-  }).optional()
-});
-var webSearchToolFactory = (0, import_provider_utils11.createProviderDefinedToolFactory)({
+var import_provider_utils18 = require("@ai-sdk/provider-utils");
+var z13 = __toESM(require("zod/v4"));
+var webSearchArgsSchema = (0, import_provider_utils18.lazySchema)(
+  () => (0, import_provider_utils18.zodSchema)(
+    z13.object({
+      filters: z13.object({
+        allowedDomains: z13.array(z13.string()).optional()
+      }).optional(),
+      searchContextSize: z13.enum(["low", "medium", "high"]).optional(),
+      userLocation: z13.object({
+        type: z13.literal("approximate"),
+        country: z13.string().optional(),
+        city: z13.string().optional(),
+        region: z13.string().optional(),
+        timezone: z13.string().optional()
+      }).optional()
+    })
+  )
+);
+var webSearchInputSchema = (0, import_provider_utils18.lazySchema)(
+  () => (0, import_provider_utils18.zodSchema)(
+    z13.object({
+      action: z13.discriminatedUnion("type", [
+        z13.object({
+          type: z13.literal("search"),
+          query: z13.string().nullish()
+        }),
+        z13.object({
+          type: z13.literal("open_page"),
+          url: z13.string()
+        }),
+        z13.object({
+          type: z13.literal("find"),
+          url: z13.string(),
+          pattern: z13.string()
+        })
+      ]).nullish()
+    })
+  )
+);
+var webSearchToolFactory = (0, import_provider_utils18.createProviderDefinedToolFactory)({
   id: "openai.web_search",
   name: "web_search",
-  inputSchema: import_v413.z.object({
-    action: import_v413.z.discriminatedUnion("type", [
-      import_v413.z.object({
-        type: import_v413.z.literal("search"),
-        query: import_v413.z.string().nullish()
-      }),
-      import_v413.z.object({
-        type: import_v413.z.literal("open_page"),
-        url: import_v413.z.string()
-      }),
-      import_v413.z.object({
-        type: import_v413.z.literal("find"),
-        url: import_v413.z.string(),
-        pattern: import_v413.z.string()
-      })
-    ]).nullish()
-  })
+  inputSchema: webSearchInputSchema
 });
 var webSearch = (args = {}) => {
   return webSearchToolFactory(args);
 };
 
 // src/tool/web-search-preview.ts
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
-var import_v414 = require("zod/v4");
-var webSearchPreviewArgsSchema = import_v414.z.object({
-  /**
-   * Search context size to use for the web search.
-   * - high: Most comprehensive context, highest cost, slower response
-   * - medium: Balanced context, cost, and latency (default)
-   * - low: Least context, lowest cost, fastest response
-   */
-  searchContextSize: import_v414.z.enum(["low", "medium", "high"]).optional(),
-  /**
-   * User location information to provide geographically relevant search results.
-   */
-  userLocation: import_v414.z.object({
-    /**
-     * Type of location (always 'approximate')
-     */
-    type: import_v414.z.literal("approximate"),
-    /**
-     * Two-letter ISO country code (e.g., 'US', 'GB')
-     */
-    country: import_v414.z.string().optional(),
-    /**
-     * City name (free text, e.g., 'Minneapolis')
-     */
-    city: import_v414.z.string().optional(),
-    /**
-     * Region name (free text, e.g., 'Minnesota')
-     */
-    region: import_v414.z.string().optional(),
-    /**
-     * IANA timezone (e.g., 'America/Chicago')
-     */
-    timezone: import_v414.z.string().optional()
-  }).optional()
-});
-var webSearchPreview = (0, import_provider_utils12.createProviderDefinedToolFactory)({
+var import_provider_utils19 = require("@ai-sdk/provider-utils");
+var z14 = __toESM(require("zod/v4"));
+var webSearchPreviewArgsSchema = (0, import_provider_utils19.lazySchema)(
+  () => (0, import_provider_utils19.zodSchema)(
+    z14.object({
+      /**
+       * Search context size to use for the web search.
+       * - high: Most comprehensive context, highest cost, slower response
+       * - medium: Balanced context, cost, and latency (default)
+       * - low: Least context, lowest cost, fastest response
+       */
+      searchContextSize: z14.enum(["low", "medium", "high"]).optional(),
+      /**
+       * User location information to provide geographically relevant search results.
+       */
+      userLocation: z14.object({
+        /**
+         * Type of location (always 'approximate')
+         */
+        type: z14.literal("approximate"),
+        /**
+         * Two-letter ISO country code (e.g., 'US', 'GB')
+         */
+        country: z14.string().optional(),
+        /**
+         * City name (free text, e.g., 'Minneapolis')
+         */
+        city: z14.string().optional(),
+        /**
+         * Region name (free text, e.g., 'Minnesota')
+         */
+        region: z14.string().optional(),
+        /**
+         * IANA timezone (e.g., 'America/Chicago')
+         */
+        timezone: z14.string().optional()
+      }).optional()
+    })
+  )
+);
+var webSearchPreviewInputSchema = (0, import_provider_utils19.lazySchema)(
+  () => (0, import_provider_utils19.zodSchema)(
+    z14.object({
+      action: z14.discriminatedUnion("type", [
+        z14.object({
+          type: z14.literal("search"),
+          query: z14.string().nullish()
+        }),
+        z14.object({
+          type: z14.literal("open_page"),
+          url: z14.string()
+        }),
+        z14.object({
+          type: z14.literal("find"),
+          url: z14.string(),
+          pattern: z14.string()
+        })
+      ]).nullish()
+    })
+  )
+);
+var webSearchPreview = (0, import_provider_utils19.createProviderDefinedToolFactory)({
   id: "openai.web_search_preview",
   name: "web_search_preview",
-  inputSchema: import_v414.z.object({
-    action: import_v414.z.discriminatedUnion("type", [
-      import_v414.z.object({
-        type: import_v414.z.literal("search"),
-        query: import_v414.z.string().nullish()
-      }),
-      import_v414.z.object({
-        type: import_v414.z.literal("open_page"),
-        url: import_v414.z.string()
-      }),
-      import_v414.z.object({
-        type: import_v414.z.literal("find"),
-        url: import_v414.z.string(),
-        pattern: import_v414.z.string()
-      })
-    ]).nullish()
-  })
+  inputSchema: webSearchPreviewInputSchema
 });
 
 // src/openai-tools.ts
@@ -1985,13 +2111,12 @@ var openaiTools = {
 
 // src/responses/openai-responses-language-model.ts
 var import_provider8 = require("@ai-sdk/provider");
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
-var import_v416 = require("zod/v4");
+var import_provider_utils24 = require("@ai-sdk/provider-utils");
 
 // src/responses/convert-to-openai-responses-input.ts
 var import_provider6 = require("@ai-sdk/provider");
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
-var import_v415 = require("zod/v4");
+var import_provider_utils20 = require("@ai-sdk/provider-utils");
+var z15 = __toESM(require("zod/v4"));
 function isFileId(data, prefixes) {
   if (!prefixes) return false;
   return prefixes.some((prefix) => data.startsWith(prefix));
@@ -2049,7 +2174,7 @@ async function convertToOpenAIResponsesInput({
                   return {
                     type: "input_image",
                     ...part.data instanceof URL ? { image_url: part.data.toString() } : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
-                      image_url: `data:${mediaType};base64,${(0, import_provider_utils13.convertToBase64)(part.data)}`
+                      image_url: `data:${mediaType};base64,${(0, import_provider_utils20.convertToBase64)(part.data)}`
                     },
                     detail: (_b2 = (_a2 = part.providerOptions) == null ? void 0 : _a2.openai) == null ? void 0 : _b2.imageDetail
                   };
@@ -2064,7 +2189,7 @@ async function convertToOpenAIResponsesInput({
                     type: "input_file",
                     ...typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
                       filename: (_c2 = part.filename) != null ? _c2 : `part-${index}.pdf`,
-                      file_data: `data:application/pdf;base64,${(0, import_provider_utils13.convertToBase64)(part.data)}`
+                      file_data: `data:application/pdf;base64,${(0, import_provider_utils20.convertToBase64)(part.data)}`
                     }
                   };
                 } else {
@@ -2097,7 +2222,10 @@ async function convertToOpenAIResponsesInput({
                 break;
               }
               if (hasLocalShellTool && part.toolName === "local_shell") {
-                const parsedInput = localShellInputSchema.parse(part.input);
+                const parsedInput = await (0, import_provider_utils20.validateTypes)({
+                  value: part.input,
+                  schema: localShellInputSchema
+                });
                 input.push({
                   type: "local_shell_call",
                   call_id: part.toolCallId,
@@ -2135,7 +2263,7 @@ async function convertToOpenAIResponsesInput({
               break;
             }
             case "reasoning": {
-              const providerOptions = await (0, import_provider_utils13.parseProviderOptions)({
+              const providerOptions = await (0, import_provider_utils20.parseProviderOptions)({
                 provider: "openai",
                 providerOptions: part.providerOptions,
                 schema: openaiResponsesReasoningProviderOptionsSchema
@@ -2193,10 +2321,14 @@ async function convertToOpenAIResponsesInput({
         for (const part of content) {
           const output = part.output;
           if (hasLocalShellTool && part.toolName === "local_shell" && output.type === "json") {
+            const parsedOutput = await (0, import_provider_utils20.validateTypes)({
+              value: output.value,
+              schema: localShellOutputSchema
+            });
             input.push({
               type: "local_shell_call_output",
               call_id: part.toolCallId,
-              output: localShellOutputSchema.parse(output.value).output
+              output: parsedOutput.output
             });
             break;
           }
@@ -2228,9 +2360,9 @@ async function convertToOpenAIResponsesInput({
   }
   return { input, warnings };
 }
-var openaiResponsesReasoningProviderOptionsSchema = import_v415.z.object({
-  itemId: import_v415.z.string().nullish(),
-  reasoningEncryptedContent: import_v415.z.string().nullish()
+var openaiResponsesReasoningProviderOptionsSchema = z15.object({
+  itemId: z15.string().nullish(),
+  reasoningEncryptedContent: z15.string().nullish()
 });
 
 // src/responses/map-openai-responses-finish-reason.ts
@@ -2251,9 +2383,539 @@ function mapOpenAIResponseFinishReason({
   }
 }
 
+// src/responses/openai-responses-api.ts
+var import_provider_utils21 = require("@ai-sdk/provider-utils");
+var z16 = __toESM(require("zod/v4"));
+var openaiResponsesChunkSchema = (0, import_provider_utils21.lazyValidator)(
+  () => (0, import_provider_utils21.zodSchema)(
+    z16.union([
+      z16.object({
+        type: z16.literal("response.output_text.delta"),
+        item_id: z16.string(),
+        delta: z16.string(),
+        logprobs: z16.array(
+          z16.object({
+            token: z16.string(),
+            logprob: z16.number(),
+            top_logprobs: z16.array(
+              z16.object({
+                token: z16.string(),
+                logprob: z16.number()
+              })
+            )
+          })
+        ).nullish()
+      }),
+      z16.object({
+        type: z16.enum(["response.completed", "response.incomplete"]),
+        response: z16.object({
+          incomplete_details: z16.object({ reason: z16.string() }).nullish(),
+          usage: z16.object({
+            input_tokens: z16.number(),
+            input_tokens_details: z16.object({ cached_tokens: z16.number().nullish() }).nullish(),
+            output_tokens: z16.number(),
+            output_tokens_details: z16.object({ reasoning_tokens: z16.number().nullish() }).nullish()
+          }),
+          service_tier: z16.string().nullish()
+        })
+      }),
+      z16.object({
+        type: z16.literal("response.created"),
+        response: z16.object({
+          id: z16.string(),
+          created_at: z16.number(),
+          model: z16.string(),
+          service_tier: z16.string().nullish()
+        })
+      }),
+      z16.object({
+        type: z16.literal("response.output_item.added"),
+        output_index: z16.number(),
+        item: z16.discriminatedUnion("type", [
+          z16.object({
+            type: z16.literal("message"),
+            id: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("reasoning"),
+            id: z16.string(),
+            encrypted_content: z16.string().nullish()
+          }),
+          z16.object({
+            type: z16.literal("function_call"),
+            id: z16.string(),
+            call_id: z16.string(),
+            name: z16.string(),
+            arguments: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("web_search_call"),
+            id: z16.string(),
+            status: z16.string(),
+            action: z16.object({
+              type: z16.literal("search"),
+              query: z16.string().optional()
+            }).nullish()
+          }),
+          z16.object({
+            type: z16.literal("computer_call"),
+            id: z16.string(),
+            status: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("file_search_call"),
+            id: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("image_generation_call"),
+            id: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("code_interpreter_call"),
+            id: z16.string(),
+            container_id: z16.string(),
+            code: z16.string().nullable(),
+            outputs: z16.array(
+              z16.discriminatedUnion("type", [
+                z16.object({ type: z16.literal("logs"), logs: z16.string() }),
+                z16.object({ type: z16.literal("image"), url: z16.string() })
+              ])
+            ).nullable(),
+            status: z16.string()
+          })
+        ])
+      }),
+      z16.object({
+        type: z16.literal("response.output_item.done"),
+        output_index: z16.number(),
+        item: z16.discriminatedUnion("type", [
+          z16.object({
+            type: z16.literal("message"),
+            id: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("reasoning"),
+            id: z16.string(),
+            encrypted_content: z16.string().nullish()
+          }),
+          z16.object({
+            type: z16.literal("function_call"),
+            id: z16.string(),
+            call_id: z16.string(),
+            name: z16.string(),
+            arguments: z16.string(),
+            status: z16.literal("completed")
+          }),
+          z16.object({
+            type: z16.literal("code_interpreter_call"),
+            id: z16.string(),
+            code: z16.string().nullable(),
+            container_id: z16.string(),
+            outputs: z16.array(
+              z16.discriminatedUnion("type", [
+                z16.object({ type: z16.literal("logs"), logs: z16.string() }),
+                z16.object({ type: z16.literal("image"), url: z16.string() })
+              ])
+            ).nullable()
+          }),
+          z16.object({
+            type: z16.literal("image_generation_call"),
+            id: z16.string(),
+            result: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("web_search_call"),
+            id: z16.string(),
+            status: z16.string(),
+            action: z16.discriminatedUnion("type", [
+              z16.object({
+                type: z16.literal("search"),
+                query: z16.string().nullish()
+              }),
+              z16.object({
+                type: z16.literal("open_page"),
+                url: z16.string()
+              }),
+              z16.object({
+                type: z16.literal("find"),
+                url: z16.string(),
+                pattern: z16.string()
+              })
+            ]).nullish()
+          }),
+          z16.object({
+            type: z16.literal("file_search_call"),
+            id: z16.string(),
+            queries: z16.array(z16.string()),
+            results: z16.array(
+              z16.object({
+                attributes: z16.record(z16.string(), z16.unknown()),
+                file_id: z16.string(),
+                filename: z16.string(),
+                score: z16.number(),
+                text: z16.string()
+              })
+            ).nullish()
+          }),
+          z16.object({
+            type: z16.literal("local_shell_call"),
+            id: z16.string(),
+            call_id: z16.string(),
+            action: z16.object({
+              type: z16.literal("exec"),
+              command: z16.array(z16.string()),
+              timeout_ms: z16.number().optional(),
+              user: z16.string().optional(),
+              working_directory: z16.string().optional(),
+              env: z16.record(z16.string(), z16.string()).optional()
+            })
+          }),
+          z16.object({
+            type: z16.literal("computer_call"),
+            id: z16.string(),
+            status: z16.literal("completed")
+          })
+        ])
+      }),
+      z16.object({
+        type: z16.literal("response.function_call_arguments.delta"),
+        item_id: z16.string(),
+        output_index: z16.number(),
+        delta: z16.string()
+      }),
+      z16.object({
+        type: z16.literal("response.image_generation_call.partial_image"),
+        item_id: z16.string(),
+        output_index: z16.number(),
+        partial_image_b64: z16.string()
+      }),
+      z16.object({
+        type: z16.literal("response.code_interpreter_call_code.delta"),
+        item_id: z16.string(),
+        output_index: z16.number(),
+        delta: z16.string()
+      }),
+      z16.object({
+        type: z16.literal("response.code_interpreter_call_code.done"),
+        item_id: z16.string(),
+        output_index: z16.number(),
+        code: z16.string()
+      }),
+      z16.object({
+        type: z16.literal("response.output_text.annotation.added"),
+        annotation: z16.discriminatedUnion("type", [
+          z16.object({
+            type: z16.literal("url_citation"),
+            url: z16.string(),
+            title: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("file_citation"),
+            file_id: z16.string(),
+            filename: z16.string().nullish(),
+            index: z16.number().nullish(),
+            start_index: z16.number().nullish(),
+            end_index: z16.number().nullish(),
+            quote: z16.string().nullish()
+          })
+        ])
+      }),
+      z16.object({
+        type: z16.literal("response.reasoning_summary_part.added"),
+        item_id: z16.string(),
+        summary_index: z16.number()
+      }),
+      z16.object({
+        type: z16.literal("response.reasoning_summary_text.delta"),
+        item_id: z16.string(),
+        summary_index: z16.number(),
+        delta: z16.string()
+      }),
+      z16.object({
+        type: z16.literal("error"),
+        code: z16.string(),
+        message: z16.string(),
+        param: z16.string().nullish(),
+        sequence_number: z16.number()
+      }),
+      z16.object({ type: z16.string() }).loose().transform((value) => ({
+        type: "unknown_chunk",
+        message: value.type
+      }))
+      // fallback for unknown chunks
+    ])
+  )
+);
+var openaiResponsesResponseSchema = (0, import_provider_utils21.lazyValidator)(
+  () => (0, import_provider_utils21.zodSchema)(
+    z16.object({
+      id: z16.string(),
+      created_at: z16.number(),
+      error: z16.object({
+        code: z16.string(),
+        message: z16.string()
+      }).nullish(),
+      model: z16.string(),
+      output: z16.array(
+        z16.discriminatedUnion("type", [
+          z16.object({
+            type: z16.literal("message"),
+            role: z16.literal("assistant"),
+            id: z16.string(),
+            content: z16.array(
+              z16.object({
+                type: z16.literal("output_text"),
+                text: z16.string(),
+                logprobs: z16.array(
+                  z16.object({
+                    token: z16.string(),
+                    logprob: z16.number(),
+                    top_logprobs: z16.array(
+                      z16.object({
+                        token: z16.string(),
+                        logprob: z16.number()
+                      })
+                    )
+                  })
+                ).nullish(),
+                annotations: z16.array(
+                  z16.discriminatedUnion("type", [
+                    z16.object({
+                      type: z16.literal("url_citation"),
+                      start_index: z16.number(),
+                      end_index: z16.number(),
+                      url: z16.string(),
+                      title: z16.string()
+                    }),
+                    z16.object({
+                      type: z16.literal("file_citation"),
+                      file_id: z16.string(),
+                      filename: z16.string().nullish(),
+                      index: z16.number().nullish(),
+                      start_index: z16.number().nullish(),
+                      end_index: z16.number().nullish(),
+                      quote: z16.string().nullish()
+                    }),
+                    z16.object({
+                      type: z16.literal("container_file_citation")
+                    })
+                  ])
+                )
+              })
+            )
+          }),
+          z16.object({
+            type: z16.literal("web_search_call"),
+            id: z16.string(),
+            status: z16.string(),
+            action: z16.discriminatedUnion("type", [
+              z16.object({
+                type: z16.literal("search"),
+                query: z16.string().nullish()
+              }),
+              z16.object({
+                type: z16.literal("open_page"),
+                url: z16.string()
+              }),
+              z16.object({
+                type: z16.literal("find"),
+                url: z16.string(),
+                pattern: z16.string()
+              })
+            ]).nullish()
+          }),
+          z16.object({
+            type: z16.literal("file_search_call"),
+            id: z16.string(),
+            queries: z16.array(z16.string()),
+            results: z16.array(
+              z16.object({
+                attributes: z16.record(z16.string(), z16.unknown()),
+                file_id: z16.string(),
+                filename: z16.string(),
+                score: z16.number(),
+                text: z16.string()
+              })
+            ).nullish()
+          }),
+          z16.object({
+            type: z16.literal("code_interpreter_call"),
+            id: z16.string(),
+            code: z16.string().nullable(),
+            container_id: z16.string(),
+            outputs: z16.array(
+              z16.discriminatedUnion("type", [
+                z16.object({ type: z16.literal("logs"), logs: z16.string() }),
+                z16.object({ type: z16.literal("image"), url: z16.string() })
+              ])
+            ).nullable()
+          }),
+          z16.object({
+            type: z16.literal("image_generation_call"),
+            id: z16.string(),
+            result: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("local_shell_call"),
+            id: z16.string(),
+            call_id: z16.string(),
+            action: z16.object({
+              type: z16.literal("exec"),
+              command: z16.array(z16.string()),
+              timeout_ms: z16.number().optional(),
+              user: z16.string().optional(),
+              working_directory: z16.string().optional(),
+              env: z16.record(z16.string(), z16.string()).optional()
+            })
+          }),
+          z16.object({
+            type: z16.literal("function_call"),
+            call_id: z16.string(),
+            name: z16.string(),
+            arguments: z16.string(),
+            id: z16.string()
+          }),
+          z16.object({
+            type: z16.literal("computer_call"),
+            id: z16.string(),
+            status: z16.string().optional()
+          }),
+          z16.object({
+            type: z16.literal("reasoning"),
+            id: z16.string(),
+            encrypted_content: z16.string().nullish(),
+            summary: z16.array(
+              z16.object({
+                type: z16.literal("summary_text"),
+                text: z16.string()
+              })
+            )
+          })
+        ])
+      ),
+      service_tier: z16.string().nullish(),
+      incomplete_details: z16.object({ reason: z16.string() }).nullish(),
+      usage: z16.object({
+        input_tokens: z16.number(),
+        input_tokens_details: z16.object({ cached_tokens: z16.number().nullish() }).nullish(),
+        output_tokens: z16.number(),
+        output_tokens_details: z16.object({ reasoning_tokens: z16.number().nullish() }).nullish()
+      })
+    })
+  )
+);
+
+// src/responses/openai-responses-options.ts
+var import_provider_utils22 = require("@ai-sdk/provider-utils");
+var z17 = __toESM(require("zod/v4"));
+var TOP_LOGPROBS_MAX = 20;
+var openaiResponsesReasoningModelIds = [
+  "o1",
+  "o1-2024-12-17",
+  "o3-mini",
+  "o3-mini-2025-01-31",
+  "o3",
+  "o3-2025-04-16",
+  "o4-mini",
+  "o4-mini-2025-04-16",
+  "codex-mini-latest",
+  "computer-use-preview",
+  "gpt-5",
+  "gpt-5-2025-08-07",
+  "gpt-5-codex",
+  "gpt-5-mini",
+  "gpt-5-mini-2025-08-07",
+  "gpt-5-nano",
+  "gpt-5-nano-2025-08-07",
+  "gpt-5-pro",
+  "gpt-5-pro-2025-10-06"
+];
+var openaiResponsesModelIds = [
+  "gpt-4.1",
+  "gpt-4.1-2025-04-14",
+  "gpt-4.1-mini",
+  "gpt-4.1-mini-2025-04-14",
+  "gpt-4.1-nano",
+  "gpt-4.1-nano-2025-04-14",
+  "gpt-4o",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-11-20",
+  "gpt-4o-audio-preview",
+  "gpt-4o-audio-preview-2024-10-01",
+  "gpt-4o-audio-preview-2024-12-17",
+  "gpt-4o-search-preview",
+  "gpt-4o-search-preview-2025-03-11",
+  "gpt-4o-mini-search-preview",
+  "gpt-4o-mini-search-preview-2025-03-11",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-turbo-preview",
+  "gpt-4-0125-preview",
+  "gpt-4-1106-preview",
+  "gpt-4",
+  "gpt-4-0613",
+  "gpt-4.5-preview",
+  "gpt-4.5-preview-2025-02-27",
+  "gpt-3.5-turbo-0125",
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-1106",
+  "chatgpt-4o-latest",
+  "gpt-5-chat-latest",
+  ...openaiResponsesReasoningModelIds
+];
+var openaiResponsesProviderOptionsSchema = (0, import_provider_utils22.lazyValidator)(
+  () => (0, import_provider_utils22.zodSchema)(
+    z17.object({
+      include: z17.array(
+        z17.enum([
+          "reasoning.encrypted_content",
+          "file_search_call.results",
+          "message.output_text.logprobs"
+        ])
+      ).nullish(),
+      instructions: z17.string().nullish(),
+      /**
+       * Return the log probabilities of the tokens.
+       *
+       * Setting to true will return the log probabilities of the tokens that
+       * were generated.
+       *
+       * Setting to a number will return the log probabilities of the top n
+       * tokens that were generated.
+       *
+       * @see https://platform.openai.com/docs/api-reference/responses/create
+       * @see https://cookbook.openai.com/examples/using_logprobs
+       */
+      logprobs: z17.union([z17.boolean(), z17.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+      /**
+       * The maximum number of total calls to built-in tools that can be processed in a response.
+       * This maximum number applies across all built-in tool calls, not per individual tool.
+       * Any further attempts to call a tool by the model will be ignored.
+       */
+      maxToolCalls: z17.number().nullish(),
+      metadata: z17.any().nullish(),
+      parallelToolCalls: z17.boolean().nullish(),
+      previousResponseId: z17.string().nullish(),
+      promptCacheKey: z17.string().nullish(),
+      reasoningEffort: z17.string().nullish(),
+      reasoningSummary: z17.string().nullish(),
+      safetyIdentifier: z17.string().nullish(),
+      serviceTier: z17.enum(["auto", "flex", "priority"]).nullish(),
+      store: z17.boolean().nullish(),
+      strictJsonSchema: z17.boolean().nullish(),
+      textVerbosity: z17.enum(["low", "medium", "high"]).nullish(),
+      user: z17.string().nullish()
+    })
+  )
+);
+
 // src/responses/openai-responses-prepare-tools.ts
 var import_provider7 = require("@ai-sdk/provider");
-function prepareResponsesTools({
+var import_provider_utils23 = require("@ai-sdk/provider-utils");
+async function prepareResponsesTools({
   tools,
   toolChoice,
   strictJsonSchema
@@ -2278,7 +2940,10 @@ function prepareResponsesTools({
       case "provider-defined": {
         switch (tool.id) {
           case "openai.file_search": {
-            const args = fileSearchArgsSchema.parse(tool.args);
+            const args = await (0, import_provider_utils23.validateTypes)({
+              value: tool.args,
+              schema: fileSearchArgsSchema
+            });
             openaiTools2.push({
               type: "file_search",
               vector_store_ids: args.vectorStoreIds,
@@ -2298,7 +2963,10 @@ function prepareResponsesTools({
             break;
           }
           case "openai.web_search_preview": {
-            const args = webSearchPreviewArgsSchema.parse(tool.args);
+            const args = await (0, import_provider_utils23.validateTypes)({
+              value: tool.args,
+              schema: webSearchPreviewArgsSchema
+            });
             openaiTools2.push({
               type: "web_search_preview",
               search_context_size: args.searchContextSize,
@@ -2307,7 +2975,10 @@ function prepareResponsesTools({
             break;
           }
           case "openai.web_search": {
-            const args = webSearchArgsSchema.parse(tool.args);
+            const args = await (0, import_provider_utils23.validateTypes)({
+              value: tool.args,
+              schema: webSearchArgsSchema
+            });
             openaiTools2.push({
               type: "web_search",
               filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : void 0,
@@ -2317,7 +2988,10 @@ function prepareResponsesTools({
             break;
           }
           case "openai.code_interpreter": {
-            const args = codeInterpreterArgsSchema.parse(tool.args);
+            const args = await (0, import_provider_utils23.validateTypes)({
+              value: tool.args,
+              schema: codeInterpreterArgsSchema
+            });
             openaiTools2.push({
               type: "code_interpreter",
               container: args.container == null ? { type: "auto", file_ids: void 0 } : typeof args.container === "string" ? args.container : { type: "auto", file_ids: args.container.fileIds }
@@ -2325,7 +2999,10 @@ function prepareResponsesTools({
             break;
           }
           case "openai.image_generation": {
-            const args = imageGenerationArgsSchema.parse(tool.args);
+            const args = await (0, import_provider_utils23.validateTypes)({
+              value: tool.args,
+              schema: imageGenerationArgsSchema
+            });
             openaiTools2.push({
               type: "image_generation",
               background: args.background,
@@ -2376,83 +3053,6 @@ function prepareResponsesTools({
 }
 
 // src/responses/openai-responses-language-model.ts
-var webSearchCallItem = import_v416.z.object({
-  type: import_v416.z.literal("web_search_call"),
-  id: import_v416.z.string(),
-  status: import_v416.z.string(),
-  action: import_v416.z.discriminatedUnion("type", [
-    import_v416.z.object({
-      type: import_v416.z.literal("search"),
-      query: import_v416.z.string().nullish()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("open_page"),
-      url: import_v416.z.string()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("find"),
-      url: import_v416.z.string(),
-      pattern: import_v416.z.string()
-    })
-  ]).nullish()
-});
-var fileSearchCallItem = import_v416.z.object({
-  type: import_v416.z.literal("file_search_call"),
-  id: import_v416.z.string(),
-  queries: import_v416.z.array(import_v416.z.string()),
-  results: import_v416.z.array(
-    import_v416.z.object({
-      attributes: import_v416.z.record(import_v416.z.string(), import_v416.z.unknown()),
-      file_id: import_v416.z.string(),
-      filename: import_v416.z.string(),
-      score: import_v416.z.number(),
-      text: import_v416.z.string()
-    })
-  ).nullish()
-});
-var codeInterpreterCallItem = import_v416.z.object({
-  type: import_v416.z.literal("code_interpreter_call"),
-  id: import_v416.z.string(),
-  code: import_v416.z.string().nullable(),
-  container_id: import_v416.z.string(),
-  outputs: import_v416.z.array(
-    import_v416.z.discriminatedUnion("type", [
-      import_v416.z.object({ type: import_v416.z.literal("logs"), logs: import_v416.z.string() }),
-      import_v416.z.object({ type: import_v416.z.literal("image"), url: import_v416.z.string() })
-    ])
-  ).nullable()
-});
-var localShellCallItem = import_v416.z.object({
-  type: import_v416.z.literal("local_shell_call"),
-  id: import_v416.z.string(),
-  call_id: import_v416.z.string(),
-  action: import_v416.z.object({
-    type: import_v416.z.literal("exec"),
-    command: import_v416.z.array(import_v416.z.string()),
-    timeout_ms: import_v416.z.number().optional(),
-    user: import_v416.z.string().optional(),
-    working_directory: import_v416.z.string().optional(),
-    env: import_v416.z.record(import_v416.z.string(), import_v416.z.string()).optional()
-  })
-});
-var imageGenerationCallItem = import_v416.z.object({
-  type: import_v416.z.literal("image_generation_call"),
-  id: import_v416.z.string(),
-  result: import_v416.z.string()
-});
-var TOP_LOGPROBS_MAX = 20;
-var LOGPROBS_SCHEMA = import_v416.z.array(
-  import_v416.z.object({
-    token: import_v416.z.string(),
-    logprob: import_v416.z.number(),
-    top_logprobs: import_v416.z.array(
-      import_v416.z.object({
-        token: import_v416.z.string(),
-        logprob: import_v416.z.number()
-      })
-    )
-  })
-);
 var OpenAIResponsesLanguageModel = class {
   constructor(modelId, config) {
     this.specificationVersion = "v2";
@@ -2505,7 +3105,7 @@ var OpenAIResponsesLanguageModel = class {
     if (stopSequences != null) {
       warnings.push({ type: "unsupported-setting", setting: "stopSequences" });
     }
-    const openaiOptions = await (0, import_provider_utils14.parseProviderOptions)({
+    const openaiOptions = await (0, import_provider_utils24.parseProviderOptions)({
       provider: "openai",
       providerOptions,
       schema: openaiResponsesProviderOptionsSchema
@@ -2644,7 +3244,7 @@ var OpenAIResponsesLanguageModel = class {
       tools: openaiTools2,
       toolChoice: openaiToolChoice,
       toolWarnings
-    } = prepareResponsesTools({
+    } = await prepareResponsesTools({
       tools,
       toolChoice,
       strictJsonSchema
@@ -2674,91 +3274,13 @@ var OpenAIResponsesLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils14.postJsonToApi)({
+    } = await (0, import_provider_utils24.postJsonToApi)({
       url,
-      headers: (0, import_provider_utils14.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils24.combineHeaders)(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils14.createJsonResponseHandler)(
-        import_v416.z.object({
-          id: import_v416.z.string(),
-          created_at: import_v416.z.number(),
-          error: import_v416.z.object({
-            code: import_v416.z.string(),
-            message: import_v416.z.string()
-          }).nullish(),
-          model: import_v416.z.string(),
-          output: import_v416.z.array(
-            import_v416.z.discriminatedUnion("type", [
-              import_v416.z.object({
-                type: import_v416.z.literal("message"),
-                role: import_v416.z.literal("assistant"),
-                id: import_v416.z.string(),
-                content: import_v416.z.array(
-                  import_v416.z.object({
-                    type: import_v416.z.literal("output_text"),
-                    text: import_v416.z.string(),
-                    logprobs: LOGPROBS_SCHEMA.nullish(),
-                    annotations: import_v416.z.array(
-                      import_v416.z.discriminatedUnion("type", [
-                        import_v416.z.object({
-                          type: import_v416.z.literal("url_citation"),
-                          start_index: import_v416.z.number(),
-                          end_index: import_v416.z.number(),
-                          url: import_v416.z.string(),
-                          title: import_v416.z.string()
-                        }),
-                        import_v416.z.object({
-                          type: import_v416.z.literal("file_citation"),
-                          file_id: import_v416.z.string(),
-                          filename: import_v416.z.string().nullish(),
-                          index: import_v416.z.number().nullish(),
-                          start_index: import_v416.z.number().nullish(),
-                          end_index: import_v416.z.number().nullish(),
-                          quote: import_v416.z.string().nullish()
-                        }),
-                        import_v416.z.object({
-                          type: import_v416.z.literal("container_file_citation")
-                        })
-                      ])
-                    )
-                  })
-                )
-              }),
-              webSearchCallItem,
-              fileSearchCallItem,
-              codeInterpreterCallItem,
-              imageGenerationCallItem,
-              localShellCallItem,
-              import_v416.z.object({
-                type: import_v416.z.literal("function_call"),
-                call_id: import_v416.z.string(),
-                name: import_v416.z.string(),
-                arguments: import_v416.z.string(),
-                id: import_v416.z.string()
-              }),
-              import_v416.z.object({
-                type: import_v416.z.literal("computer_call"),
-                id: import_v416.z.string(),
-                status: import_v416.z.string().optional()
-              }),
-              import_v416.z.object({
-                type: import_v416.z.literal("reasoning"),
-                id: import_v416.z.string(),
-                encrypted_content: import_v416.z.string().nullish(),
-                summary: import_v416.z.array(
-                  import_v416.z.object({
-                    type: import_v416.z.literal("summary_text"),
-                    text: import_v416.z.string()
-                  })
-                )
-              })
-            ])
-          ),
-          service_tier: import_v416.z.string().nullish(),
-          incomplete_details: import_v416.z.object({ reason: import_v416.z.string() }).nullish(),
-          usage: usageSchema2
-        })
+      successfulResponseHandler: (0, import_provider_utils24.createJsonResponseHandler)(
+        openaiResponsesResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -2821,7 +3343,9 @@ var OpenAIResponsesLanguageModel = class {
             type: "tool-call",
             toolCallId: part.call_id,
             toolName: "local_shell",
-            input: JSON.stringify({ action: part.action }),
+            input: JSON.stringify({
+              action: part.action
+            }),
             providerMetadata: {
               openai: {
                 itemId: part.id
@@ -2849,7 +3373,7 @@ var OpenAIResponsesLanguageModel = class {
                 content.push({
                   type: "source",
                   sourceType: "url",
-                  id: (_f = (_e = (_d = this.config).generateId) == null ? void 0 : _e.call(_d)) != null ? _f : (0, import_provider_utils14.generateId)(),
+                  id: (_f = (_e = (_d = this.config).generateId) == null ? void 0 : _e.call(_d)) != null ? _f : (0, import_provider_utils24.generateId)(),
                   url: annotation.url,
                   title: annotation.title
                 });
@@ -2857,7 +3381,7 @@ var OpenAIResponsesLanguageModel = class {
                 content.push({
                   type: "source",
                   sourceType: "document",
-                  id: (_i = (_h = (_g = this.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : (0, import_provider_utils14.generateId)(),
+                  id: (_i = (_h = (_g = this.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : (0, import_provider_utils24.generateId)(),
                   mediaType: "text/plain",
                   title: (_k = (_j = annotation.quote) != null ? _j : annotation.filename) != null ? _k : "Document",
                   filename: (_l = annotation.filename) != null ? _l : annotation.file_id
@@ -3009,18 +3533,18 @@ var OpenAIResponsesLanguageModel = class {
       warnings,
       webSearchToolName
     } = await this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils14.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils24.postJsonToApi)({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils14.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils24.combineHeaders)(this.config.headers(), options.headers),
       body: {
         ...body,
         stream: true
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils14.createEventSourceResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils24.createEventSourceResponseHandler)(
         openaiResponsesChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -3397,7 +3921,7 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "url",
-                  id: (_q = (_p = (_o = self.config).generateId) == null ? void 0 : _p.call(_o)) != null ? _q : (0, import_provider_utils14.generateId)(),
+                  id: (_q = (_p = (_o = self.config).generateId) == null ? void 0 : _p.call(_o)) != null ? _q : (0, import_provider_utils24.generateId)(),
                   url: value.annotation.url,
                   title: value.annotation.title
                 });
@@ -3405,7 +3929,7 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "document",
-                  id: (_t = (_s = (_r = self.config).generateId) == null ? void 0 : _s.call(_r)) != null ? _t : (0, import_provider_utils14.generateId)(),
+                  id: (_t = (_s = (_r = self.config).generateId) == null ? void 0 : _s.call(_r)) != null ? _t : (0, import_provider_utils24.generateId)(),
                   mediaType: "text/plain",
                   title: (_v = (_u = value.annotation.quote) != null ? _u : value.annotation.filename) != null ? _v : "Document",
                   filename: (_w = value.annotation.filename) != null ? _w : value.annotation.file_id
@@ -3441,196 +3965,6 @@ var OpenAIResponsesLanguageModel = class {
     };
   }
 };
-var usageSchema2 = import_v416.z.object({
-  input_tokens: import_v416.z.number(),
-  input_tokens_details: import_v416.z.object({ cached_tokens: import_v416.z.number().nullish() }).nullish(),
-  output_tokens: import_v416.z.number(),
-  output_tokens_details: import_v416.z.object({ reasoning_tokens: import_v416.z.number().nullish() }).nullish()
-});
-var textDeltaChunkSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.output_text.delta"),
-  item_id: import_v416.z.string(),
-  delta: import_v416.z.string(),
-  logprobs: LOGPROBS_SCHEMA.nullish()
-});
-var errorChunkSchema = import_v416.z.object({
-  type: import_v416.z.literal("error"),
-  code: import_v416.z.string(),
-  message: import_v416.z.string(),
-  param: import_v416.z.string().nullish(),
-  sequence_number: import_v416.z.number()
-});
-var responseFinishedChunkSchema = import_v416.z.object({
-  type: import_v416.z.enum(["response.completed", "response.incomplete"]),
-  response: import_v416.z.object({
-    incomplete_details: import_v416.z.object({ reason: import_v416.z.string() }).nullish(),
-    usage: usageSchema2,
-    service_tier: import_v416.z.string().nullish()
-  })
-});
-var responseCreatedChunkSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.created"),
-  response: import_v416.z.object({
-    id: import_v416.z.string(),
-    created_at: import_v416.z.number(),
-    model: import_v416.z.string(),
-    service_tier: import_v416.z.string().nullish()
-  })
-});
-var responseOutputItemAddedSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.output_item.added"),
-  output_index: import_v416.z.number(),
-  item: import_v416.z.discriminatedUnion("type", [
-    import_v416.z.object({
-      type: import_v416.z.literal("message"),
-      id: import_v416.z.string()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("reasoning"),
-      id: import_v416.z.string(),
-      encrypted_content: import_v416.z.string().nullish()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("function_call"),
-      id: import_v416.z.string(),
-      call_id: import_v416.z.string(),
-      name: import_v416.z.string(),
-      arguments: import_v416.z.string()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("web_search_call"),
-      id: import_v416.z.string(),
-      status: import_v416.z.string(),
-      action: import_v416.z.object({
-        type: import_v416.z.literal("search"),
-        query: import_v416.z.string().optional()
-      }).nullish()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("computer_call"),
-      id: import_v416.z.string(),
-      status: import_v416.z.string()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("file_search_call"),
-      id: import_v416.z.string()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("image_generation_call"),
-      id: import_v416.z.string()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("code_interpreter_call"),
-      id: import_v416.z.string(),
-      container_id: import_v416.z.string(),
-      code: import_v416.z.string().nullable(),
-      outputs: import_v416.z.array(
-        import_v416.z.discriminatedUnion("type", [
-          import_v416.z.object({ type: import_v416.z.literal("logs"), logs: import_v416.z.string() }),
-          import_v416.z.object({ type: import_v416.z.literal("image"), url: import_v416.z.string() })
-        ])
-      ).nullable(),
-      status: import_v416.z.string()
-    })
-  ])
-});
-var responseOutputItemDoneSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.output_item.done"),
-  output_index: import_v416.z.number(),
-  item: import_v416.z.discriminatedUnion("type", [
-    import_v416.z.object({
-      type: import_v416.z.literal("message"),
-      id: import_v416.z.string()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("reasoning"),
-      id: import_v416.z.string(),
-      encrypted_content: import_v416.z.string().nullish()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("function_call"),
-      id: import_v416.z.string(),
-      call_id: import_v416.z.string(),
-      name: import_v416.z.string(),
-      arguments: import_v416.z.string(),
-      status: import_v416.z.literal("completed")
-    }),
-    codeInterpreterCallItem,
-    imageGenerationCallItem,
-    webSearchCallItem,
-    fileSearchCallItem,
-    localShellCallItem,
-    import_v416.z.object({
-      type: import_v416.z.literal("computer_call"),
-      id: import_v416.z.string(),
-      status: import_v416.z.literal("completed")
-    })
-  ])
-});
-var responseFunctionCallArgumentsDeltaSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.function_call_arguments.delta"),
-  item_id: import_v416.z.string(),
-  output_index: import_v416.z.number(),
-  delta: import_v416.z.string()
-});
-var responseCodeInterpreterCallCodeDeltaSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.code_interpreter_call_code.delta"),
-  item_id: import_v416.z.string(),
-  output_index: import_v416.z.number(),
-  delta: import_v416.z.string()
-});
-var responseCodeInterpreterCallCodeDoneSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.code_interpreter_call_code.done"),
-  item_id: import_v416.z.string(),
-  output_index: import_v416.z.number(),
-  code: import_v416.z.string()
-});
-var responseAnnotationAddedSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.output_text.annotation.added"),
-  annotation: import_v416.z.discriminatedUnion("type", [
-    import_v416.z.object({
-      type: import_v416.z.literal("url_citation"),
-      url: import_v416.z.string(),
-      title: import_v416.z.string()
-    }),
-    import_v416.z.object({
-      type: import_v416.z.literal("file_citation"),
-      file_id: import_v416.z.string(),
-      filename: import_v416.z.string().nullish(),
-      index: import_v416.z.number().nullish(),
-      start_index: import_v416.z.number().nullish(),
-      end_index: import_v416.z.number().nullish(),
-      quote: import_v416.z.string().nullish()
-    })
-  ])
-});
-var responseReasoningSummaryPartAddedSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.reasoning_summary_part.added"),
-  item_id: import_v416.z.string(),
-  summary_index: import_v416.z.number()
-});
-var responseReasoningSummaryTextDeltaSchema = import_v416.z.object({
-  type: import_v416.z.literal("response.reasoning_summary_text.delta"),
-  item_id: import_v416.z.string(),
-  summary_index: import_v416.z.number(),
-  delta: import_v416.z.string()
-});
-var openaiResponsesChunkSchema = import_v416.z.union([
-  textDeltaChunkSchema,
-  responseFinishedChunkSchema,
-  responseCreatedChunkSchema,
-  responseOutputItemAddedSchema,
-  responseOutputItemDoneSchema,
-  responseFunctionCallArgumentsDeltaSchema,
-  responseCodeInterpreterCallCodeDeltaSchema,
-  responseCodeInterpreterCallCodeDoneSchema,
-  responseAnnotationAddedSchema,
-  responseReasoningSummaryPartAddedSchema,
-  responseReasoningSummaryTextDeltaSchema,
-  errorChunkSchema,
-  import_v416.z.object({ type: import_v416.z.string() }).loose()
-  // fallback for unknown chunks
-]);
 function isTextDeltaChunk(chunk) {
   return chunk.type === "response.output_text.delta";
 }
@@ -3707,55 +4041,23 @@ function getResponsesModelConfig(modelId) {
     isReasoningModel: false
   };
 }
-var openaiResponsesProviderOptionsSchema = import_v416.z.object({
-  include: import_v416.z.array(
-    import_v416.z.enum([
-      "reasoning.encrypted_content",
-      "file_search_call.results",
-      "message.output_text.logprobs"
-    ])
-  ).nullish(),
-  instructions: import_v416.z.string().nullish(),
-  /**
-   * Return the log probabilities of the tokens.
-   *
-   * Setting to true will return the log probabilities of the tokens that
-   * were generated.
-   *
-   * Setting to a number will return the log probabilities of the top n
-   * tokens that were generated.
-   *
-   * @see https://platform.openai.com/docs/api-reference/responses/create
-   * @see https://cookbook.openai.com/examples/using_logprobs
-   */
-  logprobs: import_v416.z.union([import_v416.z.boolean(), import_v416.z.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
-  /**
-   * The maximum number of total calls to built-in tools that can be processed in a response.
-   * This maximum number applies across all built-in tool calls, not per individual tool.
-   * Any further attempts to call a tool by the model will be ignored.
-   */
-  maxToolCalls: import_v416.z.number().nullish(),
-  metadata: import_v416.z.any().nullish(),
-  parallelToolCalls: import_v416.z.boolean().nullish(),
-  previousResponseId: import_v416.z.string().nullish(),
-  promptCacheKey: import_v416.z.string().nullish(),
-  reasoningEffort: import_v416.z.string().nullish(),
-  reasoningSummary: import_v416.z.string().nullish(),
-  safetyIdentifier: import_v416.z.string().nullish(),
-  serviceTier: import_v416.z.enum(["auto", "flex", "priority"]).nullish(),
-  store: import_v416.z.boolean().nullish(),
-  strictJsonSchema: import_v416.z.boolean().nullish(),
-  textVerbosity: import_v416.z.enum(["low", "medium", "high"]).nullish(),
-  user: import_v416.z.string().nullish()
-});
 
 // src/speech/openai-speech-model.ts
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
-var import_v417 = require("zod/v4");
-var OpenAIProviderOptionsSchema = import_v417.z.object({
-  instructions: import_v417.z.string().nullish(),
-  speed: import_v417.z.number().min(0.25).max(4).default(1).nullish()
-});
+var import_provider_utils26 = require("@ai-sdk/provider-utils");
+
+// src/speech/openai-speech-options.ts
+var import_provider_utils25 = require("@ai-sdk/provider-utils");
+var z18 = __toESM(require("zod/v4"));
+var openaiSpeechProviderOptionsSchema = (0, import_provider_utils25.lazyValidator)(
+  () => (0, import_provider_utils25.zodSchema)(
+    z18.object({
+      instructions: z18.string().nullish(),
+      speed: z18.number().min(0.25).max(4).default(1).nullish()
+    })
+  )
+);
+
+// src/speech/openai-speech-model.ts
 var OpenAISpeechModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -3775,10 +4077,10 @@ var OpenAISpeechModel = class {
     providerOptions
   }) {
     const warnings = [];
-    const openAIOptions = await (0, import_provider_utils15.parseProviderOptions)({
+    const openAIOptions = await (0, import_provider_utils26.parseProviderOptions)({
       provider: "openai",
       providerOptions,
-      schema: OpenAIProviderOptionsSchema
+      schema: openaiSpeechProviderOptionsSchema
     });
     const requestBody = {
       model: this.modelId,
@@ -3828,15 +4130,15 @@ var OpenAISpeechModel = class {
       value: audio,
       responseHeaders,
       rawValue: rawResponse
-    } = await (0, import_provider_utils15.postJsonToApi)({
+    } = await (0, import_provider_utils26.postJsonToApi)({
       url: this.config.url({
         path: "/audio/speech",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils15.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils26.combineHeaders)(this.config.headers(), options.headers),
       body: requestBody,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils15.createBinaryResponseHandler)(),
+      successfulResponseHandler: (0, import_provider_utils26.createBinaryResponseHandler)(),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -3857,35 +4159,73 @@ var OpenAISpeechModel = class {
 };
 
 // src/transcription/openai-transcription-model.ts
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
-var import_v419 = require("zod/v4");
+var import_provider_utils29 = require("@ai-sdk/provider-utils");
+
+// src/transcription/openai-transcription-api.ts
+var import_provider_utils27 = require("@ai-sdk/provider-utils");
+var z19 = __toESM(require("zod/v4"));
+var openaiTranscriptionResponseSchema = (0, import_provider_utils27.lazyValidator)(
+  () => (0, import_provider_utils27.zodSchema)(
+    z19.object({
+      text: z19.string(),
+      language: z19.string().nullish(),
+      duration: z19.number().nullish(),
+      words: z19.array(
+        z19.object({
+          word: z19.string(),
+          start: z19.number(),
+          end: z19.number()
+        })
+      ).nullish(),
+      segments: z19.array(
+        z19.object({
+          id: z19.number(),
+          seek: z19.number(),
+          start: z19.number(),
+          end: z19.number(),
+          text: z19.string(),
+          tokens: z19.array(z19.number()),
+          temperature: z19.number(),
+          avg_logprob: z19.number(),
+          compression_ratio: z19.number(),
+          no_speech_prob: z19.number()
+        })
+      ).nullish()
+    })
+  )
+);
 
 // src/transcription/openai-transcription-options.ts
-var import_v418 = require("zod/v4");
-var openAITranscriptionProviderOptions = import_v418.z.object({
-  /**
-   * Additional information to include in the transcription response.
-   */
-  include: import_v418.z.array(import_v418.z.string()).optional(),
-  /**
-   * The language of the input audio in ISO-639-1 format.
-   */
-  language: import_v418.z.string().optional(),
-  /**
-   * An optional text to guide the model's style or continue a previous audio segment.
-   */
-  prompt: import_v418.z.string().optional(),
-  /**
-   * The sampling temperature, between 0 and 1.
-   * @default 0
-   */
-  temperature: import_v418.z.number().min(0).max(1).default(0).optional(),
-  /**
-   * The timestamp granularities to populate for this transcription.
-   * @default ['segment']
-   */
-  timestampGranularities: import_v418.z.array(import_v418.z.enum(["word", "segment"])).default(["segment"]).optional()
-});
+var import_provider_utils28 = require("@ai-sdk/provider-utils");
+var z20 = __toESM(require("zod/v4"));
+var openAITranscriptionProviderOptions = (0, import_provider_utils28.lazyValidator)(
+  () => (0, import_provider_utils28.zodSchema)(
+    z20.object({
+      /**
+       * Additional information to include in the transcription response.
+       */
+      include: z20.array(z20.string()).optional(),
+      /**
+       * The language of the input audio in ISO-639-1 format.
+       */
+      language: z20.string().optional(),
+      /**
+       * An optional text to guide the model's style or continue a previous audio segment.
+       */
+      prompt: z20.string().optional(),
+      /**
+       * The sampling temperature, between 0 and 1.
+       * @default 0
+       */
+      temperature: z20.number().min(0).max(1).default(0).optional(),
+      /**
+       * The timestamp granularities to populate for this transcription.
+       * @default ['segment']
+       */
+      timestampGranularities: z20.array(z20.enum(["word", "segment"])).default(["segment"]).optional()
+    })
+  )
+);
 
 // src/transcription/openai-transcription-model.ts
 var languageMap = {
@@ -3962,15 +4302,15 @@ var OpenAITranscriptionModel = class {
     providerOptions
   }) {
     const warnings = [];
-    const openAIOptions = await (0, import_provider_utils16.parseProviderOptions)({
+    const openAIOptions = await (0, import_provider_utils29.parseProviderOptions)({
       provider: "openai",
       providerOptions,
       schema: openAITranscriptionProviderOptions
     });
     const formData = new FormData();
-    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([(0, import_provider_utils16.convertBase64ToUint8Array)(audio)]);
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([(0, import_provider_utils29.convertBase64ToUint8Array)(audio)]);
     formData.append("model", this.modelId);
-    const fileExtension = (0, import_provider_utils16.mediaTypeToExtension)(mediaType);
+    const fileExtension = (0, import_provider_utils29.mediaTypeToExtension)(mediaType);
     formData.append(
       "file",
       new File([blob], "audio", { type: mediaType }),
@@ -4015,15 +4355,15 @@ var OpenAITranscriptionModel = class {
       value: response,
       responseHeaders,
       rawValue: rawResponse
-    } = await (0, import_provider_utils16.postFormDataToApi)({
+    } = await (0, import_provider_utils29.postFormDataToApi)({
       url: this.config.url({
         path: "/audio/transcriptions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils16.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils29.combineHeaders)(this.config.headers(), options.headers),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils16.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils29.createJsonResponseHandler)(
         openaiTranscriptionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -4053,49 +4393,23 @@ var OpenAITranscriptionModel = class {
     };
   }
 };
-var openaiTranscriptionResponseSchema = import_v419.z.object({
-  text: import_v419.z.string(),
-  language: import_v419.z.string().nullish(),
-  duration: import_v419.z.number().nullish(),
-  words: import_v419.z.array(
-    import_v419.z.object({
-      word: import_v419.z.string(),
-      start: import_v419.z.number(),
-      end: import_v419.z.number()
-    })
-  ).nullish(),
-  segments: import_v419.z.array(
-    import_v419.z.object({
-      id: import_v419.z.number(),
-      seek: import_v419.z.number(),
-      start: import_v419.z.number(),
-      end: import_v419.z.number(),
-      text: import_v419.z.string(),
-      tokens: import_v419.z.array(import_v419.z.number()),
-      temperature: import_v419.z.number(),
-      avg_logprob: import_v419.z.number(),
-      compression_ratio: import_v419.z.number(),
-      no_speech_prob: import_v419.z.number()
-    })
-  ).nullish()
-});
 
 // src/version.ts
-var VERSION = true ? "2.0.44" : "0.0.0-test";
+var VERSION = true ? "2.0.45" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {
   var _a, _b;
-  const baseURL = (_a = (0, import_provider_utils17.withoutTrailingSlash)(
-    (0, import_provider_utils17.loadOptionalSetting)({
+  const baseURL = (_a = (0, import_provider_utils30.withoutTrailingSlash)(
+    (0, import_provider_utils30.loadOptionalSetting)({
       settingValue: options.baseURL,
       environmentVariableName: "OPENAI_BASE_URL"
     })
   )) != null ? _a : "https://api.openai.com/v1";
   const providerName = (_b = options.name) != null ? _b : "openai";
-  const getHeaders = () => (0, import_provider_utils17.withUserAgentSuffix)(
+  const getHeaders = () => (0, import_provider_utils30.withUserAgentSuffix)(
     {
-      Authorization: `Bearer ${(0, import_provider_utils17.loadApiKey)({
+      Authorization: `Bearer ${(0, import_provider_utils30.loadApiKey)({
         apiKey: options.apiKey,
         environmentVariableName: "OPENAI_API_KEY",
         description: "OpenAI"