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

package/src/ui-message-stream/pipe-ui-message-stream-to-response.ts

@@ -1,10 +1,10 @@
-import { ServerResponse } from 'node:http';
+import type { ServerResponse } from 'node:http';
 import { prepareHeaders } from '../util/prepare-headers';
 import { writeToServerResponse } from '../util/write-to-server-response';
 import { JsonToSseTransformStream } from './json-to-sse-transform-stream';
 import { UI_MESSAGE_STREAM_HEADERS } from './ui-message-stream-headers';
-import { UIMessageChunk } from './ui-message-chunks';
-import { UIMessageStreamResponseInit } from './ui-message-stream-response-init';
+import type { UIMessageChunk } from './ui-message-chunks';
+import type { UIMessageStreamResponseInit } from './ui-message-stream-response-init';
 
 /**
  * Pipes a UI message stream to a Node.js ServerResponse object.

package/src/ui-message-stream/read-ui-message-stream.ts

@@ -1,13 +1,13 @@
-import { UIMessage } from '../ui/ui-messages';
-import { UIMessageChunk } from './ui-message-chunks';
+import type { UIMessage } from '../ui/ui-messages';
+import type { UIMessageChunk } from './ui-message-chunks';
 import {
   createStreamingUIMessageState,
   processUIMessageStream,
-  StreamingUIMessageState,
+  type StreamingUIMessageState,
 } from '../ui/process-ui-message-stream';
 import {
-  AsyncIterableStream,
   createAsyncIterableStream,
+  type AsyncIterableStream,
 } from '../util/async-iterable-stream';
 import { consumeStream } from '../util/consume-stream';
 

package/src/ui-message-stream/ui-message-chunks.ts

@@ -1,16 +1,16 @@
 import { z } from 'zod/v4';
 import {
-  ProviderMetadata,
   providerMetadataSchema,
+  type ProviderMetadata,
 } from '../types/provider-metadata';
-import { FinishReason } from '../types/language-model';
-import {
+import type { FinishReason } from '../types/language-model';
+import type {
   InferUIMessageData,
   InferUIMessageMetadata,
   UIDataTypes,
   UIMessage,
 } from '../ui/ui-messages';
-import { ValueOf } from '../util/value-of';
+import type { ValueOf } from '../util/value-of';
 import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
 
 export const uiMessageChunkSchema = lazySchema(() =>

package/src/ui-message-stream/ui-message-stream-on-finish-callback.ts

@@ -1,5 +1,5 @@
-import { FinishReason } from '../types/language-model';
-import { UIMessage } from '../ui/ui-messages';
+import type { FinishReason } from '../types/language-model';
+import type { UIMessage } from '../ui/ui-messages';
 
 export type UIMessageStreamOnFinishCallback<UI_MESSAGE extends UIMessage> =
   (event: {

package/src/ui-message-stream/ui-message-stream-on-step-finish-callback.ts

@@ -1,4 +1,4 @@
-import { UIMessage } from '../ui/ui-messages';
+import type { UIMessage } from '../ui/ui-messages';
 
 /**
  * Callback that is called when a step finishes during streaming.

package/src/ui-message-stream/ui-message-stream-writer.ts

@@ -1,6 +1,6 @@
-import { UIMessage } from '../ui';
-import { ErrorHandler } from '../util/error-handler';
-import { InferUIMessageChunk } from './ui-message-chunks';
+import type { UIMessage } from '../ui';
+import type { ErrorHandler } from '../util/error-handler';
+import type { InferUIMessageChunk } from './ui-message-chunks';
 
 export interface UIMessageStreamWriter<
   UI_MESSAGE extends UIMessage = UIMessage,

package/src/upload-file/upload-file-result.ts

@@ -1,6 +1,6 @@
-import { ProviderMetadata } from '../types/provider-metadata';
-import { ProviderReference } from '../types/provider-reference';
-import { Warning } from '../types/warning';
+import type { ProviderMetadata } from '../types/provider-metadata';
+import type { ProviderReference } from '../types/provider-reference';
+import type { Warning } from '../types/warning';
 
 export interface UploadFileResult {
   readonly providerReference: ProviderReference;

package/src/upload-file/upload-file.ts

@@ -1,28 +1,24 @@
-import { FilesV4, ProviderV4 } from '@ai-sdk/provider';
+import type {
+  FilesV4,
+  FilesV4UploadFileCallOptions,
+  ProviderV4,
+} from '@ai-sdk/provider';
 import {
   convertBase64ToUint8Array,
-  DataContent,
-  ProviderOptions,
-} from '@ai-sdk/provider-utils';
-import { convertToLanguageModelV4DataContent } from '../prompt/data-content';
-import { ProviderMetadata } from '../types/provider-metadata';
-import { ProviderReference } from '../types/provider-reference';
-import { Warning } from '../types/warning';
-import {
-  audioMediaTypeSignatures,
   detectMediaType,
-  documentMediaTypeSignatures,
-  imageMediaTypeSignatures,
-  videoMediaTypeSignatures,
-} from '../util/detect-media-type';
-import { UploadFileResult } from './upload-file-result';
+} from '@ai-sdk/provider-utils';
+import type { ProviderMetadata } from '../types/provider-metadata';
+import type { ProviderReference } from '../types/provider-reference';
+import type { Warning } from '../types/warning';
+import type { UploadFileResult } from './upload-file-result';
 
 /**
  * Uploads a file using a files API interface.
  *
  * @param api - The Files API interface to use for uploading.
- * @param data - The file data to upload.
- * @param mediaType - Optional IANA media type. Auto-detected from file bytes if not provided.
+ * @param data - The file data to upload (tagged `{ type: 'data' | 'text' }`).
+ * @param mediaType - Optional IANA media type. Auto-detected from file bytes
+ * when omitted (falls back to `text/plain` for the `text` variant).
  * @param filename - Optional filename for the uploaded file.
  * @param providerOptions - Additional provider-specific options.
  *
@@ -40,48 +36,30 @@ export async function uploadFile({
    * Can be a `FilesV4` instance or a `ProviderV4` instance with a `files()` method.
    */
   api: FilesV4 | ProviderV4;
