ai 7.0.0-beta.113 → 7.0.0-beta.115

package/dist/index.js

@@ -18,7 +18,9 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/agent/tool-loop-agent.ts
-import { validateTypes as validateTypes3 } from "@ai-sdk/provider-utils";
+import {
+  validateTypes as validateTypes3
+} from "@ai-sdk/provider-utils";
 
 // src/generate-text/generate-text.ts
 import {
@@ -1015,258 +1017,23 @@ function getGlobalProvider() {
 // src/prompt/convert-to-language-model-prompt.ts
 import {
   asArray,
-  isProviderReference,
+  detectMediaType,
+  isFullMediaType,
   isUrlSupported
 } from "@ai-sdk/provider-utils";
 
-// src/util/detect-media-type.ts
-import { convertBase64ToUint8Array } from "@ai-sdk/provider-utils";
-var imageMediaTypeSignatures = [
-  {
-    mediaType: "image/gif",
-    bytesPrefix: [71, 73, 70]
-    // GIF
-  },
-  {
-    mediaType: "image/png",
-    bytesPrefix: [137, 80, 78, 71]
-    // PNG
-  },
-  {
-    mediaType: "image/jpeg",
-    bytesPrefix: [255, 216]
-    // JPEG
-  },
-  {
-    mediaType: "image/webp",
-    bytesPrefix: [
-      82,
-      73,
-      70,
-      70,
-      // "RIFF"
-      null,
-      null,
-      null,
-      null,
-      // file size (variable)
-      87,
-      69,
-      66,
-      80
-      // "WEBP"
-    ]
-  },
-  {
-    mediaType: "image/bmp",
-    bytesPrefix: [66, 77]
-  },
-  {
-    mediaType: "image/tiff",
-    bytesPrefix: [73, 73, 42, 0]
-  },
-  {
-    mediaType: "image/tiff",
-    bytesPrefix: [77, 77, 0, 42]
-  },
-  {
-    mediaType: "image/avif",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      97,
-      118,
-      105,
-      102
-    ]
-  },
-  {
-    mediaType: "image/heic",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      104,
-      101,
-      105,
-      99
-    ]
-  }
-];
-var documentMediaTypeSignatures = [
-  {
-    mediaType: "application/pdf",
-    bytesPrefix: [37, 80, 68, 70]
-    // %PDF
-  }
-];
-var audioMediaTypeSignatures = [
-  {
-    mediaType: "audio/mpeg",
-    bytesPrefix: [255, 251]
-  },
-  {
-    mediaType: "audio/mpeg",
-    bytesPrefix: [255, 250]
-  },
-  {
-    mediaType: "audio/mpeg",
-    bytesPrefix: [255, 243]
-  },
-  {
-    mediaType: "audio/mpeg",
-    bytesPrefix: [255, 242]
-  },
-  {
-    mediaType: "audio/mpeg",
-    bytesPrefix: [255, 227]
-  },
-  {
-    mediaType: "audio/mpeg",
-    bytesPrefix: [255, 226]
-  },
-  {
-    mediaType: "audio/wav",
-    bytesPrefix: [
-      82,
-      // R
-      73,
-      // I
-      70,
-      // F
-      70,
-      // F
-      null,
-      null,
-      null,
-      null,
-      87,
-      // W
-      65,
-      // A
-      86,
-      // V
-      69
-      // E
-    ]
-  },
-  {
-    mediaType: "audio/ogg",
-    bytesPrefix: [79, 103, 103, 83]
-  },
-  {
-    mediaType: "audio/flac",
-    bytesPrefix: [102, 76, 97, 67]
-  },
-  {
-    mediaType: "audio/aac",
-    bytesPrefix: [64, 21, 0, 0]
-  },
-  {
-    mediaType: "audio/mp4",
-    bytesPrefix: [102, 116, 121, 112]
-  },
-  {
-    mediaType: "audio/webm",
-    bytesPrefix: [26, 69, 223, 163]
-  }
-];
-var videoMediaTypeSignatures = [
-  {
-    mediaType: "video/mp4",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      null,
-      102,
-      116,
-      121,
-      112
-      // ftyp
-    ]
-  },
-  {
-    mediaType: "video/webm",
-    bytesPrefix: [26, 69, 223, 163]
-    // EBML
-  },
-  {
-    mediaType: "video/quicktime",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      20,
-      102,
-      116,
-      121,
-      112,
-      113,
-      116
-      // ftypqt
-    ]
-  },
-  {
-    mediaType: "video/x-msvideo",
-    bytesPrefix: [82, 73, 70, 70]
-    // RIFF (AVI)
-  }
-];
-var stripID3 = (data) => {
-  const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
-  const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
-  return bytes.slice(id3Size + 10);
-};
-function stripID3TagsIfPresent(data) {
-  const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
-  data[1] === 68 && // 'D'
-  data[2] === 51;
-  return hasId3 ? stripID3(data) : data;
-}
-function detectMediaType({
-  data,
-  signatures
-}) {
-  const processedData = stripID3TagsIfPresent(data);
-  const bytes = typeof processedData === "string" ? convertBase64ToUint8Array(
-    processedData.substring(0, Math.min(processedData.length, 24))
-  ) : processedData;
-  for (const signature of signatures) {
-    if (bytes.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
-      (byte, index) => byte === null || bytes[index] === byte
-    )) {
-      return signature.mediaType;
-    }
-  }
-  return void 0;
-}
-
 // src/util/download/download.ts
 import {
   DownloadError as DownloadError2,
   readResponseWithSizeLimit,
   DEFAULT_MAX_DOWNLOAD_SIZE,
-  validateDownloadUrl
-} from "@ai-sdk/provider-utils";
-import {
+  validateDownloadUrl,
   withUserAgentSuffix,
   getRuntimeEnvironmentUserAgent
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.0-beta.113" : "0.0.0-test";
+var VERSION = true ? "7.0.0-beta.115" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -1320,13 +1087,11 @@ var createDefaultDownloadFunction = (download2 = download) => (requestedDownload
   )
 );
 
-// src/prompt/data-content.ts
-import { AISDKError as AISDKError22 } from "@ai-sdk/provider";
+// src/prompt/file-part-data.ts
 import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array2,
-  convertUint8ArrayToBase64
+  isBuffer,
+  isProviderReference
 } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
 
 // src/prompt/split-data-url.ts
 function splitDataUrl(dataUrl) {
@@ -1344,75 +1109,89 @@ function splitDataUrl(dataUrl) {
   }
 }
 
