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

package/dist/index.js

@@ -1,53 +1,41 @@
-"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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VERSION: () => VERSION,
-  createOpenAI: () => createOpenAI,
-  openai: () => openai
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/openai-provider.ts
-var import_provider_utils40 = require("@ai-sdk/provider-utils");
+import {
+  loadApiKey,
+  loadOptionalSetting,
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // 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
 });
@@ -108,8 +96,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"
@@ -159,11 +153,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"
                       })
@@ -175,13 +169,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"
                     });
                   }
@@ -190,7 +184,7 @@ function convertToOpenAIChatMessages({
                       return {
                         type: "input_audio",
                         input_audio: {
-                          data: (0, import_provider_utils2.convertToBase64)(part.data),
+                          data: convertToBase64(part.data),
                           format: "wav"
                         }
                       };
@@ -200,20 +194,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"
                     });
                   }
@@ -221,11 +215,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}`
                   });
                 }
@@ -333,139 +327,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()
       }),
@@ -475,18 +469,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.
        *
@@ -496,36 +490,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
@@ -536,23 +530,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.
@@ -561,7 +555,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
@@ -569,7 +563,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)
@@ -578,7 +572,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.
        *
@@ -588,13 +582,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
@@ -648,7 +644,7 @@ function prepareChatTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -686,13 +682,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" });
@@ -858,15 +854,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,
@@ -881,7 +877,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
       });
@@ -890,7 +886,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
       });
@@ -932,15 +928,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,
@@ -1026,19 +1022,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.`
                     });
@@ -1066,14 +1062,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
                       });
@@ -1094,14 +1090,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
                   });
@@ -1114,7 +1110,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
                 });
@@ -1141,7 +1137,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) {
@@ -1181,7 +1183,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",
@@ -1197,7 +1202,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
         });
@@ -1223,7 +1228,7 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new import_provider4.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError3({
                 functionality: "tool-call messages"
               });
             }
@@ -1236,7 +1241,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new import_provider4.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError3({
           functionality: "tool messages"
         });
       }
@@ -1286,56 +1291,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
@@ -1344,15 +1349,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.
        *
@@ -1367,16 +1372,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
@@ -1386,7 +1391,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()
     })
   )
 );
@@ -1424,12 +1429,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
@@ -1485,15 +1490,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,
@@ -1530,15 +1535,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,
@@ -1621,37 +1626,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()
     })
   )
 );
