@ai-sdk/provider-utils 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/test/index.d.ts

@@ -9,9 +9,10 @@ declare function convertReadableStreamToArray<T>(stream: ReadableStream<T>): Pro
 declare function convertResponseStreamToArray(response: Response): Promise<string[]>;
 
 declare function isNodeVersion(version: number): boolean;
+declare function isNodeVersionAtLeast(major: number, minor?: number, patch?: number): boolean;
 
 declare function mockId({ prefix, }?: {
     prefix?: string;
 }): () => string;
 
-export { convertArrayToAsyncIterable, convertArrayToReadableStream, convertAsyncIterableToArray, convertReadableStreamToArray, convertResponseStreamToArray, isNodeVersion, mockId };
+export { convertArrayToAsyncIterable, convertArrayToReadableStream, convertAsyncIterableToArray, convertReadableStreamToArray, convertResponseStreamToArray, isNodeVersion, isNodeVersionAtLeast, mockId };

package/dist/test/index.js

@@ -1,35 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/test/index.ts
-var index_exports = {};
-__export(index_exports, {
-  convertArrayToAsyncIterable: () => convertArrayToAsyncIterable,
-  convertArrayToReadableStream: () => convertArrayToReadableStream,
-  convertAsyncIterableToArray: () => convertAsyncIterableToArray,
-  convertReadableStreamToArray: () => convertReadableStreamToArray,
-  convertResponseStreamToArray: () => convertResponseStreamToArray,
-  isNodeVersion: () => isNodeVersion,
-  mockId: () => mockId
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/test/convert-array-to-async-iterable.ts
 function convertArrayToAsyncIterable(values) {
   return {
@@ -79,16 +47,29 @@ async function convertReadableStreamToArray(stream) {
 
 // src/test/convert-response-stream-to-array.ts
 async function convertResponseStreamToArray(response) {
-  return convertReadableStreamToArray(
+  return await convertReadableStreamToArray(
     response.body.pipeThrough(new TextDecoderStream())
   );
 }
 
 // src/test/is-node-version.ts
+function getNodeVersionParts() {
+  return process.versions.node.split(".").map((version) => Number.parseInt(version, 10));
+}
 function isNodeVersion(version) {
-  const nodeMajorVersion = parseInt(process.version.slice(1).split(".")[0], 10);
+  const [nodeMajorVersion] = getNodeVersionParts();
   return nodeMajorVersion === version;
 }
+function isNodeVersionAtLeast(major, minor = 0, patch = 0) {
+  const [nodeMajorVersion, nodeMinorVersion, nodePatchVersion] = getNodeVersionParts();
+  if (nodeMajorVersion !== major) {
+    return nodeMajorVersion > major;
+  }
+  if (nodeMinorVersion !== minor) {
+    return nodeMinorVersion > minor;
+  }
+  return nodePatchVersion >= patch;
+}
 
 // src/test/mock-id.ts
 function mockId({
@@ -97,14 +78,14 @@ function mockId({
   let counter = 0;
   return () => `${prefix}-${counter++}`;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   convertArrayToAsyncIterable,
   convertArrayToReadableStream,
   convertAsyncIterableToArray,
   convertReadableStreamToArray,
   convertResponseStreamToArray,
   isNodeVersion,
+  isNodeVersionAtLeast,
   mockId
-});
+};
 //# sourceMappingURL=index.js.map

package/dist/test/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/test/index.ts","../../src/test/convert-array-to-async-iterable.ts","../../src/test/convert-array-to-readable-stream.ts","../../src/test/convert-async-iterable-to-array.ts","../../src/test/convert-readable-stream-to-array.ts","../../src/test/convert-response-stream-to-array.ts","../../src/test/is-node-version.ts","../../src/test/mock-id.ts"],"sourcesContent":["export * from './convert-array-to-async-iterable';\nexport * from './convert-array-to-readable-stream';\nexport * from './convert-async-iterable-to-array';\nexport * from './convert-readable-stream-to-array';\nexport * from './convert-response-stream-to-array';\nexport * from './is-node-version';\nexport * from './mock-id';\n","export function convertArrayToAsyncIterable<T>(values: T[]): AsyncIterable<T> {\n  return {\n    async *[Symbol.asyncIterator]() {\n      for (const value of values) {\n        yield value;\n      }\n    },\n  };\n}\n","export function convertArrayToReadableStream<T>(\n  values: T[],\n): ReadableStream<T> {\n  return new ReadableStream({\n    start(controller) {\n      try {\n        for (const value of values) {\n          controller.enqueue(value);\n        }\n      } finally {\n        controller.close();\n      }\n    },\n  });\n}\n","export async function convertAsyncIterableToArray<T>(\n  iterable: AsyncIterable<T>,\n): Promise<T[]> {\n  const result: T[] = [];\n  for await (const item of iterable) {\n    result.push(item);\n  }\n  return result;\n}\n","export async function convertReadableStreamToArray<T>(\n  stream: ReadableStream<T>,\n): Promise<T[]> {\n  const reader = stream.getReader();\n  const result: T[] = [];\n\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    result.push(value);\n  }\n\n  return result;\n}\n","import { convertReadableStreamToArray } from './convert-readable-stream-to-array';\n\nexport async function convertResponseStreamToArray(\n  response: Response,\n): Promise<string[]> {\n  return convertReadableStreamToArray(\n    response.body!.pipeThrough(new TextDecoderStream()),\n  );\n}\n","export function isNodeVersion(version: number) {\n  const nodeMajorVersion = parseInt(process.version.slice(1).split('.')[0], 10);\n  return nodeMajorVersion === version;\n}\n","export function mockId({\n  prefix = 'id',\n}: {\n  prefix?: string;\n} = {}): () => string {\n  let counter = 0;\n  return () => `${prefix}-${counter++}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,SAAS,4BAA+B,QAA+B;AAC5E,SAAO;AAAA,IACL,QAAQ,OAAO,aAAa,IAAI;AAC9B,iBAAW,SAAS,QAAQ;AAC1B,cAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;;;ACRO,SAAS,6BACd,QACmB;AACnB,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,YAAY;AAChB,UAAI;AACF,mBAAW,SAAS,QAAQ;AAC1B,qBAAW,QAAQ,KAAK;AAAA,QAC1B;AAAA,MACF,UAAE;AACA,mBAAW,MAAM;AAAA,MACnB;AAAA,IACF;AAAA,EACF,CAAC;AACH;;;ACdA,eAAsB,4BACpB,UACc;AACd,QAAM,SAAc,CAAC;AACrB,mBAAiB,QAAQ,UAAU;AACjC,WAAO,KAAK,IAAI;AAAA,EAClB;AACA,SAAO;AACT;;;ACRA,eAAsB,6BACpB,QACc;AACd,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,SAAc,CAAC;AAErB,SAAO,MAAM;AACX,UAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,QAAI,KAAM;AACV,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,SAAO;AACT;;;ACXA,eAAsB,6BACpB,UACmB;AACnB,SAAO;AAAA,IACL,SAAS,KAAM,YAAY,IAAI,kBAAkB,CAAC;AAAA,EACpD;AACF;;;ACRO,SAAS,cAAc,SAAiB;AAC7C,QAAM,mBAAmB,SAAS,QAAQ,QAAQ,MAAM,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,GAAG,EAAE;AAC5E,SAAO,qBAAqB;AAC9B;;;ACHO,SAAS,OAAO;AAAA,EACrB,SAAS;AACX,IAEI,CAAC,GAAiB;AACpB,MAAI,UAAU;AACd,SAAO,MAAM,GAAG,MAAM,IAAI,SAAS;AACrC;","names":[]}
+{"version":3,"sources":["../../src/test/convert-array-to-async-iterable.ts","../../src/test/convert-array-to-readable-stream.ts","../../src/test/convert-async-iterable-to-array.ts","../../src/test/convert-readable-stream-to-array.ts","../../src/test/convert-response-stream-to-array.ts","../../src/test/is-node-version.ts","../../src/test/mock-id.ts"],"sourcesContent":["export function convertArrayToAsyncIterable<T>(values: T[]): AsyncIterable<T> {\n  return {\n    async *[Symbol.asyncIterator]() {\n      for (const value of values) {\n        yield value;\n      }\n    },\n  };\n}\n","export function convertArrayToReadableStream<T>(\n  values: T[],\n): ReadableStream<T> {\n  return new ReadableStream({\n    start(controller) {\n      try {\n        for (const value of values) {\n          controller.enqueue(value);\n        }\n      } finally {\n        controller.close();\n      }\n    },\n  });\n}\n","export async function convertAsyncIterableToArray<T>(\n  iterable: AsyncIterable<T>,\n): Promise<T[]> {\n  const result: T[] = [];\n  for await (const item of iterable) {\n    result.push(item);\n  }\n  return result;\n}\n","export async function convertReadableStreamToArray<T>(\n  stream: ReadableStream<T>,\n): Promise<T[]> {\n  const reader = stream.getReader();\n  const result: T[] = [];\n\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    result.push(value);\n  }\n\n  return result;\n}\n","import { convertReadableStreamToArray } from './convert-readable-stream-to-array';\n\nexport async function convertResponseStreamToArray(\n  response: Response,\n): Promise<string[]> {\n  return await convertReadableStreamToArray(\n    response.body!.pipeThrough(new TextDecoderStream()),\n  );\n}\n","function getNodeVersionParts() {\n  return process.versions.node\n    .split('.')\n    .map(version => Number.parseInt(version, 10));\n}\n\nexport function isNodeVersion(version: number) {\n  const [nodeMajorVersion] = getNodeVersionParts();\n  return nodeMajorVersion === version;\n}\n\nexport function isNodeVersionAtLeast(major: number, minor = 0, patch = 0) {\n  const [nodeMajorVersion, nodeMinorVersion, nodePatchVersion] =\n    getNodeVersionParts();\n\n  if (nodeMajorVersion !== major) {\n    return nodeMajorVersion > major;\n  }\n\n  if (nodeMinorVersion !== minor) {\n    return nodeMinorVersion > minor;\n  }\n\n  return nodePatchVersion >= patch;\n}\n","export function mockId({\n  prefix = 'id',\n}: {\n  prefix?: string;\n} = {}): () => string {\n  let counter = 0;\n  return () => `${prefix}-${counter++}`;\n}\n"],"mappings":";AAAO,SAAS,4BAA+B,QAA+B;AAC5E,SAAO;AAAA,IACL,QAAQ,OAAO,aAAa,IAAI;AAC9B,iBAAW,SAAS,QAAQ;AAC1B,cAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;;;ACRO,SAAS,6BACd,QACmB;AACnB,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,YAAY;AAChB,UAAI;AACF,mBAAW,SAAS,QAAQ;AAC1B,qBAAW,QAAQ,KAAK;AAAA,QAC1B;AAAA,MACF,UAAE;AACA,mBAAW,MAAM;AAAA,MACnB;AAAA,IACF;AAAA,EACF,CAAC;AACH;;;ACdA,eAAsB,4BACpB,UACc;AACd,QAAM,SAAc,CAAC;AACrB,mBAAiB,QAAQ,UAAU;AACjC,WAAO,KAAK,IAAI;AAAA,EAClB;AACA,SAAO;AACT;;;ACRA,eAAsB,6BACpB,QACc;AACd,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,SAAc,CAAC;AAErB,SAAO,MAAM;AACX,UAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,QAAI,KAAM;AACV,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,SAAO;AACT;;;ACXA,eAAsB,6BACpB,UACmB;AACnB,SAAO,MAAM;AAAA,IACX,SAAS,KAAM,YAAY,IAAI,kBAAkB,CAAC;AAAA,EACpD;AACF;;;ACRA,SAAS,sBAAsB;AAC7B,SAAO,QAAQ,SAAS,KACrB,MAAM,GAAG,EACT,IAAI,aAAW,OAAO,SAAS,SAAS,EAAE,CAAC;AAChD;AAEO,SAAS,cAAc,SAAiB;AAC7C,QAAM,CAAC,gBAAgB,IAAI,oBAAoB;AAC/C,SAAO,qBAAqB;AAC9B;AAEO,SAAS,qBAAqB,OAAe,QAAQ,GAAG,QAAQ,GAAG;AACxE,QAAM,CAAC,kBAAkB,kBAAkB,gBAAgB,IACzD,oBAAoB;AAEtB,MAAI,qBAAqB,OAAO;AAC9B,WAAO,mBAAmB;AAAA,EAC5B;AAEA,MAAI,qBAAqB,OAAO;AAC9B,WAAO,mBAAmB;AAAA,EAC5B;AAEA,SAAO,oBAAoB;AAC7B;;;ACxBO,SAAS,OAAO;AAAA,EACrB,SAAS;AACX,IAEI,CAAC,GAAiB;AACpB,MAAI,UAAU;AACd,SAAO,MAAM,GAAG,MAAM,IAAI,SAAS;AACrC;","names":[]}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.30",
+  "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "source": "./src/index.ts",
   "files": [
@@ -22,20 +22,20 @@
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./test": {
       "types": "./dist/test/index.d.ts",
-      "import": "./dist/test/index.mjs",
-      "module": "./dist/test/index.mjs",
-      "require": "./dist/test/index.js"
+      "import": "./dist/test/index.js",
+      "default": "./dist/test/index.js"
     }
   },
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "eventsource-parser": "^3.0.6",
-    "@ai-sdk/provider": "4.0.0-beta.2"
+    "@workflow/serde": "4.1.0",
+    "eventsource-parser": "^3.0.8",
+    "@ai-sdk/provider": "4.0.0-beta.14"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
@@ -52,12 +52,14 @@
     "node": ">=18"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "homepage": "https://ai-sdk.dev/docs",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vercel/ai.git"
+    "url": "https://github.com/vercel/ai",
+    "directory": "packages/provider-utils"
   },
   "bugs": {
     "url": "https://github.com/vercel/ai/issues"
@@ -69,9 +71,7 @@
     "build": "pnpm clean && tsup --tsconfig tsconfig.build.json",
     "build:watch": "pnpm clean && tsup --watch",
     "clean": "del-cli dist *.tsbuildinfo",
-    "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --build",
-    "prettier-check": "prettier --check \"./**/*.ts*\"",
     "test": "pnpm test:node && pnpm test:edge",
     "test:update": "pnpm test:node -u",
     "test:watch": "vitest --config vitest.node.config.js",

package/src/add-additional-properties-to-json-schema.ts

@@ -1,4 +1,4 @@
-import { JSONSchema7, JSONSchema7Definition } from '@ai-sdk/provider';
+import type { JSONSchema7, JSONSchema7Definition } from '@ai-sdk/provider';
 
 /**
  * Recursively adds additionalProperties: false to the JSON schema. This is necessary because some providers (e.g. OpenAI) do not support additionalProperties: true.

package/src/as-array.ts

@@ -0,0 +1,12 @@
+/**
+ * A value that can be provided either as a single item, an array of items,
+ * or be left undefined.
+ */
+export type Arrayable<T> = T | T[] | undefined;
+
+/**
+ * Normalizes a possibly undefined or non-array value into an array.
+ */
+export function asArray<T>(value: Arrayable<T>): T[] {
+  return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}

package/src/convert-image-model-file-to-data-uri.ts

@@ -1,14 +1,14 @@
-import { ImageModelV3File } from '@ai-sdk/provider';
+import type { ImageModelV4File } from '@ai-sdk/provider';
 import { convertUint8ArrayToBase64 } from './uint8-utils';
 
 /**
- * Convert an ImageModelV3File to a URL or data URI string.
+ * Convert an ImageModelV4File to a URL or data URI string.
  *
  * If the file is a URL, it returns the URL as-is.
  * If the file is base64 data, it returns a data URI with the base64 data.
  * If the file is a Uint8Array, it converts it to base64 and returns a data URI.
  */
-export function convertImageModelFileToDataUri(file: ImageModelV3File): string {
+export function convertImageModelFileToDataUri(file: ImageModelV4File): string {
   if (file.type === 'url') return file.url;
 
   return `data:${file.mediaType};base64,${

package/src/convert-inline-file-data-to-uint8-array.ts

@@ -0,0 +1,30 @@
+import type { FilePart } from './types/content-part';
+import { convertBase64ToUint8Array } from './uint8-utils';
+
+type InlineFileData = Extract<
+  FilePart['data'],
+  { type: 'data' } | { type: 'text' }
+>;
+
+/**
+ * Converts inline file data (a tagged `data` or `text` shape) into raw bytes.
+ *
+ * - `{ type: 'text', text }` → UTF-8 encoded bytes
+ * - `{ type: 'data', data: Uint8Array | Buffer }` → returned as-is
+ * - `{ type: 'data', data: ArrayBuffer }` → wrapped in a `Uint8Array`
+ * - `{ type: 'data', data: string }` → decoded as base64
+ */
+export function convertInlineFileDataToUint8Array(
+  data: InlineFileData,
+): Uint8Array {
+  if (data.type === 'text') {
+    return new TextEncoder().encode(data.text);
+  }
+  if (data.data instanceof Uint8Array) {
+    return data.data;
+  }
+  if (data.data instanceof ArrayBuffer) {
+    return new Uint8Array(data.data);
+  }
+  return convertBase64ToUint8Array(data.data);
+}

package/src/create-tool-name-mapping.ts

@@ -1,6 +1,6 @@
-import {
-  LanguageModelV3FunctionTool,
-  LanguageModelV3ProviderTool,
+import type {
+  LanguageModelV4FunctionTool,
+  LanguageModelV4ProviderTool,
 } from '@ai-sdk/provider';
 
 /**
@@ -33,41 +33,25 @@ export interface ToolNameMapping {
 export function createToolNameMapping({
   tools = [],
   providerToolNames,
-  resolveProviderToolName,
 }: {
   /**
    * Tools that were passed to the language model.
    */
   tools:
-    | Array<LanguageModelV3FunctionTool | LanguageModelV3ProviderTool>
+    | Array<LanguageModelV4FunctionTool | LanguageModelV4ProviderTool>
     | undefined;
 
   /**
    * Maps the provider tool ids to the provider tool names.
    */
   providerToolNames: Record<`${string}.${string}`, string>;
-
-  /**
-   * Optional resolver for provider tool names that cannot be represented as
-   * static id -> name mappings (e.g. dynamic provider names).
-   */
-  resolveProviderToolName?: (
-    tool: LanguageModelV3ProviderTool,
-  ) => string | undefined;
 }): ToolNameMapping {
   const customToolNameToProviderToolName: Record<string, string> = {};
   const providerToolNameToCustomToolName: Record<string, string> = {};
 
   for (const tool of tools) {
-    if (tool.type === 'provider') {
-      const providerToolName =
-        resolveProviderToolName?.(tool) ??
-        (tool.id in providerToolNames ? providerToolNames[tool.id] : undefined);
-
-      if (providerToolName == null) {
-        continue;
-      }
-
+    if (tool.type === 'provider' && tool.id in providerToolNames) {
+      const providerToolName = providerToolNames[tool.id];
       customToolNameToProviderToolName[tool.name] = providerToolName;
       providerToolNameToCustomToolName[providerToolName] = tool.name;
     }

package/src/detect-media-type.ts

@@ -0,0 +1,312 @@
+import { convertBase64ToUint8Array } from './uint8-utils';
+
+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;
+
+const documentMediaTypeSignatures = [
+  {
+    mediaType: 'application/pdf' as const,
+    bytesPrefix: [0x25, 0x50, 0x44, 0x46], // %PDF
+  },
+] as const;
+
+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;
+
+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;
+}
+
+type MediaTypeSignatures = ReadonlyArray<{
+  readonly mediaType: string;
+  readonly bytesPrefix: ReadonlyArray<number | null>;
+}>;
+
+function detectMediaTypeBySignatures<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;
+}
+
+const topLevelSignatureTables = {
+  image: imageMediaTypeSignatures,
+  audio: audioMediaTypeSignatures,
+  video: videoMediaTypeSignatures,
+  application: documentMediaTypeSignatures,
+} as const;
+
+type TopLevelMediaType = keyof typeof topLevelSignatureTables;
+
+/**
+ * Detect the IANA media type of a file from its raw bytes or base64 string.
+ *
+ * - When `topLevelType` is omitted, every known signature is considered
+ *   (image, audio, video, and application). Returns `undefined` when the
+ *   bytes do not match any known signature.
+ * - When `topLevelType` is provided, only signatures for that top-level
+ *   segment are considered. Returns `undefined` for unsupported segments
+ *   (e.g. `"text"`) or when no signature matches.
+ */
+export function detectMediaType({
+  data,
+  topLevelType,
+}: {
+  data: Uint8Array | string;
+  topLevelType?: string;
+}): string | undefined {
+  if (topLevelType === undefined) {
+    return detectMediaTypeBySignatures({
+      data,
+      signatures: [
+        ...imageMediaTypeSignatures,
+        ...documentMediaTypeSignatures,
+        ...audioMediaTypeSignatures,
+        ...videoMediaTypeSignatures,
+      ],
+    });
+  }
+
+  const signatures = topLevelSignatureTables[topLevelType as TopLevelMediaType];
+
+  if (signatures === undefined) {
+    return undefined;
+  }
+
+  return detectMediaTypeBySignatures({ data, signatures });
+}
+
+/**
+ * Returns the top-level segment of a media type (the portion before `/`).
+ *
+ * Examples:
+ *   - `"image/png"` -> `"image"`
+ *   - `"image/*"` -> `"image"`
+ *   - `"image"` -> `"image"`
+ *   - `"image/"` -> `"image"`
+ *   - `""` -> `""`
+ *   - `"/"` -> `""`
+ */
+export function getTopLevelMediaType(mediaType: string): string {
+  const slashIndex = mediaType.indexOf('/');
+  return slashIndex === -1 ? mediaType : mediaType.substring(0, slashIndex);
+}
+
+/**
+ * Returns `true` only when the given media type has a non-empty, non-wildcard
+ * subtype (i.e. matches the form `type/subtype`, and `subtype` is not `*`).
+ *
+ * Examples:
+ *   - `"image/png"` -> `true`
+ *   - `"image/*"` -> `false`
+ *   - `"image"` -> `false`
+ *   - `"image/"` -> `false`
+ *   - `""` -> `false`
+ *   - `"/"` -> `false`
+ */
+export function isFullMediaType(mediaType: string): boolean {
+  const slashIndex = mediaType.indexOf('/');
+  if (slashIndex === -1) {
+    return false;
+  }
+  const subtype = mediaType.substring(slashIndex + 1);
+  return subtype.length > 0 && subtype !== '*';
+}

package/src/filter-nullable.ts

@@ -0,0 +1,11 @@
+/**
+ * Filters `null` and `undefined` values out of a list of values.
+ *
+ * @param values - The values to filter.
+ * @returns A new array containing only non-nullish values.
+ */
+export function filterNullable<T>(
+  ...values: Array<T | undefined | null>
+): Array<T> {
+  return values.filter((value): value is NonNullable<T> => value != null);
+}

package/src/get-error-message.ts

@@ -1,15 +1 @@
-export function getErrorMessage(error: unknown | undefined) {
-  if (error == null) {
-    return 'unknown error';
-  }
-
-  if (typeof error === 'string') {
-    return error;
-  }
-
-  if (error instanceof Error) {
-    return error.message;
-  }
-
-  return JSON.stringify(error);
-}
+export { getErrorMessage } from '@ai-sdk/provider';

package/src/get-from-api.ts

@@ -1,9 +1,9 @@
 import { APICallError } from '@ai-sdk/provider';
 import { extractResponseHeaders } from './extract-response-headers';
-import { FetchFunction } from './fetch-function';
+import type { FetchFunction } from './fetch-function';
 import { handleFetchError } from './handle-fetch-error';
 import { isAbortError } from './is-abort-error';
-import { ResponseHandler } from './response-handler';
+import type { ResponseHandler } from './response-handler';
 import { getRuntimeEnvironmentUserAgent } from './get-runtime-environment-user-agent';
 import { withUserAgentSuffix } from './with-user-agent-suffix';
 import { VERSION } from './version';

package/src/has-required-key.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if an object has required keys.
+ * @param OBJECT - The object to check.
+ * @returns True if the object has required keys, false otherwise.
+ */
+export type HasRequiredKey<OBJECT> = {} extends OBJECT ? false : true;