@ai-sdk/elevenlabs 2.0.7 → 2.0.9

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/elevenlabs
 
+## 2.0.9
+
+### Patch Changes
+
+- 8dc54db: chore: add src folders to package bundle
+
+## 2.0.8
+
+### Patch Changes
+
+- Updated dependencies [5c090e7]
+  - @ai-sdk/provider@3.0.4
+  - @ai-sdk/provider-utils@4.0.8
+
 ## 2.0.7
 
 ### Patch Changes

package/dist/index.js

@@ -364,7 +364,7 @@ var ElevenLabsSpeechModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/elevenlabs-provider.ts
 function createElevenLabs(options = {}) {

package/dist/index.mjs

@@ -353,7 +353,7 @@ var ElevenLabsSpeechModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/elevenlabs-provider.ts
 function createElevenLabs(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/elevenlabs",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,6 +8,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "src",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -20,15 +21,15 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.3",
-    "@ai-sdk/provider-utils": "4.0.7"
+    "@ai-sdk/provider": "3.0.4",
+    "@ai-sdk/provider-utils": "4.0.8"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
     "tsup": "^8",
     "typescript": "5.6.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "1.0.1",
+    "@ai-sdk/test-server": "1.0.2",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/src/elevenlabs-api-types.ts

@@ -0,0 +1,100 @@
+export type ElevenLabsTranscriptionAPITypes = {
+  /**
+   * An ISO-639-1 or ISO-639-3 language_code corresponding to the language of the audio file.
+   * Can sometimes improve transcription performance if known beforehand.
+   * Defaults to null, in this case the language is predicted automatically.
+   */
+  language_code?: string;
+
+  /**
+   * Whether to tag audio events like (laughter), (footsteps), etc. in the transcription.
+   * @default true
+   */
+  tag_audio_events?: boolean;
+
+  /**
+   * The maximum amount of speakers talking in the uploaded file.
+   * Can help with predicting who speaks when.
+   * The maximum amount of speakers that can be predicted is 32.
+   * Defaults to null, in this case the amount of speakers is set to the maximum value the model supports.
+   * @min 1
+   * @max 32
+   */
+  num_speakers?: number;
+
+  /**
+   * The granularity of the timestamps in the transcription.
+   * 'word' provides word-level timestamps and 'character' provides character-level timestamps per word.
+   * @default 'word'
+   */
+  timestamps_granularity?: 'none' | 'word' | 'character';
+
+  /**
+   * Whether to annotate which speaker is currently talking in the uploaded file.
+   * @default false
+   */
+  diarize?: boolean;
+
+  /**
+   * A list of additional formats to export the transcript to.
+   */
+  additional_formats?: Array<
+    | {
+        format: 'docx';
+        include_speakers?: boolean;
+        include_timestamps?: boolean;
+        max_segment_chars?: number;
+        max_segment_duration_s?: number;
+        segment_on_silence_longer_than_s?: number;
+      }
+    | {
+        format: 'html';
+        include_speakers?: boolean;
+        include_timestamps?: boolean;
+        max_segment_chars?: number;
+        max_segment_duration_s?: number;
+        segment_on_silence_longer_than_s?: number;
+      }
+    | {
+        format: 'pdf';
+        include_speakers?: boolean;
+        include_timestamps?: boolean;
+        max_segment_chars?: number;
+        max_segment_duration_s?: number;
+        segment_on_silence_longer_than_s?: number;
+      }
+    | {
+        format: 'segmented_json';
+        max_segment_chars?: number;
+        max_segment_duration_s?: number;
+        segment_on_silence_longer_than_s?: number;
+      }
+    | {
+        format: 'srt';
+        include_speakers?: boolean;
+        include_timestamps?: boolean;
+        max_characters_per_line?: number;
+        max_segment_chars?: number;
+        max_segment_duration_s?: number;
+        segment_on_silence_longer_than_s?: number;
+      }
+    | {
+        format: 'txt';
+        include_speakers?: boolean;
+        include_timestamps?: boolean;
+        max_characters_per_line?: number;
+        max_segment_chars?: number;
+        max_segment_duration_s?: number;
+        segment_on_silence_longer_than_s?: number;
+      }
+  >;
+
+  /**
+   * The format of input audio.
+   * For pcm_s16le_16, the input audio must be 16-bit PCM at a 16kHz sample rate,
+   * single channel (mono), and little-endian byte order.
+   * Latency will be lower than with passing an encoded waveform.
+   * @default 'other'
+   */
+  file_format?: 'pcm_s16le_16' | 'other';
+};

package/src/elevenlabs-config.ts

@@ -0,0 +1,9 @@
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+export type ElevenLabsConfig = {
+  provider: string;
+  url: (options: { modelId: string; path: string }) => string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  generateId?: () => string;
+};

package/src/elevenlabs-error.test.ts

@@ -0,0 +1,34 @@
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { elevenlabsErrorDataSchema } from './elevenlabs-error';
+import { describe, it, expect } from 'vitest';
+
+describe('elevenlabsErrorDataSchema', () => {
+  it('should parse ElevenLabs resource exhausted error', async () => {
+    const error = `
+{"error":{"message":"{\\n  \\"error\\": {\\n    \\"code\\": 429,\\n    \\"message\\": \\"Resource has been exhausted (e.g. check quota).\\",\\n    \\"status\\": \\"RESOURCE_EXHAUSTED\\"\\n  }\\n}\\n","code":429}}
+`;
+
+    const result = await safeParseJSON({
+      text: error,
+      schema: elevenlabsErrorDataSchema,
+    });
+
+    expect(result).toStrictEqual({
+      success: true,
+      value: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+      rawValue: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+    });
+  });
+});

package/src/elevenlabs-error.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod/v4';
+import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+
+export const elevenlabsErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    code: z.number(),
+  }),
+});
+
+export type ElevenLabsErrorData = z.infer<typeof elevenlabsErrorDataSchema>;
+
+export const elevenlabsFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: elevenlabsErrorDataSchema,
+  errorToMessage: data => data.error.message,
+});