-
-  /**
-   * The file data to upload.
-   */
-  data: DataContent;
-
-  /**
-   * Optional IANA media type of the file.
-   * Auto-detected from file bytes if not provided.
-   */
-  mediaType?: string;
-
-  /**
-   * Optional filename for the uploaded file.
-   */
-  filename?: string;
-
-  /**
-   * Additional provider-specific options.
-   */
-  providerOptions?: ProviderOptions;
-}): Promise<UploadFileResult> {
-  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.',
-    );
-  }
+} & Omit<FilesV4UploadFileCallOptions, 'mediaType' | 'data'> & {
+    /**
+     * The file data. Accepts the tagged `{ type: 'data' | 'text' }` shapes, or
+     * the shorthand `Uint8Array | string` (treated as `{ type: 'data', data }`).
+     */
+    data: FilesV4UploadFileCallOptions['data'] | Uint8Array | string;
+
+    /**
+     * Optional IANA media type of the file. Auto-detected from file bytes when
+     * omitted; falls back to `text/plain` for the `text` variant.
+     */
+    mediaType?: string;
+  }): Promise<UploadFileResult> {
+  const data: FilesV4UploadFileCallOptions['data'] =
+    dataArg instanceof Uint8Array || typeof dataArg === 'string'
+      ? { type: 'data', data: dataArg }
+      : dataArg;
 
   const mediaType =
     mediaTypeArg ??
-    detectMediaType({
-      data,
-      signatures: [
-        ...imageMediaTypeSignatures,
-        ...documentMediaTypeSignatures,
-        ...audioMediaTypeSignatures,
-        ...videoMediaTypeSignatures,
-      ],
-    }) ??
-    (isLikelyText(data) ? 'text/plain' : 'application/octet-stream');
+    (data.type === 'text'
+      ? 'text/plain'
+      : (detectMediaType({ data: data.data }) ??
+        (isLikelyText(data.data) ? 'text/plain' : 'application/octet-stream')));
 
   const filesApi: FilesV4 =
     'uploadFile' in api

package/src/upload-skill/upload-skill-result.ts

@@ -1,6 +1,6 @@
-import { SkillsV4UploadSkillResult } from '@ai-sdk/provider';
-import { ProviderReference } from '../types/provider-reference';
-import { Warning } from '../types/warning';
+import type { SkillsV4UploadSkillResult } from '@ai-sdk/provider';
+import type { ProviderReference } from '../types/provider-reference';
+import type { Warning } from '../types/warning';
 
 export type UploadSkillResult = Omit<
   SkillsV4UploadSkillResult,

package/src/upload-skill/upload-skill.ts

@@ -1,6 +1,18 @@
-import { ProviderV4, SkillsV4, SkillsV4File } from '@ai-sdk/provider';
-import { ProviderOptions } from '@ai-sdk/provider-utils';
-import { UploadSkillResult } from './upload-skill-result';
+import type {
+  ProviderV4,
+  SkillsV4,
+  SkillsV4File,
+  SkillsV4UploadSkillCallOptions,
+} from '@ai-sdk/provider';
+import type { UploadSkillResult } from './upload-skill-result';
+
+type UploadSkillFile = Omit<SkillsV4File, 'data'> & {
+  /**
+   * The file data. Accepts the tagged `{ type: 'data' | 'text' }` shapes, or
+   * the shorthand `Uint8Array | string` (treated as `{ type: 'data', data }`).
+   */
+  data: SkillsV4File['data'] | Uint8Array | string;
+};
 
 export async function uploadSkill({
   api,
@@ -9,10 +21,9 @@ export async function uploadSkill({
   providerOptions,
 }: {
   api: SkillsV4 | ProviderV4;
-  files: SkillsV4File[];
-  displayTitle?: string;
-  providerOptions?: ProviderOptions;
-}): Promise<UploadSkillResult> {
+} & Omit<SkillsV4UploadSkillCallOptions, 'files'> & {
+    files: UploadSkillFile[];
+  }): Promise<UploadSkillResult> {
   const skillsApi: SkillsV4 =
     'uploadSkill' in api
       ? api
@@ -24,8 +35,16 @@ export async function uploadSkill({
             );
           })();
 
+  const normalizedFiles: SkillsV4File[] = 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,
   });

