@ai-sdk/deepgram 2.0.7 → 2.0.9

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/deepgram
 
+## 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

@@ -593,7 +593,7 @@ var DeepgramSpeechModel = 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/deepgram-provider.ts
 function createDeepgram(options = {}) {

package/dist/index.mjs

@@ -579,7 +579,7 @@ var DeepgramSpeechModel = 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/deepgram-provider.ts
 function createDeepgram(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/deepgram",
-  "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/deepgram-api-types.ts

@@ -0,0 +1,36 @@
+export type DeepgramTranscriptionAPITypes = {
+  // Base parameters
+  language?: string;
+  detect_language?: boolean;
+  model?: string;
+
+  // Formatting options
+  smart_format?: boolean;
+  punctuate?: boolean;
+  paragraphs?: boolean;
+
+  // Summarization and analysis
+  summarize?: 'v2' | false;
+  topics?: boolean;
+  intents?: boolean;
+  sentiment?: boolean;
+
+  // Entity detection
+  detect_entities?: boolean;
+
+  // Redaction options
+  redact?: string | string[];
+  replace?: string;
+
+  // Search and keywords
+  search?: string;
+  keyterm?: string;
+
+  // Speaker-related features
+  diarize?: boolean;
+  utterances?: boolean;
+  utt_split?: number;
+
+  // Miscellaneous
+  filler_words?: boolean;
+};

package/src/deepgram-config.ts

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

package/src/deepgram-error.test.ts

@@ -0,0 +1,34 @@
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { deepgramErrorDataSchema } from './deepgram-error';
+import { describe, expect, it } from 'vitest';
+
+describe('deepgramErrorDataSchema', () => {
+  it('should parse Deepgram 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: deepgramErrorDataSchema,
+    });
+
+    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/deepgram-error.ts

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

package/src/deepgram-provider.ts

@@ -0,0 +1,139 @@
+import {
+  TranscriptionModelV3,
+  SpeechModelV3,
+  ProviderV3,
+  NoSuchModelError,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { DeepgramTranscriptionModel } from './deepgram-transcription-model';
+import { DeepgramTranscriptionModelId } from './deepgram-transcription-options';
+import { DeepgramSpeechModel } from './deepgram-speech-model';
+import { DeepgramSpeechModelId } from './deepgram-speech-options';
+import { VERSION } from './version';
+
+export interface DeepgramProvider extends ProviderV3 {
+  (
+    modelId: 'nova-3',
+    settings?: {},
+  ): {
+    transcription: DeepgramTranscriptionModel;
+  };
+
+  /**
+Creates a model for transcription.
+   */
+  transcription(modelId: DeepgramTranscriptionModelId): TranscriptionModelV3;
+
+  /**
+Creates a model for speech generation.
+   */
+  speech(modelId: DeepgramSpeechModelId): SpeechModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+export interface DeepgramProviderSettings {
+  /**
+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 Deepgram provider instance.
+ */
+export function createDeepgram(
+  options: DeepgramProviderSettings = {},
+): DeepgramProvider {
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        authorization: `Token ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'DEEPGRAM_API_KEY',
+          description: 'Deepgram',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/deepgram/${VERSION}`,
+    );
+
+  const createTranscriptionModel = (modelId: DeepgramTranscriptionModelId) =>
+    new DeepgramTranscriptionModel(modelId, {
+      provider: `deepgram.transcription`,
+      url: ({ path }) => `https://api.deepgram.com${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const createSpeechModel = (modelId: DeepgramSpeechModelId) =>
+    new DeepgramSpeechModel(modelId, {
+      provider: `deepgram.speech`,
+      url: ({ path }) => `https://api.deepgram.com${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = function (modelId: DeepgramTranscriptionModelId) {
+    return {
+      transcription: createTranscriptionModel(modelId),
+    };
+  };
+
+  provider.specificationVersion = 'v3' as const;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
+
+  // Required ProviderV3 methods that are not supported
+  provider.languageModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'languageModel',
+      message: 'Deepgram does not provide language models',
+    });
+  };
+
+  provider.embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'embeddingModel',
+      message: 'Deepgram does not provide text embedding models',
+    });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'imageModel',
+      message: 'Deepgram does not provide image models',
+    });
+  };
+
+  return provider as DeepgramProvider;
+}
+
+/**
+Default Deepgram provider instance.
+ */
+export const deepgram = createDeepgram();

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

@@ -0,0 +1,15 @@
+export type DeepgramSpeechAPITypes = {
+  // Request body
+  text: string;
+
+  // Query parameters (these are set via query params, not body)
+  model?: string;
+  encoding?: string;
+  sample_rate?: number;
+  bit_rate?: number | string;
+  container?: string;
+  callback?: string;
+  callback_method?: 'POST' | 'PUT';
+  mip_opt_out?: boolean;
+  tag?: string | string[];
+};

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

