ai 6.0.33 → 6.0.34

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

@@ -0,0 +1,184 @@
+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 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 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.
+ */
+export function detectMediaType({
+  data,
+  signatures,
+}: {
+  data: Uint8Array | string;
+  signatures: typeof audioMediaTypeSignatures | typeof imageMediaTypeSignatures;
+}): (typeof signatures)[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;
+}

package/src/util/download/download-function.ts

@@ -0,0 +1,45 @@
+import { download as originalDownload } from './download';
+
+/**
+ * Experimental. Can change in patch versions without warning.
+ *
+ * Download function. Called with the array of URLs and a boolean indicating
+ * whether the URL is supported by the model.
+ *
+ * The download function can decide for each URL:
+ * - to return null (which means that the URL should be passed to the model)
+ * - to download the asset and return the data (incl. retries, authentication, etc.)
+ *
+ * Should throw DownloadError if the download fails.
+ *
+ * Should return an array of objects sorted by the order of the requested downloads.
+ * For each object, the data should be a Uint8Array if the URL was downloaded.
+ * For each object, the mediaType should be the media type of the downloaded asset.
+ * For each object, the data should be null if the URL should be passed through as is.
+ */
+export type DownloadFunction = (
+  options: Array<{
+    url: URL;
+    isUrlSupportedByModel: boolean;
+  }>,
+) => PromiseLike<
+  Array<{
+    data: Uint8Array;
+    mediaType: string | undefined;
+  } | null>
+>;
+
+/**
+ * Default download function.
+ * Downloads the file if it is not supported by the model.
+ */
+export const createDefaultDownloadFunction =
+  (download: typeof originalDownload = originalDownload): DownloadFunction =>
+  requestedDownloads =>
+    Promise.all(
+      requestedDownloads.map(async requestedDownload =>
+        requestedDownload.isUrlSupportedByModel
+          ? null
+          : download(requestedDownload),
+      ),
+    );

package/src/util/download/download.test.ts

@@ -0,0 +1,69 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { DownloadError } from '@ai-sdk/provider-utils';
+import { download } from './download';
+import { describe, it, expect } from 'vitest';
+
+const server = createTestServer({
+  'http://example.com/file': {},
+});
+
+describe('download', () => {
+  it('should download data successfully and match expected bytes', async () => {
+    const expectedBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+
+    server.urls['http://example.com/file'].response = {
+      type: 'binary',
+      headers: {
+        'content-type': 'application/octet-stream',
+      },
+      body: Buffer.from(expectedBytes),
+    };
+
+    const result = await download({
+      url: new URL('http://example.com/file'),
+    });
+
+    expect(result).not.toBeNull();
+    expect(result!.data).toEqual(expectedBytes);
+    expect(result!.mediaType).toBe('application/octet-stream');
+
+    // UA header assertion
+    expect(server.calls[0].requestUserAgent).toContain('ai-sdk/');
+  });
+
+  it('should throw DownloadError when response is not ok', async () => {
+    server.urls['http://example.com/file'].response = {
+      type: 'error',
+      status: 404,
+      body: 'Not Found',
+    };
+
+    try {
+      await download({
+        url: new URL('http://example.com/file'),
+      });
+      expect.fail('Expected download to throw');
+    } catch (error: unknown) {
+      expect(error).toBeInstanceOf(DownloadError);
+      expect((error as DownloadError).statusCode).toBe(404);
+      expect((error as DownloadError).statusText).toBe('Not Found');
+    }
+  });
+
+  it('should throw DownloadError when fetch throws an error', async () => {
+    server.urls['http://example.com/file'].response = {
+      type: 'error',
+      status: 500,
+      body: 'Network error',
+    };
+
+    try {
+      await download({
+        url: new URL('http://example.com/file'),
+      });
+      expect.fail('Expected download to throw');
+    } catch (error: unknown) {
+      expect(error).toBeInstanceOf(DownloadError);
+    }
+  });
+});

package/src/util/download/download.ts

@@ -0,0 +1,46 @@
+import { DownloadError } from '@ai-sdk/provider-utils';
+import {
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent,
+} from '@ai-sdk/provider-utils';
+import { VERSION } from '../../version';
+
+/**
+ * Download a file from a URL.
+ *
+ * @param url - The URL to download from.
+ * @returns The downloaded data and media type.
+ *
+ * @throws DownloadError if the download fails.
+ */
+export const download = async ({ url }: { url: URL }) => {
+  const urlText = url.toString();
+  try {
+    const response = await fetch(urlText, {
+      headers: withUserAgentSuffix(
+        {},
+        `ai-sdk/${VERSION}`,
+        getRuntimeEnvironmentUserAgent(),
+      ),
+    });
+
+    if (!response.ok) {
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText,
+      });
+    }
+
+    return {
+      data: new Uint8Array(await response.arrayBuffer()),
+      mediaType: response.headers.get('content-type') ?? undefined,
+    };
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+
+    throw new DownloadError({ url: urlText, cause: error });
+  }
+};

