@ai-sdk/provider-utils 4.0.5 → 4.0.6

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

@@ -0,0 +1,53 @@
+import { 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.
+ */
+export function addAdditionalPropertiesToJsonSchema(
+  jsonSchema: JSONSchema7,
+): JSONSchema7 {
+  if (
+    jsonSchema.type === 'object' ||
+    (Array.isArray(jsonSchema.type) && jsonSchema.type.includes('object'))
+  ) {
+    jsonSchema.additionalProperties = false;
+    const { properties } = jsonSchema;
+    if (properties != null) {
+      for (const key of Object.keys(properties)) {
+        properties[key] = visit(properties[key]);
+      }
+    }
+  }
+
+  if (jsonSchema.items != null) {
+    jsonSchema.items = Array.isArray(jsonSchema.items)
+      ? jsonSchema.items.map(visit)
+      : visit(jsonSchema.items);
+  }
+
+  if (jsonSchema.anyOf != null) {
+    jsonSchema.anyOf = jsonSchema.anyOf.map(visit);
+  }
+
+  if (jsonSchema.allOf != null) {
+    jsonSchema.allOf = jsonSchema.allOf.map(visit);
+  }
+
+  if (jsonSchema.oneOf != null) {
+    jsonSchema.oneOf = jsonSchema.oneOf.map(visit);
+  }
+
+  const { definitions } = jsonSchema;
+  if (definitions != null) {
+    for (const key of Object.keys(definitions)) {
+      definitions[key] = visit(definitions[key]);
+    }
+  }
+
+  return jsonSchema;
+}
+
+function visit(def: JSONSchema7Definition): JSONSchema7Definition {
+  if (typeof def === 'boolean') return def;
+  return addAdditionalPropertiesToJsonSchema(def);
+}

package/src/combine-headers.ts

@@ -0,0 +1,11 @@
+export function combineHeaders(
+  ...headers: Array<Record<string, string | undefined> | undefined>
+): Record<string, string | undefined> {
+  return headers.reduce(
+    (combinedHeaders, currentHeaders) => ({
+      ...combinedHeaders,
+      ...(currentHeaders ?? {}),
+    }),
+    {},
+  ) as Record<string, string | undefined>;
+}

package/src/convert-async-iterator-to-readable-stream.test.ts

@@ -0,0 +1,78 @@
+import { convertAsyncIteratorToReadableStream } from './convert-async-iterator-to-readable-stream';
+import { describe, it, expect } from 'vitest';
+
+async function* makeGenerator(onFinally: () => void) {
+  try {
+    let i = 0;
+    while (true) {
+      await new Promise(r => setTimeout(r, 0));
+      yield i++;
+    }
+  } finally {
+    onFinally();
+  }
+}
+
+describe('convertAsyncIteratorToReadableStream', () => {
+  it('calls iterator.return() on cancel and triggers finally', async () => {
+    let finallyCalled = false;
+    const it = makeGenerator(() => {
+      finallyCalled = true;
+    });
+    const stream = convertAsyncIteratorToReadableStream(it);
+    const reader = stream.getReader();
+
+    await reader.read();
+
+    await reader.cancel('stop');
+
+    // give microtasks a tick for finally to run
+    await new Promise(r => setTimeout(r, 0));
+
+    expect(finallyCalled).toBe(true);
+  });
+
+  it('does not enqueue further values after cancel', async () => {
+    const it = makeGenerator(() => {});
+    const stream = convertAsyncIteratorToReadableStream(it);
+    const reader = stream.getReader();
+
+    await reader.read();
+    await reader.cancel('stop');
+
+    const { done, value } = await reader.read();
+    expect(done).toBe(true);
+    expect(value).toBeUndefined();
+  });
+
+  it('works with iterator without return() method', async () => {
+    const it: AsyncIterator<number> = {
+      async next() {
+        return { value: 42, done: false };
+      },
+    };
+    const stream = convertAsyncIteratorToReadableStream(it);
+    const reader = stream.getReader();
+
+    const { value } = await reader.read();
+    expect(value).toBe(42);
+
+    await expect(reader.cancel()).resolves.toBeUndefined();
+  });
+
+  it('ignores errors from iterator.return()', async () => {
+    const it: AsyncIterator<number> = {
+      async next() {
+        return { value: 1, done: false };
+      },
+      async return() {
+        throw new Error('return() failed');
+      },
+    };
+    const stream = convertAsyncIteratorToReadableStream(it);
+    const reader = stream.getReader();
+
+    await reader.read();
+    await expect(reader.cancel()).resolves.toBeUndefined();
+  });
+});

package/src/convert-async-iterator-to-readable-stream.ts

@@ -0,0 +1,47 @@
+/**
+ * Converts an AsyncIterator to a ReadableStream.
+ *
+ * @template T - The type of elements produced by the AsyncIterator.
+ * @param { <T>} iterator - The AsyncIterator to convert.
+ * @returns {ReadableStream<T>} - A ReadableStream that provides the same data as the AsyncIterator.
+ */
+export function convertAsyncIteratorToReadableStream<T>(
+  iterator: AsyncIterator<T>,
+): ReadableStream<T> {
+  let cancelled = false;
+
+  return new ReadableStream<T>({
+    /**
+     * Called when the consumer wants to pull more data from the stream.
+     *
+     * @param {ReadableStreamDefaultController<T>} controller - The controller to enqueue data into the stream.
+     * @returns {Promise<void>}
+     */
+    async pull(controller) {
+      if (cancelled) return;
+      try {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    /**
+     * Called when the consumer cancels the stream.
+     */
+    async cancel(reason?: unknown) {
+      cancelled = true;
+      if (iterator.return) {
+        try {
+          await iterator.return(reason);
+        } catch {
+          // intentionally ignore errors during cancellation
+        }
+      }
+    },
+  });
+}

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

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import { convertImageModelFileToDataUri } from './convert-image-model-file-to-data-uri';
+
+describe('convertImageModelFileToDataUri()', () => {
+  describe('URL files', () => {
+    it('should return the URL as-is for URL type files', () => {
+      const result = convertImageModelFileToDataUri({
+        type: 'url',
+        url: 'https://example.com/image.png',
+      });
+
+      expect(result).toBe('https://example.com/image.png');
+    });
+
+    it('should handle URLs with query parameters', () => {
+      const result = convertImageModelFileToDataUri({
+        type: 'url',
+        url: 'https://example.com/image.png?width=100&height=200',
+      });
+
+      expect(result).toBe('https://example.com/image.png?width=100&height=200');
+    });
+  });
+
+  describe('base64 string files', () => {
+    it('should return a data URI for base64 string data', () => {
+      const result = convertImageModelFileToDataUri({
+        type: 'file',
+        mediaType: 'image/png',
+        data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+      });
+
+      expect(result).toBe(
+        'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+      );
+    });
+
+    it('should handle different media types', () => {
+      const result = convertImageModelFileToDataUri({
+        type: 'file',
+        mediaType: 'image/jpeg',
+        data: 'base64data',
+      });
+
+      expect(result).toBe('data:image/jpeg;base64,base64data');
+    });
+  });
+
+  describe('Uint8Array files', () => {
+    it('should convert Uint8Array to base64 and return a data URI', () => {
+      // "Hello" in bytes
+      const data = new Uint8Array([72, 101, 108, 108, 111]);
+
+      const result = convertImageModelFileToDataUri({
+        type: 'file',
+        mediaType: 'image/png',
+        data,
+      });
+
+      expect(result).toBe('data:image/png;base64,SGVsbG8=');
+    });
+
+    it('should handle empty Uint8Array', () => {
+      const result = convertImageModelFileToDataUri({
+        type: 'file',
+        mediaType: 'image/png',
+        data: new Uint8Array([]),
+      });
+
+      expect(result).toBe('data:image/png;base64,');
+    });
+
+    it('should handle different media types with Uint8Array', () => {
+      const data = new Uint8Array([72, 101, 108, 108, 111]);
+
+      const result = convertImageModelFileToDataUri({
+        type: 'file',
+        mediaType: 'image/webp',
+        data,
+      });
+
+      expect(result).toBe('data:image/webp;base64,SGVsbG8=');
+    });
+  });
+});

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

@@ -0,0 +1,19 @@
+import { ImageModelV3File } from '@ai-sdk/provider';
+import { convertUint8ArrayToBase64 } from './uint8-utils';
+
+/**
+ * Convert an ImageModelV3File 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 {
+  if (file.type === 'url') return file.url;
+
+  return `data:${file.mediaType};base64,${
+    typeof file.data === 'string'
+      ? file.data
+      : convertUint8ArrayToBase64(file.data)
+  }`;
+}

package/src/convert-to-form-data.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect } from 'vitest';
+import { convertToFormData } from './convert-to-form-data';
+
+describe('convertToFormData()', () => {
+  describe('basic values', () => {
+    it('should add string values to form data', () => {
+      const formData = convertToFormData({
+        model: 'gpt-image-1',
+        prompt: 'A cute cat',
+      });
+
+      expect(formData.get('model')).toBe('gpt-image-1');
+      expect(formData.get('prompt')).toBe('A cute cat');
+    });
+
+    it('should add number values as strings', () => {
+      const formData = convertToFormData({
+        n: 2,
+        seed: 42,
+      });
+
+      expect(formData.get('n')).toBe('2');
+      expect(formData.get('seed')).toBe('42');
+    });
+
+    it('should add Blob values to form data', () => {
+      const blob = new Blob(['test'], { type: 'image/png' });
+      const formData = convertToFormData({
+        image: blob,
+      });
+
+      expect(formData.get('image')).toBeInstanceOf(Blob);
+    });
+  });
+
+  describe('null and undefined values', () => {
+    it('should skip null values', () => {
+      const formData = convertToFormData({
+        model: 'gpt-image-1',
+        mask: null,
+      });
+
+      expect(formData.get('model')).toBe('gpt-image-1');
+      expect(formData.has('mask')).toBe(false);
+    });
+
+    it('should skip undefined values', () => {
+      const formData = convertToFormData({
+        model: 'gpt-image-1',
+        size: undefined,
+      });
+
+      expect(formData.get('model')).toBe('gpt-image-1');
+      expect(formData.has('size')).toBe(false);
+    });
+  });
+
+  describe('array values', () => {
+    it('should add single-element arrays as single value without [] suffix', () => {
+      const blob = new Blob(['test'], { type: 'image/png' });
+      const formData = convertToFormData({
+        image: [blob],
+      });
+
+      expect(formData.get('image')).toBeInstanceOf(Blob);
+      expect(formData.has('image[]')).toBe(false);
+    });
+
+    it('should add multi-element arrays with [] suffix', () => {
+      const blob1 = new Blob(['test1'], { type: 'image/png' });
+      const blob2 = new Blob(['test2'], { type: 'image/jpeg' });
+      const formData = convertToFormData({
+        image: [blob1, blob2],
+      });
+
+      expect(formData.has('image')).toBe(false);
+      const images = formData.getAll('image[]');
+      expect(images).toHaveLength(2);
+      expect(images[0]).toBeInstanceOf(Blob);
+      expect(images[1]).toBeInstanceOf(Blob);
+    });
+
+    it('should add multi-element arrays without [] suffix when useArrayBrackets is false', () => {
+      const blob1 = new Blob(['test1'], { type: 'image/png' });
+      const blob2 = new Blob(['test2'], { type: 'image/jpeg' });
+      const formData = convertToFormData(
+        {
+          image: [blob1, blob2],
+        },
+        { useArrayBrackets: false },
+      );
+
+      expect(formData.has('image[]')).toBe(false);
+      const images = formData.getAll('image');
+      expect(images).toHaveLength(2);
+      expect(images[0]).toBeInstanceOf(Blob);
+      expect(images[1]).toBeInstanceOf(Blob);
+    });
+
+    it('should handle empty arrays by not adding any values', () => {
+      const formData = convertToFormData({
+        model: 'test',
+        images: [],
+      });
+
+      expect(formData.get('model')).toBe('test');
+      expect(formData.has('images')).toBe(false);
+      expect(formData.has('images[]')).toBe(false);
+    });
+
+    it('should add string arrays with [] suffix', () => {
+      const formData = convertToFormData({
+        tags: ['cat', 'cute', 'animal'],
+      });
+
+      const tags = formData.getAll('tags[]');
+      expect(tags).toHaveLength(3);
+      expect(tags).toEqual(['cat', 'cute', 'animal']);
+    });
+  });
+
+  describe('type validation', () => {
+    it('should accept typed input objects', () => {
+      type ImageInput = {
+        model: string;
+        prompt: string;
+        n: number;
+        size: `${number}x${number}` | undefined;
+      };
+
+      const formData = convertToFormData<ImageInput>({
+        model: 'dall-e-3',
+        prompt: 'A sunset',
+        n: 1,
+        size: '1024x1024',
+      });
+
+      expect(formData.get('model')).toBe('dall-e-3');
+      expect(formData.get('prompt')).toBe('A sunset');
+      expect(formData.get('n')).toBe('1');
+      expect(formData.get('size')).toBe('1024x1024');
+    });
+  });
+
+  describe('mixed values', () => {
+    it('should handle a complex input with various types', () => {
+      const blob = new Blob(['image data'], { type: 'image/png' });
+      const formData = convertToFormData({
+        model: 'gpt-image-1',
+        prompt: 'Edit this image',
+        image: [blob],
+        mask: null,
+        n: 1,
+        size: '1024x1024',
+        quality: 'high',
+      });
+
+      expect(formData.get('model')).toBe('gpt-image-1');
+      expect(formData.get('prompt')).toBe('Edit this image');
+      expect(formData.get('image')).toBeInstanceOf(Blob);
+      expect(formData.has('mask')).toBe(false);
+      expect(formData.get('n')).toBe('1');
+      expect(formData.get('size')).toBe('1024x1024');
+      expect(formData.get('quality')).toBe('high');
+    });
+  });
+});

package/src/convert-to-form-data.ts

@@ -0,0 +1,61 @@
+/**
+ * Converts an input object to FormData for multipart/form-data requests.
+ *
+ * Handles the following cases:
+ * - `null` or `undefined` values are skipped
+ * - Arrays with a single element are appended as a single value
+ * - Arrays with multiple elements are appended with `[]` suffix (e.g., `image[]`)
+ *   unless `useArrayBrackets` is set to `false`
+ * - All other values are appended directly
+ *
+ * @param input - The input object to convert. Use a generic type for type validation.
+ * @param options - Optional configuration object.
+ * @param options.useArrayBrackets - Whether to add `[]` suffix for multi-element arrays.
+ *   Defaults to `true`. Set to `false` for APIs that expect repeated keys without brackets.
+ * @returns A FormData object containing the input values.
+ *
+ * @example
+ * ```ts
+ * type MyInput = {
+ *   model: string;
+ *   prompt: string;
+ *   images: Blob[];
+ * };
+ *
+ * const formData = convertToFormData<MyInput>({
+ *   model: 'gpt-image-1',
+ *   prompt: 'A cat',
+ *   images: [blob1, blob2],
+ * });
+ * ```
+ */
+export function convertToFormData<T extends Record<string, unknown>>(
+  input: T,
+  options: { useArrayBrackets?: boolean } = {},
+): FormData {
+  const { useArrayBrackets = true } = options;
+  const formData = new FormData();
+
+  for (const [key, value] of Object.entries(input)) {
+    if (value == null) {
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      if (value.length === 1) {
+        formData.append(key, value[0] as string | Blob);
+        continue;
+      }
+
+      const arrayKey = useArrayBrackets ? `${key}[]` : key;
+      for (const item of value) {
+        formData.append(arrayKey, item as string | Blob);
+      }
+      continue;
+    }
+
+    formData.append(key, value as string | Blob);
+  }
+
+  return formData;
+}

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

@@ -0,0 +1,163 @@
+import {
+  LanguageModelV3FunctionTool,
+  LanguageModelV3ProviderTool,
+} from '@ai-sdk/provider';
+import { describe, expect, it } from 'vitest';
+import { createToolNameMapping } from './create-tool-name-mapping';
+
+describe('createToolNameMapping', () => {
+  it('should create mappings for provider-defined tools', () => {
+    const tools: Array<
+      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
+    > = [
+      {
+        type: 'provider',
+        id: 'anthropic.computer-use',
+        name: 'custom-computer-tool',
+        args: {},
+      },
+      {
+        type: 'provider',
+        id: 'openai.code-interpreter',
+        name: 'custom-code-tool',
+        args: {},
+      },
+    ];
+
+    const providerToolNames: Record<`${string}.${string}`, string> = {
+      'anthropic.computer-use': 'computer_use',
+      'openai.code-interpreter': 'code_interpreter',
+    };
+
+    const mapping = createToolNameMapping({ tools, providerToolNames });
+
+    expect(mapping.toProviderToolName('custom-computer-tool')).toBe(
+      'computer_use',
+    );
+    expect(mapping.toProviderToolName('custom-code-tool')).toBe(
+      'code_interpreter',
+    );
+    expect(mapping.toCustomToolName('computer_use')).toBe(
+      'custom-computer-tool',
+    );
+    expect(mapping.toCustomToolName('code_interpreter')).toBe(
+      'custom-code-tool',
+    );
+  });
+
+  it('should ignore function tools', () => {
+    const tools: Array<
+      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
+    > = [
+      {
+        type: 'function',
+        name: 'my-function-tool',
+        description: 'A function tool',
+        inputSchema: { type: 'object' },
+      },
+    ];
+
+    const providerToolNames: Record<`${string}.${string}`, string> = {};
+
+    const mapping = createToolNameMapping({ tools, providerToolNames });
+
+    expect(mapping.toProviderToolName('my-function-tool')).toBe(
+      'my-function-tool',
+    );
+    expect(mapping.toCustomToolName('my-function-tool')).toBe(
+      'my-function-tool',
+    );
+  });
+
+  it('should return input name when tool is not in providerToolNames', () => {
+    const tools: Array<
+      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
+    > = [
+      {
+        type: 'provider',
+        id: 'unknown.tool',
+        name: 'custom-tool',
+        args: {},
+      },
+    ];
+
+    const providerToolNames: Record<`${string}.${string}`, string> = {};
+
+    const mapping = createToolNameMapping({ tools, providerToolNames });
+
+    expect(mapping.toProviderToolName('custom-tool')).toBe('custom-tool');
+    expect(mapping.toCustomToolName('unknown-name')).toBe('unknown-name');
+  });
+
+  it('should return input name when mapping does not exist', () => {
+    const tools: Array<
+      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
+    > = [
+      {
+        type: 'provider',
+        id: 'anthropic.computer-use',
+        name: 'custom-computer-tool',
+        args: {},
+      },
+    ];
+
+    const providerToolNames: Record<`${string}.${string}`, string> = {
+      'anthropic.computer-use': 'computer_use',
+    };
+
+    const mapping = createToolNameMapping({ tools, providerToolNames });
+
+    expect(mapping.toProviderToolName('non-existent-tool')).toBe(
+      'non-existent-tool',
+    );
+    expect(mapping.toCustomToolName('non-existent-provider-tool')).toBe(
+      'non-existent-provider-tool',
+    );
+  });
+
+  it('should handle empty tools array', () => {
+    const tools: Array<
+      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
+    > = [];
+
+    const providerToolNames: Record<`${string}.${string}`, string> = {};
+
+    const mapping = createToolNameMapping({ tools, providerToolNames });
+
+    expect(mapping.toProviderToolName('any-tool')).toBe('any-tool');
+    expect(mapping.toCustomToolName('any-tool')).toBe('any-tool');
+  });
+
+  it('should handle mixed function and provider-defined tools', () => {
+    const tools: Array<
+      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
+    > = [
+      {
+        type: 'function',
+        name: 'function-tool',
+        description: 'A function tool',
+        inputSchema: { type: 'object' },
+      },
+      {
+        type: 'provider',
+        id: 'anthropic.computer-use',
+        name: 'provider-tool',
+        args: {},
+      },
+    ];
+
+    const providerToolNames: Record<`${string}.${string}`, string> = {
+      'anthropic.computer-use': 'computer_use',
+    };
+
+    const mapping = createToolNameMapping({ tools, providerToolNames });
+
+    // Function tool should not be mapped
+    expect(mapping.toProviderToolName('function-tool')).toBe('function-tool');
+    expect(mapping.toCustomToolName('function-tool')).toBe('function-tool');
+
+    // Provider-defined tool should be mapped
+    expect(mapping.toProviderToolName('provider-tool')).toBe('computer_use');
+    expect(mapping.toCustomToolName('computer_use')).toBe('provider-tool');
+  });
+});