@@ -1676,14 +1688,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
@@ -1692,12 +1704,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,
@@ -1706,7 +1718,7 @@ var OpenAIEmbeddingModel = class {
         user: openaiOptions.user
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils11.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         openaiTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -1722,39 +1734,45 @@ var OpenAIEmbeddingModel = class {
 };
 
 // src/files/openai-files.ts
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders4,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  parseProviderOptions as parseProviderOptions4,
+  postFormDataToApi
+} from "@ai-sdk/provider-utils";
 
 // src/files/openai-files-api.ts
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
-var openaiFilesResponseSchema = (0, import_provider_utils12.lazySchema)(
-  () => (0, import_provider_utils12.zodSchema)(
-    import_v48.z.object({
-      id: import_v48.z.string(),
-      object: import_v48.z.string().nullish(),
-      bytes: import_v48.z.number().nullish(),
-      created_at: import_v48.z.number().nullish(),
-      filename: import_v48.z.string().nullish(),
-      purpose: import_v48.z.string().nullish(),
-      status: import_v48.z.string().nullish(),
-      expires_at: import_v48.z.number().nullish()
+import { lazySchema as lazySchema7, zodSchema as zodSchema7 } from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var openaiFilesResponseSchema = lazySchema7(
+  () => zodSchema7(
+    z8.object({
+      id: z8.string(),
+      object: z8.string().nullish(),
+      bytes: z8.number().nullish(),
+      created_at: z8.number().nullish(),
+      filename: z8.string().nullish(),
+      purpose: z8.string().nullish(),
+      status: z8.string().nullish(),
+      expires_at: z8.number().nullish()
     })
   )
 );
 
 // src/files/openai-files-options.ts
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
-var import_v49 = require("zod/v4");
-var openaiFilesOptionsSchema = (0, import_provider_utils13.lazySchema)(
-  () => (0, import_provider_utils13.zodSchema)(
-    import_v49.z.object({
+import { lazySchema as lazySchema8, zodSchema as zodSchema8 } from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+var openaiFilesOptionsSchema = lazySchema8(
+  () => zodSchema8(
+    z9.object({
       /*
        * Required by the OpenAI API, but optional here because
        * the SDK defaults to "assistants" — by far the most common
        * purpose when uploading files in this context.
        */
-      purpose: import_v49.z.string().optional(),
-      expiresAfter: import_v49.z.number().optional()
+      purpose: z9.string().optional(),
+      expiresAfter: z9.number().optional()
     })
   )
 );
@@ -1775,12 +1793,12 @@ var OpenAIFiles = class {
     providerOptions
   }) {
     var _a, _b, _c;
-    const openaiOptions = await (0, import_provider_utils14.parseProviderOptions)({
+    const openaiOptions = await parseProviderOptions4({
       provider: "openai",
       providerOptions,
       schema: openaiFilesOptionsSchema
     });
-    const fileBytes = data instanceof Uint8Array ? data : (0, import_provider_utils14.convertBase64ToUint8Array)(data);
+    const fileBytes = data instanceof Uint8Array ? data : convertBase64ToUint8Array(data);
     const blob = new Blob([fileBytes], {
       type: mediaType
     });
@@ -1794,12 +1812,12 @@ var OpenAIFiles = class {
     if ((openaiOptions == null ? void 0 : openaiOptions.expiresAfter) != null) {
       formData.append("expires_after", String(openaiOptions.expiresAfter));
     }
-    const { value: response } = await (0, import_provider_utils14.postFormDataToApi)({
+    const { value: response } = await postFormDataToApi({
       url: `${this.config.baseURL}/files`,
-      headers: (0, import_provider_utils14.combineHeaders)(this.config.headers()),
+      headers: combineHeaders4(this.config.headers()),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils14.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler4(
         openaiFilesResponseSchema
       ),
       fetch: this.config.fetch
@@ -1824,32 +1842,40 @@ var OpenAIFiles = class {
 };
 
 // src/image/openai-image-model.ts
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders5,
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertToFormData,
+  createJsonResponseHandler as createJsonResponseHandler5,
+  downloadBlob,
+  postFormDataToApi as postFormDataToApi2,
+  postJsonToApi as postJsonToApi4
+} from "@ai-sdk/provider-utils";
 
 // src/image/openai-image-api.ts
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
-var import_v410 = require("zod/v4");
-var openaiImageResponseSchema = (0, import_provider_utils15.lazySchema)(
-  () => (0, import_provider_utils15.zodSchema)(
-    import_v410.z.object({
-      created: import_v410.z.number().nullish(),
-      data: import_v410.z.array(
-        import_v410.z.object({
-          b64_json: import_v410.z.string(),
-          revised_prompt: import_v410.z.string().nullish()
+import { lazySchema as lazySchema9, zodSchema as zodSchema9 } from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod/v4";
+var openaiImageResponseSchema = lazySchema9(
+  () => zodSchema9(
+    z10.object({
+      created: z10.number().nullish(),
+      data: z10.array(
+        z10.object({
+          b64_json: z10.string(),
+          revised_prompt: z10.string().nullish()
         })
       ),
-      background: import_v410.z.string().nullish(),
-      output_format: import_v410.z.string().nullish(),
-      size: import_v410.z.string().nullish(),
-      quality: import_v410.z.string().nullish(),
-      usage: import_v410.z.object({
-        input_tokens: import_v410.z.number().nullish(),
-        output_tokens: import_v410.z.number().nullish(),
-        total_tokens: import_v410.z.number().nullish(),
-        input_tokens_details: import_v410.z.object({
-          image_tokens: import_v410.z.number().nullish(),
-          text_tokens: import_v410.z.number().nullish()
+      background: z10.string().nullish(),
+      output_format: z10.string().nullish(),
+      size: z10.string().nullish(),
+      quality: z10.string().nullish(),
+      usage: z10.object({
+        input_tokens: z10.number().nullish(),
+        output_tokens: z10.number().nullish(),
+        total_tokens: z10.number().nullish(),
+        input_tokens_details: z10.object({
+          image_tokens: z10.number().nullish(),
+          text_tokens: z10.number().nullish()
         }).nullish()
       }).nullish()
     })
@@ -1917,13 +1943,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_utils16.postFormDataToApi)({
+      const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi2({
         url: this.config.url({
           path: "/images/edits",
           modelId: this.modelId
         }),
-        headers: (0, import_provider_utils16.combineHeaders)(this.config.headers(), headers),
-        formData: (0, import_provider_utils16.convertToFormData)({
+        headers: combineHeaders5(this.config.headers(), headers),
+        formData: convertToFormData({
           model: this.modelId,
           prompt,
           image: await Promise.all(
@@ -1932,12 +1958,12 @@ var OpenAIImageModel = class {
                 [
                   file.data instanceof Uint8Array ? new Blob([file.data], {
                     type: file.mediaType
-                  }) : new Blob([(0, import_provider_utils16.convertBase64ToUint8Array)(file.data)], {
+                  }) : new Blob([convertBase64ToUint8Array2(file.data)], {
                     type: file.mediaType
                   })
                 ],
                 { type: file.mediaType }
-              ) : (0, import_provider_utils16.downloadBlob)(file.url)
+              ) : downloadBlob(file.url)
             )
           ),
           mask: mask != null ? await fileToBlob(mask) : void 0,
@@ -1946,7 +1972,7 @@ var OpenAIImageModel = class {
           ...(_d = providerOptions.openai) != null ? _d : {}
         }),
         failedResponseHandler: openaiFailedResponseHandler,
-        successfulResponseHandler: (0, import_provider_utils16.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler5(
           openaiImageResponseSchema
         ),
         abortSignal,
@@ -1987,12 +2013,12 @@ var OpenAIImageModel = class {
         }
       };
     }
-    const { value: response, responseHeaders } = await (0, import_provider_utils16.postJsonToApi)({
+    const { value: response, responseHeaders } = await postJsonToApi4({
       url: this.config.url({
         path: "/images/generations",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils16.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders5(this.config.headers(), headers),
       body: {
         model: this.modelId,
         prompt,
@@ -2002,7 +2028,7 @@ var OpenAIImageModel = class {
         ...!hasDefaultResponseFormat(this.modelId) ? { response_format: "b64_json" } : {}
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils16.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler5(
         openaiImageResponseSchema
       ),
       abortSignal,
@@ -2064,48 +2090,52 @@ function distributeTokenDetails(details, index, total) {
 async function fileToBlob(file) {
   if (!file) return void 0;
   if (file.type === "url") {
-    return (0, import_provider_utils16.downloadBlob)(file.url);
+    return downloadBlob(file.url);
   }
-  const data = file.data instanceof Uint8Array ? file.data : (0, import_provider_utils16.convertBase64ToUint8Array)(file.data);
+  const data = file.data instanceof Uint8Array ? file.data : convertBase64ToUint8Array2(file.data);
   return new Blob([data], { type: file.mediaType });
 }
 
 // src/tool/apply-patch.ts
-var import_provider_utils17 = require("@ai-sdk/provider-utils");
-var import_v411 = require("zod/v4");
-var applyPatchInputSchema = (0, import_provider_utils17.lazySchema)(
-  () => (0, import_provider_utils17.zodSchema)(
-    import_v411.z.object({
-      callId: import_v411.z.string(),
-      operation: import_v411.z.discriminatedUnion("type", [
-        import_v411.z.object({
-          type: import_v411.z.literal("create_file"),
-          path: import_v411.z.string(),
-          diff: import_v411.z.string()
+import {
+  createProviderToolFactoryWithOutputSchema,
+  lazySchema as lazySchema10,
+  zodSchema as zodSchema10
+} from "@ai-sdk/provider-utils";
+import { z as z11 } from "zod/v4";
+var applyPatchInputSchema = lazySchema10(
+  () => zodSchema10(
+    z11.object({
+      callId: z11.string(),
+      operation: z11.discriminatedUnion("type", [
+        z11.object({
+          type: z11.literal("create_file"),
+          path: z11.string(),
+          diff: z11.string()
         }),
-        import_v411.z.object({
-          type: import_v411.z.literal("delete_file"),
-          path: import_v411.z.string()
+        z11.object({
+          type: z11.literal("delete_file"),
+          path: z11.string()
         }),
-        import_v411.z.object({
-          type: import_v411.z.literal("update_file"),
-          path: import_v411.z.string(),
-          diff: import_v411.z.string()
+        z11.object({
+          type: z11.literal("update_file"),
+          path: z11.string(),
+          diff: z11.string()
         })
       ])
     })
   )
 );
-var applyPatchOutputSchema = (0, import_provider_utils17.lazySchema)(
-  () => (0, import_provider_utils17.zodSchema)(
-    import_v411.z.object({
-      status: import_v411.z.enum(["completed", "failed"]),
-      output: import_v411.z.string().optional()
+var applyPatchOutputSchema = lazySchema10(
+  () => zodSchema10(
+    z11.object({
+      status: z11.enum(["completed", "failed"]),
+      output: z11.string().optional()
     })
   )
 );
-var applyPatchArgsSchema = (0, import_provider_utils17.lazySchema)(() => (0, import_provider_utils17.zodSchema)(import_v411.z.object({})));
-var applyPatchToolFactory = (0, import_provider_utils17.createProviderToolFactoryWithOutputSchema)({
+var applyPatchArgsSchema = lazySchema10(() => zodSchema10(z11.object({})));
+var applyPatchToolFactory = createProviderToolFactoryWithOutputSchema({
   id: "openai.apply_patch",
   inputSchema: applyPatchInputSchema,
   outputSchema: applyPatchOutputSchema
@@ -2113,41 +2143,45 @@ var applyPatchToolFactory = (0, import_provider_utils17.createProviderToolFactor
 var applyPatch = applyPatchToolFactory;
 
 // src/tool/code-interpreter.ts
-var import_provider_utils18 = require("@ai-sdk/provider-utils");
-var import_v412 = require("zod/v4");
-var codeInterpreterInputSchema = (0, import_provider_utils18.lazySchema)(
-  () => (0, import_provider_utils18.zodSchema)(
-    import_v412.z.object({
-      code: import_v412.z.string().nullish(),
-      containerId: import_v412.z.string()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema2,
+  lazySchema as lazySchema11,
+  zodSchema as zodSchema11
+} from "@ai-sdk/provider-utils";
+import { z as z12 } from "zod/v4";
+var codeInterpreterInputSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
+      code: z12.string().nullish(),
+      containerId: z12.string()
     })
   )
 );
-var codeInterpreterOutputSchema = (0, import_provider_utils18.lazySchema)(
-  () => (0, import_provider_utils18.zodSchema)(
-    import_v412.z.object({
-      outputs: import_v412.z.array(
-        import_v412.z.discriminatedUnion("type", [
-          import_v412.z.object({ type: import_v412.z.literal("logs"), logs: import_v412.z.string() }),
-          import_v412.z.object({ type: import_v412.z.literal("image"), url: import_v412.z.string() })
+var codeInterpreterOutputSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
+      outputs: z12.array(
+        z12.discriminatedUnion("type", [
+          z12.object({ type: z12.literal("logs"), logs: z12.string() }),
+          z12.object({ type: z12.literal("image"), url: z12.string() })
         ])
       ).nullish()
     })
   )
 );
-var codeInterpreterArgsSchema = (0, import_provider_utils18.lazySchema)(
-  () => (0, import_provider_utils18.zodSchema)(
-    import_v412.z.object({
-      container: import_v412.z.union([
-        import_v412.z.string(),
-        import_v412.z.object({
-          fileIds: import_v412.z.array(import_v412.z.string()).optional()
+var codeInterpreterArgsSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
+      container: z12.union([
+        z12.string(),
+        z12.object({
+          fileIds: z12.array(z12.string()).optional()
         })
       ]).optional()
     })
   )
 );
-var codeInterpreterToolFactory = (0, import_provider_utils18.createProviderToolFactoryWithOutputSchema)({
+var codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema2({
   id: "openai.code_interpreter",
   inputSchema: codeInterpreterInputSchema,
   outputSchema: codeInterpreterOutputSchema
@@ -2157,108 +2191,120 @@ var codeInterpreter = (args = {}) => {
 };
 
 // src/tool/custom.ts
-var import_provider_utils19 = require("@ai-sdk/provider-utils");
-var import_v413 = require("zod/v4");
-var customArgsSchema = (0, import_provider_utils19.lazySchema)(
-  () => (0, import_provider_utils19.zodSchema)(
-    import_v413.z.object({
-      description: import_v413.z.string().optional(),
-      format: import_v413.z.union([
-        import_v413.z.object({
-          type: import_v413.z.literal("grammar"),
-          syntax: import_v413.z.enum(["regex", "lark"]),
-          definition: import_v413.z.string()
+import {
+  createProviderToolFactory,
+  lazySchema as lazySchema12,
+  zodSchema as zodSchema12
+} from "@ai-sdk/provider-utils";
+import { z as z13 } from "zod/v4";
+var customArgsSchema = lazySchema12(
+  () => zodSchema12(
+    z13.object({
+      description: z13.string().optional(),
+      format: z13.union([
+        z13.object({
+          type: z13.literal("grammar"),
+          syntax: z13.enum(["regex", "lark"]),
+          definition: z13.string()
         }),
-        import_v413.z.object({
-          type: import_v413.z.literal("text")
+        z13.object({
+          type: z13.literal("text")
         })
       ]).optional()
     })
   )
 );
-var customInputSchema = (0, import_provider_utils19.lazySchema)(() => (0, import_provider_utils19.zodSchema)(import_v413.z.string()));
-var customToolFactory = (0, import_provider_utils19.createProviderToolFactory)({
+var customInputSchema = lazySchema12(() => zodSchema12(z13.string()));
+var customToolFactory = createProviderToolFactory({
   id: "openai.custom",
   inputSchema: customInputSchema
 });
 var customTool = (args) => customToolFactory(args);
 
 // src/tool/file-search.ts
-var import_provider_utils20 = require("@ai-sdk/provider-utils");
-var import_v414 = require("zod/v4");
-var comparisonFilterSchema = import_v414.z.object({
-  key: import_v414.z.string(),
-  type: import_v414.z.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin"]),
-  value: import_v414.z.union([import_v414.z.string(), import_v414.z.number(), import_v414.z.boolean(), import_v414.z.array(import_v414.z.string())])
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema3,
+  lazySchema as lazySchema13,
+  zodSchema as zodSchema13
+} from "@ai-sdk/provider-utils";
+import { z as z14 } from "zod/v4";
+var comparisonFilterSchema = z14.object({
+  key: z14.string(),
+  type: z14.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin"]),
+  value: z14.union([z14.string(), z14.number(), z14.boolean(), z14.array(z14.string())])
 });
-var compoundFilterSchema = import_v414.z.object({
-  type: import_v414.z.enum(["and", "or"]),
-  filters: import_v414.z.array(
-    import_v414.z.union([comparisonFilterSchema, import_v414.z.lazy(() => compoundFilterSchema)])
+var compoundFilterSchema = z14.object({
+  type: z14.enum(["and", "or"]),
+  filters: z14.array(
+    z14.union([comparisonFilterSchema, z14.lazy(() => compoundFilterSchema)])
   )
 });
-var fileSearchArgsSchema = (0, import_provider_utils20.lazySchema)(
-  () => (0, import_provider_utils20.zodSchema)(
-    import_v414.z.object({
-      vectorStoreIds: import_v414.z.array(import_v414.z.string()),
-      maxNumResults: import_v414.z.number().optional(),
-      ranking: import_v414.z.object({
-        ranker: import_v414.z.string().optional(),
-        scoreThreshold: import_v414.z.number().optional()
+var fileSearchArgsSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      vectorStoreIds: z14.array(z14.string()),
+      maxNumResults: z14.number().optional(),
+      ranking: z14.object({
+        ranker: z14.string().optional(),
+        scoreThreshold: z14.number().optional()
       }).optional(),
-      filters: import_v414.z.union([comparisonFilterSchema, compoundFilterSchema]).optional()
+      filters: z14.union([comparisonFilterSchema, compoundFilterSchema]).optional()
     })
   )
 );
-var fileSearchOutputSchema = (0, import_provider_utils20.lazySchema)(
-  () => (0, import_provider_utils20.zodSchema)(
-    import_v414.z.object({
-      queries: import_v414.z.array(import_v414.z.string()),
-      results: import_v414.z.array(
-        import_v414.z.object({
-          attributes: import_v414.z.record(import_v414.z.string(), import_v414.z.unknown()),
-          fileId: import_v414.z.string(),
-          filename: import_v414.z.string(),
-          score: import_v414.z.number(),
-          text: import_v414.z.string()
+var fileSearchOutputSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      queries: z14.array(z14.string()),
+      results: z14.array(
+        z14.object({
+          attributes: z14.record(z14.string(), z14.unknown()),
+          fileId: z14.string(),
+          filename: z14.string(),
+          score: z14.number(),
+          text: z14.string()
         })
       ).nullable()
     })
   )
 );
-var fileSearch = (0, import_provider_utils20.createProviderToolFactoryWithOutputSchema)({
+var fileSearch = createProviderToolFactoryWithOutputSchema3({
   id: "openai.file_search",
-  inputSchema: import_v414.z.object({}),
+  inputSchema: z14.object({}),
   outputSchema: fileSearchOutputSchema
 });
 
 // src/tool/image-generation.ts
-var import_provider_utils21 = require("@ai-sdk/provider-utils");
-var import_v415 = require("zod/v4");
-var imageGenerationArgsSchema = (0, import_provider_utils21.lazySchema)(
-  () => (0, import_provider_utils21.zodSchema)(
-    import_v415.z.object({
-      background: import_v415.z.enum(["auto", "opaque", "transparent"]).optional(),
-      inputFidelity: import_v415.z.enum(["low", "high"]).optional(),
-      inputImageMask: import_v415.z.object({
-        fileId: import_v415.z.string().optional(),
-        imageUrl: import_v415.z.string().optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema4,
+  lazySchema as lazySchema14,
+  zodSchema as zodSchema14
+} from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
+var imageGenerationArgsSchema = lazySchema14(
+  () => zodSchema14(
+    z15.object({
+      background: z15.enum(["auto", "opaque", "transparent"]).optional(),
+      inputFidelity: z15.enum(["low", "high"]).optional(),
+      inputImageMask: z15.object({
+        fileId: z15.string().optional(),
+        imageUrl: z15.string().optional()
       }).optional(),
-      model: import_v415.z.string().optional(),
-      moderation: import_v415.z.enum(["auto"]).optional(),
-      outputCompression: import_v415.z.number().int().min(0).max(100).optional(),
-      outputFormat: import_v415.z.enum(["png", "jpeg", "webp"]).optional(),
-      partialImages: import_v415.z.number().int().min(0).max(3).optional(),
-      quality: import_v415.z.enum(["auto", "low", "medium", "high"]).optional(),
-      size: import_v415.z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+      model: z15.string().optional(),
+      moderation: z15.enum(["auto"]).optional(),
+      outputCompression: z15.number().int().min(0).max(100).optional(),
+      outputFormat: z15.enum(["png", "jpeg", "webp"]).optional(),
+      partialImages: z15.number().int().min(0).max(3).optional(),
+      quality: z15.enum(["auto", "low", "medium", "high"]).optional(),
+      size: z15.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
     }).strict()
   )
 );
-var imageGenerationInputSchema = (0, import_provider_utils21.lazySchema)(() => (0, import_provider_utils21.zodSchema)(import_v415.z.object({})));
-var imageGenerationOutputSchema = (0, import_provider_utils21.lazySchema)(
-  () => (0, import_provider_utils21.zodSchema)(import_v415.z.object({ result: import_v415.z.string() }))
+var imageGenerationInputSchema = lazySchema14(() => zodSchema14(z15.object({})));
+var imageGenerationOutputSchema = lazySchema14(
+  () => zodSchema14(z15.object({ result: z15.string() }))
 );
-var imageGenerationToolFactory = (0, import_provider_utils21.createProviderToolFactoryWithOutputSchema)({
+var imageGenerationToolFactory = createProviderToolFactoryWithOutputSchema4({
   id: "openai.image_generation",
   inputSchema: imageGenerationInputSchema,
   outputSchema: imageGenerationOutputSchema
@@ -2268,115 +2314,123 @@ var imageGeneration = (args = {}) => {
 };
 
 // src/tool/local-shell.ts
-var import_provider_utils22 = require("@ai-sdk/provider-utils");
-var import_v416 = require("zod/v4");
-var localShellInputSchema = (0, import_provider_utils22.lazySchema)(
-  () => (0, import_provider_utils22.zodSchema)(
-    import_v416.z.object({
-      action: import_v416.z.object({
-        type: import_v416.z.literal("exec"),
-        command: import_v416.z.array(import_v416.z.string()),
-        timeoutMs: import_v416.z.number().optional(),
-        user: import_v416.z.string().optional(),
-        workingDirectory: import_v416.z.string().optional(),
-        env: import_v416.z.record(import_v416.z.string(), import_v416.z.string()).optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema5,
+  lazySchema as lazySchema15,
+  zodSchema as zodSchema15
+} from "@ai-sdk/provider-utils";
+import { z as z16 } from "zod/v4";
+var localShellInputSchema = lazySchema15(
+  () => zodSchema15(
+    z16.object({
+      action: z16.object({
+        type: z16.literal("exec"),
+        command: z16.array(z16.string()),
+        timeoutMs: z16.number().optional(),
+        user: z16.string().optional(),
+        workingDirectory: z16.string().optional(),
+        env: z16.record(z16.string(), z16.string()).optional()
       })
     })
   )
 );
-var localShellOutputSchema = (0, import_provider_utils22.lazySchema)(
-  () => (0, import_provider_utils22.zodSchema)(import_v416.z.object({ output: import_v416.z.string() }))
+var localShellOutputSchema = lazySchema15(
+  () => zodSchema15(z16.object({ output: z16.string() }))
 );
-var localShell = (0, import_provider_utils22.createProviderToolFactoryWithOutputSchema)({
+var localShell = createProviderToolFactoryWithOutputSchema5({
   id: "openai.local_shell",
   inputSchema: localShellInputSchema,
   outputSchema: localShellOutputSchema
 });
 
 // src/tool/shell.ts
-var import_provider_utils23 = require("@ai-sdk/provider-utils");
-var import_v417 = require("zod/v4");
-var shellInputSchema = (0, import_provider_utils23.lazySchema)(
-  () => (0, import_provider_utils23.zodSchema)(
-    import_v417.z.object({
-      action: import_v417.z.object({
-        commands: import_v417.z.array(import_v417.z.string()),
-        timeoutMs: import_v417.z.number().optional(),
-        maxOutputLength: import_v417.z.number().optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema6,
+  lazySchema as lazySchema16,
+  zodSchema as zodSchema16
+} from "@ai-sdk/provider-utils";
+import { z as z17 } from "zod/v4";
+var shellInputSchema = lazySchema16(
+  () => zodSchema16(
+    z17.object({
+      action: z17.object({
+        commands: z17.array(z17.string()),
+        timeoutMs: z17.number().optional(),
+        maxOutputLength: z17.number().optional()
       })
     })
   )
 );
-var shellOutputSchema = (0, import_provider_utils23.lazySchema)(
-  () => (0, import_provider_utils23.zodSchema)(
-    import_v417.z.object({
-      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"), exitCode: import_v417.z.number() })
+var shellOutputSchema = lazySchema16(
+  () => zodSchema16(
+    z17.object({
+      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"), exitCode: z17.number() })
           ])
         })
       )
     })
   )
 );
-var shellSkillsSchema = import_v417.z.array(
-  import_v417.z.discriminatedUnion("type", [
-    import_v417.z.object({
-      type: import_v417.z.literal("skillReference"),
-      providerReference: import_v417.z.record(import_v417.z.string(), import_v417.z.string()),
-      version: import_v417.z.string().optional()
+var shellSkillsSchema = z17.array(
+  z17.discriminatedUnion("type", [
+    z17.object({
+      type: z17.literal("skillReference"),
+      providerReference: z17.record(z17.string(), z17.string()),
+      version: z17.string().optional()
     }),
-    import_v417.z.object({
-      type: import_v417.z.literal("inline"),
-      name: import_v417.z.string(),
-      description: import_v417.z.string(),
-      source: import_v417.z.object({
-        type: import_v417.z.literal("base64"),
-        mediaType: import_v417.z.literal("application/zip"),
-        data: import_v417.z.string()
+    z17.object({
+      type: z17.literal("inline"),
+      name: z17.string(),
+      description: z17.string(),
+      source: z17.object({
+        type: z17.literal("base64"),
+        mediaType: z17.literal("application/zip"),
+        data: z17.string()
       })
     })
   ])
 ).optional();
-var shellArgsSchema = (0, import_provider_utils23.lazySchema)(
-  () => (0, import_provider_utils23.zodSchema)(
-    import_v417.z.object({
-      environment: import_v417.z.union([
-        import_v417.z.object({
-          type: import_v417.z.literal("containerAuto"),
-          fileIds: import_v417.z.array(import_v417.z.string()).optional(),
-          memoryLimit: import_v417.z.enum(["1g", "4g", "16g", "64g"]).optional(),
-          networkPolicy: import_v417.z.discriminatedUnion("type", [
-            import_v417.z.object({ type: import_v417.z.literal("disabled") }),
-            import_v417.z.object({
-              type: import_v417.z.literal("allowlist"),
-              allowedDomains: import_v417.z.array(import_v417.z.string()),
-              domainSecrets: import_v417.z.array(
-                import_v417.z.object({
-                  domain: import_v417.z.string(),
-                  name: import_v417.z.string(),
-                  value: import_v417.z.string()
+var shellArgsSchema = lazySchema16(
+  () => zodSchema16(
+    z17.object({
+      environment: z17.union([
+        z17.object({
+          type: z17.literal("containerAuto"),
+          fileIds: z17.array(z17.string()).optional(),
+          memoryLimit: z17.enum(["1g", "4g", "16g", "64g"]).optional(),
+          networkPolicy: z17.discriminatedUnion("type", [
+            z17.object({ type: z17.literal("disabled") }),
+            z17.object({
+              type: z17.literal("allowlist"),
+              allowedDomains: z17.array(z17.string()),
+              domainSecrets: z17.array(
+                z17.object({
+                  domain: z17.string(),
+                  name: z17.string(),
+                  value: z17.string()
                 })
               ).optional()
             })
           ]).optional(),
           skills: shellSkillsSchema
         }),
-        import_v417.z.object({
-          type: import_v417.z.literal("containerReference"),
-          containerId: import_v417.z.string()
+        z17.object({
+          type: z17.literal("containerReference"),
+          containerId: z17.string()
         }),
-        import_v417.z.object({
-          type: import_v417.z.literal("local").optional(),
-          skills: import_v417.z.array(
-            import_v417.z.object({
-              name: import_v417.z.string(),
-              description: import_v417.z.string(),
-              path: import_v417.z.string()
+        z17.object({
+          type: z17.literal("local").optional(),
+          skills: z17.array(
+            z17.object({
+              name: z17.string(),
+              description: z17.string(),
+              path: z17.string()
             })
           ).optional()
         })
@@ -2384,40 +2438,44 @@ var shellArgsSchema = (0, import_provider_utils23.lazySchema)(
     })
   )
 );
-var shell = (0, import_provider_utils23.createProviderToolFactoryWithOutputSchema)({
+var shell = createProviderToolFactoryWithOutputSchema6({
   id: "openai.shell",
   inputSchema: shellInputSchema,
   outputSchema: shellOutputSchema
 });
 
 // src/tool/tool-search.ts
-var import_provider_utils24 = require("@ai-sdk/provider-utils");
-var import_v418 = require("zod/v4");
-var toolSearchArgsSchema = (0, import_provider_utils24.lazySchema)(
-  () => (0, import_provider_utils24.zodSchema)(
-    import_v418.z.object({
-      execution: import_v418.z.enum(["server", "client"]).optional(),
-      description: import_v418.z.string().optional(),
-      parameters: import_v418.z.record(import_v418.z.string(), import_v418.z.unknown()).optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema7,
+  lazySchema as lazySchema17,
+  zodSchema as zodSchema17
+} from "@ai-sdk/provider-utils";
+import { z as z18 } from "zod/v4";
+var toolSearchArgsSchema = lazySchema17(
+  () => zodSchema17(
+    z18.object({
+      execution: z18.enum(["server", "client"]).optional(),
+      description: z18.string().optional(),
+      parameters: z18.record(z18.string(), z18.unknown()).optional()
     })
   )
 );
-var toolSearchInputSchema = (0, import_provider_utils24.lazySchema)(
-  () => (0, import_provider_utils24.zodSchema)(
-    import_v418.z.object({
-      arguments: import_v418.z.unknown().optional(),
-      call_id: import_v418.z.string().nullish()
+var toolSearchInputSchema = lazySchema17(
+  () => zodSchema17(
+    z18.object({
+      arguments: z18.unknown().optional(),
+      call_id: z18.string().nullish()
     })
   )
 );
-var toolSearchOutputSchema = (0, import_provider_utils24.lazySchema)(
-  () => (0, import_provider_utils24.zodSchema)(
-    import_v418.z.object({
-      tools: import_v418.z.array(import_v418.z.record(import_v418.z.string(), import_v418.z.unknown()))
+var toolSearchOutputSchema = lazySchema17(
+  () => zodSchema17(
+    z18.object({
+      tools: z18.array(z18.record(z18.string(), z18.unknown()))
     })
   )
 );
-var toolSearchToolFactory = (0, import_provider_utils24.createProviderToolFactoryWithOutputSchema)({
+var toolSearchToolFactory = createProviderToolFactoryWithOutputSchema7({
   id: "openai.tool_search",
   inputSchema: toolSearchInputSchema,
   outputSchema: toolSearchOutputSchema
@@ -2425,53 +2483,57 @@ var toolSearchToolFactory = (0, import_provider_utils24.createProviderToolFactor
 var toolSearch = (args = {}) => toolSearchToolFactory(args);
 
 // src/tool/web-search.ts
-var import_provider_utils25 = require("@ai-sdk/provider-utils");
-var import_v419 = require("zod/v4");
-var webSearchArgsSchema = (0, import_provider_utils25.lazySchema)(
-  () => (0, import_provider_utils25.zodSchema)(
-    import_v419.z.object({
-      externalWebAccess: import_v419.z.boolean().optional(),
-      filters: import_v419.z.object({ allowedDomains: import_v419.z.array(import_v419.z.string()).optional() }).optional(),
-      searchContextSize: import_v419.z.enum(["low", "medium", "high"]).optional(),
-      userLocation: import_v419.z.object({
-        type: import_v419.z.literal("approximate"),
-        country: import_v419.z.string().optional(),
-        city: import_v419.z.string().optional(),
-        region: import_v419.z.string().optional(),
-        timezone: import_v419.z.string().optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema8,
+  lazySchema as lazySchema18,
+  zodSchema as zodSchema18
+} from "@ai-sdk/provider-utils";
+import { z as z19 } from "zod/v4";
+var webSearchArgsSchema = lazySchema18(
+  () => zodSchema18(
+    z19.object({
+      externalWebAccess: z19.boolean().optional(),
+      filters: z19.object({ allowedDomains: z19.array(z19.string()).optional() }).optional(),
+      searchContextSize: z19.enum(["low", "medium", "high"]).optional(),
+      userLocation: z19.object({
+        type: z19.literal("approximate"),
+        country: z19.string().optional(),
+        city: z19.string().optional(),
+        region: z19.string().optional(),
+        timezone: z19.string().optional()
       }).optional()
     })
   )
 );
-var webSearchInputSchema = (0, import_provider_utils25.lazySchema)(() => (0, import_provider_utils25.zodSchema)(import_v419.z.object({})));
-var webSearchOutputSchema = (0, import_provider_utils25.lazySchema)(
-  () => (0, import_provider_utils25.zodSchema)(
-    import_v419.z.object({
-      action: import_v419.z.discriminatedUnion("type", [
-        import_v419.z.object({
-          type: import_v419.z.literal("search"),
-          query: import_v419.z.string().optional()
+var webSearchInputSchema = lazySchema18(() => zodSchema18(z19.object({})));
+var webSearchOutputSchema = lazySchema18(
+  () => zodSchema18(
+    z19.object({
+      action: z19.discriminatedUnion("type", [
+        z19.object({
+          type: z19.literal("search"),
+          query: z19.string().optional()
         }),
-        import_v419.z.object({
-          type: import_v419.z.literal("openPage"),
-          url: import_v419.z.string().nullish()
+        z19.object({
+          type: z19.literal("openPage"),
+          url: z19.string().nullish()
         }),
-        import_v419.z.object({
-          type: import_v419.z.literal("findInPage"),
-          url: import_v419.z.string().nullish(),
-          pattern: import_v419.z.string().nullish()
+        z19.object({
+          type: z19.literal("findInPage"),
+          url: z19.string().nullish(),
+          pattern: z19.string().nullish()
         })
       ]).optional(),
-      sources: import_v419.z.array(
-        import_v419.z.discriminatedUnion("type", [
-          import_v419.z.object({ type: import_v419.z.literal("url"), url: import_v419.z.string() }),
-          import_v419.z.object({ type: import_v419.z.literal("api"), name: import_v419.z.string() })
+      sources: z19.array(
+        z19.discriminatedUnion("type", [
+          z19.object({ type: z19.literal("url"), url: z19.string() }),
+          z19.object({ type: z19.literal("api"), name: z19.string() })
         ])
       ).optional()
     })
   )
 );
-var webSearchToolFactory = (0, import_provider_utils25.createProviderToolFactoryWithOutputSchema)({
+var webSearchToolFactory = createProviderToolFactoryWithOutputSchema8({
   id: "openai.web_search",
   inputSchema: webSearchInputSchema,
   outputSchema: webSearchOutputSchema
@@ -2479,109 +2541,117 @@ var webSearchToolFactory = (0, import_provider_utils25.createProviderToolFactory
 var webSearch = (args = {}) => webSearchToolFactory(args);
 
 // src/tool/web-search-preview.ts
-var import_provider_utils26 = require("@ai-sdk/provider-utils");
-var import_v420 = require("zod/v4");
-var webSearchPreviewArgsSchema = (0, import_provider_utils26.lazySchema)(
-  () => (0, import_provider_utils26.zodSchema)(
-    import_v420.z.object({
-      searchContextSize: import_v420.z.enum(["low", "medium", "high"]).optional(),
-      userLocation: import_v420.z.object({
-        type: import_v420.z.literal("approximate"),
-        country: import_v420.z.string().optional(),
-        city: import_v420.z.string().optional(),
-        region: import_v420.z.string().optional(),
-        timezone: import_v420.z.string().optional()
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema9,
+  lazySchema as lazySchema19,
+  zodSchema as zodSchema19
+} from "@ai-sdk/provider-utils";
+import { z as z20 } from "zod/v4";
+var webSearchPreviewArgsSchema = lazySchema19(
+  () => zodSchema19(
+    z20.object({
+      searchContextSize: z20.enum(["low", "medium", "high"]).optional(),
+      userLocation: z20.object({
+        type: z20.literal("approximate"),
+        country: z20.string().optional(),
+        city: z20.string().optional(),
+        region: z20.string().optional(),
+        timezone: z20.string().optional()
       }).optional()
     })
   )
 );
-var webSearchPreviewInputSchema = (0, import_provider_utils26.lazySchema)(
-  () => (0, import_provider_utils26.zodSchema)(import_v420.z.object({}))
+var webSearchPreviewInputSchema = lazySchema19(
+  () => zodSchema19(z20.object({}))
 );
-var webSearchPreviewOutputSchema = (0, import_provider_utils26.lazySchema)(
-  () => (0, import_provider_utils26.zodSchema)(
-    import_v420.z.object({
-      action: import_v420.z.discriminatedUnion("type", [
-        import_v420.z.object({
-          type: import_v420.z.literal("search"),
-          query: import_v420.z.string().optional()
+var webSearchPreviewOutputSchema = lazySchema19(
+  () => zodSchema19(
+    z20.object({
+      action: z20.discriminatedUnion("type", [
+        z20.object({
+          type: z20.literal("search"),
+          query: z20.string().optional()
         }),
-        import_v420.z.object({
-          type: import_v420.z.literal("openPage"),
-          url: import_v420.z.string().nullish()
+        z20.object({
+          type: z20.literal("openPage"),
+          url: z20.string().nullish()
         }),
-        import_v420.z.object({
-          type: import_v420.z.literal("findInPage"),
-          url: import_v420.z.string().nullish(),
-          pattern: import_v420.z.string().nullish()
+        z20.object({
+          type: z20.literal("findInPage"),
+          url: z20.string().nullish(),
+          pattern: z20.string().nullish()
         })
       ]).optional()
     })
   )
 );
-var webSearchPreview = (0, import_provider_utils26.createProviderToolFactoryWithOutputSchema)({
+var webSearchPreview = createProviderToolFactoryWithOutputSchema9({
   id: "openai.web_search_preview",
   inputSchema: webSearchPreviewInputSchema,
   outputSchema: webSearchPreviewOutputSchema
 });
 
 // src/tool/mcp.ts
-var import_provider_utils27 = require("@ai-sdk/provider-utils");
-var import_v421 = require("zod/v4");
-var jsonValueSchema = import_v421.z.lazy(
-  () => import_v421.z.union([
-    import_v421.z.string(),
-    import_v421.z.number(),
-    import_v421.z.boolean(),
-    import_v421.z.null(),
-    import_v421.z.array(jsonValueSchema),
-    import_v421.z.record(import_v421.z.string(), jsonValueSchema)
+import {
+  createProviderToolFactoryWithOutputSchema as createProviderToolFactoryWithOutputSchema10,
+  lazySchema as lazySchema20,
+  zodSchema as zodSchema20
+} from "@ai-sdk/provider-utils";
+import { z as z21 } from "zod/v4";
+var jsonValueSchema = z21.lazy(
+  () => z21.union([
+    z21.string(),
+    z21.number(),
+    z21.boolean(),
+    z21.null(),
+    z21.array(jsonValueSchema),
+    z21.record(z21.string(), jsonValueSchema)
   ])
 );
-var mcpArgsSchema = (0, import_provider_utils27.lazySchema)(
-  () => (0, import_provider_utils27.zodSchema)(
-    import_v421.z.object({
-      serverLabel: import_v421.z.string(),
-      allowedTools: import_v421.z.union([
-        import_v421.z.array(import_v421.z.string()),
-        import_v421.z.object({
-          readOnly: import_v421.z.boolean().optional(),
-          toolNames: import_v421.z.array(import_v421.z.string()).optional()
+var mcpArgsSchema = lazySchema20(
+  () => zodSchema20(
+    z21.object({
+      serverLabel: z21.string(),
+      allowedTools: z21.union([
+        z21.array(z21.string()),
+        z21.object({
+          readOnly: z21.boolean().optional(),
+          toolNames: z21.array(z21.string()).optional()
         })
       ]).optional(),
-      authorization: import_v421.z.string().optional(),
-      connectorId: import_v421.z.string().optional(),
-      headers: import_v421.z.record(import_v421.z.string(), import_v421.z.string()).optional(),
-      requireApproval: import_v421.z.union([
-        import_v421.z.enum(["always", "never"]),
-        import_v421.z.object({
-          never: import_v421.z.object({
-            toolNames: import_v421.z.array(import_v421.z.string()).optional()
+      authorization: z21.string().optional(),
+      connectorId: z21.string().optional(),
+      headers: z21.record(z21.string(), z21.string()).optional(),
+      requireApproval: z21.union([
+        z21.enum(["always", "never"]),
+        z21.object({
+          never: z21.object({
+            toolNames: z21.array(z21.string()).optional()
           }).optional()
         })
       ]).optional(),
-      serverDescription: import_v421.z.string().optional(),
-      serverUrl: import_v421.z.string().optional()
+      serverDescription: z21.string().optional(),
+      serverUrl: z21.string().optional()
     }).refine(
       (v) => v.serverUrl != null || v.connectorId != null,
       "One of serverUrl or connectorId must be provided."
     )
   )
 );
-var mcpInputSchema = (0, import_provider_utils27.lazySchema)(() => (0, import_provider_utils27.zodSchema)(import_v421.z.object({})));
-var mcpOutputSchema = (0, import_provider_utils27.lazySchema)(
-  () => (0, import_provider_utils27.zodSchema)(
-    import_v421.z.object({
-      type: import_v421.z.literal("call"),
-      serverLabel: import_v421.z.string(),
-      name: import_v421.z.string(),
-      arguments: import_v421.z.string(),
-      output: import_v421.z.string().nullish(),
-      error: import_v421.z.union([import_v421.z.string(), jsonValueSchema]).optional()
+var mcpInputSchema = lazySchema20(() => zodSchema20(z21.object({})));
+var mcpOutputSchema = lazySchema20(
+  () => zodSchema20(
+    z21.object({
+      type: z21.literal("call"),
+      serverLabel: z21.string(),
+      name: z21.string(),
+      arguments: z21.string(),
+      output: z21.string().nullish(),
+      error: z21.union([z21.string(), jsonValueSchema]).optional()
     })
   )
 );
-var mcpToolFactory = (0, import_provider_utils27.createProviderToolFactoryWithOutputSchema)({
+var mcpToolFactory = createProviderToolFactoryWithOutputSchema10({
   id: "openai.mcp",
   inputSchema: mcpInputSchema,
   outputSchema: mcpOutputSchema
@@ -2706,8 +2776,19 @@ var openaiTools = {
 };
 
 // src/responses/openai-responses-language-model.ts
-var import_provider8 = require("@ai-sdk/provider");
-var import_provider_utils32 = require("@ai-sdk/provider-utils");
+import {
+  APICallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders6,
+  createEventSourceResponseHandler as createEventSourceResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler6,
+  createToolNameMapping,
+  generateId as generateId2,
+  isCustomReasoning as isCustomReasoning2,
+  parseProviderOptions as parseProviderOptions6,
+  postJsonToApi as postJsonToApi5
+} from "@ai-sdk/provider-utils";
 
 // src/responses/convert-openai-responses-usage.ts
 function convertOpenAIResponsesUsage(usage) {
@@ -2749,9 +2830,19 @@ function convertOpenAIResponsesUsage(usage) {
 }
 
 // src/responses/convert-to-openai-responses-input.ts
-var import_provider6 = require("@ai-sdk/provider");
-var import_provider_utils28 = require("@ai-sdk/provider-utils");
-var import_v422 = require("zod/v4");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
+} from "@ai-sdk/provider";
+import {
+  convertToBase64 as convertToBase642,
+  isNonNullable,
+  isProviderReference as isProviderReference2,
+  parseJSON,
+  parseProviderOptions as parseProviderOptions5,
+  resolveProviderReference as resolveProviderReference2,
+  validateTypes
+} from "@ai-sdk/provider-utils";
+import { z as z22 } from "zod/v4";
 function isFileId(data, prefixes) {
   if (!prefixes) return false;
   return prefixes.some((prefix) => data.startsWith(prefix));
@@ -2811,8 +2902,8 @@ async function convertToOpenAIResponsesInput({
                 return { type: "input_text", text: part.text };
               }
               case "file": {
-                if ((0, import_provider_utils28.isProviderReference)(part.data)) {
-                  const fileId = (0, import_provider_utils28.resolveProviderReference)({
+                if (isProviderReference2(part.data)) {
+                  const fileId = resolveProviderReference2({
                     reference: part.data,
                     provider: providerOptionsName
                   });
@@ -2833,7 +2924,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_utils28.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
                   };
@@ -2848,11 +2939,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_utils28.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}`
                   });
                 }
@@ -2898,10 +2989,10 @@ async function convertToOpenAIResponsesInput({
                   input.push({ type: "item_reference", id });
                   break;
                 }
-                const parsedInput = typeof part.input === "string" ? await (0, import_provider_utils28.parseJSON)({
+                const parsedInput = typeof part.input === "string" ? await parseJSON({
                   text: part.input,
                   schema: toolSearchInputSchema
-                }) : await (0, import_provider_utils28.validateTypes)({
+                }) : await validateTypes({
                   value: part.input,
                   schema: toolSearchInputSchema
                 });
@@ -2927,7 +3018,7 @@ async function convertToOpenAIResponsesInput({
                 break;
               }
               if (hasLocalShellTool && resolvedToolName === "local_shell") {
-                const parsedInput = await (0, import_provider_utils28.validateTypes)({
+                const parsedInput = await validateTypes({
                   value: part.input,
                   schema: localShellInputSchema
                 });
@@ -2947,7 +3038,7 @@ async function convertToOpenAIResponsesInput({
                 break;
               }
               if (hasShellTool && resolvedToolName === "shell") {
-                const parsedInput = await (0, import_provider_utils28.validateTypes)({
+                const parsedInput = await validateTypes({
                   value: part.input,
                   schema: shellInputSchema
                 });
@@ -2965,7 +3056,7 @@ async function convertToOpenAIResponsesInput({
                 break;
               }
               if (hasApplyPatchTool && resolvedToolName === "apply_patch") {
-                const parsedInput = await (0, import_provider_utils28.validateTypes)({
+                const parsedInput = await validateTypes({
                   value: part.input,
                   schema: applyPatchInputSchema
                 });
@@ -3013,7 +3104,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_utils28.validateTypes)({
+                  const parsedOutput = await validateTypes({
                     value: part.output.value,
                     schema: toolSearchOutputSchema
                   });
@@ -3030,7 +3121,7 @@ async function convertToOpenAIResponsesInput({
               }
               if (hasShellTool && resolvedResultToolName === "shell") {
                 if (part.output.type === "json") {
-                  const parsedOutput = await (0, import_provider_utils28.validateTypes)({
+                  const parsedOutput = await validateTypes({
                     value: part.output.value,
                     schema: shellOutputSchema
                   });
@@ -3061,7 +3152,7 @@ async function convertToOpenAIResponsesInput({
               break;
             }
             case "reasoning": {
-              const providerOptions = await (0, import_provider_utils28.parseProviderOptions)({
+              const providerOptions = await parseProviderOptions5({
                 provider: providerOptionsName,
                 providerOptions: part.providerOptions,
                 schema: openaiResponsesReasoningProviderOptionsSchema
@@ -3191,7 +3282,7 @@ async function convertToOpenAIResponsesInput({
             part.toolName
           );
           if (resolvedToolName === "tool_search" && output.type === "json") {
-            const parsedOutput = await (0, import_provider_utils28.validateTypes)({
+            const parsedOutput = await validateTypes({
               value: output.value,
               schema: toolSearchOutputSchema
             });
@@ -3205,7 +3296,7 @@ async function convertToOpenAIResponsesInput({
             continue;
           }
           if (hasLocalShellTool && resolvedToolName === "local_shell" && output.type === "json") {
-            const parsedOutput = await (0, import_provider_utils28.validateTypes)({
+            const parsedOutput = await validateTypes({
               value: output.value,
               schema: localShellOutputSchema
             });
@@ -3217,7 +3308,7 @@ async function convertToOpenAIResponsesInput({
             continue;
           }
           if (hasShellTool && resolvedToolName === "shell" && output.type === "json") {
-            const parsedOutput = await (0, import_provider_utils28.validateTypes)({
+            const parsedOutput = await validateTypes({
               value: output.value,
               schema: shellOutputSchema
             });
@@ -3236,7 +3327,7 @@ async function convertToOpenAIResponsesInput({
             continue;
           }
           if (hasApplyPatchTool && part.toolName === "apply_patch" && output.type === "json") {
-            const parsedOutput = await (0, import_provider_utils28.validateTypes)({
+            const parsedOutput = await validateTypes({
               value: output.value,
               schema: applyPatchOutputSchema
             });
@@ -3296,7 +3387,7 @@ async function convertToOpenAIResponsesInput({
                       });
                       return void 0;
                   }
-                }).filter(import_provider_utils28.isNonNullable);
+                }).filter(isNonNullable);
                 break;
               default:
                 outputValue = "";
@@ -3361,7 +3452,7 @@ async function convertToOpenAIResponsesInput({
                     return void 0;
                   }
                 }
-              }).filter(import_provider_utils28.isNonNullable);
+              }).filter(isNonNullable);
               break;
           }
           input.push({
@@ -3391,9 +3482,9 @@ async function convertToOpenAIResponsesInput({
   }
   return { input, warnings };
 }
-var openaiResponsesReasoningProviderOptionsSchema = import_v422.z.object({
-  itemId: import_v422.z.string().nullish(),
-  reasoningEncryptedContent: import_v422.z.string().nullish()
+var openaiResponsesReasoningProviderOptionsSchema = z22.object({
+  itemId: z22.string().nullish(),
+  reasoningEncryptedContent: z22.string().nullish()
 });
 
 // src/responses/map-openai-responses-finish-reason.ts
@@ -3415,552 +3506,552 @@ function mapOpenAIResponseFinishReason({
 }
 
 // src/responses/openai-responses-api.ts
-var import_provider_utils29 = 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.optional())
+import { 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.optional())
   ])
 );
-var openaiResponsesChunkSchema = (0, import_provider_utils29.lazySchema)(
-  () => (0, import_provider_utils29.zodSchema)(
-    import_v423.z.union([
-      import_v423.z.object({
-        type: import_v423.z.literal("response.output_text.delta"),
-        item_id: import_v423.z.string(),
-        delta: import_v423.z.string(),
-        logprobs: import_v423.z.array(
-          import_v423.z.object({
-            token: import_v423.z.string(),
-            logprob: import_v423.z.number(),
-            top_logprobs: import_v423.z.array(
-              import_v423.z.object({
-                token: import_v423.z.string(),
-                logprob: import_v423.z.number()
+var openaiResponsesChunkSchema = lazySchema21(
+  () => zodSchema21(
+    z23.union([
+      z23.object({
+        type: z23.literal("response.output_text.delta"),
+        item_id: z23.string(),
+        delta: z23.string(),
+        logprobs: z23.array(
+          z23.object({
+            token: z23.string(),
+            logprob: z23.number(),
+            top_logprobs: z23.array(
+              z23.object({
+                token: z23.string(),
+                logprob: z23.number()
               })
             )
           })
         ).nullish()
       }),
-      import_v423.z.object({
-        type: import_v423.z.enum(["response.completed", "response.incomplete"]),
-        response: import_v423.z.object({
-          incomplete_details: import_v423.z.object({ reason: import_v423.z.string() }).nullish(),
-          usage: import_v423.z.object({
-            input_tokens: import_v423.z.number(),
-            input_tokens_details: import_v423.z.object({ cached_tokens: import_v423.z.number().nullish() }).nullish(),
-            output_tokens: import_v423.z.number(),
-            output_tokens_details: import_v423.z.object({ reasoning_tokens: import_v423.z.number().nullish() }).nullish()
+      z23.object({
+        type: z23.enum(["response.completed", "response.incomplete"]),
+        response: z23.object({
+          incomplete_details: z23.object({ reason: z23.string() }).nullish(),
+          usage: z23.object({
+            input_tokens: z23.number(),
+            input_tokens_details: z23.object({ cached_tokens: z23.number().nullish() }).nullish(),
+            output_tokens: z23.number(),
+            output_tokens_details: z23.object({ reasoning_tokens: z23.number().nullish() }).nullish()
           }),
-          service_tier: import_v423.z.string().nullish()
+          service_tier: z23.string().nullish()
         })
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.failed"),
-        response: import_v423.z.object({
-          error: import_v423.z.object({
-            code: import_v423.z.string().nullish(),
-            message: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.failed"),
+        response: z23.object({
+          error: z23.object({
+            code: z23.string().nullish(),
+            message: z23.string()
           }).nullish(),
-          incomplete_details: import_v423.z.object({ reason: import_v423.z.string() }).nullish(),
-          usage: import_v423.z.object({
-            input_tokens: import_v423.z.number(),
-            input_tokens_details: import_v423.z.object({ cached_tokens: import_v423.z.number().nullish() }).nullish(),
-            output_tokens: import_v423.z.number(),
-            output_tokens_details: import_v423.z.object({ reasoning_tokens: import_v423.z.number().nullish() }).nullish()
+          incomplete_details: z23.object({ reason: z23.string() }).nullish(),
+          usage: z23.object({
+            input_tokens: z23.number(),
+            input_tokens_details: z23.object({ cached_tokens: z23.number().nullish() }).nullish(),
+            output_tokens: z23.number(),
+            output_tokens_details: z23.object({ reasoning_tokens: z23.number().nullish() }).nullish()
           }).nullish(),
-          service_tier: import_v423.z.string().nullish()
+          service_tier: z23.string().nullish()
         })
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.created"),
-        response: import_v423.z.object({
-          id: import_v423.z.string(),
-          created_at: import_v423.z.number(),
-          model: import_v423.z.string(),
-          service_tier: import_v423.z.string().nullish()
+      z23.object({
+        type: z23.literal("response.created"),
+        response: z23.object({
+          id: z23.string(),
+          created_at: z23.number(),
+          model: z23.string(),
+          service_tier: z23.string().nullish()
         })
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.output_item.added"),
-        output_index: import_v423.z.number(),
-        item: import_v423.z.discriminatedUnion("type", [
-          import_v423.z.object({
-            type: import_v423.z.literal("message"),
-            id: import_v423.z.string(),
-            phase: import_v423.z.enum(["commentary", "final_answer"]).nullish()
+      z23.object({
+        type: z23.literal("response.output_item.added"),
+        output_index: z23.number(),
+        item: z23.discriminatedUnion("type", [
+          z23.object({
+            type: z23.literal("message"),
+            id: z23.string(),
+            phase: z23.enum(["commentary", "final_answer"]).nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("reasoning"),
-            id: import_v423.z.string(),
-            encrypted_content: import_v423.z.string().nullish()
+          z23.object({
+            type: z23.literal("reasoning"),
+            id: z23.string(),
+            encrypted_content: z23.string().nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("function_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            name: import_v423.z.string(),
-            arguments: import_v423.z.string()
+          z23.object({
+            type: z23.literal("function_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            name: z23.string(),
+            arguments: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("web_search_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.string()
+          z23.object({
+            type: z23.literal("web_search_call"),
+            id: z23.string(),
+            status: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("computer_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.string()
+          z23.object({
+            type: z23.literal("computer_call"),
+            id: z23.string(),
+            status: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("file_search_call"),
-            id: import_v423.z.string()
+          z23.object({
+            type: z23.literal("file_search_call"),
+            id: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("image_generation_call"),
-            id: import_v423.z.string()
+          z23.object({
+            type: z23.literal("image_generation_call"),
+            id: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("code_interpreter_call"),
-            id: import_v423.z.string(),
-            container_id: import_v423.z.string(),
-            code: import_v423.z.string().nullable(),
-            outputs: import_v423.z.array(
-              import_v423.z.discriminatedUnion("type", [
-                import_v423.z.object({ type: import_v423.z.literal("logs"), logs: import_v423.z.string() }),
-                import_v423.z.object({ type: import_v423.z.literal("image"), url: import_v423.z.string() })
+          z23.object({
+            type: z23.literal("code_interpreter_call"),
+            id: z23.string(),
+            container_id: z23.string(),
+            code: z23.string().nullable(),
+            outputs: z23.array(
+              z23.discriminatedUnion("type", [
+                z23.object({ type: z23.literal("logs"), logs: z23.string() }),
+                z23.object({ type: z23.literal("image"), url: z23.string() })
               ])
             ).nullable(),
-            status: import_v423.z.string()
+            status: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.string(),
-            approval_request_id: import_v423.z.string().nullish()
+          z23.object({
+            type: z23.literal("mcp_call"),
+            id: z23.string(),
+            status: z23.string(),
+            approval_request_id: z23.string().nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_list_tools"),
-            id: import_v423.z.string()
+          z23.object({
+            type: z23.literal("mcp_list_tools"),
+            id: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_approval_request"),
-            id: import_v423.z.string()
+          z23.object({
+            type: z23.literal("mcp_approval_request"),
+            id: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("apply_patch_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed"]),
-            operation: import_v423.z.discriminatedUnion("type", [
-              import_v423.z.object({
-                type: import_v423.z.literal("create_file"),
-                path: import_v423.z.string(),
-                diff: import_v423.z.string()
+          z23.object({
+            type: z23.literal("apply_patch_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed"]),
+            operation: z23.discriminatedUnion("type", [
+              z23.object({
+                type: z23.literal("create_file"),
+                path: z23.string(),
+                diff: z23.string()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("delete_file"),
-                path: import_v423.z.string()
+              z23.object({
+                type: z23.literal("delete_file"),
+                path: z23.string()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("update_file"),
-                path: import_v423.z.string(),
-                diff: import_v423.z.string()
+              z23.object({
+                type: z23.literal("update_file"),
+                path: z23.string(),
+                diff: z23.string()
               })
             ])
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("custom_tool_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            name: import_v423.z.string(),
-            input: import_v423.z.string()
+          z23.object({
+            type: z23.literal("custom_tool_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            name: z23.string(),
+            input: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("shell_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            action: import_v423.z.object({
-              commands: import_v423.z.array(import_v423.z.string())
+          z23.object({
+            type: z23.literal("shell_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            action: z23.object({
+              commands: z23.array(z23.string())
             })
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("compaction"),
-            id: import_v423.z.string(),
-            encrypted_content: import_v423.z.string().nullish()
+          z23.object({
+            type: z23.literal("compaction"),
+            id: z23.string(),
+            encrypted_content: z23.string().nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("shell_call_output"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            output: import_v423.z.array(
-              import_v423.z.object({
-                stdout: import_v423.z.string(),
-                stderr: import_v423.z.string(),
-                outcome: import_v423.z.discriminatedUnion("type", [
-                  import_v423.z.object({ type: import_v423.z.literal("timeout") }),
-                  import_v423.z.object({
-                    type: import_v423.z.literal("exit"),
-                    exit_code: import_v423.z.number()
+          z23.object({
+            type: z23.literal("shell_call_output"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            output: z23.array(
+              z23.object({
+                stdout: z23.string(),
+                stderr: z23.string(),
+                outcome: z23.discriminatedUnion("type", [
+                  z23.object({ type: z23.literal("timeout") }),
+                  z23.object({
+                    type: z23.literal("exit"),
+                    exit_code: z23.number()
                   })
                 ])
               })
             )
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("tool_search_call"),
-            id: import_v423.z.string(),
-            execution: import_v423.z.enum(["server", "client"]),
-            call_id: import_v423.z.string().nullable(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            arguments: import_v423.z.unknown()
+          z23.object({
+            type: z23.literal("tool_search_call"),
+            id: z23.string(),
+            execution: z23.enum(["server", "client"]),
+            call_id: z23.string().nullable(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z23.unknown()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("tool_search_output"),
-            id: import_v423.z.string(),
-            execution: import_v423.z.enum(["server", "client"]),
-            call_id: import_v423.z.string().nullable(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            tools: import_v423.z.array(import_v423.z.record(import_v423.z.string(), jsonValueSchema2.optional()))
+          z23.object({
+            type: z23.literal("tool_search_output"),
+            id: z23.string(),
+            execution: z23.enum(["server", "client"]),
+            call_id: z23.string().nullable(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            tools: z23.array(z23.record(z23.string(), jsonValueSchema2.optional()))
           })
         ])
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.output_item.done"),
-        output_index: import_v423.z.number(),
-        item: import_v423.z.discriminatedUnion("type", [
-          import_v423.z.object({
-            type: import_v423.z.literal("message"),
-            id: import_v423.z.string(),
-            phase: import_v423.z.enum(["commentary", "final_answer"]).nullish()
+      z23.object({
+        type: z23.literal("response.output_item.done"),
+        output_index: z23.number(),
+        item: z23.discriminatedUnion("type", [
+          z23.object({
+            type: z23.literal("message"),
+            id: z23.string(),
+            phase: z23.enum(["commentary", "final_answer"]).nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("reasoning"),
-            id: import_v423.z.string(),
-            encrypted_content: import_v423.z.string().nullish()
+          z23.object({
+            type: z23.literal("reasoning"),
+            id: z23.string(),
+            encrypted_content: z23.string().nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("function_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            name: import_v423.z.string(),
-            arguments: import_v423.z.string(),
-            status: import_v423.z.literal("completed")
+          z23.object({
+            type: z23.literal("function_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            name: z23.string(),
+            arguments: z23.string(),
+            status: z23.literal("completed")
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("custom_tool_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            name: import_v423.z.string(),
-            input: import_v423.z.string(),
-            status: import_v423.z.literal("completed")
+          z23.object({
+            type: z23.literal("custom_tool_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            name: z23.string(),
+            input: z23.string(),
+            status: z23.literal("completed")
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("code_interpreter_call"),
-            id: import_v423.z.string(),
-            code: import_v423.z.string().nullable(),
-            container_id: import_v423.z.string(),
-            outputs: import_v423.z.array(
-              import_v423.z.discriminatedUnion("type", [
-                import_v423.z.object({ type: import_v423.z.literal("logs"), logs: import_v423.z.string() }),
-                import_v423.z.object({ type: import_v423.z.literal("image"), url: import_v423.z.string() })
+          z23.object({
+            type: z23.literal("code_interpreter_call"),
+            id: z23.string(),
+            code: z23.string().nullable(),
+            container_id: z23.string(),
+            outputs: z23.array(
+              z23.discriminatedUnion("type", [
+                z23.object({ type: z23.literal("logs"), logs: z23.string() }),
+                z23.object({ type: z23.literal("image"), url: z23.string() })
               ])
             ).nullable()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("image_generation_call"),
-            id: import_v423.z.string(),
-            result: import_v423.z.string()
+          z23.object({
+            type: z23.literal("image_generation_call"),
+            id: z23.string(),
+            result: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("web_search_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.string(),
-            action: import_v423.z.discriminatedUnion("type", [
-              import_v423.z.object({
-                type: import_v423.z.literal("search"),
-                query: import_v423.z.string().nullish(),
-                sources: import_v423.z.array(
-                  import_v423.z.discriminatedUnion("type", [
-                    import_v423.z.object({ type: import_v423.z.literal("url"), url: import_v423.z.string() }),
-                    import_v423.z.object({ type: import_v423.z.literal("api"), name: import_v423.z.string() })
+          z23.object({
+            type: z23.literal("web_search_call"),
+            id: z23.string(),
+            status: z23.string(),
+            action: z23.discriminatedUnion("type", [
+              z23.object({
+                type: z23.literal("search"),
+                query: z23.string().nullish(),
+                sources: z23.array(
+                  z23.discriminatedUnion("type", [
+                    z23.object({ type: z23.literal("url"), url: z23.string() }),
+                    z23.object({ type: z23.literal("api"), name: z23.string() })
                   ])
                 ).nullish()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("open_page"),
-                url: import_v423.z.string().nullish()
+              z23.object({
+                type: z23.literal("open_page"),
+                url: z23.string().nullish()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("find_in_page"),
-                url: import_v423.z.string().nullish(),
-                pattern: import_v423.z.string().nullish()
+              z23.object({
+                type: z23.literal("find_in_page"),
+                url: z23.string().nullish(),
+                pattern: z23.string().nullish()
               })
             ]).nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("file_search_call"),
-            id: import_v423.z.string(),
-            queries: import_v423.z.array(import_v423.z.string()),
-            results: import_v423.z.array(
-              import_v423.z.object({
-                attributes: import_v423.z.record(
-                  import_v423.z.string(),
-                  import_v423.z.union([import_v423.z.string(), import_v423.z.number(), import_v423.z.boolean()])
+          z23.object({
+            type: z23.literal("file_search_call"),
+            id: z23.string(),
+            queries: z23.array(z23.string()),
+            results: z23.array(
+              z23.object({
+                attributes: z23.record(
+                  z23.string(),
+                  z23.union([z23.string(), z23.number(), z23.boolean()])
                 ),
-                file_id: import_v423.z.string(),
-                filename: import_v423.z.string(),
-                score: import_v423.z.number(),
-                text: import_v423.z.string()
+                file_id: z23.string(),
+                filename: z23.string(),
+                score: z23.number(),
+                text: z23.string()
               })
             ).nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("local_shell_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            action: import_v423.z.object({
-              type: import_v423.z.literal("exec"),
-              command: import_v423.z.array(import_v423.z.string()),
-              timeout_ms: import_v423.z.number().optional(),
-              user: import_v423.z.string().optional(),
-              working_directory: import_v423.z.string().optional(),
-              env: import_v423.z.record(import_v423.z.string(), import_v423.z.string()).optional()
+          z23.object({
+            type: z23.literal("local_shell_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            action: z23.object({
+              type: z23.literal("exec"),
+              command: z23.array(z23.string()),
+              timeout_ms: z23.number().optional(),
+              user: z23.string().optional(),
+              working_directory: z23.string().optional(),
+              env: z23.record(z23.string(), z23.string()).optional()
             })
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("computer_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.literal("completed")
+          z23.object({
+            type: z23.literal("computer_call"),
+            id: z23.string(),
+            status: z23.literal("completed")
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.string(),
-            arguments: import_v423.z.string(),
-            name: import_v423.z.string(),
-            server_label: import_v423.z.string(),
-            output: import_v423.z.string().nullish(),
-            error: import_v423.z.union([
-              import_v423.z.string(),
-              import_v423.z.object({
-                type: import_v423.z.string().optional(),
-                code: import_v423.z.union([import_v423.z.number(), import_v423.z.string()]).optional(),
-                message: import_v423.z.string().optional()
+          z23.object({
+            type: z23.literal("mcp_call"),
+            id: z23.string(),
+            status: z23.string(),
+            arguments: z23.string(),
+            name: z23.string(),
+            server_label: z23.string(),
+            output: z23.string().nullish(),
+            error: z23.union([
+              z23.string(),
+              z23.object({
+                type: z23.string().optional(),
+                code: z23.union([z23.number(), z23.string()]).optional(),
+                message: z23.string().optional()
               }).loose()
             ]).nullish(),
-            approval_request_id: import_v423.z.string().nullish()
+            approval_request_id: z23.string().nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_list_tools"),
-            id: import_v423.z.string(),
-            server_label: import_v423.z.string(),
-            tools: import_v423.z.array(
-              import_v423.z.object({
-                name: import_v423.z.string(),
-                description: import_v423.z.string().optional(),
-                input_schema: import_v423.z.any(),
-                annotations: import_v423.z.record(import_v423.z.string(), import_v423.z.unknown()).optional()
+          z23.object({
+            type: z23.literal("mcp_list_tools"),
+            id: z23.string(),
+            server_label: z23.string(),
+            tools: z23.array(
+              z23.object({
+                name: z23.string(),
+                description: z23.string().optional(),
+                input_schema: z23.any(),
+                annotations: z23.record(z23.string(), z23.unknown()).optional()
               })
             ),
-            error: import_v423.z.union([
-              import_v423.z.string(),
-              import_v423.z.object({
-                type: import_v423.z.string().optional(),
-                code: import_v423.z.union([import_v423.z.number(), import_v423.z.string()]).optional(),
-                message: import_v423.z.string().optional()
+            error: z23.union([
+              z23.string(),
+              z23.object({
+                type: z23.string().optional(),
+                code: z23.union([z23.number(), z23.string()]).optional(),
+                message: z23.string().optional()
               }).loose()
             ]).optional()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_approval_request"),
-            id: import_v423.z.string(),
-            server_label: import_v423.z.string(),
-            name: import_v423.z.string(),
-            arguments: import_v423.z.string(),
-            approval_request_id: import_v423.z.string().optional()
+          z23.object({
+            type: z23.literal("mcp_approval_request"),
+            id: z23.string(),
+            server_label: z23.string(),
+            name: z23.string(),
+            arguments: z23.string(),
+            approval_request_id: z23.string().optional()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("apply_patch_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed"]),
-            operation: import_v423.z.discriminatedUnion("type", [
-              import_v423.z.object({
-                type: import_v423.z.literal("create_file"),
-                path: import_v423.z.string(),
-                diff: import_v423.z.string()
+          z23.object({
+            type: z23.literal("apply_patch_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed"]),
+            operation: z23.discriminatedUnion("type", [
+              z23.object({
+                type: z23.literal("create_file"),
+                path: z23.string(),
+                diff: z23.string()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("delete_file"),
-                path: import_v423.z.string()
+              z23.object({
+                type: z23.literal("delete_file"),
+                path: z23.string()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("update_file"),
-                path: import_v423.z.string(),
-                diff: import_v423.z.string()
+              z23.object({
+                type: z23.literal("update_file"),
+                path: z23.string(),
+                diff: z23.string()
               })
             ])
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("shell_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            action: import_v423.z.object({
-              commands: import_v423.z.array(import_v423.z.string())
+          z23.object({
+            type: z23.literal("shell_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            action: z23.object({
+              commands: z23.array(z23.string())
             })
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("compaction"),
-            id: import_v423.z.string(),
-            encrypted_content: import_v423.z.string()
+          z23.object({
+            type: z23.literal("compaction"),
+            id: z23.string(),
+            encrypted_content: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("shell_call_output"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            output: import_v423.z.array(
-              import_v423.z.object({
-                stdout: import_v423.z.string(),
-                stderr: import_v423.z.string(),
-                outcome: import_v423.z.discriminatedUnion("type", [
-                  import_v423.z.object({ type: import_v423.z.literal("timeout") }),
-                  import_v423.z.object({
-                    type: import_v423.z.literal("exit"),
-                    exit_code: import_v423.z.number()
+          z23.object({
+            type: z23.literal("shell_call_output"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            output: z23.array(
+              z23.object({
+                stdout: z23.string(),
+                stderr: z23.string(),
+                outcome: z23.discriminatedUnion("type", [
+                  z23.object({ type: z23.literal("timeout") }),
+                  z23.object({
+                    type: z23.literal("exit"),
+                    exit_code: z23.number()
                   })
                 ])
               })
             )
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("tool_search_call"),
-            id: import_v423.z.string(),
-            execution: import_v423.z.enum(["server", "client"]),
-            call_id: import_v423.z.string().nullable(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            arguments: import_v423.z.unknown()
+          z23.object({
+            type: z23.literal("tool_search_call"),
+            id: z23.string(),
+            execution: z23.enum(["server", "client"]),
+            call_id: z23.string().nullable(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z23.unknown()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("tool_search_output"),
-            id: import_v423.z.string(),
-            execution: import_v423.z.enum(["server", "client"]),
-            call_id: import_v423.z.string().nullable(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            tools: import_v423.z.array(import_v423.z.record(import_v423.z.string(), jsonValueSchema2.optional()))
+          z23.object({
+            type: z23.literal("tool_search_output"),
+            id: z23.string(),
+            execution: z23.enum(["server", "client"]),
+            call_id: z23.string().nullable(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            tools: z23.array(z23.record(z23.string(), jsonValueSchema2.optional()))
           })
         ])
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.function_call_arguments.delta"),
-        item_id: import_v423.z.string(),
-        output_index: import_v423.z.number(),
-        delta: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.function_call_arguments.delta"),
+        item_id: z23.string(),
+        output_index: z23.number(),
+        delta: z23.string()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.custom_tool_call_input.delta"),
-        item_id: import_v423.z.string(),
-        output_index: import_v423.z.number(),
-        delta: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.custom_tool_call_input.delta"),
+        item_id: z23.string(),
+        output_index: z23.number(),
+        delta: z23.string()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.image_generation_call.partial_image"),
-        item_id: import_v423.z.string(),
-        output_index: import_v423.z.number(),
-        partial_image_b64: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.image_generation_call.partial_image"),
+        item_id: z23.string(),
+        output_index: z23.number(),
+        partial_image_b64: z23.string()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.code_interpreter_call_code.delta"),
-        item_id: import_v423.z.string(),
-        output_index: import_v423.z.number(),
-        delta: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.code_interpreter_call_code.delta"),
+        item_id: z23.string(),
+        output_index: z23.number(),
+        delta: z23.string()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.code_interpreter_call_code.done"),
-        item_id: import_v423.z.string(),
-        output_index: import_v423.z.number(),
-        code: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.code_interpreter_call_code.done"),
+        item_id: z23.string(),
+        output_index: z23.number(),
+        code: z23.string()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.output_text.annotation.added"),
-        annotation: import_v423.z.discriminatedUnion("type", [
-          import_v423.z.object({
-            type: import_v423.z.literal("url_citation"),
-            start_index: import_v423.z.number(),
-            end_index: import_v423.z.number(),
-            url: import_v423.z.string(),
-            title: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.output_text.annotation.added"),
+        annotation: z23.discriminatedUnion("type", [
+          z23.object({
+            type: z23.literal("url_citation"),
+            start_index: z23.number(),
+            end_index: z23.number(),
+            url: z23.string(),
+            title: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("file_citation"),
-            file_id: import_v423.z.string(),
-            filename: import_v423.z.string(),
-            index: import_v423.z.number()
+          z23.object({
+            type: z23.literal("file_citation"),
+            file_id: z23.string(),
+            filename: z23.string(),
+            index: z23.number()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("container_file_citation"),
-            container_id: import_v423.z.string(),
-            file_id: import_v423.z.string(),
-            filename: import_v423.z.string(),
-            start_index: import_v423.z.number(),
-            end_index: import_v423.z.number()
+          z23.object({
+            type: z23.literal("container_file_citation"),
+            container_id: z23.string(),
+            file_id: z23.string(),
+            filename: z23.string(),
+            start_index: z23.number(),
+            end_index: z23.number()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("file_path"),
-            file_id: import_v423.z.string(),
-            index: import_v423.z.number()
+          z23.object({
+            type: z23.literal("file_path"),
+            file_id: z23.string(),
+            index: z23.number()
           })
         ])
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.reasoning_summary_part.added"),
-        item_id: import_v423.z.string(),
-        summary_index: import_v423.z.number()
+      z23.object({
+        type: z23.literal("response.reasoning_summary_part.added"),
+        item_id: z23.string(),
+        summary_index: z23.number()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.reasoning_summary_text.delta"),
-        item_id: import_v423.z.string(),
-        summary_index: import_v423.z.number(),
-        delta: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.reasoning_summary_text.delta"),
+        item_id: z23.string(),
+        summary_index: z23.number(),
+        delta: z23.string()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.reasoning_summary_part.done"),
-        item_id: import_v423.z.string(),
-        summary_index: import_v423.z.number()
+      z23.object({
+        type: z23.literal("response.reasoning_summary_part.done"),
+        item_id: z23.string(),
+        summary_index: z23.number()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.apply_patch_call_operation_diff.delta"),
-        item_id: import_v423.z.string(),
-        output_index: import_v423.z.number(),
-        delta: import_v423.z.string(),
-        obfuscation: import_v423.z.string().nullish()
+      z23.object({
+        type: z23.literal("response.apply_patch_call_operation_diff.delta"),
+        item_id: z23.string(),
+        output_index: z23.number(),
+        delta: z23.string(),
+        obfuscation: z23.string().nullish()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("response.apply_patch_call_operation_diff.done"),
-        item_id: import_v423.z.string(),
-        output_index: import_v423.z.number(),
-        diff: import_v423.z.string()
+      z23.object({
+        type: z23.literal("response.apply_patch_call_operation_diff.done"),
+        item_id: z23.string(),
+        output_index: z23.number(),
+        diff: z23.string()
       }),
-      import_v423.z.object({
-        type: import_v423.z.literal("error"),
-        sequence_number: import_v423.z.number(),
-        error: import_v423.z.object({
-          type: import_v423.z.string(),
-          code: import_v423.z.string(),
-          message: import_v423.z.string(),
-          param: import_v423.z.string().nullish()
+      z23.object({
+        type: z23.literal("error"),
+        sequence_number: z23.number(),
+        error: z23.object({
+          type: z23.string(),
+          code: z23.string(),
+          message: z23.string(),
+          param: z23.string().nullish()
         })
       }),
-      import_v423.z.object({ type: import_v423.z.string() }).loose().transform((value) => ({
+      z23.object({ type: z23.string() }).loose().transform((value) => ({
         type: "unknown_chunk",
         message: value.type
       }))
@@ -3968,315 +4059,315 @@ var openaiResponsesChunkSchema = (0, import_provider_utils29.lazySchema)(
     ])
   )
 );
-var openaiResponsesResponseSchema = (0, import_provider_utils29.lazySchema)(
-  () => (0, import_provider_utils29.zodSchema)(
-    import_v423.z.object({
-      id: import_v423.z.string().optional(),
-      created_at: import_v423.z.number().optional(),
-      error: import_v423.z.object({
-        message: import_v423.z.string(),
-        type: import_v423.z.string(),
-        param: import_v423.z.string().nullish(),
-        code: import_v423.z.string()
+var openaiResponsesResponseSchema = lazySchema21(
+  () => zodSchema21(
+    z23.object({
+      id: z23.string().optional(),
+      created_at: z23.number().optional(),
+      error: z23.object({
+        message: z23.string(),
+        type: z23.string(),
+        param: z23.string().nullish(),
+        code: z23.string()
       }).nullish(),
-      model: import_v423.z.string().optional(),
-      output: import_v423.z.array(
-        import_v423.z.discriminatedUnion("type", [
-          import_v423.z.object({
-            type: import_v423.z.literal("message"),
-            role: import_v423.z.literal("assistant"),
-            id: import_v423.z.string(),
-            phase: import_v423.z.enum(["commentary", "final_answer"]).nullish(),
-            content: import_v423.z.array(
-              import_v423.z.object({
-                type: import_v423.z.literal("output_text"),
-                text: import_v423.z.string(),
-                logprobs: import_v423.z.array(
-                  import_v423.z.object({
-                    token: import_v423.z.string(),
-                    logprob: import_v423.z.number(),
-                    top_logprobs: import_v423.z.array(
-                      import_v423.z.object({
-                        token: import_v423.z.string(),
-                        logprob: import_v423.z.number()
+      model: z23.string().optional(),
+      output: z23.array(
+        z23.discriminatedUnion("type", [
+          z23.object({
+            type: z23.literal("message"),
+            role: z23.literal("assistant"),
+            id: z23.string(),
+            phase: z23.enum(["commentary", "final_answer"]).nullish(),
+            content: z23.array(
+              z23.object({
+                type: z23.literal("output_text"),
+                text: z23.string(),
+                logprobs: z23.array(
+                  z23.object({
+                    token: z23.string(),
+                    logprob: z23.number(),
+                    top_logprobs: z23.array(
+                      z23.object({
+                        token: z23.string(),
+                        logprob: z23.number()
                       })
                     )
                   })
                 ).nullish(),
-                annotations: import_v423.z.array(
-                  import_v423.z.discriminatedUnion("type", [
-                    import_v423.z.object({
-                      type: import_v423.z.literal("url_citation"),
-                      start_index: import_v423.z.number(),
-                      end_index: import_v423.z.number(),
-                      url: import_v423.z.string(),
-                      title: import_v423.z.string()
+                annotations: z23.array(
+                  z23.discriminatedUnion("type", [
+                    z23.object({
+                      type: z23.literal("url_citation"),
+                      start_index: z23.number(),
+                      end_index: z23.number(),
+                      url: z23.string(),
+                      title: z23.string()
                     }),
-                    import_v423.z.object({
-                      type: import_v423.z.literal("file_citation"),
-                      file_id: import_v423.z.string(),
-                      filename: import_v423.z.string(),
-                      index: import_v423.z.number()
+                    z23.object({
+                      type: z23.literal("file_citation"),
+                      file_id: z23.string(),
+                      filename: z23.string(),
+                      index: z23.number()
                     }),
-                    import_v423.z.object({
-                      type: import_v423.z.literal("container_file_citation"),
-                      container_id: import_v423.z.string(),
-                      file_id: import_v423.z.string(),
-                      filename: import_v423.z.string(),
-                      start_index: import_v423.z.number(),
-                      end_index: import_v423.z.number()
+                    z23.object({
+                      type: z23.literal("container_file_citation"),
+                      container_id: z23.string(),
+                      file_id: z23.string(),
+                      filename: z23.string(),
+                      start_index: z23.number(),
+                      end_index: z23.number()
                     }),
-                    import_v423.z.object({
-                      type: import_v423.z.literal("file_path"),
-                      file_id: import_v423.z.string(),
-                      index: import_v423.z.number()
+                    z23.object({
+                      type: z23.literal("file_path"),
+                      file_id: z23.string(),
+                      index: z23.number()
                     })
                   ])
                 )
               })
             )
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("web_search_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.string(),
-            action: import_v423.z.discriminatedUnion("type", [
-              import_v423.z.object({
-                type: import_v423.z.literal("search"),
-                query: import_v423.z.string().nullish(),
-                sources: import_v423.z.array(
-                  import_v423.z.discriminatedUnion("type", [
-                    import_v423.z.object({ type: import_v423.z.literal("url"), url: import_v423.z.string() }),
-                    import_v423.z.object({
-                      type: import_v423.z.literal("api"),
-                      name: import_v423.z.string()
+          z23.object({
+            type: z23.literal("web_search_call"),
+            id: z23.string(),
+            status: z23.string(),
+            action: z23.discriminatedUnion("type", [
+              z23.object({
+                type: z23.literal("search"),
+                query: z23.string().nullish(),
+                sources: z23.array(
+                  z23.discriminatedUnion("type", [
+                    z23.object({ type: z23.literal("url"), url: z23.string() }),
+                    z23.object({
+                      type: z23.literal("api"),
+                      name: z23.string()
                     })
                   ])
                 ).nullish()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("open_page"),
-                url: import_v423.z.string().nullish()
+              z23.object({
+                type: z23.literal("open_page"),
+                url: z23.string().nullish()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("find_in_page"),
-                url: import_v423.z.string().nullish(),
-                pattern: import_v423.z.string().nullish()
+              z23.object({
+                type: z23.literal("find_in_page"),
+                url: z23.string().nullish(),
+                pattern: z23.string().nullish()
               })
             ]).nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("file_search_call"),
-            id: import_v423.z.string(),
-            queries: import_v423.z.array(import_v423.z.string()),
-            results: import_v423.z.array(
-              import_v423.z.object({
-                attributes: import_v423.z.record(
-                  import_v423.z.string(),
-                  import_v423.z.union([import_v423.z.string(), import_v423.z.number(), import_v423.z.boolean()])
+          z23.object({
+            type: z23.literal("file_search_call"),
+            id: z23.string(),
+            queries: z23.array(z23.string()),
+            results: z23.array(
+              z23.object({
+                attributes: z23.record(
+                  z23.string(),
+                  z23.union([z23.string(), z23.number(), z23.boolean()])
                 ),
-                file_id: import_v423.z.string(),
-                filename: import_v423.z.string(),
-                score: import_v423.z.number(),
-                text: import_v423.z.string()
+                file_id: z23.string(),
+                filename: z23.string(),
+                score: z23.number(),
+                text: z23.string()
               })
             ).nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("code_interpreter_call"),
-            id: import_v423.z.string(),
-            code: import_v423.z.string().nullable(),
-            container_id: import_v423.z.string(),
-            outputs: import_v423.z.array(
-              import_v423.z.discriminatedUnion("type", [
-                import_v423.z.object({ type: import_v423.z.literal("logs"), logs: import_v423.z.string() }),
-                import_v423.z.object({ type: import_v423.z.literal("image"), url: import_v423.z.string() })
+          z23.object({
+            type: z23.literal("code_interpreter_call"),
+            id: z23.string(),
+            code: z23.string().nullable(),
+            container_id: z23.string(),
+            outputs: z23.array(
+              z23.discriminatedUnion("type", [
+                z23.object({ type: z23.literal("logs"), logs: z23.string() }),
+                z23.object({ type: z23.literal("image"), url: z23.string() })
               ])
             ).nullable()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("image_generation_call"),
-            id: import_v423.z.string(),
-            result: import_v423.z.string()
+          z23.object({
+            type: z23.literal("image_generation_call"),
+            id: z23.string(),
+            result: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("local_shell_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            action: import_v423.z.object({
-              type: import_v423.z.literal("exec"),
-              command: import_v423.z.array(import_v423.z.string()),
-              timeout_ms: import_v423.z.number().optional(),
-              user: import_v423.z.string().optional(),
-              working_directory: import_v423.z.string().optional(),
-              env: import_v423.z.record(import_v423.z.string(), import_v423.z.string()).optional()
+          z23.object({
+            type: z23.literal("local_shell_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            action: z23.object({
+              type: z23.literal("exec"),
+              command: z23.array(z23.string()),
+              timeout_ms: z23.number().optional(),
+              user: z23.string().optional(),
+              working_directory: z23.string().optional(),
+              env: z23.record(z23.string(), z23.string()).optional()
             })
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("function_call"),
-            call_id: import_v423.z.string(),
-            name: import_v423.z.string(),
-            arguments: import_v423.z.string(),
-            id: import_v423.z.string()
+          z23.object({
+            type: z23.literal("function_call"),
+            call_id: z23.string(),
+            name: z23.string(),
+            arguments: z23.string(),
+            id: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("custom_tool_call"),
-            call_id: import_v423.z.string(),
-            name: import_v423.z.string(),
-            input: import_v423.z.string(),
-            id: import_v423.z.string()
+          z23.object({
+            type: z23.literal("custom_tool_call"),
+            call_id: z23.string(),
+            name: z23.string(),
+            input: z23.string(),
+            id: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("computer_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.string().optional()
+          z23.object({
+            type: z23.literal("computer_call"),
+            id: z23.string(),
+            status: z23.string().optional()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("reasoning"),
-            id: import_v423.z.string(),
-            encrypted_content: import_v423.z.string().nullish(),
-            summary: import_v423.z.array(
-              import_v423.z.object({
-                type: import_v423.z.literal("summary_text"),
-                text: import_v423.z.string()
+          z23.object({
+            type: z23.literal("reasoning"),
+            id: z23.string(),
+            encrypted_content: z23.string().nullish(),
+            summary: z23.array(
+              z23.object({
+                type: z23.literal("summary_text"),
+                text: z23.string()
               })
             )
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_call"),
-            id: import_v423.z.string(),
-            status: import_v423.z.string(),
-            arguments: import_v423.z.string(),
-            name: import_v423.z.string(),
-            server_label: import_v423.z.string(),
-            output: import_v423.z.string().nullish(),
-            error: import_v423.z.union([
-              import_v423.z.string(),
-              import_v423.z.object({
-                type: import_v423.z.string().optional(),
-                code: import_v423.z.union([import_v423.z.number(), import_v423.z.string()]).optional(),
-                message: import_v423.z.string().optional()
+          z23.object({
+            type: z23.literal("mcp_call"),
+            id: z23.string(),
+            status: z23.string(),
+            arguments: z23.string(),
+            name: z23.string(),
+            server_label: z23.string(),
+            output: z23.string().nullish(),
+            error: z23.union([
+              z23.string(),
+              z23.object({
+                type: z23.string().optional(),
+                code: z23.union([z23.number(), z23.string()]).optional(),
+                message: z23.string().optional()
               }).loose()
             ]).nullish(),
-            approval_request_id: import_v423.z.string().nullish()
+            approval_request_id: z23.string().nullish()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_list_tools"),
-            id: import_v423.z.string(),
-            server_label: import_v423.z.string(),
-            tools: import_v423.z.array(
-              import_v423.z.object({
-                name: import_v423.z.string(),
-                description: import_v423.z.string().optional(),
-                input_schema: import_v423.z.any(),
-                annotations: import_v423.z.record(import_v423.z.string(), import_v423.z.unknown()).optional()
+          z23.object({
+            type: z23.literal("mcp_list_tools"),
+            id: z23.string(),
+            server_label: z23.string(),
+            tools: z23.array(
+              z23.object({
+                name: z23.string(),
+                description: z23.string().optional(),
+                input_schema: z23.any(),
+                annotations: z23.record(z23.string(), z23.unknown()).optional()
               })
             ),
-            error: import_v423.z.union([
-              import_v423.z.string(),
-              import_v423.z.object({
-                type: import_v423.z.string().optional(),
-                code: import_v423.z.union([import_v423.z.number(), import_v423.z.string()]).optional(),
-                message: import_v423.z.string().optional()
+            error: z23.union([
+              z23.string(),
+              z23.object({
+                type: z23.string().optional(),
+                code: z23.union([z23.number(), z23.string()]).optional(),
+                message: z23.string().optional()
               }).loose()
             ]).optional()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("mcp_approval_request"),
-            id: import_v423.z.string(),
-            server_label: import_v423.z.string(),
-            name: import_v423.z.string(),
-            arguments: import_v423.z.string(),
-            approval_request_id: import_v423.z.string().optional()
+          z23.object({
+            type: z23.literal("mcp_approval_request"),
+            id: z23.string(),
+            server_label: z23.string(),
+            name: z23.string(),
+            arguments: z23.string(),
+            approval_request_id: z23.string().optional()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("apply_patch_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed"]),
-            operation: import_v423.z.discriminatedUnion("type", [
-              import_v423.z.object({
-                type: import_v423.z.literal("create_file"),
-                path: import_v423.z.string(),
-                diff: import_v423.z.string()
+          z23.object({
+            type: z23.literal("apply_patch_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed"]),
+            operation: z23.discriminatedUnion("type", [
+              z23.object({
+                type: z23.literal("create_file"),
+                path: z23.string(),
+                diff: z23.string()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("delete_file"),
-                path: import_v423.z.string()
+              z23.object({
+                type: z23.literal("delete_file"),
+                path: z23.string()
               }),
-              import_v423.z.object({
-                type: import_v423.z.literal("update_file"),
-                path: import_v423.z.string(),
-                diff: import_v423.z.string()
+              z23.object({
+                type: z23.literal("update_file"),
+                path: z23.string(),
+                diff: z23.string()
               })
             ])
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("shell_call"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            action: import_v423.z.object({
-              commands: import_v423.z.array(import_v423.z.string())
+          z23.object({
+            type: z23.literal("shell_call"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            action: z23.object({
+              commands: z23.array(z23.string())
             })
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("compaction"),
-            id: import_v423.z.string(),
-            encrypted_content: import_v423.z.string()
+          z23.object({
+            type: z23.literal("compaction"),
+            id: z23.string(),
+            encrypted_content: z23.string()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("shell_call_output"),
-            id: import_v423.z.string(),
-            call_id: import_v423.z.string(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            output: import_v423.z.array(
-              import_v423.z.object({
-                stdout: import_v423.z.string(),
-                stderr: import_v423.z.string(),
-                outcome: import_v423.z.discriminatedUnion("type", [
-                  import_v423.z.object({ type: import_v423.z.literal("timeout") }),
-                  import_v423.z.object({
-                    type: import_v423.z.literal("exit"),
-                    exit_code: import_v423.z.number()
+          z23.object({
+            type: z23.literal("shell_call_output"),
+            id: z23.string(),
+            call_id: z23.string(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            output: z23.array(
+              z23.object({
+                stdout: z23.string(),
+                stderr: z23.string(),
+                outcome: z23.discriminatedUnion("type", [
+                  z23.object({ type: z23.literal("timeout") }),
+                  z23.object({
+                    type: z23.literal("exit"),
+                    exit_code: z23.number()
                   })
                 ])
               })
             )
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("tool_search_call"),
-            id: import_v423.z.string(),
-            execution: import_v423.z.enum(["server", "client"]),
-            call_id: import_v423.z.string().nullable(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            arguments: import_v423.z.unknown()
+          z23.object({
+            type: z23.literal("tool_search_call"),
+            id: z23.string(),
+            execution: z23.enum(["server", "client"]),
+            call_id: z23.string().nullable(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            arguments: z23.unknown()
           }),
-          import_v423.z.object({
-            type: import_v423.z.literal("tool_search_output"),
-            id: import_v423.z.string(),
-            execution: import_v423.z.enum(["server", "client"]),
-            call_id: import_v423.z.string().nullable(),
-            status: import_v423.z.enum(["in_progress", "completed", "incomplete"]),
-            tools: import_v423.z.array(import_v423.z.record(import_v423.z.string(), jsonValueSchema2.optional()))
+          z23.object({
+            type: z23.literal("tool_search_output"),
+            id: z23.string(),
+            execution: z23.enum(["server", "client"]),
+            call_id: z23.string().nullable(),
+            status: z23.enum(["in_progress", "completed", "incomplete"]),
+            tools: z23.array(z23.record(z23.string(), jsonValueSchema2.optional()))
           })
         ])
       ).optional(),
-      service_tier: import_v423.z.string().nullish(),
-      incomplete_details: import_v423.z.object({ reason: import_v423.z.string() }).nullish(),
-      usage: import_v423.z.object({
-        input_tokens: import_v423.z.number(),
-        input_tokens_details: import_v423.z.object({ cached_tokens: import_v423.z.number().nullish() }).nullish(),
-        output_tokens: import_v423.z.number(),
-        output_tokens_details: import_v423.z.object({ reasoning_tokens: import_v423.z.number().nullish() }).nullish()
+      service_tier: z23.string().nullish(),
+      incomplete_details: z23.object({ reason: z23.string() }).nullish(),
+      usage: z23.object({
+        input_tokens: z23.number(),
+        input_tokens_details: z23.object({ cached_tokens: z23.number().nullish() }).nullish(),
+        output_tokens: z23.number(),
+        output_tokens_details: z23.object({ reasoning_tokens: z23.number().nullish() }).nullish()
       }).optional()
     })
   )
 );
 
 // src/responses/openai-responses-options.ts
-var import_provider_utils30 = require("@ai-sdk/provider-utils");
-var import_v424 = require("zod/v4");
+import { lazySchema as lazySchema22, zodSchema as zodSchema22 } from "@ai-sdk/provider-utils";
+import { z as z24 } from "zod/v4";
 var TOP_LOGPROBS_MAX = 20;
 var openaiResponsesReasoningModelIds = [
   "o1",
@@ -4341,9 +4432,9 @@ var openaiResponsesModelIds = [
   "gpt-5-chat-latest",
   ...openaiResponsesReasoningModelIds
 ];
-var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.lazySchema)(
-  () => (0, import_provider_utils30.zodSchema)(
-    import_v424.z.object({
+var openaiLanguageModelResponsesOptionsSchema = lazySchema22(
+  () => zodSchema22(
+    z24.object({
       /**
        * The ID of the OpenAI Conversation to continue.
        * You must create a conversation first via the OpenAI API.
@@ -4351,13 +4442,13 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.lazy
        * Defaults to `undefined`.
        * @see https://platform.openai.com/docs/api-reference/conversations/create
        */
-      conversation: import_v424.z.string().nullish(),
+      conversation: z24.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_v424.z.array(
-        import_v424.z.enum([
+      include: z24.array(
+        z24.enum([
           "reasoning.encrypted_content",
           // handled internally by default, only needed for unknown reasoning models
           "file_search_call.results",
@@ -4369,7 +4460,7 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.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_v424.z.string().nullish(),
+      instructions: z24.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
@@ -4384,30 +4475,30 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.lazy
        * @see https://platform.openai.com/docs/api-reference/responses/create
        * @see https://cookbook.openai.com/examples/using_logprobs
        */
-      logprobs: import_v424.z.union([import_v424.z.boolean(), import_v424.z.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+      logprobs: z24.union([z24.boolean(), z24.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_v424.z.number().nullish(),
+      maxToolCalls: z24.number().nullish(),
       /**
        * Additional metadata to store with the generation.
        */
-      metadata: import_v424.z.any().nullish(),
+      metadata: z24.any().nullish(),
       /**
        * Whether to use parallel tool calls. Defaults to `true`.
        */
-      parallelToolCalls: import_v424.z.boolean().nullish(),
+      parallelToolCalls: z24.boolean().nullish(),
       /**
        * The ID of the previous response. You can use it to continue a conversation.
        * Defaults to `undefined`.
        */
-      previousResponseId: import_v424.z.string().nullish(),
+      previousResponseId: z24.string().nullish(),
       /**
        * Sets a cache key to tie this prompt to cached prefixes for better caching performance.
        */
-      promptCacheKey: import_v424.z.string().nullish(),
+      promptCacheKey: z24.string().nullish(),
       /**
        * The retention policy for the prompt cache.
        * - 'in_memory': Default. Standard prompt caching behavior.
@@ -4416,7 +4507,7 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.lazy
        *
        * @default 'in_memory'
        */
-      promptCacheRetention: import_v424.z.enum(["in_memory", "24h"]).nullish(),
+      promptCacheRetention: z24.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.
@@ -4427,17 +4518,17 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.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_v424.z.string().nullish(),
+      reasoningEffort: z24.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_v424.z.string().nullish(),
+      reasoningSummary: z24.string().nullish(),
       /**
        * The identifier for safety monitoring and tracking.
        */
-      safetyIdentifier: import_v424.z.string().nullish(),
+      safetyIdentifier: z24.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).
@@ -4445,34 +4536,34 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.lazy
        *
        * Defaults to 'auto'.
        */
-      serviceTier: import_v424.z.enum(["auto", "flex", "priority", "default"]).nullish(),
+      serviceTier: z24.enum(["auto", "flex", "priority", "default"]).nullish(),
       /**
        * Whether to store the generation. Defaults to `true`.
        */
-      store: import_v424.z.boolean().nullish(),
+      store: z24.boolean().nullish(),
       /**
        * Whether to use strict JSON schema validation.
        * Defaults to `true`.
        */
-      strictJsonSchema: import_v424.z.boolean().nullish(),
+      strictJsonSchema: z24.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_v424.z.enum(["low", "medium", "high"]).nullish(),
+      textVerbosity: z24.enum(["low", "medium", "high"]).nullish(),
       /**
        * Controls output truncation. 'auto' (default) performs truncation automatically;
        * 'disabled' turns truncation off.
        */
-      truncation: import_v424.z.enum(["auto", "disabled"]).nullish(),
+      truncation: z24.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_v424.z.string().nullish(),
+      user: z24.string().nullish(),
       /**
        * Override the system message mode for this model.
        * - 'system': Use the 'system' role for system messages (default for most models)
@@ -4481,7 +4572,7 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.lazy
        *
        * If not specified, the mode is automatically determined based on the model.
        */
-      systemMessageMode: import_v424.z.enum(["system", "developer", "remove"]).optional(),
+      systemMessageMode: z24.enum(["system", "developer", "remove"]).optional(),
       /**
        * Force treating this model as a reasoning model.
        *
@@ -4491,14 +4582,14 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.lazy
        * When enabled, the SDK applies reasoning-model parameter compatibility rules
        * and defaults `systemMessageMode` to `developer` unless overridden.
        */
-      forceReasoning: import_v424.z.boolean().optional(),
+      forceReasoning: z24.boolean().optional(),
       /**
        * Enable server-side context management (compaction).
        */
-      contextManagement: import_v424.z.array(
-        import_v424.z.object({
-          type: import_v424.z.literal("compaction"),
-          compactThreshold: import_v424.z.number()
+      contextManagement: z24.array(
+        z24.object({
+          type: z24.literal("compaction"),
+          compactThreshold: z24.number()
         })
       ).nullish()
     })
@@ -4506,8 +4597,13 @@ var openaiLanguageModelResponsesOptionsSchema = (0, import_provider_utils30.lazy
 );
 
 // src/responses/openai-responses-prepare-tools.ts
-var import_provider7 = require("@ai-sdk/provider");
-var import_provider_utils31 = 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";
 async function prepareResponsesTools({
   tools,
   toolChoice,
@@ -4540,7 +4636,7 @@ async function prepareResponsesTools({
       case "provider": {
         switch (tool.id) {
           case "openai.file_search": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: fileSearchArgsSchema
             });
@@ -4563,7 +4659,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.shell": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: shellArgsSchema
             });
@@ -4582,7 +4678,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.web_search_preview": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: webSearchPreviewArgsSchema
             });
@@ -4594,7 +4690,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.web_search": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: webSearchArgsSchema
             });
@@ -4608,7 +4704,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.code_interpreter": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: codeInterpreterArgsSchema
             });
@@ -4619,7 +4715,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.image_generation": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: imageGenerationArgsSchema
             });
@@ -4642,7 +4738,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.mcp": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: mcpArgsSchema
             });
@@ -4668,7 +4764,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.custom": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: customArgsSchema
             });
@@ -4682,7 +4778,7 @@ async function prepareResponsesTools({
             break;
           }
           case "openai.tool_search": {
-            const args = await (0, import_provider_utils31.validateTypes)({
+            const args = await validateTypes2({
               value: tool.args,
               schema: toolSearchArgsSchema
             });
@@ -4724,7 +4820,7 @@ async function prepareResponsesTools({
     }
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider7.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError5({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -4764,7 +4860,7 @@ function mapShellSkills(skills) {
       var _a, _b;
       return skill.type === "skillReference" ? {
         type: "skill_reference",
-        skill_id: (0, import_provider_utils31.resolveProviderReference)({
+        skill_id: resolveProviderReference3({
           reference: (_a = skill.providerReference) != null ? _a : {},
           provider: "openai"
         }),
@@ -4847,19 +4943,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_utils32.parseProviderOptions)({
+    let openaiOptions = await parseProviderOptions6({
       provider: providerOptionsName,
       providerOptions,
       schema: openaiLanguageModelResponsesOptionsSchema
     });
     if (openaiOptions == null && providerOptionsName !== "openai") {
-      openaiOptions = await (0, import_provider_utils32.parseProviderOptions)({
+      openaiOptions = await parseProviderOptions6({
         provider: "openai",
         providerOptions,
         schema: openaiLanguageModelResponsesOptionsSchema
       });
     }
-    const resolvedReasoningEffort = (_a = openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null ? _a : (0, import_provider_utils32.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({
@@ -4868,7 +4964,7 @@ var OpenAIResponsesLanguageModel = class {
         details: "conversation and previousResponseId cannot be used together"
       });
     }
-    const toolNameMapping = (0, import_provider_utils32.createToolNameMapping)({
+    const toolNameMapping = createToolNameMapping({
       tools,
       providerToolNames: {
         "openai.code_interpreter": "code_interpreter",
@@ -5082,19 +5178,19 @@ var OpenAIResponsesLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils32.postJsonToApi)({
+    } = await postJsonToApi5({
       url,
-      headers: (0, import_provider_utils32.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders6(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils32.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,
@@ -5263,7 +5359,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_utils32.generateId)(),
+                  id: (_i = (_h = (_g = this.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : generateId2(),
                   url: annotation.url,
                   title: annotation.title
                 });
@@ -5271,7 +5367,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_utils32.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,
@@ -5287,7 +5383,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_utils32.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,
@@ -5303,7 +5399,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_utils32.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,
@@ -5407,7 +5503,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_utils32.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",
@@ -5562,18 +5658,18 @@ var OpenAIResponsesLanguageModel = class {
       providerOptionsName,
       isShellProviderExecuted
     } = await this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils32.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi5({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils32.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders6(this.config.headers(), options.headers),
       body: {
         ...body,
         stream: true
       },
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils32.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler3(
         openaiResponsesChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -6053,7 +6149,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_utils32.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,
@@ -6356,7 +6452,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_utils32.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
                 });
@@ -6364,7 +6460,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_utils32.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,
@@ -6380,7 +6476,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_utils32.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,
@@ -6396,7 +6492,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_utils32.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,
@@ -6509,16 +6605,21 @@ function escapeJSONDelta(delta) {
 }
 
 // src/speech/openai-speech-model.ts
-var import_provider_utils34 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders7,
+  createBinaryResponseHandler,
+  parseProviderOptions as parseProviderOptions7,
+  postJsonToApi as postJsonToApi6
+} from "@ai-sdk/provider-utils";
 
 // src/speech/openai-speech-options.ts
-var import_provider_utils33 = require("@ai-sdk/provider-utils");
-var import_v425 = require("zod/v4");
-var openaiSpeechModelOptionsSchema = (0, import_provider_utils33.lazySchema)(
-  () => (0, import_provider_utils33.zodSchema)(
-    import_v425.z.object({
-      instructions: import_v425.z.string().nullish(),
-      speed: import_v425.z.number().min(0.25).max(4).default(1).nullish()
+import { lazySchema as lazySchema23, zodSchema as zodSchema23 } from "@ai-sdk/provider-utils";
+import { z as z25 } from "zod/v4";
+var openaiSpeechModelOptionsSchema = lazySchema23(
+  () => zodSchema23(
+    z25.object({
+      instructions: z25.string().nullish(),
+      speed: z25.number().min(0.25).max(4).default(1).nullish()
     })
   )
 );
@@ -6543,7 +6644,7 @@ var OpenAISpeechModel = class {
     providerOptions
   }) {
     const warnings = [];
-    const openAIOptions = await (0, import_provider_utils34.parseProviderOptions)({
+    const openAIOptions = await parseProviderOptions7({
       provider: "openai",
       providerOptions,
       schema: openaiSpeechModelOptionsSchema
@@ -6596,15 +6697,15 @@ var OpenAISpeechModel = class {
       value: audio,
       responseHeaders,
       rawValue: rawResponse
-    } = await (0, import_provider_utils34.postJsonToApi)({
+    } = await postJsonToApi6({
       url: this.config.url({
         path: "/audio/speech",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils34.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders7(this.config.headers(), options.headers),
       body: requestBody,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils34.createBinaryResponseHandler)(),
+      successfulResponseHandler: createBinaryResponseHandler(),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -6625,36 +6726,43 @@ var OpenAISpeechModel = class {
 };
 
 // src/transcription/openai-transcription-model.ts
-var import_provider_utils37 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders8,
+  convertBase64ToUint8Array as convertBase64ToUint8Array3,
+  createJsonResponseHandler as createJsonResponseHandler7,
+  mediaTypeToExtension,
+  parseProviderOptions as parseProviderOptions8,
+  postFormDataToApi as postFormDataToApi3
+} from "@ai-sdk/provider-utils";
 
 // src/transcription/openai-transcription-api.ts
-var import_provider_utils35 = require("@ai-sdk/provider-utils");
-var import_v426 = require("zod/v4");
-var openaiTranscriptionResponseSchema = (0, import_provider_utils35.lazySchema)(
-  () => (0, import_provider_utils35.zodSchema)(
-    import_v426.z.object({
-      text: import_v426.z.string(),
-      language: import_v426.z.string().nullish(),
-      duration: import_v426.z.number().nullish(),
-      words: import_v426.z.array(
-        import_v426.z.object({
-          word: import_v426.z.string(),
-          start: import_v426.z.number(),
-          end: import_v426.z.number()
+import { lazySchema as lazySchema24, zodSchema as zodSchema24 } from "@ai-sdk/provider-utils";
+import { z as z26 } from "zod/v4";
+var openaiTranscriptionResponseSchema = lazySchema24(
+  () => zodSchema24(
+    z26.object({
+      text: z26.string(),
+      language: z26.string().nullish(),
+      duration: z26.number().nullish(),
+      words: z26.array(
+        z26.object({
+          word: z26.string(),
+          start: z26.number(),
+          end: z26.number()
         })
       ).nullish(),
-      segments: import_v426.z.array(
-        import_v426.z.object({
-          id: import_v426.z.number(),
-          seek: import_v426.z.number(),
-          start: import_v426.z.number(),
-          end: import_v426.z.number(),
-          text: import_v426.z.string(),
-          tokens: import_v426.z.array(import_v426.z.number()),
-          temperature: import_v426.z.number(),
-          avg_logprob: import_v426.z.number(),
-          compression_ratio: import_v426.z.number(),
-          no_speech_prob: import_v426.z.number()
+      segments: z26.array(
+        z26.object({
+          id: z26.number(),
+          seek: z26.number(),
+          start: z26.number(),
+          end: z26.number(),
+          text: z26.string(),
+          tokens: z26.array(z26.number()),
+          temperature: z26.number(),
+          avg_logprob: z26.number(),
+          compression_ratio: z26.number(),
+          no_speech_prob: z26.number()
         })
       ).nullish()
     })
@@ -6662,33 +6770,33 @@ var openaiTranscriptionResponseSchema = (0, import_provider_utils35.lazySchema)(
 );
 
 // src/transcription/openai-transcription-options.ts
-var import_provider_utils36 = require("@ai-sdk/provider-utils");
-var import_v427 = require("zod/v4");
-var openAITranscriptionModelOptions = (0, import_provider_utils36.lazySchema)(
-  () => (0, import_provider_utils36.zodSchema)(
-    import_v427.z.object({
+import { lazySchema as lazySchema25, zodSchema as zodSchema25 } from "@ai-sdk/provider-utils";
+import { z as z27 } from "zod/v4";
+var openAITranscriptionModelOptions = lazySchema25(
+  () => zodSchema25(
+    z27.object({
       /**
        * Additional information to include in the transcription response.
        */
-      include: import_v427.z.array(import_v427.z.string()).optional(),
+      include: z27.array(z27.string()).optional(),
       /**
        * The language of the input audio in ISO-639-1 format.
        */
-      language: import_v427.z.string().optional(),
+      language: z27.string().optional(),
       /**
        * An optional text to guide the model's style or continue a previous audio segment.
        */
-      prompt: import_v427.z.string().optional(),
+      prompt: z27.string().optional(),
       /**
        * The sampling temperature, between 0 and 1.
        * @default 0
        */
-      temperature: import_v427.z.number().min(0).max(1).default(0).optional(),
+      temperature: z27.number().min(0).max(1).default(0).optional(),
       /**
        * The timestamp granularities to populate for this transcription.
        * @default ['segment']
        */
-      timestampGranularities: import_v427.z.array(import_v427.z.enum(["word", "segment"])).default(["segment"]).optional()
+      timestampGranularities: z27.array(z27.enum(["word", "segment"])).default(["segment"]).optional()
     })
   )
 );
@@ -6768,15 +6876,15 @@ var OpenAITranscriptionModel = class {
     providerOptions
   }) {
     const warnings = [];
-    const openAIOptions = await (0, import_provider_utils37.parseProviderOptions)({
+    const openAIOptions = await parseProviderOptions8({
       provider: "openai",
       providerOptions,
       schema: openAITranscriptionModelOptions
     });
     const formData = new FormData();
-    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([(0, import_provider_utils37.convertBase64ToUint8Array)(audio)]);
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array3(audio)]);
     formData.append("model", this.modelId);
-    const fileExtension = (0, import_provider_utils37.mediaTypeToExtension)(mediaType);
+    const fileExtension = mediaTypeToExtension(mediaType);
     formData.append(
       "file",
       new File([blob], "audio", { type: mediaType }),
@@ -6821,15 +6929,15 @@ var OpenAITranscriptionModel = class {
       value: response,
       responseHeaders,
       rawValue: rawResponse
-    } = await (0, import_provider_utils37.postFormDataToApi)({
+    } = await postFormDataToApi3({
       url: this.config.url({
         path: "/audio/transcriptions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils37.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders8(this.config.headers(), options.headers),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils37.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler7(
         openaiTranscriptionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -6861,31 +6969,36 @@ var OpenAITranscriptionModel = class {
 };
 
 // src/skills/openai-skills.ts
-var import_provider_utils39 = require("@ai-sdk/provider-utils");
+import {
+  combineHeaders as combineHeaders9,
+  convertBase64ToUint8Array as convertBase64ToUint8Array4,
+  createJsonResponseHandler as createJsonResponseHandler8,
+  postFormDataToApi as postFormDataToApi4
+} from "@ai-sdk/provider-utils";
 
 // src/skills/openai-skills-api.ts
-var import_provider_utils38 = require("@ai-sdk/provider-utils");
-var import_v428 = require("zod/v4");
-var openaiSkillResponseSchema = (0, import_provider_utils38.lazySchema)(
-  () => (0, import_provider_utils38.zodSchema)(
-    import_v428.z.object({
-      id: import_v428.z.string(),
-      name: import_v428.z.string().nullish(),
-      description: import_v428.z.string().nullish(),
-      default_version: import_v428.z.string().nullish(),
-      latest_version: import_v428.z.string().nullish(),
-      created_at: import_v428.z.number(),
-      updated_at: import_v428.z.number().nullish()
+import { lazySchema as lazySchema26, zodSchema as zodSchema26 } from "@ai-sdk/provider-utils";
+import { z as z28 } from "zod/v4";
+var openaiSkillResponseSchema = lazySchema26(
+  () => zodSchema26(
+    z28.object({
+      id: z28.string(),
+      name: z28.string().nullish(),
+      description: z28.string().nullish(),
+      default_version: z28.string().nullish(),
+      latest_version: z28.string().nullish(),
+      created_at: z28.number(),
+      updated_at: z28.number().nullish()
     })
   )
 );
-var openaiSkillVersionResponseSchema = (0, import_provider_utils38.lazySchema)(
-  () => (0, import_provider_utils38.zodSchema)(
-    import_v428.z.object({
-      id: import_v428.z.string(),
-      version: import_v428.z.string().nullish(),
-      name: import_v428.z.string().nullish(),
-      description: import_v428.z.string().nullish()
+var openaiSkillVersionResponseSchema = lazySchema26(
+  () => zodSchema26(
+    z28.object({
+      id: z28.string(),
+      version: z28.string().nullish(),
+      name: z28.string().nullish(),
+      description: z28.string().nullish()
     })
   )
 );
@@ -6909,15 +7022,15 @@ var OpenAISkills = class {
     }
     const formData = new FormData();
     for (const file of params.files) {
-      const content = typeof file.content === "string" ? (0, import_provider_utils39.convertBase64ToUint8Array)(file.content) : file.content;
+      const content = typeof file.content === "string" ? convertBase64ToUint8Array4(file.content) : file.content;
       formData.append("files[]", new Blob([content]), file.path);
     }
-    const { value: response } = await (0, import_provider_utils39.postFormDataToApi)({
+    const { value: response } = await postFormDataToApi4({
       url: this.config.url({ path: "/skills" }),
-      headers: (0, import_provider_utils39.combineHeaders)(this.config.headers()),
+      headers: combineHeaders9(this.config.headers()),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils39.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler8(
         openaiSkillResponseSchema
       ),
       fetch: this.config.fetch
@@ -6940,21 +7053,21 @@ var OpenAISkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.0-beta.29" : "0.0.0-test";
+var VERSION = true ? "4.0.0-beta.30" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {
   var _a, _b;
-  const baseURL = (_a = (0, import_provider_utils40.withoutTrailingSlash)(
-    (0, import_provider_utils40.loadOptionalSetting)({
+  const baseURL = (_a = withoutTrailingSlash(
+    loadOptionalSetting({
       settingValue: options.baseURL,
       environmentVariableName: "OPENAI_BASE_URL"
     })
   )) != null ? _a : "https://api.openai.com/v1";
   const providerName = (_b = options.name) != null ? _b : "openai";
-  const getHeaders = () => (0, import_provider_utils40.withUserAgentSuffix)(
+  const getHeaders = () => withUserAgentSuffix(
     {
-      Authorization: `Bearer ${(0, import_provider_utils40.loadApiKey)({
+      Authorization: `Bearer ${loadApiKey({
         apiKey: options.apiKey,
         environmentVariableName: "OPENAI_API_KEY",
         description: "OpenAI"
@@ -7055,10 +7168,9 @@ function createOpenAI(options = {}) {
   return provider;
 }
 var openai = createOpenAI();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   VERSION,
   createOpenAI,
   openai
-});
+};
 //# sourceMappingURL=index.js.map