@ai-sdk/openai 2.0.46 → 2.0.48

package/dist/internal/index.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,14 +15,6 @@ 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/internal/index.ts
@@ -63,17 +53,17 @@ var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
 // src/openai-error.ts
-var z = __toESM(require("zod/v4"));
+var import_v4 = require("zod/v4");
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var openaiErrorDataSchema = z.object({
-  error: z.object({
-    message: z.string(),
+var openaiErrorDataSchema = import_v4.z.object({
+  error: import_v4.z.object({
+    message: import_v4.z.string(),
     // The additional information below is handled loosely to support
     // OpenAI-compatible providers that have slightly different error
     // responses:
-    type: z.string().nullish(),
-    param: z.any().nullish(),
-    code: z.union([z.string(), z.number()]).nullish()
+    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()
   })
 });
 var openaiFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
@@ -291,67 +281,67 @@ 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 import_v42 = 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()
+    import_v42.z.object({
+      id: import_v42.z.string().nullish(),
+      created: import_v42.z.number().nullish(),
+      model: import_v42.z.string().nullish(),
+      choices: import_v42.z.array(
+        import_v42.z.object({
+          message: import_v42.z.object({
+            role: import_v42.z.literal("assistant").nullish(),
+            content: import_v42.z.string().nullish(),
+            tool_calls: import_v42.z.array(
+              import_v42.z.object({
+                id: import_v42.z.string().nullish(),
+                type: import_v42.z.literal("function"),
+                function: import_v42.z.object({
+                  name: import_v42.z.string(),
+                  arguments: import_v42.z.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()
+            annotations: import_v42.z.array(
+              import_v42.z.object({
+                type: import_v42.z.literal("url_citation"),
+                start_index: import_v42.z.number(),
+                end_index: import_v42.z.number(),
+                url: import_v42.z.string(),
+                title: import_v42.z.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()
+          index: import_v42.z.number(),
+          logprobs: import_v42.z.object({
+            content: import_v42.z.array(
+              import_v42.z.object({
+                token: import_v42.z.string(),
+                logprob: import_v42.z.number(),
+                top_logprobs: import_v42.z.array(
+                  import_v42.z.object({
+                    token: import_v42.z.string(),
+                    logprob: import_v42.z.number()
                   })
                 )
               })
             ).nullish()
           }).nullish(),
-          finish_reason: z2.string().nullish()
+          finish_reason: import_v42.z.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()
+      usage: import_v42.z.object({
+        prompt_tokens: import_v42.z.number().nullish(),
+        completion_tokens: import_v42.z.number().nullish(),
+        total_tokens: import_v42.z.number().nullish(),
+        prompt_tokens_details: import_v42.z.object({
+          cached_tokens: import_v42.z.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()
+        completion_tokens_details: import_v42.z.object({
+          reasoning_tokens: import_v42.z.number().nullish(),
+          accepted_prediction_tokens: import_v42.z.number().nullish(),
+          rejected_prediction_tokens: import_v42.z.number().nullish()
         }).nullish()
       }).nullish()
     })
@@ -359,66 +349,66 @@ var openaiChatResponseSchema = (0, import_provider_utils3.lazyValidator)(
 );
 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()
+    import_v42.z.union([
+      import_v42.z.object({
+        id: import_v42.z.string().nullish(),
+        created: import_v42.z.number().nullish(),
+        model: import_v42.z.string().nullish(),
+        choices: import_v42.z.array(
+          import_v42.z.object({
+            delta: import_v42.z.object({
+              role: import_v42.z.enum(["assistant"]).nullish(),
+              content: import_v42.z.string().nullish(),
+              tool_calls: import_v42.z.array(
+                import_v42.z.object({
+                  index: import_v42.z.number(),
+                  id: import_v42.z.string().nullish(),
+                  type: import_v42.z.literal("function").nullish(),
+                  function: import_v42.z.object({
+                    name: import_v42.z.string().nullish(),
+                    arguments: import_v42.z.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()
+              annotations: import_v42.z.array(
+                import_v42.z.object({
+                  type: import_v42.z.literal("url_citation"),
+                  start_index: import_v42.z.number(),
+                  end_index: import_v42.z.number(),
+                  url: import_v42.z.string(),
+                  title: import_v42.z.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()
+            logprobs: import_v42.z.object({
+              content: import_v42.z.array(
+                import_v42.z.object({
+                  token: import_v42.z.string(),
+                  logprob: import_v42.z.number(),
+                  top_logprobs: import_v42.z.array(
+                    import_v42.z.object({
+                      token: import_v42.z.string(),
+                      logprob: import_v42.z.number()
                     })
                   )
                 })
               ).nullish()
             }).nullish(),
-            finish_reason: z2.string().nullish(),
-            index: z2.number()
+            finish_reason: import_v42.z.string().nullish(),
+            index: import_v42.z.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()
+        usage: import_v42.z.object({
+          prompt_tokens: import_v42.z.number().nullish(),
+          completion_tokens: import_v42.z.number().nullish(),
+          total_tokens: import_v42.z.number().nullish(),
+          prompt_tokens_details: import_v42.z.object({
+            cached_tokens: import_v42.z.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()
+          completion_tokens_details: import_v42.z.object({
+            reasoning_tokens: import_v42.z.number().nullish(),
+            accepted_prediction_tokens: import_v42.z.number().nullish(),
+            rejected_prediction_tokens: import_v42.z.number().nullish()
           }).nullish()
         }).nullish()
       }),
@@ -429,17 +419,17 @@ var openaiChatChunkSchema = (0, import_provider_utils3.lazyValidator)(
 
 // src/chat/openai-chat-options.ts
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var z3 = __toESM(require("zod/v4"));
+var import_v43 = require("zod/v4");
 var openaiChatLanguageModelOptions = (0, import_provider_utils4.lazyValidator)(
   () => (0, import_provider_utils4.zodSchema)(
-    z3.object({
+    import_v43.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: z3.record(z3.coerce.number(), z3.number()).optional(),
+      logitBias: import_v43.z.record(import_v43.z.coerce.number(), import_v43.z.number()).optional(),
       /**
        * Return the log probabilities of the tokens.
        *
@@ -449,42 +439,42 @@ var openaiChatLanguageModelOptions = (0, import_provider_utils4.lazyValidator)(
        * 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(),
+      logprobs: import_v43.z.union([import_v43.z.boolean(), import_v43.z.number()]).optional(),
       /**
        * Whether to enable parallel function calling during tool use. Default to true.
        */
-      parallelToolCalls: z3.boolean().optional(),
+      parallelToolCalls: import_v43.z.boolean().optional(),
       /**
        * A unique identifier representing your end-user, which can help OpenAI to
        * monitor and detect abuse.
        */
-      user: z3.string().optional(),
+      user: import_v43.z.string().optional(),
       /**
        * Reasoning effort for reasoning models. Defaults to `medium`.
        */
-      reasoningEffort: z3.enum(["minimal", "low", "medium", "high"]).optional(),
+      reasoningEffort: import_v43.z.enum(["minimal", "low", "medium", "high"]).optional(),
       /**
        * Maximum number of completion tokens to generate. Useful for reasoning models.
        */
-      maxCompletionTokens: z3.number().optional(),
+      maxCompletionTokens: import_v43.z.number().optional(),
       /**
        * Whether to enable persistence in responses API.
        */
-      store: z3.boolean().optional(),
+      store: import_v43.z.boolean().optional(),
       /**
        * Metadata to associate with the request.
        */
-      metadata: z3.record(z3.string().max(64), z3.string().max(512)).optional(),
+      metadata: import_v43.z.record(import_v43.z.string().max(64), import_v43.z.string().max(512)).optional(),
       /**
        * Parameters for prediction mode.
        */
-      prediction: z3.record(z3.string(), z3.any()).optional(),
+      prediction: import_v43.z.record(import_v43.z.string(), import_v43.z.any()).optional(),
       /**
        * Whether to use structured outputs.
        *
        * @default true
        */
-      structuredOutputs: z3.boolean().optional(),
+      structuredOutputs: import_v43.z.boolean().optional(),
       /**
        * Service tier for the request.
        * - 'auto': Default service tier. The request will be processed with the service tier configured in the
@@ -495,23 +485,23 @@ var openaiChatLanguageModelOptions = (0, import_provider_utils4.lazyValidator)(
        *
        * @default 'auto'
        */
-      serviceTier: z3.enum(["auto", "flex", "priority", "default"]).optional(),
+      serviceTier: import_v43.z.enum(["auto", "flex", "priority", "default"]).optional(),
       /**
        * Whether to use strict JSON schema validation.
        *
        * @default false
        */
-      strictJsonSchema: z3.boolean().optional(),
+      strictJsonSchema: import_v43.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: z3.enum(["low", "medium", "high"]).optional(),
+      textVerbosity: import_v43.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: z3.string().optional(),
+      promptCacheKey: import_v43.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
@@ -519,7 +509,7 @@ var openaiChatLanguageModelOptions = (0, import_provider_utils4.lazyValidator)(
        * username or email address, in order to avoid sending us any identifying
        * information.
        */
-      safetyIdentifier: z3.string().optional()
+      safetyIdentifier: import_v43.z.string().optional()
     })
   )
 );
@@ -1236,56 +1226,56 @@ function mapOpenAIFinishReason2(finishReason) {
 }
 
 // src/completion/openai-completion-api.ts
-var z4 = __toESM(require("zod/v4"));
+var import_v44 = 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()
+    import_v44.z.object({
+      id: import_v44.z.string().nullish(),
+      created: import_v44.z.number().nullish(),
+      model: import_v44.z.string().nullish(),
+      choices: import_v44.z.array(
+        import_v44.z.object({
+          text: import_v44.z.string(),
+          finish_reason: import_v44.z.string(),
+          logprobs: import_v44.z.object({
+            tokens: import_v44.z.array(import_v44.z.string()),
+            token_logprobs: import_v44.z.array(import_v44.z.number()),
+            top_logprobs: import_v44.z.array(import_v44.z.record(import_v44.z.string(), import_v44.z.number())).nullish()
           }).nullish()
         })
       ),
-      usage: z4.object({
-        prompt_tokens: z4.number(),
-        completion_tokens: z4.number(),
-        total_tokens: z4.number()
+      usage: import_v44.z.object({
+        prompt_tokens: import_v44.z.number(),
+        completion_tokens: import_v44.z.number(),
+        total_tokens: import_v44.z.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()
+    import_v44.z.union([
+      import_v44.z.object({
+        id: import_v44.z.string().nullish(),
+        created: import_v44.z.number().nullish(),
+        model: import_v44.z.string().nullish(),
+        choices: import_v44.z.array(
+          import_v44.z.object({
+            text: import_v44.z.string(),
+            finish_reason: import_v44.z.string().nullish(),
+            index: import_v44.z.number(),
+            logprobs: import_v44.z.object({
+              tokens: import_v44.z.array(import_v44.z.string()),
+              token_logprobs: import_v44.z.array(import_v44.z.number()),
+              top_logprobs: import_v44.z.array(import_v44.z.record(import_v44.z.string(), import_v44.z.number())).nullish()
             }).nullish()
           })
         ),
-        usage: z4.object({
-          prompt_tokens: z4.number(),
-          completion_tokens: z4.number(),
-          total_tokens: z4.number()
+        usage: import_v44.z.object({
+          prompt_tokens: import_v44.z.number(),
+          completion_tokens: import_v44.z.number(),
+          total_tokens: import_v44.z.number()
         }).nullish()
       }),
       openaiErrorDataSchema
@@ -1295,14 +1285,14 @@ var openaiCompletionChunkSchema = (0, import_provider_utils6.lazyValidator)(
 
 // src/completion/openai-completion-options.ts
 var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var z5 = __toESM(require("zod/v4"));
+var import_v45 = require("zod/v4");
 var openaiCompletionProviderOptions = (0, import_provider_utils7.lazyValidator)(
   () => (0, import_provider_utils7.zodSchema)(
-    z5.object({
+    import_v45.z.object({
       /**
       Echo back the prompt in addition to the completion.
          */
-      echo: z5.boolean().optional(),
+      echo: import_v45.z.boolean().optional(),
       /**
       Modify the likelihood of specified tokens appearing in the completion.
       
@@ -1317,16 +1307,16 @@ var openaiCompletionProviderOptions = (0, import_provider_utils7.lazyValidator)(
       As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
       token from being generated.
        */
-      logitBias: z5.record(z5.string(), z5.number()).optional(),
+      logitBias: import_v45.z.record(import_v45.z.string(), import_v45.z.number()).optional(),
       /**
       The suffix that comes after a completion of inserted text.
        */
-      suffix: z5.string().optional(),
+      suffix: import_v45.z.string().optional(),
       /**
       A unique identifier representing your end-user, which can help OpenAI to
       monitor and detect abuse. Learn more.
        */
-      user: z5.string().optional(),
+      user: import_v45.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
@@ -1336,7 +1326,7 @@ var openaiCompletionProviderOptions = (0, import_provider_utils7.lazyValidator)(
       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()
+      logprobs: import_v45.z.union([import_v45.z.boolean(), import_v45.z.number()]).optional()
     })
   )
 );
@@ -1577,32 +1567,32 @@ var import_provider_utils11 = require("@ai-sdk/provider-utils");
 
 // src/embedding/openai-embedding-options.ts
 var import_provider_utils9 = require("@ai-sdk/provider-utils");
-var z6 = __toESM(require("zod/v4"));
+var import_v46 = require("zod/v4");
 var openaiEmbeddingProviderOptions = (0, import_provider_utils9.lazyValidator)(
   () => (0, import_provider_utils9.zodSchema)(
-    z6.object({
+    import_v46.z.object({
       /**
       The number of dimensions the resulting output embeddings should have.
       Only supported in text-embedding-3 and later models.
          */
-      dimensions: z6.number().optional(),
+      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: z6.string().optional()
+      user: import_v46.z.string().optional()
     })
   )
 );
 
 // src/embedding/openai-embedding-api.ts
 var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var z7 = __toESM(require("zod/v4"));
+var import_v47 = 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()
+    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()
     })
   )
 );
@@ -1676,14 +1666,14 @@ 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 import_v48 = 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()
+    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()
         })
       )
     })
@@ -1786,32 +1776,32 @@ var import_provider_utils16 = require("@ai-sdk/provider-utils");
 
 // src/transcription/openai-transcription-api.ts
 var import_provider_utils14 = require("@ai-sdk/provider-utils");
-var z9 = __toESM(require("zod/v4"));
+var import_v49 = require("zod/v4");
 var openaiTranscriptionResponseSchema = (0, import_provider_utils14.lazyValidator)(
   () => (0, import_provider_utils14.zodSchema)(
-    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()
+    import_v49.z.object({
+      text: import_v49.z.string(),
+      language: import_v49.z.string().nullish(),
+      duration: import_v49.z.number().nullish(),
+      words: import_v49.z.array(
+        import_v49.z.object({
+          word: import_v49.z.string(),
+          start: import_v49.z.number(),
+          end: import_v49.z.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()
+      segments: import_v49.z.array(
+        import_v49.z.object({
+          id: import_v49.z.number(),
+          seek: import_v49.z.number(),
+          start: import_v49.z.number(),
+          end: import_v49.z.number(),
+          text: import_v49.z.string(),
+          tokens: import_v49.z.array(import_v49.z.number()),
+          temperature: import_v49.z.number(),
+          avg_logprob: import_v49.z.number(),
+          compression_ratio: import_v49.z.number(),
+          no_speech_prob: import_v49.z.number()
         })
       ).nullish()
     })
@@ -1820,32 +1810,32 @@ var openaiTranscriptionResponseSchema = (0, import_provider_utils14.lazyValidato
 
 // src/transcription/openai-transcription-options.ts
 var import_provider_utils15 = require("@ai-sdk/provider-utils");
-var z10 = __toESM(require("zod/v4"));
+var import_v410 = require("zod/v4");
 var openAITranscriptionProviderOptions = (0, import_provider_utils15.lazyValidator)(
   () => (0, import_provider_utils15.zodSchema)(
-    z10.object({
+    import_v410.z.object({
       /**
        * Additional information to include in the transcription response.
        */
-      include: z10.array(z10.string()).optional(),
+      include: import_v410.z.array(import_v410.z.string()).optional(),
       /**
        * The language of the input audio in ISO-639-1 format.
        */
-      language: z10.string().optional(),
+      language: import_v410.z.string().optional(),
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */
-      prompt: z10.string().optional(),
+      prompt: import_v410.z.string().optional(),
       /**
        * The sampling temperature, between 0 and 1.
        * @default 0
        */
-      temperature: z10.number().min(0).max(1).default(0).optional(),
+      temperature: import_v410.z.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()
+      timestampGranularities: import_v410.z.array(import_v410.z.enum(["word", "segment"])).default(["segment"]).optional()
     })
   )
 );
@@ -2022,12 +2012,12 @@ var import_provider_utils18 = require("@ai-sdk/provider-utils");
 
 // src/speech/openai-speech-options.ts
 var import_provider_utils17 = require("@ai-sdk/provider-utils");
-var z11 = __toESM(require("zod/v4"));
+var import_v411 = require("zod/v4");
 var openaiSpeechProviderOptionsSchema = (0, import_provider_utils17.lazyValidator)(
   () => (0, import_provider_utils17.zodSchema)(
-    z11.object({
-      instructions: z11.string().nullish(),
-      speed: z11.number().min(0.25).max(4).default(1).nullish()
+    import_v411.z.object({
+      instructions: import_v411.z.string().nullish(),
+      speed: import_v411.z.number().min(0.25).max(4).default(1).nullish()
     })
   )
 );
@@ -2140,27 +2130,27 @@ var import_provider_utils29 = require("@ai-sdk/provider-utils");
 // src/responses/convert-to-openai-responses-input.ts
 var import_provider6 = require("@ai-sdk/provider");
 var import_provider_utils20 = require("@ai-sdk/provider-utils");
-var z13 = __toESM(require("zod/v4"));
+var import_v413 = require("zod/v4");
 
 // src/tool/local-shell.ts
 var import_provider_utils19 = require("@ai-sdk/provider-utils");
-var z12 = __toESM(require("zod/v4"));
+var import_v412 = require("zod/v4");
 var localShellInputSchema = (0, import_provider_utils19.lazySchema)(
   () => (0, import_provider_utils19.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()
+    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 = (0, import_provider_utils19.lazySchema)(
-  () => (0, import_provider_utils19.zodSchema)(z12.object({ output: z12.string() }))
+  () => (0, import_provider_utils19.zodSchema)(import_v412.z.object({ output: import_v412.z.string() }))
 );
 var localShell = (0, import_provider_utils19.createProviderDefinedToolFactoryWithOutputSchema)({
   id: "openai.local_shell",
@@ -2391,11 +2381,29 @@ async function convertToOpenAIResponsesInput({
             case "error-text":
               contentValue = output.value;
               break;
-            case "content":
             case "json":
             case "error-json":
               contentValue = JSON.stringify(output.value);
               break;
+            case "content":
+              contentValue = output.value.map((item) => {
+                switch (item.type) {
+                  case "text": {
+                    return { type: "input_text", text: item.text };
+                  }
+                  case "media": {
+                    return item.mediaType.startsWith("image/") ? {
+                      type: "input_image",
+                      image_url: `data:${item.mediaType};base64,${item.data}`
+                    } : {
+                      type: "input_file",
+                      filename: "data",
+                      file_data: `data:${item.mediaType};base64,${item.data}`
+                    };
+                  }
+                }
+              });
+              break;
           }
           input.push({
             type: "function_call_output",
@@ -2413,9 +2421,9 @@ async function convertToOpenAIResponsesInput({
   }
   return { input, warnings };
 }
-var openaiResponsesReasoningProviderOptionsSchema = z13.object({
-  itemId: z13.string().nullish(),
-  reasoningEncryptedContent: z13.string().nullish()
+var openaiResponsesReasoningProviderOptionsSchema = import_v413.z.object({
+  itemId: import_v413.z.string().nullish(),
+  reasoningEncryptedContent: import_v413.z.string().nullish()
 });
 
 // src/responses/map-openai-responses-finish-reason.ts
@@ -2438,260 +2446,260 @@ function mapOpenAIResponseFinishReason({
 
 // src/responses/openai-responses-api.ts
 var import_provider_utils21 = require("@ai-sdk/provider-utils");
-var z14 = __toESM(require("zod/v4"));
+var import_v414 = require("zod/v4");
 var openaiResponsesChunkSchema = (0, import_provider_utils21.lazyValidator)(
   () => (0, import_provider_utils21.zodSchema)(
-    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()
+    import_v414.z.union([
+      import_v414.z.object({
+        type: import_v414.z.literal("response.output_text.delta"),
+        item_id: import_v414.z.string(),
+        delta: import_v414.z.string(),
+        logprobs: import_v414.z.array(
+          import_v414.z.object({
+            token: import_v414.z.string(),
+            logprob: import_v414.z.number(),
+            top_logprobs: import_v414.z.array(
+              import_v414.z.object({
+                token: import_v414.z.string(),
+                logprob: import_v414.z.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()
+      import_v414.z.object({
+        type: import_v414.z.enum(["response.completed", "response.incomplete"]),
+        response: import_v414.z.object({
+          incomplete_details: import_v414.z.object({ reason: import_v414.z.string() }).nullish(),
+          usage: import_v414.z.object({
+            input_tokens: import_v414.z.number(),
+            input_tokens_details: import_v414.z.object({ cached_tokens: import_v414.z.number().nullish() }).nullish(),
+            output_tokens: import_v414.z.number(),
+            output_tokens_details: import_v414.z.object({ reasoning_tokens: import_v414.z.number().nullish() }).nullish()
           }),
-          service_tier: z14.string().nullish()
+          service_tier: import_v414.z.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()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.created"),
+        response: import_v414.z.object({
+          id: import_v414.z.string(),
+          created_at: import_v414.z.number(),
+          model: import_v414.z.string(),
+          service_tier: import_v414.z.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()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.output_item.added"),
+        output_index: import_v414.z.number(),
+        item: import_v414.z.discriminatedUnion("type", [
+          import_v414.z.object({
+            type: import_v414.z.literal("message"),
+            id: import_v414.z.string()
           }),
-          z14.object({
-            type: z14.literal("reasoning"),
-            id: z14.string(),
-            encrypted_content: z14.string().nullish()
+          import_v414.z.object({
+            type: import_v414.z.literal("reasoning"),
+            id: import_v414.z.string(),
+            encrypted_content: import_v414.z.string().nullish()
           }),
-          z14.object({
-            type: z14.literal("function_call"),
-            id: z14.string(),
-            call_id: z14.string(),
-            name: z14.string(),
-            arguments: z14.string()
+          import_v414.z.object({
+            type: import_v414.z.literal("function_call"),
+            id: import_v414.z.string(),
+            call_id: import_v414.z.string(),
+            name: import_v414.z.string(),
+            arguments: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("web_search_call"),
+            id: import_v414.z.string(),
+            status: import_v414.z.string(),
+            action: import_v414.z.object({
+              type: import_v414.z.literal("search"),
+              query: import_v414.z.string().optional()
             }).nullish()
           }),
-          z14.object({
-            type: z14.literal("computer_call"),
-            id: z14.string(),
-            status: z14.string()
+          import_v414.z.object({
+            type: import_v414.z.literal("computer_call"),
+            id: import_v414.z.string(),
+            status: import_v414.z.string()
           }),
-          z14.object({
-            type: z14.literal("file_search_call"),
-            id: z14.string()
+          import_v414.z.object({
+            type: import_v414.z.literal("file_search_call"),
+            id: import_v414.z.string()
           }),
-          z14.object({
-            type: z14.literal("image_generation_call"),
-            id: z14.string()
+          import_v414.z.object({
+            type: import_v414.z.literal("image_generation_call"),
+            id: import_v414.z.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() })
+          import_v414.z.object({
+            type: import_v414.z.literal("code_interpreter_call"),
+            id: import_v414.z.string(),
+            container_id: import_v414.z.string(),
+            code: import_v414.z.string().nullable(),
+            outputs: import_v414.z.array(
+              import_v414.z.discriminatedUnion("type", [
+                import_v414.z.object({ type: import_v414.z.literal("logs"), logs: import_v414.z.string() }),
+                import_v414.z.object({ type: import_v414.z.literal("image"), url: import_v414.z.string() })
               ])
             ).nullable(),
-            status: z14.string()
+            status: import_v414.z.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()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.output_item.done"),
+        output_index: import_v414.z.number(),
+        item: import_v414.z.discriminatedUnion("type", [
+          import_v414.z.object({
+            type: import_v414.z.literal("message"),
+            id: import_v414.z.string()
           }),
-          z14.object({
-            type: z14.literal("reasoning"),
-            id: z14.string(),
-            encrypted_content: z14.string().nullish()
+          import_v414.z.object({
+            type: import_v414.z.literal("reasoning"),
+            id: import_v414.z.string(),
+            encrypted_content: import_v414.z.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")
+          import_v414.z.object({
+            type: import_v414.z.literal("function_call"),
+            id: import_v414.z.string(),
+            call_id: import_v414.z.string(),
+            name: import_v414.z.string(),
+            arguments: import_v414.z.string(),
+            status: import_v414.z.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() })
+          import_v414.z.object({
+            type: import_v414.z.literal("code_interpreter_call"),
+            id: import_v414.z.string(),
+            code: import_v414.z.string().nullable(),
+            container_id: import_v414.z.string(),
+            outputs: import_v414.z.array(
+              import_v414.z.discriminatedUnion("type", [
+                import_v414.z.object({ type: import_v414.z.literal("logs"), logs: import_v414.z.string() }),
+                import_v414.z.object({ type: import_v414.z.literal("image"), url: import_v414.z.string() })
               ])
             ).nullable()
           }),
-          z14.object({
-            type: z14.literal("image_generation_call"),
-            id: z14.string(),
-            result: z14.string()
+          import_v414.z.object({
+            type: import_v414.z.literal("image_generation_call"),
+            id: import_v414.z.string(),
+            result: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("web_search_call"),
+            id: import_v414.z.string(),
+            status: import_v414.z.string(),
+            action: import_v414.z.discriminatedUnion("type", [
+              import_v414.z.object({
+                type: import_v414.z.literal("search"),
+                query: import_v414.z.string().nullish()
               }),
-              z14.object({
-                type: z14.literal("open_page"),
-                url: z14.string()
+              import_v414.z.object({
+                type: import_v414.z.literal("open_page"),
+                url: import_v414.z.string()
               }),
-              z14.object({
-                type: z14.literal("find"),
-                url: z14.string(),
-                pattern: z14.string()
+              import_v414.z.object({
+                type: import_v414.z.literal("find"),
+                url: import_v414.z.string(),
+                pattern: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("file_search_call"),
+            id: import_v414.z.string(),
+            queries: import_v414.z.array(import_v414.z.string()),
+            results: import_v414.z.array(
+              import_v414.z.object({
+                attributes: import_v414.z.record(import_v414.z.string(), import_v414.z.unknown()),
+                file_id: import_v414.z.string(),
+                filename: import_v414.z.string(),
+                score: import_v414.z.number(),
+                text: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("local_shell_call"),
+            id: import_v414.z.string(),
+            call_id: import_v414.z.string(),
+            action: import_v414.z.object({
+              type: import_v414.z.literal("exec"),
+              command: import_v414.z.array(import_v414.z.string()),
+              timeout_ms: import_v414.z.number().optional(),
+              user: import_v414.z.string().optional(),
+              working_directory: import_v414.z.string().optional(),
+              env: import_v414.z.record(import_v414.z.string(), import_v414.z.string()).optional()
             })
           }),
-          z14.object({
-            type: z14.literal("computer_call"),
-            id: z14.string(),
-            status: z14.literal("completed")
+          import_v414.z.object({
+            type: import_v414.z.literal("computer_call"),
+            id: import_v414.z.string(),
+            status: import_v414.z.literal("completed")
           })
         ])
       }),
-      z14.object({
-        type: z14.literal("response.function_call_arguments.delta"),
-        item_id: z14.string(),
-        output_index: z14.number(),
-        delta: z14.string()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.function_call_arguments.delta"),
+        item_id: import_v414.z.string(),
+        output_index: import_v414.z.number(),
+        delta: import_v414.z.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()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.image_generation_call.partial_image"),
+        item_id: import_v414.z.string(),
+        output_index: import_v414.z.number(),
+        partial_image_b64: import_v414.z.string()
       }),
-      z14.object({
-        type: z14.literal("response.code_interpreter_call_code.delta"),
-        item_id: z14.string(),
-        output_index: z14.number(),
-        delta: z14.string()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.code_interpreter_call_code.delta"),
+        item_id: import_v414.z.string(),
+        output_index: import_v414.z.number(),
+        delta: import_v414.z.string()
       }),
-      z14.object({
-        type: z14.literal("response.code_interpreter_call_code.done"),
-        item_id: z14.string(),
-        output_index: z14.number(),
-        code: z14.string()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.code_interpreter_call_code.done"),
+        item_id: import_v414.z.string(),
+        output_index: import_v414.z.number(),
+        code: import_v414.z.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()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.output_text.annotation.added"),
+        annotation: import_v414.z.discriminatedUnion("type", [
+          import_v414.z.object({
+            type: import_v414.z.literal("url_citation"),
+            url: import_v414.z.string(),
+            title: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("file_citation"),
+            file_id: import_v414.z.string(),
+            filename: import_v414.z.string().nullish(),
+            index: import_v414.z.number().nullish(),
+            start_index: import_v414.z.number().nullish(),
+            end_index: import_v414.z.number().nullish(),
+            quote: import_v414.z.string().nullish()
           })
         ])
       }),
-      z14.object({
-        type: z14.literal("response.reasoning_summary_part.added"),
-        item_id: z14.string(),
-        summary_index: z14.number()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.reasoning_summary_part.added"),
+        item_id: import_v414.z.string(),
+        summary_index: import_v414.z.number()
       }),
-      z14.object({
-        type: z14.literal("response.reasoning_summary_text.delta"),
-        item_id: z14.string(),
-        summary_index: z14.number(),
-        delta: z14.string()
+      import_v414.z.object({
+        type: import_v414.z.literal("response.reasoning_summary_text.delta"),
+        item_id: import_v414.z.string(),
+        summary_index: import_v414.z.number(),
+        delta: import_v414.z.string()
       }),
-      z14.object({
-        type: z14.literal("error"),
-        code: z14.string(),
-        message: z14.string(),
-        param: z14.string().nullish(),
-        sequence_number: z14.number()
+      import_v414.z.object({
+        type: import_v414.z.literal("error"),
+        code: import_v414.z.string(),
+        message: import_v414.z.string(),
+        param: import_v414.z.string().nullish(),
+        sequence_number: import_v414.z.number()
       }),
-      z14.object({ type: z14.string() }).loose().transform((value) => ({
+      import_v414.z.object({ type: import_v414.z.string() }).loose().transform((value) => ({
         type: "unknown_chunk",
         message: value.type
       }))
@@ -2701,158 +2709,158 @@ var openaiResponsesChunkSchema = (0, import_provider_utils21.lazyValidator)(
 );
 var openaiResponsesResponseSchema = (0, import_provider_utils21.lazyValidator)(
   () => (0, import_provider_utils21.zodSchema)(
-    z14.object({
-      id: z14.string(),
-      created_at: z14.number(),
-      error: z14.object({
-        code: z14.string(),
-        message: z14.string()
+    import_v414.z.object({
+      id: import_v414.z.string(),
+      created_at: import_v414.z.number(),
+      error: import_v414.z.object({
+        code: import_v414.z.string(),
+        message: import_v414.z.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()
+      model: import_v414.z.string(),
+      output: import_v414.z.array(
+        import_v414.z.discriminatedUnion("type", [
+          import_v414.z.object({
+            type: import_v414.z.literal("message"),
+            role: import_v414.z.literal("assistant"),
+            id: import_v414.z.string(),
+            content: import_v414.z.array(
+              import_v414.z.object({
+                type: import_v414.z.literal("output_text"),
+                text: import_v414.z.string(),
+                logprobs: import_v414.z.array(
+                  import_v414.z.object({
+                    token: import_v414.z.string(),
+                    logprob: import_v414.z.number(),
+                    top_logprobs: import_v414.z.array(
+                      import_v414.z.object({
+                        token: import_v414.z.string(),
+                        logprob: import_v414.z.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()
+                annotations: import_v414.z.array(
+                  import_v414.z.discriminatedUnion("type", [
+                    import_v414.z.object({
+                      type: import_v414.z.literal("url_citation"),
+                      start_index: import_v414.z.number(),
+                      end_index: import_v414.z.number(),
+                      url: import_v414.z.string(),
+                      title: import_v414.z.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()
+                    import_v414.z.object({
+                      type: import_v414.z.literal("file_citation"),
+                      file_id: import_v414.z.string(),
+                      filename: import_v414.z.string().nullish(),
+                      index: import_v414.z.number().nullish(),
+                      start_index: import_v414.z.number().nullish(),
+                      end_index: import_v414.z.number().nullish(),
+                      quote: import_v414.z.string().nullish()
                     }),
-                    z14.object({
-                      type: z14.literal("container_file_citation")
+                    import_v414.z.object({
+                      type: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("web_search_call"),
+            id: import_v414.z.string(),
+            status: import_v414.z.string(),
+            action: import_v414.z.discriminatedUnion("type", [
+              import_v414.z.object({
+                type: import_v414.z.literal("search"),
+                query: import_v414.z.string().nullish()
               }),
-              z14.object({
-                type: z14.literal("open_page"),
-                url: z14.string()
+              import_v414.z.object({
+                type: import_v414.z.literal("open_page"),
+                url: import_v414.z.string()
               }),
-              z14.object({
-                type: z14.literal("find"),
-                url: z14.string(),
-                pattern: z14.string()
+              import_v414.z.object({
+                type: import_v414.z.literal("find"),
+                url: import_v414.z.string(),
+                pattern: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("file_search_call"),
+            id: import_v414.z.string(),
+            queries: import_v414.z.array(import_v414.z.string()),
+            results: import_v414.z.array(
+              import_v414.z.object({
+                attributes: import_v414.z.record(import_v414.z.string(), import_v414.z.unknown()),
+                file_id: import_v414.z.string(),
+                filename: import_v414.z.string(),
+                score: import_v414.z.number(),
+                text: import_v414.z.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() })
+          import_v414.z.object({
+            type: import_v414.z.literal("code_interpreter_call"),
+            id: import_v414.z.string(),
+            code: import_v414.z.string().nullable(),
+            container_id: import_v414.z.string(),
+            outputs: import_v414.z.array(
+              import_v414.z.discriminatedUnion("type", [
+                import_v414.z.object({ type: import_v414.z.literal("logs"), logs: import_v414.z.string() }),
+                import_v414.z.object({ type: import_v414.z.literal("image"), url: import_v414.z.string() })
               ])
             ).nullable()
           }),
-          z14.object({
-            type: z14.literal("image_generation_call"),
-            id: z14.string(),
-            result: z14.string()
+          import_v414.z.object({
+            type: import_v414.z.literal("image_generation_call"),
+            id: import_v414.z.string(),
+            result: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("local_shell_call"),
+            id: import_v414.z.string(),
+            call_id: import_v414.z.string(),
+            action: import_v414.z.object({
+              type: import_v414.z.literal("exec"),
+              command: import_v414.z.array(import_v414.z.string()),
+              timeout_ms: import_v414.z.number().optional(),
+              user: import_v414.z.string().optional(),
+              working_directory: import_v414.z.string().optional(),
+              env: import_v414.z.record(import_v414.z.string(), import_v414.z.string()).optional()
             })
           }),
-          z14.object({
-            type: z14.literal("function_call"),
-            call_id: z14.string(),
-            name: z14.string(),
-            arguments: z14.string(),
-            id: z14.string()
+          import_v414.z.object({
+            type: import_v414.z.literal("function_call"),
+            call_id: import_v414.z.string(),
+            name: import_v414.z.string(),
+            arguments: import_v414.z.string(),
+            id: import_v414.z.string()
           }),
-          z14.object({
-            type: z14.literal("computer_call"),
-            id: z14.string(),
-            status: z14.string().optional()
+          import_v414.z.object({
+            type: import_v414.z.literal("computer_call"),
+            id: import_v414.z.string(),
+            status: import_v414.z.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()
+          import_v414.z.object({
+            type: import_v414.z.literal("reasoning"),
+            id: import_v414.z.string(),
+            encrypted_content: import_v414.z.string().nullish(),
+            summary: import_v414.z.array(
+              import_v414.z.object({
+                type: import_v414.z.literal("summary_text"),
+                text: import_v414.z.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()
+      service_tier: import_v414.z.string().nullish(),
+      incomplete_details: import_v414.z.object({ reason: import_v414.z.string() }).nullish(),
+      usage: import_v414.z.object({
+        input_tokens: import_v414.z.number(),
+        input_tokens_details: import_v414.z.object({ cached_tokens: import_v414.z.number().nullish() }).nullish(),
+        output_tokens: import_v414.z.number(),
+        output_tokens_details: import_v414.z.object({ reasoning_tokens: import_v414.z.number().nullish() }).nullish()
       })
     })
   )
@@ -2860,7 +2868,7 @@ var openaiResponsesResponseSchema = (0, import_provider_utils21.lazyValidator)(
 
 // src/responses/openai-responses-options.ts
 var import_provider_utils22 = require("@ai-sdk/provider-utils");
-var z15 = __toESM(require("zod/v4"));
+var import_v415 = require("zod/v4");
 var TOP_LOGPROBS_MAX = 20;
 var openaiResponsesReasoningModelIds = [
   "o1",
@@ -2921,15 +2929,15 @@ var openaiResponsesModelIds = [
 ];
 var openaiResponsesProviderOptionsSchema = (0, import_provider_utils22.lazyValidator)(
   () => (0, import_provider_utils22.zodSchema)(
-    z15.object({
-      include: z15.array(
-        z15.enum([
+    import_v415.z.object({
+      include: import_v415.z.array(
+        import_v415.z.enum([
           "reasoning.encrypted_content",
           "file_search_call.results",
           "message.output_text.logprobs"
         ])
       ).nullish(),
-      instructions: z15.string().nullish(),
+      instructions: import_v415.z.string().nullish(),
       /**
        * Return the log probabilities of the tokens.
        *
@@ -2942,25 +2950,25 @@ var openaiResponsesProviderOptionsSchema = (0, import_provider_utils22.lazyValid
        * @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(),
+      logprobs: import_v415.z.union([import_v415.z.boolean(), import_v415.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: 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", "default"]).nullish(),
-      store: z15.boolean().nullish(),
-      strictJsonSchema: z15.boolean().nullish(),
-      textVerbosity: z15.enum(["low", "medium", "high"]).nullish(),
-      user: z15.string().nullish()
+      maxToolCalls: import_v415.z.number().nullish(),
+      metadata: import_v415.z.any().nullish(),
+      parallelToolCalls: import_v415.z.boolean().nullish(),
+      previousResponseId: import_v415.z.string().nullish(),
+      promptCacheKey: import_v415.z.string().nullish(),
+      reasoningEffort: import_v415.z.string().nullish(),
+      reasoningSummary: import_v415.z.string().nullish(),
+      safetyIdentifier: import_v415.z.string().nullish(),
+      serviceTier: import_v415.z.enum(["auto", "flex", "priority", "default"]).nullish(),
+      store: import_v415.z.boolean().nullish(),
+      strictJsonSchema: import_v415.z.boolean().nullish(),
+      textVerbosity: import_v415.z.enum(["low", "medium", "high"]).nullish(),
+      user: import_v415.z.string().nullish()
     })
   )
 );
@@ -2970,22 +2978,22 @@ var import_provider7 = require("@ai-sdk/provider");
 
 // src/tool/code-interpreter.ts
 var import_provider_utils23 = require("@ai-sdk/provider-utils");
-var z16 = __toESM(require("zod/v4"));
+var import_v416 = require("zod/v4");
 var codeInterpreterInputSchema = (0, import_provider_utils23.lazySchema)(
   () => (0, import_provider_utils23.zodSchema)(
-    z16.object({
-      code: z16.string().nullish(),
-      containerId: z16.string()
+    import_v416.z.object({
+      code: import_v416.z.string().nullish(),
+      containerId: import_v416.z.string()
     })
   )
 );
 var codeInterpreterOutputSchema = (0, import_provider_utils23.lazySchema)(
   () => (0, import_provider_utils23.zodSchema)(
-    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() })
+    import_v416.z.object({
+      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() })
         ])
       ).nullish()
     })
@@ -2993,11 +3001,11 @@ var codeInterpreterOutputSchema = (0, import_provider_utils23.lazySchema)(
 );
 var codeInterpreterArgsSchema = (0, import_provider_utils23.lazySchema)(
   () => (0, import_provider_utils23.zodSchema)(
-    z16.object({
-      container: z16.union([
-        z16.string(),
-        z16.object({
-          fileIds: z16.array(z16.string()).optional()
+    import_v416.z.object({
+      container: import_v416.z.union([
+        import_v416.z.string(),
+        import_v416.z.object({
+          fileIds: import_v416.z.array(import_v416.z.string()).optional()
         })
       ]).optional()
     })
@@ -3015,42 +3023,42 @@ var codeInterpreter = (args = {}) => {
 
 // src/tool/file-search.ts
 var import_provider_utils24 = require("@ai-sdk/provider-utils");
-var z17 = __toESM(require("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 import_v417 = require("zod/v4");
+var comparisonFilterSchema = import_v417.z.object({
+  key: import_v417.z.string(),
+  type: import_v417.z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+  value: import_v417.z.union([import_v417.z.string(), import_v417.z.number(), import_v417.z.boolean()])
 });
-var compoundFilterSchema = z17.object({
-  type: z17.enum(["and", "or"]),
-  filters: z17.array(
-    z17.union([comparisonFilterSchema, z17.lazy(() => compoundFilterSchema)])
+var compoundFilterSchema = import_v417.z.object({
+  type: import_v417.z.enum(["and", "or"]),
+  filters: import_v417.z.array(
+    import_v417.z.union([comparisonFilterSchema, import_v417.z.lazy(() => compoundFilterSchema)])
   )
 });
 var fileSearchArgsSchema = (0, import_provider_utils24.lazySchema)(
   () => (0, import_provider_utils24.zodSchema)(
-    z17.object({
-      vectorStoreIds: z17.array(z17.string()),
-      maxNumResults: z17.number().optional(),
-      ranking: z17.object({
-        ranker: z17.string().optional(),
-        scoreThreshold: z17.number().optional()
+    import_v417.z.object({
+      vectorStoreIds: import_v417.z.array(import_v417.z.string()),
+      maxNumResults: import_v417.z.number().optional(),
+      ranking: import_v417.z.object({
+        ranker: import_v417.z.string().optional(),
+        scoreThreshold: import_v417.z.number().optional()
       }).optional(),
-      filters: z17.union([comparisonFilterSchema, compoundFilterSchema]).optional()
+      filters: import_v417.z.union([comparisonFilterSchema, compoundFilterSchema]).optional()
     })
   )
 );
 var fileSearchOutputSchema = (0, import_provider_utils24.lazySchema)(
   () => (0, import_provider_utils24.zodSchema)(
-    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()
+    import_v417.z.object({
+      queries: import_v417.z.array(import_v417.z.string()),
+      results: import_v417.z.array(
+        import_v417.z.object({
+          attributes: import_v417.z.record(import_v417.z.string(), import_v417.z.unknown()),
+          fileId: import_v417.z.string(),
+          filename: import_v417.z.string(),
+          score: import_v417.z.number(),
+          text: import_v417.z.string()
         })
       ).nullable()
     })
@@ -3059,46 +3067,46 @@ var fileSearchOutputSchema = (0, import_provider_utils24.lazySchema)(
 var fileSearch = (0, import_provider_utils24.createProviderDefinedToolFactoryWithOutputSchema)({
   id: "openai.file_search",
   name: "file_search",
-  inputSchema: z17.object({}),
+  inputSchema: import_v417.z.object({}),
   outputSchema: fileSearchOutputSchema
 });
 
 // src/tool/web-search.ts
 var import_provider_utils25 = require("@ai-sdk/provider-utils");
-var z18 = __toESM(require("zod/v4"));
+var import_v418 = require("zod/v4");
 var webSearchArgsSchema = (0, import_provider_utils25.lazySchema)(
   () => (0, import_provider_utils25.zodSchema)(
-    z18.object({
-      filters: z18.object({
-        allowedDomains: z18.array(z18.string()).optional()
+    import_v418.z.object({
+      filters: import_v418.z.object({
+        allowedDomains: import_v418.z.array(import_v418.z.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()
+      searchContextSize: import_v418.z.enum(["low", "medium", "high"]).optional(),
+      userLocation: import_v418.z.object({
+        type: import_v418.z.literal("approximate"),
+        country: import_v418.z.string().optional(),
+        city: import_v418.z.string().optional(),
+        region: import_v418.z.string().optional(),
+        timezone: import_v418.z.string().optional()
       }).optional()
     })
   )
 );
 var webSearchInputSchema = (0, import_provider_utils25.lazySchema)(
   () => (0, import_provider_utils25.zodSchema)(
-    z18.object({
-      action: z18.discriminatedUnion("type", [
-        z18.object({
-          type: z18.literal("search"),
-          query: z18.string().nullish()
+    import_v418.z.object({
+      action: import_v418.z.discriminatedUnion("type", [
+        import_v418.z.object({
+          type: import_v418.z.literal("search"),
+          query: import_v418.z.string().nullish()
         }),
-        z18.object({
-          type: z18.literal("open_page"),
-          url: z18.string()
+        import_v418.z.object({
+          type: import_v418.z.literal("open_page"),
+          url: import_v418.z.string()
         }),
-        z18.object({
-          type: z18.literal("find"),
-          url: z18.string(),
-          pattern: z18.string()
+        import_v418.z.object({
+          type: import_v418.z.literal("find"),
+          url: import_v418.z.string(),
+          pattern: import_v418.z.string()
         })
       ]).nullish()
     })
@@ -3112,61 +3120,61 @@ var webSearchToolFactory = (0, import_provider_utils25.createProviderDefinedTool
 
 // src/tool/web-search-preview.ts
 var import_provider_utils26 = require("@ai-sdk/provider-utils");
-var z19 = __toESM(require("zod/v4"));
+var import_v419 = require("zod/v4");
 var webSearchPreviewArgsSchema = (0, import_provider_utils26.lazySchema)(
   () => (0, import_provider_utils26.zodSchema)(
-    z19.object({
+    import_v419.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: z19.enum(["low", "medium", "high"]).optional(),
+      searchContextSize: import_v419.z.enum(["low", "medium", "high"]).optional(),
       /**
        * User location information to provide geographically relevant search results.
        */
-      userLocation: z19.object({
+      userLocation: import_v419.z.object({
         /**
          * Type of location (always 'approximate')
          */
-        type: z19.literal("approximate"),
+        type: import_v419.z.literal("approximate"),
         /**
          * Two-letter ISO country code (e.g., 'US', 'GB')
          */
-        country: z19.string().optional(),
+        country: import_v419.z.string().optional(),
         /**
          * City name (free text, e.g., 'Minneapolis')
          */
-        city: z19.string().optional(),
+        city: import_v419.z.string().optional(),
         /**
          * Region name (free text, e.g., 'Minnesota')
          */
-        region: z19.string().optional(),
+        region: import_v419.z.string().optional(),
         /**
          * IANA timezone (e.g., 'America/Chicago')
          */
-        timezone: z19.string().optional()
+        timezone: import_v419.z.string().optional()
       }).optional()
     })
   )
 );
 var webSearchPreviewInputSchema = (0, import_provider_utils26.lazySchema)(
   () => (0, import_provider_utils26.zodSchema)(
-    z19.object({
-      action: z19.discriminatedUnion("type", [
-        z19.object({
-          type: z19.literal("search"),
-          query: z19.string().nullish()
+    import_v419.z.object({
+      action: import_v419.z.discriminatedUnion("type", [
+        import_v419.z.object({
+          type: import_v419.z.literal("search"),
+          query: import_v419.z.string().nullish()
         }),
-        z19.object({
-          type: z19.literal("open_page"),
-          url: z19.string()
+        import_v419.z.object({
+          type: import_v419.z.literal("open_page"),
+          url: import_v419.z.string()
         }),
-        z19.object({
-          type: z19.literal("find"),
-          url: z19.string(),
-          pattern: z19.string()
+        import_v419.z.object({
+          type: import_v419.z.literal("find"),
+          url: import_v419.z.string(),
+          pattern: import_v419.z.string()
         })
       ]).nullish()
     })
@@ -3180,29 +3188,29 @@ var webSearchPreview = (0, import_provider_utils26.createProviderDefinedToolFact
 
 // src/tool/image-generation.ts
 var import_provider_utils27 = require("@ai-sdk/provider-utils");
-var z20 = __toESM(require("zod/v4"));
+var import_v420 = require("zod/v4");
 var imageGenerationArgsSchema = (0, import_provider_utils27.lazySchema)(
   () => (0, import_provider_utils27.zodSchema)(
-    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()
+    import_v420.z.object({
+      background: import_v420.z.enum(["auto", "opaque", "transparent"]).optional(),
+      inputFidelity: import_v420.z.enum(["low", "high"]).optional(),
+      inputImageMask: import_v420.z.object({
+        fileId: import_v420.z.string().optional(),
+        imageUrl: import_v420.z.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()
+      model: import_v420.z.string().optional(),
+      moderation: import_v420.z.enum(["auto"]).optional(),
+      outputCompression: import_v420.z.number().int().min(0).max(100).optional(),
+      outputFormat: import_v420.z.enum(["png", "jpeg", "webp"]).optional(),
+      partialImages: import_v420.z.number().int().min(0).max(3).optional(),
+      quality: import_v420.z.enum(["auto", "low", "medium", "high"]).optional(),
+      size: import_v420.z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
     }).strict()
   )
 );
-var imageGenerationInputSchema = (0, import_provider_utils27.lazySchema)(() => (0, import_provider_utils27.zodSchema)(z20.object({})));
+var imageGenerationInputSchema = (0, import_provider_utils27.lazySchema)(() => (0, import_provider_utils27.zodSchema)(import_v420.z.object({})));
 var imageGenerationOutputSchema = (0, import_provider_utils27.lazySchema)(
-  () => (0, import_provider_utils27.zodSchema)(z20.object({ result: z20.string() }))
+  () => (0, import_provider_utils27.zodSchema)(import_v420.z.object({ result: import_v420.z.string() }))
 );
 var imageGenerationToolFactory = (0, import_provider_utils27.createProviderDefinedToolFactoryWithOutputSchema)({
   id: "openai.image_generation",