package/src/elevenlabs-provider.ts

@@ -0,0 +1,138 @@
+import {
+  TranscriptionModelV3,
+  SpeechModelV3,
+  ProviderV3,
+  NoSuchModelError,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { ElevenLabsTranscriptionModel } from './elevenlabs-transcription-model';
+import { ElevenLabsTranscriptionModelId } from './elevenlabs-transcription-options';
+import { ElevenLabsSpeechModel } from './elevenlabs-speech-model';
+import { ElevenLabsSpeechModelId } from './elevenlabs-speech-options';
+import { VERSION } from './version';
+
+export interface ElevenLabsProvider extends ProviderV3 {
+  (
+    modelId: 'scribe_v1',
+    settings?: {},
+  ): {
+    transcription: ElevenLabsTranscriptionModel;
+  };
+
+  /**
+Creates a model for transcription.
+   */
+  transcription(modelId: ElevenLabsTranscriptionModelId): TranscriptionModelV3;
+
+  /**
+Creates a model for speech generation.
+   */
+  speech(modelId: ElevenLabsSpeechModelId): SpeechModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+export interface ElevenLabsProviderSettings {
+  /**
+API key for authenticating requests.
+     */
+  apiKey?: string;
+
+  /**
+Custom headers to include in the requests.
+     */
+  headers?: Record<string, string>;
+
+  /**
+Custom fetch implementation. You can use it as a middleware to intercept requests,
+or to provide a custom fetch implementation for e.g. testing.
+    */
+  fetch?: FetchFunction;
+}
+
+/**
+Create an ElevenLabs provider instance.
+ */
+export function createElevenLabs(
+  options: ElevenLabsProviderSettings = {},
+): ElevenLabsProvider {
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        'xi-api-key': loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'ELEVENLABS_API_KEY',
+          description: 'ElevenLabs',
+        }),
+        ...options.headers,
+      },
+      `ai-sdk/elevenlabs/${VERSION}`,
+    );
+
+  const createTranscriptionModel = (modelId: ElevenLabsTranscriptionModelId) =>
+    new ElevenLabsTranscriptionModel(modelId, {
+      provider: `elevenlabs.transcription`,
+      url: ({ path }) => `https://api.elevenlabs.io${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const createSpeechModel = (modelId: ElevenLabsSpeechModelId) =>
+    new ElevenLabsSpeechModel(modelId, {
+      provider: `elevenlabs.speech`,
+      url: ({ path }) => `https://api.elevenlabs.io${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = function (modelId: ElevenLabsTranscriptionModelId) {
+    return {
+      transcription: createTranscriptionModel(modelId),
+    };
+  };
+
+  provider.specificationVersion = 'v3' as const;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
+
+  provider.languageModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'languageModel',
+      message: 'ElevenLabs does not provide language models',
+    });
+  };
+
+  provider.embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'embeddingModel',
+      message: 'ElevenLabs does not provide embedding models',
+    });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'imageModel',
+      message: 'ElevenLabs does not provide image models',
+    });
+  };
+
+  return provider as ElevenLabsProvider;
+}
+
+/**
+Default ElevenLabs provider instance.
+ */
+export const elevenlabs = createElevenLabs();

package/src/elevenlabs-speech-api-types.ts

@@ -0,0 +1,23 @@
+export type ElevenLabsSpeechAPITypes = {
+  text: string;
+  model_id?: string;
+  language_code?: string;
+  voice_settings?: {
+    stability?: number;
+    similarity_boost?: number;
+    style?: number;
+    use_speaker_boost?: boolean;
+    speed?: number;
+  };
+  pronunciation_dictionary_locators?: Array<{
+    pronunciation_dictionary_id: string;
+    version_id?: string;
+  }>;
+  seed?: number;
+  previous_text?: string;
+  next_text?: string;
+  previous_request_ids?: string[];
+  next_request_ids?: string[];
+  apply_text_normalization?: 'auto' | 'on' | 'off';
+  apply_language_text_normalization?: boolean;
+};