package/src/util/create-resolvable-promise.ts

@@ -1,4 +1,4 @@
-import { ErrorHandler } from './error-handler';
+import type { ErrorHandler } from './error-handler';
 
 /**
  * Creates a Promise with externally accessible resolve and reject functions.

package/src/util/deep-partial.ts

@@ -19,7 +19,7 @@
 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 
-import { FlexibleSchema, InferSchema } from '@ai-sdk/provider-utils';
+import type { FlexibleSchema, InferSchema } from '@ai-sdk/provider-utils';
 
 /**
  * Create a type from an object with all keys and nested keys set to optional.

package/src/util/download/download.ts

@@ -3,8 +3,6 @@ import {
   readResponseWithSizeLimit,
   DEFAULT_MAX_DOWNLOAD_SIZE,
   validateDownloadUrl,
-} from '@ai-sdk/provider-utils';
-import {
   withUserAgentSuffix,
   getRuntimeEnvironmentUserAgent,
 } from '@ai-sdk/provider-utils';

package/src/util/extract-literal-union.ts

@@ -0,0 +1,18 @@
+/**
+ * If `text` is exactly the wide `string` type, there are no string literals to
+ * preserve, so this resolves to `never`.
+ *
+ * If `text` is a string literal or a union of string literals, this resolves
+ * to that literal union unchanged.
+ *
+ * This is used when building template-literal model identifiers (for example
+ * `"provider:modelId"`) so that editors can suggest concrete `modelId` values
+ * when the underlying method parameter is narrowed, while falling back to a
+ * generic `"provider:${string}"` style overload when the parameter is only
+ * typed as `string`.
+ */
+export type ExtractLiteralUnion<text> = text extends string
+  ? string extends text
+    ? never
+    : text
+  : never;

package/src/util/is-node-runtime.ts

@@ -0,0 +1,3 @@
+export function isNodeRuntime(): boolean {
+  return typeof process !== 'undefined' && process.release?.name === 'node';
+}