package/src/util/error-handler.ts

@@ -0,0 +1 @@
+export type ErrorHandler = (error: unknown) => void;

package/src/util/fix-json.test.ts

@@ -0,0 +1,279 @@
+import assert from 'node:assert';
+import { describe, test } from 'vitest';
+import { fixJson } from './fix-json';
+
+test('should handle empty input', () => {
+  assert.strictEqual(fixJson(''), '');
+});
+
+describe('literals', () => {
+  test('should handle incomplete null', () => {
+    assert.strictEqual(fixJson('nul'), 'null');
+  });
+
+  test('should handle incomplete true', () => {
+    assert.strictEqual(fixJson('t'), 'true');
+  });
+
+  test('should handle incomplete false', () => {
+    assert.strictEqual(fixJson('fals'), 'false');
+  });
+});
+
+describe('number', () => {
+  test('should handle incomplete numbers', () => {
+    assert.strictEqual(fixJson('12.'), '12');
+  });
+
+  test('should handle numbers with dot', () => {
+    assert.strictEqual(fixJson('12.2'), '12.2');
+  });
+
+  test('should handle negative numbers', () => {
+    assert.strictEqual(fixJson('-12'), '-12');
+  });
+
+  test('should handle incomplete negative numbers', () => {
+    assert.strictEqual(fixJson('-'), '');
+  });
+
+  test('should handle e-notation numbers', () => {
+    assert.strictEqual(fixJson('2.5e'), '2.5');
+    assert.strictEqual(fixJson('2.5e-'), '2.5');
+    assert.strictEqual(fixJson('2.5e3'), '2.5e3');
+    assert.strictEqual(fixJson('-2.5e3'), '-2.5e3');
+  });
+
+  test('should handle uppercase e-notation numbers', () => {
+    assert.strictEqual(fixJson('2.5E'), '2.5');
+    assert.strictEqual(fixJson('2.5E-'), '2.5');
+    assert.strictEqual(fixJson('2.5E3'), '2.5E3');
+    assert.strictEqual(fixJson('-2.5E3'), '-2.5E3');
+  });
+
+  test('should handle incomplete numbers', () => {
+    assert.strictEqual(fixJson('12.e'), '12');
+    assert.strictEqual(fixJson('12.34e'), '12.34');
+    assert.strictEqual(fixJson('5e'), '5');
+  });
+});
+
+describe('string', () => {
+  test('should handle incomplete strings', () => {
+    assert.strictEqual(fixJson('"abc'), '"abc"');
+  });
+
+  test('should handle escape sequences', () => {
+    assert.strictEqual(
+      fixJson('"value with \\"quoted\\" text and \\\\ escape'),
+      '"value with \\"quoted\\" text and \\\\ escape"',
+    );
+  });
+
+  test('should handle incomplete escape sequences', () => {
+    assert.strictEqual(fixJson('"value with \\'), '"value with "');
+  });
+
+  test('should handle unicode characters', () => {
+    assert.strictEqual(
+      fixJson('"value with unicode \u003C"'),
+      '"value with unicode \u003C"',
+    );
+  });
+});
+
+describe('array', () => {
+  test('should handle incomplete array', () => {
+    assert.strictEqual(fixJson('['), '[]');
+  });
+
+  test('should handle closing bracket after number in array', () => {
+    assert.strictEqual(fixJson('[[1], [2'), '[[1], [2]]');
+  });
+
+  test('should handle closing bracket after string in array', () => {
+    assert.strictEqual(fixJson(`[["1"], ["2`), `[["1"], ["2"]]`);
+  });
+
+  test('should handle closing bracket after literal in array', () => {
+    assert.strictEqual(fixJson('[[false], [nu'), '[[false], [null]]');
+  });
+
+  test('should handle closing bracket after array in array', () => {
+    assert.strictEqual(fixJson('[[[]], [[]'), '[[[]], [[]]]');
+  });
+
+  test('should handle closing bracket after object in array', () => {
+    assert.strictEqual(fixJson('[[{}], [{'), '[[{}], [{}]]');
+  });
+
+  test('should handle trailing comma', () => {
+    assert.strictEqual(fixJson('[1, '), '[1]');
+  });
+
+  test('should handle closing array', () => {
+    assert.strictEqual(fixJson('[[], 123'), '[[], 123]');
+  });
+});
+
+describe('object', () => {
+  test('should handle keys without values', () => {
+    assert.strictEqual(fixJson('{"key":'), '{}');
+  });
+
+  test('should handle closing brace after number in object', () => {
+    assert.strictEqual(
+      fixJson('{"a": {"b": 1}, "c": {"d": 2'),
+      '{"a": {"b": 1}, "c": {"d": 2}}',
+    );
+  });
+
+  test('should handle closing brace after string in object', () => {
+    assert.strictEqual(
+      fixJson('{"a": {"b": "1"}, "c": {"d": 2'),
+      '{"a": {"b": "1"}, "c": {"d": 2}}',
+    );
+  });
+
+  test('should handle closing brace after literal in object', () => {
+    assert.strictEqual(
+      fixJson('{"a": {"b": false}, "c": {"d": 2'),
+      '{"a": {"b": false}, "c": {"d": 2}}',
+    );
+  });
+
+  test('should handle closing brace after array in object', () => {
+    assert.strictEqual(
+      fixJson('{"a": {"b": []}, "c": {"d": 2'),
+      '{"a": {"b": []}, "c": {"d": 2}}',
+    );
+  });
+
+  test('should handle closing brace after object in object', () => {
+    assert.strictEqual(
+      fixJson('{"a": {"b": {}}, "c": {"d": 2'),
+      '{"a": {"b": {}}, "c": {"d": 2}}',
+    );
+  });
+
+  test('should handle partial keys (first key)', () => {
+    assert.strictEqual(fixJson('{"ke'), '{}');
+  });
+
+  test('should handle partial keys (second key)', () => {
+    assert.strictEqual(fixJson('{"k1": 1, "k2'), '{"k1": 1}');
+  });
+
+  test('should handle partial keys with colon (second key)', () => {
+    assert.strictEqual(fixJson('{"k1": 1, "k2":'), '{"k1": 1}');
+  });
+
+  test('should handle trailing whitespace', () => {
+    assert.strictEqual(fixJson('{"key": "value"  '), '{"key": "value"}');
+  });
+
+  test('should handle closing after empty object', () => {
+    assert.strictEqual(fixJson('{"a": {"b": {}'), '{"a": {"b": {}}}');
+  });
+});
+
+describe('nesting', () => {
+  test('should handle nested arrays with numbers', () => {
+    assert.strictEqual(fixJson('[1, [2, 3, ['), '[1, [2, 3, []]]');
+  });
+
+  test('should handle nested arrays with literals', () => {
+    assert.strictEqual(fixJson('[false, [true, ['), '[false, [true, []]]');
+  });
+
+  test('should handle nested objects', () => {
+    assert.strictEqual(fixJson('{"key": {"subKey":'), '{"key": {}}');
+  });
+
+  test('should handle nested objects with numbers', () => {
+    assert.strictEqual(
+      fixJson('{"key": 123, "key2": {"subKey":'),
+      '{"key": 123, "key2": {}}',
+    );
+  });
+
+  test('should handle nested objects with literals', () => {
+    assert.strictEqual(
+      fixJson('{"key": null, "key2": {"subKey":'),
+      '{"key": null, "key2": {}}',
+    );
+  });
+
+  test('should handle arrays within objects', () => {
+    assert.strictEqual(fixJson('{"key": [1, 2, {'), '{"key": [1, 2, {}]}');
+  });
+
+  test('should handle objects within arrays', () => {
+    assert.strictEqual(
+      fixJson('[1, 2, {"key": "value",'),
+      '[1, 2, {"key": "value"}]',
+    );
+  });
+
+  test('should handle nested arrays and objects', () => {
+    assert.strictEqual(
+      fixJson('{"a": {"b": ["c", {"d": "e",'),
+      '{"a": {"b": ["c", {"d": "e"}]}}',
+    );
+  });
+
+  test('should handle deeply nested objects', () => {
+    assert.strictEqual(
+      fixJson('{"a": {"b": {"c": {"d":'),
+      '{"a": {"b": {"c": {}}}}',
+    );
+  });
+
+  test('should handle potential nested arrays or objects', () => {
+    assert.strictEqual(fixJson('{"a": 1, "b": ['), '{"a": 1, "b": []}');
+    assert.strictEqual(fixJson('{"a": 1, "b": {'), '{"a": 1, "b": {}}');
+    assert.strictEqual(fixJson('{"a": 1, "b": "'), '{"a": 1, "b": ""}');
+  });
+});
+
+describe('regression', () => {
+  test('should handle complex nesting 1', () => {
+    assert.strictEqual(
+      fixJson(
+        [
+          '{',
+          '  "a": [',
+          '    {',
+          '      "a1": "v1",',
+          '      "a2": "v2",',
+          `      "a3": "v3"`,
+          '    }',
+          '  ],',
+          '  "b": [',
+          '    {',
+          '      "b1": "n',
+        ].join('\n'),
+      ),
+      [
+        '{',
+        '  "a": [',
+        '    {',
+        '      "a1": "v1",',
+        '      "a2": "v2",',
+        `      "a3": "v3"`,
+        '    }',
+        '  ],',
+        '  "b": [',
+        '    {',
+        '      "b1": "n"}]}',
+      ].join('\n'),
+    );
+  });
+
+  test('should handle empty objects inside nested objects and arrays', () => {
+    assert.strictEqual(
+      fixJson(`{"type":"div","children":[{"type":"Card","props":{}`),
+      `{"type":"div","children":[{"type":"Card","props":{}}]}`,
+    );
+  });
+});