-// src/prompt/data-content.ts
-var dataContentSchema = z.union([
-  z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
-  z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a21, _b;
-      return (_b = (_a21 = globalThis.Buffer) == null ? void 0 : _a21.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-function convertToLanguageModelV4DataContent(content) {
-  if (content instanceof Uint8Array) {
-    return { data: content, mediaType: void 0 };
-  }
-  if (content instanceof ArrayBuffer) {
-    return { data: new Uint8Array(content), mediaType: void 0 };
-  }
-  if (typeof content === "string") {
-    try {
-      content = new URL(content);
-    } catch (e) {
-    }
-  }
-  if (content instanceof URL && content.protocol === "data:") {
-    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
-      content.toString()
-    );
-    if (dataUrlMediaType == null || base64Content == null) {
-      throw new AISDKError22({
-        name: "InvalidDataContentError",
-        message: `Invalid data URL format in content ${content.toString()}`
+// src/prompt/file-part-data.ts
+function isTaggedFileData(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const type = value.type;
+  return type === "data" || type === "url" || type === "reference" || type === "text";
+}
+function convertUrlToFilePartData(url) {
+  if (url.protocol === "data:") {
+    const { mediaType, base64Content } = splitDataUrl(url.toString());
+    if (mediaType == null || base64Content == null) {
+      throw new InvalidDataContentError({
+        content: url,
+        message: `Invalid data URL format in content ${url.toString()}`
       });
     }
-    return { data: base64Content, mediaType: dataUrlMediaType };
+    return { data: { type: "data", data: base64Content }, mediaType };
   }
-  return { data: content, mediaType: void 0 };
+  return { data: { type: "url", url }, mediaType: void 0 };
 }
-function convertDataContentToBase64String(content) {
-  if (typeof content === "string") {
-    return content;
+function convertInlineDataToFilePartData(content) {
+  if (content instanceof Uint8Array) {
+    return { data: { type: "data", data: content }, mediaType: void 0 };
   }
   if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase64(new Uint8Array(content));
+    return {
+      data: { type: "data", data: new Uint8Array(content) },
+      mediaType: void 0
+    };
   }
-  return convertUint8ArrayToBase64(content);
+  if (isBuffer(content)) {
+    return {
+      data: { type: "data", data: new Uint8Array(content) },
+      mediaType: void 0
+    };
+  }
+  return {
+    data: { type: "data", data: content },
+    mediaType: void 0
+  };
 }
-function convertDataContentToUint8Array(content) {
-  if (content instanceof Uint8Array) {
-    return content;
+function convertToLanguageModelV4FilePart(content) {
+  if (isTaggedFileData(content)) {
+    switch (content.type) {
+      case "data":
+        if (typeof content.data === "string" && content.data.startsWith("data:")) {
+          throw new InvalidDataContentError({
+            content: content.data,
+            message: 'Data URLs are not valid inline data. Pass them as { type: "url", url } instead.'
+          });
+        }
+        return convertInlineDataToFilePartData(content.data);
+      case "url":
+        return convertUrlToFilePartData(content.url);
+      case "reference":
+        return {
+          data: { type: "reference", reference: content.reference },
+          mediaType: void 0
+        };
+      case "text":
+        return {
+          data: { type: "text", text: content.text },
+          mediaType: void 0
+        };
+    }
+  }
+  if (content instanceof URL) {
+    return convertUrlToFilePartData(content);
   }
   if (typeof content === "string") {
     try {
-      return convertBase64ToUint8Array2(content);
-    } catch (error) {
-      throw new InvalidDataContentError({
-        message: "Invalid data content. Content string is not a base64-encoded media.",
-        content,
-        cause: error
-      });
+      return convertUrlToFilePartData(new URL(content));
+    } catch (e) {
+      return convertInlineDataToFilePartData(content);
     }
   }
-  if (content instanceof ArrayBuffer) {
-    return new Uint8Array(content);
+  if (isProviderReference(content)) {
+    return {
+      data: { type: "reference", reference: content },
+      mediaType: void 0
+    };
   }
-  throw new InvalidDataContentError({ content });
+  return convertInlineDataToFilePartData(content);
 }
 
 // src/prompt/convert-to-language-model-prompt.ts
@@ -1551,7 +1330,16 @@ function convertToLanguageModelMessage({
       }
       const converted = {
         role: "user",
-        content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
+        content: message.content.map((part) => {
+          if (part.type === "image") {
+            warnings.push({
+              type: "deprecated",
+              setting: '"image" content part',
+              message: `The "image" content part type is deprecated. Use a "file" part with mediaType: 'image' (or a more specific image/* subtype) instead.`
+            });
+          }
+          return convertImagePartToFilePart(part);
+        }).map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
         providerOptions: message.providerOptions
       };
       if (warnings.length > 0) {
@@ -1585,16 +1373,7 @@ function convertToLanguageModelMessage({
               };
             }
             case "file": {
-              if (!(part.data instanceof ArrayBuffer) && isProviderReference(part.data)) {
-                return {
-                  type: "file",
-                  data: part.data,
-                  filename: part.filename,
-                  mediaType: part.mediaType,
-                  providerOptions
-                };
-              }
-              const { data, mediaType } = convertToLanguageModelV4DataContent(
+              const { data, mediaType } = convertToLanguageModelV4FilePart(
                 part.data
               );
               return {
@@ -1613,9 +1392,14 @@ function convertToLanguageModelMessage({
               };
             }
             case "reasoning-file": {
-              const { data, mediaType } = convertToLanguageModelV4DataContent(
+              const { data, mediaType } = convertToLanguageModelV4FilePart(
                 part.data
               );
+              if (data.type !== "data" && data.type !== "url") {
+                throw new Error(
+                  `Unsupported reasoning-file data type: ${data.type}`
+                );
+              }
               return {
                 type: "reasoning-file",
                 data,
@@ -1706,28 +1490,29 @@ function convertToLanguageModelMessage({
     }
   }
 }
+function convertImagePartToFilePart(part) {
+  var _a21;
+  if (part.type !== "image") {
+    return part;
+  }
+  return {
+    type: "file",
+    data: part.image,
+    mediaType: (_a21 = part.mediaType) != null ? _a21 : "image",
+    providerOptions: part.providerOptions
+  };
+}
 async function downloadAssets(messages, download2, supportedUrls) {
   const plannedDownloads = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
     (content) => Array.isArray(content)
-  ).flat().filter(
-    (part) => part.type === "image" || part.type === "file"
-  ).map((part) => {
-    var _a21;
-    const mediaType = (_a21 = part.mediaType) != null ? _a21 : part.type === "image" ? "image/*" : void 0;
-    let data = part.type === "image" ? part.image : part.data;
-    if (typeof data === "string") {
-      try {
-        data = new URL(data);
-      } catch (e) {
-      }
-    }
+  ).flat().map((part) => convertImagePartToFilePart(part)).filter((part) => part.type === "file").map((part) => {
+    const mediaType = part.mediaType;
+    const { data } = convertToLanguageModelV4FilePart(part.data);
     return { mediaType, data };
-  }).filter(
-    (part) => part.data instanceof URL
-  ).map((part) => ({
-    url: part.data,
+  }).filter((part) => part.data.type === "url").map((part) => ({
+    url: part.data.url,
     isUrlSupportedByModel: part.mediaType != null && isUrlSupported({
-      url: part.data.toString(),
+      url: part.data.url.toString(),
       mediaType: part.mediaType,
       supportedUrls
     })
@@ -1743,7 +1528,6 @@ async function downloadAssets(messages, download2, supportedUrls) {
   );
 }
 function convertPartToLanguageModelPart(part, downloadedAssets) {
-  var _a21, _b;
   if (part.type === "text") {
     return {
       type: "text",
@@ -1751,55 +1535,37 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
       providerOptions: part.providerOptions
     };
   }
-  const type = part.type;
-  const rawData = type === "image" ? part.image : part.data;
-  if (typeof rawData === "object" && !(rawData instanceof Uint8Array) && !(rawData instanceof ArrayBuffer) && !(rawData instanceof URL)) {
-    return {
-      type: "file",
-      mediaType: (_a21 = part.mediaType) != null ? _a21 : type === "image" ? "image/*" : "",
-      filename: type === "file" ? part.filename : void 0,
-      data: rawData,
-      providerOptions: part.providerOptions
-    };
-  }
-  const originalData = rawData;
-  const { data: convertedData, mediaType: convertedMediaType } = convertToLanguageModelV4DataContent(originalData);
-  let mediaType = convertedMediaType != null ? convertedMediaType : part.mediaType;
-  let data = convertedData;
-  if (data instanceof URL) {
-    const downloadedFile = downloadedAssets[data.toString()];
+  const { data: normalizedData, mediaType: dataUrlMediaType } = convertToLanguageModelV4FilePart(part.data);
+  let mediaType = dataUrlMediaType != null ? dataUrlMediaType : part.mediaType;
+  let data = normalizedData;
+  if (data.type === "url") {
+    const downloadedFile = downloadedAssets[data.url.toString()];
     if (downloadedFile) {
-      data = downloadedFile.data;
-      mediaType != null ? mediaType : mediaType = downloadedFile.mediaType;
-    }
-  }
-  switch (type) {
-    case "image": {
-      if (data instanceof Uint8Array || typeof data === "string") {
-        mediaType = (_b = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _b : mediaType;
+      data = { type: "data", data: downloadedFile.data };
+      if (downloadedFile.mediaType != null && (mediaType == null || !isFullMediaType(mediaType))) {
+        mediaType = downloadedFile.mediaType;
       }
-      return {
-        type: "file",
-        mediaType: mediaType != null ? mediaType : "image/*",
-        // any image
-        filename: void 0,
-        data,
-        providerOptions: part.providerOptions
-      };
     }
-    case "file": {
-      if (mediaType == null) {
-        throw new Error(`Media type is missing for file part`);
-      }
-      return {
-        type: "file",
-        mediaType,
-        filename: part.filename,
-        data,
-        providerOptions: part.providerOptions
-      };
+  }
+  if (data.type === "data" && (data.data instanceof Uint8Array || typeof data.data === "string")) {
+    const imageMediaType = detectMediaType({
+      data: data.data,
+      topLevelType: "image"
+    });
+    if (imageMediaType != null) {
+      mediaType = imageMediaType;
     }
   }
+  if (mediaType == null) {
+    throw new Error(`Media type is missing for file part`);
+  }
+  return {
+    type: "file",
+    mediaType,
+    filename: part.filename,
+    data,
+    providerOptions: part.providerOptions
+  };
 }
 function mapToolResultOutput({
   output,
@@ -2163,170 +1929,197 @@ import {
   asArray as asArray2,
   safeValidateTypes
 } from "@ai-sdk/provider-utils";
-import { z as z6 } from "zod/v4";
+import { z as z5 } from "zod/v4";
 
 // src/prompt/message.ts
-import { z as z5 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 
 // src/types/provider-metadata.ts
-import { z as z3 } from "zod/v4";
+import { z as z2 } from "zod/v4";
 
 // src/types/json-value.ts
-import { z as z2 } from "zod/v4";
-var jsonValueSchema = z2.lazy(
-  () => z2.union([
-    z2.null(),
-    z2.string(),
-    z2.number(),
-    z2.boolean(),
-    z2.record(z2.string(), jsonValueSchema.optional()),
-    z2.array(jsonValueSchema)
+import { z } from "zod/v4";
+var jsonValueSchema = z.lazy(
+  () => z.union([
+    z.null(),
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.record(z.string(), jsonValueSchema.optional()),
+    z.array(jsonValueSchema)
   ])
 );
 
 // src/types/provider-metadata.ts
-var providerMetadataSchema = z3.record(
-  z3.string(),
-  z3.record(z3.string(), jsonValueSchema.optional())
+var providerMetadataSchema = z2.record(
+  z2.string(),
+  z2.record(z2.string(), jsonValueSchema.optional())
 );
 
 // src/prompt/content-part.ts
-import { z as z4 } from "zod/v4";
-var providerReferenceSchema = z4.record(z4.string(), z4.string());
-var textPartSchema = z4.object({
-  type: z4.literal("text"),
-  text: z4.string(),
+import {
+  isBuffer as isBuffer2
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+var fileInlineDataSchema = z3.union([
+  z3.string(),
+  z3.instanceof(Uint8Array),
+  z3.instanceof(ArrayBuffer),
+  z3.custom(isBuffer2, { message: "Must be a Buffer" })
+]);
+var providerReferenceSchema = z3.record(z3.string(), z3.string());
+var textPartSchema = z3.object({
+  type: z3.literal("text"),
+  text: z3.string(),
   providerOptions: providerMetadataSchema.optional()
 });
-var imagePartSchema = z4.object({
-  type: z4.literal("image"),
-  image: z4.union([
-    dataContentSchema,
-    z4.instanceof(URL),
+var imagePartSchema = z3.object({
+  type: z3.literal("image"),
+  image: z3.union([
+    fileInlineDataSchema,
+    z3.instanceof(URL),
     providerReferenceSchema
   ]),
-  mediaType: z4.string().optional(),
+  mediaType: z3.string().optional(),
   providerOptions: providerMetadataSchema.optional()
 });
-var filePartSchema = z4.object({
-  type: z4.literal("file"),
-  data: z4.union([
-    dataContentSchema,
-    z4.instanceof(URL),
+var taggedFileDataSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("data"), data: fileInlineDataSchema }),
+  z3.object({ type: z3.literal("url"), url: z3.instanceof(URL) }),
+  z3.object({
+    type: z3.literal("reference"),
+    reference: providerReferenceSchema
+  }),
+  z3.object({ type: z3.literal("text"), text: z3.string() })
+]);
+var taggedReasoningFileDataSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("data"), data: fileInlineDataSchema }),
+  z3.object({ type: z3.literal("url"), url: z3.instanceof(URL) })
+]);
+var filePartSchema = z3.object({
+  type: z3.literal("file"),
+  data: z3.union([
+    taggedFileDataSchema,
+    fileInlineDataSchema,
+    z3.instanceof(URL),
     providerReferenceSchema
   ]),
-  filename: z4.string().optional(),
-  mediaType: z4.string(),
+  filename: z3.string().optional(),
+  mediaType: z3.string(),
   providerOptions: providerMetadataSchema.optional()
 });
-var reasoningPartSchema = z4.object({
-  type: z4.literal("reasoning"),
-  text: z4.string(),
+var reasoningPartSchema = z3.object({
+  type: z3.literal("reasoning"),
+  text: z3.string(),
   providerOptions: providerMetadataSchema.optional()
 });
-var customPartSchema = z4.object({
-  type: z4.literal("custom"),
-  kind: z4.string().transform((value) => value),
+var customPartSchema = z3.object({
+  type: z3.literal("custom"),
+  kind: z3.string().transform((value) => value),
   providerOptions: providerMetadataSchema.optional()
 });
-var reasoningFilePartSchema = z4.object({
-  type: z4.literal("reasoning-file"),
-  data: z4.union([dataContentSchema, z4.instanceof(URL)]),
-  mediaType: z4.string(),
+var reasoningFilePartSchema = z3.object({
+  type: z3.literal("reasoning-file"),
+  data: z3.union([
+    taggedReasoningFileDataSchema,
+    fileInlineDataSchema,
+    z3.instanceof(URL)
+  ]),
+  mediaType: z3.string(),
   providerOptions: providerMetadataSchema.optional()
 });
-var toolCallPartSchema = z4.object({
-  type: z4.literal("tool-call"),
-  toolCallId: z4.string(),
-  toolName: z4.string(),
-  input: z4.unknown(),
+var toolCallPartSchema = z3.object({
+  type: z3.literal("tool-call"),
+  toolCallId: z3.string(),
+  toolName: z3.string(),
+  input: z3.unknown(),
   providerOptions: providerMetadataSchema.optional(),
-  providerExecuted: z4.boolean().optional()
+  providerExecuted: z3.boolean().optional()
 });
-var outputSchema = z4.discriminatedUnion(
+var outputSchema = z3.discriminatedUnion(
   "type",
   [
-    z4.object({
-      type: z4.literal("text"),
-      value: z4.string(),
+    z3.object({
+      type: z3.literal("text"),
+      value: z3.string(),
       providerOptions: providerMetadataSchema.optional()
     }),
-    z4.object({
-      type: z4.literal("json"),
+    z3.object({
+      type: z3.literal("json"),
       value: jsonValueSchema,
       providerOptions: providerMetadataSchema.optional()
     }),
-    z4.object({
-      type: z4.literal("execution-denied"),
-      reason: z4.string().optional(),
+    z3.object({
+      type: z3.literal("execution-denied"),
+      reason: z3.string().optional(),
       providerOptions: providerMetadataSchema.optional()
     }),
-    z4.object({
-      type: z4.literal("error-text"),
-      value: z4.string(),
+    z3.object({
+      type: z3.literal("error-text"),
+      value: z3.string(),
       providerOptions: providerMetadataSchema.optional()
     }),
-    z4.object({
-      type: z4.literal("error-json"),
+    z3.object({
+      type: z3.literal("error-json"),
       value: jsonValueSchema,
       providerOptions: providerMetadataSchema.optional()
     }),
-    z4.object({
-      type: z4.literal("content"),
-      value: z4.array(
-        z4.union([
-          z4.object({
-            type: z4.literal("text"),
-            text: z4.string(),
+    z3.object({
+      type: z3.literal("content"),
+      value: z3.array(
+        z3.union([
+          z3.object({
+            type: z3.literal("text"),
+            text: z3.string(),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("file-data"),
-            data: z4.string(),
-            mediaType: z4.string(),
-            filename: z4.string().optional(),
+          z3.object({
+            type: z3.literal("file-data"),
+            data: z3.string(),
+            mediaType: z3.string(),
+            filename: z3.string().optional(),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("file-url"),
-            url: z4.string(),
+          z3.object({
+            type: z3.literal("file-url"),
+            url: z3.string(),
             // Temporarily optional. TODO: make required in v8, after migration period.
-            mediaType: z4.string().optional(),
+            mediaType: z3.string().optional(),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("file-id"),
-            fileId: z4.union([z4.string(), z4.record(z4.string(), z4.string())]),
+          z3.object({
+            type: z3.literal("file-id"),
+            fileId: z3.union([z3.string(), z3.record(z3.string(), z3.string())]),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("file-reference"),
-            providerReference: z4.record(z4.string(), z4.string()),
+          z3.object({
+            type: z3.literal("file-reference"),
+            providerReference: z3.record(z3.string(), z3.string()),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("image-data"),
-            data: z4.string(),
-            mediaType: z4.string(),
+          z3.object({
+            type: z3.literal("image-data"),
+            data: z3.string(),
+            mediaType: z3.string(),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("image-url"),
-            url: z4.string(),
+          z3.object({
+            type: z3.literal("image-url"),
+            url: z3.string(),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("image-file-id"),
-            fileId: z4.union([z4.string(), z4.record(z4.string(), z4.string())]),
+          z3.object({
+            type: z3.literal("image-file-id"),
+            fileId: z3.union([z3.string(), z3.record(z3.string(), z3.string())]),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("image-file-reference"),
-            providerReference: z4.record(z4.string(), z4.string()),
+          z3.object({
+            type: z3.literal("image-file-reference"),
+            providerReference: z3.record(z3.string(), z3.string()),
             providerOptions: providerMetadataSchema.optional()
           }),
-          z4.object({
-            type: z4.literal("custom"),
+          z3.object({
+            type: z3.literal("custom"),
             providerOptions: providerMetadataSchema.optional()
           })
         ])
@@ -2334,47 +2127,47 @@ var outputSchema = z4.discriminatedUnion(
     })
   ]
 );
-var toolResultPartSchema = z4.object({
-  type: z4.literal("tool-result"),
-  toolCallId: z4.string(),
-  toolName: z4.string(),
+var toolResultPartSchema = z3.object({
+  type: z3.literal("tool-result"),
+  toolCallId: z3.string(),
+  toolName: z3.string(),
   output: outputSchema,
   providerOptions: providerMetadataSchema.optional()
 });
-var toolApprovalRequestSchema = z4.object({
-  type: z4.literal("tool-approval-request"),
-  approvalId: z4.string(),
-  toolCallId: z4.string()
+var toolApprovalRequestSchema = z3.object({
+  type: z3.literal("tool-approval-request"),
+  approvalId: z3.string(),
+  toolCallId: z3.string()
 });
-var toolApprovalResponseSchema = z4.object({
-  type: z4.literal("tool-approval-response"),
-  approvalId: z4.string(),
-  approved: z4.boolean(),
-  reason: z4.string().optional()
+var toolApprovalResponseSchema = z3.object({
+  type: z3.literal("tool-approval-response"),
+  approvalId: z3.string(),
+  approved: z3.boolean(),
+  reason: z3.string().optional()
 });
 
 // src/prompt/message.ts
-var systemModelMessageSchema = z5.object(
+var systemModelMessageSchema = z4.object(
   {
-    role: z5.literal("system"),
-    content: z5.string(),
+    role: z4.literal("system"),
+    content: z4.string(),
     providerOptions: providerMetadataSchema.optional()
   }
 );
-var userModelMessageSchema = z5.object({
-  role: z5.literal("user"),
-  content: z5.union([
-    z5.string(),
-    z5.array(z5.union([textPartSchema, imagePartSchema, filePartSchema]))
+var userModelMessageSchema = z4.object({
+  role: z4.literal("user"),
+  content: z4.union([
+    z4.string(),
+    z4.array(z4.union([textPartSchema, imagePartSchema, filePartSchema]))
   ]),
   providerOptions: providerMetadataSchema.optional()
 });
-var assistantModelMessageSchema = z5.object({
-  role: z5.literal("assistant"),
-  content: z5.union([
-    z5.string(),
-    z5.array(
-      z5.union([
+var assistantModelMessageSchema = z4.object({
+  role: z4.literal("assistant"),
+  content: z4.union([
+    z4.string(),
+    z4.array(
+      z4.union([
         textPartSchema,
         customPartSchema,
         filePartSchema,
@@ -2388,12 +2181,12 @@ var assistantModelMessageSchema = z5.object({
   ]),
   providerOptions: providerMetadataSchema.optional()
 });
-var toolModelMessageSchema = z5.object({
-  role: z5.literal("tool"),
-  content: z5.array(z5.union([toolResultPartSchema, toolApprovalResponseSchema])),
+var toolModelMessageSchema = z4.object({
+  role: z4.literal("tool"),
+  content: z4.array(z4.union([toolResultPartSchema, toolApprovalResponseSchema])),
   providerOptions: providerMetadataSchema.optional()
 });
-var modelMessageSchema = z5.union([
+var modelMessageSchema = z4.union([
   systemModelMessageSchema,
   userModelMessageSchema,
   assistantModelMessageSchema,
@@ -2449,7 +2242,7 @@ async function standardizePrompt({
   }
   const validationResult = await safeValidateTypes({
     value: messages,
-    schema: z6.array(modelMessageSchema)
+    schema: z5.array(modelMessageSchema)
   });
   if (!validationResult.success) {
     throw new InvalidPromptError2({
@@ -2463,14 +2256,14 @@ async function standardizePrompt({
 
 // src/prompt/wrap-gateway-error.ts
 import { GatewayAuthenticationError } from "@ai-sdk/gateway";
-import { AISDKError as AISDKError23 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError22 } from "@ai-sdk/provider";
 function wrapGatewayError(error) {
   if (!GatewayAuthenticationError.isInstance(error))
     return error;
   const isProductionEnv = (process == null ? void 0 : process.env.NODE_ENV) === "production";
   const moreInfoURL = "https://ai-sdk.dev/unauthenticated-ai-gateway";
   if (isProductionEnv) {
-    return new AISDKError23({
+    return new AISDKError22({
       name: "GatewayError",
       message: `Unauthenticated. Configure AI_GATEWAY_API_KEY or use a provider module. Learn more: ${moreInfoURL}`
     });
@@ -3001,8 +2794,8 @@ function filterActiveTools({
 
 // src/generate-text/generated-file.ts
 import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array3,
-  convertUint8ArrayToBase64 as convertUint8ArrayToBase642
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64
 } from "@ai-sdk/provider-utils";
 var DefaultGeneratedFile = class {
   constructor({
@@ -3017,14 +2810,14 @@ var DefaultGeneratedFile = class {
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get base64() {
     if (this.base64Data == null) {
-      this.base64Data = convertUint8ArrayToBase642(this.uint8ArrayData);
+      this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
     }
     return this.base64Data;
   }
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get uint8Array() {
     if (this.uint8ArrayData == null) {
-      this.uint8ArrayData = convertBase64ToUint8Array3(this.base64Data);
+      this.uint8ArrayData = convertBase64ToUint8Array(this.base64Data);
     }
     return this.uint8ArrayData;
   }
@@ -3710,6 +3503,15 @@ import {
   safeParseJSON as safeParseJSON3,
   safeValidateTypes as safeValidateTypes3
 } from "@ai-sdk/provider-utils";
+function mergeToolProviderMetadata(toolMetadata, callMetadata) {
+  if (toolMetadata == null) {
+    return callMetadata;
+  }
+  if (callMetadata == null) {
+    return toolMetadata;
+  }
+  return { ...toolMetadata, ...callMetadata };
+}
 async function parseToolCall({
   toolCall,
   tools,
@@ -3717,7 +3519,7 @@ async function parseToolCall({
   system,
   messages
 }) {
-  var _a21;
+  var _a21, _b;
   try {
     if (tools == null) {
       if (toolCall.providerExecuted && toolCall.dynamic) {
@@ -3768,7 +3570,10 @@ async function parseToolCall({
       error,
       title: (_a21 = tools == null ? void 0 : tools[toolCall.toolName]) == null ? void 0 : _a21.title,
       providerExecuted: toolCall.providerExecuted,
-      providerMetadata: toolCall.providerMetadata
+      providerMetadata: mergeToolProviderMetadata(
+        (_b = tools == null ? void 0 : tools[toolCall.toolName]) == null ? void 0 : _b.providerMetadata,
+        toolCall.providerMetadata
+      )
     };
   }
 }
@@ -3815,13 +3620,17 @@ async function doParseToolCall({
       cause: parseResult.error
     });
   }
+  const mergedProviderMetadata = mergeToolProviderMetadata(
+    tool2.providerMetadata,
+    toolCall.providerMetadata
+  );
   return tool2.type === "dynamic" ? {
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName: toolCall.toolName,
     input: parseResult.value,
     providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata,
+    providerMetadata: mergedProviderMetadata,
     dynamic: true,
     title: tool2.title
   } : {
@@ -3830,12 +3639,18 @@ async function doParseToolCall({
     toolName,
     input: parseResult.value,
     providerExecuted: toolCall.providerExecuted,
-    providerMetadata: toolCall.providerMetadata,
+    providerMetadata: mergedProviderMetadata,
     title: tool2.title
   };
 }
 
 // src/generate-text/reasoning-output.ts
+function unwrapReasoningFileData(data) {
+  if (typeof data === "object" && data !== null && "type" in data) {
+    return data.type === "data" ? data.data : data.url;
+  }
+  return data;
+}
 function convertFromReasoningOutputs(parts) {
   return parts.map((part) => {
     if (part.type === "reasoning") {
@@ -3862,10 +3677,12 @@ function convertToReasoningOutputs(parts) {
         ...part.providerOptions != null ? { providerMetadata: part.providerOptions } : {}
       };
     }
+    const rawData = unwrapReasoningFileData(part.data);
+    const fileData = rawData instanceof ArrayBuffer ? new Uint8Array(rawData) : rawData instanceof URL ? rawData.toString() : rawData;
     return {
       type: "reasoning-file",
       file: new DefaultGeneratedFile({
-        data: part.data instanceof ArrayBuffer ? new Uint8Array(part.data) : part.data instanceof URL ? part.data.toString() : part.data,
+        data: fileData,
         mediaType: part.mediaType
       }),
       ...part.providerOptions != null ? { providerMetadata: part.providerOptions } : {}
@@ -3887,6 +3704,40 @@ function mergeCallbacks(...callbacks) {
   };
 }
 
+// src/telemetry/diagnostic-channel.ts
+var AI_SDK_TELEMETRY_DIAGNOSTIC_CHANNEL = "aisdk:telemetry";
+
+// src/util/is-node-runtime.ts
+function isNodeRuntime() {
+  var _a21;
+  return typeof process !== "undefined" && ((_a21 = process.release) == null ? void 0 : _a21.name) === "node";
+}
+
+// src/telemetry/diagnostic-channel-publisher.ts
+var diagnosticsChannelPromise;
+async function loadDiagnosticsChannel() {
+  if (!isNodeRuntime()) {
+    return void 0;
+  }
+  if (diagnosticsChannelPromise == null) {
+    diagnosticsChannelPromise = import(
+      /* webpackIgnore: true */
+      "diagnostics_channel"
+    ).catch(() => void 0);
+  }
+  return diagnosticsChannelPromise;
+}
+async function publishTelemetryDiagnosticChannelMessage(message) {
+  const diagnosticsChannel = await loadDiagnosticsChannel();
+  if ((diagnosticsChannel == null ? void 0 : diagnosticsChannel.hasSubscribers(AI_SDK_TELEMETRY_DIAGNOSTIC_CHANNEL)) !== true) {
+    return;
+  }
+  try {
+    diagnosticsChannel.channel(AI_SDK_TELEMETRY_DIAGNOSTIC_CHANNEL).publish(message);
+  } catch (e) {
+  }
+}
+
 // src/telemetry/telemetry-registry.ts
 function registerTelemetry(...integrations) {
   if (!globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) {
@@ -3921,7 +3772,12 @@ function createTelemetryDispatcher({
     functionId: telemetry == null ? void 0 : telemetry.functionId
   };
   const mergeTelemetryCallback = (key) => {
+    const publishDiagnosticChannelMessage = (event) => publishTelemetryDiagnosticChannelMessage({
+      type: key,
+      event: augmentEvent(event, telemetryMetadata)
+    });
     return mergeCallbacks(
+      publishDiagnosticChannelMessage,
       ...integrations.map((integration) => {
         var _a21;
         return (_a21 = integration[key]) == null ? void 0 : _a21.bind(integration);
@@ -5199,7 +5055,10 @@ function asContent({
       case "reasoning-file": {
         contentParts.push({
           type: part.type,
-          file: new DefaultGeneratedFile(part),
+          file: new DefaultGeneratedFile({
+            data: part.data.type === "data" ? part.data.data : part.data.url.toString(),
+            mediaType: part.mediaType
+          }),
           ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
         });
         break;
@@ -5466,172 +5325,172 @@ function getResponseUIMessageId({
 import { validateTypes as validateTypes2 } from "@ai-sdk/provider-utils";
 
 // src/ui-message-stream/ui-message-chunks.ts
-import { z as z7 } from "zod/v4";
+import { z as z6 } from "zod/v4";
 import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
 var uiMessageChunkSchema = lazySchema(
   () => zodSchema(
-    z7.union([
-      z7.strictObject({
-        type: z7.literal("text-start"),
-        id: z7.string(),
+    z6.union([
+      z6.strictObject({
+        type: z6.literal("text-start"),
+        id: z6.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("text-delta"),
-        id: z7.string(),
-        delta: z7.string(),
+      z6.strictObject({
+        type: z6.literal("text-delta"),
+        id: z6.string(),
+        delta: z6.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("text-end"),
-        id: z7.string(),
+      z6.strictObject({
+        type: z6.literal("text-end"),
+        id: z6.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("error"),
-        errorText: z7.string()
+      z6.strictObject({
+        type: z6.literal("error"),
+        errorText: z6.string()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-input-start"),
-        toolCallId: z7.string(),
-        toolName: z7.string(),
-        providerExecuted: z7.boolean().optional(),
+      z6.strictObject({
+        type: z6.literal("tool-input-start"),
+        toolCallId: z6.string(),
+        toolName: z6.string(),
+        providerExecuted: z6.boolean().optional(),
         providerMetadata: providerMetadataSchema.optional(),
-        dynamic: z7.boolean().optional(),
-        title: z7.string().optional()
+        dynamic: z6.boolean().optional(),
+        title: z6.string().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-input-delta"),
-        toolCallId: z7.string(),
-        inputTextDelta: z7.string()
+      z6.strictObject({
+        type: z6.literal("tool-input-delta"),
+        toolCallId: z6.string(),
+        inputTextDelta: z6.string()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-input-available"),
-        toolCallId: z7.string(),
-        toolName: z7.string(),
-        input: z7.unknown(),
-        providerExecuted: z7.boolean().optional(),
+      z6.strictObject({
+        type: z6.literal("tool-input-available"),
+        toolCallId: z6.string(),
+        toolName: z6.string(),
+        input: z6.unknown(),
+        providerExecuted: z6.boolean().optional(),
         providerMetadata: providerMetadataSchema.optional(),
-        dynamic: z7.boolean().optional(),
-        title: z7.string().optional()
+        dynamic: z6.boolean().optional(),
+        title: z6.string().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-input-error"),
-        toolCallId: z7.string(),
-        toolName: z7.string(),
-        input: z7.unknown(),
-        providerExecuted: z7.boolean().optional(),
+      z6.strictObject({
+        type: z6.literal("tool-input-error"),
+        toolCallId: z6.string(),
+        toolName: z6.string(),
+        input: z6.unknown(),
+        providerExecuted: z6.boolean().optional(),
         providerMetadata: providerMetadataSchema.optional(),
-        dynamic: z7.boolean().optional(),
-        errorText: z7.string(),
-        title: z7.string().optional()
+        dynamic: z6.boolean().optional(),
+        errorText: z6.string(),
+        title: z6.string().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-approval-request"),
-        approvalId: z7.string(),
-        toolCallId: z7.string(),
-        isAutomatic: z7.boolean().optional()
+      z6.strictObject({
+        type: z6.literal("tool-approval-request"),
+        approvalId: z6.string(),
+        toolCallId: z6.string(),
+        isAutomatic: z6.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-approval-response"),
-        approvalId: z7.string(),
-        approved: z7.boolean(),
-        reason: z7.string().optional(),
-        providerExecuted: z7.boolean().optional(),
+      z6.strictObject({
+        type: z6.literal("tool-approval-response"),
+        approvalId: z6.string(),
+        approved: z6.boolean(),
+        reason: z6.string().optional(),
+        providerExecuted: z6.boolean().optional(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-output-available"),
-        toolCallId: z7.string(),
-        output: z7.unknown(),
-        providerExecuted: z7.boolean().optional(),
+      z6.strictObject({
+        type: z6.literal("tool-output-available"),
+        toolCallId: z6.string(),
+        output: z6.unknown(),
+        providerExecuted: z6.boolean().optional(),
         providerMetadata: providerMetadataSchema.optional(),
-        dynamic: z7.boolean().optional(),
-        preliminary: z7.boolean().optional()
+        dynamic: z6.boolean().optional(),
+        preliminary: z6.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-output-error"),
-        toolCallId: z7.string(),
-        errorText: z7.string(),
-        providerExecuted: z7.boolean().optional(),
+      z6.strictObject({
+        type: z6.literal("tool-output-error"),
+        toolCallId: z6.string(),
+        errorText: z6.string(),
+        providerExecuted: z6.boolean().optional(),
         providerMetadata: providerMetadataSchema.optional(),
-        dynamic: z7.boolean().optional()
+        dynamic: z6.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("tool-output-denied"),
-        toolCallId: z7.string()
+      z6.strictObject({
+        type: z6.literal("tool-output-denied"),
+        toolCallId: z6.string()
       }),
-      z7.strictObject({
-        type: z7.literal("reasoning-start"),
-        id: z7.string(),
+      z6.strictObject({
+        type: z6.literal("reasoning-start"),
+        id: z6.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("reasoning-delta"),
-        id: z7.string(),
-        delta: z7.string(),
+      z6.strictObject({
+        type: z6.literal("reasoning-delta"),
+        id: z6.string(),
+        delta: z6.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("reasoning-end"),
-        id: z7.string(),
+      z6.strictObject({
+        type: z6.literal("reasoning-end"),
+        id: z6.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("custom"),
-        kind: z7.string().transform((value) => value),
+      z6.strictObject({
+        type: z6.literal("custom"),
+        kind: z6.string().transform((value) => value),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("source-url"),
-        sourceId: z7.string(),
-        url: z7.string(),
-        title: z7.string().optional(),
+      z6.strictObject({
+        type: z6.literal("source-url"),
+        sourceId: z6.string(),
+        url: z6.string(),
+        title: z6.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(),
+      z6.strictObject({
+        type: z6.literal("source-document"),
+        sourceId: z6.string(),
+        mediaType: z6.string(),
+        title: z6.string(),
+        filename: z6.string().optional(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("file"),
-        url: z7.string(),
-        mediaType: z7.string(),
+      z6.strictObject({
+        type: z6.literal("file"),
+        url: z6.string(),
+        mediaType: z6.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.literal("reasoning-file"),
-        url: z7.string(),
-        mediaType: z7.string(),
+      z6.strictObject({
+        type: z6.literal("reasoning-file"),
+        url: z6.string(),
+        mediaType: z6.string(),
         providerMetadata: providerMetadataSchema.optional()
       }),
-      z7.strictObject({
-        type: z7.custom(
+      z6.strictObject({
+        type: z6.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: z6.string().optional(),
+        data: z6.unknown(),
+        transient: z6.boolean().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("start-step")
+      z6.strictObject({
+        type: z6.literal("start-step")
       }),
-      z7.strictObject({
-        type: z7.literal("finish-step")
+      z6.strictObject({
+        type: z6.literal("finish-step")
       }),
-      z7.strictObject({
-        type: z7.literal("start"),
-        messageId: z7.string().optional(),
-        messageMetadata: z7.unknown().optional()
+      z6.strictObject({
+        type: z6.literal("start"),
+        messageId: z6.string().optional(),
+        messageMetadata: z6.unknown().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("finish"),
-        finishReason: z7.enum([
+      z6.strictObject({
+        type: z6.literal("finish"),
+        finishReason: z6.enum([
           "stop",
           "length",
           "content-filter",
@@ -5639,15 +5498,15 @@ var uiMessageChunkSchema = lazySchema(
           "error",
           "other"
         ]).optional(),
-        messageMetadata: z7.unknown().optional()
+        messageMetadata: z6.unknown().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("abort"),
-        reason: z7.string().optional()
+      z6.strictObject({
+        type: z6.literal("abort"),
+        reason: z6.string().optional()
       }),
-      z7.strictObject({
-        type: z7.literal("message-metadata"),
-        messageMetadata: z7.unknown()
+      z6.strictObject({
+        type: z6.literal("message-metadata"),
+        messageMetadata: z6.unknown()
       })
     ])
   )
@@ -6989,7 +6848,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
         case "file":
         case "reasoning-file": {
           const file = new DefaultGeneratedFileWithType({
-            data: chunk.data,
+            data: chunk.data.type === "data" ? chunk.data.data : chunk.data.url.toString(),
             mediaType: chunk.mediaType
           });
           modelCallContent.push({
@@ -7903,6 +7762,7 @@ var DefaultStreamTextResult = class {
                 toolChoice: (_b2 = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _b2 : toolChoice,
                 system: stepSystem,
                 messages: stepMessages,
+                allowSystemInMessages,
                 repairToolCall,
                 abortSignal,
                 headers,
@@ -9072,7 +8932,7 @@ async function convertToModelMessages(messages, options) {
         modelMessages.push({
           role: "user",
           content: message.parts.map((part) => {
-            var _a21, _b;
+            var _a21;
             if (isTextUIPart(part)) {
               return {
                 type: "text",
@@ -9085,12 +8945,15 @@ async function convertToModelMessages(messages, options) {
                 type: "file",
                 mediaType: part.mediaType,
                 filename: part.filename,
-                data: (_a21 = part.providerReference) != null ? _a21 : part.url,
+                data: part.providerReference != null ? {
+                  type: "reference",
+                  reference: part.providerReference
+                } : { type: "url", url: new URL(part.url) },
                 ...part.providerMetadata != null ? { providerOptions: part.providerMetadata } : {}
               };
             }
             if (isDataUIPart(part)) {
-              return (_b = options == null ? void 0 : options.convertDataPart) == null ? void 0 : _b.call(
+              return (_a21 = options == null ? void 0 : options.convertDataPart) == null ? void 0 : _a21.call(
                 options,
                 part
               );
@@ -9103,7 +8966,7 @@ async function convertToModelMessages(messages, options) {
         if (message.parts != null) {
           let block = [];
           async function processBlock() {
-            var _a21, _b, _c, _d, _e, _f, _g, _h, _i;
+            var _a21, _b, _c, _d, _e, _f, _g, _h;
             if (block.length === 0) {
               return;
             }
@@ -9126,13 +8989,16 @@ async function convertToModelMessages(messages, options) {
                   type: "file",
                   mediaType: part.mediaType,
                   filename: part.filename,
-                  data: (_a21 = part.providerReference) != null ? _a21 : part.url,
+                  data: part.providerReference != null ? {
+                    type: "reference",
+                    reference: part.providerReference
+                  } : { type: "url", url: new URL(part.url) },
                   ...part.providerMetadata != null ? { providerOptions: part.providerMetadata } : {}
                 });
               } else if (isReasoningFileUIPart(part)) {
                 content.push({
                   type: "reasoning-file",
-                  data: part.url,
+                  data: { type: "url", url: new URL(part.url) },
                   mediaType: part.mediaType,
                   providerOptions: part.providerMetadata
                 });
@@ -9149,7 +9015,7 @@ async function convertToModelMessages(messages, options) {
                     type: "tool-call",
                     toolCallId: part.toolCallId,
                     toolName,
-                    input: part.state === "output-error" ? (_b = part.input) != null ? _b : "rawInput" in part ? part.rawInput : void 0 : part.input,
+                    input: part.state === "output-error" ? (_a21 = part.input) != null ? _a21 : "rawInput" in part ? part.rawInput : void 0 : part.input,
                     providerExecuted: part.providerExecuted,
                     ...part.callProviderMetadata != null ? { providerOptions: part.callProviderMetadata } : {}
                   });
@@ -9162,7 +9028,7 @@ async function convertToModelMessages(messages, options) {
                     });
                   }
                   if (part.providerExecuted === true && part.state !== "approval-responded" && (part.state === "output-available" || part.state === "output-error")) {
-                    const resultProviderMetadata = (_c = part.resultProviderMetadata) != null ? _c : part.callProviderMetadata;
+                    const resultProviderMetadata = (_b = part.resultProviderMetadata) != null ? _b : part.callProviderMetadata;
                     content.push({
                       type: "tool-result",
                       toolCallId: part.toolCallId,
@@ -9171,7 +9037,7 @@ async function convertToModelMessages(messages, options) {
                         toolCallId: part.toolCallId,
                         input: part.input,
                         output: part.state === "output-error" ? part.errorText : part.output,
-                        tool: (_d = options == null ? void 0 : options.tools) == null ? void 0 : _d[toolName],
+                        tool: (_c = options == null ? void 0 : options.tools) == null ? void 0 : _c[toolName],
                         errorMode: part.state === "output-error" ? "json" : "none"
                       }),
                       ...resultProviderMetadata != null ? { providerOptions: resultProviderMetadata } : {}
@@ -9179,7 +9045,7 @@ async function convertToModelMessages(messages, options) {
                   }
                 }
               } else if (isDataUIPart(part)) {
-                const dataPart = (_e = options == null ? void 0 : options.convertDataPart) == null ? void 0 : _e.call(
+                const dataPart = (_d = options == null ? void 0 : options.convertDataPart) == null ? void 0 : _d.call(
                   options,
                   part
                 );
@@ -9205,7 +9071,7 @@ async function convertToModelMessages(messages, options) {
               {
                 const content2 = [];
                 for (const toolPart of toolParts) {
-                  if (((_f = toolPart.approval) == null ? void 0 : _f.approved) != null) {
+                  if (((_e = toolPart.approval) == null ? void 0 : _e.approved) != null) {
                     content2.push({
                       type: "tool-approval-response",
                       approvalId: toolPart.approval.id,
@@ -9214,7 +9080,7 @@ async function convertToModelMessages(messages, options) {
                       providerExecuted: toolPart.providerExecuted
                     });
                   }
-                  if (toolPart.state === "approval-responded" && ((_g = toolPart.approval) == null ? void 0 : _g.approved) === false) {
+                  if (toolPart.state === "approval-responded" && ((_f = toolPart.approval) == null ? void 0 : _f.approved) === false) {
                     content2.push({
                       type: "tool-result",
                       toolCallId: toolPart.toolCallId,
@@ -9237,7 +9103,7 @@ async function convertToModelMessages(messages, options) {
                         toolName: getToolName(toolPart),
                         output: {
                           type: "error-text",
-                          value: (_h = toolPart.approval.reason) != null ? _h : "Tool call execution denied."
+                          value: (_g = toolPart.approval.reason) != null ? _g : "Tool call execution denied."
                         },
                         ...toolPart.callProviderMetadata != null ? { providerOptions: toolPart.callProviderMetadata } : {}
                       });
@@ -9254,7 +9120,7 @@ async function convertToModelMessages(messages, options) {
                           toolCallId: toolPart.toolCallId,
                           input: toolPart.input,
                           output: toolPart.state === "output-error" ? toolPart.errorText : toolPart.output,
-                          tool: (_i = options == null ? void 0 : options.tools) == null ? void 0 : _i[toolName],
+                          tool: (_h = options == null ? void 0 : options.tools) == null ? void 0 : _h[toolName],
                           errorMode: toolPart.state === "output-error" ? "text" : "none"
                         }),
                         ...toolPart.callProviderMetadata != null ? { providerOptions: toolPart.callProviderMetadata } : {}
@@ -9304,286 +9170,286 @@ import {
   validateTypes as validateTypes4,
   zodSchema as zodSchema2
 } from "@ai-sdk/provider-utils";
-import { z as z8 } from "zod/v4";
+import { z as z7 } from "zod/v4";
 var uiMessagesSchema = lazySchema2(
   () => zodSchema2(
-    z8.array(
-      z8.object({
-        id: z8.string(),
-        role: z8.enum(["system", "user", "assistant"]),
-        metadata: z8.unknown().optional(),
-        parts: z8.array(
-          z8.union([
-            z8.object({
-              type: z8.literal("text"),
-              text: z8.string(),
-              state: z8.enum(["streaming", "done"]).optional(),
+    z7.array(
+      z7.object({
+        id: z7.string(),
+        role: z7.enum(["system", "user", "assistant"]),
+        metadata: z7.unknown().optional(),
+        parts: z7.array(
+          z7.union([
+            z7.object({
+              type: z7.literal("text"),
+              text: z7.string(),
+              state: z7.enum(["streaming", "done"]).optional(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z8.object({
-              type: z8.literal("reasoning"),
-              text: z8.string(),
-              state: z8.enum(["streaming", "done"]).optional(),
+            z7.object({
+              type: z7.literal("reasoning"),
+              text: z7.string(),
+              state: z7.enum(["streaming", "done"]).optional(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z8.object({
-              type: z8.literal("custom"),
-              kind: z8.string(),
+            z7.object({
+              type: z7.literal("custom"),
+              kind: z7.string(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z8.object({
-              type: z8.literal("source-url"),
-              sourceId: z8.string(),
-              url: z8.string(),
-              title: z8.string().optional(),
+            z7.object({
+              type: z7.literal("source-url"),
+              sourceId: z7.string(),
+              url: z7.string(),
+              title: z7.string().optional(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z8.object({
-              type: z8.literal("source-document"),
-              sourceId: z8.string(),
-              mediaType: z8.string(),
-              title: z8.string(),
-              filename: z8.string().optional(),
+            z7.object({
+              type: z7.literal("source-document"),
+              sourceId: z7.string(),
+              mediaType: z7.string(),
+              title: z7.string(),
+              filename: z7.string().optional(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z8.object({
-              type: z8.literal("file"),
-              mediaType: z8.string(),
-              filename: z8.string().optional(),
-              url: z8.string(),
+            z7.object({
+              type: z7.literal("file"),
+              mediaType: z7.string(),
+              filename: z7.string().optional(),
+              url: z7.string(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z8.object({
-              type: z8.literal("reasoning-file"),
-              mediaType: z8.string(),
-              url: z8.string(),
+            z7.object({
+              type: z7.literal("reasoning-file"),
+              mediaType: z7.string(),
+              url: z7.string(),
               providerMetadata: providerMetadataSchema.optional()
             }),
-            z8.object({
-              type: z8.literal("step-start")
+            z7.object({
+              type: z7.literal("step-start")
             }),
-            z8.object({
-              type: z8.string().startsWith("data-"),
-              id: z8.string().optional(),
-              data: z8.unknown()
+            z7.object({
+              type: z7.string().startsWith("data-"),
+              id: z7.string().optional(),
+              data: z7.unknown()
             }),
-            z8.object({
-              type: z8.literal("dynamic-tool"),
-              toolName: z8.string(),
-              toolCallId: z8.string(),
-              state: z8.literal("input-streaming"),
-              input: z8.unknown().optional(),
-              providerExecuted: z8.boolean().optional(),
+            z7.object({
+              type: z7.literal("dynamic-tool"),
+              toolName: z7.string(),
+              toolCallId: z7.string(),
+              state: z7.literal("input-streaming"),
+              input: z7.unknown().optional(),
+              providerExecuted: z7.boolean().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
-              approval: z8.never().optional()
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
+              approval: z7.never().optional()
             }),
-            z8.object({
-              type: z8.literal("dynamic-tool"),
-              toolName: z8.string(),
-              toolCallId: z8.string(),
-              state: z8.literal("input-available"),
-              input: z8.unknown(),
-              providerExecuted: z8.boolean().optional(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.literal("dynamic-tool"),
+              toolName: z7.string(),
+              toolCallId: z7.string(),
+              state: z7.literal("input-available"),
+              input: z7.unknown(),
+              providerExecuted: z7.boolean().optional(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.never().optional()
+              approval: z7.never().optional()
             }),
-            z8.object({
-              type: z8.literal("dynamic-tool"),
-              toolName: z8.string(),
-              toolCallId: z8.string(),
-              state: z8.literal("approval-requested"),
-              input: z8.unknown(),
-              providerExecuted: z8.boolean().optional(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.literal("dynamic-tool"),
+              toolName: z7.string(),
+              toolCallId: z7.string(),
+              state: z7.literal("approval-requested"),
+              input: z7.unknown(),
+              providerExecuted: z7.boolean().optional(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.never().optional(),
-                reason: z8.never().optional(),
-                isAutomatic: z8.boolean().optional()
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.never().optional(),
+                reason: z7.never().optional(),
+                isAutomatic: z7.boolean().optional()
               })
             }),
-            z8.object({
-              type: z8.literal("dynamic-tool"),
-              toolName: z8.string(),
-              toolCallId: z8.string(),
-              state: z8.literal("approval-responded"),
-              input: z8.unknown(),
-              providerExecuted: z8.boolean().optional(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.literal("dynamic-tool"),
+              toolName: z7.string(),
+              toolCallId: z7.string(),
+              state: z7.literal("approval-responded"),
+              input: z7.unknown(),
+              providerExecuted: z7.boolean().optional(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.boolean(),
-                reason: z8.string().optional(),
-                isAutomatic: z8.boolean().optional()
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.boolean(),
+                reason: z7.string().optional(),
+                isAutomatic: z7.boolean().optional()
               })
             }),
-            z8.object({
-              type: z8.literal("dynamic-tool"),
-              toolName: z8.string(),
-              toolCallId: z8.string(),
-              state: z8.literal("output-available"),
-              input: z8.unknown(),
-              providerExecuted: z8.boolean().optional(),
-              output: z8.unknown(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.literal("dynamic-tool"),
+              toolName: z7.string(),
+              toolCallId: z7.string(),
+              state: z7.literal("output-available"),
+              input: z7.unknown(),
+              providerExecuted: z7.boolean().optional(),
+              output: z7.unknown(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
               resultProviderMetadata: providerMetadataSchema.optional(),
-              preliminary: z8.boolean().optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.literal(true),
-                reason: z8.string().optional(),
-                isAutomatic: z8.boolean().optional()
+              preliminary: z7.boolean().optional(),
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.literal(true),
+                reason: z7.string().optional(),
+                isAutomatic: z7.boolean().optional()
               }).optional()
             }),
-            z8.object({
-              type: z8.literal("dynamic-tool"),
-              toolName: z8.string(),
-              toolCallId: z8.string(),
-              state: z8.literal("output-error"),
-              input: z8.unknown(),
-              rawInput: z8.unknown().optional(),
-              providerExecuted: z8.boolean().optional(),
-              output: z8.never().optional(),
-              errorText: z8.string(),
+            z7.object({
+              type: z7.literal("dynamic-tool"),
+              toolName: z7.string(),
+              toolCallId: z7.string(),
+              state: z7.literal("output-error"),
+              input: z7.unknown(),
+              rawInput: z7.unknown().optional(),
+              providerExecuted: z7.boolean().optional(),
+              output: z7.never().optional(),
+              errorText: z7.string(),
               callProviderMetadata: providerMetadataSchema.optional(),
               resultProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.literal(true),
-                reason: z8.string().optional(),
-                isAutomatic: z8.boolean().optional()
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.literal(true),
+                reason: z7.string().optional(),
+                isAutomatic: z7.boolean().optional()
               }).optional()
             }),
-            z8.object({
-              type: z8.literal("dynamic-tool"),
-              toolName: z8.string(),
-              toolCallId: z8.string(),
-              state: z8.literal("output-denied"),
-              input: z8.unknown(),
-              providerExecuted: z8.boolean().optional(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.literal("dynamic-tool"),
+              toolName: z7.string(),
+              toolCallId: z7.string(),
+              state: z7.literal("output-denied"),
+              input: z7.unknown(),
+              providerExecuted: z7.boolean().optional(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.literal(false),
-                reason: z8.string().optional(),
-                isAutomatic: z8.boolean().optional()
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.literal(false),
+                reason: z7.string().optional(),
+                isAutomatic: z7.boolean().optional()
               })
             }),
-            z8.object({
-              type: z8.string().startsWith("tool-"),
-              toolCallId: z8.string(),
-              state: z8.literal("input-streaming"),
-              providerExecuted: z8.boolean().optional(),
+            z7.object({
+              type: z7.string().startsWith("tool-"),
+              toolCallId: z7.string(),
+              state: z7.literal("input-streaming"),
+              providerExecuted: z7.boolean().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              input: z8.unknown().optional(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
-              approval: z8.never().optional()
+              input: z7.unknown().optional(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
+              approval: z7.never().optional()
             }),
-            z8.object({
-              type: z8.string().startsWith("tool-"),
-              toolCallId: z8.string(),
-              state: z8.literal("input-available"),
-              providerExecuted: z8.boolean().optional(),
-              input: z8.unknown(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.string().startsWith("tool-"),
+              toolCallId: z7.string(),
+              state: z7.literal("input-available"),
+              providerExecuted: z7.boolean().optional(),
+              input: z7.unknown(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.never().optional()
+              approval: z7.never().optional()
             }),
-            z8.object({
-              type: z8.string().startsWith("tool-"),
-              toolCallId: z8.string(),
-              state: z8.literal("approval-requested"),
-              input: z8.unknown(),
-              providerExecuted: z8.boolean().optional(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.string().startsWith("tool-"),
+              toolCallId: z7.string(),
+              state: z7.literal("approval-requested"),
+              input: z7.unknown(),
+              providerExecuted: z7.boolean().optional(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.never().optional(),
-                reason: z8.never().optional(),
-                isAutomatic: z8.boolean().optional()
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.never().optional(),
+                reason: z7.never().optional(),
+                isAutomatic: z7.boolean().optional()
               })
             }),
-            z8.object({
-              type: z8.string().startsWith("tool-"),
-              toolCallId: z8.string(),
-              state: z8.literal("approval-responded"),
-              input: z8.unknown(),
-              providerExecuted: z8.boolean().optional(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.string().startsWith("tool-"),
+              toolCallId: z7.string(),
+              state: z7.literal("approval-responded"),
+              input: z7.unknown(),
+              providerExecuted: z7.boolean().optional(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.boolean(),
-                reason: z8.string().optional(),
-                isAutomatic: z8.boolean().optional()
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.boolean(),
+                reason: z7.string().optional(),
+                isAutomatic: z7.boolean().optional()
               })
             }),
-            z8.object({
-              type: z8.string().startsWith("tool-"),
-              toolCallId: z8.string(),
-              state: z8.literal("output-available"),
-              providerExecuted: z8.boolean().optional(),
-              input: z8.unknown(),
-              output: z8.unknown(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.string().startsWith("tool-"),
+              toolCallId: z7.string(),
+              state: z7.literal("output-available"),
+              providerExecuted: z7.boolean().optional(),
+              input: z7.unknown(),
+              output: z7.unknown(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
               resultProviderMetadata: providerMetadataSchema.optional(),
-              preliminary: z8.boolean().optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.literal(true),
-                reason: z8.string().optional(),
-                isAutomatic: z8.boolean().optional()
+              preliminary: z7.boolean().optional(),
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.literal(true),
+                reason: z7.string().optional(),
+                isAutomatic: z7.boolean().optional()
               }).optional()
             }),
-            z8.object({
-              type: z8.string().startsWith("tool-"),
-              toolCallId: z8.string(),
-              state: z8.literal("output-error"),
-              providerExecuted: z8.boolean().optional(),
-              input: z8.unknown(),
-              rawInput: z8.unknown().optional(),
-              output: z8.never().optional(),
-              errorText: z8.string(),
+            z7.object({
+              type: z7.string().startsWith("tool-"),
+              toolCallId: z7.string(),
+              state: z7.literal("output-error"),
+              providerExecuted: z7.boolean().optional(),
+              input: z7.unknown(),
+              rawInput: z7.unknown().optional(),
+              output: z7.never().optional(),
+              errorText: z7.string(),
               callProviderMetadata: providerMetadataSchema.optional(),
               resultProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.literal(true),
-                reason: z8.string().optional(),
-                isAutomatic: z8.boolean().optional()
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.literal(true),
+                reason: z7.string().optional(),
+                isAutomatic: z7.boolean().optional()
               }).optional()
             }),
-            z8.object({
-              type: z8.string().startsWith("tool-"),
-              toolCallId: z8.string(),
-              state: z8.literal("output-denied"),
-              providerExecuted: z8.boolean().optional(),
-              input: z8.unknown(),
-              output: z8.never().optional(),
-              errorText: z8.never().optional(),
+            z7.object({
+              type: z7.string().startsWith("tool-"),
+              toolCallId: z7.string(),
+              state: z7.literal("output-denied"),
+              providerExecuted: z7.boolean().optional(),
+              input: z7.unknown(),
+              output: z7.never().optional(),
+              errorText: z7.never().optional(),
               callProviderMetadata: providerMetadataSchema.optional(),
-              approval: z8.object({
-                id: z8.string(),
-                approved: z8.literal(false),
-                reason: z8.string().optional(),
-                isAutomatic: z8.boolean().optional()
+              approval: z7.object({
+                id: z7.string(),
+                approved: z7.literal(false),
+                reason: z7.string().optional(),
+                isAutomatic: z7.boolean().optional()
               })
             })
           ])
@@ -10202,9 +10068,47 @@ var DefaultEmbedManyResult = class {
 
 // src/generate-image/generate-image.ts
 import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array4,
+  convertBase64ToUint8Array as convertBase64ToUint8Array3,
+  detectMediaType as detectMediaType2,
   withUserAgentSuffix as withUserAgentSuffix5
 } from "@ai-sdk/provider-utils";
+
+// src/prompt/data-content.ts
+import {
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642
+} from "@ai-sdk/provider-utils";
+function convertDataContentToBase64String(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content instanceof ArrayBuffer) {
+    return convertUint8ArrayToBase642(new Uint8Array(content));
+  }
+  return convertUint8ArrayToBase642(content);
+}
+function convertDataContentToUint8Array(content) {
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+  if (typeof content === "string") {
+    try {
+      return convertBase64ToUint8Array2(content);
+    } catch (error) {
+      throw new InvalidDataContentError({
+        message: "Invalid data content. Content string is not a base64-encoded media.",
+        content,
+        cause: error
+      });
+    }
+  }
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
+  }
+  throw new InvalidDataContentError({ content });
+}
+
+// src/generate-image/generate-image.ts
 async function generateImage({
   model: modelArg,
   prompt: promptArg,
@@ -10272,9 +10176,9 @@ async function generateImage({
           var _a22;
           return new DefaultGeneratedFile({
             data: image,
-            mediaType: (_a22 = detectMediaType({
+            mediaType: (_a22 = detectMediaType2({
               data: image,
-              signatures: imageMediaTypeSignatures
+              topLevelType: "image"
             })) != null ? _a22 : "image/png"
           });
         }
@@ -10363,13 +10267,13 @@ function toImageModelV4File(dataContent) {
   if (typeof dataContent === "string" && dataContent.startsWith("data:")) {
     const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(dataContent);
     if (base64Content != null) {
-      const uint8Data2 = convertBase64ToUint8Array4(base64Content);
+      const uint8Data2 = convertBase64ToUint8Array3(base64Content);
       return {
         type: "file",
         data: uint8Data2,
-        mediaType: dataUrlMediaType || detectMediaType({
+        mediaType: dataUrlMediaType || detectMediaType2({
           data: uint8Data2,
-          signatures: imageMediaTypeSignatures
+          topLevelType: "image"
         }) || "image/png"
       };
     }
@@ -10378,9 +10282,9 @@ function toImageModelV4File(dataContent) {
   return {
     type: "file",
     data: uint8Data,
-    mediaType: detectMediaType({
+    mediaType: detectMediaType2({
       data: uint8Data,
-      signatures: imageMediaTypeSignatures
+      topLevelType: "image"
     }) || "image/png"
   };
 }
@@ -11733,7 +11637,10 @@ var DefaultStreamObjectResult = class {
 };
 
 // src/generate-speech/generate-speech.ts
-import { withUserAgentSuffix as withUserAgentSuffix7 } from "@ai-sdk/provider-utils";
+import {
+  detectMediaType as detectMediaType3,
+  withUserAgentSuffix as withUserAgentSuffix7
+} from "@ai-sdk/provider-utils";
 
 // src/generate-speech/generated-audio-file.ts
 var DefaultGeneratedAudioFile = class extends DefaultGeneratedFile {
@@ -11811,9 +11718,9 @@ async function generateSpeech({
   return new DefaultSpeechResult({
     audio: new DefaultGeneratedAudioFile({
       data: result.audio,
-      mediaType: (_a21 = detectMediaType({
+      mediaType: (_a21 = detectMediaType3({
         data: result.audio,
-        signatures: audioMediaTypeSignatures
+        topLevelType: "audio"
       })) != null ? _a21 : "audio/mp3"
     }),
     warnings: result.warnings,
@@ -11912,7 +11819,9 @@ function pruneMessages({
 
 // src/generate-text/smooth-stream.ts
 import { delay as originalDelay } from "@ai-sdk/provider-utils";
-import { InvalidArgumentError as InvalidArgumentError2 } from "@ai-sdk/provider";
+import {
+  InvalidArgumentError as InvalidArgumentError2
+} from "@ai-sdk/provider";
 var CHUNKING_REGEXPS = {
   word: /\S+\s+/m,
   line: /\n+/m
@@ -12010,8 +11919,9 @@ function smoothStream({
 
 // src/generate-video/generate-video.ts
 import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array5,
-  withUserAgentSuffix as withUserAgentSuffix8
+  convertBase64ToUint8Array as convertBase64ToUint8Array4,
+  withUserAgentSuffix as withUserAgentSuffix8,
+  detectMediaType as detectMediaType4
 } from "@ai-sdk/provider-utils";
 var defaultDownload = createDownload();
 async function experimental_generateVideo({
@@ -12079,9 +11989,9 @@ async function experimental_generateVideo({
             abortSignal
           });
           const isUsableMediaType = (type) => !!type && type !== "application/octet-stream";
-          const mediaType = isUsableMediaType(videoData.mediaType) && videoData.mediaType || isUsableMediaType(downloadedMediaType) && downloadedMediaType || detectMediaType({
+          const mediaType = isUsableMediaType(videoData.mediaType) && videoData.mediaType || isUsableMediaType(downloadedMediaType) && downloadedMediaType || detectMediaType4({
             data,
-            signatures: videoMediaTypeSignatures
+            topLevelType: "video"
           }) || "video/mp4";
           videos.push(
             new DefaultGeneratedFile({
@@ -12101,9 +12011,9 @@ async function experimental_generateVideo({
           break;
         }
         case "binary": {
-          const mediaType = videoData.mediaType || detectMediaType({
+          const mediaType = videoData.mediaType || detectMediaType4({
             data: videoData.data,
-            signatures: videoMediaTypeSignatures
+            topLevelType: "video"
           }) || "video/mp4";
           videos.push(
             new DefaultGeneratedFile({
@@ -12184,13 +12094,13 @@ function normalizePrompt2(promptArg) {
         image = {
           type: "file",
           mediaType: mediaType != null ? mediaType : "image/png",
-          data: convertBase64ToUint8Array5(base64Content != null ? base64Content : "")
+          data: convertBase64ToUint8Array4(base64Content != null ? base64Content : "")
         };
       } else {
-        const bytes = convertBase64ToUint8Array5(dataContent);
-        const mediaType = (_a21 = detectMediaType({
+        const bytes = convertBase64ToUint8Array4(dataContent);
+        const mediaType = (_a21 = detectMediaType4({
           data: bytes,
-          signatures: imageMediaTypeSignatures
+          topLevelType: "image"
         })) != null ? _a21 : "image/png";
         image = {
           type: "file",
@@ -12199,9 +12109,9 @@ function normalizePrompt2(promptArg) {
         };
       }
     } else if (dataContent instanceof Uint8Array) {
-      const mediaType = (_b = detectMediaType({
+      const mediaType = (_b = detectMediaType4({
         data: dataContent,
-        signatures: imageMediaTypeSignatures
+        topLevelType: "image"
       })) != null ? _b : "image/png";
       image = {
         type: "file",
@@ -12859,15 +12769,12 @@ function customProvider({
   skills,
   fallbackProvider: fallbackProviderArg
 }) {
-  var _a21, _b;
-  const fallbackProvider = fallbackProviderArg ? asProviderV4(fallbackProviderArg) : void 0;
-  const resolvedFiles = files != null ? files : (_a21 = fallbackProvider == null ? void 0 : fallbackProvider.files) == null ? void 0 : _a21.call(fallbackProvider);
-  const resolvedSkills = skills != null ? skills : (_b = fallbackProvider == null ? void 0 : fallbackProvider.skills) == null ? void 0 : _b.call(fallbackProvider);
-  return {
+  const fallbackProvider = fallbackProviderArg == null ? void 0 : asProviderV4(fallbackProviderArg);
+  const baseProvider = {
     specificationVersion: "v4",
     languageModel(modelId) {
       if (languageModels != null && modelId in languageModels) {
-        return asLanguageModelV4(languageModels[modelId]);
+        return resolveLanguageModel(languageModels[modelId]);
       }
       if (fallbackProvider) {
         return fallbackProvider.languageModel(modelId);
@@ -12876,7 +12783,7 @@ function customProvider({
     },
     embeddingModel(modelId) {
       if (embeddingModels != null && modelId in embeddingModels) {
-        return asEmbeddingModelV4(embeddingModels[modelId]);
+        return resolveEmbeddingModel(embeddingModels[modelId]);
       }
       if (fallbackProvider) {
         return fallbackProvider.embeddingModel(modelId);
@@ -12885,7 +12792,7 @@ function customProvider({
     },
     imageModel(modelId) {
       if (imageModels != null && modelId in imageModels) {
-        return asImageModelV4(imageModels[modelId]);
+        return resolveImageModel(imageModels[modelId]);
       }
       if (fallbackProvider == null ? void 0 : fallbackProvider.imageModel) {
         return fallbackProvider.imageModel(modelId);
@@ -12894,7 +12801,10 @@ function customProvider({
     },
     transcriptionModel(modelId) {
       if (transcriptionModels != null && modelId in transcriptionModels) {
-        return asTranscriptionModelV4(transcriptionModels[modelId]);
+        const model = resolveTranscriptionModel(transcriptionModels[modelId]);
+        if (model != null) {
+          return model;
+        }
       }
       if (fallbackProvider == null ? void 0 : fallbackProvider.transcriptionModel) {
         return fallbackProvider.transcriptionModel(modelId);
@@ -12903,7 +12813,10 @@ function customProvider({
     },
     speechModel(modelId) {
       if (speechModels != null && modelId in speechModels) {
-        return asSpeechModelV4(speechModels[modelId]);
+        const model = resolveSpeechModel(speechModels[modelId]);
+        if (model != null) {
+          return model;
+        }
       }
       if (fallbackProvider == null ? void 0 : fallbackProvider.speechModel) {
         return fallbackProvider.speechModel(modelId);
@@ -12912,7 +12825,7 @@ function customProvider({
     },
     rerankingModel(modelId) {
       if (rerankingModels != null && modelId in rerankingModels) {
-        return asRerankingModelV4(rerankingModels[modelId]);
+        return resolveRerankingModel(rerankingModels[modelId]);
       }
       if (fallbackProvider == null ? void 0 : fallbackProvider.rerankingModel) {
         return fallbackProvider.rerankingModel(modelId);
@@ -12921,22 +12834,32 @@ function customProvider({
     },
     videoModel(modelId) {
       if (videoModels != null && modelId in videoModels) {
-        return asVideoModelV4(videoModels[modelId]);
+        return resolveVideoModel(videoModels[modelId]);
       }
       const videoModel = fallbackProvider == null ? void 0 : fallbackProvider.videoModel;
       if (videoModel) {
         return videoModel(modelId);
       }
       throw new NoSuchModelError2({ modelId, modelType: "videoModel" });
-    },
-    ...resolvedFiles != null ? { files: () => resolvedFiles } : {},
-    ...resolvedSkills != null ? { skills: () => resolvedSkills } : {}
+    }
   };
+  const filesAndSkills = {
+    ...files != null || (fallbackProvider == null ? void 0 : fallbackProvider.files) != null ? {
+      files() {
+        return files != null ? files : fallbackProvider.files();
+      }
+    } : {},
+    ...skills != null || (fallbackProvider == null ? void 0 : fallbackProvider.skills) != null ? {
+      skills() {
+        return skills != null ? skills : fallbackProvider.skills();
+      }
+    } : {}
+  };
+  return Object.assign(baseProvider, filesAndSkills);
 }
-var experimental_customProvider = customProvider;
 
 // src/registry/no-such-provider-error.ts
-import { AISDKError as AISDKError24, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError23, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
 var name20 = "AI_NoSuchProviderError";
 var marker20 = `vercel.ai.error.${name20}`;
 var symbol20 = Symbol.for(marker20);
@@ -12955,7 +12878,7 @@ var NoSuchProviderError = class extends NoSuchModelError3 {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return AISDKError24.hasMarker(error, marker20);
+    return AISDKError23.hasMarker(error, marker20);
   }
 };
 _a20 = symbol20;
@@ -12975,7 +12898,7 @@ function createProviderRegistry(providers, {
     imageModelMiddleware
   });
   for (const [id, provider] of Object.entries(providers)) {
-    registry.registerProvider({ id, provider: asProviderV4(provider) });
+    registry.registerProvider({ id, provider });
   }
   return registry;
 }
@@ -12995,7 +12918,13 @@ var DefaultProviderRegistry = class {
     id,
     provider
   }) {
-    this.providers[id] = provider;
+    var _a21;
+    const providerV4 = asProviderV4(provider);
+    const videoModel = (_a21 = provider.videoModel) == null ? void 0 : _a21.bind(provider);
+    this.providers[id] = videoModel == null ? providerV4 : Object.assign(Object.create(Object.getPrototypeOf(providerV4)), {
+      ...providerV4,
+      videoModel: (modelId) => asVideoModelV4(videoModel(modelId))
+    });
   }
   getProvider(id, modelType) {
     const provider = this.providers[id];
@@ -13007,7 +12936,7 @@ var DefaultProviderRegistry = class {
         availableProviders: Object.keys(this.providers)
       });
     }
-    return asProviderV4(provider);
+    return provider;
   }
   splitId(id, modelType) {
     const index = id.indexOf(this.separator);
@@ -13108,50 +13037,36 @@ var DefaultProviderRegistry = class {
     if (model == null) {
       throw new NoSuchModelError4({ modelId: id, modelType: "videoModel" });
     }
-    return model;
+    return asVideoModelV4(model);
   }
-  files(providerId) {
-    var _a21, _b;
-    const providerInstance = this.providers[providerId];
-    if (providerInstance == null) {
-      throw new NoSuchProviderError({
-        modelId: providerId,
-        modelType: "languageModel",
-        providerId,
-        availableProviders: Object.keys(this.providers)
-      });
-    }
-    const filesInterface = (_b = (_a21 = asProviderV4(providerInstance)).files) == null ? void 0 : _b.call(_a21);
-    if (filesInterface == null) {
+  files(id) {
+    var _a21;
+    const provider = this.getProvider(id, "languageModel");
+    const files = (_a21 = provider.files) == null ? void 0 : _a21.call(provider);
+    if (files == null) {
       throw new Error(
-        `Provider '${providerId}' does not support files. Make sure the provider has a files() method.`
+        `The provider "${id}" does not support file uploads. Make sure it exposes a files() method.`
       );
     }
-    return filesInterface;
+    return files;
   }
-  skills(providerId) {
-    var _a21, _b;
-    const providerInstance = this.providers[providerId];
-    if (providerInstance == null) {
-      throw new NoSuchProviderError({
-        modelId: providerId,
-        modelType: "languageModel",
-        providerId,
-        availableProviders: Object.keys(this.providers)
-      });
-    }
-    const skillsInterface = (_b = (_a21 = asProviderV4(providerInstance)).skills) == null ? void 0 : _b.call(_a21);
-    if (skillsInterface == null) {
+  skills(id) {
+    var _a21;
+    const provider = this.getProvider(id, "languageModel");
+    const skills = (_a21 = provider.skills) == null ? void 0 : _a21.call(provider);
+    if (skills == null) {
       throw new Error(
-        `Provider '${providerId}' does not support skills. Make sure the provider has a skills() method.`
+        `The provider "${id}" does not support skills. Make sure it exposes a skills() method.`
       );
     }
-    return skillsInterface;
+    return skills;
   }
 };
 
 // src/rerank/rerank.ts
-import { createIdGenerator as createIdGenerator8 } from "@ai-sdk/provider-utils";
+import {
+  createIdGenerator as createIdGenerator8
+} from "@ai-sdk/provider-utils";
 var originalGenerateCallId6 = createIdGenerator8({
   prefix: "call",
   size: 24
@@ -13349,7 +13264,10 @@ var DefaultRerankResult = class {
 };
 
 // src/transcribe/transcribe.ts
-import { withUserAgentSuffix as withUserAgentSuffix9 } from "@ai-sdk/provider-utils";
+import {
+  detectMediaType as detectMediaType5,
+  withUserAgentSuffix as withUserAgentSuffix9
+} from "@ai-sdk/provider-utils";
 var defaultDownload2 = createDownload();
 async function transcribe({
   model,
@@ -13381,9 +13299,9 @@ async function transcribe({
         abortSignal,
         headers: headersWithUserAgent,
         providerOptions,
-        mediaType: (_a21 = detectMediaType({
+        mediaType: (_a21 = detectMediaType5({
           data: audioData,
-          signatures: audioMediaTypeSignatures
+          topLevelType: "audio"
         })) != null ? _a21 : "audio/wav"
       });
     }
@@ -14244,7 +14162,8 @@ var TextStreamChatTransport = class extends HttpChatTransport {
 
 // src/upload-file/upload-file.ts
 import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array6
+  convertBase64ToUint8Array as convertBase64ToUint8Array5,
+  detectMediaType as detectMediaType6
 } from "@ai-sdk/provider-utils";
 async function uploadFile({
   api,
@@ -14254,21 +14173,8 @@ async function uploadFile({
   providerOptions
 }) {
   var _a21;
-  const { data } = convertToLanguageModelV4DataContent(dataArg);
-  if (data instanceof URL) {
-    throw new Error(
-      "URL data is not supported for file uploads. Fetch the URL content first and pass the bytes."
-    );
-  }
-  const mediaType = (_a21 = mediaTypeArg != null ? mediaTypeArg : detectMediaType({
-    data,
-    signatures: [
-      ...imageMediaTypeSignatures,
-      ...documentMediaTypeSignatures,
-      ...audioMediaTypeSignatures,
-      ...videoMediaTypeSignatures
-    ]
-  })) != null ? _a21 : isLikelyText(data) ? "text/plain" : "application/octet-stream";
+  const data = dataArg instanceof Uint8Array || typeof dataArg === "string" ? { type: "data", data: dataArg } : dataArg;
+  const mediaType = mediaTypeArg != null ? mediaTypeArg : data.type === "text" ? "text/plain" : (_a21 = detectMediaType6({ data: data.data })) != null ? _a21 : isLikelyText(data.data) ? "text/plain" : "application/octet-stream";
   const filesApi = "uploadFile" in api ? api : typeof api.files === "function" ? api.files() : (() => {
     throw new Error(
       "The provider does not support file uploads. Make sure it exposes a files() method."
@@ -14300,7 +14206,7 @@ var DefaultUploadFileResult = class {
 function isLikelyText(data) {
   const CHECK_LENGTH = 512;
   const BASE64_CHECK_LENGTH = Math.ceil((CHECK_LENGTH + 4) / 3) * 4;
-  const bytes = typeof data === "string" ? convertBase64ToUint8Array6(
+  const bytes = typeof data === "string" ? convertBase64ToUint8Array5(
     data.substring(0, Math.min(data.length, BASE64_CHECK_LENGTH))
   ) : data;
   const checkLength = Math.min(bytes.length, CHECK_LENGTH);
@@ -14327,8 +14233,12 @@ async function uploadSkill({
       "The provider does not support skills. Make sure it exposes a skills() method."
     );
   })();
+  const normalizedFiles = files.map((file) => ({
+    ...file,
+    data: file.data instanceof Uint8Array || typeof file.data === "string" ? { type: "data", data: file.data } : file.data
+  }));
   const result = await skillsApi.uploadSkill({
-    files,
+    files: normalizedFiles,
     displayTitle,
     providerOptions
   });
@@ -14336,6 +14246,7 @@ async function uploadSkill({
 }
 export {
   AISDKError21 as AISDKError,
+  AI_SDK_TELEMETRY_DIAGNOSTIC_CHANNEL,
   APICallError,
   AbstractChat,
   DefaultChatTransport,
@@ -14408,7 +14319,6 @@ export {
   embed,
   embedMany,
   experimental_createProviderRegistry,
-  experimental_customProvider,
   filterActiveTools as experimental_filterActiveTools,
   experimental_generateImage,
   generateSpeech as experimental_generateSpeech,