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

package/dist/internal/index.js

@@ -8,13 +8,13 @@ function createAsyncIterableStream(source) {
     const reader = this.getReader();
     let finished = false;
     async function cleanup(cancelStream) {
-      var _a5;
+      var _a6;
       if (finished)
         return;
       finished = true;
       try {
         if (cancelStream) {
-          await ((_a5 = reader.cancel) == null ? void 0 : _a5.call(reader));
+          await ((_a6 = reader.cancel) == null ? void 0 : _a6.call(reader));
         }
       } finally {
         try {
@@ -66,138 +66,23 @@ function createAsyncIterableStream(source) {
 // 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 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,
   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 ({
@@ -205,7 +90,7 @@ var download = async ({
   maxBytes,
   abortSignal
 }) => {
-  var _a5;
+  var _a6;
   const urlText = url.toString();
   validateDownloadUrl(urlText);
   try {
@@ -234,7 +119,7 @@ var download = async ({
     });
     return {
       data,
-      mediaType: (_a5 = response.headers.get("content-type")) != null ? _a5 : void 0
+      mediaType: (_a6 = response.headers.get("content-type")) != null ? _a6 : void 0
     };
   } catch (error) {
     if (DownloadError.isInstance(error)) {
@@ -251,13 +136,33 @@ var createDefaultDownloadFunction = (download2 = download) => (requestedDownload
   )
 );
 
-// src/prompt/data-content.ts
-import { AISDKError } 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/invalid-data-content-error.ts
+import { AISDKError } from "@ai-sdk/provider";
+var name = "AI_InvalidDataContentError";
+var marker = `vercel.ai.error.${name}`;
+var symbol = Symbol.for(marker);
+var _a;
+var InvalidDataContentError = class extends AISDKError {
+  constructor({
+    content,
+    cause,
+    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
+  }) {
+    super({ name, message, cause });
+    this[_a] = true;
+    this.content = content;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker);
+  }
+};
+_a = symbol;
 
 // src/prompt/split-data-url.ts
 function splitDataUrl(dataUrl) {
@@ -275,46 +180,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 _a5, _b;
-      return (_b = (_a5 = globalThis.Buffer) == null ? void 0 : _a5.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-function convertToLanguageModelV4DataContent(content) {
+// 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: { type: "data", data: base64Content }, mediaType };
+  }
+  return { data: { type: "url", url }, mediaType: void 0 };
+}
+function convertInlineDataToFilePartData(content) {
   if (content instanceof Uint8Array) {
-    return { data: content, mediaType: void 0 };
+    return { data: { type: "data", data: content }, mediaType: void 0 };
   }
   if (content instanceof ArrayBuffer) {
-    return { data: new Uint8Array(content), mediaType: void 0 };
+    return {
+      data: { type: "data", data: new Uint8Array(content) },
+      mediaType: void 0
+    };
+  }
+  if (isBuffer(content)) {
+    return {
+      data: { type: "data", data: new Uint8Array(content) },
+      mediaType: void 0
+    };
+  }
+  return {
+    data: { type: "data", data: content },
+    mediaType: void 0
+  };
+}
+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 {
-      content = new URL(content);
+      return convertUrlToFilePartData(new URL(content));
     } catch (e) {
+      return convertInlineDataToFilePartData(content);
     }
   }
-  if (content instanceof URL && content.protocol === "data:") {
-    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
-      content.toString()
-    );
-    if (dataUrlMediaType == null || base64Content == null) {
-      throw new AISDKError({
-        name: "InvalidDataContentError",
-        message: `Invalid data URL format in content ${content.toString()}`
-      });
-    }
-    return { data: base64Content, mediaType: dataUrlMediaType };
+  if (isProviderReference(content)) {
+    return {
+      data: { type: "reference", reference: content },
+      mediaType: void 0
+    };
   }
-  return { data: content, mediaType: void 0 };
+  return convertInlineDataToFilePartData(content);
 }
 
 // src/logger/log-warnings.ts
@@ -387,47 +335,47 @@ var logWarnings = (options) => {
 
 // src/prompt/invalid-message-role-error.ts
 import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
-var name = "AI_InvalidMessageRoleError";
-var marker = `vercel.ai.error.${name}`;
-var symbol = Symbol.for(marker);
-var _a;
+var name2 = "AI_InvalidMessageRoleError";
+var marker2 = `vercel.ai.error.${name2}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
 var InvalidMessageRoleError = class extends AISDKError2 {
   constructor({
     role,
     message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
   }) {
-    super({ name, message });
-    this[_a] = true;
+    super({ name: name2, message });
+    this[_a2] = true;
     this.role = role;
   }
   static isInstance(error) {
-    return AISDKError2.hasMarker(error, marker);
+    return AISDKError2.hasMarker(error, marker2);
   }
 };
-_a = symbol;
+_a2 = symbol2;
 
 // src/error/missing-tool-result-error.ts
 import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
-var name2 = "AI_MissingToolResultsError";
-var marker2 = `vercel.ai.error.${name2}`;
-var symbol2 = Symbol.for(marker2);
-var _a2;
+var name3 = "AI_MissingToolResultsError";
+var marker3 = `vercel.ai.error.${name3}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
 var MissingToolResultsError = class extends AISDKError3 {
   constructor({ toolCallIds }) {
     super({
-      name: name2,
+      name: name3,
       message: `Tool result${toolCallIds.length > 1 ? "s are" : " is"} missing for tool call${toolCallIds.length > 1 ? "s" : ""} ${toolCallIds.join(
         ", "
       )}.`
     });
-    this[_a2] = true;
+    this[_a3] = true;
     this.toolCallIds = toolCallIds;
   }
   static isInstance(error) {
-    return AISDKError3.hasMarker(error, marker2);
+    return AISDKError3.hasMarker(error, marker3);
   }
 };
-_a2 = symbol2;
+_a3 = symbol3;
 
 // src/prompt/convert-to-language-model-prompt.ts
 async function convertToLanguageModelPrompt({
@@ -565,7 +513,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) {
@@ -599,16 +556,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 {
@@ -627,9 +575,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,
@@ -720,28 +673,29 @@ function convertToLanguageModelMessage({
     }
   }
 }
+function convertImagePartToFilePart(part) {
+  var _a6;
+  if (part.type !== "image") {
+    return part;
+  }
+  return {
+    type: "file",
+    data: part.image,
+    mediaType: (_a6 = part.mediaType) != null ? _a6 : "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 _a5;
-    const mediaType = (_a5 = part.mediaType) != null ? _a5 : 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
     })
@@ -757,7 +711,6 @@ async function downloadAssets(messages, download2, supportedUrls) {
   );
 }
 function convertPartToLanguageModelPart(part, downloadedAssets) {
-  var _a5, _b;
   if (part.type === "text") {
     return {
       type: "text",
@@ -765,55 +718,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: (_a5 = part.mediaType) != null ? _a5 : 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,
@@ -828,7 +763,7 @@ function mapToolResultOutput({
   return {
     type: "content",
     value: output.value.map((item) => {
-      var _a5;
+      var _a6;
       switch (item.type) {
         case "image-data": {
           warnings.push({
@@ -899,7 +834,7 @@ function mapToolResultOutput({
           };
         }
         case "file-url": {
-          const mediaType = (_a5 = item.mediaType) != null ? _a5 : getMediaTypeFromUrl(item.url);
+          const mediaType = (_a6 = item.mediaType) != null ? _a6 : getMediaTypeFromUrl(item.url);
           if (!item.mediaType) {
             const messageSuffix = mediaType === "application/octet-stream" ? `Unable to infer media type from URL. Defaulting to 'application/octet-stream'.` : `Inferred media type '${mediaType}' from URL.`;
             warnings.push({
@@ -955,10 +890,10 @@ var URL_EXTENSION_TO_MEDIA_TYPE = {
   ogg: "audio/ogg"
 };
 function getMediaTypeFromUrl(url, fallbackMediaType = "application/octet-stream") {
-  var _a5;
+  var _a6;
   try {
     const pathname = new URL(url).pathname;
-    const ext = (_a5 = pathname.split(".").pop()) == null ? void 0 : _a5.toLowerCase();
+    const ext = (_a6 = pathname.split(".").pop()) == null ? void 0 : _a6.toLowerCase();
     if (ext && Object.hasOwn(URL_EXTENSION_TO_MEDIA_TYPE, ext)) {
       return URL_EXTENSION_TO_MEDIA_TYPE[ext];
     }
@@ -990,7 +925,7 @@ async function prepareTools({
     return void 0;
   }
   const languageModelTools = [];
-  for (const [name5, tool] of Object.entries(tools)) {
+  for (const [name6, tool] of Object.entries(tools)) {
     const toolType = tool.type;
     switch (toolType) {
       case void 0:
@@ -998,7 +933,7 @@ async function prepareTools({
       case "function":
         languageModelTools.push({
           type: "function",
-          name: name5,
+          name: name6,
           description: tool.description,
           inputSchema: await asSchema(tool.inputSchema).jsonSchema,
           ...tool.inputExamples != null ? { inputExamples: tool.inputExamples } : {},
@@ -1009,7 +944,7 @@ async function prepareTools({
       case "provider":
         languageModelTools.push({
           type: "provider",
-          name: name5,
+          name: name6,
           id: tool.id,
           args: tool.args
         });
@@ -1029,170 +964,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()
           })
         ])
@@ -1200,47 +1162,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,
@@ -1254,12 +1216,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,
@@ -1315,7 +1277,7 @@ async function standardizePrompt({
   }
   const validationResult = await safeValidateTypes({
     value: messages,
-    schema: z6.array(modelMessageSchema)
+    schema: z5.array(modelMessageSchema)
   });
   if (!validationResult.success) {
     throw new InvalidPromptError({
@@ -1329,10 +1291,10 @@ async function standardizePrompt({
 
 // src/error/invalid-argument-error.ts
 import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
-var name3 = "AI_InvalidArgumentError";
-var marker3 = `vercel.ai.error.${name3}`;
-var symbol3 = Symbol.for(marker3);
-var _a3;
+var name4 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name4}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
 var InvalidArgumentError = class extends AISDKError4 {
   constructor({
     parameter,
@@ -1340,18 +1302,18 @@ var InvalidArgumentError = class extends AISDKError4 {
     message
   }) {
     super({
-      name: name3,
+      name: name4,
       message: `Invalid argument for parameter ${parameter}: ${message}`
     });
-    this[_a3] = true;
+    this[_a4] = true;
     this.parameter = parameter;
     this.value = value;
   }
   static isInstance(error) {
-    return AISDKError4.hasMarker(error, marker3);
+    return AISDKError4.hasMarker(error, marker4);
   }
 };
-_a3 = symbol3;
+_a4 = symbol4;
 
 // src/prompt/prepare-language-model-call-options.ts
 function prepareLanguageModelCallOptions({
@@ -1454,27 +1416,27 @@ import { delay, getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
 
 // src/util/retry-error.ts
 import { AISDKError as AISDKError5 } from "@ai-sdk/provider";
-var name4 = "AI_RetryError";
-var marker4 = `vercel.ai.error.${name4}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
+var name5 = "AI_RetryError";
+var marker5 = `vercel.ai.error.${name5}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
 var RetryError = class extends AISDKError5 {
   constructor({
     message,
     reason,
     errors
   }) {
-    super({ name: name4, message });
-    this[_a4] = true;
+    super({ name: name5, message });
+    this[_a5] = true;
     this.reason = reason;
     this.errors = errors;
     this.lastError = errors[errors.length - 1];
   }
   static isInstance(error) {
-    return AISDKError5.hasMarker(error, marker4);
+    return AISDKError5.hasMarker(error, marker5);
   }
 };
-_a4 = symbol4;
+_a5 = symbol5;
 
 // src/util/retry-with-exponential-backoff.ts
 function getRetryDelayInMs({
@@ -1977,8 +1939,8 @@ function resolveLanguageModel(model) {
   return asLanguageModelV4(model);
 }
 function getGlobalProvider() {
-  var _a5;
-  const provider = (_a5 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a5 : gateway;
+  var _a6;
+  const provider = (_a6 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a6 : gateway;
   return asProviderV4(provider);
 }