ai 5.0.66 → 5.0.68

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name17 in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -795,7 +785,7 @@ function detectMediaType({
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "5.0.66" : "0.0.0-test";
+var VERSION = true ? "5.0.68" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({ url }) => {
@@ -838,7 +828,7 @@ var createDefaultDownloadFunction = (download2 = download) => (requestedDownload
 // src/prompt/data-content.ts
 var import_provider19 = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var z = __toESM(require("zod/v4"));
+var import_v4 = require("zod/v4");
 
 // src/prompt/split-data-url.ts
 function splitDataUrl(dataUrl) {
@@ -857,11 +847,11 @@ function splitDataUrl(dataUrl) {
 }
 
 // src/prompt/data-content.ts
-var dataContentSchema = z.union([
-  z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
-  z.custom(
+var dataContentSchema = import_v4.z.union([
+  import_v4.z.string(),
+  import_v4.z.instanceof(Uint8Array),
+  import_v4.z.instanceof(ArrayBuffer),
+  import_v4.z.custom(
     // Buffer might not be available in some environments such as CloudFlare:
     (value) => {
       var _a17, _b;
@@ -1250,8 +1240,8 @@ function prepareCallSettings({
 var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
 // src/util/is-non-empty-object.ts
-function isNonEmptyObject(object7) {
-  return object7 != null && Object.keys(object7).length > 0;
+function isNonEmptyObject(object2) {
+  return object2 != null && Object.keys(object2).length > 0;
 }
 
 // src/prompt/prepare-tools-and-tool-choice.ts
@@ -1303,132 +1293,132 @@ function prepareToolsAndToolChoice({
 // src/prompt/standardize-prompt.ts
 var import_provider20 = require("@ai-sdk/provider");
 var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var z6 = __toESM(require("zod/v4"));
+var import_v46 = require("zod/v4");
 
 // src/prompt/message.ts
-var z5 = __toESM(require("zod/v4"));
+var import_v45 = require("zod/v4");
 
 // src/types/provider-metadata.ts
-var z3 = __toESM(require("zod/v4"));
+var import_v43 = require("zod/v4");
 
 // src/types/json-value.ts
-var z2 = __toESM(require("zod/v4"));
-var jsonValueSchema = z2.lazy(
-  () => z2.union([
-    z2.null(),
-    z2.string(),
-    z2.number(),
-    z2.boolean(),
-    z2.record(z2.string(), jsonValueSchema),
-    z2.array(jsonValueSchema)
+var import_v42 = require("zod/v4");
+var jsonValueSchema = import_v42.z.lazy(
+  () => import_v42.z.union([
+    import_v42.z.null(),
+    import_v42.z.string(),
+    import_v42.z.number(),
+    import_v42.z.boolean(),
+    import_v42.z.record(import_v42.z.string(), jsonValueSchema),
+    import_v42.z.array(jsonValueSchema)
   ])
 );
 
 // src/types/provider-metadata.ts
-var providerMetadataSchema = z3.record(
-  z3.string(),
-  z3.record(z3.string(), jsonValueSchema)
+var providerMetadataSchema = import_v43.z.record(
+  import_v43.z.string(),
+  import_v43.z.record(import_v43.z.string(), jsonValueSchema)
 );
 
 // src/prompt/content-part.ts
-var z4 = __toESM(require("zod/v4"));
-var textPartSchema = z4.object({
-  type: z4.literal("text"),
-  text: z4.string(),
+var import_v44 = require("zod/v4");
+var textPartSchema = import_v44.z.object({
+  type: import_v44.z.literal("text"),
+  text: import_v44.z.string(),
   providerOptions: providerMetadataSchema.optional()
 });
-var imagePartSchema = z4.object({
-  type: z4.literal("image"),
-  image: z4.union([dataContentSchema, z4.instanceof(URL)]),
-  mediaType: z4.string().optional(),
+var imagePartSchema = import_v44.z.object({
+  type: import_v44.z.literal("image"),
+  image: import_v44.z.union([dataContentSchema, import_v44.z.instanceof(URL)]),
+  mediaType: import_v44.z.string().optional(),
   providerOptions: providerMetadataSchema.optional()
 });
-var filePartSchema = z4.object({
-  type: z4.literal("file"),
-  data: z4.union([dataContentSchema, z4.instanceof(URL)]),
-  filename: z4.string().optional(),
-  mediaType: z4.string(),
+var filePartSchema = import_v44.z.object({
+  type: import_v44.z.literal("file"),
+  data: import_v44.z.union([dataContentSchema, import_v44.z.instanceof(URL)]),
+  filename: import_v44.z.string().optional(),
+  mediaType: import_v44.z.string(),
   providerOptions: providerMetadataSchema.optional()
 });
-var reasoningPartSchema = z4.object({
-  type: z4.literal("reasoning"),
-  text: z4.string(),
+var reasoningPartSchema = import_v44.z.object({
+  type: import_v44.z.literal("reasoning"),
+  text: import_v44.z.string(),
   providerOptions: providerMetadataSchema.optional()
 });
-var toolCallPartSchema = z4.object({
-  type: z4.literal("tool-call"),
-  toolCallId: z4.string(),
-  toolName: z4.string(),
-  input: z4.unknown(),
+var toolCallPartSchema = import_v44.z.object({
+  type: import_v44.z.literal("tool-call"),
+  toolCallId: import_v44.z.string(),
+  toolName: import_v44.z.string(),
+  input: import_v44.z.unknown(),
   providerOptions: providerMetadataSchema.optional(),
-  providerExecuted: z4.boolean().optional()
+  providerExecuted: import_v44.z.boolean().optional()
 });
-var outputSchema = z4.discriminatedUnion("type", [
-  z4.object({
-    type: z4.literal("text"),
-    value: z4.string()
+var outputSchema = import_v44.z.discriminatedUnion("type", [
+  import_v44.z.object({
+    type: import_v44.z.literal("text"),
+    value: import_v44.z.string()
   }),
-  z4.object({
-    type: z4.literal("json"),
+  import_v44.z.object({
+    type: import_v44.z.literal("json"),
     value: jsonValueSchema
   }),
-  z4.object({
-    type: z4.literal("error-text"),
-    value: z4.string()
+  import_v44.z.object({
+    type: import_v44.z.literal("error-text"),
+    value: import_v44.z.string()
   }),
-  z4.object({
-    type: z4.literal("error-json"),
+  import_v44.z.object({
+    type: import_v44.z.literal("error-json"),
     value: jsonValueSchema
   }),
-  z4.object({
-    type: z4.literal("content"),
-    value: z4.array(
-      z4.union([
-        z4.object({
-          type: z4.literal("text"),
-          text: z4.string()
+  import_v44.z.object({
+    type: import_v44.z.literal("content"),
+    value: import_v44.z.array(
+      import_v44.z.union([
+        import_v44.z.object({
+          type: import_v44.z.literal("text"),
+          text: import_v44.z.string()
         }),
-        z4.object({
-          type: z4.literal("media"),
-          data: z4.string(),
-          mediaType: z4.string()
+        import_v44.z.object({
+          type: import_v44.z.literal("media"),
+          data: import_v44.z.string(),
+          mediaType: import_v44.z.string()
         })
       ])
     )
   })
 ]);
-var toolResultPartSchema = z4.object({
-  type: z4.literal("tool-result"),
-  toolCallId: z4.string(),
-  toolName: z4.string(),
+var toolResultPartSchema = import_v44.z.object({
+  type: import_v44.z.literal("tool-result"),
+  toolCallId: import_v44.z.string(),
+  toolName: import_v44.z.string(),
   output: outputSchema,
   providerOptions: providerMetadataSchema.optional()
 });
 
 // src/prompt/message.ts
-var systemModelMessageSchema = z5.object(
+var systemModelMessageSchema = import_v45.z.object(
   {
-    role: z5.literal("system"),
-    content: z5.string(),
+    role: import_v45.z.literal("system"),
+    content: import_v45.z.string(),
     providerOptions: providerMetadataSchema.optional()
   }
 );
 var coreSystemMessageSchema = systemModelMessageSchema;
-var userModelMessageSchema = z5.object({
-  role: z5.literal("user"),
-  content: z5.union([
-    z5.string(),
-    z5.array(z5.union([textPartSchema, imagePartSchema, filePartSchema]))
+var userModelMessageSchema = import_v45.z.object({
+  role: import_v45.z.literal("user"),
+  content: import_v45.z.union([
+    import_v45.z.string(),
+    import_v45.z.array(import_v45.z.union([textPartSchema, imagePartSchema, filePartSchema]))
   ]),
   providerOptions: providerMetadataSchema.optional()
 });
 var coreUserMessageSchema = userModelMessageSchema;
-var assistantModelMessageSchema = z5.object({
-  role: z5.literal("assistant"),
-  content: z5.union([
-    z5.string(),
-    z5.array(
-      z5.union([
+var assistantModelMessageSchema = import_v45.z.object({
+  role: import_v45.z.literal("assistant"),
+  content: import_v45.z.union([
+    import_v45.z.string(),
+    import_v45.z.array(
+      import_v45.z.union([
         textPartSchema,
         filePartSchema,
         reasoningPartSchema,
@@ -1440,13 +1430,13 @@ var assistantModelMessageSchema = z5.object({
   providerOptions: providerMetadataSchema.optional()
 });
 var coreAssistantMessageSchema = assistantModelMessageSchema;
-var toolModelMessageSchema = z5.object({
-  role: z5.literal("tool"),
-  content: z5.array(toolResultPartSchema),
+var toolModelMessageSchema = import_v45.z.object({
+  role: import_v45.z.literal("tool"),
+  content: import_v45.z.array(toolResultPartSchema),
   providerOptions: providerMetadataSchema.optional()
 });
 var coreToolMessageSchema = toolModelMessageSchema;
-var modelMessageSchema = z5.union([
+var modelMessageSchema = import_v45.z.union([
   systemModelMessageSchema,
   userModelMessageSchema,
   assistantModelMessageSchema,
@@ -1495,7 +1485,7 @@ async function standardizePrompt(prompt) {
   }
   const validationResult = await (0, import_provider_utils6.safeValidateTypes)({
     value: messages,
-    schema: z6.array(modelMessageSchema)
+    schema: import_v46.z.array(modelMessageSchema)
   });
   if (!validationResult.success) {
     throw new import_provider20.InvalidPromptError({
@@ -2953,144 +2943,144 @@ function getResponseUIMessageId({
 var import_provider_utils13 = require("@ai-sdk/provider-utils");
 
 // src/ui-message-stream/ui-message-chunks.ts
-var z7 = __toESM(require("zod/v4"));
+var import_v47 = require("zod/v4");
 var import_provider_utils11 = require("@ai-sdk/provider-utils");
 var uiMessageChunkSchema = (0, import_provider_utils11.lazyValidator)(
   () => (0, import_provider_utils11.zodSchema)(
-    z7.union([
-      z7.strictObject({
-        type: z7.literal("text-start"),
-        id: z7.string(),
+    import_v47.z.union([
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("text-start"),
+        id: import_v47.z.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("text-delta"),
-        id: z7.string(),
-        delta: z7.string(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("text-delta"),
+        id: import_v47.z.string(),
+        delta: import_v47.z.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("text-end"),
-        id: z7.string(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("text-end"),
+        id: import_v47.z.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("error"),
-        errorText: z7.string()
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("error"),
+        errorText: import_v47.z.string()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-input-start"),
-        toolCallId: z7.string(),
-        toolName: z7.string(),
-        providerExecuted: z7.boolean().optional(),
-        dynamic: z7.boolean().optional()
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("tool-input-start"),
+        toolCallId: import_v47.z.string(),
+        toolName: import_v47.z.string(),
+        providerExecuted: import_v47.z.boolean().optional(),
+        dynamic: import_v47.z.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-input-delta"),
-        toolCallId: z7.string(),
-        inputTextDelta: z7.string()
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("tool-input-delta"),
+        toolCallId: import_v47.z.string(),
+        inputTextDelta: import_v47.z.string()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-input-available"),
-        toolCallId: z7.string(),
-        toolName: z7.string(),
-        input: z7.unknown(),
-        providerExecuted: z7.boolean().optional(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("tool-input-available"),
+        toolCallId: import_v47.z.string(),
+        toolName: import_v47.z.string(),
+        input: import_v47.z.unknown(),
+        providerExecuted: import_v47.z.boolean().optional(),
         providerMetadata: providerMetadataSchema.optional(),
-        dynamic: z7.boolean().optional()
+        dynamic: import_v47.z.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-input-error"),
-        toolCallId: z7.string(),
-        toolName: z7.string(),
-        input: z7.unknown(),
-        providerExecuted: z7.boolean().optional(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("tool-input-error"),
+        toolCallId: import_v47.z.string(),
+        toolName: import_v47.z.string(),
+        input: import_v47.z.unknown(),
+        providerExecuted: import_v47.z.boolean().optional(),
         providerMetadata: providerMetadataSchema.optional(),
-        dynamic: z7.boolean().optional(),
-        errorText: z7.string()
+        dynamic: import_v47.z.boolean().optional(),
+        errorText: import_v47.z.string()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-output-available"),
-        toolCallId: z7.string(),
-        output: z7.unknown(),
-        providerExecuted: z7.boolean().optional(),
-        dynamic: z7.boolean().optional(),
-        preliminary: z7.boolean().optional()
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("tool-output-available"),
+        toolCallId: import_v47.z.string(),
+        output: import_v47.z.unknown(),
+        providerExecuted: import_v47.z.boolean().optional(),
+        dynamic: import_v47.z.boolean().optional(),
+        preliminary: import_v47.z.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-output-error"),
-        toolCallId: z7.string(),
-        errorText: z7.string(),
-        providerExecuted: z7.boolean().optional(),
-        dynamic: z7.boolean().optional()
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("tool-output-error"),
+        toolCallId: import_v47.z.string(),
+        errorText: import_v47.z.string(),
+        providerExecuted: import_v47.z.boolean().optional(),
+        dynamic: import_v47.z.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("reasoning-start"),
-        id: z7.string(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("reasoning-start"),
+        id: import_v47.z.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("reasoning-delta"),
-        id: z7.string(),
-        delta: z7.string(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("reasoning-delta"),
+        id: import_v47.z.string(),
+        delta: import_v47.z.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("reasoning-end"),
-        id: z7.string(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("reasoning-end"),
+        id: import_v47.z.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("source-url"),
-        sourceId: z7.string(),
-        url: z7.string(),
-        title: z7.string().optional(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("source-url"),
+        sourceId: import_v47.z.string(),
+        url: import_v47.z.string(),
+        title: import_v47.z.string().optional(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("source-document"),
-        sourceId: z7.string(),
-        mediaType: z7.string(),
-        title: z7.string(),
-        filename: z7.string().optional(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("source-document"),
+        sourceId: import_v47.z.string(),
+        mediaType: import_v47.z.string(),
+        title: import_v47.z.string(),
+        filename: import_v47.z.string().optional(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("file"),
-        url: z7.string(),
-        mediaType: z7.string(),
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("file"),
+        url: import_v47.z.string(),
+        mediaType: import_v47.z.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.custom(
+      import_v47.z.strictObject({
+        type: import_v47.z.custom(
           (value) => typeof value === "string" && value.startsWith("data-"),
           { message: 'Type must start with "data-"' }
         ),
-        id: z7.string().optional(),
-        data: z7.unknown(),
-        transient: z7.boolean().optional()
+        id: import_v47.z.string().optional(),
+        data: import_v47.z.unknown(),
+        transient: import_v47.z.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("start-step")
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("start-step")
       }),
-      z7.strictObject({
-        type: z7.literal("finish-step")
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("finish-step")
       }),
-      z7.strictObject({
-        type: z7.literal("start"),
-        messageId: z7.string().optional(),
-        messageMetadata: z7.unknown().optional()
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("start"),
+        messageId: import_v47.z.string().optional(),
+        messageMetadata: import_v47.z.unknown().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("finish"),
-        messageMetadata: z7.unknown().optional()
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("finish"),
+        messageMetadata: import_v47.z.unknown().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("abort")
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("abort")
       }),
-      z7.strictObject({
-        type: z7.literal("message-metadata"),
-        messageMetadata: z7.unknown()
+      import_v47.z.strictObject({
+        type: import_v47.z.literal("message-metadata"),
+        messageMetadata: import_v47.z.unknown()
       })
     ])
   )
@@ -6168,13 +6158,13 @@ var DefaultEmbedResult = class {
 var import_provider_utils17 = require("@ai-sdk/provider-utils");
 
 // src/util/split-array.ts
-function splitArray(array7, chunkSize) {
+function splitArray(array, chunkSize) {
   if (chunkSize <= 0) {
     throw new Error("chunkSize must be greater than 0");
   }
   const result = [];
-  for (let i = 0; i < array7.length; i += chunkSize) {
-    result.push(array7.slice(i, i + chunkSize));
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
   }
   return result;
 }
@@ -6683,9 +6673,9 @@ var arrayOutputStrategy = (schema) => {
             transform(chunk, controller) {
               switch (chunk.type) {
                 case "object": {
-                  const array7 = chunk.object;
-                  for (; publishedElements < array7.length; publishedElements++) {
-                    controller.enqueue(array7[publishedElements]);
+                  const array = chunk.object;
+                  for (; publishedElements < array.length; publishedElements++) {
+                    controller.enqueue(array[publishedElements]);
                   }
                   break;
                 }
@@ -7174,7 +7164,7 @@ async function generateObject(options) {
         response = generateResult.responseData;
         reasoning = generateResult.reasoning;
         logWarnings(warnings);
-        const object7 = await parseAndValidateObjectResultWithRepair(
+        const object2 = await parseAndValidateObjectResultWithRepair(
           result,
           outputStrategy,
           repairText,
@@ -7190,7 +7180,7 @@ async function generateObject(options) {
             attributes: {
               "ai.response.finishReason": finishReason,
               "ai.response.object": {
-                output: () => JSON.stringify(object7)
+                output: () => JSON.stringify(object2)
               },
               "ai.response.providerMetadata": JSON.stringify(
                 resultProviderMetadata
@@ -7202,7 +7192,7 @@ async function generateObject(options) {
           })
         );
         return new DefaultGenerateObjectResult({
-          object: object7,
+          object: object2,
           reasoning,
           finishReason,
           usage,
@@ -7602,7 +7592,7 @@ var DefaultStreamObjectResult = class {
         };
         let finishReason;
         let providerMetadata;
-        let object7;
+        let object2;
         let error;
         let accumulatedText = "";
         let textDelta = "";
@@ -7696,7 +7686,7 @@ var DefaultStreamObjectResult = class {
                   });
                   self._finishReason.resolve(finishReason != null ? finishReason : "unknown");
                   try {
-                    object7 = await parseAndValidateObjectResultWithRepair(
+                    object2 = await parseAndValidateObjectResultWithRepair(
                       accumulatedText,
                       outputStrategy,
                       repairText,
@@ -7706,7 +7696,7 @@ var DefaultStreamObjectResult = class {
                         finishReason
                       }
                     );
-                    self._object.resolve(object7);
+                    self._object.resolve(object2);
                   } catch (e) {
                     error = e;
                     self._object.reject(e);
@@ -7733,7 +7723,7 @@ var DefaultStreamObjectResult = class {
                     attributes: {
                       "ai.response.finishReason": finishReason,
                       "ai.response.object": {
-                        output: () => JSON.stringify(object7)
+                        output: () => JSON.stringify(object2)
                       },
                       "ai.response.id": fullResponse.id,
                       "ai.response.model": fullResponse.modelId,
@@ -7764,7 +7754,7 @@ var DefaultStreamObjectResult = class {
                       "ai.usage.reasoningTokens": finalUsage.reasoningTokens,
                       "ai.usage.cachedInputTokens": finalUsage.cachedInputTokens,
                       "ai.response.object": {
-                        output: () => JSON.stringify(object7)
+                        output: () => JSON.stringify(object2)
                       },
                       "ai.response.providerMetadata": JSON.stringify(providerMetadata)
                     }
@@ -7772,7 +7762,7 @@ var DefaultStreamObjectResult = class {
                 );
                 await (onFinish == null ? void 0 : onFinish({
                   usage: finalUsage,
-                  object: object7,
+                  object: object2,
                   error,
                   response: {
                     ...fullResponse,
@@ -7994,7 +7984,7 @@ var DefaultSpeechResult = class {
 // src/generate-text/output.ts
 var output_exports = {};
 __export(output_exports, {
-  object: () => object3,
+  object: () => object,
   text: () => text
 });
 var import_provider_utils25 = require("@ai-sdk/provider-utils");
@@ -8008,7 +7998,7 @@ var text = () => ({
     return text2;
   }
 });
-var object3 = ({
+var object = ({
   schema: inputSchema
 }) => {
   const schema = (0, import_provider_utils25.asSchema)(inputSchema);
@@ -8682,137 +8672,137 @@ var import_provider_utils28 = require("@ai-sdk/provider-utils");
 var import_provider_utils27 = require("@ai-sdk/provider-utils");
 
 // src/tool/mcp/json-rpc-message.ts
-var z9 = __toESM(require("zod/v4"));
+var import_v49 = require("zod/v4");
 
 // src/tool/mcp/types.ts
-var z8 = __toESM(require("zod/v4"));
+var import_v48 = require("zod/v4");
 var LATEST_PROTOCOL_VERSION = "2025-06-18";
 var SUPPORTED_PROTOCOL_VERSIONS = [
   LATEST_PROTOCOL_VERSION,
   "2025-03-26",
   "2024-11-05"
 ];
-var ClientOrServerImplementationSchema = z8.looseObject({
-  name: z8.string(),
-  version: z8.string()
+var ClientOrServerImplementationSchema = import_v48.z.looseObject({
+  name: import_v48.z.string(),
+  version: import_v48.z.string()
 });
-var BaseParamsSchema = z8.looseObject({
-  _meta: z8.optional(z8.object({}).loose())
+var BaseParamsSchema = import_v48.z.looseObject({
+  _meta: import_v48.z.optional(import_v48.z.object({}).loose())
 });
 var ResultSchema = BaseParamsSchema;
-var RequestSchema = z8.object({
-  method: z8.string(),
-  params: z8.optional(BaseParamsSchema)
+var RequestSchema = import_v48.z.object({
+  method: import_v48.z.string(),
+  params: import_v48.z.optional(BaseParamsSchema)
 });
-var ServerCapabilitiesSchema = z8.looseObject({
-  experimental: z8.optional(z8.object({}).loose()),
-  logging: z8.optional(z8.object({}).loose()),
-  prompts: z8.optional(
-    z8.looseObject({
-      listChanged: z8.optional(z8.boolean())
+var ServerCapabilitiesSchema = import_v48.z.looseObject({
+  experimental: import_v48.z.optional(import_v48.z.object({}).loose()),
+  logging: import_v48.z.optional(import_v48.z.object({}).loose()),
+  prompts: import_v48.z.optional(
+    import_v48.z.looseObject({
+      listChanged: import_v48.z.optional(import_v48.z.boolean())
     })
   ),
-  resources: z8.optional(
-    z8.looseObject({
-      subscribe: z8.optional(z8.boolean()),
-      listChanged: z8.optional(z8.boolean())
+  resources: import_v48.z.optional(
+    import_v48.z.looseObject({
+      subscribe: import_v48.z.optional(import_v48.z.boolean()),
+      listChanged: import_v48.z.optional(import_v48.z.boolean())
     })
   ),
-  tools: z8.optional(
-    z8.looseObject({
-      listChanged: z8.optional(z8.boolean())
+  tools: import_v48.z.optional(
+    import_v48.z.looseObject({
+      listChanged: import_v48.z.optional(import_v48.z.boolean())
     })
   )
 });
 var InitializeResultSchema = ResultSchema.extend({
-  protocolVersion: z8.string(),
+  protocolVersion: import_v48.z.string(),
   capabilities: ServerCapabilitiesSchema,
   serverInfo: ClientOrServerImplementationSchema,
-  instructions: z8.optional(z8.string())
+  instructions: import_v48.z.optional(import_v48.z.string())
 });
 var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: z8.optional(z8.string())
+  nextCursor: import_v48.z.optional(import_v48.z.string())
 });
-var ToolSchema = z8.object({
-  name: z8.string(),
-  description: z8.optional(z8.string()),
-  inputSchema: z8.object({
-    type: z8.literal("object"),
-    properties: z8.optional(z8.object({}).loose())
+var ToolSchema = import_v48.z.object({
+  name: import_v48.z.string(),
+  description: import_v48.z.optional(import_v48.z.string()),
+  inputSchema: import_v48.z.object({
+    type: import_v48.z.literal("object"),
+    properties: import_v48.z.optional(import_v48.z.object({}).loose())
   }).loose()
 }).loose();
 var ListToolsResultSchema = PaginatedResultSchema.extend({
-  tools: z8.array(ToolSchema)
+  tools: import_v48.z.array(ToolSchema)
 });
-var TextContentSchema = z8.object({
-  type: z8.literal("text"),
-  text: z8.string()
+var TextContentSchema = import_v48.z.object({
+  type: import_v48.z.literal("text"),
+  text: import_v48.z.string()
 }).loose();
-var ImageContentSchema = z8.object({
-  type: z8.literal("image"),
-  data: z8.base64(),
-  mimeType: z8.string()
+var ImageContentSchema = import_v48.z.object({
+  type: import_v48.z.literal("image"),
+  data: import_v48.z.base64(),
+  mimeType: import_v48.z.string()
 }).loose();
-var ResourceContentsSchema = z8.object({
+var ResourceContentsSchema = import_v48.z.object({
   /**
    * The URI of this resource.
    */
-  uri: z8.string(),
+  uri: import_v48.z.string(),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: z8.optional(z8.string())
+  mimeType: import_v48.z.optional(import_v48.z.string())
 }).loose();
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: z8.string()
+  text: import_v48.z.string()
 });
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: z8.base64()
+  blob: import_v48.z.base64()
 });
-var EmbeddedResourceSchema = z8.object({
-  type: z8.literal("resource"),
-  resource: z8.union([TextResourceContentsSchema, BlobResourceContentsSchema])
+var EmbeddedResourceSchema = import_v48.z.object({
+  type: import_v48.z.literal("resource"),
+  resource: import_v48.z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
 }).loose();
 var CallToolResultSchema = ResultSchema.extend({
-  content: z8.array(
-    z8.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
+  content: import_v48.z.array(
+    import_v48.z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
   ),
-  isError: z8.boolean().default(false).optional()
+  isError: import_v48.z.boolean().default(false).optional()
 }).or(
   ResultSchema.extend({
-    toolResult: z8.unknown()
+    toolResult: import_v48.z.unknown()
   })
 );
 
 // src/tool/mcp/json-rpc-message.ts
 var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()])
+var JSONRPCRequestSchema = import_v49.z.object({
+  jsonrpc: import_v49.z.literal(JSONRPC_VERSION),
+  id: import_v49.z.union([import_v49.z.string(), import_v49.z.number().int()])
 }).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()]),
+var JSONRPCResponseSchema = import_v49.z.object({
+  jsonrpc: import_v49.z.literal(JSONRPC_VERSION),
+  id: import_v49.z.union([import_v49.z.string(), import_v49.z.number().int()]),
   result: ResultSchema
 }).strict();
-var JSONRPCErrorSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()]),
-  error: z9.object({
-    code: z9.number().int(),
-    message: z9.string(),
-    data: z9.optional(z9.unknown())
+var JSONRPCErrorSchema = import_v49.z.object({
+  jsonrpc: import_v49.z.literal(JSONRPC_VERSION),
+  id: import_v49.z.union([import_v49.z.string(), import_v49.z.number().int()]),
+  error: import_v49.z.object({
+    code: import_v49.z.number().int(),
+    message: import_v49.z.string(),
+    data: import_v49.z.optional(import_v49.z.unknown())
   })
 }).strict();
-var JSONRPCNotificationSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION)
+var JSONRPCNotificationSchema = import_v49.z.object({
+  jsonrpc: import_v49.z.literal(JSONRPC_VERSION)
 }).merge(
-  z9.object({
-    method: z9.string(),
-    params: z9.optional(BaseParamsSchema)
+  import_v49.z.object({
+    method: import_v49.z.string(),
+    params: import_v49.z.optional(BaseParamsSchema)
   })
 ).strict();
-var JSONRPCMessageSchema = z9.union([
+var JSONRPCMessageSchema = import_v49.z.union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
   JSONRPCResponseSchema,
@@ -10032,193 +10022,193 @@ var TextStreamChatTransport = class extends HttpChatTransport {
 // src/ui/validate-ui-messages.ts
 var import_provider32 = require("@ai-sdk/provider");
 var import_provider_utils34 = require("@ai-sdk/provider-utils");
-var z10 = __toESM(require("zod/v4"));
+var import_v410 = require("zod/v4");
 var uiMessagesSchema = (0, import_provider_utils34.lazyValidator)(
   () => (0, import_provider_utils34.zodSchema)(
-    z10.array(
-      z10.object({
-        id: z10.string(),
-        role: z10.enum(["system", "user", "assistant"]),
-        metadata: z10.unknown().optional(),
-        parts: z10.array(
-          z10.union([
-            z10.object({
-              type: z10.literal("text"),
-              text: z10.string(),
-              state: z10.enum(["streaming", "done"]).optional(),
+    import_v410.z.array(
+      import_v410.z.object({
+        id: import_v410.z.string(),
+        role: import_v410.z.enum(["system", "user", "assistant"]),
+        metadata: import_v410.z.unknown().optional(),
+        parts: import_v410.z.array(
+          import_v410.z.union([
+            import_v410.z.object({
+              type: import_v410.z.literal("text"),
+              text: import_v410.z.string(),
+              state: import_v410.z.enum(["streaming", "done"]).optional(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z10.object({
-              type: z10.literal("reasoning"),
-              text: z10.string(),
-              state: z10.enum(["streaming", "done"]).optional(),
+            import_v410.z.object({
+              type: import_v410.z.literal("reasoning"),
+              text: import_v410.z.string(),
+              state: import_v410.z.enum(["streaming", "done"]).optional(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z10.object({
-              type: z10.literal("source-url"),
-              sourceId: z10.string(),
-              url: z10.string(),
-              title: z10.string().optional(),
+            import_v410.z.object({
+              type: import_v410.z.literal("source-url"),
+              sourceId: import_v410.z.string(),
+              url: import_v410.z.string(),
+              title: import_v410.z.string().optional(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z10.object({
-              type: z10.literal("source-document"),
-              sourceId: z10.string(),
-              mediaType: z10.string(),
-              title: z10.string(),
-              filename: z10.string().optional(),
+            import_v410.z.object({
+              type: import_v410.z.literal("source-document"),
+              sourceId: import_v410.z.string(),
+              mediaType: import_v410.z.string(),
+              title: import_v410.z.string(),
+              filename: import_v410.z.string().optional(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z10.object({
-              type: z10.literal("file"),
-              mediaType: z10.string(),
-              filename: z10.string().optional(),
-              url: z10.string(),
+            import_v410.z.object({
+              type: import_v410.z.literal("file"),
+              mediaType: import_v410.z.string(),
+              filename: import_v410.z.string().optional(),
+              url: import_v410.z.string(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z10.object({
-              type: z10.literal("step-start")
+            import_v410.z.object({
+              type: import_v410.z.literal("step-start")
             }),
-            z10.object({
-              type: z10.string().startsWith("data-"),
-              id: z10.string().optional(),
-              data: z10.unknown()
+            import_v410.z.object({
+              type: import_v410.z.string().startsWith("data-"),
+              id: import_v410.z.string().optional(),
+              data: import_v410.z.unknown()
             }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("input-streaming"),
-              input: z10.unknown().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional()
+            import_v410.z.object({
+              type: import_v410.z.literal("dynamic-tool"),
+              toolName: import_v410.z.string(),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("input-streaming"),
+              input: import_v410.z.unknown().optional(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.never().optional()
             }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("input-available"),
-              input: z10.unknown(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
+            import_v410.z.object({
+              type: import_v410.z.literal("dynamic-tool"),
+              toolName: import_v410.z.string(),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("input-available"),
+              input: import_v410.z.unknown(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional()
             }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("output-available"),
-              input: z10.unknown(),
-              output: z10.unknown(),
-              errorText: z10.never().optional(),
+            import_v410.z.object({
+              type: import_v410.z.literal("dynamic-tool"),
+              toolName: import_v410.z.string(),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("output-available"),
+              input: import_v410.z.unknown(),
+              output: import_v410.z.unknown(),
+              errorText: import_v410.z.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              preliminary: z10.boolean().optional()
+              preliminary: import_v410.z.boolean().optional()
             }),
-            z10.object({
-              type: z10.literal("dynamic-tool"),
-              toolName: z10.string(),
-              toolCallId: z10.string(),
-              state: z10.literal("output-error"),
-              input: z10.unknown(),
-              output: z10.never().optional(),
-              errorText: z10.string(),
+            import_v410.z.object({
+              type: import_v410.z.literal("dynamic-tool"),
+              toolName: import_v410.z.string(),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("output-error"),
+              input: import_v410.z.unknown(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.string(),
               callProviderMetadata: providerMetadataSchema.optional()
             }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("input-streaming"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
-              approval: z10.never().optional()
+            import_v410.z.object({
+              type: import_v410.z.string().startsWith("tool-"),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("input-streaming"),
+              providerExecuted: import_v410.z.boolean().optional(),
+              input: import_v410.z.unknown().optional(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.never().optional(),
+              approval: import_v410.z.never().optional()
             }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("input-available"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
+            import_v410.z.object({
+              type: import_v410.z.string().startsWith("tool-"),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("input-available"),
+              providerExecuted: import_v410.z.boolean().optional(),
+              input: import_v410.z.unknown(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.never().optional()
+              approval: import_v410.z.never().optional()
             }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("approval-requested"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
+            import_v410.z.object({
+              type: import_v410.z.string().startsWith("tool-"),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("approval-requested"),
+              input: import_v410.z.unknown(),
+              providerExecuted: import_v410.z.boolean().optional(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.never().optional(),
-                reason: z10.never().optional()
+              approval: import_v410.z.object({
+                id: import_v410.z.string(),
+                approved: import_v410.z.never().optional(),
+                reason: import_v410.z.never().optional()
               })
             }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("approval-responded"),
-              input: z10.unknown(),
-              providerExecuted: z10.boolean().optional(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
+            import_v410.z.object({
+              type: import_v410.z.string().startsWith("tool-"),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("approval-responded"),
+              input: import_v410.z.unknown(),
+              providerExecuted: import_v410.z.boolean().optional(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.boolean(),
-                reason: z10.string().optional()
+              approval: import_v410.z.object({
+                id: import_v410.z.string(),
+                approved: import_v410.z.boolean(),
+                reason: import_v410.z.string().optional()
               })
             }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("output-available"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown(),
-              output: z10.unknown(),
-              errorText: z10.never().optional(),
+            import_v410.z.object({
+              type: import_v410.z.string().startsWith("tool-"),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("output-available"),
+              providerExecuted: import_v410.z.boolean().optional(),
+              input: import_v410.z.unknown(),
+              output: import_v410.z.unknown(),
+              errorText: import_v410.z.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              preliminary: z10.boolean().optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(true),
-                reason: z10.string().optional()
+              preliminary: import_v410.z.boolean().optional(),
+              approval: import_v410.z.object({
+                id: import_v410.z.string(),
+                approved: import_v410.z.literal(true),
+                reason: import_v410.z.string().optional()
               }).optional()
             }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("output-error"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown(),
-              output: z10.never().optional(),
-              errorText: z10.string(),
+            import_v410.z.object({
+              type: import_v410.z.string().startsWith("tool-"),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("output-error"),
+              providerExecuted: import_v410.z.boolean().optional(),
+              input: import_v410.z.unknown(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.string(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(true),
-                reason: z10.string().optional()
+              approval: import_v410.z.object({
+                id: import_v410.z.string(),
+                approved: import_v410.z.literal(true),
+                reason: import_v410.z.string().optional()
               }).optional()
             }),
-            z10.object({
-              type: z10.string().startsWith("tool-"),
-              toolCallId: z10.string(),
-              state: z10.literal("output-denied"),
-              providerExecuted: z10.boolean().optional(),
-              input: z10.unknown(),
-              output: z10.never().optional(),
-              errorText: z10.never().optional(),
+            import_v410.z.object({
+              type: import_v410.z.string().startsWith("tool-"),
+              toolCallId: import_v410.z.string(),
+              state: import_v410.z.literal("output-denied"),
+              providerExecuted: import_v410.z.boolean().optional(),
+              input: import_v410.z.unknown(),
+              output: import_v410.z.never().optional(),
+              errorText: import_v410.z.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z10.object({
-                id: z10.string(),
-                approved: z10.literal(false),
-                reason: z10.string().optional()
+              approval: import_v410.z.object({
+                id: import_v410.z.string(),
+                approved: import_v410.z.literal(false),
+                reason: import_v410.z.string().optional()
               })
             })
           ])