ai 6.0.32 → 6.0.34

package/src/generate-object/validate-object-generation-input.ts

@@ -0,0 +1,144 @@
+import { FlexibleSchema } from '@ai-sdk/provider-utils';
+import { InvalidArgumentError } from '../error/invalid-argument-error';
+
+export function validateObjectGenerationInput({
+  output,
+  schema,
+  schemaName,
+  schemaDescription,
+  enumValues,
+}: {
+  output?: 'object' | 'array' | 'enum' | 'no-schema';
+  schema?: FlexibleSchema<unknown>;
+  schemaName?: string;
+  schemaDescription?: string;
+  enumValues?: Array<unknown>;
+}) {
+  if (
+    output != null &&
+    output !== 'object' &&
+    output !== 'array' &&
+    output !== 'enum' &&
+    output !== 'no-schema'
+  ) {
+    throw new InvalidArgumentError({
+      parameter: 'output',
+      value: output,
+      message: 'Invalid output type.',
+    });
+  }
+
+  if (output === 'no-schema') {
+    if (schema != null) {
+      throw new InvalidArgumentError({
+        parameter: 'schema',
+        value: schema,
+        message: 'Schema is not supported for no-schema output.',
+      });
+    }
+
+    if (schemaDescription != null) {
+      throw new InvalidArgumentError({
+        parameter: 'schemaDescription',
+        value: schemaDescription,
+        message: 'Schema description is not supported for no-schema output.',
+      });
+    }
+
+    if (schemaName != null) {
+      throw new InvalidArgumentError({
+        parameter: 'schemaName',
+        value: schemaName,
+        message: 'Schema name is not supported for no-schema output.',
+      });
+    }
+
+    if (enumValues != null) {
+      throw new InvalidArgumentError({
+        parameter: 'enumValues',
+        value: enumValues,
+        message: 'Enum values are not supported for no-schema output.',
+      });
+    }
+  }
+
+  if (output === 'object') {
+    if (schema == null) {
+      throw new InvalidArgumentError({
+        parameter: 'schema',
+        value: schema,
+        message: 'Schema is required for object output.',
+      });
+    }
+
+    if (enumValues != null) {
+      throw new InvalidArgumentError({
+        parameter: 'enumValues',
+        value: enumValues,
+        message: 'Enum values are not supported for object output.',
+      });
+    }
+  }
+
+  if (output === 'array') {
+    if (schema == null) {
+      throw new InvalidArgumentError({
+        parameter: 'schema',
+        value: schema,
+        message: 'Element schema is required for array output.',
+      });
+    }
+
+    if (enumValues != null) {
+      throw new InvalidArgumentError({
+        parameter: 'enumValues',
+        value: enumValues,
+        message: 'Enum values are not supported for array output.',
+      });
+    }
+  }
+
+  if (output === 'enum') {
+    if (schema != null) {
+      throw new InvalidArgumentError({
+        parameter: 'schema',
+        value: schema,
+        message: 'Schema is not supported for enum output.',
+      });
+    }
+
+    if (schemaDescription != null) {
+      throw new InvalidArgumentError({
+        parameter: 'schemaDescription',
+        value: schemaDescription,
+        message: 'Schema description is not supported for enum output.',
+      });
+    }
+
+    if (schemaName != null) {
+      throw new InvalidArgumentError({
+        parameter: 'schemaName',
+        value: schemaName,
+        message: 'Schema name is not supported for enum output.',
+      });
+    }
+
+    if (enumValues == null) {
+      throw new InvalidArgumentError({
+        parameter: 'enumValues',
+        value: enumValues,
+        message: 'Enum values are required for enum output.',
+      });
+    }
+
+    for (const value of enumValues) {
+      if (typeof value !== 'string') {
+        throw new InvalidArgumentError({
+          parameter: 'enumValues',
+          value,
+          message: 'Enum values must be strings.',
+        });
+      }
+    }
+  }
+}

package/src/generate-speech/generate-speech-result.ts

@@ -0,0 +1,30 @@
+import { JSONObject } from '@ai-sdk/provider';
+import { SpeechModelResponseMetadata } from '../types/speech-model-response-metadata';
+import { Warning } from '../types/warning';
+import { GeneratedAudioFile } from './generated-audio-file';
+
+/**
+The result of a `generateSpeech` call.
+It contains the audio data and additional information.
+ */
+export interface SpeechResult {
+  /**
+   * The audio data as a base64 encoded string or binary data.
+   */
+  readonly audio: GeneratedAudioFile;
+
+  /**
+  Warnings for the call, e.g. unsupported settings.
+     */
+  readonly warnings: Array<Warning>;
+
+  /**
+  Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+   */
+  readonly responses: Array<SpeechModelResponseMetadata>;
+
+  /**
+  Provider metadata from the provider.
+   */
+  readonly providerMetadata: Record<string, JSONObject>;
+}