package/src/elevenlabs-speech-model.test.ts

@@ -0,0 +1,179 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { describe, expect, it, vi } from 'vitest';
+import { createElevenLabs } from './elevenlabs-provider';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const provider = createElevenLabs({ apiKey: 'test-api-key' });
+const model = provider.speech('eleven_multilingual_v2');
+
+const server = createTestServer({
+  'https://api.elevenlabs.io/v1/text-to-speech/*': {},
+});
+
+describe('ElevenLabsSpeechModel', () => {
+  function prepareAudioResponse({
+    headers,
+    format = 'mp3',
+  }: {
+    headers?: Record<string, string>;
+    format?: string;
+  } = {}) {
+    const audioBuffer = new Uint8Array(100); // Mock audio data
+    server.urls['https://api.elevenlabs.io/v1/text-to-speech/*'].response = {
+      type: 'binary',
+      headers: {
+        'content-type': `audio/${format}`,
+        ...headers,
+      },
+      body: Buffer.from(audioBuffer),
+    };
+    return audioBuffer;
+  }
+
+  describe('doGenerate', () => {
+    it('should generate speech with required parameters', async () => {
+      prepareAudioResponse();
+
+      await model.doGenerate({
+        text: 'Hello, world!',
+        voice: 'test-voice-id',
+      });
+
+      expect(await server.calls[0].requestBodyJson).toMatchObject({
+        text: 'Hello, world!',
+        model_id: 'eleven_multilingual_v2',
+      });
+
+      // Check output_format is in query params
+      expect(server.calls[0].requestUrl).toContain(
+        'output_format=mp3_44100_128',
+      );
+    });
+
+    it('should handle custom output format', async () => {
+      prepareAudioResponse();
+
+      await model.doGenerate({
+        text: 'Hello, world!',
+        voice: 'test-voice-id',
+        outputFormat: 'pcm_44100',
+      });
+
+      expect(await server.calls[0].requestBodyJson).toMatchObject({
+        text: 'Hello, world!',
+        model_id: 'eleven_multilingual_v2',
+      });
+
+      // Check output_format is in query params
+      expect(server.calls[0].requestUrl).toContain('output_format=pcm_44100');
+    });
+
+    it('should handle language parameter', async () => {
+      prepareAudioResponse();
+
+      await model.doGenerate({
+        text: 'Hola, mundo!',
+        voice: 'test-voice-id',
+        language: 'es',
+      });
+
+      expect(await server.calls[0].requestBodyJson).toMatchObject({
+        text: 'Hola, mundo!',
+        model_id: 'eleven_multilingual_v2',
+        language_code: 'es',
+      });
+
+      // Check output_format is in query params
+      expect(server.calls[0].requestUrl).toContain(
+        'output_format=mp3_44100_128',
+      );
+    });
+
+    it('should handle speed parameter in voice settings', async () => {
+      prepareAudioResponse();
+
+      await model.doGenerate({
+        text: 'Hello, world!',
+        voice: 'test-voice-id',
+        speed: 1.5,
+      });
+
+      expect(await server.calls[0].requestBodyJson).toMatchObject({
+        text: 'Hello, world!',
+        model_id: 'eleven_multilingual_v2',
+        voice_settings: {
+          speed: 1.5,
+        },
+      });
+    });
+
+    it('should warn about unsupported instructions parameter', async () => {
+      prepareAudioResponse();
+
+      const result = await model.doGenerate({
+        text: 'Hello, world!',
+        voice: 'test-voice-id',
+        instructions: 'Speak slowly',
+      });
+
+      expect(result.warnings).toMatchInlineSnapshot(`
+        [
+          {
+            "details": "ElevenLabs speech models do not support instructions. Instructions parameter was ignored.",
+            "feature": "instructions",
+            "type": "unsupported",
+          },
+        ]
+      `);
+    });
+
+    it('should pass provider-specific options', async () => {
+      prepareAudioResponse();
+
+      await model.doGenerate({
+        text: 'Hello, world!',
+        voice: 'test-voice-id',
+        providerOptions: {
+          elevenlabs: {
+            voiceSettings: {
+              stability: 0.5,
+              similarityBoost: 0.75,
+            },
+            seed: 123,
+          },
+        },
+      });
+
+      expect(await server.calls[0].requestBodyJson).toMatchObject({
+        text: 'Hello, world!',
+        model_id: 'eleven_multilingual_v2',
+        voice_settings: {
+          stability: 0.5,
+          similarity_boost: 0.75,
+        },
+        seed: 123,
+      });
+
+      // Check output_format is in query params
+      expect(server.calls[0].requestUrl).toContain(
+        'output_format=mp3_44100_128',
+      );
+    });
+
+    it('should include user-agent header', async () => {
+      prepareAudioResponse();
+
+      await model.doGenerate({
+        text: 'Hello, world!',
+        voice: 'test-voice-id',
+      });
+
+      expect(server.calls[0].requestUserAgent).toContain(
+        `ai-sdk/elevenlabs/0.0.0-test`,
+      );
+    });
+  });
+});