package/src/util/notify.ts

@@ -1,4 +1,4 @@
-import { Arrayable, asArray } from '@ai-sdk/provider-utils';
+import { asArray, type Arrayable } from '@ai-sdk/provider-utils';
 import type { Callback } from './callback';
 
 /**

package/src/util/parse-partial-json.ts

@@ -1,4 +1,4 @@
-import { JSONValue } from '@ai-sdk/provider';
+import type { JSONValue } from '@ai-sdk/provider';
 import { safeParseJSON } from '@ai-sdk/provider-utils';
 import { fixJson } from './fix-json';
 

package/src/util/prepare-retries.ts

@@ -1,9 +1,8 @@
 import { InvalidArgumentError } from '../error/invalid-argument-error';
 import {
-  RetryFunction,
   retryWithExponentialBackoffRespectingRetryHeaders,
+  type RetryFunction,
 } from '../util/retry-with-exponential-backoff';
-
 /**
  * Validate and prepare retries.
  */

package/src/util/serial-job-executor.ts

@@ -1,4 +1,4 @@
-import { Job } from './job';
+import type { Job } from './job';
 
 export class SerialJobExecutor {
   private queue: Array<Job> = [];

package/src/util/write-to-server-response.ts

@@ -1,4 +1,4 @@
-import { ServerResponse } from 'node:http';
+import type { ServerResponse } from 'node:http';
 
 /**
  * Writes the content of a stream to a server response.

package/src/util/detect-media-type.ts

@@ -1,235 +0,0 @@
-import { convertBase64ToUint8Array } from '@ai-sdk/provider-utils';
-
-export const imageMediaTypeSignatures = [
-  {
-    mediaType: 'image/gif' as const,
-    bytesPrefix: [0x47, 0x49, 0x46], // GIF
-  },
-  {
-    mediaType: 'image/png' as const,
-    bytesPrefix: [0x89, 0x50, 0x4e, 0x47], // PNG
-  },
-  {
-    mediaType: 'image/jpeg' as const,
-    bytesPrefix: [0xff, 0xd8], // JPEG
-  },
-  {
-    mediaType: 'image/webp' as const,
-    bytesPrefix: [
-      0x52,
-      0x49,
-      0x46,
-      0x46, // "RIFF"
-      null,
-      null,
-      null,
-      null, // file size (variable)
-      0x57,
-      0x45,
-      0x42,
-      0x50, // "WEBP"
-    ],
-  },
-  {
-    mediaType: 'image/bmp' as const,
-    bytesPrefix: [0x42, 0x4d],
-  },
-  {
-    mediaType: 'image/tiff' as const,
-    bytesPrefix: [0x49, 0x49, 0x2a, 0x00],
-  },
-  {
-    mediaType: 'image/tiff' as const,
-    bytesPrefix: [0x4d, 0x4d, 0x00, 0x2a],
-  },
-  {
-    mediaType: 'image/avif' as const,
-    bytesPrefix: [
-      0x00, 0x00, 0x00, 0x20, 0x66, 0x74, 0x79, 0x70, 0x61, 0x76, 0x69, 0x66,
-    ],
-  },
-  {
-    mediaType: 'image/heic' as const,
-    bytesPrefix: [
-      0x00, 0x00, 0x00, 0x20, 0x66, 0x74, 0x79, 0x70, 0x68, 0x65, 0x69, 0x63,
-    ],
-  },
-] as const;
-
-export const documentMediaTypeSignatures = [
-  {
-    mediaType: 'application/pdf' as const,
-    bytesPrefix: [0x25, 0x50, 0x44, 0x46], // %PDF
-  },
-] as const;
-
-export const audioMediaTypeSignatures = [
-  {
-    mediaType: 'audio/mpeg' as const,
-    bytesPrefix: [0xff, 0xfb],
-  },
-  {
-    mediaType: 'audio/mpeg' as const,
-    bytesPrefix: [0xff, 0xfa],
-  },
-  {
-    mediaType: 'audio/mpeg' as const,
-    bytesPrefix: [0xff, 0xf3],
-  },
-  {
-    mediaType: 'audio/mpeg' as const,
-    bytesPrefix: [0xff, 0xf2],
-  },
-  {
-    mediaType: 'audio/mpeg' as const,
-    bytesPrefix: [0xff, 0xe3],
-  },
-  {
-    mediaType: 'audio/mpeg' as const,
-    bytesPrefix: [0xff, 0xe2],
-  },
-  {
-    mediaType: 'audio/wav' as const,
-    bytesPrefix: [
-      0x52, // R
-      0x49, // I
-      0x46, // F
-      0x46, // F
-      null,
-      null,
-      null,
-      null,
-      0x57, // W
-      0x41, // A
-      0x56, // V
-      0x45, // E
-    ],
-  },
-  {
-    mediaType: 'audio/ogg' as const,
-    bytesPrefix: [0x4f, 0x67, 0x67, 0x53],
-  },
-  {
-    mediaType: 'audio/flac' as const,
-    bytesPrefix: [0x66, 0x4c, 0x61, 0x43],
-  },
-  {
-    mediaType: 'audio/aac' as const,
-    bytesPrefix: [0x40, 0x15, 0x00, 0x00],
-  },
-  {
-    mediaType: 'audio/mp4' as const,
-    bytesPrefix: [0x66, 0x74, 0x79, 0x70],
-  },
-  {
-    mediaType: 'audio/webm',
-    bytesPrefix: [0x1a, 0x45, 0xdf, 0xa3],
-  },
-] as const;
-
-export const videoMediaTypeSignatures = [
-  {
-    mediaType: 'video/mp4' as const,
-    bytesPrefix: [
-      0x00,
-      0x00,
-      0x00,
-      null,
-      0x66,
-      0x74,
-      0x79,
-      0x70, // ftyp
-    ],
-  },
-  {
-    mediaType: 'video/webm' as const,
-    bytesPrefix: [0x1a, 0x45, 0xdf, 0xa3], // EBML
-  },
-  {
-    mediaType: 'video/quicktime' as const,
-    bytesPrefix: [
-      0x00,
-      0x00,
-      0x00,
-      0x14,
-      0x66,
-      0x74,
-      0x79,
-      0x70,
-      0x71,
-      0x74, // ftypqt
-    ],
-  },
-  {
-    mediaType: 'video/x-msvideo' as const,
-    bytesPrefix: [0x52, 0x49, 0x46, 0x46], // RIFF (AVI)
-  },
-] as const;
-
-const stripID3 = (data: Uint8Array | string) => {
-  const bytes =
-    typeof data === 'string' ? convertBase64ToUint8Array(data) : data;
-  const id3Size =
-    ((bytes[6] & 0x7f) << 21) |
-    ((bytes[7] & 0x7f) << 14) |
-    ((bytes[8] & 0x7f) << 7) |
-    (bytes[9] & 0x7f);
-
-  // The raw MP3 starts here
-  return bytes.slice(id3Size + 10);
-};
-
-function stripID3TagsIfPresent(data: Uint8Array | string): Uint8Array | string {
-  const hasId3 =
-    (typeof data === 'string' && data.startsWith('SUQz')) ||
-    (typeof data !== 'string' &&
-      data.length > 10 &&
-      data[0] === 0x49 && // 'I'
-      data[1] === 0x44 && // 'D'
-      data[2] === 0x33); // '3'
-
-  return hasId3 ? stripID3(data) : data;
-}
-
-/**
- * Detect the media IANA media type of a file using a list of signatures.
- *
- * @param data - The file data.
- * @param signatures - The signatures to use for detection.
- * @returns The media type of the file.
- */
-type MediaTypeSignatures = ReadonlyArray<{
-  readonly mediaType: string;
-  readonly bytesPrefix: ReadonlyArray<number | null>;
-}>;
-
-export function detectMediaType<T extends MediaTypeSignatures>({
-  data,
-  signatures,
-}: {
-  data: Uint8Array | string;
-  signatures: T;
-}): T[number]['mediaType'] | undefined {
-  const processedData = stripID3TagsIfPresent(data);
-
-  // Convert the first ~18 bytes (24 base64 chars) for consistent detection logic:
-  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 undefined;
-}