package/src/generate-speech/generate-speech.test.ts

@@ -0,0 +1,300 @@
+import { JSONObject, SpeechModelV3 } from '@ai-sdk/provider';
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+  vitest,
+} from 'vitest';
+import * as logWarningsModule from '../logger/log-warnings';
+import { MockSpeechModelV3 } from '../test/mock-speech-model-v3';
+import { Warning } from '../types/warning';
+import { generateSpeech } from './generate-speech';
+import {
+  DefaultGeneratedAudioFile,
+  GeneratedAudioFile,
+} from './generated-audio-file';
+
+const audio = new Uint8Array([1, 2, 3, 4]); // Sample audio data
+const testDate = new Date(2024, 0, 1);
+const mockFile = new DefaultGeneratedAudioFile({
+  data: audio,
+  mediaType: 'audio/mp3',
+});
+
+const sampleText = 'This is a sample text to convert to speech.';
+
+vi.mock('../version', () => {
+  return {
+    VERSION: '0.0.0-test',
+  };
+});
+
+const createMockResponse = (options: {
+  audio: GeneratedAudioFile;
+  warnings?: Warning[];
+  timestamp?: Date;
+  modelId?: string;
+  headers?: Record<string, string>;
+  providerMetadata?: Record<string, JSONObject>;
+}) => ({
+  audio: options.audio.uint8Array,
+  warnings: options.warnings ?? [],
+  response: {
+    timestamp: options.timestamp ?? new Date(),
+    modelId: options.modelId ?? 'test-model-id',
+    headers: options.headers ?? {},
+  },
+  providerMetadata: options.providerMetadata ?? {},
+});
+
+describe('generateSpeech', () => {
+  let logWarningsSpy: ReturnType<typeof vitest.spyOn>;
+
+  beforeEach(() => {
+    logWarningsSpy = vitest
+      .spyOn(logWarningsModule, 'logWarnings')
+      .mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logWarningsSpy.mockRestore();
+  });
+
+  it('should send args to doGenerate', async () => {
+    const abortController = new AbortController();
+    const abortSignal = abortController.signal;
+
+    let capturedArgs!: Parameters<SpeechModelV3['doGenerate']>[0];
+
+    await generateSpeech({
+      model: new MockSpeechModelV3({
+        doGenerate: async args => {
+          capturedArgs = args;
+          return createMockResponse({
+            audio: mockFile,
+          });
+        },
+      }),
+      text: sampleText,
+      voice: 'test-voice',
+      headers: {
+        'custom-request-header': 'request-header-value',
+      },
+      abortSignal,
+    });
+
+    expect(capturedArgs).toStrictEqual({
+      text: sampleText,
+      voice: 'test-voice',
+      headers: {
+        'custom-request-header': 'request-header-value',
+        'user-agent': 'ai/0.0.0-test',
+      },
+      abortSignal,
+      providerOptions: {},
+      outputFormat: undefined,
+      instructions: undefined,
+      speed: undefined,
+      language: undefined,
+    });
+  });
+
+  it('should return warnings', async () => {
+    const result = await generateSpeech({
+      model: new MockSpeechModelV3({
+        doGenerate: async () =>
+          createMockResponse({
+            audio: mockFile,
+            warnings: [
+              {
+                type: 'other',
+                message: 'Setting is not supported',
+              },
+            ],
+            providerMetadata: {
+              'test-provider': {
+                'test-key': 'test-value',
+              },
+            },
+          }),
+      }),
+      text: sampleText,
+    });
+
+    expect(result.warnings).toStrictEqual([
+      {
+        type: 'other',
+        message: 'Setting is not supported',
+      },
+    ]);
+  });
+
+  it('should call logWarnings with the correct warnings', async () => {
+    const expectedWarnings: Warning[] = [
+      {
+        type: 'other',
+        message: 'Setting is not supported',
+      },
+      {
+        type: 'unsupported',
+        feature: 'voice',
+        details: 'Voice parameter not supported',
+      },
+    ];
+
+    await generateSpeech({
+      model: new MockSpeechModelV3({
+        doGenerate: async () =>
+          createMockResponse({
+            audio: mockFile,
+            warnings: expectedWarnings,
+          }),
+      }),
+      text: sampleText,
+    });
+
+    expect(logWarningsSpy).toHaveBeenCalledOnce();
+    expect(logWarningsSpy).toHaveBeenCalledWith({
+      warnings: expectedWarnings,
+      provider: 'mock-provider',
+      model: 'mock-model-id',
+    });
+  });
+
+  it('should call logWarnings with empty array when no warnings are present', async () => {
+    await generateSpeech({
+      model: new MockSpeechModelV3({
+        doGenerate: async () =>
+          createMockResponse({
+            audio: mockFile,
+            warnings: [], // no warnings
+          }),
+      }),
+      text: sampleText,
+    });
+
+    expect(logWarningsSpy).toHaveBeenCalledOnce();
+    expect(logWarningsSpy).toHaveBeenCalledWith({
+      warnings: [],
+      provider: 'mock-provider',
+      model: 'mock-model-id',
+    });
+  });
+
+  it('should return the audio data', async () => {
+    const result = await generateSpeech({
+      model: new MockSpeechModelV3({
+        doGenerate: async () =>
+          createMockResponse({
+            audio: mockFile,
+          }),
+      }),
+      text: sampleText,
+    });
+
+    expect(result).toEqual({
+      audio: mockFile,
+      warnings: [],
+      responses: [
+        {
+          timestamp: expect.any(Date),
+          modelId: 'test-model-id',
+          headers: {},
+        },
+      ],
+      providerMetadata: {},
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw NoSpeechGeneratedError when no audio is returned', async () => {
+      await expect(
+        generateSpeech({
+          model: new MockSpeechModelV3({
+            doGenerate: async () =>
+              createMockResponse({
+                audio: new DefaultGeneratedAudioFile({
+                  data: new Uint8Array(),
+                  mediaType: 'audio/mp3',
+                }),
+                timestamp: testDate,
+              }),
+          }),
+          text: sampleText,
+        }),
+      ).rejects.toMatchObject({
+        name: 'AI_NoSpeechGeneratedError',
+        message: 'No speech audio generated.',
+        responses: [
+          {
+            timestamp: testDate,
+            modelId: expect.any(String),
+          },
+        ],
+      });
+    });
+
+    it('should include response headers in error when no audio generated', async () => {
+      await expect(
+        generateSpeech({
+          model: new MockSpeechModelV3({
+            doGenerate: async () =>
+              createMockResponse({
+                audio: new DefaultGeneratedAudioFile({
+                  data: new Uint8Array(),
+                  mediaType: 'audio/mp3',
+                }),
+                timestamp: testDate,
+                headers: {
+                  'custom-response-header': 'response-header-value',
+                  'user-agent': 'ai/0.0.0-test',
+                },
+              }),
+          }),
+          text: sampleText,
+        }),
+      ).rejects.toMatchObject({
+        name: 'AI_NoSpeechGeneratedError',
+        message: 'No speech audio generated.',
+        responses: [
+          {
+            timestamp: testDate,
+            modelId: expect.any(String),
+            headers: {
+              'custom-response-header': 'response-header-value',
+              'user-agent': 'ai/0.0.0-test',
+            },
+          },
+        ],
+      });
+    });
+  });
+
+  it('should return response metadata', async () => {
+    const testHeaders = { 'x-test': 'value' };
+
+    const result = await generateSpeech({
+      model: new MockSpeechModelV3({
+        doGenerate: async () =>
+          createMockResponse({
+            audio: mockFile,
+            timestamp: testDate,
+            modelId: 'test-model',
+            headers: testHeaders,
+          }),
+      }),
+      text: sampleText,
+    });
+
+    expect(result.responses).toStrictEqual([
+      {
+        timestamp: testDate,
+        modelId: 'test-model',
+        headers: testHeaders,
+      },
+    ]);
+  });
+});

