@ai-sdk/openai 4.0.0-beta.29 → 4.0.0-beta.30

package/dist/internal/index.js

@@ -1,80 +1,33 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/internal/index.ts
-var index_exports = {};
-__export(index_exports, {
-  OpenAIChatLanguageModel: () => OpenAIChatLanguageModel,
-  OpenAICompletionLanguageModel: () => OpenAICompletionLanguageModel,
-  OpenAIEmbeddingModel: () => OpenAIEmbeddingModel,
-  OpenAIImageModel: () => OpenAIImageModel,
-  OpenAIResponsesLanguageModel: () => OpenAIResponsesLanguageModel,
-  OpenAISpeechModel: () => OpenAISpeechModel,
-  OpenAITranscriptionModel: () => OpenAITranscriptionModel,
-  applyPatch: () => applyPatch,
-  applyPatchArgsSchema: () => applyPatchArgsSchema,
-  applyPatchInputSchema: () => applyPatchInputSchema,
-  applyPatchOutputSchema: () => applyPatchOutputSchema,
-  applyPatchToolFactory: () => applyPatchToolFactory,
-  codeInterpreter: () => codeInterpreter,
-  codeInterpreterArgsSchema: () => codeInterpreterArgsSchema,
-  codeInterpreterInputSchema: () => codeInterpreterInputSchema,
-  codeInterpreterOutputSchema: () => codeInterpreterOutputSchema,
-  codeInterpreterToolFactory: () => codeInterpreterToolFactory,
-  fileSearch: () => fileSearch,
-  fileSearchArgsSchema: () => fileSearchArgsSchema,
-  fileSearchOutputSchema: () => fileSearchOutputSchema,
-  hasDefaultResponseFormat: () => hasDefaultResponseFormat,
-  imageGeneration: () => imageGeneration,
-  imageGenerationArgsSchema: () => imageGenerationArgsSchema,
-  imageGenerationOutputSchema: () => imageGenerationOutputSchema,
-  modelMaxImagesPerCall: () => modelMaxImagesPerCall,
-  openAITranscriptionModelOptions: () => openAITranscriptionModelOptions,
-  openaiEmbeddingModelOptions: () => openaiEmbeddingModelOptions,
-  openaiLanguageModelChatOptions: () => openaiLanguageModelChatOptions,
-  openaiLanguageModelCompletionOptions: () => openaiLanguageModelCompletionOptions,
-  openaiSpeechModelOptionsSchema: () => openaiSpeechModelOptionsSchema,
-  webSearchPreview: () => webSearchPreview,
-  webSearchPreviewArgsSchema: () => webSearchPreviewArgsSchema,
-  webSearchPreviewInputSchema: () => webSearchPreviewInputSchema
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/chat/openai-chat-language-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+import {
+  InvalidResponseDataError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isCustomReasoning,
+  isParsableJson,
+  parseProviderOptions,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
 
 // src/openai-error.ts
-var import_v4 = require("zod/v4");
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var openaiErrorDataSchema = import_v4.z.object({
-  error: import_v4.z.object({
-    message: import_v4.z.string(),
+import { z } from "zod/v4";
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+var openaiErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
     // The additional information below is handled loosely to support
     // OpenAI-compatible providers that have slightly different error
     // responses:
-    type: import_v4.z.string().nullish(),
-    param: import_v4.z.any().nullish(),
-    code: import_v4.z.union([import_v4.z.string(), import_v4.z.number()]).nullish()
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
   })
 });
-var openaiFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+var openaiFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: openaiErrorDataSchema,
   errorToMessage: (data) => data.error.message
 });
@@ -135,8 +88,14 @@ function convertOpenAIChatUsage(usage) {
 }
 
 // src/chat/convert-to-openai-chat-messages.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  convertToBase64,
+  isProviderReference,
+  resolveProviderReference
+} from "@ai-sdk/provider-utils";
 function convertToOpenAIChatMessages({
   prompt,
   systemMessageMode = "system"
@@ -186,11 +145,11 @@ function convertToOpenAIChatMessages({
                 return { type: "text", text: part.text };
               }
               case "file": {
-                if ((0, import_provider_utils2.isProviderReference)(part.data)) {
+                if (isProviderReference(part.data)) {
                   return {
                     type: "file",
                     file: {
-                      file_id: (0, import_provider_utils2.resolveProviderReference)({
+                      file_id: resolveProviderReference({
                         reference: part.data,
                         provider: "openai"
                       })
@@ -202,13 +161,13 @@ function convertToOpenAIChatMessages({
                   return {
                     type: "image_url",
                     image_url: {
-                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${(0, import_provider_utils2.convertToBase64)(part.data)}`,
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`,
                       detail: (_b = (_a2 = part.providerOptions) == null ? void 0 : _a2.openai) == null ? void 0 : _b.imageDetail
                     }
                   };
                 } else if (part.mediaType.startsWith("audio/")) {
                   if (part.data instanceof URL) {
-                    throw new import_provider.UnsupportedFunctionalityError({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "audio file parts with URLs"
                     });
                   }
@@ -217,7 +176,7 @@ function convertToOpenAIChatMessages({
                       return {
                         type: "input_audio",
                         input_audio: {
-                          data: (0, import_provider_utils2.convertToBase64)(part.data),
+                          data: convertToBase64(part.data),
                           format: "wav"
                         }
                       };
@@ -227,20 +186,20 @@ function convertToOpenAIChatMessages({
                       return {
                         type: "input_audio",
                         input_audio: {
-                          data: (0, import_provider_utils2.convertToBase64)(part.data),
+                          data: convertToBase64(part.data),
                           format: "mp3"
                         }
                       };
                     }
                     default: {
-                      throw new import_provider.UnsupportedFunctionalityError({
+                      throw new UnsupportedFunctionalityError({
                         functionality: `audio content parts with media type ${part.mediaType}`
                       });
                     }
                   }
                 } else if (part.mediaType === "application/pdf") {
                   if (part.data instanceof URL) {
-                    throw new import_provider.UnsupportedFunctionalityError({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "PDF file parts with URLs"
                     });
                   }
@@ -248,11 +207,11 @@ function convertToOpenAIChatMessages({
                     type: "file",
                     file: {
                       filename: (_c = part.filename) != null ? _c : `part-${index}.pdf`,
-                      file_data: `data:application/pdf;base64,${(0, import_provider_utils2.convertToBase64)(part.data)}`
+                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
                     }
                   };
                 } else {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError({
                     functionality: `file part media type ${part.mediaType}`
                   });
                 }
@@ -360,139 +319,139 @@ function mapOpenAIFinishReason(finishReason) {
 }
 
 // src/chat/openai-chat-api.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
-var openaiChatResponseSchema = (0, import_provider_utils3.lazySchema)(
-  () => (0, import_provider_utils3.zodSchema)(
-    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()
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+var openaiChatResponseSchema = lazySchema(
+  () => 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: import_v42.z.array(
-              import_v42.z.object({
-                type: import_v42.z.literal("url_citation"),
-                url_citation: import_v42.z.object({
-                  start_index: import_v42.z.number(),
-                  end_index: import_v42.z.number(),
-                  url: import_v42.z.string(),
-                  title: import_v42.z.string()
+            annotations: z2.array(
+              z2.object({
+                type: z2.literal("url_citation"),
+                url_citation: z2.object({
+                  start_index: z2.number(),
+                  end_index: z2.number(),
+                  url: z2.string(),
+                  title: z2.string()
                 })
               })
             ).nullish()
           }),
-          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()
+          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: import_v42.z.string().nullish()
+          finish_reason: z2.string().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()
+      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: 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()
+        completion_tokens_details: z2.object({
+          reasoning_tokens: z2.number().nullish(),
+          accepted_prediction_tokens: z2.number().nullish(),
+          rejected_prediction_tokens: z2.number().nullish()
         }).nullish()
       }).nullish()
     })
   )
 );
-var openaiChatChunkSchema = (0, import_provider_utils3.lazySchema)(
-  () => (0, import_provider_utils3.zodSchema)(
-    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()
+var openaiChatChunkSchema = lazySchema(
+  () => 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: import_v42.z.array(
-                import_v42.z.object({
-                  type: import_v42.z.literal("url_citation"),
-                  url_citation: import_v42.z.object({
-                    start_index: import_v42.z.number(),
-                    end_index: import_v42.z.number(),
-                    url: import_v42.z.string(),
-                    title: import_v42.z.string()
+              annotations: z2.array(
+                z2.object({
+                  type: z2.literal("url_citation"),
+                  url_citation: z2.object({
+                    start_index: z2.number(),
+                    end_index: z2.number(),
+                    url: z2.string(),
+                    title: z2.string()
                   })
                 })
               ).nullish()
             }).nullish(),
-            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()
+            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: import_v42.z.string().nullish(),
-            index: import_v42.z.number()
+            finish_reason: z2.string().nullish(),
+            index: z2.number()
           })
         ),
-        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()
+        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: 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()
+          completion_tokens_details: z2.object({
+            reasoning_tokens: z2.number().nullish(),
+            accepted_prediction_tokens: z2.number().nullish(),
+            rejected_prediction_tokens: z2.number().nullish()
           }).nullish()
         }).nullish()
       }),
@@ -502,18 +461,18 @@ var openaiChatChunkSchema = (0, import_provider_utils3.lazySchema)(
 );
 
 // src/chat/openai-chat-options.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
-var openaiLanguageModelChatOptions = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v43.z.object({
+import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+var openaiLanguageModelChatOptions = lazySchema2(
+  () => 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: import_v43.z.record(import_v43.z.coerce.number(), import_v43.z.number()).optional(),
+      logitBias: z3.record(z3.coerce.number(), z3.number()).optional(),
       /**
        * Return the log probabilities of the tokens.
        *
@@ -523,36 +482,36 @@ var openaiLanguageModelChatOptions = (0, import_provider_utils4.lazySchema)(
        * Setting to a number will return the log probabilities of the top n
        * tokens that were generated.
        */
-      logprobs: import_v43.z.union([import_v43.z.boolean(), import_v43.z.number()]).optional(),
+      logprobs: z3.union([z3.boolean(), z3.number()]).optional(),
       /**
        * Whether to enable parallel function calling during tool use. Default to true.
        */
-      parallelToolCalls: import_v43.z.boolean().optional(),
+      parallelToolCalls: z3.boolean().optional(),
       /**
        * A unique identifier representing your end-user, which can help OpenAI to
        * monitor and detect abuse.
        */
-      user: import_v43.z.string().optional(),
+      user: z3.string().optional(),
       /**
        * Reasoning effort for reasoning models. Defaults to `medium`.
        */
-      reasoningEffort: import_v43.z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+      reasoningEffort: z3.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
       /**
        * Maximum number of completion tokens to generate. Useful for reasoning models.
        */
-      maxCompletionTokens: import_v43.z.number().optional(),
+      maxCompletionTokens: z3.number().optional(),
       /**
        * Whether to enable persistence in responses API.
        */
-      store: import_v43.z.boolean().optional(),
+      store: z3.boolean().optional(),
       /**
        * Metadata to associate with the request.
        */
-      metadata: import_v43.z.record(import_v43.z.string().max(64), import_v43.z.string().max(512)).optional(),
+      metadata: z3.record(z3.string().max(64), z3.string().max(512)).optional(),
       /**
        * Parameters for prediction mode.
        */
-      prediction: import_v43.z.record(import_v43.z.string(), import_v43.z.any()).optional(),
+      prediction: z3.record(z3.string(), z3.any()).optional(),
       /**
        * Service tier for the request.
        * - 'auto': Default service tier. The request will be processed with the service tier configured in the
@@ -563,23 +522,23 @@ var openaiLanguageModelChatOptions = (0, import_provider_utils4.lazySchema)(
        *
        * @default 'auto'
        */
-      serviceTier: import_v43.z.enum(["auto", "flex", "priority", "default"]).optional(),
+      serviceTier: z3.enum(["auto", "flex", "priority", "default"]).optional(),
       /**
        * Whether to use strict JSON schema validation.
        *
        * @default true
        */
-      strictJsonSchema: import_v43.z.boolean().optional(),
+      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: import_v43.z.enum(["low", "medium", "high"]).optional(),
+      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: import_v43.z.string().optional(),
+      promptCacheKey: z3.string().optional(),
       /**
        * The retention policy for the prompt cache.
        * - 'in_memory': Default. Standard prompt caching behavior.
@@ -588,7 +547,7 @@ var openaiLanguageModelChatOptions = (0, import_provider_utils4.lazySchema)(
        *
        * @default 'in_memory'
        */
-      promptCacheRetention: import_v43.z.enum(["in_memory", "24h"]).optional(),
+      promptCacheRetention: z3.enum(["in_memory", "24h"]).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
@@ -596,7 +555,7 @@ var openaiLanguageModelChatOptions = (0, import_provider_utils4.lazySchema)(
        * username or email address, in order to avoid sending us any identifying
        * information.
        */
-      safetyIdentifier: import_v43.z.string().optional(),
+      safetyIdentifier: z3.string().optional(),
       /**
        * Override the system message mode for this model.
        * - 'system': Use the 'system' role for system messages (default for most models)
@@ -605,7 +564,7 @@ var openaiLanguageModelChatOptions = (0, import_provider_utils4.lazySchema)(
        *
        * If not specified, the mode is automatically determined based on the model.
        */
-      systemMessageMode: import_v43.z.enum(["system", "developer", "remove"]).optional(),
+      systemMessageMode: z3.enum(["system", "developer", "remove"]).optional(),
       /**
        * Force treating this model as a reasoning model.
        *
@@ -615,13 +574,15 @@ var openaiLanguageModelChatOptions = (0, import_provider_utils4.lazySchema)(
        * When enabled, the SDK applies reasoning-model parameter compatibility rules
        * and defaults `systemMessageMode` to `developer` unless overridden.
        */
-      forceReasoning: import_v43.z.boolean().optional()
+      forceReasoning: z3.boolean().optional()
     })
   )
 );
 
 // src/chat/openai-chat-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 function prepareChatTools({
   tools,
   toolChoice
@@ -675,7 +636,7 @@ function prepareChatTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -713,13 +674,13 @@ var OpenAIChatLanguageModel = class {
   }) {
     var _a, _b, _c, _d, _e, _f;
     const warnings = [];
-    const openaiOptions = (_a = await (0, import_provider_utils5.parseProviderOptions)({
+    const openaiOptions = (_a = await parseProviderOptions({
       provider: "openai",
       providerOptions,
       schema: openaiLanguageModelChatOptions
     })) != null ? _a : {};
     const modelCapabilities = getOpenAILanguageModelCapabilities(this.modelId);
-    const resolvedReasoningEffort = (_b = openaiOptions.reasoningEffort) != null ? _b : (0, import_provider_utils5.isCustomReasoning)(reasoning) ? reasoning : void 0;
+    const resolvedReasoningEffort = (_b = openaiOptions.reasoningEffort) != null ? _b : isCustomReasoning(reasoning) ? reasoning : void 0;
     const isReasoningModel = (_c = openaiOptions.forceReasoning) != null ? _c : modelCapabilities.isReasoningModel;
     if (topK != null) {
       warnings.push({ type: "unsupported", feature: "topK" });
@@ -885,15 +846,15 @@ var OpenAIChatLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils5.postJsonToApi)({
+    } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         openaiChatResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -908,7 +869,7 @@ var OpenAIChatLanguageModel = class {
     for (const toolCall of (_a = choice.message.tool_calls) != null ? _a : []) {
       content.push({
         type: "tool-call",
-        toolCallId: (_b = toolCall.id) != null ? _b : (0, import_provider_utils5.generateId)(),
+        toolCallId: (_b = toolCall.id) != null ? _b : generateId(),
         toolName: toolCall.function.name,
         input: toolCall.function.arguments
       });
@@ -917,7 +878,7 @@ var OpenAIChatLanguageModel = class {
       content.push({
         type: "source",
         sourceType: "url",
-        id: (0, import_provider_utils5.generateId)(),
+        id: generateId(),
         url: annotation.url_citation.url,
         title: annotation.url_citation.title
       });
@@ -959,15 +920,15 @@ var OpenAIChatLanguageModel = class {
         include_usage: true
       }
     };
-    const { responseHeaders, value: response } = await (0, import_provider_utils5.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils5.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         openaiChatChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -1053,19 +1014,19 @@ var OpenAIChatLanguageModel = class {
                 const index = toolCallDelta.index;
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.type != null && toolCallDelta.type !== "function") {
-                    throw new import_provider3.InvalidResponseDataError({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function' type.`
                     });
                   }
                   if (toolCallDelta.id == null) {
-                    throw new import_provider3.InvalidResponseDataError({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'id' to be a string.`
                     });
                   }
                   if (((_f = toolCallDelta.function) == null ? void 0 : _f.name) == null) {
-                    throw new import_provider3.InvalidResponseDataError({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
                     });
@@ -1093,14 +1054,14 @@ var OpenAIChatLanguageModel = class {
                         delta: toolCall2.function.arguments
                       });
                     }
-                    if ((0, import_provider_utils5.isParsableJson)(toolCall2.function.arguments)) {
+                    if (isParsableJson(toolCall2.function.arguments)) {
                       controller.enqueue({
                         type: "tool-input-end",
                         id: toolCall2.id
                       });
                       controller.enqueue({
                         type: "tool-call",
-                        toolCallId: (_j = toolCall2.id) != null ? _j : (0, import_provider_utils5.generateId)(),
+                        toolCallId: (_j = toolCall2.id) != null ? _j : generateId(),
                         toolName: toolCall2.function.name,
                         input: toolCall2.function.arguments
                       });
@@ -1121,14 +1082,14 @@ var OpenAIChatLanguageModel = class {
                   id: toolCall.id,
                   delta: (_n = toolCallDelta.function.arguments) != null ? _n : ""
                 });
-                if (((_o = toolCall.function) == null ? void 0 : _o.name) != null && ((_p = toolCall.function) == null ? void 0 : _p.arguments) != null && (0, import_provider_utils5.isParsableJson)(toolCall.function.arguments)) {
+                if (((_o = toolCall.function) == null ? void 0 : _o.name) != null && ((_p = toolCall.function) == null ? void 0 : _p.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-input-end",
                     id: toolCall.id
                   });
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallId: (_q = toolCall.id) != null ? _q : (0, import_provider_utils5.generateId)(),
+                    toolCallId: (_q = toolCall.id) != null ? _q : generateId(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments
                   });
@@ -1141,7 +1102,7 @@ var OpenAIChatLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "url",
-                  id: (0, import_provider_utils5.generateId)(),
+                  id: generateId(),
                   url: annotation.url_citation.url,
                   title: annotation.url_citation.title
                 });
@@ -1168,7 +1129,13 @@ var OpenAIChatLanguageModel = class {
 };
 
 // src/completion/openai-completion-language-model.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders2,
+  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi2
+} from "@ai-sdk/provider-utils";
 
 // src/completion/convert-openai-completion-usage.ts
 function convertOpenAICompletionUsage(usage) {
@@ -1208,7 +1175,10 @@ function convertOpenAICompletionUsage(usage) {
 }
 
 // src/completion/convert-to-openai-completion-prompt.ts
-var import_provider4 = require("@ai-sdk/provider");
+import {
+  InvalidPromptError,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+} from "@ai-sdk/provider";
 function convertToOpenAICompletionPrompt({
   prompt,
   user = "user",
@@ -1224,7 +1194,7 @@ function convertToOpenAICompletionPrompt({
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
-        throw new import_provider4.InvalidPromptError({
+        throw new InvalidPromptError({
           message: "Unexpected system message in prompt: ${content}",
           prompt
         });
@@ -1250,7 +1220,7 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new import_provider4.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError3({
                 functionality: "tool-call messages"
               });
             }
@@ -1263,7 +1233,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new import_provider4.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError3({
           functionality: "tool messages"
         });
       }
@@ -1313,56 +1283,56 @@ function mapOpenAIFinishReason2(finishReason) {
 }
 
 // src/completion/openai-completion-api.ts
-var import_v44 = require("zod/v4");
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var openaiCompletionResponseSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    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()
+import { z as z4 } from "zod/v4";
+import { lazySchema as lazySchema3, zodSchema as zodSchema3 } from "@ai-sdk/provider-utils";
+var openaiCompletionResponseSchema = lazySchema3(
+  () => 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: import_v44.z.object({
-        prompt_tokens: import_v44.z.number(),
-        completion_tokens: import_v44.z.number(),
-        total_tokens: import_v44.z.number()
+      usage: z4.object({
+        prompt_tokens: z4.number(),
+        completion_tokens: z4.number(),
+        total_tokens: z4.number()
       }).nullish()
     })
   )
 );
-var openaiCompletionChunkSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    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()
+var openaiCompletionChunkSchema = lazySchema3(
+  () => 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: import_v44.z.object({
-          prompt_tokens: import_v44.z.number(),
-          completion_tokens: import_v44.z.number(),
-          total_tokens: import_v44.z.number()
+        usage: z4.object({
+          prompt_tokens: z4.number(),
+          completion_tokens: z4.number(),
+          total_tokens: z4.number()
         }).nullish()
       }),
       openaiErrorDataSchema
@@ -1371,15 +1341,15 @@ var openaiCompletionChunkSchema = (0, import_provider_utils6.lazySchema)(
 );
 
 // src/completion/openai-completion-options.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
-var openaiLanguageModelCompletionOptions = (0, import_provider_utils7.lazySchema)(
-  () => (0, import_provider_utils7.zodSchema)(
-    import_v45.z.object({
+import { lazySchema as lazySchema4, zodSchema as zodSchema4 } from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+var openaiLanguageModelCompletionOptions = lazySchema4(
+  () => zodSchema4(
+    z5.object({
       /**
        * Echo back the prompt in addition to the completion.
        */
-      echo: import_v45.z.boolean().optional(),
+      echo: z5.boolean().optional(),
       /**
        * Modify the likelihood of specified tokens appearing in the completion.
        *
@@ -1394,16 +1364,16 @@ var openaiLanguageModelCompletionOptions = (0, import_provider_utils7.lazySchema
        * As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
        * token from being generated.
        */
-      logitBias: import_v45.z.record(import_v45.z.string(), import_v45.z.number()).optional(),
+      logitBias: z5.record(z5.string(), z5.number()).optional(),
       /**
        * The suffix that comes after a completion of inserted text.
        */
-      suffix: import_v45.z.string().optional(),
+      suffix: z5.string().optional(),
       /**
        * A unique identifier representing your end-user, which can help OpenAI to
        * monitor and detect abuse. Learn more.
        */
-      user: import_v45.z.string().optional(),
+      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
@@ -1413,7 +1383,7 @@ var openaiLanguageModelCompletionOptions = (0, import_provider_utils7.lazySchema
        * Setting to a number will return the log probabilities of the top n
        * tokens that were generated.
        */
-      logprobs: import_v45.z.union([import_v45.z.boolean(), import_v45.z.number()]).optional()
+      logprobs: z5.union([z5.boolean(), z5.number()]).optional()
     })
   )
 );
@@ -1451,12 +1421,12 @@ var OpenAICompletionLanguageModel = class {
   }) {
     const warnings = [];
     const openaiOptions = {
-      ...await (0, import_provider_utils8.parseProviderOptions)({
+      ...await parseProviderOptions2({
         provider: "openai",
         providerOptions,
         schema: openaiLanguageModelCompletionOptions
       }),
-      ...await (0, import_provider_utils8.parseProviderOptions)({
+      ...await parseProviderOptions2({
         provider: this.providerOptionsName,
         providerOptions,
         schema: openaiLanguageModelCompletionOptions
@@ -1512,15 +1482,15 @@ var OpenAICompletionLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils8.postJsonToApi)({
+    } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils8.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders2(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils8.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         openaiCompletionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -1557,15 +1527,15 @@ var OpenAICompletionLanguageModel = class {
         include_usage: true
       }
     };
-    const { responseHeaders, value: response } = await (0, import_provider_utils8.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils8.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders2(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils8.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler2(
         openaiCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -1648,37 +1618,44 @@ var OpenAICompletionLanguageModel = class {
 };
 
 // src/embedding/openai-embedding-model.ts
-var import_provider5 = require("@ai-sdk/provider");
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3
+} from "@ai-sdk/provider-utils";
 
 // src/embedding/openai-embedding-options.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var openaiEmbeddingModelOptions = (0, import_provider_utils9.lazySchema)(
-  () => (0, import_provider_utils9.zodSchema)(
-    import_v46.z.object({
+import { lazySchema as lazySchema5, zodSchema as zodSchema5 } from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var openaiEmbeddingModelOptions = lazySchema5(
+  () => zodSchema5(
+    z6.object({
       /**
        * The number of dimensions the resulting output embeddings should have.
        * Only supported in text-embedding-3 and later models.
        */
-      dimensions: import_v46.z.number().optional(),
+      dimensions: z6.number().optional(),
       /**
        * A unique identifier representing your end-user, which can help OpenAI to
        * monitor and detect abuse. Learn more.
        */
-      user: import_v46.z.string().optional()
+      user: z6.string().optional()
     })
   )
 );
 
 // src/embedding/openai-embedding-api.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-var openaiTextEmbeddingResponseSchema = (0, import_provider_utils10.lazySchema)(
-  () => (0, import_provider_utils10.zodSchema)(
-    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()
+import { lazySchema as lazySchema6, zodSchema as zodSchema6 } from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var openaiTextEmbeddingResponseSchema = lazySchema6(
+  () => zodSchema6(
+    z7.object({
+      data: z7.array(z7.object({ embedding: z7.array(z7.number()) })),
+      usage: z7.object({ prompt_tokens: z7.number() }).nullish()
     })
   )
 );
@@ -1703,14 +1680,14 @@ var OpenAIEmbeddingModel = class {
   }) {
     var _a;
     if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider5.TooManyEmbeddingValuesForCallError({
+      throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
         modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
         values
       });
     }
-    const openaiOptions = (_a = await (0, import_provider_utils11.parseProviderOptions)({
+    const openaiOptions = (_a = await parseProviderOptions3({
       provider: "openai",
       providerOptions,
       schema: openaiEmbeddingModelOptions
@@ -1719,12 +1696,12 @@ var OpenAIEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils11.postJsonToApi)({
+    } = await postJsonToApi3({
       url: this.config.url({
         path: "/embeddings",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils11.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders3(this.config.headers(), headers),
       body: {
         model: this.modelId,
         input: values,
@@ -1733,7 +1710,7 @@ var OpenAIEmbeddingModel = class {
         user: openaiOptions.user
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils11.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         openaiTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -1749,32 +1726,40 @@ var OpenAIEmbeddingModel = class {
 };
 
 // src/image/openai-image-model.ts
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders4,
+  convertBase64ToUint8Array,
+  convertToFormData,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  downloadBlob,
+  postFormDataToApi,
+  postJsonToApi as postJsonToApi4
+} from "@ai-sdk/provider-utils";
 
 // src/image/openai-image-api.ts
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
-var openaiImageResponseSchema = (0, import_provider_utils12.lazySchema)(
-  () => (0, import_provider_utils12.zodSchema)(
-    import_v48.z.object({
-      created: import_v48.z.number().nullish(),
-      data: import_v48.z.array(
-        import_v48.z.object({
-          b64_json: import_v48.z.string(),
-          revised_prompt: import_v48.z.string().nullish()
+import { lazySchema as lazySchema7, zodSchema as zodSchema7 } from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var openaiImageResponseSchema = lazySchema7(
+  () => zodSchema7(
+    z8.object({
+      created: z8.number().nullish(),
+      data: z8.array(
+        z8.object({
+          b64_json: z8.string(),
+          revised_prompt: z8.string().nullish()
         })
       ),
-      background: import_v48.z.string().nullish(),
-      output_format: import_v48.z.string().nullish(),
-      size: import_v48.z.string().nullish(),
-      quality: import_v48.z.string().nullish(),
-      usage: import_v48.z.object({
-        input_tokens: import_v48.z.number().nullish(),
-        output_tokens: import_v48.z.number().nullish(),
-        total_tokens: import_v48.z.number().nullish(),
-        input_tokens_details: import_v48.z.object({
-          image_tokens: import_v48.z.number().nullish(),
-          text_tokens: import_v48.z.number().nullish()
+      background: z8.string().nullish(),
+      output_format: z8.string().nullish(),
+      size: z8.string().nullish(),
+      quality: z8.string().nullish(),
+      usage: z8.object({
+        input_tokens: z8.number().nullish(),
+        output_tokens: z8.number().nullish(),
+        total_tokens: z8.number().nullish(),
+        input_tokens_details: z8.object({
+          image_tokens: z8.number().nullish(),
+          text_tokens: z8.number().nullish()
         }).nullish()
       }).nullish()
     })
@@ -1842,13 +1827,13 @@ var OpenAIImageModel = class {
     }
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
     if (files != null) {
-      const { value: response2, responseHeaders: responseHeaders2 } = await (0, import_provider_utils13.postFormDataToApi)({
+      const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi({
         url: this.config.url({
           path: "/images/edits",
           modelId: this.modelId
         }),
-        headers: (0, import_provider_utils13.combineHeaders)(this.config.headers(), headers),
-        formData: (0, import_provider_utils13.convertToFormData)({
+        headers: combineHeaders4(this.config.headers(), headers),
+        formData: convertToFormData({
           model: this.modelId,
           prompt,
           image: await Promise.all(
@@ -1857,12 +1842,12 @@ var OpenAIImageModel = class {
                 [
                   file.data instanceof Uint8Array ? new Blob([file.data], {
                     type: file.mediaType
-                  }) : new Blob([(0, import_provider_utils13.convertBase64ToUint8Array)(file.data)], {
+                  }) : new Blob([convertBase64ToUint8Array(file.data)], {
                     type: file.mediaType
                   })
                 ],
                 { type: file.mediaType }
-              ) : (0, import_provider_utils13.downloadBlob)(file.url)
+              ) : downloadBlob(file.url)
             )
           ),
           mask: mask != null ? await fileToBlob(mask) : void 0,
@@ -1871,7 +1856,7 @@ var OpenAIImageModel = class {
           ...(_d = providerOptions.openai) != null ? _d : {}
         }),
         failedResponseHandler: openaiFailedResponseHandler,
-        successfulResponseHandler: (0, import_provider_utils13.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler4(
           openaiImageResponseSchema
         ),
         abortSignal,
@@ -1912,12 +1897,12 @@ var OpenAIImageModel = class {
         }
       };
     }
-    const { value: response, responseHeaders } = await (0, import_provider_utils13.postJsonToApi)({
+    const { value: response, responseHeaders } = await postJsonToApi4({
       url: this.config.url({
         path: "/images/generations",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils13.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders4(this.config.headers(), headers),
       body: {
         model: this.modelId,
         prompt,
@@ -1927,7 +1912,7 @@ var OpenAIImageModel = class {
         ...!hasDefaultResponseFormat(this.modelId) ? { response_format: "b64_json" } : {}
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils13.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler4(
         openaiImageResponseSchema
       ),
       abortSignal,
@@ -1989,43 +1974,50 @@ function distributeTokenDetails(details, index, total) {
 async function fileToBlob(file) {
   if (!file) return void 0;
   if (file.type === "url") {
-    return (0, import_provider_utils13.downloadBlob)(file.url);
+    return downloadBlob(file.url);
   }
-  const data = file.data instanceof Uint8Array ? file.data : (0, import_provider_utils13.convertBase64ToUint8Array)(file.data);
+  const data = file.data instanceof Uint8Array ? file.data : convertBase64ToUint8Array(file.data);
   return new Blob([data], { type: file.mediaType });
 }
 
 // src/transcription/openai-transcription-model.ts
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders5,
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  createJsonResponseHandler as createJsonResponseHandler5,
+  mediaTypeToExtension,
+  parseProviderOptions as parseProviderOptions4,
+  postFormDataToApi as postFormDataToApi2
+} from "@ai-sdk/provider-utils";
 
 // src/transcription/openai-transcription-api.ts
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
-var import_v49 = require("zod/v4");
-var openaiTranscriptionResponseSchema = (0, import_provider_utils14.lazySchema)(
-  () => (0, import_provider_utils14.zodSchema)(
-    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()
+import { lazySchema as lazySchema8, zodSchema as zodSchema8 } from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+var openaiTranscriptionResponseSchema = lazySchema8(
+  () => 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: 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()
+      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()
     })
@@ -2033,33 +2025,33 @@ var openaiTranscriptionResponseSchema = (0, import_provider_utils14.lazySchema)(
 );
 
 // src/transcription/openai-transcription-options.ts
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
-var import_v410 = require("zod/v4");
-var openAITranscriptionModelOptions = (0, import_provider_utils15.lazySchema)(
-  () => (0, import_provider_utils15.zodSchema)(
-    import_v410.z.object({
+import { lazySchema as lazySchema9, zodSchema as zodSchema9 } from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod/v4";
+var openAITranscriptionModelOptions = lazySchema9(
+  () => zodSchema9(
+    z10.object({
       /**
        * Additional information to include in the transcription response.
        */
-      include: import_v410.z.array(import_v410.z.string()).optional(),
+      include: z10.array(z10.string()).optional(),
       /**
        * The language of the input audio in ISO-639-1 format.
        */
-      language: import_v410.z.string().optional(),
+      language: z10.string().optional(),
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */
-      prompt: import_v410.z.string().optional(),
+      prompt: z10.string().optional(),
       /**
        * The sampling temperature, between 0 and 1.
        * @default 0
        */
-      temperature: import_v410.z.number().min(0).max(1).default(0).optional(),
+      temperature: z10.number().min(0).max(1).default(0).optional(),
       /**
        * The timestamp granularities to populate for this transcription.
        * @default ['segment']
        */
-      timestampGranularities: import_v410.z.array(import_v410.z.enum(["word", "segment"])).default(["segment"]).optional()
+      timestampGranularities: z10.array(z10.enum(["word", "segment"])).default(["segment"]).optional()
     })
   )
 );
@@ -2139,15 +2131,15 @@ var OpenAITranscriptionModel = class {
     providerOptions
   }) {
     const warnings = [];
-    const openAIOptions = await (0, import_provider_utils16.parseProviderOptions)({
+    const openAIOptions = await parseProviderOptions4({
       provider: "openai",
       providerOptions,
       schema: openAITranscriptionModelOptions
     });
     const formData = new FormData();
-    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([(0, import_provider_utils16.convertBase64ToUint8Array)(audio)]);
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array2(audio)]);
     formData.append("model", this.modelId);
-    const fileExtension = (0, import_provider_utils16.mediaTypeToExtension)(mediaType);
+    const fileExtension = mediaTypeToExtension(mediaType);
     formData.append(
       "file",
       new File([blob], "audio", { type: mediaType }),
@@ -2192,15 +2184,15 @@ var OpenAITranscriptionModel = class {
       value: response,
       responseHeaders,
       rawValue: rawResponse
-    } = await (0, import_provider_utils16.postFormDataToApi)({
+    } = await postFormDataToApi2({
       url: this.config.url({
         path: "/audio/transcriptions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils16.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders5(this.config.headers(), options.headers),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils16.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler5(
         openaiTranscriptionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -2232,16 +2224,21 @@ var OpenAITranscriptionModel = class {
 };
 
 // src/speech/openai-speech-model.ts
-var import_provider_utils18 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders6,
+  createBinaryResponseHandler,
+  parseProviderOptions as parseProviderOptions5,
+  postJsonToApi as postJsonToApi5
+} from "@ai-sdk/provider-utils";
 
 // src/speech/openai-speech-options.ts
-var import_provider_utils17 = require("@ai-sdk/provider-utils");
-var import_v411 = require("zod/v4");
-var openaiSpeechModelOptionsSchema = (0, import_provider_utils17.lazySchema)(
-  () => (0, import_provider_utils17.zodSchema)(
-    import_v411.z.object({
-      instructions: import_v411.z.string().nullish(),
-      speed: import_v411.z.number().min(0.25).max(4).default(1).nullish()
+import { lazySchema as lazySchema10, zodSchema as zodSchema10 } from "@ai-sdk/provider-utils";
+import { z as z11 } from "zod/v4";
+var openaiSpeechModelOptionsSchema = lazySchema10(
+  () => zodSchema10(
+    z11.object({
+      instructions: z11.string().nullish(),
+      speed: z11.number().min(0.25).max(4).default(1).nullish()
     })
   )
 );
@@ -2266,7 +2263,7 @@ var OpenAISpeechModel = class {
     providerOptions
   }) {
     const warnings = [];
-    const openAIOptions = await (0, import_provider_utils18.parseProviderOptions)({
+    const openAIOptions = await parseProviderOptions5({
       provider: "openai",
       providerOptions,
       schema: openaiSpeechModelOptionsSchema
@@ -2319,15 +2316,15 @@ var OpenAISpeechModel = class {
       value: audio,
       responseHeaders,
       rawValue: rawResponse
-    } = await (0, import_provider_utils18.postJsonToApi)({
+    } = await postJsonToApi5({
       url: this.config.url({
         path: "/audio/speech",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils18.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders6(this.config.headers(), options.headers),
       body: requestBody,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils18.createBinaryResponseHandler)(),
+      successfulResponseHandler: createBinaryResponseHandler(),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -2348,8 +2345,19 @@ var OpenAISpeechModel = class {
 };
 
 // src/responses/openai-responses-language-model.ts
-var import_provider8 = require("@ai-sdk/provider");
-var import_provider_utils34 = require("@ai-sdk/provider-utils");
+import {
+  APICallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders7,
+  createEventSourceResponseHandler as createEventSourceResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler6,
+  createToolNameMapping,
+  generateId as generateId2,
+  isCustomReasoning as isCustomReasoning2,
+  parseProviderOptions as parseProviderOptions7,
+  postJsonToApi as postJsonToApi6
+} from "@ai-sdk/provider-utils";
 
 // src/responses/convert-openai-responses-usage.ts
 function convertOpenAIResponsesUsage(usage) {
@@ -2391,46 +2399,60 @@ function convertOpenAIResponsesUsage(usage) {
 }
 
 // src/responses/convert-to-openai-responses-input.ts
-var import_provider6 = require("@ai-sdk/provider");
-var import_provider_utils23 = require("@ai-sdk/provider-utils");
-var import_v416 = require("zod/v4");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
+} from "@ai-sdk/provider";
+import {
+  convertToBase64 as convertToBase642,
+  isNonNullable,
+  isProviderReference as isProviderReference2,
+  parseJSON,
+  parseProviderOptions as parseProviderOptions6,
+  resolveProviderReference as resolveProviderReference2,
+  validateTypes
+} from "@ai-sdk/provider-utils";
+import { z as z16 } from "zod/v4";
 
 // src/tool/apply-patch.ts
-var import_provider_utils19 = require("@ai-sdk/provider-utils");
-var import_v412 = require("zod/v4");
-var applyPatchInputSchema = (0, import_provider_utils19.lazySchema)(
-  () => (0, import_provider_utils19.zodSchema)(
-    import_v412.z.object({
-      callId: import_v412.z.string(),
-      operation: import_v412.z.discriminatedUnion("type", [
-        import_v412.z.object({
-          type: import_v412.z.literal("create_file"),
-          path: import_v412.z.string(),
-          diff: import_v412.z.string()
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema as lazySchema11,
+  zodSchema as zodSchema11
+} from "@ai-sdk/provider-utils";
+import { z as z12 } from "zod/v4";
+var applyPatchInputSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
+      callId: z12.string(),
+      operation: z12.discriminatedUnion("type", [
+        z12.object({
+          type: z12.literal("create_file"),
+          path: z12.string(),
+          diff: z12.string()
         }),
-        import_v412.z.object({
-          type: import_v412.z.literal("delete_file"),
-          path: import_v412.z.string()
+        z12.object({
+          type: z12.literal("delete_file"),
+          path: z12.string()
         }),
-        import_v412.z.object({
-          type: import_v412.z.literal("update_file"),
-          path: import_v412.z.string(),
-          diff: import_v412.z.string()
+        z12.object({
+          type: z12.literal("update_file"),
+          path: z12.string(),
+          diff: z12.string()
         })
       ])
     })
   )
 );
-var applyPatchOutputSchema = (0, import_provider_utils19.lazySchema)(
-  () => (0, import_provider_utils19.zodSchema)(
-    import_v412.z.object({
-      status: import_v412.z.enum(["completed", "failed"]),
-      output: import_v412.z.string().optional()
+var applyPatchOutputSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
+      status: z12.enum(["completed", "failed"]),
+      output: z12.string().optional()
     })
   )
 );
-var applyPatchArgsSchema = (0, import_provider_utils19.lazySchema)(() => (0, import_provider_utils19.zodSchema)(import_v412.z.object({})));
-var applyPatchToolFactory = (0, import_provider_utils19.createProviderToolFactoryWithOutputSchema)({
+var applyPatchArgsSchema = lazySchema11(() => zodSchema11(z12.object({})));
+var applyPatchToolFactory = createProviderToolFactoryWithOutputSchema({
   id: "openai.apply_patch",
   inputSchema: applyPatchInputSchema,
   outputSchema: applyPatchOutputSchema
@@ -2438,115 +2460,123 @@ var applyPatchToolFactory = (0, import_provider_utils19.createProviderToolFactor
 var applyPatch = applyPatchToolFactory;
 
 // src/tool/local-shell.ts
-var import_provider_utils20 = require("@ai-sdk/provider-utils");
-var import_v413 = require("zod/v4");
-var localShellInputSchema = (0, import_provider_utils20.lazySchema)(
-  () => (0, import_provider_utils20.zodSchema)(
-    import_v413.z.object({
-      action: import_v413.z.object({
-        type: import_v413.z.literal("exec"),
-        command: import_v413.z.array(import_v413.z.string()),
-        timeoutMs: import_v413.z.number().optional(),
-        user: import_v413.z.string().optional(),
-        workingDirectory: import_v413.z.string().optional(),
-        env: import_v413.z.record(import_v413.z.string(), import_v413.z.string()).optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema2,
+  lazySchema as lazySchema12,
+  zodSchema as zodSchema12
+} from "@ai-sdk/provider-utils";
+import { z as z13 } from "zod/v4";
+var localShellInputSchema = lazySchema12(
+  () => zodSchema12(
+    z13.object({
+      action: z13.object({
+        type: z13.literal("exec"),
+        command: z13.array(z13.string()),
+        timeoutMs: z13.number().optional(),
+        user: z13.string().optional(),
+        workingDirectory: z13.string().optional(),
+        env: z13.record(z13.string(), z13.string()).optional()
       })
     })
   )
 );
-var localShellOutputSchema = (0, import_provider_utils20.lazySchema)(
-  () => (0, import_provider_utils20.zodSchema)(import_v413.z.object({ output: import_v413.z.string() }))
+var localShellOutputSchema = lazySchema12(
+  () => zodSchema12(z13.object({ output: z13.string() }))
 );
-var localShell = (0, import_provider_utils20.createProviderToolFactoryWithOutputSchema)({
+var localShell = createProviderToolFactoryWithOutputSchema2({
   id: "openai.local_shell",
   inputSchema: localShellInputSchema,
   outputSchema: localShellOutputSchema
 });
 
 // src/tool/shell.ts
-var import_provider_utils21 = require("@ai-sdk/provider-utils");
-var import_v414 = require("zod/v4");
-var shellInputSchema = (0, import_provider_utils21.lazySchema)(
-  () => (0, import_provider_utils21.zodSchema)(
-    import_v414.z.object({
-      action: import_v414.z.object({
-        commands: import_v414.z.array(import_v414.z.string()),
-        timeoutMs: import_v414.z.number().optional(),
-        maxOutputLength: import_v414.z.number().optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema3,
+  lazySchema as lazySchema13,
+  zodSchema as zodSchema13
+} from "@ai-sdk/provider-utils";
+import { z as z14 } from "zod/v4";
+var shellInputSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      action: z14.object({
+        commands: z14.array(z14.string()),
+        timeoutMs: z14.number().optional(),
+        maxOutputLength: z14.number().optional()
       })
     })
   )
 );
-var shellOutputSchema = (0, import_provider_utils21.lazySchema)(
-  () => (0, import_provider_utils21.zodSchema)(
-    import_v414.z.object({
-      output: import_v414.z.array(
-        import_v414.z.object({
-          stdout: import_v414.z.string(),
-          stderr: import_v414.z.string(),
-          outcome: import_v414.z.discriminatedUnion("type", [
-            import_v414.z.object({ type: import_v414.z.literal("timeout") }),
-            import_v414.z.object({ type: import_v414.z.literal("exit"), exitCode: import_v414.z.number() })
+var shellOutputSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      output: z14.array(
+        z14.object({
+          stdout: z14.string(),
+          stderr: z14.string(),
+          outcome: z14.discriminatedUnion("type", [
+            z14.object({ type: z14.literal("timeout") }),
+            z14.object({ type: z14.literal("exit"), exitCode: z14.number() })
           ])
         })
       )
     })
   )
 );
-var shellSkillsSchema = import_v414.z.array(
-  import_v414.z.discriminatedUnion("type", [
-    import_v414.z.object({
-      type: import_v414.z.literal("skillReference"),
-      providerReference: import_v414.z.record(import_v414.z.string(), import_v414.z.string()),
-      version: import_v414.z.string().optional()
+var shellSkillsSchema = z14.array(
+  z14.discriminatedUnion("type", [
+    z14.object({
+      type: z14.literal("skillReference"),
+      providerReference: z14.record(z14.string(), z14.string()),
+      version: z14.string().optional()
     }),
-    import_v414.z.object({
-      type: import_v414.z.literal("inline"),
-      name: import_v414.z.string(),
-      description: import_v414.z.string(),
-      source: import_v414.z.object({
-        type: import_v414.z.literal("base64"),
-        mediaType: import_v414.z.literal("application/zip"),
-        data: import_v414.z.string()
+    z14.object({
+      type: z14.literal("inline"),
+      name: z14.string(),
+      description: z14.string(),
+      source: z14.object({
+        type: z14.literal("base64"),
+        mediaType: z14.literal("application/zip"),
+        data: z14.string()
       })
     })
   ])
 ).optional();
-var shellArgsSchema = (0, import_provider_utils21.lazySchema)(
-  () => (0, import_provider_utils21.zodSchema)(
-    import_v414.z.object({
-      environment: import_v414.z.union([
-        import_v414.z.object({
-          type: import_v414.z.literal("containerAuto"),
-          fileIds: import_v414.z.array(import_v414.z.string()).optional(),
-          memoryLimit: import_v414.z.enum(["1g", "4g", "16g", "64g"]).optional(),
-          networkPolicy: import_v414.z.discriminatedUnion("type", [
-            import_v414.z.object({ type: import_v414.z.literal("disabled") }),
-            import_v414.z.object({
-              type: import_v414.z.literal("allowlist"),
-              allowedDomains: import_v414.z.array(import_v414.z.string()),
-              domainSecrets: import_v414.z.array(
-                import_v414.z.object({
-                  domain: import_v414.z.string(),
-                  name: import_v414.z.string(),
-                  value: import_v414.z.string()
+var shellArgsSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      environment: z14.union([
+        z14.object({
+          type: z14.literal("containerAuto"),
+          fileIds: z14.array(z14.string()).optional(),
+          memoryLimit: z14.enum(["1g", "4g", "16g", "64g"]).optional(),
+          networkPolicy: z14.discriminatedUnion("type", [
+            z14.object({ type: z14.literal("disabled") }),
+            z14.object({
+              type: z14.literal("allowlist"),
+              allowedDomains: z14.array(z14.string()),
+              domainSecrets: z14.array(
+                z14.object({
+                  domain: z14.string(),
+                  name: z14.string(),
+                  value: z14.string()
                 })
               ).optional()
             })
           ]).optional(),
           skills: shellSkillsSchema
         }),
-        import_v414.z.object({
-          type: import_v414.z.literal("containerReference"),
-          containerId: import_v414.z.string()
+        z14.object({
+          type: z14.literal("containerReference"),
+          containerId: z14.string()
         }),
-        import_v414.z.object({
-          type: import_v414.z.literal("local").optional(),
-          skills: import_v414.z.array(
-            import_v414.z.object({
-              name: import_v414.z.string(),
-              description: import_v414.z.string(),
-              path: import_v414.z.string()
+        z14.object({
+          type: z14.literal("local").optional(),
+          skills: z14.array(
+            z14.object({
+              name: z14.string(),
+              description: z14.string(),
+              path: z14.string()
             })
           ).optional()
         })
@@ -2554,40 +2584,44 @@ var shellArgsSchema = (0, import_provider_utils21.lazySchema)(
     })
   )
 );
-var shell = (0, import_provider_utils21.createProviderToolFactoryWithOutputSchema)({
+var shell = createProviderToolFactoryWithOutputSchema3({
   id: "openai.shell",
   inputSchema: shellInputSchema,
   outputSchema: shellOutputSchema
 });
 
 // src/tool/tool-search.ts
-var import_provider_utils22 = require("@ai-sdk/provider-utils");
-var import_v415 = require("zod/v4");
-var toolSearchArgsSchema = (0, import_provider_utils22.lazySchema)(
-  () => (0, import_provider_utils22.zodSchema)(
-    import_v415.z.object({
-      execution: import_v415.z.enum(["server", "client"]).optional(),
-      description: import_v415.z.string().optional(),
-      parameters: import_v415.z.record(import_v415.z.string(), import_v415.z.unknown()).optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema4,
+  lazySchema as lazySchema14,
+  zodSchema as zodSchema14
+} from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
+var toolSearchArgsSchema = lazySchema14(
+  () => zodSchema14(
+    z15.object({
+      execution: z15.enum(["server", "client"]).optional(),
+      description: z15.string().optional(),
+      parameters: z15.record(z15.string(), z15.unknown()).optional()
     })
   )
 );
-var toolSearchInputSchema = (0, import_provider_utils22.lazySchema)(
-  () => (0, import_provider_utils22.zodSchema)(
-    import_v415.z.object({
-      arguments: import_v415.z.unknown().optional(),
-      call_id: import_v415.z.string().nullish()
+var toolSearchInputSchema = lazySchema14(
+  () => zodSchema14(
+    z15.object({
+      arguments: z15.unknown().optional(),
+      call_id: z15.string().nullish()
     })
   )
 );
-var toolSearchOutputSchema = (0, import_provider_utils22.lazySchema)(
-  () => (0, import_provider_utils22.zodSchema)(
-    import_v415.z.object({
-      tools: import_v415.z.array(import_v415.z.record(import_v415.z.string(), import_v415.z.unknown()))
+var toolSearchOutputSchema = lazySchema14(
+  () => zodSchema14(
+    z15.object({
+      tools: z15.array(z15.record(z15.string(), z15.unknown()))
     })
   )
 );
-var toolSearchToolFactory = (0, import_provider_utils22.createProviderToolFactoryWithOutputSchema)({
+var toolSearchToolFactory = createProviderToolFactoryWithOutputSchema4({
   id: "openai.tool_search",
   inputSchema: toolSearchInputSchema,
   outputSchema: toolSearchOutputSchema
@@ -2653,8 +2687,8 @@ async function convertToOpenAIResponsesInput({
                 return { type: "input_text", text: part.text };
               }
               case "file": {
-                if ((0, import_provider_utils23.isProviderReference)(part.data)) {
-                  const fileId = (0, import_provider_utils23.resolveProviderReference)({
+                if (isProviderReference2(part.data)) {
+                  const fileId = resolveProviderReference2({
                     reference: part.data,
                     provider: providerOptionsName
                   });
@@ -2675,7 +2709,7 @@ async function convertToOpenAIResponsesInput({
                   return {
                     type: "input_image",
                     ...part.data instanceof URL ? { image_url: part.data.toString() } : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
-                      image_url: `data:${mediaType};base64,${(0, import_provider_utils23.convertToBase64)(part.data)}`
+                      image_url: `data:${mediaType};base64,${convertToBase642(part.data)}`
                     },
                     detail: (_d2 = (_c2 = part.providerOptions) == null ? void 0 : _c2[providerOptionsName]) == null ? void 0 : _d2.imageDetail
                   };
@@ -2690,11 +2724,11 @@ async function convertToOpenAIResponsesInput({
                     type: "input_file",
                     ...typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
                       filename: (_e2 = part.filename) != null ? _e2 : `part-${index}.pdf`,
-                      file_data: `data:application/pdf;base64,${(0, import_provider_utils23.convertToBase64)(part.data)}`
+                      file_data: `data:application/pdf;base64,${convertToBase642(part.data)}`
                     }
                   };
                 } else {
-                  throw new import_provider6.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError4({
                     functionality: `file part media type ${part.mediaType}`
                   });
                 }
@@ -2740,10 +2774,10 @@ async function convertToOpenAIResponsesInput({
                   input.push({ type: "item_reference", id });
                   break;
                 }
-                const parsedInput = typeof part.input === "string" ? await (0, import_provider_utils23.parseJSON)({
+                const parsedInput = typeof part.input === "string" ? await parseJSON({
                   text: part.input,
                   schema: toolSearchInputSchema
-                }) : await (0, import_provider_utils23.validateTypes)({
+                }) : await validateTypes({
                   value: part.input,
                   schema: toolSearchInputSchema
                 });
@@ -2769,7 +2803,7 @@ async function convertToOpenAIResponsesInput({
                 break;
               }
               if (hasLocalShellTool && resolvedToolName === "local_shell") {
-                const parsedInput = await (0, import_provider_utils23.validateTypes)({
+                const parsedInput = await validateTypes({
                   value: part.input,
                   schema: localShellInputSchema
                 });
@@ -2789,7 +2823,7 @@ async function convertToOpenAIResponsesInput({
                 break;
               }
               if (hasShellTool && resolvedToolName === "shell") {
-                const parsedInput = await (0, import_provider_utils23.validateTypes)({
+                const parsedInput = await validateTypes({
                   value: part.input,
                   schema: shellInputSchema
                 });
@@ -2807,7 +2841,7 @@ async function convertToOpenAIResponsesInput({
                 break;
               }
               if (hasApplyPatchTool && resolvedToolName === "apply_patch") {
-                const parsedInput = await (0, import_provider_utils23.validateTypes)({
+                const parsedInput = await validateTypes({
                   value: part.input,
                   schema: applyPatchInputSchema
                 });
@@ -2855,7 +2889,7 @@ async function convertToOpenAIResponsesInput({
                 if (store) {
                   input.push({ type: "item_reference", id: itemId });
                 } else if (part.output.type === "json") {
-                  const parsedOutput = await (0, import_provider_utils23.validateTypes)({
+                  const parsedOutput = await validateTypes({
                     value: part.output.value,
                     schema: toolSearchOutputSchema
                   });
@@ -2872,7 +2906,7 @@ async function convertToOpenAIResponsesInput({
               }
               if (hasShellTool && resolvedResultToolName === "shell") {
                 if (part.output.type === "json") {
-                  const parsedOutput = await (0, import_provider_utils23.validateTypes)({
+                  const parsedOutput = await validateTypes({
                     value: part.output.value,
                     schema: shellOutputSchema
                   });
@@ -2903,7 +2937,7 @@ async function convertToOpenAIResponsesInput({
               break;
             }
             case "reasoning": {
-              const providerOptions = await (0, import_provider_utils23.parseProviderOptions)({
+              const providerOptions = await parseProviderOptions6({
                 provider: providerOptionsName,
                 providerOptions: part.providerOptions,
                 schema: openaiResponsesReasoningProviderOptionsSchema
@@ -3033,7 +3067,7 @@ async function convertToOpenAIResponsesInput({
             part.toolName
           );
           if (resolvedToolName === "tool_search" && output.type === "json") {
-            const parsedOutput = await (0, import_provider_utils23.validateTypes)({
+            const parsedOutput = await validateTypes({
               value: output.value,
               schema: toolSearchOutputSchema
             });
@@ -3047,7 +3081,7 @@ async function convertToOpenAIResponsesInput({
             continue;
           }
           if (hasLocalShellTool && resolvedToolName === "local_shell" && output.type === "json") {
-            const parsedOutput = await (0, import_provider_utils23.validateTypes)({
+            const parsedOutput = await validateTypes({
               value: output.value,
               schema: localShellOutputSchema
             });
@@ -3059,7 +3093,7 @@ async function convertToOpenAIResponsesInput({
             continue;
           }
           if (hasShellTool && resolvedToolName === "shell" && output.type === "json") {
-            const parsedOutput = await (0, import_provider_utils23.validateTypes)({
+            const parsedOutput = await validateTypes({
               value: output.value,
               schema: shellOutputSchema
             });
@@ -3078,7 +3112,7 @@ async function convertToOpenAIResponsesInput({
             continue;
           }
           if (hasApplyPatchTool && part.toolName === "apply_patch" && output.type === "json") {
-            const parsedOutput = await (0, import_provider_utils23.validateTypes)({
+            const parsedOutput = await validateTypes({
               value: output.value,
               schema: applyPatchOutputSchema
             });
@@ -3138,7 +3172,7 @@ async function convertToOpenAIResponsesInput({
                       });
                       return void 0;
                   }
-                }).filter(import_provider_utils23.isNonNullable);
+                }).filter(isNonNullable);
                 break;
               default:
                 outputValue = "";
@@ -3203,7 +3237,7 @@ async function convertToOpenAIResponsesInput({
                     return void 0;
                   }
                 }
-              }).filter(import_provider_utils23.isNonNullable);
+              }).filter(isNonNullable);
               break;
           }
           input.push({
@@ -3233,9 +3267,9 @@ async function convertToOpenAIResponsesInput({
   }
   return { input, warnings };
 }
-var openaiResponsesReasoningProviderOptionsSchema = import_v416.z.object({
-  itemId: import_v416.z.string().nullish(),
-  reasoningEncryptedContent: import_v416.z.string().nullish()
+var openaiResponsesReasoningProviderOptionsSchema = z16.object({
+  itemId: z16.string().nullish(),
+  reasoningEncryptedContent: z16.string().nullish()
 });
 
 // src/responses/map-openai-responses-finish-reason.ts
@@ -3257,552 +3291,552 @@ function mapOpenAIResponseFinishReason({
 }
 
 // src/responses/openai-responses-api.ts
-var import_provider_utils24 = require("@ai-sdk/provider-utils");
-var import_v417 = require("zod/v4");
-var jsonValueSchema = import_v417.z.lazy(
-  () => import_v417.z.union([
-    import_v417.z.string(),
-    import_v417.z.number(),
-    import_v417.z.boolean(),
-    import_v417.z.null(),
-    import_v417.z.array(jsonValueSchema),
-    import_v417.z.record(import_v417.z.string(), jsonValueSchema.optional())
+import { lazySchema as lazySchema15, zodSchema as zodSchema15 } from "@ai-sdk/provider-utils";
+import { z as z17 } from "zod/v4";
+var jsonValueSchema = z17.lazy(
+  () => z17.union([
+    z17.string(),
+    z17.number(),
+    z17.boolean(),
+    z17.null(),
+    z17.array(jsonValueSchema),
+    z17.record(z17.string(), jsonValueSchema.optional())
   ])
 );
-var openaiResponsesChunkSchema = (0, import_provider_utils24.lazySchema)(
-  () => (0, import_provider_utils24.zodSchema)(
-    import_v417.z.union([
-      import_v417.z.object({
-        type: import_v417.z.literal("response.output_text.delta"),
-        item_id: import_v417.z.string(),
-        delta: import_v417.z.string(),
-        logprobs: import_v417.z.array(
-          import_v417.z.object({
-            token: import_v417.z.string(),
-            logprob: import_v417.z.number(),
-            top_logprobs: import_v417.z.array(
-              import_v417.z.object({
-                token: import_v417.z.string(),
-                logprob: import_v417.z.number()
+var openaiResponsesChunkSchema = lazySchema15(
+  () => zodSchema15(
+    z17.union([
+      z17.object({
+        type: z17.literal("response.output_text.delta"),
+        item_id: z17.string(),
+        delta: z17.string(),
+        logprobs: z17.array(
+          z17.object({
+            token: z17.string(),
+            logprob: z17.number(),
+            top_logprobs: z17.array(
+              z17.object({
+                token: z17.string(),
+                logprob: z17.number()
               })
             )
           })
         ).nullish()
       }),
-      import_v417.z.object({
-        type: import_v417.z.enum(["response.completed", "response.incomplete"]),
-        response: import_v417.z.object({
-          incomplete_details: import_v417.z.object({ reason: import_v417.z.string() }).nullish(),
-          usage: import_v417.z.object({
-            input_tokens: import_v417.z.number(),
-            input_tokens_details: import_v417.z.object({ cached_tokens: import_v417.z.number().nullish() }).nullish(),
-            output_tokens: import_v417.z.number(),
-            output_tokens_details: import_v417.z.object({ reasoning_tokens: import_v417.z.number().nullish() }).nullish()
+      z17.object({
+        type: z17.enum(["response.completed", "response.incomplete"]),
+        response: z17.object({
+          incomplete_details: z17.object({ reason: z17.string() }).nullish(),
+          usage: z17.object({
+            input_tokens: z17.number(),
+            input_tokens_details: z17.object({ cached_tokens: z17.number().nullish() }).nullish(),
+            output_tokens: z17.number(),
+            output_tokens_details: z17.object({ reasoning_tokens: z17.number().nullish() }).nullish()
           }),
-          service_tier: import_v417.z.string().nullish()
+          service_tier: z17.string().nullish()
         })
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.failed"),
-        response: import_v417.z.object({
-          error: import_v417.z.object({
-            code: import_v417.z.string().nullish(),
-            message: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.failed"),
+        response: z17.object({
+          error: z17.object({
+            code: z17.string().nullish(),
+            message: z17.string()
           }).nullish(),
-          incomplete_details: import_v417.z.object({ reason: import_v417.z.string() }).nullish(),
-          usage: import_v417.z.object({
-            input_tokens: import_v417.z.number(),
-            input_tokens_details: import_v417.z.object({ cached_tokens: import_v417.z.number().nullish() }).nullish(),
-            output_tokens: import_v417.z.number(),
-            output_tokens_details: import_v417.z.object({ reasoning_tokens: import_v417.z.number().nullish() }).nullish()
+          incomplete_details: z17.object({ reason: z17.string() }).nullish(),
+          usage: z17.object({
+            input_tokens: z17.number(),
+            input_tokens_details: z17.object({ cached_tokens: z17.number().nullish() }).nullish(),
+            output_tokens: z17.number(),
+            output_tokens_details: z17.object({ reasoning_tokens: z17.number().nullish() }).nullish()
           }).nullish(),
-          service_tier: import_v417.z.string().nullish()
+          service_tier: z17.string().nullish()
         })
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.created"),
-        response: import_v417.z.object({
-          id: import_v417.z.string(),
-          created_at: import_v417.z.number(),
-          model: import_v417.z.string(),
-          service_tier: import_v417.z.string().nullish()
+      z17.object({
+        type: z17.literal("response.created"),
+        response: z17.object({
+          id: z17.string(),
+          created_at: z17.number(),
+          model: z17.string(),
+          service_tier: z17.string().nullish()
         })
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.output_item.added"),
-        output_index: import_v417.z.number(),
-        item: import_v417.z.discriminatedUnion("type", [
-          import_v417.z.object({
-            type: import_v417.z.literal("message"),
-            id: import_v417.z.string(),
-            phase: import_v417.z.enum(["commentary", "final_answer"]).nullish()
+      z17.object({
+        type: z17.literal("response.output_item.added"),
+        output_index: z17.number(),
+        item: z17.discriminatedUnion("type", [
+          z17.object({
+            type: z17.literal("message"),
+            id: z17.string(),
+            phase: z17.enum(["commentary", "final_answer"]).nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("reasoning"),
-            id: import_v417.z.string(),
-            encrypted_content: import_v417.z.string().nullish()
+          z17.object({
+            type: z17.literal("reasoning"),
+            id: z17.string(),
+            encrypted_content: z17.string().nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("function_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            name: import_v417.z.string(),
-            arguments: import_v417.z.string()
+          z17.object({
+            type: z17.literal("function_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            name: z17.string(),
+            arguments: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("web_search_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.string()
+          z17.object({
+            type: z17.literal("web_search_call"),
+            id: z17.string(),
+            status: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("computer_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.string()
+          z17.object({
+            type: z17.literal("computer_call"),
+            id: z17.string(),
+            status: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("file_search_call"),
-            id: import_v417.z.string()
+          z17.object({
+            type: z17.literal("file_search_call"),
+            id: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("image_generation_call"),
-            id: import_v417.z.string()
+          z17.object({
+            type: z17.literal("image_generation_call"),
+            id: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("code_interpreter_call"),
-            id: import_v417.z.string(),
-            container_id: import_v417.z.string(),
-            code: import_v417.z.string().nullable(),
-            outputs: import_v417.z.array(
-              import_v417.z.discriminatedUnion("type", [
-                import_v417.z.object({ type: import_v417.z.literal("logs"), logs: import_v417.z.string() }),
-                import_v417.z.object({ type: import_v417.z.literal("image"), url: import_v417.z.string() })
+          z17.object({
+            type: z17.literal("code_interpreter_call"),
+            id: z17.string(),
+            container_id: z17.string(),
+            code: z17.string().nullable(),
+            outputs: z17.array(
+              z17.discriminatedUnion("type", [
+                z17.object({ type: z17.literal("logs"), logs: z17.string() }),
+                z17.object({ type: z17.literal("image"), url: z17.string() })
               ])
             ).nullable(),
-            status: import_v417.z.string()
+            status: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.string(),
-            approval_request_id: import_v417.z.string().nullish()
+          z17.object({
+            type: z17.literal("mcp_call"),
+            id: z17.string(),
+            status: z17.string(),
+            approval_request_id: z17.string().nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_list_tools"),
-            id: import_v417.z.string()
+          z17.object({
+            type: z17.literal("mcp_list_tools"),
+            id: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_approval_request"),
-            id: import_v417.z.string()
+          z17.object({
+            type: z17.literal("mcp_approval_request"),
+            id: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("apply_patch_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed"]),
-            operation: import_v417.z.discriminatedUnion("type", [
-              import_v417.z.object({
-                type: import_v417.z.literal("create_file"),
-                path: import_v417.z.string(),
-                diff: import_v417.z.string()
+          z17.object({
+            type: z17.literal("apply_patch_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed"]),
+            operation: z17.discriminatedUnion("type", [
+              z17.object({
+                type: z17.literal("create_file"),
+                path: z17.string(),
+                diff: z17.string()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("delete_file"),
-                path: import_v417.z.string()
+              z17.object({
+                type: z17.literal("delete_file"),
+                path: z17.string()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("update_file"),
-                path: import_v417.z.string(),
-                diff: import_v417.z.string()
+              z17.object({
+                type: z17.literal("update_file"),
+                path: z17.string(),
+                diff: z17.string()
               })
             ])
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("custom_tool_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            name: import_v417.z.string(),
-            input: import_v417.z.string()
+          z17.object({
+            type: z17.literal("custom_tool_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            name: z17.string(),
+            input: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("shell_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            action: import_v417.z.object({
-              commands: import_v417.z.array(import_v417.z.string())
+          z17.object({
+            type: z17.literal("shell_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            action: z17.object({
+              commands: z17.array(z17.string())
             })
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("compaction"),
-            id: import_v417.z.string(),
-            encrypted_content: import_v417.z.string().nullish()
+          z17.object({
+            type: z17.literal("compaction"),
+            id: z17.string(),
+            encrypted_content: z17.string().nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("shell_call_output"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            output: import_v417.z.array(
-              import_v417.z.object({
-                stdout: import_v417.z.string(),
-                stderr: import_v417.z.string(),
-                outcome: import_v417.z.discriminatedUnion("type", [
-                  import_v417.z.object({ type: import_v417.z.literal("timeout") }),
-                  import_v417.z.object({
-                    type: import_v417.z.literal("exit"),
-                    exit_code: import_v417.z.number()
+          z17.object({
+            type: z17.literal("shell_call_output"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            output: z17.array(
+              z17.object({
+                stdout: z17.string(),
+                stderr: z17.string(),
+                outcome: z17.discriminatedUnion("type", [
+                  z17.object({ type: z17.literal("timeout") }),
+                  z17.object({
+                    type: z17.literal("exit"),
+                    exit_code: z17.number()
                   })
                 ])
               })
             )
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("tool_search_call"),
-            id: import_v417.z.string(),
-            execution: import_v417.z.enum(["server", "client"]),
-            call_id: import_v417.z.string().nullable(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            arguments: import_v417.z.unknown()
+          z17.object({
+            type: z17.literal("tool_search_call"),
+            id: z17.string(),
+            execution: z17.enum(["server", "client"]),
+            call_id: z17.string().nullable(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z17.unknown()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("tool_search_output"),
-            id: import_v417.z.string(),
-            execution: import_v417.z.enum(["server", "client"]),
-            call_id: import_v417.z.string().nullable(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            tools: import_v417.z.array(import_v417.z.record(import_v417.z.string(), jsonValueSchema.optional()))
+          z17.object({
+            type: z17.literal("tool_search_output"),
+            id: z17.string(),
+            execution: z17.enum(["server", "client"]),
+            call_id: z17.string().nullable(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            tools: z17.array(z17.record(z17.string(), jsonValueSchema.optional()))
           })
         ])
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.output_item.done"),
-        output_index: import_v417.z.number(),
-        item: import_v417.z.discriminatedUnion("type", [
-          import_v417.z.object({
-            type: import_v417.z.literal("message"),
-            id: import_v417.z.string(),
-            phase: import_v417.z.enum(["commentary", "final_answer"]).nullish()
+      z17.object({
+        type: z17.literal("response.output_item.done"),
+        output_index: z17.number(),
+        item: z17.discriminatedUnion("type", [
+          z17.object({
+            type: z17.literal("message"),
+            id: z17.string(),
+            phase: z17.enum(["commentary", "final_answer"]).nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("reasoning"),
-            id: import_v417.z.string(),
-            encrypted_content: import_v417.z.string().nullish()
+          z17.object({
+            type: z17.literal("reasoning"),
+            id: z17.string(),
+            encrypted_content: z17.string().nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("function_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            name: import_v417.z.string(),
-            arguments: import_v417.z.string(),
-            status: import_v417.z.literal("completed")
+          z17.object({
+            type: z17.literal("function_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            name: z17.string(),
+            arguments: z17.string(),
+            status: z17.literal("completed")
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("custom_tool_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            name: import_v417.z.string(),
-            input: import_v417.z.string(),
-            status: import_v417.z.literal("completed")
+          z17.object({
+            type: z17.literal("custom_tool_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            name: z17.string(),
+            input: z17.string(),
+            status: z17.literal("completed")
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("code_interpreter_call"),
-            id: import_v417.z.string(),
-            code: import_v417.z.string().nullable(),
-            container_id: import_v417.z.string(),
-            outputs: import_v417.z.array(
-              import_v417.z.discriminatedUnion("type", [
-                import_v417.z.object({ type: import_v417.z.literal("logs"), logs: import_v417.z.string() }),
-                import_v417.z.object({ type: import_v417.z.literal("image"), url: import_v417.z.string() })
+          z17.object({
+            type: z17.literal("code_interpreter_call"),
+            id: z17.string(),
+            code: z17.string().nullable(),
+            container_id: z17.string(),
+            outputs: z17.array(
+              z17.discriminatedUnion("type", [
+                z17.object({ type: z17.literal("logs"), logs: z17.string() }),
+                z17.object({ type: z17.literal("image"), url: z17.string() })
               ])
             ).nullable()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("image_generation_call"),
-            id: import_v417.z.string(),
-            result: import_v417.z.string()
+          z17.object({
+            type: z17.literal("image_generation_call"),
+            id: z17.string(),
+            result: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("web_search_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.string(),
-            action: import_v417.z.discriminatedUnion("type", [
-              import_v417.z.object({
-                type: import_v417.z.literal("search"),
-                query: import_v417.z.string().nullish(),
-                sources: import_v417.z.array(
-                  import_v417.z.discriminatedUnion("type", [
-                    import_v417.z.object({ type: import_v417.z.literal("url"), url: import_v417.z.string() }),
-                    import_v417.z.object({ type: import_v417.z.literal("api"), name: import_v417.z.string() })
+          z17.object({
+            type: z17.literal("web_search_call"),
+            id: z17.string(),
+            status: z17.string(),
+            action: z17.discriminatedUnion("type", [
+              z17.object({
+                type: z17.literal("search"),
+                query: z17.string().nullish(),
+                sources: z17.array(
+                  z17.discriminatedUnion("type", [
+                    z17.object({ type: z17.literal("url"), url: z17.string() }),
+                    z17.object({ type: z17.literal("api"), name: z17.string() })
                   ])
                 ).nullish()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("open_page"),
-                url: import_v417.z.string().nullish()
+              z17.object({
+                type: z17.literal("open_page"),
+                url: z17.string().nullish()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("find_in_page"),
-                url: import_v417.z.string().nullish(),
-                pattern: import_v417.z.string().nullish()
+              z17.object({
+                type: z17.literal("find_in_page"),
+                url: z17.string().nullish(),
+                pattern: z17.string().nullish()
               })
             ]).nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("file_search_call"),
-            id: import_v417.z.string(),
-            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.union([import_v417.z.string(), import_v417.z.number(), import_v417.z.boolean()])
+          z17.object({
+            type: z17.literal("file_search_call"),
+            id: z17.string(),
+            queries: z17.array(z17.string()),
+            results: z17.array(
+              z17.object({
+                attributes: z17.record(
+                  z17.string(),
+                  z17.union([z17.string(), z17.number(), z17.boolean()])
                 ),
-                file_id: import_v417.z.string(),
-                filename: import_v417.z.string(),
-                score: import_v417.z.number(),
-                text: import_v417.z.string()
+                file_id: z17.string(),
+                filename: z17.string(),
+                score: z17.number(),
+                text: z17.string()
               })
             ).nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("local_shell_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            action: import_v417.z.object({
-              type: import_v417.z.literal("exec"),
-              command: import_v417.z.array(import_v417.z.string()),
-              timeout_ms: import_v417.z.number().optional(),
-              user: import_v417.z.string().optional(),
-              working_directory: import_v417.z.string().optional(),
-              env: import_v417.z.record(import_v417.z.string(), import_v417.z.string()).optional()
+          z17.object({
+            type: z17.literal("local_shell_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            action: z17.object({
+              type: z17.literal("exec"),
+              command: z17.array(z17.string()),
+              timeout_ms: z17.number().optional(),
+              user: z17.string().optional(),
+              working_directory: z17.string().optional(),
+              env: z17.record(z17.string(), z17.string()).optional()
             })
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("computer_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.literal("completed")
+          z17.object({
+            type: z17.literal("computer_call"),
+            id: z17.string(),
+            status: z17.literal("completed")
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.string(),
-            arguments: import_v417.z.string(),
-            name: import_v417.z.string(),
-            server_label: import_v417.z.string(),
-            output: import_v417.z.string().nullish(),
-            error: import_v417.z.union([
-              import_v417.z.string(),
-              import_v417.z.object({
-                type: import_v417.z.string().optional(),
-                code: import_v417.z.union([import_v417.z.number(), import_v417.z.string()]).optional(),
-                message: import_v417.z.string().optional()
+          z17.object({
+            type: z17.literal("mcp_call"),
+            id: z17.string(),
+            status: z17.string(),
+            arguments: z17.string(),
+            name: z17.string(),
+            server_label: z17.string(),
+            output: z17.string().nullish(),
+            error: z17.union([
+              z17.string(),
+              z17.object({
+                type: z17.string().optional(),
+                code: z17.union([z17.number(), z17.string()]).optional(),
+                message: z17.string().optional()
               }).loose()
             ]).nullish(),
-            approval_request_id: import_v417.z.string().nullish()
+            approval_request_id: z17.string().nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_list_tools"),
-            id: import_v417.z.string(),
-            server_label: import_v417.z.string(),
-            tools: import_v417.z.array(
-              import_v417.z.object({
-                name: import_v417.z.string(),
-                description: import_v417.z.string().optional(),
-                input_schema: import_v417.z.any(),
-                annotations: import_v417.z.record(import_v417.z.string(), import_v417.z.unknown()).optional()
+          z17.object({
+            type: z17.literal("mcp_list_tools"),
+            id: z17.string(),
+            server_label: z17.string(),
+            tools: z17.array(
+              z17.object({
+                name: z17.string(),
+                description: z17.string().optional(),
+                input_schema: z17.any(),
+                annotations: z17.record(z17.string(), z17.unknown()).optional()
               })
             ),
-            error: import_v417.z.union([
-              import_v417.z.string(),
-              import_v417.z.object({
-                type: import_v417.z.string().optional(),
-                code: import_v417.z.union([import_v417.z.number(), import_v417.z.string()]).optional(),
-                message: import_v417.z.string().optional()
+            error: z17.union([
+              z17.string(),
+              z17.object({
+                type: z17.string().optional(),
+                code: z17.union([z17.number(), z17.string()]).optional(),
+                message: z17.string().optional()
               }).loose()
             ]).optional()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_approval_request"),
-            id: import_v417.z.string(),
-            server_label: import_v417.z.string(),
-            name: import_v417.z.string(),
-            arguments: import_v417.z.string(),
-            approval_request_id: import_v417.z.string().optional()
+          z17.object({
+            type: z17.literal("mcp_approval_request"),
+            id: z17.string(),
+            server_label: z17.string(),
+            name: z17.string(),
+            arguments: z17.string(),
+            approval_request_id: z17.string().optional()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("apply_patch_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed"]),
-            operation: import_v417.z.discriminatedUnion("type", [
-              import_v417.z.object({
-                type: import_v417.z.literal("create_file"),
-                path: import_v417.z.string(),
-                diff: import_v417.z.string()
+          z17.object({
+            type: z17.literal("apply_patch_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed"]),
+            operation: z17.discriminatedUnion("type", [
+              z17.object({
+                type: z17.literal("create_file"),
+                path: z17.string(),
+                diff: z17.string()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("delete_file"),
-                path: import_v417.z.string()
+              z17.object({
+                type: z17.literal("delete_file"),
+                path: z17.string()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("update_file"),
-                path: import_v417.z.string(),
-                diff: import_v417.z.string()
+              z17.object({
+                type: z17.literal("update_file"),
+                path: z17.string(),
+                diff: z17.string()
               })
             ])
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("shell_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            action: import_v417.z.object({
-              commands: import_v417.z.array(import_v417.z.string())
+          z17.object({
+            type: z17.literal("shell_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            action: z17.object({
+              commands: z17.array(z17.string())
             })
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("compaction"),
-            id: import_v417.z.string(),
-            encrypted_content: import_v417.z.string()
+          z17.object({
+            type: z17.literal("compaction"),
+            id: z17.string(),
+            encrypted_content: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("shell_call_output"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            output: import_v417.z.array(
-              import_v417.z.object({
-                stdout: import_v417.z.string(),
-                stderr: import_v417.z.string(),
-                outcome: import_v417.z.discriminatedUnion("type", [
-                  import_v417.z.object({ type: import_v417.z.literal("timeout") }),
-                  import_v417.z.object({
-                    type: import_v417.z.literal("exit"),
-                    exit_code: import_v417.z.number()
+          z17.object({
+            type: z17.literal("shell_call_output"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            output: z17.array(
+              z17.object({
+                stdout: z17.string(),
+                stderr: z17.string(),
+                outcome: z17.discriminatedUnion("type", [
+                  z17.object({ type: z17.literal("timeout") }),
+                  z17.object({
+                    type: z17.literal("exit"),
+                    exit_code: z17.number()
                   })
                 ])
               })
             )
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("tool_search_call"),
-            id: import_v417.z.string(),
-            execution: import_v417.z.enum(["server", "client"]),
-            call_id: import_v417.z.string().nullable(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            arguments: import_v417.z.unknown()
+          z17.object({
+            type: z17.literal("tool_search_call"),
+            id: z17.string(),
+            execution: z17.enum(["server", "client"]),
+            call_id: z17.string().nullable(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z17.unknown()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("tool_search_output"),
-            id: import_v417.z.string(),
-            execution: import_v417.z.enum(["server", "client"]),
-            call_id: import_v417.z.string().nullable(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            tools: import_v417.z.array(import_v417.z.record(import_v417.z.string(), jsonValueSchema.optional()))
+          z17.object({
+            type: z17.literal("tool_search_output"),
+            id: z17.string(),
+            execution: z17.enum(["server", "client"]),
+            call_id: z17.string().nullable(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            tools: z17.array(z17.record(z17.string(), jsonValueSchema.optional()))
           })
         ])
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.function_call_arguments.delta"),
-        item_id: import_v417.z.string(),
-        output_index: import_v417.z.number(),
-        delta: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.function_call_arguments.delta"),
+        item_id: z17.string(),
+        output_index: z17.number(),
+        delta: z17.string()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.custom_tool_call_input.delta"),
-        item_id: import_v417.z.string(),
-        output_index: import_v417.z.number(),
-        delta: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.custom_tool_call_input.delta"),
+        item_id: z17.string(),
+        output_index: z17.number(),
+        delta: z17.string()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.image_generation_call.partial_image"),
-        item_id: import_v417.z.string(),
-        output_index: import_v417.z.number(),
-        partial_image_b64: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.image_generation_call.partial_image"),
+        item_id: z17.string(),
+        output_index: z17.number(),
+        partial_image_b64: z17.string()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.code_interpreter_call_code.delta"),
-        item_id: import_v417.z.string(),
-        output_index: import_v417.z.number(),
-        delta: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.code_interpreter_call_code.delta"),
+        item_id: z17.string(),
+        output_index: z17.number(),
+        delta: z17.string()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.code_interpreter_call_code.done"),
-        item_id: import_v417.z.string(),
-        output_index: import_v417.z.number(),
-        code: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.code_interpreter_call_code.done"),
+        item_id: z17.string(),
+        output_index: z17.number(),
+        code: z17.string()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.output_text.annotation.added"),
-        annotation: import_v417.z.discriminatedUnion("type", [
-          import_v417.z.object({
-            type: import_v417.z.literal("url_citation"),
-            start_index: import_v417.z.number(),
-            end_index: import_v417.z.number(),
-            url: import_v417.z.string(),
-            title: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.output_text.annotation.added"),
+        annotation: z17.discriminatedUnion("type", [
+          z17.object({
+            type: z17.literal("url_citation"),
+            start_index: z17.number(),
+            end_index: z17.number(),
+            url: z17.string(),
+            title: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("file_citation"),
-            file_id: import_v417.z.string(),
-            filename: import_v417.z.string(),
-            index: import_v417.z.number()
+          z17.object({
+            type: z17.literal("file_citation"),
+            file_id: z17.string(),
+            filename: z17.string(),
+            index: z17.number()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("container_file_citation"),
-            container_id: import_v417.z.string(),
-            file_id: import_v417.z.string(),
-            filename: import_v417.z.string(),
-            start_index: import_v417.z.number(),
-            end_index: import_v417.z.number()
+          z17.object({
+            type: z17.literal("container_file_citation"),
+            container_id: z17.string(),
+            file_id: z17.string(),
+            filename: z17.string(),
+            start_index: z17.number(),
+            end_index: z17.number()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("file_path"),
-            file_id: import_v417.z.string(),
-            index: import_v417.z.number()
+          z17.object({
+            type: z17.literal("file_path"),
+            file_id: z17.string(),
+            index: z17.number()
           })
         ])
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.reasoning_summary_part.added"),
-        item_id: import_v417.z.string(),
-        summary_index: import_v417.z.number()
+      z17.object({
+        type: z17.literal("response.reasoning_summary_part.added"),
+        item_id: z17.string(),
+        summary_index: z17.number()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.reasoning_summary_text.delta"),
-        item_id: import_v417.z.string(),
-        summary_index: import_v417.z.number(),
-        delta: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.reasoning_summary_text.delta"),
+        item_id: z17.string(),
+        summary_index: z17.number(),
+        delta: z17.string()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.reasoning_summary_part.done"),
-        item_id: import_v417.z.string(),
-        summary_index: import_v417.z.number()
+      z17.object({
+        type: z17.literal("response.reasoning_summary_part.done"),
+        item_id: z17.string(),
+        summary_index: z17.number()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.apply_patch_call_operation_diff.delta"),
-        item_id: import_v417.z.string(),
-        output_index: import_v417.z.number(),
-        delta: import_v417.z.string(),
-        obfuscation: import_v417.z.string().nullish()
+      z17.object({
+        type: z17.literal("response.apply_patch_call_operation_diff.delta"),
+        item_id: z17.string(),
+        output_index: z17.number(),
+        delta: z17.string(),
+        obfuscation: z17.string().nullish()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("response.apply_patch_call_operation_diff.done"),
-        item_id: import_v417.z.string(),
-        output_index: import_v417.z.number(),
-        diff: import_v417.z.string()
+      z17.object({
+        type: z17.literal("response.apply_patch_call_operation_diff.done"),
+        item_id: z17.string(),
+        output_index: z17.number(),
+        diff: z17.string()
       }),
-      import_v417.z.object({
-        type: import_v417.z.literal("error"),
-        sequence_number: import_v417.z.number(),
-        error: import_v417.z.object({
-          type: import_v417.z.string(),
-          code: import_v417.z.string(),
-          message: import_v417.z.string(),
-          param: import_v417.z.string().nullish()
+      z17.object({
+        type: z17.literal("error"),
+        sequence_number: z17.number(),
+        error: z17.object({
+          type: z17.string(),
+          code: z17.string(),
+          message: z17.string(),
+          param: z17.string().nullish()
         })
       }),
-      import_v417.z.object({ type: import_v417.z.string() }).loose().transform((value) => ({
+      z17.object({ type: z17.string() }).loose().transform((value) => ({
         type: "unknown_chunk",
         message: value.type
       }))
@@ -3810,315 +3844,315 @@ var openaiResponsesChunkSchema = (0, import_provider_utils24.lazySchema)(
     ])
   )
 );
-var openaiResponsesResponseSchema = (0, import_provider_utils24.lazySchema)(
-  () => (0, import_provider_utils24.zodSchema)(
-    import_v417.z.object({
-      id: import_v417.z.string().optional(),
-      created_at: import_v417.z.number().optional(),
-      error: import_v417.z.object({
-        message: import_v417.z.string(),
-        type: import_v417.z.string(),
-        param: import_v417.z.string().nullish(),
-        code: import_v417.z.string()
+var openaiResponsesResponseSchema = lazySchema15(
+  () => zodSchema15(
+    z17.object({
+      id: z17.string().optional(),
+      created_at: z17.number().optional(),
+      error: z17.object({
+        message: z17.string(),
+        type: z17.string(),
+        param: z17.string().nullish(),
+        code: z17.string()
       }).nullish(),
-      model: import_v417.z.string().optional(),
-      output: import_v417.z.array(
-        import_v417.z.discriminatedUnion("type", [
-          import_v417.z.object({
-            type: import_v417.z.literal("message"),
-            role: import_v417.z.literal("assistant"),
-            id: import_v417.z.string(),
-            phase: import_v417.z.enum(["commentary", "final_answer"]).nullish(),
-            content: import_v417.z.array(
-              import_v417.z.object({
-                type: import_v417.z.literal("output_text"),
-                text: import_v417.z.string(),
-                logprobs: import_v417.z.array(
-                  import_v417.z.object({
-                    token: import_v417.z.string(),
-                    logprob: import_v417.z.number(),
-                    top_logprobs: import_v417.z.array(
-                      import_v417.z.object({
-                        token: import_v417.z.string(),
-                        logprob: import_v417.z.number()
+      model: z17.string().optional(),
+      output: z17.array(
+        z17.discriminatedUnion("type", [
+          z17.object({
+            type: z17.literal("message"),
+            role: z17.literal("assistant"),
+            id: z17.string(),
+            phase: z17.enum(["commentary", "final_answer"]).nullish(),
+            content: z17.array(
+              z17.object({
+                type: z17.literal("output_text"),
+                text: z17.string(),
+                logprobs: z17.array(
+                  z17.object({
+                    token: z17.string(),
+                    logprob: z17.number(),
+                    top_logprobs: z17.array(
+                      z17.object({
+                        token: z17.string(),
+                        logprob: z17.number()
                       })
                     )
                   })
                 ).nullish(),
-                annotations: import_v417.z.array(
-                  import_v417.z.discriminatedUnion("type", [
-                    import_v417.z.object({
-                      type: import_v417.z.literal("url_citation"),
-                      start_index: import_v417.z.number(),
-                      end_index: import_v417.z.number(),
-                      url: import_v417.z.string(),
-                      title: import_v417.z.string()
+                annotations: z17.array(
+                  z17.discriminatedUnion("type", [
+                    z17.object({
+                      type: z17.literal("url_citation"),
+                      start_index: z17.number(),
+                      end_index: z17.number(),
+                      url: z17.string(),
+                      title: z17.string()
                     }),
-                    import_v417.z.object({
-                      type: import_v417.z.literal("file_citation"),
-                      file_id: import_v417.z.string(),
-                      filename: import_v417.z.string(),
-                      index: import_v417.z.number()
+                    z17.object({
+                      type: z17.literal("file_citation"),
+                      file_id: z17.string(),
+                      filename: z17.string(),
+                      index: z17.number()
                     }),
-                    import_v417.z.object({
-                      type: import_v417.z.literal("container_file_citation"),
-                      container_id: import_v417.z.string(),
-                      file_id: import_v417.z.string(),
-                      filename: import_v417.z.string(),
-                      start_index: import_v417.z.number(),
-                      end_index: import_v417.z.number()
+                    z17.object({
+                      type: z17.literal("container_file_citation"),
+                      container_id: z17.string(),
+                      file_id: z17.string(),
+                      filename: z17.string(),
+                      start_index: z17.number(),
+                      end_index: z17.number()
                     }),
-                    import_v417.z.object({
-                      type: import_v417.z.literal("file_path"),
-                      file_id: import_v417.z.string(),
-                      index: import_v417.z.number()
+                    z17.object({
+                      type: z17.literal("file_path"),
+                      file_id: z17.string(),
+                      index: z17.number()
                     })
                   ])
                 )
               })
             )
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("web_search_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.string(),
-            action: import_v417.z.discriminatedUnion("type", [
-              import_v417.z.object({
-                type: import_v417.z.literal("search"),
-                query: import_v417.z.string().nullish(),
-                sources: import_v417.z.array(
-                  import_v417.z.discriminatedUnion("type", [
-                    import_v417.z.object({ type: import_v417.z.literal("url"), url: import_v417.z.string() }),
-                    import_v417.z.object({
-                      type: import_v417.z.literal("api"),
-                      name: import_v417.z.string()
+          z17.object({
+            type: z17.literal("web_search_call"),
+            id: z17.string(),
+            status: z17.string(),
+            action: z17.discriminatedUnion("type", [
+              z17.object({
+                type: z17.literal("search"),
+                query: z17.string().nullish(),
+                sources: z17.array(
+                  z17.discriminatedUnion("type", [
+                    z17.object({ type: z17.literal("url"), url: z17.string() }),
+                    z17.object({
+                      type: z17.literal("api"),
+                      name: z17.string()
                     })
                   ])
                 ).nullish()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("open_page"),
-                url: import_v417.z.string().nullish()
+              z17.object({
+                type: z17.literal("open_page"),
+                url: z17.string().nullish()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("find_in_page"),
-                url: import_v417.z.string().nullish(),
-                pattern: import_v417.z.string().nullish()
+              z17.object({
+                type: z17.literal("find_in_page"),
+                url: z17.string().nullish(),
+                pattern: z17.string().nullish()
               })
             ]).nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("file_search_call"),
-            id: import_v417.z.string(),
-            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.union([import_v417.z.string(), import_v417.z.number(), import_v417.z.boolean()])
+          z17.object({
+            type: z17.literal("file_search_call"),
+            id: z17.string(),
+            queries: z17.array(z17.string()),
+            results: z17.array(
+              z17.object({
+                attributes: z17.record(
+                  z17.string(),
+                  z17.union([z17.string(), z17.number(), z17.boolean()])
                 ),
-                file_id: import_v417.z.string(),
-                filename: import_v417.z.string(),
-                score: import_v417.z.number(),
-                text: import_v417.z.string()
+                file_id: z17.string(),
+                filename: z17.string(),
+                score: z17.number(),
+                text: z17.string()
               })
             ).nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("code_interpreter_call"),
-            id: import_v417.z.string(),
-            code: import_v417.z.string().nullable(),
-            container_id: import_v417.z.string(),
-            outputs: import_v417.z.array(
-              import_v417.z.discriminatedUnion("type", [
-                import_v417.z.object({ type: import_v417.z.literal("logs"), logs: import_v417.z.string() }),
-                import_v417.z.object({ type: import_v417.z.literal("image"), url: import_v417.z.string() })
+          z17.object({
+            type: z17.literal("code_interpreter_call"),
+            id: z17.string(),
+            code: z17.string().nullable(),
+            container_id: z17.string(),
+            outputs: z17.array(
+              z17.discriminatedUnion("type", [
+                z17.object({ type: z17.literal("logs"), logs: z17.string() }),
+                z17.object({ type: z17.literal("image"), url: z17.string() })
               ])
             ).nullable()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("image_generation_call"),
-            id: import_v417.z.string(),
-            result: import_v417.z.string()
+          z17.object({
+            type: z17.literal("image_generation_call"),
+            id: z17.string(),
+            result: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("local_shell_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            action: import_v417.z.object({
-              type: import_v417.z.literal("exec"),
-              command: import_v417.z.array(import_v417.z.string()),
-              timeout_ms: import_v417.z.number().optional(),
-              user: import_v417.z.string().optional(),
-              working_directory: import_v417.z.string().optional(),
-              env: import_v417.z.record(import_v417.z.string(), import_v417.z.string()).optional()
+          z17.object({
+            type: z17.literal("local_shell_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            action: z17.object({
+              type: z17.literal("exec"),
+              command: z17.array(z17.string()),
+              timeout_ms: z17.number().optional(),
+              user: z17.string().optional(),
+              working_directory: z17.string().optional(),
+              env: z17.record(z17.string(), z17.string()).optional()
             })
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("function_call"),
-            call_id: import_v417.z.string(),
-            name: import_v417.z.string(),
-            arguments: import_v417.z.string(),
-            id: import_v417.z.string()
+          z17.object({
+            type: z17.literal("function_call"),
+            call_id: z17.string(),
+            name: z17.string(),
+            arguments: z17.string(),
+            id: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("custom_tool_call"),
-            call_id: import_v417.z.string(),
-            name: import_v417.z.string(),
-            input: import_v417.z.string(),
-            id: import_v417.z.string()
+          z17.object({
+            type: z17.literal("custom_tool_call"),
+            call_id: z17.string(),
+            name: z17.string(),
+            input: z17.string(),
+            id: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("computer_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.string().optional()
+          z17.object({
+            type: z17.literal("computer_call"),
+            id: z17.string(),
+            status: z17.string().optional()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("reasoning"),
-            id: import_v417.z.string(),
-            encrypted_content: import_v417.z.string().nullish(),
-            summary: import_v417.z.array(
-              import_v417.z.object({
-                type: import_v417.z.literal("summary_text"),
-                text: import_v417.z.string()
+          z17.object({
+            type: z17.literal("reasoning"),
+            id: z17.string(),
+            encrypted_content: z17.string().nullish(),
+            summary: z17.array(
+              z17.object({
+                type: z17.literal("summary_text"),
+                text: z17.string()
               })
             )
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_call"),
-            id: import_v417.z.string(),
-            status: import_v417.z.string(),
-            arguments: import_v417.z.string(),
-            name: import_v417.z.string(),
-            server_label: import_v417.z.string(),
-            output: import_v417.z.string().nullish(),
-            error: import_v417.z.union([
-              import_v417.z.string(),
-              import_v417.z.object({
-                type: import_v417.z.string().optional(),
-                code: import_v417.z.union([import_v417.z.number(), import_v417.z.string()]).optional(),
-                message: import_v417.z.string().optional()
+          z17.object({
+            type: z17.literal("mcp_call"),
+            id: z17.string(),
+            status: z17.string(),
+            arguments: z17.string(),
+            name: z17.string(),
+            server_label: z17.string(),
+            output: z17.string().nullish(),
+            error: z17.union([
+              z17.string(),
+              z17.object({
+                type: z17.string().optional(),
+                code: z17.union([z17.number(), z17.string()]).optional(),
+                message: z17.string().optional()
               }).loose()
             ]).nullish(),
-            approval_request_id: import_v417.z.string().nullish()
+            approval_request_id: z17.string().nullish()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_list_tools"),
-            id: import_v417.z.string(),
-            server_label: import_v417.z.string(),
-            tools: import_v417.z.array(
-              import_v417.z.object({
-                name: import_v417.z.string(),
-                description: import_v417.z.string().optional(),
-                input_schema: import_v417.z.any(),
-                annotations: import_v417.z.record(import_v417.z.string(), import_v417.z.unknown()).optional()
+          z17.object({
+            type: z17.literal("mcp_list_tools"),
+            id: z17.string(),
+            server_label: z17.string(),
+            tools: z17.array(
+              z17.object({
+                name: z17.string(),
+                description: z17.string().optional(),
+                input_schema: z17.any(),
+                annotations: z17.record(z17.string(), z17.unknown()).optional()
               })
             ),
-            error: import_v417.z.union([
-              import_v417.z.string(),
-              import_v417.z.object({
-                type: import_v417.z.string().optional(),
-                code: import_v417.z.union([import_v417.z.number(), import_v417.z.string()]).optional(),
-                message: import_v417.z.string().optional()
+            error: z17.union([
+              z17.string(),
+              z17.object({
+                type: z17.string().optional(),
+                code: z17.union([z17.number(), z17.string()]).optional(),
+                message: z17.string().optional()
               }).loose()
             ]).optional()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("mcp_approval_request"),
-            id: import_v417.z.string(),
-            server_label: import_v417.z.string(),
-            name: import_v417.z.string(),
-            arguments: import_v417.z.string(),
-            approval_request_id: import_v417.z.string().optional()
+          z17.object({
+            type: z17.literal("mcp_approval_request"),
+            id: z17.string(),
+            server_label: z17.string(),
+            name: z17.string(),
+            arguments: z17.string(),
+            approval_request_id: z17.string().optional()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("apply_patch_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed"]),
-            operation: import_v417.z.discriminatedUnion("type", [
-              import_v417.z.object({
-                type: import_v417.z.literal("create_file"),
-                path: import_v417.z.string(),
-                diff: import_v417.z.string()
+          z17.object({
+            type: z17.literal("apply_patch_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed"]),
+            operation: z17.discriminatedUnion("type", [
+              z17.object({
+                type: z17.literal("create_file"),
+                path: z17.string(),
+                diff: z17.string()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("delete_file"),
-                path: import_v417.z.string()
+              z17.object({
+                type: z17.literal("delete_file"),
+                path: z17.string()
               }),
-              import_v417.z.object({
-                type: import_v417.z.literal("update_file"),
-                path: import_v417.z.string(),
-                diff: import_v417.z.string()
+              z17.object({
+                type: z17.literal("update_file"),
+                path: z17.string(),
+                diff: z17.string()
               })
             ])
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("shell_call"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            action: import_v417.z.object({
-              commands: import_v417.z.array(import_v417.z.string())
+          z17.object({
+            type: z17.literal("shell_call"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            action: z17.object({
+              commands: z17.array(z17.string())
             })
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("compaction"),
-            id: import_v417.z.string(),
-            encrypted_content: import_v417.z.string()
+          z17.object({
+            type: z17.literal("compaction"),
+            id: z17.string(),
+            encrypted_content: z17.string()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("shell_call_output"),
-            id: import_v417.z.string(),
-            call_id: import_v417.z.string(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            output: import_v417.z.array(
-              import_v417.z.object({
-                stdout: import_v417.z.string(),
-                stderr: import_v417.z.string(),
-                outcome: import_v417.z.discriminatedUnion("type", [
-                  import_v417.z.object({ type: import_v417.z.literal("timeout") }),
-                  import_v417.z.object({
-                    type: import_v417.z.literal("exit"),
-                    exit_code: import_v417.z.number()
+          z17.object({
+            type: z17.literal("shell_call_output"),
+            id: z17.string(),
+            call_id: z17.string(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            output: z17.array(
+              z17.object({
+                stdout: z17.string(),
+                stderr: z17.string(),
+                outcome: z17.discriminatedUnion("type", [
+                  z17.object({ type: z17.literal("timeout") }),
+                  z17.object({
+                    type: z17.literal("exit"),
+                    exit_code: z17.number()
                   })
                 ])
               })
             )
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("tool_search_call"),
-            id: import_v417.z.string(),
-            execution: import_v417.z.enum(["server", "client"]),
-            call_id: import_v417.z.string().nullable(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            arguments: import_v417.z.unknown()
+          z17.object({
+            type: z17.literal("tool_search_call"),
+            id: z17.string(),
+            execution: z17.enum(["server", "client"]),
+            call_id: z17.string().nullable(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z17.unknown()
           }),
-          import_v417.z.object({
-            type: import_v417.z.literal("tool_search_output"),
-            id: import_v417.z.string(),
-            execution: import_v417.z.enum(["server", "client"]),
-            call_id: import_v417.z.string().nullable(),
-            status: import_v417.z.enum(["in_progress", "completed", "incomplete"]),
-            tools: import_v417.z.array(import_v417.z.record(import_v417.z.string(), jsonValueSchema.optional()))
+          z17.object({
+            type: z17.literal("tool_search_output"),
+            id: z17.string(),
+            execution: z17.enum(["server", "client"]),
+            call_id: z17.string().nullable(),
+            status: z17.enum(["in_progress", "completed", "incomplete"]),
+            tools: z17.array(z17.record(z17.string(), jsonValueSchema.optional()))
           })
         ])
       ).optional(),
-      service_tier: import_v417.z.string().nullish(),
-      incomplete_details: import_v417.z.object({ reason: import_v417.z.string() }).nullish(),
-      usage: import_v417.z.object({
-        input_tokens: import_v417.z.number(),
-        input_tokens_details: import_v417.z.object({ cached_tokens: import_v417.z.number().nullish() }).nullish(),
-        output_tokens: import_v417.z.number(),
-        output_tokens_details: import_v417.z.object({ reasoning_tokens: import_v417.z.number().nullish() }).nullish()
+      service_tier: z17.string().nullish(),
+      incomplete_details: z17.object({ reason: z17.string() }).nullish(),
+      usage: z17.object({
+        input_tokens: z17.number(),
+        input_tokens_details: z17.object({ cached_tokens: z17.number().nullish() }).nullish(),
+        output_tokens: z17.number(),
+        output_tokens_details: z17.object({ reasoning_tokens: z17.number().nullish() }).nullish()
       }).optional()
     })
   )
 );
 
 // src/responses/openai-responses-options.ts
-var import_provider_utils25 = require("@ai-sdk/provider-utils");
-var import_v418 = require("zod/v4");
+import { lazySchema as lazySchema16, zodSchema as zodSchema16 } from "@ai-sdk/provider-utils";
+import { z as z18 } from "zod/v4";
 var TOP_LOGPROBS_MAX = 20;
 var openaiResponsesReasoningModelIds = [
   "o1",
@@ -4183,9 +4217,9 @@ var openaiResponsesModelIds = [
   "gpt-5-chat-latest",
   ...openaiResponsesReasoningModelIds
 ];
-var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazySchema)(
-  () => (0, import_provider_utils25.zodSchema)(
-    import_v418.z.object({
+var openaiLanguageModelResponsesOptionsSchema = lazySchema16(
+  () => zodSchema16(
+    z18.object({
       /**
        * The ID of the OpenAI Conversation to continue.
        * You must create a conversation first via the OpenAI API.
@@ -4193,13 +4227,13 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
        * Defaults to `undefined`.
        * @see https://platform.openai.com/docs/api-reference/conversations/create
        */
-      conversation: import_v418.z.string().nullish(),
+      conversation: z18.string().nullish(),
       /**
        * The set of extra fields to include in the response (advanced, usually not needed).
        * Example values: 'reasoning.encrypted_content', 'file_search_call.results', 'message.output_text.logprobs'.
        */
-      include: import_v418.z.array(
-        import_v418.z.enum([
+      include: z18.array(
+        z18.enum([
           "reasoning.encrypted_content",
           // handled internally by default, only needed for unknown reasoning models
           "file_search_call.results",
@@ -4211,7 +4245,7 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
        * They can be used to change the system or developer message when continuing a conversation using the `previousResponseId` option.
        * Defaults to `undefined`.
        */
-      instructions: import_v418.z.string().nullish(),
+      instructions: z18.string().nullish(),
       /**
        * Return the log probabilities of the tokens. Including logprobs will increase
        * the response size and can slow down response times. However, it can
@@ -4226,30 +4260,30 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
        * @see https://platform.openai.com/docs/api-reference/responses/create
        * @see https://cookbook.openai.com/examples/using_logprobs
        */
-      logprobs: import_v418.z.union([import_v418.z.boolean(), import_v418.z.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+      logprobs: z18.union([z18.boolean(), z18.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
       /**
        * The maximum number of total calls to built-in tools that can be processed in a response.
        * This maximum number applies across all built-in tool calls, not per individual tool.
        * Any further attempts to call a tool by the model will be ignored.
        */
-      maxToolCalls: import_v418.z.number().nullish(),
+      maxToolCalls: z18.number().nullish(),
       /**
        * Additional metadata to store with the generation.
        */
-      metadata: import_v418.z.any().nullish(),
+      metadata: z18.any().nullish(),
       /**
        * Whether to use parallel tool calls. Defaults to `true`.
        */
-      parallelToolCalls: import_v418.z.boolean().nullish(),
+      parallelToolCalls: z18.boolean().nullish(),
       /**
        * The ID of the previous response. You can use it to continue a conversation.
        * Defaults to `undefined`.
        */
-      previousResponseId: import_v418.z.string().nullish(),
+      previousResponseId: z18.string().nullish(),
       /**
        * Sets a cache key to tie this prompt to cached prefixes for better caching performance.
        */
-      promptCacheKey: import_v418.z.string().nullish(),
+      promptCacheKey: z18.string().nullish(),
       /**
        * The retention policy for the prompt cache.
        * - 'in_memory': Default. Standard prompt caching behavior.
@@ -4258,7 +4292,7 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
        *
        * @default 'in_memory'
        */
-      promptCacheRetention: import_v418.z.enum(["in_memory", "24h"]).nullish(),
+      promptCacheRetention: z18.enum(["in_memory", "24h"]).nullish(),
       /**
        * Reasoning effort for reasoning models. Defaults to `medium`. If you use
        * `providerOptions` to set the `reasoningEffort` option, this model setting will be ignored.
@@ -4269,17 +4303,17 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
        * OpenAI's GPT-5.1-Codex-Max model. Setting `reasoningEffort` to 'none' or 'xhigh' with unsupported models will result in
        * an error.
        */
-      reasoningEffort: import_v418.z.string().nullish(),
+      reasoningEffort: z18.string().nullish(),
       /**
        * Controls reasoning summary output from the model.
        * Set to "auto" to automatically receive the richest level available,
        * or "detailed" for comprehensive summaries.
        */
-      reasoningSummary: import_v418.z.string().nullish(),
+      reasoningSummary: z18.string().nullish(),
       /**
        * The identifier for safety monitoring and tracking.
        */
-      safetyIdentifier: import_v418.z.string().nullish(),
+      safetyIdentifier: z18.string().nullish(),
       /**
        * Service tier for the request.
        * Set to 'flex' for 50% cheaper processing at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
@@ -4287,34 +4321,34 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
        *
        * Defaults to 'auto'.
        */
-      serviceTier: import_v418.z.enum(["auto", "flex", "priority", "default"]).nullish(),
+      serviceTier: z18.enum(["auto", "flex", "priority", "default"]).nullish(),
       /**
        * Whether to store the generation. Defaults to `true`.
        */
-      store: import_v418.z.boolean().nullish(),
+      store: z18.boolean().nullish(),
       /**
        * Whether to use strict JSON schema validation.
        * Defaults to `true`.
        */
-      strictJsonSchema: import_v418.z.boolean().nullish(),
+      strictJsonSchema: z18.boolean().nullish(),
       /**
        * Controls the verbosity of the model's responses. Lower values ('low') will result
        * in more concise responses, while higher values ('high') will result in more verbose responses.
        * Valid values: 'low', 'medium', 'high'.
        */
-      textVerbosity: import_v418.z.enum(["low", "medium", "high"]).nullish(),
+      textVerbosity: z18.enum(["low", "medium", "high"]).nullish(),
       /**
        * Controls output truncation. 'auto' (default) performs truncation automatically;
        * 'disabled' turns truncation off.
        */
-      truncation: import_v418.z.enum(["auto", "disabled"]).nullish(),
+      truncation: z18.enum(["auto", "disabled"]).nullish(),
       /**
        * A unique identifier representing your end-user, which can help OpenAI to
        * monitor and detect abuse.
        * Defaults to `undefined`.
        * @see https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids
        */
-      user: import_v418.z.string().nullish(),
+      user: z18.string().nullish(),
       /**
        * Override the system message mode for this model.
        * - 'system': Use the 'system' role for system messages (default for most models)
@@ -4323,7 +4357,7 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
        *
        * If not specified, the mode is automatically determined based on the model.
        */
-      systemMessageMode: import_v418.z.enum(["system", "developer", "remove"]).optional(),
+      systemMessageMode: z18.enum(["system", "developer", "remove"]).optional(),
       /**
        * Force treating this model as a reasoning model.
        *
@@ -4333,14 +4367,14 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
        * When enabled, the SDK applies reasoning-model parameter compatibility rules
        * and defaults `systemMessageMode` to `developer` unless overridden.
        */
-      forceReasoning: import_v418.z.boolean().optional(),
+      forceReasoning: z18.boolean().optional(),
       /**
        * Enable server-side context management (compaction).
        */
-      contextManagement: import_v418.z.array(
-        import_v418.z.object({
-          type: import_v418.z.literal("compaction"),
-          compactThreshold: import_v418.z.number()
+      contextManagement: z18.array(
+        z18.object({
+          type: z18.literal("compaction"),
+          compactThreshold: z18.number()
         })
       ).nullish()
     })
@@ -4348,45 +4382,54 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils25.lazy
 );
 
 // src/responses/openai-responses-prepare-tools.ts
-var import_provider7 = require("@ai-sdk/provider");
-var import_provider_utils33 = require("@ai-sdk/provider-utils");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
+} from "@ai-sdk/provider";
+import {
+  resolveProviderReference as resolveProviderReference3,
+  validateTypes as validateTypes2
+} from "@ai-sdk/provider-utils";
 
 // src/tool/code-interpreter.ts
-var import_provider_utils26 = require("@ai-sdk/provider-utils");
-var import_v419 = require("zod/v4");
-var codeInterpreterInputSchema = (0, import_provider_utils26.lazySchema)(
-  () => (0, import_provider_utils26.zodSchema)(
-    import_v419.z.object({
-      code: import_v419.z.string().nullish(),
-      containerId: import_v419.z.string()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema5,
+  lazySchema as lazySchema17,
+  zodSchema as zodSchema17
+} from "@ai-sdk/provider-utils";
+import { z as z19 } from "zod/v4";
+var codeInterpreterInputSchema = lazySchema17(
+  () => zodSchema17(
+    z19.object({
+      code: z19.string().nullish(),
+      containerId: z19.string()
     })
   )
 );
-var codeInterpreterOutputSchema = (0, import_provider_utils26.lazySchema)(
-  () => (0, import_provider_utils26.zodSchema)(
-    import_v419.z.object({
-      outputs: import_v419.z.array(
-        import_v419.z.discriminatedUnion("type", [
-          import_v419.z.object({ type: import_v419.z.literal("logs"), logs: import_v419.z.string() }),
-          import_v419.z.object({ type: import_v419.z.literal("image"), url: import_v419.z.string() })
+var codeInterpreterOutputSchema = lazySchema17(
+  () => zodSchema17(
+    z19.object({
+      outputs: z19.array(
+        z19.discriminatedUnion("type", [
+          z19.object({ type: z19.literal("logs"), logs: z19.string() }),
+          z19.object({ type: z19.literal("image"), url: z19.string() })
         ])
       ).nullish()
     })
   )
 );
-var codeInterpreterArgsSchema = (0, import_provider_utils26.lazySchema)(
-  () => (0, import_provider_utils26.zodSchema)(
-    import_v419.z.object({
-      container: import_v419.z.union([
-        import_v419.z.string(),
-        import_v419.z.object({
-          fileIds: import_v419.z.array(import_v419.z.string()).optional()
+var codeInterpreterArgsSchema = lazySchema17(
+  () => zodSchema17(
+    z19.object({
+      container: z19.union([
+        z19.string(),
+        z19.object({
+          fileIds: z19.array(z19.string()).optional()
         })
       ]).optional()
     })
   )
 );
-var codeInterpreterToolFactory = (0, import_provider_utils26.createProviderToolFactoryWithOutputSchema)({
+var codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema5({
   id: "openai.code_interpreter",
   inputSchema: codeInterpreterInputSchema,
   outputSchema: codeInterpreterOutputSchema
@@ -4396,81 +4439,89 @@ var codeInterpreter = (args = {}) => {
 };
 
 // src/tool/file-search.ts
-var import_provider_utils27 = require("@ai-sdk/provider-utils");
-var import_v420 = require("zod/v4");
-var comparisonFilterSchema = import_v420.z.object({
-  key: import_v420.z.string(),
-  type: import_v420.z.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin"]),
-  value: import_v420.z.union([import_v420.z.string(), import_v420.z.number(), import_v420.z.boolean(), import_v420.z.array(import_v420.z.string())])
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema6,
+  lazySchema as lazySchema18,
+  zodSchema as zodSchema18
+} from "@ai-sdk/provider-utils";
+import { z as z20 } from "zod/v4";
+var comparisonFilterSchema = z20.object({
+  key: z20.string(),
+  type: z20.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin"]),
+  value: z20.union([z20.string(), z20.number(), z20.boolean(), z20.array(z20.string())])
 });
-var compoundFilterSchema = import_v420.z.object({
-  type: import_v420.z.enum(["and", "or"]),
-  filters: import_v420.z.array(
-    import_v420.z.union([comparisonFilterSchema, import_v420.z.lazy(() => compoundFilterSchema)])
+var compoundFilterSchema = z20.object({
+  type: z20.enum(["and", "or"]),
+  filters: z20.array(
+    z20.union([comparisonFilterSchema, z20.lazy(() => compoundFilterSchema)])
   )
 });
-var fileSearchArgsSchema = (0, import_provider_utils27.lazySchema)(
-  () => (0, import_provider_utils27.zodSchema)(
-    import_v420.z.object({
-      vectorStoreIds: import_v420.z.array(import_v420.z.string()),
-      maxNumResults: import_v420.z.number().optional(),
-      ranking: import_v420.z.object({
-        ranker: import_v420.z.string().optional(),
-        scoreThreshold: import_v420.z.number().optional()
+var fileSearchArgsSchema = lazySchema18(
+  () => zodSchema18(
+    z20.object({
+      vectorStoreIds: z20.array(z20.string()),
+      maxNumResults: z20.number().optional(),
+      ranking: z20.object({
+        ranker: z20.string().optional(),
+        scoreThreshold: z20.number().optional()
       }).optional(),
-      filters: import_v420.z.union([comparisonFilterSchema, compoundFilterSchema]).optional()
+      filters: z20.union([comparisonFilterSchema, compoundFilterSchema]).optional()
     })
   )
 );
-var fileSearchOutputSchema = (0, import_provider_utils27.lazySchema)(
-  () => (0, import_provider_utils27.zodSchema)(
-    import_v420.z.object({
-      queries: import_v420.z.array(import_v420.z.string()),
-      results: import_v420.z.array(
-        import_v420.z.object({
-          attributes: import_v420.z.record(import_v420.z.string(), import_v420.z.unknown()),
-          fileId: import_v420.z.string(),
-          filename: import_v420.z.string(),
-          score: import_v420.z.number(),
-          text: import_v420.z.string()
+var fileSearchOutputSchema = lazySchema18(
+  () => zodSchema18(
+    z20.object({
+      queries: z20.array(z20.string()),
+      results: z20.array(
+        z20.object({
+          attributes: z20.record(z20.string(), z20.unknown()),
+          fileId: z20.string(),
+          filename: z20.string(),
+          score: z20.number(),
+          text: z20.string()
         })
       ).nullable()
     })
   )
 );
-var fileSearch = (0, import_provider_utils27.createProviderToolFactoryWithOutputSchema)({
+var fileSearch = createProviderToolFactoryWithOutputSchema6({
   id: "openai.file_search",
-  inputSchema: import_v420.z.object({}),
+  inputSchema: z20.object({}),
   outputSchema: fileSearchOutputSchema
 });
 
 // src/tool/image-generation.ts
-var import_provider_utils28 = require("@ai-sdk/provider-utils");
-var import_v421 = require("zod/v4");
-var imageGenerationArgsSchema = (0, import_provider_utils28.lazySchema)(
-  () => (0, import_provider_utils28.zodSchema)(
-    import_v421.z.object({
-      background: import_v421.z.enum(["auto", "opaque", "transparent"]).optional(),
-      inputFidelity: import_v421.z.enum(["low", "high"]).optional(),
-      inputImageMask: import_v421.z.object({
-        fileId: import_v421.z.string().optional(),
-        imageUrl: import_v421.z.string().optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema7,
+  lazySchema as lazySchema19,
+  zodSchema as zodSchema19
+} from "@ai-sdk/provider-utils";
+import { z as z21 } from "zod/v4";
+var imageGenerationArgsSchema = lazySchema19(
+  () => zodSchema19(
+    z21.object({
+      background: z21.enum(["auto", "opaque", "transparent"]).optional(),
+      inputFidelity: z21.enum(["low", "high"]).optional(),
+      inputImageMask: z21.object({
+        fileId: z21.string().optional(),
+        imageUrl: z21.string().optional()
       }).optional(),
-      model: import_v421.z.string().optional(),
-      moderation: import_v421.z.enum(["auto"]).optional(),
-      outputCompression: import_v421.z.number().int().min(0).max(100).optional(),
-      outputFormat: import_v421.z.enum(["png", "jpeg", "webp"]).optional(),
-      partialImages: import_v421.z.number().int().min(0).max(3).optional(),
-      quality: import_v421.z.enum(["auto", "low", "medium", "high"]).optional(),
-      size: import_v421.z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+      model: z21.string().optional(),
+      moderation: z21.enum(["auto"]).optional(),
+      outputCompression: z21.number().int().min(0).max(100).optional(),
+      outputFormat: z21.enum(["png", "jpeg", "webp"]).optional(),
+      partialImages: z21.number().int().min(0).max(3).optional(),
+      quality: z21.enum(["auto", "low", "medium", "high"]).optional(),
+      size: z21.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
     }).strict()
   )
 );
-var imageGenerationInputSchema = (0, import_provider_utils28.lazySchema)(() => (0, import_provider_utils28.zodSchema)(import_v421.z.object({})));
-var imageGenerationOutputSchema = (0, import_provider_utils28.lazySchema)(
-  () => (0, import_provider_utils28.zodSchema)(import_v421.z.object({ result: import_v421.z.string() }))
+var imageGenerationInputSchema = lazySchema19(() => zodSchema19(z21.object({})));
+var imageGenerationOutputSchema = lazySchema19(
+  () => zodSchema19(z21.object({ result: z21.string() }))
 );
-var imageGenerationToolFactory = (0, import_provider_utils28.createProviderToolFactoryWithOutputSchema)({
+var imageGenerationToolFactory = createProviderToolFactoryWithOutputSchema7({
   id: "openai.image_generation",
   inputSchema: imageGenerationInputSchema,
   outputSchema: imageGenerationOutputSchema
@@ -4480,188 +4531,204 @@ var imageGeneration = (args = {}) => {
 };
 
 // src/tool/custom.ts
-var import_provider_utils29 = require("@ai-sdk/provider-utils");
-var import_v422 = require("zod/v4");
-var customArgsSchema = (0, import_provider_utils29.lazySchema)(
-  () => (0, import_provider_utils29.zodSchema)(
-    import_v422.z.object({
-      description: import_v422.z.string().optional(),
-      format: import_v422.z.union([
-        import_v422.z.object({
-          type: import_v422.z.literal("grammar"),
-          syntax: import_v422.z.enum(["regex", "lark"]),
-          definition: import_v422.z.string()
+import {
+  createProviderToolFactory,
+  lazySchema as lazySchema20,
+  zodSchema as zodSchema20
+} from "@ai-sdk/provider-utils";
+import { z as z22 } from "zod/v4";
+var customArgsSchema = lazySchema20(
+  () => zodSchema20(
+    z22.object({
+      description: z22.string().optional(),
+      format: z22.union([
+        z22.object({
+          type: z22.literal("grammar"),
+          syntax: z22.enum(["regex", "lark"]),
+          definition: z22.string()
         }),
-        import_v422.z.object({
-          type: import_v422.z.literal("text")
+        z22.object({
+          type: z22.literal("text")
         })
       ]).optional()
     })
   )
 );
-var customInputSchema = (0, import_provider_utils29.lazySchema)(() => (0, import_provider_utils29.zodSchema)(import_v422.z.string()));
-var customToolFactory = (0, import_provider_utils29.createProviderToolFactory)({
+var customInputSchema = lazySchema20(() => zodSchema20(z22.string()));
+var customToolFactory = createProviderToolFactory({
   id: "openai.custom",
   inputSchema: customInputSchema
 });
 
 // src/tool/mcp.ts
-var import_provider_utils30 = require("@ai-sdk/provider-utils");
-var import_v423 = require("zod/v4");
-var jsonValueSchema2 = import_v423.z.lazy(
-  () => import_v423.z.union([
-    import_v423.z.string(),
-    import_v423.z.number(),
-    import_v423.z.boolean(),
-    import_v423.z.null(),
-    import_v423.z.array(jsonValueSchema2),
-    import_v423.z.record(import_v423.z.string(), jsonValueSchema2)
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema8,
+  lazySchema as lazySchema21,
+  zodSchema as zodSchema21
+} from "@ai-sdk/provider-utils";
+import { z as z23 } from "zod/v4";
+var jsonValueSchema2 = z23.lazy(
+  () => z23.union([
+    z23.string(),
+    z23.number(),
+    z23.boolean(),
+    z23.null(),
+    z23.array(jsonValueSchema2),
+    z23.record(z23.string(), jsonValueSchema2)
   ])
 );
-var mcpArgsSchema = (0, import_provider_utils30.lazySchema)(
-  () => (0, import_provider_utils30.zodSchema)(
-    import_v423.z.object({
-      serverLabel: import_v423.z.string(),
-      allowedTools: import_v423.z.union([
-        import_v423.z.array(import_v423.z.string()),
-        import_v423.z.object({
-          readOnly: import_v423.z.boolean().optional(),
-          toolNames: import_v423.z.array(import_v423.z.string()).optional()
+var mcpArgsSchema = lazySchema21(
+  () => zodSchema21(
+    z23.object({
+      serverLabel: z23.string(),
+      allowedTools: z23.union([
+        z23.array(z23.string()),
+        z23.object({
+          readOnly: z23.boolean().optional(),
+          toolNames: z23.array(z23.string()).optional()
         })
       ]).optional(),
-      authorization: import_v423.z.string().optional(),
-      connectorId: import_v423.z.string().optional(),
-      headers: import_v423.z.record(import_v423.z.string(), import_v423.z.string()).optional(),
-      requireApproval: import_v423.z.union([
-        import_v423.z.enum(["always", "never"]),
-        import_v423.z.object({
-          never: import_v423.z.object({
-            toolNames: import_v423.z.array(import_v423.z.string()).optional()
+      authorization: z23.string().optional(),
+      connectorId: z23.string().optional(),
+      headers: z23.record(z23.string(), z23.string()).optional(),
+      requireApproval: z23.union([
+        z23.enum(["always", "never"]),
+        z23.object({
+          never: z23.object({
+            toolNames: z23.array(z23.string()).optional()
           }).optional()
         })
       ]).optional(),
-      serverDescription: import_v423.z.string().optional(),
-      serverUrl: import_v423.z.string().optional()
+      serverDescription: z23.string().optional(),
+      serverUrl: z23.string().optional()
     }).refine(
       (v) => v.serverUrl != null || v.connectorId != null,
       "One of serverUrl or connectorId must be provided."
     )
   )
 );
-var mcpInputSchema = (0, import_provider_utils30.lazySchema)(() => (0, import_provider_utils30.zodSchema)(import_v423.z.object({})));
-var mcpOutputSchema = (0, import_provider_utils30.lazySchema)(
-  () => (0, import_provider_utils30.zodSchema)(
-    import_v423.z.object({
-      type: import_v423.z.literal("call"),
-      serverLabel: import_v423.z.string(),
-      name: import_v423.z.string(),
-      arguments: import_v423.z.string(),
-      output: import_v423.z.string().nullish(),
-      error: import_v423.z.union([import_v423.z.string(), jsonValueSchema2]).optional()
+var mcpInputSchema = lazySchema21(() => zodSchema21(z23.object({})));
+var mcpOutputSchema = lazySchema21(
+  () => zodSchema21(
+    z23.object({
+      type: z23.literal("call"),
+      serverLabel: z23.string(),
+      name: z23.string(),
+      arguments: z23.string(),
+      output: z23.string().nullish(),
+      error: z23.union([z23.string(), jsonValueSchema2]).optional()
     })
   )
 );
-var mcpToolFactory = (0, import_provider_utils30.createProviderToolFactoryWithOutputSchema)({
+var mcpToolFactory = createProviderToolFactoryWithOutputSchema8({
   id: "openai.mcp",
   inputSchema: mcpInputSchema,
   outputSchema: mcpOutputSchema
 });
 
 // src/tool/web-search.ts
-var import_provider_utils31 = require("@ai-sdk/provider-utils");
-var import_v424 = require("zod/v4");
-var webSearchArgsSchema = (0, import_provider_utils31.lazySchema)(
-  () => (0, import_provider_utils31.zodSchema)(
-    import_v424.z.object({
-      externalWebAccess: import_v424.z.boolean().optional(),
-      filters: import_v424.z.object({ allowedDomains: import_v424.z.array(import_v424.z.string()).optional() }).optional(),
-      searchContextSize: import_v424.z.enum(["low", "medium", "high"]).optional(),
-      userLocation: import_v424.z.object({
-        type: import_v424.z.literal("approximate"),
-        country: import_v424.z.string().optional(),
-        city: import_v424.z.string().optional(),
-        region: import_v424.z.string().optional(),
-        timezone: import_v424.z.string().optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema9,
+  lazySchema as lazySchema22,
+  zodSchema as zodSchema22
+} from "@ai-sdk/provider-utils";
+import { z as z24 } from "zod/v4";
+var webSearchArgsSchema = lazySchema22(
+  () => zodSchema22(
+    z24.object({
+      externalWebAccess: z24.boolean().optional(),
+      filters: z24.object({ allowedDomains: z24.array(z24.string()).optional() }).optional(),
+      searchContextSize: z24.enum(["low", "medium", "high"]).optional(),
+      userLocation: z24.object({
+        type: z24.literal("approximate"),
+        country: z24.string().optional(),
+        city: z24.string().optional(),
+        region: z24.string().optional(),
+        timezone: z24.string().optional()
       }).optional()
     })
   )
 );
-var webSearchInputSchema = (0, import_provider_utils31.lazySchema)(() => (0, import_provider_utils31.zodSchema)(import_v424.z.object({})));
-var webSearchOutputSchema = (0, import_provider_utils31.lazySchema)(
-  () => (0, import_provider_utils31.zodSchema)(
-    import_v424.z.object({
-      action: import_v424.z.discriminatedUnion("type", [
-        import_v424.z.object({
-          type: import_v424.z.literal("search"),
-          query: import_v424.z.string().optional()
+var webSearchInputSchema = lazySchema22(() => zodSchema22(z24.object({})));
+var webSearchOutputSchema = lazySchema22(
+  () => zodSchema22(
+    z24.object({
+      action: z24.discriminatedUnion("type", [
+        z24.object({
+          type: z24.literal("search"),
+          query: z24.string().optional()
         }),
-        import_v424.z.object({
-          type: import_v424.z.literal("openPage"),
-          url: import_v424.z.string().nullish()
+        z24.object({
+          type: z24.literal("openPage"),
+          url: z24.string().nullish()
         }),
-        import_v424.z.object({
-          type: import_v424.z.literal("findInPage"),
-          url: import_v424.z.string().nullish(),
-          pattern: import_v424.z.string().nullish()
+        z24.object({
+          type: z24.literal("findInPage"),
+          url: z24.string().nullish(),
+          pattern: z24.string().nullish()
         })
       ]).optional(),
-      sources: import_v424.z.array(
-        import_v424.z.discriminatedUnion("type", [
-          import_v424.z.object({ type: import_v424.z.literal("url"), url: import_v424.z.string() }),
-          import_v424.z.object({ type: import_v424.z.literal("api"), name: import_v424.z.string() })
+      sources: z24.array(
+        z24.discriminatedUnion("type", [
+          z24.object({ type: z24.literal("url"), url: z24.string() }),
+          z24.object({ type: z24.literal("api"), name: z24.string() })
         ])
       ).optional()
     })
   )
 );
-var webSearchToolFactory = (0, import_provider_utils31.createProviderToolFactoryWithOutputSchema)({
+var webSearchToolFactory = createProviderToolFactoryWithOutputSchema9({
   id: "openai.web_search",
   inputSchema: webSearchInputSchema,
   outputSchema: webSearchOutputSchema
 });
 
 // src/tool/web-search-preview.ts
-var import_provider_utils32 = require("@ai-sdk/provider-utils");
-var import_v425 = require("zod/v4");
-var webSearchPreviewArgsSchema = (0, import_provider_utils32.lazySchema)(
-  () => (0, import_provider_utils32.zodSchema)(
-    import_v425.z.object({
-      searchContextSize: import_v425.z.enum(["low", "medium", "high"]).optional(),
-      userLocation: import_v425.z.object({
-        type: import_v425.z.literal("approximate"),
-        country: import_v425.z.string().optional(),
-        city: import_v425.z.string().optional(),
-        region: import_v425.z.string().optional(),
-        timezone: import_v425.z.string().optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema10,
+  lazySchema as lazySchema23,
+  zodSchema as zodSchema23
+} from "@ai-sdk/provider-utils";
+import { z as z25 } from "zod/v4";
+var webSearchPreviewArgsSchema = lazySchema23(
+  () => zodSchema23(
+    z25.object({
+      searchContextSize: z25.enum(["low", "medium", "high"]).optional(),
+      userLocation: z25.object({
+        type: z25.literal("approximate"),
+        country: z25.string().optional(),
+        city: z25.string().optional(),
+        region: z25.string().optional(),
+        timezone: z25.string().optional()
       }).optional()
     })
   )
 );
-var webSearchPreviewInputSchema = (0, import_provider_utils32.lazySchema)(
-  () => (0, import_provider_utils32.zodSchema)(import_v425.z.object({}))
+var webSearchPreviewInputSchema = lazySchema23(
+  () => zodSchema23(z25.object({}))
 );
-var webSearchPreviewOutputSchema = (0, import_provider_utils32.lazySchema)(
-  () => (0, import_provider_utils32.zodSchema)(
-    import_v425.z.object({
-      action: import_v425.z.discriminatedUnion("type", [
-        import_v425.z.object({
-          type: import_v425.z.literal("search"),
-          query: import_v425.z.string().optional()
+var webSearchPreviewOutputSchema = lazySchema23(
+  () => zodSchema23(
+    z25.object({
+      action: z25.discriminatedUnion("type", [
+        z25.object({
+          type: z25.literal("search"),
+          query: z25.string().optional()
         }),
-        import_v425.z.object({
-          type: import_v425.z.literal("openPage"),
-          url: import_v425.z.string().nullish()
+        z25.object({
+          type: z25.literal("openPage"),
+          url: z25.string().nullish()
         }),
-        import_v425.z.object({
-          type: import_v425.z.literal("findInPage"),
-          url: import_v425.z.string().nullish(),
-          pattern: import_v425.z.string().nullish()
+        z25.object({
+          type: z25.literal("findInPage"),
+          url: z25.string().nullish(),
+          pattern: z25.string().nullish()
         })
       ]).optional()
     })
   )
 );
-var webSearchPreview = (0, import_provider_utils32.createProviderToolFactoryWithOutputSchema)({
+var webSearchPreview = createProviderToolFactoryWithOutputSchema10({
   id: "openai.web_search_preview",
   inputSchema: webSearchPreviewInputSchema,
   outputSchema: webSearchPreviewOutputSchema
@@ -4700,7 +4767,7 @@ async function prepareResponsesTools({
       case "provider": {
         switch (tool.id) {
           case "openai.file_search": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: fileSearchArgsSchema
             });
@@ -4723,7 +4790,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.shell": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: shellArgsSchema
             });
@@ -4742,7 +4809,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.web_search_preview": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: webSearchPreviewArgsSchema
             });
@@ -4754,7 +4821,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.web_search": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: webSearchArgsSchema
             });
@@ -4768,7 +4835,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.code_interpreter": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: codeInterpreterArgsSchema
             });
@@ -4779,7 +4846,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.image_generation": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: imageGenerationArgsSchema
             });
@@ -4802,7 +4869,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.mcp": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: mcpArgsSchema
             });
@@ -4828,7 +4895,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.custom": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: customArgsSchema
             });
@@ -4842,7 +4909,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.tool_search": {
-            const args = await (0, import_provider_utils33.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: toolSearchArgsSchema
             });
@@ -4884,7 +4951,7 @@ async function prepareResponsesTools({
     }
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider7.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError5({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -4924,7 +4991,7 @@ function mapShellSkills(skills) {
       var _a, _b;
       return skill.type === "skillReference" ? {
         type: "skill_reference",
-        skill_id: (0, import_provider_utils33.resolveProviderReference)({
+        skill_id: resolveProviderReference3({
           reference: (_a = skill.providerReference) != null ? _a : {},
           provider: "openai"
         }),
@@ -5007,19 +5074,19 @@ var OpenAIResponsesLanguageModel = class {
       warnings.push({ type: "unsupported", feature: "stopSequences" });
     }
     const providerOptionsName = this.config.provider.includes("azure") ? "azure" : "openai";
-    let openaiOptions = await (0, import_provider_utils34.parseProviderOptions)({
+    let openaiOptions = await parseProviderOptions7({
       provider: providerOptionsName,
       providerOptions,
       schema: openaiLanguageModelResponsesOptionsSchema
     });
     if (openaiOptions == null && providerOptionsName !== "openai") {
-      openaiOptions = await (0, import_provider_utils34.parseProviderOptions)({
+      openaiOptions = await parseProviderOptions7({
         provider: "openai",
         providerOptions,
         schema: openaiLanguageModelResponsesOptionsSchema
       });
     }
-    const resolvedReasoningEffort = (_a = openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null ? _a : (0, import_provider_utils34.isCustomReasoning)(reasoning) ? reasoning : void 0;
+    const resolvedReasoningEffort = (_a = openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null ? _a : isCustomReasoning2(reasoning) ? reasoning : void 0;
     const isReasoningModel = (_b = openaiOptions == null ? void 0 : openaiOptions.forceReasoning) != null ? _b : modelCapabilities.isReasoningModel;
     if ((openaiOptions == null ? void 0 : openaiOptions.conversation) && (openaiOptions == null ? void 0 : openaiOptions.previousResponseId)) {
       warnings.push({
@@ -5028,7 +5095,7 @@ var OpenAIResponsesLanguageModel = class {
         details: "conversation and previousResponseId cannot be used together"
       });
     }
-    const toolNameMapping = (0, import_provider_utils34.createToolNameMapping)({
+    const toolNameMapping = createToolNameMapping({
       tools,
       providerToolNames: {
         "openai.code_interpreter": "code_interpreter",
@@ -5242,19 +5309,19 @@ var OpenAIResponsesLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils34.postJsonToApi)({
+    } = await postJsonToApi6({
       url,
-      headers: (0, import_provider_utils34.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders7(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils34.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler6(
         openaiResponsesResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     if (response.error) {
-      throw new import_provider8.APICallError({
+      throw new APICallError({
         message: response.error.message,
         url,
         requestBodyValues: body,
@@ -5423,7 +5490,7 @@ var OpenAIResponsesLanguageModel = class {
                 content.push({
                   type: "source",
                   sourceType: "url",
-                  id: (_i = (_h = (_g = this.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : (0, import_provider_utils34.generateId)(),
+                  id: (_i = (_h = (_g = this.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : generateId2(),
                   url: annotation.url,
                   title: annotation.title
                 });
@@ -5431,7 +5498,7 @@ var OpenAIResponsesLanguageModel = class {
                 content.push({
                   type: "source",
                   sourceType: "document",
-                  id: (_l = (_k = (_j = this.config).generateId) == null ? void 0 : _k.call(_j)) != null ? _l : (0, import_provider_utils34.generateId)(),
+                  id: (_l = (_k = (_j = this.config).generateId) == null ? void 0 : _k.call(_j)) != null ? _l : generateId2(),
                   mediaType: "text/plain",
                   title: annotation.filename,
                   filename: annotation.filename,
@@ -5447,7 +5514,7 @@ var OpenAIResponsesLanguageModel = class {
                 content.push({
                   type: "source",
                   sourceType: "document",
-                  id: (_o = (_n = (_m = this.config).generateId) == null ? void 0 : _n.call(_m)) != null ? _o : (0, import_provider_utils34.generateId)(),
+                  id: (_o = (_n = (_m = this.config).generateId) == null ? void 0 : _n.call(_m)) != null ? _o : generateId2(),
                   mediaType: "text/plain",
                   title: annotation.filename,
                   filename: annotation.filename,
@@ -5463,7 +5530,7 @@ var OpenAIResponsesLanguageModel = class {
                 content.push({
                   type: "source",
                   sourceType: "document",
-                  id: (_r = (_q = (_p = this.config).generateId) == null ? void 0 : _q.call(_p)) != null ? _r : (0, import_provider_utils34.generateId)(),
+                  id: (_r = (_q = (_p = this.config).generateId) == null ? void 0 : _q.call(_p)) != null ? _r : generateId2(),
                   mediaType: "application/octet-stream",
                   title: annotation.file_id,
                   filename: annotation.file_id,
@@ -5567,7 +5634,7 @@ var OpenAIResponsesLanguageModel = class {
         }
         case "mcp_approval_request": {
           const approvalRequestId = (_t = part.approval_request_id) != null ? _t : part.id;
-          const dummyToolCallId = (_w = (_v = (_u = this.config).generateId) == null ? void 0 : _v.call(_u)) != null ? _w : (0, import_provider_utils34.generateId)();
+          const dummyToolCallId = (_w = (_v = (_u = this.config).generateId) == null ? void 0 : _v.call(_u)) != null ? _w : generateId2();
           const toolName = `mcp.${part.name}`;
           content.push({
             type: "tool-call",
@@ -5722,18 +5789,18 @@ var OpenAIResponsesLanguageModel = class {
       providerOptionsName,
       isShellProviderExecuted
     } = await this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils34.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi6({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils34.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders7(this.config.headers(), options.headers),
       body: {
         ...body,
         stream: true
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils34.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler3(
         openaiResponsesChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -6213,7 +6280,7 @@ var OpenAIResponsesLanguageModel = class {
                 ongoingToolCalls[value.output_index] = void 0;
               } else if (value.item.type === "mcp_approval_request") {
                 ongoingToolCalls[value.output_index] = void 0;
-                const dummyToolCallId = (_o = (_n = (_m = self.config).generateId) == null ? void 0 : _n.call(_m)) != null ? _o : (0, import_provider_utils34.generateId)();
+                const dummyToolCallId = (_o = (_n = (_m = self.config).generateId) == null ? void 0 : _n.call(_m)) != null ? _o : generateId2();
                 const approvalRequestId = (_p = value.item.approval_request_id) != null ? _p : value.item.id;
                 approvalRequestIdToDummyToolCallIdFromStream.set(
                   approvalRequestId,
@@ -6516,7 +6583,7 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "url",
-                  id: (_C = (_B = (_A = self.config).generateId) == null ? void 0 : _B.call(_A)) != null ? _C : (0, import_provider_utils34.generateId)(),
+                  id: (_C = (_B = (_A = self.config).generateId) == null ? void 0 : _B.call(_A)) != null ? _C : generateId2(),
                   url: value.annotation.url,
                   title: value.annotation.title
                 });
@@ -6524,7 +6591,7 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "document",
-                  id: (_F = (_E = (_D = self.config).generateId) == null ? void 0 : _E.call(_D)) != null ? _F : (0, import_provider_utils34.generateId)(),
+                  id: (_F = (_E = (_D = self.config).generateId) == null ? void 0 : _E.call(_D)) != null ? _F : generateId2(),
                   mediaType: "text/plain",
                   title: value.annotation.filename,
                   filename: value.annotation.filename,
@@ -6540,7 +6607,7 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "document",
-                  id: (_I = (_H = (_G = self.config).generateId) == null ? void 0 : _H.call(_G)) != null ? _I : (0, import_provider_utils34.generateId)(),
+                  id: (_I = (_H = (_G = self.config).generateId) == null ? void 0 : _H.call(_G)) != null ? _I : generateId2(),
                   mediaType: "text/plain",
                   title: value.annotation.filename,
                   filename: value.annotation.filename,
@@ -6556,7 +6623,7 @@ var OpenAIResponsesLanguageModel = class {
                 controller.enqueue({
                   type: "source",
                   sourceType: "document",
-                  id: (_L = (_K = (_J = self.config).generateId) == null ? void 0 : _K.call(_J)) != null ? _L : (0, import_provider_utils34.generateId)(),
+                  id: (_L = (_K = (_J = self.config).generateId) == null ? void 0 : _K.call(_J)) != null ? _L : generateId2(),
                   mediaType: "application/octet-stream",
                   title: value.annotation.file_id,
                   filename: value.annotation.file_id,
@@ -6667,8 +6734,7 @@ function mapWebSearchOutput(action) {
 function escapeJSONDelta(delta) {
   return JSON.stringify(delta).slice(1, -1);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   OpenAIChatLanguageModel,
   OpenAICompletionLanguageModel,
   OpenAIEmbeddingModel,
@@ -6702,5 +6768,5 @@ function escapeJSONDelta(delta) {
   webSearchPreview,
   webSearchPreviewArgsSchema,
   webSearchPreviewInputSchema
-});
+};
 //# sourceMappingURL=index.js.map