@@ -0,0 +1,355 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { createDeepgram } from './deepgram-provider';
+import { DeepgramSpeechModel } from './deepgram-speech-model';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const provider = createDeepgram({ apiKey: 'test-api-key' });
+const model = provider.speech('aura-2-helena-en');
+
+const server = createTestServer({
+  'https://api.deepgram.com/v1/speak': {},
+});
+
+describe('doGenerate', () => {
+  function prepareAudioResponse({
+    headers,
+  }: {
+    headers?: Record<string, string>;
+  } = {}) {
+    const audioBuffer = new Uint8Array(100); // Mock audio data
+    server.urls['https://api.deepgram.com/v1/speak'].response = {
+      type: 'binary',
+      headers: {
+        'content-type': 'audio/mp3',
+        ...headers,
+      },
+      body: Buffer.from(audioBuffer),
+    };
+    return audioBuffer;
+  }
+
+  it('should pass the model and text', async () => {
+    prepareAudioResponse();
+
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+    });
+
+    expect(await server.calls[0].requestBodyJson).toMatchObject({
+      text: 'Hello, welcome to Deepgram!',
+    });
+
+    const url = new URL(server.calls[0].requestUrl);
+    expect(url.searchParams.get('model')).toBe('aura-2-helena-en');
+  });
+
+  it('should pass headers', async () => {
+    prepareAudioResponse();
+
+    const provider = createDeepgram({
+      apiKey: 'test-api-key',
+      headers: {
+        'Custom-Provider-Header': 'provider-header-value',
+      },
+    });
+
+    await provider.speech('aura-2-helena-en').doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      headers: {
+        'Custom-Request-Header': 'request-header-value',
+      },
+    });
+
+    expect(server.calls[0].requestHeaders).toMatchObject({
+      authorization: 'Token test-api-key',
+      'content-type': 'application/json',
+      'custom-provider-header': 'provider-header-value',
+      'custom-request-header': 'request-header-value',
+    });
+
+    expect(server.calls[0].requestUserAgent).toContain(
+      `ai-sdk/deepgram/0.0.0-test`,
+    );
+  });
+
+  it('should pass query parameters for model', async () => {
+    prepareAudioResponse();
+
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+    });
+
+    const url = new URL(server.calls[0].requestUrl);
+    expect(url.searchParams.get('model')).toBe('aura-2-helena-en');
+  });
+
+  it('should map outputFormat to encoding/container', async () => {
+    prepareAudioResponse();
+
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      outputFormat: 'wav',
+    });
+
+    const url = new URL(server.calls[0].requestUrl);
+    expect(url.searchParams.get('container')).toBe('wav');
+    expect(url.searchParams.get('encoding')).toBe('linear16');
+  });
+
+  it('should pass provider options', async () => {
+    prepareAudioResponse();
+
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      providerOptions: {
+        deepgram: {
+          encoding: 'mp3',
+          bitRate: 48000,
+          container: 'wav',
+          callback: 'https://example.com/callback',
+          callbackMethod: 'POST',
+          mipOptOut: true,
+          tag: 'test-tag',
+        },
+      },
+    });
+
+    const url = new URL(server.calls[0].requestUrl);
+    expect(url.searchParams.get('encoding')).toBe('mp3');
+    expect(url.searchParams.get('bit_rate')).toBe('48000');
+    // mp3 doesn't support container, so it should be removed
+    expect(url.searchParams.get('container')).toBeNull();
+    expect(url.searchParams.get('callback')).toBe(
+      'https://example.com/callback',
+    );
+    expect(url.searchParams.get('callback_method')).toBe('POST');
+    expect(url.searchParams.get('mip_opt_out')).toBe('true');
+    expect(url.searchParams.get('tag')).toBe('test-tag');
+  });
+
+  it('should handle array tag', async () => {
+    prepareAudioResponse();
+
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      providerOptions: {
+        deepgram: {
+          tag: ['tag1', 'tag2'],
+        },
+      },
+    });
+
+    const url = new URL(server.calls[0].requestUrl);
+    expect(url.searchParams.get('tag')).toBe('tag1,tag2');
+  });
+
+  it('should return audio data', async () => {
+    const audio = new Uint8Array(100); // Mock audio data
+    prepareAudioResponse({
+      headers: {
+        'x-request-id': 'test-request-id',
+      },
+    });
+
+    const result = await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+    });
+
+    expect(result.audio).toStrictEqual(audio);
+  });
+
+  it('should include response data with timestamp, modelId and headers', async () => {
+    prepareAudioResponse({
+      headers: {
+        'x-request-id': 'test-request-id',
+      },
+    });
+
+    const testDate = new Date(0);
+    const customModel = new DeepgramSpeechModel('aura-2-helena-en', {
+      provider: 'test-provider',
+      url: () => 'https://api.deepgram.com/v1/speak',
+      headers: () => ({}),
+      _internal: {
+        currentDate: () => testDate,
+      },
+    });
+
+    const result = await customModel.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+    });
+
+    expect(result.response).toMatchObject({
+      timestamp: testDate,
+      modelId: 'aura-2-helena-en',
+      headers: {
+        'content-type': 'audio/mp3',
+        'x-request-id': 'test-request-id',
+      },
+    });
+  });
+
+  it('should warn about unsupported voice parameter', async () => {
+    prepareAudioResponse();
+
+    const result = await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      voice: 'different-voice',
+    });
+
+    expect(result.warnings).toMatchInlineSnapshot(`
+      [
+        {
+          "details": "Deepgram TTS models embed the voice in the model ID. The voice parameter "different-voice" was ignored. Use the model ID to select a voice (e.g., "aura-2-helena-en").",
+          "feature": "voice",
+          "type": "unsupported",
+        },
+      ]
+    `);
+  });
+
+  it('should warn about unsupported speed parameter', async () => {
+    prepareAudioResponse();
+
+    const result = await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      speed: 1.5,
+    });
+
+    expect(result.warnings).toMatchInlineSnapshot(`
+      [
+        {
+          "details": "Deepgram TTS REST API does not support speed adjustment. Speed parameter was ignored.",
+          "feature": "speed",
+          "type": "unsupported",
+        },
+      ]
+    `);
+  });
+
+  it('should warn about unsupported language parameter', async () => {
+    prepareAudioResponse();
+
+    const result = await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      language: 'en',
+    });
+
+    expect(result.warnings).toMatchInlineSnapshot(`
+      [
+        {
+          "details": "Deepgram TTS models are language-specific via the model ID. Language parameter "en" was ignored. Select a model with the appropriate language suffix (e.g., "-en" for English).",
+          "feature": "language",
+          "type": "unsupported",
+        },
+      ]
+    `);
+  });
+
+  it('should warn about unsupported instructions parameter', async () => {
+    prepareAudioResponse();
+
+    const result = await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      instructions: 'Speak slowly',
+    });
+
+    expect(result.warnings).toMatchInlineSnapshot(`
+      [
+        {
+          "details": "Deepgram TTS REST API does not support instructions. Instructions parameter was ignored.",
+          "feature": "instructions",
+          "type": "unsupported",
+        },
+      ]
+    `);
+  });
+
+  it('should include request body in response', async () => {
+    prepareAudioResponse();
+
+    const result = await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+    });
+
+    expect(result.request?.body).toBe(
+      JSON.stringify({ text: 'Hello, welcome to Deepgram!' }),
+    );
+  });
+
+  it('should clean up incompatible parameters when encoding changes via providerOptions', async () => {
+    prepareAudioResponse();
+
+    // Test case 1: outputFormat sets sample_rate, encoding changed to mp3 (fixed sample rate)
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      outputFormat: 'linear16_16000', // Sets: encoding=linear16, sample_rate=16000
+      providerOptions: {
+        deepgram: {
+          encoding: 'mp3', // Changes encoding to mp3
+        },
+      },
+    });
+
+    const url1 = new URL(server.calls[0].requestUrl);
+    expect(url1.searchParams.get('encoding')).toBe('mp3');
+    expect(url1.searchParams.get('sample_rate')).toBeNull(); // Should be removed
+
+    // Test case 2: outputFormat sets container for linear16, encoding changed to opus
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      outputFormat: 'linear16_16000', // Sets: encoding=linear16, container=wav
+      providerOptions: {
+        deepgram: {
+          encoding: 'opus', // Changes encoding to opus
+        },
+      },
+    });
+
+    const url2 = new URL(server.calls[1].requestUrl);
+    expect(url2.searchParams.get('encoding')).toBe('opus');
+    expect(url2.searchParams.get('container')).toBe('ogg'); // Should be ogg, not wav
+    expect(url2.searchParams.get('sample_rate')).toBeNull(); // Should be removed
+
+    // Test case 3: outputFormat sets bit_rate, encoding changed to linear16 (no bitrate support)
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      outputFormat: 'mp3', // Sets: encoding=mp3
+      providerOptions: {
+        deepgram: {
+          encoding: 'linear16', // Changes encoding to linear16
+          bitRate: 48000, // Try to set bitrate
+        },
+      },
+    });
+
+    const url3 = new URL(server.calls[2].requestUrl);
+    expect(url3.searchParams.get('encoding')).toBe('linear16');
+    expect(url3.searchParams.get('bit_rate')).toBeNull(); // Should be removed
+  });
+
+  it('should clean up incompatible parameters when container changes encoding implicitly', async () => {
+    prepareAudioResponse();
+
+    // Test case: outputFormat sets sample_rate, container changes encoding to opus
+    await model.doGenerate({
+      text: 'Hello, welcome to Deepgram!',
+      outputFormat: 'linear16_16000', // Sets: encoding=linear16, sample_rate=16000
+      providerOptions: {
+        deepgram: {
+          container: 'ogg', // Changes encoding to opus implicitly
+        },
+      },
+    });
+
+    const callIndex = server.calls.length - 1;
+    const url = new URL(server.calls[callIndex].requestUrl);
+    expect(url.searchParams.get('encoding')).toBe('opus');
+    expect(url.searchParams.get('container')).toBe('ogg');
+    expect(url.searchParams.get('sample_rate')).toBeNull(); // Should be removed (opus has fixed sample rate)
+  });
+});