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

package/src/model/as-image-model-v4.ts

@@ -1,4 +1,8 @@
-import { ImageModelV2, ImageModelV3, ImageModelV4 } from '@ai-sdk/provider';
+import type {
+  ImageModelV2,
+  ImageModelV3,
+  ImageModelV4,
+} from '@ai-sdk/provider';
 import { asImageModelV3 } from './as-image-model-v3';
 
 export function asImageModelV4(

package/src/model/as-language-model-v3.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   LanguageModelV2,
   LanguageModelV2FinishReason,
   LanguageModelV2StreamPart,

package/src/model/as-language-model-v4.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   LanguageModelV2,
   LanguageModelV3,
   LanguageModelV4,

package/src/model/as-provider-v3.ts

@@ -1,4 +1,4 @@
-import { ProviderV2, ProviderV3 } from '@ai-sdk/provider';
+import type { ProviderV2, ProviderV3 } from '@ai-sdk/provider';
 import { asEmbeddingModelV3 } from './as-embedding-model-v3';
 import { asImageModelV3 } from './as-image-model-v3';
 import { asLanguageModelV3 } from './as-language-model-v3';

package/src/model/as-provider-v4.ts

@@ -1,4 +1,4 @@
-import { ProviderV2, ProviderV3, ProviderV4 } from '@ai-sdk/provider';
+import type { ProviderV2, ProviderV3, ProviderV4 } from '@ai-sdk/provider';
 import { asProviderV3 } from './as-provider-v3';
 import { asEmbeddingModelV4 } from './as-embedding-model-v4';
 import { asImageModelV4 } from './as-image-model-v4';

package/src/model/as-reranking-model-v4.ts

@@ -1,4 +1,4 @@
-import { RerankingModelV3, RerankingModelV4 } from '@ai-sdk/provider';
+import type { RerankingModelV3, RerankingModelV4 } from '@ai-sdk/provider';
 
 export function asRerankingModelV4(
   model: RerankingModelV3 | RerankingModelV4,

package/src/model/as-speech-model-v3.ts

@@ -1,4 +1,4 @@
-import { SpeechModelV2, SpeechModelV3 } from '@ai-sdk/provider';
+import type { SpeechModelV2, SpeechModelV3 } from '@ai-sdk/provider';
 import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
 
 export function asSpeechModelV3(

package/src/model/as-speech-model-v4.ts

@@ -1,4 +1,8 @@
-import { SpeechModelV2, SpeechModelV3, SpeechModelV4 } from '@ai-sdk/provider';
+import type {
+  SpeechModelV2,
+  SpeechModelV3,
+  SpeechModelV4,
+} from '@ai-sdk/provider';
 import { asSpeechModelV3 } from './as-speech-model-v3';
 
 export function asSpeechModelV4(

package/src/model/as-transcription-model-v3.ts

@@ -1,4 +1,7 @@
-import { TranscriptionModelV2, TranscriptionModelV3 } from '@ai-sdk/provider';
+import type {
+  TranscriptionModelV2,
+  TranscriptionModelV3,
+} from '@ai-sdk/provider';
 import { logV2CompatibilityWarning } from '../util/log-v2-compatibility-warning';
 
 export function asTranscriptionModelV3(

package/src/model/as-transcription-model-v4.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   TranscriptionModelV2,
   TranscriptionModelV3,
   TranscriptionModelV4,

package/src/model/as-video-model-v4.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Experimental_VideoModelV3,
   Experimental_VideoModelV4,
 } from '@ai-sdk/provider';

package/src/model/resolve-model.ts

@@ -1,5 +1,5 @@
 import { gateway } from '@ai-sdk/gateway';
-import {
+import type {
   EmbeddingModelV4,
   Experimental_VideoModelV4,
   ImageModelV4,
@@ -10,10 +10,10 @@ import {
   TranscriptionModelV4,
 } from '@ai-sdk/provider';
 import { UnsupportedModelVersionError } from '../error';
-import { EmbeddingModel } from '../types/embedding-model';
-import { LanguageModel } from '../types/language-model';
-import { SpeechModel } from '../types/speech-model';
-import { TranscriptionModel } from '../types/transcription-model';
+import type { EmbeddingModel } from '../types/embedding-model';
+import type { LanguageModel } from '../types/language-model';
+import type { SpeechModel } from '../types/speech-model';
+import type { TranscriptionModel } from '../types/transcription-model';
 import { asEmbeddingModelV4 } from './as-embedding-model-v4';
 import { asImageModelV4 } from './as-image-model-v4';
 import { asLanguageModelV4 } from './as-language-model-v4';
@@ -22,9 +22,9 @@ import { asSpeechModelV4 } from './as-speech-model-v4';
 import { asTranscriptionModelV4 } from './as-transcription-model-v4';
 import { asVideoModelV4 } from './as-video-model-v4';
 import { asProviderV4 } from './as-provider-v4';
-import { ImageModel } from '../types/image-model';
-import { RerankingModel } from '../types/reranking-model';
-import { VideoModel } from '../types/video-model';
+import type { ImageModel } from '../types/image-model';
+import type { RerankingModel } from '../types/reranking-model';
+import type { VideoModel } from '../types/video-model';
 
 export function resolveLanguageModel(model: LanguageModel): LanguageModelV4 {
   if (typeof model === 'string') {

package/src/prompt/content-part.ts

@@ -1,20 +1,28 @@
 import {
-  CustomPart,
-  FilePart,
-  ImagePart,
-  ProviderOptions,
-  ReasoningFilePart,
-  ReasoningPart,
-  TextPart,
-  ToolApprovalRequest,
-  ToolApprovalResponse,
-  ToolResultOutput,
-  ToolResultPart,
+  isBuffer,
+  type CustomPart,
+  type DataContent,
+  type FilePart,
+  type ImagePart,
+  type ProviderOptions,
+  type ReasoningFilePart,
+  type ReasoningPart,
+  type TextPart,
+  type ToolApprovalRequest,
+  type ToolApprovalResponse,
+  type ToolResultOutput,
+  type ToolResultPart,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { jsonValueSchema } from '../types/json-value';
 import { providerMetadataSchema } from '../types/provider-metadata';
-import { dataContentSchema } from './data-content';
+
+const fileInlineDataSchema: z.ZodType<DataContent> = z.union([
+  z.string(),
+  z.instanceof(Uint8Array),
+  z.instanceof(ArrayBuffer),
+  z.custom<Buffer>(isBuffer, { message: 'Must be a Buffer' }),
+]);
 
 const providerReferenceSchema = z.record(z.string(), z.string());
 
@@ -29,11 +37,13 @@ export const textPartSchema: z.ZodType<TextPart> = z.object({
 
 /**
  * @internal
+ * @deprecated Use `filePartSchema` with `mediaType: 'image'` instead:
+ * `{ type: 'file', mediaType: 'image', data: { type: 'data', data } }`.
  */
 export const imagePartSchema: z.ZodType<ImagePart> = z.object({
   type: z.literal('image'),
   image: z.union([
-    dataContentSchema,
+    fileInlineDataSchema,
     z.instanceof(URL),
     providerReferenceSchema,
   ]),
@@ -41,13 +51,29 @@ export const imagePartSchema: z.ZodType<ImagePart> = z.object({
   providerOptions: providerMetadataSchema.optional(),
 });
 
+const taggedFileDataSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('data'), data: fileInlineDataSchema }),
+  z.object({ type: z.literal('url'), url: z.instanceof(URL) }),
+  z.object({
+    type: z.literal('reference'),
+    reference: providerReferenceSchema,
+  }),
+  z.object({ type: z.literal('text'), text: z.string() }),
+]);
+
+const taggedReasoningFileDataSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('data'), data: fileInlineDataSchema }),
+  z.object({ type: z.literal('url'), url: z.instanceof(URL) }),
+]);
+
 /**
  * @internal
  */
 export const filePartSchema: z.ZodType<FilePart> = z.object({
   type: z.literal('file'),
   data: z.union([
-    dataContentSchema,
+    taggedFileDataSchema,
+    fileInlineDataSchema,
     z.instanceof(URL),
     providerReferenceSchema,
   ]),
@@ -79,7 +105,11 @@ export const customPartSchema: z.ZodType<CustomPart> = z.object({
  */
 export const reasoningFilePartSchema: z.ZodType<ReasoningFilePart> = z.object({
   type: z.literal('reasoning-file'),
-  data: z.union([dataContentSchema, z.instanceof(URL)]),
+  data: z.union([
+    taggedReasoningFileDataSchema,
+    fileInlineDataSchema,
+    z.instanceof(URL),
+  ]),
   mediaType: z.string(),
   providerOptions: providerMetadataSchema.optional(),
 });

package/src/prompt/convert-to-language-model-prompt.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   LanguageModelV4FilePart,
   LanguageModelV4Message,
   LanguageModelV4Prompt,
@@ -7,33 +7,29 @@ import {
 } from '@ai-sdk/provider';
 import {
   asArray,
-  CustomPart,
-  DataContent,
-  FilePart,
-  ImagePart,
-  isProviderReference,
+  detectMediaType,
+  isFullMediaType,
   isUrlSupported,
-  ModelMessage,
-  ReasoningFilePart,
-  ReasoningPart,
-  TextPart,
-  ToolCallPart,
-  ToolResultOutput,
-  ToolResultPart,
+  type CustomPart,
+  type FilePart,
+  type ImagePart,
+  type ModelMessage,
+  type ReasoningFilePart,
+  type ReasoningPart,
+  type TextPart,
+  type ToolCallPart,
+  type ToolResultOutput,
+  type ToolResultPart,
 } from '@ai-sdk/provider-utils';
-import {
-  detectMediaType,
-  imageMediaTypeSignatures,
-} from '../util/detect-media-type';
 import {
   createDefaultDownloadFunction,
-  DownloadFunction,
+  type DownloadFunction,
 } from '../util/download/download-function';
-import { convertToLanguageModelV4DataContent } from './data-content';
+import { convertToLanguageModelV4FilePart } from './file-part-data';
 import { logWarnings } from '../logger/log-warnings';
 import type { Warning } from '../types/warning';
 import { InvalidMessageRoleError } from './invalid-message-role-error';
-import { StandardizedPrompt } from './standardize-prompt';
+import type { StandardizedPrompt } from './standardize-prompt';
 import { MissingToolResultsError } from '../error/missing-tool-result-error';
 
 export async function convertToLanguageModelPrompt({
@@ -217,6 +213,16 @@ export function convertToLanguageModelMessage({
       const converted = {
         role: 'user' as const,
         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))
           // remove empty text parts:
           .filter(part => part.type !== 'text' || part.text !== ''),
@@ -271,19 +277,7 @@ export function convertToLanguageModelMessage({
                 };
               }
               case 'file': {
-                if (
-                  !(part.data instanceof ArrayBuffer) &&
-                  isProviderReference(part.data)
-                ) {
-                  return {
-                    type: 'file' as const,
-                    data: part.data,
-                    filename: part.filename,
-                    mediaType: part.mediaType,
-                    providerOptions,
-                  };
-                }
-                const { data, mediaType } = convertToLanguageModelV4DataContent(
+                const { data, mediaType } = convertToLanguageModelV4FilePart(
                   part.data,
                 );
                 return {
@@ -302,9 +296,14 @@ export 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' as const,
                   data,
@@ -401,8 +400,29 @@ export function convertToLanguageModelMessage({
   }
 }
 
+/*
+ * Rewrites a legacy `ImagePart` into an equivalent `FilePart`. The default
+ * `mediaType` for a bare `ImagePart` (no `mediaType`) is `"image"` (top-level
+ * segment); an explicit `mediaType` is carried through verbatim. After this
+ * pre-pass, only `TextPart` and `FilePart` ever reach the provider-facing
+ * conversion logic.
+ */
+function convertImagePartToFilePart(
+  part: TextPart | ImagePart | FilePart,
+): TextPart | FilePart {
+  if (part.type !== 'image') {
+    return part;
+  }
+  return {
+    type: 'file',
+    data: part.image,
+    mediaType: part.mediaType ?? 'image',
+    providerOptions: part.providerOptions,
+  };
+}
+
 /**
- * Downloads images and files from URLs in the messages.
+ * Downloads files from URLs in the user messages.
  */
 async function downloadAssets(
   messages: ModelMessage[],
@@ -411,6 +431,15 @@ async function downloadAssets(
 ): Promise<
   Record<string, { mediaType: string | undefined; data: Uint8Array }>
 > {
+  type ConvertedFile = {
+    mediaType: string | undefined;
+    data: LanguageModelV4FilePart['data'];
+  };
+  type UrlTaggedFile = {
+    mediaType: string | undefined;
+    data: { type: 'url'; url: URL };
+  };
+
   const plannedDownloads = messages
     .filter(message => message.role === 'user')
     .map(message => message.content)
@@ -418,34 +447,20 @@ async function downloadAssets(
       Array.isArray(content),
     )
     .flat()
-    .filter(
-      (part): part is ImagePart | FilePart =>
-        part.type === 'image' || part.type === 'file',
-    )
-    .map(part => {
-      const mediaType =
-        part.mediaType ?? (part.type === 'image' ? 'image/*' : undefined);
-
-      let data = part.type === 'image' ? part.image : part.data;
-      if (typeof data === 'string') {
-        try {
-          data = new URL(data);
-        } catch {}
-      }
-
+    .map(part => convertImagePartToFilePart(part))
+    .filter((part): part is FilePart => part.type === 'file')
+    .map((part): ConvertedFile => {
+      const mediaType = part.mediaType;
+      const { data } = convertToLanguageModelV4FilePart(part.data);
       return { mediaType, data };
     })
-
-    .filter(
-      (part): part is { mediaType: string | undefined; data: URL } =>
-        part.data instanceof URL,
-    )
+    .filter((part): part is UrlTaggedFile => part.data.type === 'url')
     .map(part => ({
-      url: part.data,
+      url: part.data.url,
       isUrlSupportedByModel:
         part.mediaType != null &&
         isUrlSupported({
-          url: part.data.toString(),
+          url: part.data.url.toString(),
           mediaType: part.mediaType,
           supportedUrls,
         }),
@@ -469,7 +484,7 @@ async function downloadAssets(
 }
 
 /**
- * Convert part of a message to a LanguageModelV4Part.
+ * Convert part of a user message to a LanguageModelV4Part.
  *
  * @param part - The part to convert.
  * @param downloadedAssets - A map of URLs to their downloaded data. Only
@@ -477,7 +492,7 @@ async function downloadAssets(
  * @returns The converted part.
  */
 function convertPartToLanguageModelPart(
-  part: TextPart | ImagePart | FilePart,
+  part: TextPart | FilePart,
   downloadedAssets: Record<
     string,
     { mediaType: string | undefined; data: Uint8Array }
@@ -491,78 +506,49 @@ function convertPartToLanguageModelPart(
     };
   }
 
-  const type = part.type;
-  const rawData = type === 'image' ? part.image : part.data;
+  const { data: normalizedData, mediaType: dataUrlMediaType } =
+    convertToLanguageModelV4FilePart(part.data);
 
-  if (
-    typeof rawData === 'object' &&
-    !(rawData instanceof Uint8Array) &&
-    !(rawData instanceof ArrayBuffer) &&
-    !(rawData instanceof URL)
-  ) {
-    return {
-      type: 'file',
-      mediaType: part.mediaType ?? (type === 'image' ? 'image/*' : ''),
-      filename: type === 'file' ? part.filename : undefined,
-      data: rawData,
-      providerOptions: part.providerOptions,
-    };
-  }
-
-  const originalData: DataContent | URL = rawData;
+  let mediaType: string | undefined = dataUrlMediaType ?? part.mediaType;
+  let data: LanguageModelV4FilePart['data'] = normalizedData;
 
-  const { data: convertedData, mediaType: convertedMediaType } =
-    convertToLanguageModelV4DataContent(originalData);
-
-  let mediaType: string | undefined = convertedMediaType ?? part.mediaType;
-  let data: Uint8Array | string | URL = convertedData; // binary | base64 | url
-
-  // If the content is a URL, we check if it was downloaded:
-  if (data instanceof URL) {
-    const downloadedFile = downloadedAssets[data.toString()];
+  if (data.type === 'url') {
+    const downloadedFile = downloadedAssets[data.url.toString()];
     if (downloadedFile) {
-      data = downloadedFile.data;
-      mediaType ??= downloadedFile.mediaType;
+      data = { type: 'data', data: downloadedFile.data };
+      if (
+        downloadedFile.mediaType != null &&
+        (mediaType == null || !isFullMediaType(mediaType))
+      ) {
+        mediaType = downloadedFile.mediaType;
+      }
     }
   }
 
-  // Now that we have the normalized data either as a URL or a Uint8Array,
-  // we can create the LanguageModelV4Part.
-  switch (type) {
-    case 'image': {
-      // When possible, try to detect the media type automatically
-      // to deal with incorrect media type inputs.
-      // When detection fails, use provided media type.
-      if (data instanceof Uint8Array || typeof data === 'string') {
-        mediaType =
-          detectMediaType({ data, signatures: imageMediaTypeSignatures }) ??
-          mediaType;
-      }
-
-      return {
-        type: 'file',
-        mediaType: mediaType ?? 'image/*', // any image
-        filename: undefined,
-        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;
     }
+  }
 
-    case 'file': {
-      // We must have a mediaType for files, if not, throw an error.
-      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 (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({

package/src/prompt/create-tool-model-output.ts

@@ -1,5 +1,5 @@
-import { getErrorMessage, JSONValue } from '@ai-sdk/provider';
-import { Tool, ToolResultOutput } from '@ai-sdk/provider-utils';
+import { getErrorMessage, type JSONValue } from '@ai-sdk/provider';
+import type { Tool, ToolResultOutput } from '@ai-sdk/provider-utils';
 
 export async function createToolModelOutput({
   toolCallId,

package/src/prompt/data-content.ts

@@ -1,72 +1,9 @@
-import { AISDKError, LanguageModelV4DataContent } from '@ai-sdk/provider';
 import {
   convertBase64ToUint8Array,
   convertUint8ArrayToBase64,
-  DataContent,
+  type DataContent,
 } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
 import { InvalidDataContentError } from './invalid-data-content-error';
-import { splitDataUrl } from './split-data-url';
-
-/**
- * @internal
- */
-export const dataContentSchema: z.ZodType<DataContent> = z.union([
-  z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
-  z.custom<Buffer>(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value: unknown): value is Buffer =>
-      globalThis.Buffer?.isBuffer(value) ?? false,
-    { message: 'Must be a Buffer' },
-  ),
-]);
-
-export function convertToLanguageModelV4DataContent(
-  content: DataContent | URL,
-): {
-  data: LanguageModelV4DataContent;
-  mediaType: string | undefined;
-} {
-  // Buffer & Uint8Array:
-  if (content instanceof Uint8Array) {
-    return { data: content, mediaType: undefined };
-  }
-
-  // ArrayBuffer needs conversion to Uint8Array (lightweight):
-  if (content instanceof ArrayBuffer) {
-    return { data: new Uint8Array(content), mediaType: undefined };
-  }
-
-  // Attempt to create a URL from the data. If it fails, we can assume the data
-  // is not a URL and likely some other sort of data.
-  if (typeof content === 'string') {
-    try {
-      content = new URL(content);
-    } catch {
-      // ignored
-    }
-  }
-
-  // Extract data from data URL:
-  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 };
-  }
-
-  return { data: content, mediaType: undefined };
-}
 
 /**
  * Converts data content to a base64-encoded string.
@@ -118,17 +55,3 @@ export function convertDataContentToUint8Array(
 
   throw new InvalidDataContentError({ content });
 }
-
-/**
- * Converts a Uint8Array to a string of text.
- *
- * @param uint8Array - The Uint8Array to convert.
- * @returns The converted string.
- */
-export function convertUint8ArrayToText(uint8Array: Uint8Array): string {
-  try {
-    return new TextDecoder().decode(uint8Array);
-  } catch {
-    throw new Error('Error decoding Uint8Array to text');
-  }
-}