@ai-sdk/provider-utils 5.0.11 → 5.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.11",
+  "version": "5.0.13",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,7 +35,7 @@
     "@standard-schema/spec": "^1.1.0",
     "@workflow/serde": "4.1.0",
     "eventsource-parser": "^3.0.8",
-    "@ai-sdk/provider": "4.0.3"
+    "@ai-sdk/provider": "4.0.4"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/detect-media-type.ts

@@ -63,7 +63,7 @@ const documentMediaTypeSignatures = [
   },
 ] as const;
 
-const audioMediaTypeSignatures = [
+const audioMediaTypeSignaturesWithoutMp4 = [
   {
     mediaType: 'audio/mpeg' as const,
     bytesPrefix: [0xff, 0xfb],
@@ -117,16 +117,29 @@ const audioMediaTypeSignatures = [
     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 audioMediaTypeSignatures = [
+  ...audioMediaTypeSignaturesWithoutMp4,
+  {
+    mediaType: 'audio/mp4' as const,
+    bytesPrefix: [
+      0x00,
+      0x00,
+      0x00,
+      null,
+      0x66,
+      0x74,
+      0x79,
+      0x70, // ftyp
+    ],
+  },
+] as const;
+
 const videoMediaTypeSignatures = [
   {
     mediaType: 'video/mp4' as const,
@@ -166,31 +179,54 @@ const videoMediaTypeSignatures = [
   },
 ] as const;
 
-const stripID3 = (data: Uint8Array | string) => {
-  const bytes =
-    typeof data === 'string' ? convertBase64ToUint8Array(data) : data;
+const DEFAULT_SNIFF_BYTES = 18;
+
+// Longest signature prefix in the tables above (e.g. image/avif = 12 bytes).
+const MAX_SIGNATURE_BYTES = 12;
+
+// Largest ID3v2 tag (10-byte header + body) skipped to reach the audio frame.
+// Covers typical tags including embedded cover art while keeping the decode
+// bounded and O(1) in the attachment size. Exported for boundary tests.
+export const MAX_ID3_TAG_BYTES = 128 * 1024;
+
+// Total prefix decoded when an ID3 tag is present: the tag plus room for the
+// trailing signature, so a tag right at the size limit stays detectable.
+const ID3_SCAN_BYTES = MAX_ID3_TAG_BYTES + MAX_SIGNATURE_BYTES;
+
+// Decode/view exactly the first `maxBytes` bytes from the front of the input.
+// The base64 and raw-byte paths yield the same length, so detection does not
+// depend on the input's representation.
+function decodePrefix(data: Uint8Array | string, maxBytes: number): Uint8Array {
+  if (typeof data !== 'string') {
+    return data.length > maxBytes ? data.subarray(0, maxBytes) : data;
+  }
+  // base64: 4 chars -> 3 bytes. Decode whole 4-char groups, then trim the 0-2
+  // extra bytes so the result matches the raw-byte path exactly.
+  const maxChars = Math.ceil(maxBytes / 3) * 4;
+  const bytes = convertBase64ToUint8Array(
+    data.substring(0, Math.min(data.length, maxChars)),
+  );
+  return bytes.length > maxBytes ? bytes.subarray(0, maxBytes) : bytes;
+}
+
+function hasID3(bytes: Uint8Array): boolean {
+  return (
+    bytes.length > 10 &&
+    bytes[0] === 0x49 && // 'I'
+    bytes[1] === 0x44 && // 'D'
+    bytes[2] === 0x33 // '3'
+  );
+}
+
+const stripID3 = (bytes: Uint8Array): Uint8Array => {
   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);
+  return bytes.subarray(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>;
@@ -203,15 +239,13 @@ function detectMediaTypeBySignatures<T extends MediaTypeSignatures>({
   data: Uint8Array | string;
   signatures: T;
 }): T[number]['mediaType'] | undefined {
-  const processedData = stripID3TagsIfPresent(data);
+  let bytes = decodePrefix(data, DEFAULT_SNIFF_BYTES);
 
-  // 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;
+  // ID3v2-tagged MP3s carry the audio frame after the tag; scan a bounded
+  // prefix past it rather than decoding the whole input.
+  if (hasID3(bytes)) {
+    bytes = stripID3(decodePrefix(data, ID3_SCAN_BYTES));
+  }
 
   for (const signature of signatures) {
     if (
@@ -259,7 +293,9 @@ export function detectMediaType({
       signatures: [
         ...imageMediaTypeSignatures,
         ...documentMediaTypeSignatures,
-        ...audioMediaTypeSignatures,
+        // MP4 containers cannot be distinguished as audio or video by ftyp alone.
+        // Preserve the generic detection result as video/mp4.
+        ...audioMediaTypeSignaturesWithoutMp4,
         ...videoMediaTypeSignatures,
       ],
     });