@ai-sdk/openai 2.0.43 → 2.0.45

package/dist/internal/index.mjs

@@ -11,10 +11,9 @@ import {
   parseProviderOptions,
   postJsonToApi
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
 
 // src/openai-error.ts
-import { z } from "zod/v4";
+import * as z from "zod/v4";
 import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
 var openaiErrorDataSchema = z.object({
   error: z.object({
@@ -242,95 +241,244 @@ function mapOpenAIFinishReason(finishReason) {
   }
 }
 
+// src/chat/openai-chat-api.ts
+import {
+  lazyValidator,
+  zodSchema
+} from "@ai-sdk/provider-utils";
+import * as z2 from "zod/v4";
+var openaiChatResponseSchema = lazyValidator(
+  () => 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 = lazyValidator(
+  () => 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
-import { z as z2 } from "zod/v4";
-var openaiChatLanguageModelOptions = z2.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: z2.record(z2.coerce.number(), z2.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: z2.union([z2.boolean(), z2.number()]).optional(),
-  /**
-   * Whether to enable parallel function calling during tool use. Default to true.
-   */
-  parallelToolCalls: z2.boolean().optional(),
-  /**
-   * A unique identifier representing your end-user, which can help OpenAI to
-   * monitor and detect abuse.
-   */
-  user: z2.string().optional(),
-  /**
-   * Reasoning effort for reasoning models. Defaults to `medium`.
-   */
-  reasoningEffort: z2.enum(["minimal", "low", "medium", "high"]).optional(),
-  /**
-   * Maximum number of completion tokens to generate. Useful for reasoning models.
-   */
-  maxCompletionTokens: z2.number().optional(),
-  /**
-   * Whether to enable persistence in responses API.
-   */
-  store: z2.boolean().optional(),
-  /**
-   * Metadata to associate with the request.
-   */
-  metadata: z2.record(z2.string().max(64), z2.string().max(512)).optional(),
-  /**
-   * Parameters for prediction mode.
-   */
-  prediction: z2.record(z2.string(), z2.any()).optional(),
-  /**
-   * Whether to use structured outputs.
-   *
-   * @default true
-   */
-  structuredOutputs: z2.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: z2.enum(["auto", "flex", "priority"]).optional(),
-  /**
-   * Whether to use strict JSON schema validation.
-   *
-   * @default false
-   */
-  strictJsonSchema: z2.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: z2.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: z2.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: z2.string().optional()
-});
+import {
+  lazyValidator as lazyValidator2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+import * as z3 from "zod/v4";
+var openaiChatLanguageModelOptions = lazyValidator2(
+  () => zodSchema2(
+    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
 import {
@@ -888,121 +1036,6 @@ var OpenAIChatLanguageModel = class {
     };
   }
 };
-var openaiTokenUsageSchema = z3.object({
-  prompt_tokens: z3.number().nullish(),
-  completion_tokens: z3.number().nullish(),
-  total_tokens: z3.number().nullish(),
-  prompt_tokens_details: z3.object({
-    cached_tokens: z3.number().nullish()
-  }).nullish(),
-  completion_tokens_details: z3.object({
-    reasoning_tokens: z3.number().nullish(),
-    accepted_prediction_tokens: z3.number().nullish(),
-    rejected_prediction_tokens: z3.number().nullish()
-  }).nullish()
-}).nullish();
-var openaiChatResponseSchema = z3.object({
-  id: z3.string().nullish(),
-  created: z3.number().nullish(),
-  model: z3.string().nullish(),
-  choices: z3.array(
-    z3.object({
-      message: z3.object({
-        role: z3.literal("assistant").nullish(),
-        content: z3.string().nullish(),
-        tool_calls: z3.array(
-          z3.object({
-            id: z3.string().nullish(),
-            type: z3.literal("function"),
-            function: z3.object({
-              name: z3.string(),
-              arguments: z3.string()
-            })
-          })
-        ).nullish(),
-        annotations: z3.array(
-          z3.object({
-            type: z3.literal("url_citation"),
-            start_index: z3.number(),
-            end_index: z3.number(),
-            url: z3.string(),
-            title: z3.string()
-          })
-        ).nullish()
-      }),
-      index: z3.number(),
-      logprobs: z3.object({
-        content: z3.array(
-          z3.object({
-            token: z3.string(),
-            logprob: z3.number(),
-            top_logprobs: z3.array(
-              z3.object({
-                token: z3.string(),
-                logprob: z3.number()
-              })
-            )
-          })
-        ).nullish()
-      }).nullish(),
-      finish_reason: z3.string().nullish()
-    })
-  ),
-  usage: openaiTokenUsageSchema
-});
-var openaiChatChunkSchema = z3.union([
-  z3.object({
-    id: z3.string().nullish(),
-    created: z3.number().nullish(),
-    model: z3.string().nullish(),
-    choices: z3.array(
-      z3.object({
-        delta: z3.object({
-          role: z3.enum(["assistant"]).nullish(),
-          content: z3.string().nullish(),
-          tool_calls: z3.array(
-            z3.object({
-              index: z3.number(),
-              id: z3.string().nullish(),
-              type: z3.literal("function").nullish(),
-              function: z3.object({
-                name: z3.string().nullish(),
-                arguments: z3.string().nullish()
-              })
-            })
-          ).nullish(),
-          annotations: z3.array(
-            z3.object({
-              type: z3.literal("url_citation"),
-              start_index: z3.number(),
-              end_index: z3.number(),
-              url: z3.string(),
-              title: z3.string()
-            })
-          ).nullish()
-        }).nullish(),
-        logprobs: z3.object({
-          content: z3.array(
-            z3.object({
-              token: z3.string(),
-              logprob: z3.number(),
-              top_logprobs: z3.array(
-                z3.object({
-                  token: z3.string(),
-                  logprob: z3.number()
-                })
-              )
-            })
-          ).nullish()
-        }).nullish(),
-        finish_reason: z3.string().nullish(),
-        index: z3.number()
-      })
-    ),
-    usage: openaiTokenUsageSchema
-  }),
-  openaiErrorDataSchema
-]);
 function isReasoningModel(modelId) {
   return (modelId.startsWith("o") || modelId.startsWith("gpt-5")) && !modelId.startsWith("gpt-5-chat");
 }
@@ -1060,7 +1093,6 @@ import {
   parseProviderOptions as parseProviderOptions2,
   postJsonToApi as postJsonToApi2
 } from "@ai-sdk/provider-utils";
-import { z as z5 } from "zod/v4";
 
 // src/completion/convert-to-openai-completion-prompt.ts
 import {
@@ -1170,48 +1202,117 @@ function mapOpenAIFinishReason2(finishReason) {
   }
 }
 
+// src/completion/openai-completion-api.ts
+import * as z4 from "zod/v4";
+import {
+  lazyValidator as lazyValidator3,
+  zodSchema as zodSchema3
+} from "@ai-sdk/provider-utils";
+var openaiCompletionResponseSchema = lazyValidator3(
+  () => zodSchema3(
+    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 = lazyValidator3(
+  () => zodSchema3(
+    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
-import { z as z4 } from "zod/v4";
-var openaiCompletionProviderOptions = z4.object({
-  /**
-  Echo back the prompt in addition to the completion.
-     */
-  echo: z4.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: z4.record(z4.string(), z4.number()).optional(),
-  /**
-  The suffix that comes after a completion of inserted text.
-   */
-  suffix: z4.string().optional(),
-  /**
-  A unique identifier representing your end-user, which can help OpenAI to
-  monitor and detect abuse. Learn more.
-   */
-  user: z4.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: z4.union([z4.boolean(), z4.number()]).optional()
-});
+import {
+  lazyValidator as lazyValidator4,
+  zodSchema as zodSchema4
+} from "@ai-sdk/provider-utils";
+import * as z5 from "zod/v4";
+var openaiCompletionProviderOptions = lazyValidator4(
+  () => zodSchema4(
+    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 {
@@ -1442,49 +1543,6 @@ var OpenAICompletionLanguageModel = class {
     };
   }
 };
-var usageSchema = z5.object({
-  prompt_tokens: z5.number(),
-  completion_tokens: z5.number(),
-  total_tokens: z5.number()
-});
-var openaiCompletionResponseSchema = z5.object({
-  id: z5.string().nullish(),
-  created: z5.number().nullish(),
-  model: z5.string().nullish(),
-  choices: z5.array(
-    z5.object({
-      text: z5.string(),
-      finish_reason: z5.string(),
-      logprobs: z5.object({
-        tokens: z5.array(z5.string()),
-        token_logprobs: z5.array(z5.number()),
-        top_logprobs: z5.array(z5.record(z5.string(), z5.number())).nullish()
-      }).nullish()
-    })
-  ),
-  usage: usageSchema.nullish()
-});
-var openaiCompletionChunkSchema = z5.union([
-  z5.object({
-    id: z5.string().nullish(),
-    created: z5.number().nullish(),
-    model: z5.string().nullish(),
-    choices: z5.array(
-      z5.object({
-        text: z5.string(),
-        finish_reason: z5.string().nullish(),
-        index: z5.number(),
-        logprobs: z5.object({
-          tokens: z5.array(z5.string()),
-          token_logprobs: z5.array(z5.number()),
-          top_logprobs: z5.array(z5.record(z5.string(), z5.number())).nullish()
-        }).nullish()
-      })
-    ),
-    usage: usageSchema.nullish()
-  }),
-  openaiErrorDataSchema
-]);
 
 // src/embedding/openai-embedding-model.ts
 import {
@@ -1496,22 +1554,41 @@ import {
   parseProviderOptions as parseProviderOptions3,
   postJsonToApi as postJsonToApi3
 } from "@ai-sdk/provider-utils";
-import { z as z7 } from "zod/v4";
 
 // src/embedding/openai-embedding-options.ts
-import { z as z6 } from "zod/v4";
-var openaiEmbeddingProviderOptions = 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()
-});
+import {
+  lazyValidator as lazyValidator5,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
+import * as z6 from "zod/v4";
+var openaiEmbeddingProviderOptions = lazyValidator5(
+  () => zodSchema5(
+    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
+import { lazyValidator as lazyValidator6, zodSchema as zodSchema6 } from "@ai-sdk/provider-utils";
+import * as z7 from "zod/v4";
+var openaiTextEmbeddingResponseSchema = lazyValidator6(
+  () => zodSchema6(
+    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 {
@@ -1576,10 +1653,6 @@ var OpenAIEmbeddingModel = class {
     };
   }
 };
-var openaiTextEmbeddingResponseSchema = z7.object({
-  data: z7.array(z7.object({ embedding: z7.array(z7.number()) })),
-  usage: z7.object({ prompt_tokens: z7.number() }).nullish()
-});
 
 // src/image/openai-image-model.ts
 import {
@@ -1587,7 +1660,22 @@ import {
   createJsonResponseHandler as createJsonResponseHandler4,
   postJsonToApi as postJsonToApi4
 } from "@ai-sdk/provider-utils";
-import { z as z8 } from "zod/v4";
+
+// src/image/openai-image-api.ts
+import { lazyValidator as lazyValidator7, zodSchema as zodSchema7 } from "@ai-sdk/provider-utils";
+import * as z8 from "zod/v4";
+var openaiImageResponseSchema = lazyValidator7(
+  () => zodSchema7(
+    z8.object({
+      data: z8.array(
+        z8.object({
+          b64_json: z8.string(),
+          revised_prompt: z8.string().optional()
+        })
+      )
+    })
+  )
+);
 
 // src/image/openai-image-options.ts
 var modelMaxImagesPerCall = {
@@ -1679,11 +1767,6 @@ var OpenAIImageModel = class {
     };
   }
 };
-var openaiImageResponseSchema = z8.object({
-  data: z8.array(
-    z8.object({ b64_json: z8.string(), revised_prompt: z8.string().optional() })
-  )
-});
 
 // src/transcription/openai-transcription-model.ts
 import {
@@ -1694,34 +1777,75 @@ import {
   parseProviderOptions as parseProviderOptions4,
   postFormDataToApi
 } from "@ai-sdk/provider-utils";
-import { z as z10 } from "zod/v4";
+
+// src/transcription/openai-transcription-api.ts
+import { lazyValidator as lazyValidator8, zodSchema as zodSchema8 } from "@ai-sdk/provider-utils";
+import * as z9 from "zod/v4";
+var openaiTranscriptionResponseSchema = lazyValidator8(
+  () => zodSchema8(
+    z9.object({
+      text: z9.string(),
+      language: z9.string().nullish(),
+      duration: z9.number().nullish(),
+      words: z9.array(
+        z9.object({
+          word: z9.string(),
+          start: z9.number(),
+          end: z9.number()
+        })
+      ).nullish(),
+      segments: z9.array(
+        z9.object({
+          id: z9.number(),
+          seek: z9.number(),
+          start: z9.number(),
+          end: z9.number(),
+          text: z9.string(),
+          tokens: z9.array(z9.number()),
+          temperature: z9.number(),
+          avg_logprob: z9.number(),
+          compression_ratio: z9.number(),
+          no_speech_prob: z9.number()
+        })
+      ).nullish()
+    })
+  )
+);
 
 // src/transcription/openai-transcription-options.ts
-import { z as z9 } from "zod/v4";
-var openAITranscriptionProviderOptions = z9.object({
-  /**
-   * Additional information to include in the transcription response.
-   */
-  include: z9.array(z9.string()).optional(),
-  /**
-   * The language of the input audio in ISO-639-1 format.
-   */
-  language: z9.string().optional(),
-  /**
-   * An optional text to guide the model's style or continue a previous audio segment.
-   */
-  prompt: z9.string().optional(),
-  /**
-   * The sampling temperature, between 0 and 1.
-   * @default 0
-   */
-  temperature: z9.number().min(0).max(1).default(0).optional(),
-  /**
-   * The timestamp granularities to populate for this transcription.
-   * @default ['segment']
-   */
-  timestampGranularities: z9.array(z9.enum(["word", "segment"])).default(["segment"]).optional()
-});
+import {
+  lazyValidator as lazyValidator9,
+  zodSchema as zodSchema9
+} from "@ai-sdk/provider-utils";
+import * as z10 from "zod/v4";
+var openAITranscriptionProviderOptions = lazyValidator9(
+  () => zodSchema9(
+    z10.object({
+      /**
+       * Additional information to include in the transcription response.
+       */
+      include: z10.array(z10.string()).optional(),
+      /**
+       * The language of the input audio in ISO-639-1 format.
+       */
+      language: z10.string().optional(),
+      /**
+       * An optional text to guide the model's style or continue a previous audio segment.
+       */
+      prompt: z10.string().optional(),
+      /**
+       * The sampling temperature, between 0 and 1.
+       * @default 0
+       */
+      temperature: z10.number().min(0).max(1).default(0).optional(),
+      /**
+       * The timestamp granularities to populate for this transcription.
+       * @default ['segment']
+       */
+      timestampGranularities: z10.array(z10.enum(["word", "segment"])).default(["segment"]).optional()
+    })
+  )
+);
 
 // src/transcription/openai-transcription-model.ts
 var languageMap = {
@@ -1889,32 +2013,6 @@ var OpenAITranscriptionModel = class {
     };
   }
 };
-var openaiTranscriptionResponseSchema = z10.object({
-  text: z10.string(),
-  language: z10.string().nullish(),
-  duration: z10.number().nullish(),
-  words: z10.array(
-    z10.object({
-      word: z10.string(),
-      start: z10.number(),
-      end: z10.number()
-    })
-  ).nullish(),
-  segments: z10.array(
-    z10.object({
-      id: z10.number(),
-      seek: z10.number(),
-      start: z10.number(),
-      end: z10.number(),
-      text: z10.string(),
-      tokens: z10.array(z10.number()),
-      temperature: z10.number(),
-      avg_logprob: z10.number(),
-      compression_ratio: z10.number(),
-      no_speech_prob: z10.number()
-    })
-  ).nullish()
-});
 
 // src/speech/openai-speech-model.ts
 import {
@@ -1923,11 +2021,23 @@ import {
   parseProviderOptions as parseProviderOptions5,
   postJsonToApi as postJsonToApi5
 } from "@ai-sdk/provider-utils";
-import { z as z11 } from "zod/v4";
-var OpenAIProviderOptionsSchema = z11.object({
-  instructions: z11.string().nullish(),
-  speed: z11.number().min(0.25).max(4).default(1).nullish()
-});
+
+// src/speech/openai-speech-options.ts
+import {
+  lazyValidator as lazyValidator10,
+  zodSchema as zodSchema10
+} from "@ai-sdk/provider-utils";
+import * as z11 from "zod/v4";
+var openaiSpeechProviderOptionsSchema = lazyValidator10(
+  () => zodSchema10(
+    z11.object({
+      instructions: z11.string().nullish(),
+      speed: z11.number().min(0.25).max(4).default(1).nullish()
+    })
+  )
+);
+
+// src/speech/openai-speech-model.ts
 var OpenAISpeechModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -1950,7 +2060,7 @@ var OpenAISpeechModel = class {
     const openAIOptions = await parseProviderOptions5({
       provider: "openai",
       providerOptions,
-      schema: OpenAIProviderOptionsSchema
+      schema: openaiSpeechProviderOptionsSchema
     });
     const requestBody = {
       model: this.modelId,
@@ -2040,31 +2150,42 @@ import {
   parseProviderOptions as parseProviderOptions7,
   postJsonToApi as postJsonToApi6
 } from "@ai-sdk/provider-utils";
-import { z as z19 } from "zod/v4";
 
 // src/responses/convert-to-openai-responses-input.ts
 import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError4
 } from "@ai-sdk/provider";
-import { convertToBase64 as convertToBase642, parseProviderOptions as parseProviderOptions6 } from "@ai-sdk/provider-utils";
-import { z as z13 } from "zod/v4";
+import {
+  convertToBase64 as convertToBase642,
+  parseProviderOptions as parseProviderOptions6,
+  validateTypes
+} from "@ai-sdk/provider-utils";
+import * as z13 from "zod/v4";
 
 // src/tool/local-shell.ts
-import { createProviderDefinedToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
-import { z as z12 } from "zod/v4";
-var localShellInputSchema = 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 = z12.object({
-  output: z12.string()
-});
+import {
+  createProviderDefinedToolFactoryWithOutputSchema,
+  lazySchema,
+  zodSchema as zodSchema11
+} from "@ai-sdk/provider-utils";
+import * as z12 from "zod/v4";
+var localShellInputSchema = lazySchema(
+  () => zodSchema11(
+    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 = lazySchema(
+  () => zodSchema11(z12.object({ output: z12.string() }))
+);
 var localShell = createProviderDefinedToolFactoryWithOutputSchema({
   id: "openai.local_shell",
   name: "local_shell",
@@ -2178,7 +2299,10 @@ async function convertToOpenAIResponsesInput({
                 break;
               }
               if (hasLocalShellTool && part.toolName === "local_shell") {
-                const parsedInput = localShellInputSchema.parse(part.input);
+                const parsedInput = await validateTypes({
+                  value: part.input,
+                  schema: localShellInputSchema
+                });
                 input.push({
                   type: "local_shell_call",
                   call_id: part.toolCallId,
@@ -2274,10 +2398,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 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;
           }
@@ -2332,34 +2460,585 @@ function mapOpenAIResponseFinishReason({
   }
 }
 
+// src/responses/openai-responses-api.ts
+import {
+  lazyValidator as lazyValidator11,
+  zodSchema as zodSchema12
+} from "@ai-sdk/provider-utils";
+import * as z14 from "zod/v4";
+var openaiResponsesChunkSchema = lazyValidator11(
+  () => zodSchema12(
+    z14.union([
+      z14.object({
+        type: z14.literal("response.output_text.delta"),
+        item_id: z14.string(),
+        delta: z14.string(),
+        logprobs: z14.array(
+          z14.object({
+            token: z14.string(),
+            logprob: z14.number(),
+            top_logprobs: z14.array(
+              z14.object({
+                token: z14.string(),
+                logprob: z14.number()
+              })
+            )
+          })
+        ).nullish()
+      }),
+      z14.object({
+        type: z14.enum(["response.completed", "response.incomplete"]),
+        response: z14.object({
+          incomplete_details: z14.object({ reason: z14.string() }).nullish(),
+          usage: z14.object({
+            input_tokens: z14.number(),
+            input_tokens_details: z14.object({ cached_tokens: z14.number().nullish() }).nullish(),
+            output_tokens: z14.number(),
+            output_tokens_details: z14.object({ reasoning_tokens: z14.number().nullish() }).nullish()
+          }),
+          service_tier: z14.string().nullish()
+        })
+      }),
+      z14.object({
+        type: z14.literal("response.created"),
+        response: z14.object({
+          id: z14.string(),
+          created_at: z14.number(),
+          model: z14.string(),
+          service_tier: z14.string().nullish()
+        })
+      }),
+      z14.object({
+        type: z14.literal("response.output_item.added"),
+        output_index: z14.number(),
+        item: z14.discriminatedUnion("type", [
+          z14.object({
+            type: z14.literal("message"),
+            id: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("reasoning"),
+            id: z14.string(),
+            encrypted_content: z14.string().nullish()
+          }),
+          z14.object({
+            type: z14.literal("function_call"),
+            id: z14.string(),
+            call_id: z14.string(),
+            name: z14.string(),
+            arguments: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("web_search_call"),
+            id: z14.string(),
+            status: z14.string(),
+            action: z14.object({
+              type: z14.literal("search"),
+              query: z14.string().optional()
+            }).nullish()
+          }),
+          z14.object({
+            type: z14.literal("computer_call"),
+            id: z14.string(),
+            status: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("file_search_call"),
+            id: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("image_generation_call"),
+            id: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("code_interpreter_call"),
+            id: z14.string(),
+            container_id: z14.string(),
+            code: z14.string().nullable(),
+            outputs: z14.array(
+              z14.discriminatedUnion("type", [
+                z14.object({ type: z14.literal("logs"), logs: z14.string() }),
+                z14.object({ type: z14.literal("image"), url: z14.string() })
+              ])
+            ).nullable(),
+            status: z14.string()
+          })
+        ])
+      }),
+      z14.object({
+        type: z14.literal("response.output_item.done"),
+        output_index: z14.number(),
+        item: z14.discriminatedUnion("type", [
+          z14.object({
+            type: z14.literal("message"),
+            id: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("reasoning"),
+            id: z14.string(),
+            encrypted_content: z14.string().nullish()
+          }),
+          z14.object({
+            type: z14.literal("function_call"),
+            id: z14.string(),
+            call_id: z14.string(),
+            name: z14.string(),
+            arguments: z14.string(),
+            status: z14.literal("completed")
+          }),
+          z14.object({
+            type: z14.literal("code_interpreter_call"),
+            id: z14.string(),
+            code: z14.string().nullable(),
+            container_id: z14.string(),
+            outputs: z14.array(
+              z14.discriminatedUnion("type", [
+                z14.object({ type: z14.literal("logs"), logs: z14.string() }),
+                z14.object({ type: z14.literal("image"), url: z14.string() })
+              ])
+            ).nullable()
+          }),
+          z14.object({
+            type: z14.literal("image_generation_call"),
+            id: z14.string(),
+            result: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("web_search_call"),
+            id: z14.string(),
+            status: z14.string(),
+            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()
+          }),
+          z14.object({
+            type: z14.literal("file_search_call"),
+            id: z14.string(),
+            queries: z14.array(z14.string()),
+            results: z14.array(
+              z14.object({
+                attributes: z14.record(z14.string(), z14.unknown()),
+                file_id: z14.string(),
+                filename: z14.string(),
+                score: z14.number(),
+                text: z14.string()
+              })
+            ).nullish()
+          }),
+          z14.object({
+            type: z14.literal("local_shell_call"),
+            id: z14.string(),
+            call_id: z14.string(),
+            action: z14.object({
+              type: z14.literal("exec"),
+              command: z14.array(z14.string()),
+              timeout_ms: z14.number().optional(),
+              user: z14.string().optional(),
+              working_directory: z14.string().optional(),
+              env: z14.record(z14.string(), z14.string()).optional()
+            })
+          }),
+          z14.object({
+            type: z14.literal("computer_call"),
+            id: z14.string(),
+            status: z14.literal("completed")
+          })
+        ])
+      }),
+      z14.object({
+        type: z14.literal("response.function_call_arguments.delta"),
+        item_id: z14.string(),
+        output_index: z14.number(),
+        delta: z14.string()
+      }),
+      z14.object({
+        type: z14.literal("response.image_generation_call.partial_image"),
+        item_id: z14.string(),
+        output_index: z14.number(),
+        partial_image_b64: z14.string()
+      }),
+      z14.object({
+        type: z14.literal("response.code_interpreter_call_code.delta"),
+        item_id: z14.string(),
+        output_index: z14.number(),
+        delta: z14.string()
+      }),
+      z14.object({
+        type: z14.literal("response.code_interpreter_call_code.done"),
+        item_id: z14.string(),
+        output_index: z14.number(),
+        code: z14.string()
+      }),
+      z14.object({
+        type: z14.literal("response.output_text.annotation.added"),
+        annotation: z14.discriminatedUnion("type", [
+          z14.object({
+            type: z14.literal("url_citation"),
+            url: z14.string(),
+            title: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("file_citation"),
+            file_id: z14.string(),
+            filename: z14.string().nullish(),
+            index: z14.number().nullish(),
+            start_index: z14.number().nullish(),
+            end_index: z14.number().nullish(),
+            quote: z14.string().nullish()
+          })
+        ])
+      }),
+      z14.object({
+        type: z14.literal("response.reasoning_summary_part.added"),
+        item_id: z14.string(),
+        summary_index: z14.number()
+      }),
+      z14.object({
+        type: z14.literal("response.reasoning_summary_text.delta"),
+        item_id: z14.string(),
+        summary_index: z14.number(),
+        delta: z14.string()
+      }),
+      z14.object({
+        type: z14.literal("error"),
+        code: z14.string(),
+        message: z14.string(),
+        param: z14.string().nullish(),
+        sequence_number: z14.number()
+      }),
+      z14.object({ type: z14.string() }).loose().transform((value) => ({
+        type: "unknown_chunk",
+        message: value.type
+      }))
+      // fallback for unknown chunks
+    ])
+  )
+);
+var openaiResponsesResponseSchema = lazyValidator11(
+  () => zodSchema12(
+    z14.object({
+      id: z14.string(),
+      created_at: z14.number(),
+      error: z14.object({
+        code: z14.string(),
+        message: z14.string()
+      }).nullish(),
+      model: z14.string(),
+      output: z14.array(
+        z14.discriminatedUnion("type", [
+          z14.object({
+            type: z14.literal("message"),
+            role: z14.literal("assistant"),
+            id: z14.string(),
+            content: z14.array(
+              z14.object({
+                type: z14.literal("output_text"),
+                text: z14.string(),
+                logprobs: z14.array(
+                  z14.object({
+                    token: z14.string(),
+                    logprob: z14.number(),
+                    top_logprobs: z14.array(
+                      z14.object({
+                        token: z14.string(),
+                        logprob: z14.number()
+                      })
+                    )
+                  })
+                ).nullish(),
+                annotations: z14.array(
+                  z14.discriminatedUnion("type", [
+                    z14.object({
+                      type: z14.literal("url_citation"),
+                      start_index: z14.number(),
+                      end_index: z14.number(),
+                      url: z14.string(),
+                      title: z14.string()
+                    }),
+                    z14.object({
+                      type: z14.literal("file_citation"),
+                      file_id: z14.string(),
+                      filename: z14.string().nullish(),
+                      index: z14.number().nullish(),
+                      start_index: z14.number().nullish(),
+                      end_index: z14.number().nullish(),
+                      quote: z14.string().nullish()
+                    }),
+                    z14.object({
+                      type: z14.literal("container_file_citation")
+                    })
+                  ])
+                )
+              })
+            )
+          }),
+          z14.object({
+            type: z14.literal("web_search_call"),
+            id: z14.string(),
+            status: z14.string(),
+            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()
+          }),
+          z14.object({
+            type: z14.literal("file_search_call"),
+            id: z14.string(),
+            queries: z14.array(z14.string()),
+            results: z14.array(
+              z14.object({
+                attributes: z14.record(z14.string(), z14.unknown()),
+                file_id: z14.string(),
+                filename: z14.string(),
+                score: z14.number(),
+                text: z14.string()
+              })
+            ).nullish()
+          }),
+          z14.object({
+            type: z14.literal("code_interpreter_call"),
+            id: z14.string(),
+            code: z14.string().nullable(),
+            container_id: z14.string(),
+            outputs: z14.array(
+              z14.discriminatedUnion("type", [
+                z14.object({ type: z14.literal("logs"), logs: z14.string() }),
+                z14.object({ type: z14.literal("image"), url: z14.string() })
+              ])
+            ).nullable()
+          }),
+          z14.object({
+            type: z14.literal("image_generation_call"),
+            id: z14.string(),
+            result: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("local_shell_call"),
+            id: z14.string(),
+            call_id: z14.string(),
+            action: z14.object({
+              type: z14.literal("exec"),
+              command: z14.array(z14.string()),
+              timeout_ms: z14.number().optional(),
+              user: z14.string().optional(),
+              working_directory: z14.string().optional(),
+              env: z14.record(z14.string(), z14.string()).optional()
+            })
+          }),
+          z14.object({
+            type: z14.literal("function_call"),
+            call_id: z14.string(),
+            name: z14.string(),
+            arguments: z14.string(),
+            id: z14.string()
+          }),
+          z14.object({
+            type: z14.literal("computer_call"),
+            id: z14.string(),
+            status: z14.string().optional()
+          }),
+          z14.object({
+            type: z14.literal("reasoning"),
+            id: z14.string(),
+            encrypted_content: z14.string().nullish(),
+            summary: z14.array(
+              z14.object({
+                type: z14.literal("summary_text"),
+                text: z14.string()
+              })
+            )
+          })
+        ])
+      ),
+      service_tier: z14.string().nullish(),
+      incomplete_details: z14.object({ reason: z14.string() }).nullish(),
+      usage: z14.object({
+        input_tokens: z14.number(),
+        input_tokens_details: z14.object({ cached_tokens: z14.number().nullish() }).nullish(),
+        output_tokens: z14.number(),
+        output_tokens_details: z14.object({ reasoning_tokens: z14.number().nullish() }).nullish()
+      })
+    })
+  )
+);
+
+// src/responses/openai-responses-options.ts
+import {
+  lazyValidator as lazyValidator12,
+  zodSchema as zodSchema13
+} from "@ai-sdk/provider-utils";
+import * as z15 from "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 = lazyValidator12(
+  () => zodSchema13(
+    z15.object({
+      include: z15.array(
+        z15.enum([
+          "reasoning.encrypted_content",
+          "file_search_call.results",
+          "message.output_text.logprobs"
+        ])
+      ).nullish(),
+      instructions: z15.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: z15.union([z15.boolean(), z15.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: z15.number().nullish(),
+      metadata: z15.any().nullish(),
+      parallelToolCalls: z15.boolean().nullish(),
+      previousResponseId: z15.string().nullish(),
+      promptCacheKey: z15.string().nullish(),
+      reasoningEffort: z15.string().nullish(),
+      reasoningSummary: z15.string().nullish(),
+      safetyIdentifier: z15.string().nullish(),
+      serviceTier: z15.enum(["auto", "flex", "priority"]).nullish(),
+      store: z15.boolean().nullish(),
+      strictJsonSchema: z15.boolean().nullish(),
+      textVerbosity: z15.enum(["low", "medium", "high"]).nullish(),
+      user: z15.string().nullish()
+    })
+  )
+);
+
 // src/responses/openai-responses-prepare-tools.ts
 import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError5
 } from "@ai-sdk/provider";
 
 // src/tool/code-interpreter.ts
-import { createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema2 } from "@ai-sdk/provider-utils";
-import { z as z14 } from "zod/v4";
-var codeInterpreterInputSchema = z14.object({
-  code: z14.string().nullish(),
-  containerId: z14.string()
-});
-var codeInterpreterOutputSchema = z14.object({
-  outputs: z14.array(
-    z14.discriminatedUnion("type", [
-      z14.object({ type: z14.literal("logs"), logs: z14.string() }),
-      z14.object({ type: z14.literal("image"), url: z14.string() })
-    ])
-  ).nullish()
-});
-var codeInterpreterArgsSchema = z14.object({
-  container: z14.union([
-    z14.string(),
-    z14.object({
-      fileIds: z14.array(z14.string()).optional()
+import {
+  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema2,
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema14
+} from "@ai-sdk/provider-utils";
+import * as z16 from "zod/v4";
+var codeInterpreterInputSchema = lazySchema2(
+  () => zodSchema14(
+    z16.object({
+      code: z16.string().nullish(),
+      containerId: z16.string()
     })
-  ]).optional()
-});
+  )
+);
+var codeInterpreterOutputSchema = lazySchema2(
+  () => zodSchema14(
+    z16.object({
+      outputs: z16.array(
+        z16.discriminatedUnion("type", [
+          z16.object({ type: z16.literal("logs"), logs: z16.string() }),
+          z16.object({ type: z16.literal("image"), url: z16.string() })
+        ])
+      ).nullish()
+    })
+  )
+);
+var codeInterpreterArgsSchema = lazySchema2(
+  () => zodSchema14(
+    z16.object({
+      container: z16.union([
+        z16.string(),
+        z16.object({
+          fileIds: z16.array(z16.string()).optional()
+        })
+      ]).optional()
+    })
+  )
+);
 var codeInterpreterToolFactory = createProviderDefinedToolFactoryWithOutputSchema2({
   id: "openai.code_interpreter",
   name: "code_interpreter",
@@ -2371,168 +3050,216 @@ var codeInterpreter = (args = {}) => {
 };
 
 // src/tool/file-search.ts
-import { createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema3 } from "@ai-sdk/provider-utils";
-import { z as z15 } from "zod/v4";
-var comparisonFilterSchema = z15.object({
-  key: z15.string(),
-  type: z15.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
-  value: z15.union([z15.string(), z15.number(), z15.boolean()])
+import {
+  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema3,
+  lazySchema as lazySchema3,
+  zodSchema as zodSchema15
+} from "@ai-sdk/provider-utils";
+import * as z17 from "zod/v4";
+var comparisonFilterSchema = z17.object({
+  key: z17.string(),
+  type: z17.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+  value: z17.union([z17.string(), z17.number(), z17.boolean()])
 });
-var compoundFilterSchema = z15.object({
-  type: z15.enum(["and", "or"]),
-  filters: z15.array(
-    z15.union([comparisonFilterSchema, z15.lazy(() => compoundFilterSchema)])
+var compoundFilterSchema = z17.object({
+  type: z17.enum(["and", "or"]),
+  filters: z17.array(
+    z17.union([comparisonFilterSchema, z17.lazy(() => compoundFilterSchema)])
   )
 });
-var fileSearchArgsSchema = z15.object({
-  vectorStoreIds: z15.array(z15.string()),
-  maxNumResults: z15.number().optional(),
-  ranking: z15.object({
-    ranker: z15.string().optional(),
-    scoreThreshold: z15.number().optional()
-  }).optional(),
-  filters: z15.union([comparisonFilterSchema, compoundFilterSchema]).optional()
-});
-var fileSearchOutputSchema = z15.object({
-  queries: z15.array(z15.string()),
-  results: z15.array(
-    z15.object({
-      attributes: z15.record(z15.string(), z15.unknown()),
-      fileId: z15.string(),
-      filename: z15.string(),
-      score: z15.number(),
-      text: z15.string()
+var fileSearchArgsSchema = lazySchema3(
+  () => zodSchema15(
+    z17.object({
+      vectorStoreIds: z17.array(z17.string()),
+      maxNumResults: z17.number().optional(),
+      ranking: z17.object({
+        ranker: z17.string().optional(),
+        scoreThreshold: z17.number().optional()
+      }).optional(),
+      filters: z17.union([comparisonFilterSchema, compoundFilterSchema]).optional()
     })
-  ).nullable()
-});
+  )
+);
+var fileSearchOutputSchema = lazySchema3(
+  () => zodSchema15(
+    z17.object({
+      queries: z17.array(z17.string()),
+      results: z17.array(
+        z17.object({
+          attributes: z17.record(z17.string(), z17.unknown()),
+          fileId: z17.string(),
+          filename: z17.string(),
+          score: z17.number(),
+          text: z17.string()
+        })
+      ).nullable()
+    })
+  )
+);
 var fileSearch = createProviderDefinedToolFactoryWithOutputSchema3({
   id: "openai.file_search",
   name: "file_search",
-  inputSchema: z15.object({}),
+  inputSchema: z17.object({}),
   outputSchema: fileSearchOutputSchema
 });
 
 // src/tool/web-search.ts
-import { createProviderDefinedToolFactory } from "@ai-sdk/provider-utils";
-import { z as z16 } from "zod/v4";
-var webSearchArgsSchema = z16.object({
-  filters: z16.object({
-    allowedDomains: z16.array(z16.string()).optional()
-  }).optional(),
-  searchContextSize: z16.enum(["low", "medium", "high"]).optional(),
-  userLocation: z16.object({
-    type: z16.literal("approximate"),
-    country: z16.string().optional(),
-    city: z16.string().optional(),
-    region: z16.string().optional(),
-    timezone: z16.string().optional()
-  }).optional()
-});
+import {
+  createProviderDefinedToolFactory,
+  lazySchema as lazySchema4,
+  zodSchema as zodSchema16
+} from "@ai-sdk/provider-utils";
+import * as z18 from "zod/v4";
+var webSearchArgsSchema = lazySchema4(
+  () => zodSchema16(
+    z18.object({
+      filters: z18.object({
+        allowedDomains: z18.array(z18.string()).optional()
+      }).optional(),
+      searchContextSize: z18.enum(["low", "medium", "high"]).optional(),
+      userLocation: z18.object({
+        type: z18.literal("approximate"),
+        country: z18.string().optional(),
+        city: z18.string().optional(),
+        region: z18.string().optional(),
+        timezone: z18.string().optional()
+      }).optional()
+    })
+  )
+);
+var webSearchInputSchema = lazySchema4(
+  () => zodSchema16(
+    z18.object({
+      action: z18.discriminatedUnion("type", [
+        z18.object({
+          type: z18.literal("search"),
+          query: z18.string().nullish()
+        }),
+        z18.object({
+          type: z18.literal("open_page"),
+          url: z18.string()
+        }),
+        z18.object({
+          type: z18.literal("find"),
+          url: z18.string(),
+          pattern: z18.string()
+        })
+      ]).nullish()
+    })
+  )
+);
 var webSearchToolFactory = createProviderDefinedToolFactory({
   id: "openai.web_search",
   name: "web_search",
-  inputSchema: z16.object({
-    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()
-  })
+  inputSchema: webSearchInputSchema
 });
 
 // src/tool/web-search-preview.ts
-import { createProviderDefinedToolFactory as createProviderDefinedToolFactory2 } from "@ai-sdk/provider-utils";
-import { z as z17 } from "zod/v4";
-var webSearchPreviewArgsSchema = z17.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: z17.enum(["low", "medium", "high"]).optional(),
-  /**
-   * User location information to provide geographically relevant search results.
-   */
-  userLocation: z17.object({
-    /**
-     * Type of location (always 'approximate')
-     */
-    type: z17.literal("approximate"),
-    /**
-     * Two-letter ISO country code (e.g., 'US', 'GB')
-     */
-    country: z17.string().optional(),
-    /**
-     * City name (free text, e.g., 'Minneapolis')
-     */
-    city: z17.string().optional(),
-    /**
-     * Region name (free text, e.g., 'Minnesota')
-     */
-    region: z17.string().optional(),
-    /**
-     * IANA timezone (e.g., 'America/Chicago')
-     */
-    timezone: z17.string().optional()
-  }).optional()
-});
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory2,
+  lazySchema as lazySchema5,
+  zodSchema as zodSchema17
+} from "@ai-sdk/provider-utils";
+import * as z19 from "zod/v4";
+var webSearchPreviewArgsSchema = lazySchema5(
+  () => zodSchema17(
+    z19.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: z19.enum(["low", "medium", "high"]).optional(),
+      /**
+       * User location information to provide geographically relevant search results.
+       */
+      userLocation: z19.object({
+        /**
+         * Type of location (always 'approximate')
+         */
+        type: z19.literal("approximate"),
+        /**
+         * Two-letter ISO country code (e.g., 'US', 'GB')
+         */
+        country: z19.string().optional(),
+        /**
+         * City name (free text, e.g., 'Minneapolis')
+         */
+        city: z19.string().optional(),
+        /**
+         * Region name (free text, e.g., 'Minnesota')
+         */
+        region: z19.string().optional(),
+        /**
+         * IANA timezone (e.g., 'America/Chicago')
+         */
+        timezone: z19.string().optional()
+      }).optional()
+    })
+  )
+);
+var webSearchPreviewInputSchema = lazySchema5(
+  () => zodSchema17(
+    z19.object({
+      action: z19.discriminatedUnion("type", [
+        z19.object({
+          type: z19.literal("search"),
+          query: z19.string().nullish()
+        }),
+        z19.object({
+          type: z19.literal("open_page"),
+          url: z19.string()
+        }),
+        z19.object({
+          type: z19.literal("find"),
+          url: z19.string(),
+          pattern: z19.string()
+        })
+      ]).nullish()
+    })
+  )
+);
 var webSearchPreview = createProviderDefinedToolFactory2({
   id: "openai.web_search_preview",
   name: "web_search_preview",
-  inputSchema: z17.object({
-    action: z17.discriminatedUnion("type", [
-      z17.object({
-        type: z17.literal("search"),
-        query: z17.string().nullish()
-      }),
-      z17.object({
-        type: z17.literal("open_page"),
-        url: z17.string()
-      }),
-      z17.object({
-        type: z17.literal("find"),
-        url: z17.string(),
-        pattern: z17.string()
-      })
-    ]).nullish()
-  })
+  inputSchema: webSearchPreviewInputSchema
 });
 
 // src/tool/image-generation.ts
-import { createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema4 } from "@ai-sdk/provider-utils";
-import { z as z18 } from "zod/v4";
-var imageGenerationArgsSchema = z18.object({
-  background: z18.enum(["auto", "opaque", "transparent"]).optional(),
-  inputFidelity: z18.enum(["low", "high"]).optional(),
-  inputImageMask: z18.object({
-    fileId: z18.string().optional(),
-    imageUrl: z18.string().optional()
-  }).optional(),
-  model: z18.string().optional(),
-  moderation: z18.enum(["auto"]).optional(),
-  outputCompression: z18.number().int().min(0).max(100).optional(),
-  outputFormat: z18.enum(["png", "jpeg", "webp"]).optional(),
-  quality: z18.enum(["auto", "low", "medium", "high"]).optional(),
-  size: z18.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
-}).strict();
-var imageGenerationOutputSchema = z18.object({
-  result: z18.string()
-});
+import {
+  createProviderDefinedToolFactoryWithOutputSchema as createProviderDefinedToolFactoryWithOutputSchema4,
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema18
+} from "@ai-sdk/provider-utils";
+import * as z20 from "zod/v4";
+var imageGenerationArgsSchema = lazySchema6(
+  () => zodSchema18(
+    z20.object({
+      background: z20.enum(["auto", "opaque", "transparent"]).optional(),
+      inputFidelity: z20.enum(["low", "high"]).optional(),
+      inputImageMask: z20.object({
+        fileId: z20.string().optional(),
+        imageUrl: z20.string().optional()
+      }).optional(),
+      model: z20.string().optional(),
+      moderation: z20.enum(["auto"]).optional(),
+      outputCompression: z20.number().int().min(0).max(100).optional(),
+      outputFormat: z20.enum(["png", "jpeg", "webp"]).optional(),
+      partialImages: z20.number().int().min(0).max(3).optional(),
+      quality: z20.enum(["auto", "low", "medium", "high"]).optional(),
+      size: z20.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+    }).strict()
+  )
+);
+var imageGenerationInputSchema = lazySchema6(() => zodSchema18(z20.object({})));
+var imageGenerationOutputSchema = lazySchema6(
+  () => zodSchema18(z20.object({ result: z20.string() }))
+);
 var imageGenerationToolFactory = createProviderDefinedToolFactoryWithOutputSchema4({
   id: "openai.image_generation",
   name: "image_generation",
-  inputSchema: z18.object({}),
+  inputSchema: imageGenerationInputSchema,
   outputSchema: imageGenerationOutputSchema
 });
 var imageGeneration = (args = {}) => {
@@ -2540,7 +3267,8 @@ var imageGeneration = (args = {}) => {
 };
 
 // src/responses/openai-responses-prepare-tools.ts
-function prepareResponsesTools({
+import { validateTypes as validateTypes2 } from "@ai-sdk/provider-utils";
+async function prepareResponsesTools({
   tools,
   toolChoice,
   strictJsonSchema
@@ -2565,7 +3293,10 @@ function prepareResponsesTools({
       case "provider-defined": {
         switch (tool.id) {
           case "openai.file_search": {
-            const args = fileSearchArgsSchema.parse(tool.args);
+            const args = await validateTypes2({
+              value: tool.args,
+              schema: fileSearchArgsSchema
+            });
             openaiTools.push({
               type: "file_search",
               vector_store_ids: args.vectorStoreIds,
@@ -2585,7 +3316,10 @@ function prepareResponsesTools({
             break;
           }
           case "openai.web_search_preview": {
-            const args = webSearchPreviewArgsSchema.parse(tool.args);
+            const args = await validateTypes2({
+              value: tool.args,
+              schema: webSearchPreviewArgsSchema
+            });
             openaiTools.push({
               type: "web_search_preview",
               search_context_size: args.searchContextSize,
@@ -2594,7 +3328,10 @@ function prepareResponsesTools({
             break;
           }
           case "openai.web_search": {
-            const args = webSearchArgsSchema.parse(tool.args);
+            const args = await validateTypes2({
+              value: tool.args,
+              schema: webSearchArgsSchema
+            });
             openaiTools.push({
               type: "web_search",
               filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : void 0,
@@ -2604,7 +3341,10 @@ function prepareResponsesTools({
             break;
           }
           case "openai.code_interpreter": {
-            const args = codeInterpreterArgsSchema.parse(tool.args);
+            const args = await validateTypes2({
+              value: tool.args,
+              schema: codeInterpreterArgsSchema
+            });
             openaiTools.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 }
@@ -2612,7 +3352,10 @@ function prepareResponsesTools({
             break;
           }
           case "openai.image_generation": {
-            const args = imageGenerationArgsSchema.parse(tool.args);
+            const args = await validateTypes2({
+              value: tool.args,
+              schema: imageGenerationArgsSchema
+            });
             openaiTools.push({
               type: "image_generation",
               background: args.background,
@@ -2663,83 +3406,6 @@ function prepareResponsesTools({
 }
 
 // src/responses/openai-responses-language-model.ts
-var webSearchCallItem = z19.object({
-  type: z19.literal("web_search_call"),
-  id: z19.string(),
-  status: z19.string(),
-  action: z19.discriminatedUnion("type", [
-    z19.object({
-      type: z19.literal("search"),
-      query: z19.string().nullish()
-    }),
-    z19.object({
-      type: z19.literal("open_page"),
-      url: z19.string()
-    }),
-    z19.object({
-      type: z19.literal("find"),
-      url: z19.string(),
-      pattern: z19.string()
-    })
-  ]).nullish()
-});
-var fileSearchCallItem = z19.object({
-  type: z19.literal("file_search_call"),
-  id: z19.string(),
-  queries: z19.array(z19.string()),
-  results: z19.array(
-    z19.object({
-      attributes: z19.record(z19.string(), z19.unknown()),
-      file_id: z19.string(),
-      filename: z19.string(),
-      score: z19.number(),
-      text: z19.string()
-    })
-  ).nullish()
-});
-var codeInterpreterCallItem = z19.object({
-  type: z19.literal("code_interpreter_call"),
-  id: z19.string(),
-  code: z19.string().nullable(),
-  container_id: z19.string(),
-  outputs: z19.array(
-    z19.discriminatedUnion("type", [
-      z19.object({ type: z19.literal("logs"), logs: z19.string() }),
-      z19.object({ type: z19.literal("image"), url: z19.string() })
-    ])
-  ).nullable()
-});
-var localShellCallItem = z19.object({
-  type: z19.literal("local_shell_call"),
-  id: z19.string(),
-  call_id: z19.string(),
-  action: z19.object({
-    type: z19.literal("exec"),
-    command: z19.array(z19.string()),
-    timeout_ms: z19.number().optional(),
-    user: z19.string().optional(),
-    working_directory: z19.string().optional(),
-    env: z19.record(z19.string(), z19.string()).optional()
-  })
-});
-var imageGenerationCallItem = z19.object({
-  type: z19.literal("image_generation_call"),
-  id: z19.string(),
-  result: z19.string()
-});
-var TOP_LOGPROBS_MAX = 20;
-var LOGPROBS_SCHEMA = z19.array(
-  z19.object({
-    token: z19.string(),
-    logprob: z19.number(),
-    top_logprobs: z19.array(
-      z19.object({
-        token: z19.string(),
-        logprob: z19.number()
-      })
-    )
-  })
-);
 var OpenAIResponsesLanguageModel = class {
   constructor(modelId, config) {
     this.specificationVersion = "v2";
@@ -2931,7 +3597,7 @@ var OpenAIResponsesLanguageModel = class {
       tools: openaiTools,
       toolChoice: openaiToolChoice,
       toolWarnings
-    } = prepareResponsesTools({
+    } = await prepareResponsesTools({
       tools,
       toolChoice,
       strictJsonSchema
@@ -2967,85 +3633,7 @@ var OpenAIResponsesLanguageModel = class {
       body,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler6(
-        z19.object({
-          id: z19.string(),
-          created_at: z19.number(),
-          error: z19.object({
-            code: z19.string(),
-            message: z19.string()
-          }).nullish(),
-          model: z19.string(),
-          output: z19.array(
-            z19.discriminatedUnion("type", [
-              z19.object({
-                type: z19.literal("message"),
-                role: z19.literal("assistant"),
-                id: z19.string(),
-                content: z19.array(
-                  z19.object({
-                    type: z19.literal("output_text"),
-                    text: z19.string(),
-                    logprobs: LOGPROBS_SCHEMA.nullish(),
-                    annotations: z19.array(
-                      z19.discriminatedUnion("type", [
-                        z19.object({
-                          type: z19.literal("url_citation"),
-                          start_index: z19.number(),
-                          end_index: z19.number(),
-                          url: z19.string(),
-                          title: z19.string()
-                        }),
-                        z19.object({
-                          type: z19.literal("file_citation"),
-                          file_id: z19.string(),
-                          filename: z19.string().nullish(),
-                          index: z19.number().nullish(),
-                          start_index: z19.number().nullish(),
-                          end_index: z19.number().nullish(),
-                          quote: z19.string().nullish()
-                        }),
-                        z19.object({
-                          type: z19.literal("container_file_citation")
-                        })
-                      ])
-                    )
-                  })
-                )
-              }),
-              webSearchCallItem,
-              fileSearchCallItem,
-              codeInterpreterCallItem,
-              imageGenerationCallItem,
-              localShellCallItem,
-              z19.object({
-                type: z19.literal("function_call"),
-                call_id: z19.string(),
-                name: z19.string(),
-                arguments: z19.string(),
-                id: z19.string()
-              }),
-              z19.object({
-                type: z19.literal("computer_call"),
-                id: z19.string(),
-                status: z19.string().optional()
-              }),
-              z19.object({
-                type: z19.literal("reasoning"),
-                id: z19.string(),
-                encrypted_content: z19.string().nullish(),
-                summary: z19.array(
-                  z19.object({
-                    type: z19.literal("summary_text"),
-                    text: z19.string()
-                  })
-                )
-              })
-            ])
-          ),
-          service_tier: z19.string().nullish(),
-          incomplete_details: z19.object({ reason: z19.string() }).nullish(),
-          usage: usageSchema2
-        })
+        openaiResponsesResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -3108,7 +3696,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
@@ -3362,7 +3952,8 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "tool-input-start",
                   id: value.item.id,
-                  toolName: webSearchToolName != null ? webSearchToolName : "web_search"
+                  toolName: webSearchToolName != null ? webSearchToolName : "web_search",
+                  providerExecuted: true
                 });
               } else if (value.item.type === "computer_call") {
                 ongoingToolCalls[value.output_index] = {
@@ -3372,7 +3963,8 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "tool-input-start",
                   id: value.item.id,
-                  toolName: "computer_use"
+                  toolName: "computer_use",
+                  providerExecuted: true
                 });
               } else if (value.item.type === "code_interpreter_call") {
                 ongoingToolCalls[value.output_index] = {
@@ -3385,7 +3977,8 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "tool-input-start",
                   id: value.item.id,
-                  toolName: "code_interpreter"
+                  toolName: "code_interpreter",
+                  providerExecuted: true
                 });
                 controller.enqueue({
                   type: "tool-input-delta",
@@ -3725,196 +4318,6 @@ var OpenAIResponsesLanguageModel = class {
     };
   }
 };
-var usageSchema2 = z19.object({
-  input_tokens: z19.number(),
-  input_tokens_details: z19.object({ cached_tokens: z19.number().nullish() }).nullish(),
-  output_tokens: z19.number(),
-  output_tokens_details: z19.object({ reasoning_tokens: z19.number().nullish() }).nullish()
-});
-var textDeltaChunkSchema = z19.object({
-  type: z19.literal("response.output_text.delta"),
-  item_id: z19.string(),
-  delta: z19.string(),
-  logprobs: LOGPROBS_SCHEMA.nullish()
-});
-var errorChunkSchema = z19.object({
-  type: z19.literal("error"),
-  code: z19.string(),
-  message: z19.string(),
-  param: z19.string().nullish(),
-  sequence_number: z19.number()
-});
-var responseFinishedChunkSchema = z19.object({
-  type: z19.enum(["response.completed", "response.incomplete"]),
-  response: z19.object({
-    incomplete_details: z19.object({ reason: z19.string() }).nullish(),
-    usage: usageSchema2,
-    service_tier: z19.string().nullish()
-  })
-});
-var responseCreatedChunkSchema = z19.object({
-  type: z19.literal("response.created"),
-  response: z19.object({
-    id: z19.string(),
-    created_at: z19.number(),
-    model: z19.string(),
-    service_tier: z19.string().nullish()
-  })
-});
-var responseOutputItemAddedSchema = z19.object({
-  type: z19.literal("response.output_item.added"),
-  output_index: z19.number(),
-  item: z19.discriminatedUnion("type", [
-    z19.object({
-      type: z19.literal("message"),
-      id: z19.string()
-    }),
-    z19.object({
-      type: z19.literal("reasoning"),
-      id: z19.string(),
-      encrypted_content: z19.string().nullish()
-    }),
-    z19.object({
-      type: z19.literal("function_call"),
-      id: z19.string(),
-      call_id: z19.string(),
-      name: z19.string(),
-      arguments: z19.string()
-    }),
-    z19.object({
-      type: z19.literal("web_search_call"),
-      id: z19.string(),
-      status: z19.string(),
-      action: z19.object({
-        type: z19.literal("search"),
-        query: z19.string().optional()
-      }).nullish()
-    }),
-    z19.object({
-      type: z19.literal("computer_call"),
-      id: z19.string(),
-      status: z19.string()
-    }),
-    z19.object({
-      type: z19.literal("file_search_call"),
-      id: z19.string()
-    }),
-    z19.object({
-      type: z19.literal("image_generation_call"),
-      id: z19.string()
-    }),
-    z19.object({
-      type: z19.literal("code_interpreter_call"),
-      id: z19.string(),
-      container_id: z19.string(),
-      code: z19.string().nullable(),
-      outputs: z19.array(
-        z19.discriminatedUnion("type", [
-          z19.object({ type: z19.literal("logs"), logs: z19.string() }),
-          z19.object({ type: z19.literal("image"), url: z19.string() })
-        ])
-      ).nullable(),
-      status: z19.string()
-    })
-  ])
-});
-var responseOutputItemDoneSchema = z19.object({
-  type: z19.literal("response.output_item.done"),
-  output_index: z19.number(),
-  item: z19.discriminatedUnion("type", [
-    z19.object({
-      type: z19.literal("message"),
-      id: z19.string()
-    }),
-    z19.object({
-      type: z19.literal("reasoning"),
-      id: z19.string(),
-      encrypted_content: z19.string().nullish()
-    }),
-    z19.object({
-      type: z19.literal("function_call"),
-      id: z19.string(),
-      call_id: z19.string(),
-      name: z19.string(),
-      arguments: z19.string(),
-      status: z19.literal("completed")
-    }),
-    codeInterpreterCallItem,
-    imageGenerationCallItem,
-    webSearchCallItem,
-    fileSearchCallItem,
-    localShellCallItem,
-    z19.object({
-      type: z19.literal("computer_call"),
-      id: z19.string(),
-      status: z19.literal("completed")
-    })
-  ])
-});
-var responseFunctionCallArgumentsDeltaSchema = z19.object({
-  type: z19.literal("response.function_call_arguments.delta"),
-  item_id: z19.string(),
-  output_index: z19.number(),
-  delta: z19.string()
-});
-var responseCodeInterpreterCallCodeDeltaSchema = z19.object({
-  type: z19.literal("response.code_interpreter_call_code.delta"),
-  item_id: z19.string(),
-  output_index: z19.number(),
-  delta: z19.string()
-});
-var responseCodeInterpreterCallCodeDoneSchema = z19.object({
-  type: z19.literal("response.code_interpreter_call_code.done"),
-  item_id: z19.string(),
-  output_index: z19.number(),
-  code: z19.string()
-});
-var responseAnnotationAddedSchema = z19.object({
-  type: z19.literal("response.output_text.annotation.added"),
-  annotation: z19.discriminatedUnion("type", [
-    z19.object({
-      type: z19.literal("url_citation"),
-      url: z19.string(),
-      title: z19.string()
-    }),
-    z19.object({
-      type: z19.literal("file_citation"),
-      file_id: z19.string(),
-      filename: z19.string().nullish(),
-      index: z19.number().nullish(),
-      start_index: z19.number().nullish(),
-      end_index: z19.number().nullish(),
-      quote: z19.string().nullish()
-    })
-  ])
-});
-var responseReasoningSummaryPartAddedSchema = z19.object({
-  type: z19.literal("response.reasoning_summary_part.added"),
-  item_id: z19.string(),
-  summary_index: z19.number()
-});
-var responseReasoningSummaryTextDeltaSchema = z19.object({
-  type: z19.literal("response.reasoning_summary_text.delta"),
-  item_id: z19.string(),
-  summary_index: z19.number(),
-  delta: z19.string()
-});
-var openaiResponsesChunkSchema = z19.union([
-  textDeltaChunkSchema,
-  responseFinishedChunkSchema,
-  responseCreatedChunkSchema,
-  responseOutputItemAddedSchema,
-  responseOutputItemDoneSchema,
-  responseFunctionCallArgumentsDeltaSchema,
-  responseCodeInterpreterCallCodeDeltaSchema,
-  responseCodeInterpreterCallCodeDoneSchema,
-  responseAnnotationAddedSchema,
-  responseReasoningSummaryPartAddedSchema,
-  responseReasoningSummaryTextDeltaSchema,
-  errorChunkSchema,
-  z19.object({ type: z19.string() }).loose()
-  // fallback for unknown chunks
-]);
 function isTextDeltaChunk(chunk) {
   return chunk.type === "response.output_text.delta";
 }
@@ -3991,47 +4394,6 @@ function getResponsesModelConfig(modelId) {
     isReasoningModel: false
   };
 }
-var openaiResponsesProviderOptionsSchema = z19.object({
-  include: z19.array(
-    z19.enum([
-      "reasoning.encrypted_content",
-      "file_search_call.results",
-      "message.output_text.logprobs"
-    ])
-  ).nullish(),
-  instructions: z19.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: z19.union([z19.boolean(), z19.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: z19.number().nullish(),
-  metadata: z19.any().nullish(),
-  parallelToolCalls: z19.boolean().nullish(),
-  previousResponseId: z19.string().nullish(),
-  promptCacheKey: z19.string().nullish(),
-  reasoningEffort: z19.string().nullish(),
-  reasoningSummary: z19.string().nullish(),
-  safetyIdentifier: z19.string().nullish(),
-  serviceTier: z19.enum(["auto", "flex", "priority"]).nullish(),
-  store: z19.boolean().nullish(),
-  strictJsonSchema: z19.boolean().nullish(),
-  textVerbosity: z19.enum(["low", "medium", "high"]).nullish(),
-  user: z19.string().nullish()
-});
 export {
   OpenAIChatLanguageModel,
   OpenAICompletionLanguageModel,
@@ -4056,6 +4418,7 @@ export {
   openAITranscriptionProviderOptions,
   openaiChatLanguageModelOptions,
   openaiCompletionProviderOptions,
-  openaiEmbeddingProviderOptions
+  openaiEmbeddingProviderOptions,
+  openaiSpeechProviderOptionsSchema
 };
 //# sourceMappingURL=index.mjs.map