package/src/generate-speech/generate-speech.ts

@@ -0,0 +1,190 @@
+import { JSONObject } from '@ai-sdk/provider';
+import { ProviderOptions, withUserAgentSuffix } from '@ai-sdk/provider-utils';
+import { NoSpeechGeneratedError } from '../error/no-speech-generated-error';
+import { logWarnings } from '../logger/log-warnings';
+import { resolveSpeechModel } from '../model/resolve-model';
+import { SpeechModel } from '../types/speech-model';
+import { SpeechModelResponseMetadata } from '../types/speech-model-response-metadata';
+import { Warning } from '../types/warning';
+import {
+  audioMediaTypeSignatures,
+  detectMediaType,
+} from '../util/detect-media-type';
+import { prepareRetries } from '../util/prepare-retries';
+import { VERSION } from '../version';
+import { SpeechResult } from './generate-speech-result';
+import {
+  DefaultGeneratedAudioFile,
+  GeneratedAudioFile,
+} from './generated-audio-file';
+
+/**
+Generates speech audio using a speech model.
+
+@param model - The speech model to use.
+@param text - The text to convert to speech.
+@param voice - The voice to use for speech generation.
+@param outputFormat - The output format to use for speech generation e.g. "mp3", "wav", etc.
+@param instructions - Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+@param speed - The speed of the speech generation.
+@param providerOptions - Additional provider-specific options that are passed through to the provider
+as body parameters.
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@returns A result object that contains the generated audio data.
+ */
+export async function generateSpeech({
+  model,
+  text,
+  voice,
+  outputFormat,
+  instructions,
+  speed,
+  language,
+  providerOptions = {},
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+}: {
+  /**
+The speech model to use.
+     */
+  model: SpeechModel;
+
+  /**
+The text to convert to speech.
+   */
+  text: string;
+
+  /**
+The voice to use for speech generation.
+   */
+  voice?: string;
+
+  /**
+   * The desired output format for the audio e.g. "mp3", "wav", etc.
+   */
+  outputFormat?: 'mp3' | 'wav' | (string & {});
+
+  /**
+    Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+  */
+  instructions?: string;
+
+  /**
+  The speed of the speech generation.
+   */
+  speed?: number;
+
+  /**
+  The language for speech generation. This should be an ISO 639-1 language code (e.g. "en", "es", "fr")
+  or "auto" for automatic language detection. Provider support varies.
+   */
+  language?: string;
+
+  /**
+Additional provider-specific options that are passed through to the provider
+as body parameters.
+
+The outer record is keyed by the provider name, and the inner
+record is keyed by the provider-specific metadata key.
+```ts
+{
+  "openai": {}
+}
+```
+     */
+  providerOptions?: ProviderOptions;
+
+  /**
+Maximum number of retries per speech model call. Set to 0 to disable retries.
+
+@default 2
+   */
+  maxRetries?: number;
+
+  /**
+Abort signal.
+ */
+  abortSignal?: AbortSignal;
+
+  /**
+Additional headers to include in the request.
+Only applicable for HTTP-based providers.
+ */
+  headers?: Record<string, string>;
+}): Promise<SpeechResult> {
+  const resolvedModel = resolveSpeechModel(model);
+  if (!resolvedModel) {
+    throw new Error('Model could not be resolved');
+  }
+
+  const headersWithUserAgent = withUserAgentSuffix(
+    headers ?? {},
+    `ai/${VERSION}`,
+  );
+
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+  });
+
+  const result = await retry(() =>
+    resolvedModel.doGenerate({
+      text,
+      voice,
+      outputFormat,
+      instructions,
+      speed,
+      language,
+      abortSignal,
+      headers: headersWithUserAgent,
+      providerOptions,
+    }),
+  );
+
+  if (!result.audio || result.audio.length === 0) {
+    throw new NoSpeechGeneratedError({ responses: [result.response] });
+  }
+
+  logWarnings({
+    warnings: result.warnings,
+    provider: resolvedModel.provider,
+    model: resolvedModel.modelId,
+  });
+
+  return new DefaultSpeechResult({
+    audio: new DefaultGeneratedAudioFile({
+      data: result.audio,
+      mediaType:
+        detectMediaType({
+          data: result.audio,
+          signatures: audioMediaTypeSignatures,
+        }) ?? 'audio/mp3',
+    }),
+    warnings: result.warnings,
+    responses: [result.response],
+    providerMetadata: result.providerMetadata,
+  });
+}
+
+class DefaultSpeechResult implements SpeechResult {
+  readonly audio: GeneratedAudioFile;
+  readonly warnings: Array<Warning>;
+  readonly responses: Array<SpeechModelResponseMetadata>;
+  readonly providerMetadata: Record<string, JSONObject>;
+
+  constructor(options: {
+    audio: GeneratedAudioFile;
+    warnings: Array<Warning>;
+    responses: Array<SpeechModelResponseMetadata>;
+    providerMetadata: Record<string, JSONObject> | undefined;
+  }) {
+    this.audio = options.audio;
+    this.warnings = options.warnings;
+    this.responses = options.responses;
+    this.providerMetadata = options.providerMetadata ?? {};
+  }
+}