@ai-sdk/deepgram 2.0.0-beta.32 → 2.0.0-beta.34

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ai-sdk/deepgram
 
+## 2.0.0-beta.34
+
+### Patch Changes
+
+- f118108: feat(deepgram): add text-to-speech support
+
+  Add text-to-speech support for Deepgram Aura models via the REST API. Supports all Aura voice models (aura-2-helena-en, aura-2-thalia-en, etc.) with proper audio format validation, encoding/container/sample_rate/bitrate combinations, and comprehensive parameter validation.
+
+## 2.0.0-beta.33
+
+### Patch Changes
+
+- Updated dependencies [b681d7d]
+  - @ai-sdk/provider@3.0.0-beta.16
+  - @ai-sdk/provider-utils@4.0.0-beta.33
+
 ## 2.0.0-beta.32
 
 ### Patch Changes

package/README.md

@@ -1,7 +1,7 @@
 # AI SDK - Deepgram Provider
 
 The **[Deepgram provider](https://ai-sdk.dev/providers/ai-sdk-providers/deepgram)** for the [AI SDK](https://ai-sdk.dev/docs)
-contains transcription model support for the Deepgram transcription API.
+contains transcription model support for the Deepgram transcription API and speech model support for the Deepgram text-to-speech API.
 
 ## Setup
 
@@ -19,7 +19,9 @@ You can import the default provider instance `deepgram` from `@ai-sdk/deepgram`:
 import { deepgram } from '@ai-sdk/deepgram';
 ```
 
-## Example
+## Examples
+
+### Transcription
 
 ```ts
 import { deepgram } from '@ai-sdk/deepgram';
@@ -33,6 +35,18 @@ const { text } = await transcribe({
 });
 ```
 
+### Text-to-Speech
+
+```ts
+import { deepgram } from '@ai-sdk/deepgram';
+import { experimental_generateSpeech as generateSpeech } from 'ai';
+
+const { audio } = await generateSpeech({
+  model: deepgram.speech('aura-2-helena-en'),
+  text: 'Hello, welcome to Deepgram!',
+});
+```
+
 ## Documentation
 
 Please check out the **[Deepgram provider documentation](https://ai-sdk.dev/providers/ai-sdk-providers/deepgram)** for more information.

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { TranscriptionModelV3, ProviderV3 } from '@ai-sdk/provider';
+import { TranscriptionModelV3, ProviderV3, SpeechModelV3 } from '@ai-sdk/provider';
 import { FetchFunction } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
 
 type DeepgramConfig = {
     provider: string;
@@ -29,6 +30,8 @@ declare class DeepgramTranscriptionModel implements TranscriptionModelV3 {
     doGenerate(options: Parameters<TranscriptionModelV3['doGenerate']>[0]): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>>;
 }
 
+type DeepgramSpeechModelId = 'aura-asteria-en' | 'aura-2-asteria-en' | 'aura-2-thalia-en' | 'aura-2-helena-en' | 'aura-2-orpheus-en' | 'aura-2-zeus-en' | 'aura-luna-en' | 'aura-stella-en' | (string & {});
+
 interface DeepgramProvider extends ProviderV3 {
     (modelId: 'nova-3', settings?: {}): {
         transcription: DeepgramTranscriptionModel;
@@ -37,6 +40,10 @@ interface DeepgramProvider extends ProviderV3 {
   Creates a model for transcription.
      */
     transcription(modelId: DeepgramTranscriptionModelId): TranscriptionModelV3;
+    /**
+  Creates a model for speech generation.
+     */
+    speech(modelId: DeepgramSpeechModelId): SpeechModelV3;
 }
 interface DeepgramProviderSettings {
     /**
@@ -62,6 +69,35 @@ Default Deepgram provider instance.
  */
 declare const deepgram: DeepgramProvider;
 
+declare const deepgramSpeechProviderOptionsSchema: z.ZodObject<{
+    bitRate: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+    container: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    encoding: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sampleRate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    callback: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    callbackMethod: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        POST: "POST";
+        PUT: "PUT";
+    }>>>;
+    mipOptOut: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    tag: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+}, z.core.$strip>;
+type DeepgramSpeechCallOptions = z.infer<typeof deepgramSpeechProviderOptionsSchema>;
+interface DeepgramSpeechModelConfig extends DeepgramConfig {
+    _internal?: {
+        currentDate?: () => Date;
+    };
+}
+declare class DeepgramSpeechModel implements SpeechModelV3 {
+    readonly modelId: DeepgramSpeechModelId;
+    private readonly config;
+    readonly specificationVersion = "v3";
+    get provider(): string;
+    constructor(modelId: DeepgramSpeechModelId, config: DeepgramSpeechModelConfig);
+    private getArgs;
+    doGenerate(options: Parameters<SpeechModelV3['doGenerate']>[0]): Promise<Awaited<ReturnType<SpeechModelV3['doGenerate']>>>;
+}
+
 declare const VERSION: string;
 
-export { type DeepgramProvider, type DeepgramProviderSettings, VERSION, createDeepgram, deepgram };
+export { type DeepgramProvider, type DeepgramProviderSettings, type DeepgramSpeechCallOptions, DeepgramSpeechModel, type DeepgramSpeechModelId, VERSION, createDeepgram, deepgram };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { TranscriptionModelV3, ProviderV3 } from '@ai-sdk/provider';
+import { TranscriptionModelV3, ProviderV3, SpeechModelV3 } from '@ai-sdk/provider';
 import { FetchFunction } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
 
 type DeepgramConfig = {
     provider: string;
@@ -29,6 +30,8 @@ declare class DeepgramTranscriptionModel implements TranscriptionModelV3 {
     doGenerate(options: Parameters<TranscriptionModelV3['doGenerate']>[0]): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>>;
 }
 
+type DeepgramSpeechModelId = 'aura-asteria-en' | 'aura-2-asteria-en' | 'aura-2-thalia-en' | 'aura-2-helena-en' | 'aura-2-orpheus-en' | 'aura-2-zeus-en' | 'aura-luna-en' | 'aura-stella-en' | (string & {});
+
 interface DeepgramProvider extends ProviderV3 {
     (modelId: 'nova-3', settings?: {}): {
         transcription: DeepgramTranscriptionModel;
@@ -37,6 +40,10 @@ interface DeepgramProvider extends ProviderV3 {
   Creates a model for transcription.
      */
     transcription(modelId: DeepgramTranscriptionModelId): TranscriptionModelV3;
+    /**
+  Creates a model for speech generation.
+     */
+    speech(modelId: DeepgramSpeechModelId): SpeechModelV3;
 }
 interface DeepgramProviderSettings {
     /**
@@ -62,6 +69,35 @@ Default Deepgram provider instance.
  */
 declare const deepgram: DeepgramProvider;
 
+declare const deepgramSpeechProviderOptionsSchema: z.ZodObject<{
+    bitRate: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+    container: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    encoding: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sampleRate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    callback: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    callbackMethod: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        POST: "POST";
+        PUT: "PUT";
+    }>>>;
+    mipOptOut: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    tag: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+}, z.core.$strip>;
+type DeepgramSpeechCallOptions = z.infer<typeof deepgramSpeechProviderOptionsSchema>;
+interface DeepgramSpeechModelConfig extends DeepgramConfig {
+    _internal?: {
+        currentDate?: () => Date;
+    };
+}
+declare class DeepgramSpeechModel implements SpeechModelV3 {
+    readonly modelId: DeepgramSpeechModelId;
+    private readonly config;
+    readonly specificationVersion = "v3";
+    get provider(): string;
+    constructor(modelId: DeepgramSpeechModelId, config: DeepgramSpeechModelConfig);
+    private getArgs;
+    doGenerate(options: Parameters<SpeechModelV3['doGenerate']>[0]): Promise<Awaited<ReturnType<SpeechModelV3['doGenerate']>>>;
+}
+
 declare const VERSION: string;
 
-export { type DeepgramProvider, type DeepgramProviderSettings, VERSION, createDeepgram, deepgram };
+export { type DeepgramProvider, type DeepgramProviderSettings, type DeepgramSpeechCallOptions, DeepgramSpeechModel, type DeepgramSpeechModelId, VERSION, createDeepgram, deepgram };

package/dist/index.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  DeepgramSpeechModel: () => DeepgramSpeechModel,
   VERSION: () => VERSION,
   createDeepgram: () => createDeepgram,
   deepgram: () => deepgram
@@ -28,7 +29,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/deepgram-provider.ts
 var import_provider = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
 
 // src/deepgram-transcription-model.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
@@ -206,14 +207,395 @@ var deepgramTranscriptionResponseSchema = import_v42.z.object({
   }).nullish()
 });
 
+// src/deepgram-speech-model.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_v43 = require("zod/v4");
+var deepgramSpeechProviderOptionsSchema = import_v43.z.object({
+  /** Bitrate of the audio in bits per second. Can be a number or predefined enum value. */
+  bitRate: import_v43.z.union([import_v43.z.number(), import_v43.z.string()]).nullish(),
+  /** Container format for the output audio (mp3, wav, etc.). */
+  container: import_v43.z.string().nullish(),
+  /** Encoding type for the audio output (linear16, mulaw, alaw, etc.). */
+  encoding: import_v43.z.string().nullish(),
+  /** Sample rate for the output audio in Hz (8000, 16000, 24000, 44100, 48000). */
+  sampleRate: import_v43.z.number().nullish(),
+  /** URL to which we'll make the callback request. */
+  callback: import_v43.z.string().url().nullish(),
+  /** HTTP method by which the callback request will be made (POST or PUT). */
+  callbackMethod: import_v43.z.enum(["POST", "PUT"]).nullish(),
+  /** Opts out requests from the Deepgram Model Improvement Program. */
+  mipOptOut: import_v43.z.boolean().nullish(),
+  /** Label your requests for the purpose of identification during usage reporting. */
+  tag: import_v43.z.union([import_v43.z.string(), import_v43.z.array(import_v43.z.string())]).nullish()
+});
+var DeepgramSpeechModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    text,
+    voice,
+    outputFormat = "mp3",
+    speed,
+    language,
+    instructions,
+    providerOptions
+  }) {
+    var _a, _b, _c;
+    const warnings = [];
+    const deepgramOptions = await (0, import_provider_utils3.parseProviderOptions)({
+      provider: "deepgram",
+      providerOptions,
+      schema: deepgramSpeechProviderOptionsSchema
+    });
+    const requestBody = {
+      text
+    };
+    const queryParams = {
+      model: this.modelId
+    };
+    if (outputFormat) {
+      const formatLower = outputFormat.toLowerCase();
+      const formatMap = {
+        // MP3: no container, fixed 22050 sample rate, bitrate 32000/48000
+        mp3: { encoding: "mp3" },
+        // Don't set container or sample_rate for mp3
+        // Linear16: wav/none container, configurable sample rate
+        wav: { container: "wav", encoding: "linear16" },
+        linear16: { encoding: "linear16", container: "wav" },
+        // MuLaw: wav/none container, 8000/16000 sample rate
+        mulaw: { encoding: "mulaw", container: "wav" },
+        // ALaw: wav/none container, 8000/16000 sample rate
+        alaw: { encoding: "alaw", container: "wav" },
+        // Opus: ogg container, fixed 48000 sample rate
+        opus: { encoding: "opus", container: "ogg" },
+        ogg: { encoding: "opus", container: "ogg" },
+        // FLAC: no container, configurable sample rate
+        flac: { encoding: "flac" },
+        // AAC: no container, fixed 22050 sample rate
+        aac: { encoding: "aac" },
+        // Raw audio (no container)
+        pcm: { encoding: "linear16", container: "none" }
+      };
+      const mappedFormat = formatMap[formatLower];
+      if (mappedFormat) {
+        if (mappedFormat.encoding) {
+          queryParams.encoding = mappedFormat.encoding;
+        }
+        if (mappedFormat.container) {
+          queryParams.container = mappedFormat.container;
+        }
+        if (mappedFormat.sampleRate) {
+          queryParams.sample_rate = String(mappedFormat.sampleRate);
+        }
+        if (mappedFormat.bitRate) {
+          queryParams.bit_rate = String(mappedFormat.bitRate);
+        }
+      } else {
+        const parts = formatLower.split("_");
+        if (parts.length >= 2) {
+          const firstPart = parts[0];
+          const secondPart = parts[1];
+          const sampleRate = parseInt(secondPart, 10);
+          if ([
+            "linear16",
+            "mulaw",
+            "alaw",
+            "mp3",
+            "opus",
+            "flac",
+            "aac"
+          ].includes(firstPart)) {
+            queryParams.encoding = firstPart;
+            if (["linear16", "mulaw", "alaw"].includes(firstPart)) {
+              queryParams.container = "wav";
+            } else if (firstPart === "opus") {
+              queryParams.container = "ogg";
+            }
+            if (!isNaN(sampleRate)) {
+              if (firstPart === "linear16" && [8e3, 16e3, 24e3, 32e3, 48e3].includes(sampleRate)) {
+                queryParams.sample_rate = String(sampleRate);
+              } else if (firstPart === "mulaw" && [8e3, 16e3].includes(sampleRate)) {
+                queryParams.sample_rate = String(sampleRate);
+              } else if (firstPart === "alaw" && [8e3, 16e3].includes(sampleRate)) {
+                queryParams.sample_rate = String(sampleRate);
+              } else if (firstPart === "flac" && [8e3, 16e3, 22050, 32e3, 48e3].includes(sampleRate)) {
+                queryParams.sample_rate = String(sampleRate);
+              }
+            }
+          } else if (["wav", "ogg"].includes(firstPart)) {
+            if (firstPart === "wav") {
+              queryParams.container = "wav";
+              queryParams.encoding = "linear16";
+            } else if (firstPart === "ogg") {
+              queryParams.container = "ogg";
+              queryParams.encoding = "opus";
+            }
+            if (!isNaN(sampleRate)) {
+              queryParams.sample_rate = String(sampleRate);
+            }
+          }
+        }
+      }
+    }
+    if (deepgramOptions) {
+      if (deepgramOptions.encoding) {
+        const newEncoding = deepgramOptions.encoding.toLowerCase();
+        queryParams.encoding = newEncoding;
+        if (deepgramOptions.container) {
+          if (["linear16", "mulaw", "alaw"].includes(newEncoding)) {
+            if (!["wav", "none"].includes(deepgramOptions.container.toLowerCase())) {
+              warnings.push({
+                type: "unsupported-setting",
+                setting: "providerOptions",
+                details: `Encoding "${newEncoding}" only supports containers "wav" or "none". Container "${deepgramOptions.container}" was ignored.`
+              });
+            } else {
+              queryParams.container = deepgramOptions.container.toLowerCase();
+            }
+          } else if (newEncoding === "opus") {
+            queryParams.container = "ogg";
+          } else if (["mp3", "flac", "aac"].includes(newEncoding)) {
+            warnings.push({
+              type: "unsupported-setting",
+              setting: "providerOptions",
+              details: `Encoding "${newEncoding}" does not support container parameter. Container "${deepgramOptions.container}" was ignored.`
+            });
+            delete queryParams.container;
+          }
+        } else {
+          if (["mp3", "flac", "aac"].includes(newEncoding)) {
+            delete queryParams.container;
+          } else if (["linear16", "mulaw", "alaw"].includes(newEncoding)) {
+            if (!queryParams.container) {
+              queryParams.container = "wav";
+            }
+          } else if (newEncoding === "opus") {
+            queryParams.container = "ogg";
+          }
+        }
+        if (["mp3", "opus", "aac"].includes(newEncoding)) {
+          delete queryParams.sample_rate;
+        }
+        if (["linear16", "mulaw", "alaw", "flac"].includes(newEncoding)) {
+          delete queryParams.bit_rate;
+        }
+      } else if (deepgramOptions.container) {
+        const container = deepgramOptions.container.toLowerCase();
+        const oldEncoding = (_a = queryParams.encoding) == null ? void 0 : _a.toLowerCase();
+        let newEncoding;
+        if (container === "wav") {
+          queryParams.container = "wav";
+          newEncoding = "linear16";
+        } else if (container === "ogg") {
+          queryParams.container = "ogg";
+          newEncoding = "opus";
+        } else if (container === "none") {
+          queryParams.container = "none";
+          newEncoding = "linear16";
+        }
+        if (newEncoding && newEncoding !== oldEncoding) {
+          queryParams.encoding = newEncoding;
+          if (["mp3", "opus", "aac"].includes(newEncoding)) {
+            delete queryParams.sample_rate;
+          }
+          if (["linear16", "mulaw", "alaw", "flac"].includes(newEncoding)) {
+            delete queryParams.bit_rate;
+          }
+        }
+      }
+      if (deepgramOptions.sampleRate != null) {
+        const encoding = ((_b = queryParams.encoding) == null ? void 0 : _b.toLowerCase()) || "";
+        const sampleRate = deepgramOptions.sampleRate;
+        if (encoding === "linear16") {
+          if (![8e3, 16e3, 24e3, 32e3, 48e3].includes(sampleRate)) {
+            warnings.push({
+              type: "unsupported-setting",
+              setting: "providerOptions",
+              details: `Encoding "linear16" only supports sample rates: 8000, 16000, 24000, 32000, 48000. Sample rate ${sampleRate} was ignored.`
+            });
+          } else {
+            queryParams.sample_rate = String(sampleRate);
+          }
+        } else if (encoding === "mulaw" || encoding === "alaw") {
+          if (![8e3, 16e3].includes(sampleRate)) {
+            warnings.push({
+              type: "unsupported-setting",
+              setting: "providerOptions",
+              details: `Encoding "${encoding}" only supports sample rates: 8000, 16000. Sample rate ${sampleRate} was ignored.`
+            });
+          } else {
+            queryParams.sample_rate = String(sampleRate);
+          }
+        } else if (encoding === "flac") {
+          if (![8e3, 16e3, 22050, 32e3, 48e3].includes(sampleRate)) {
+            warnings.push({
+              type: "unsupported-setting",
+              setting: "providerOptions",
+              details: `Encoding "flac" only supports sample rates: 8000, 16000, 22050, 32000, 48000. Sample rate ${sampleRate} was ignored.`
+            });
+          } else {
+            queryParams.sample_rate = String(sampleRate);
+          }
+        } else if (["mp3", "opus", "aac"].includes(encoding)) {
+          warnings.push({
+            type: "unsupported-setting",
+            setting: "providerOptions",
+            details: `Encoding "${encoding}" has a fixed sample rate and does not support sample_rate parameter. Sample rate ${sampleRate} was ignored.`
+          });
+        } else {
+          queryParams.sample_rate = String(sampleRate);
+        }
+      }
+      if (deepgramOptions.bitRate != null) {
+        const encoding = ((_c = queryParams.encoding) == null ? void 0 : _c.toLowerCase()) || "";
+        const bitRate = deepgramOptions.bitRate;
+        if (encoding === "mp3") {
+          if (![32e3, 48e3].includes(Number(bitRate))) {
+            warnings.push({
+              type: "unsupported-setting",
+              setting: "providerOptions",
+              details: `Encoding "mp3" only supports bit rates: 32000, 48000. Bit rate ${bitRate} was ignored.`
+            });
+          } else {
+            queryParams.bit_rate = String(bitRate);
+          }
+        } else if (encoding === "opus") {
+          const bitRateNum = Number(bitRate);
+          if (bitRateNum < 4e3 || bitRateNum > 65e4) {
+            warnings.push({
+              type: "unsupported-setting",
+              setting: "providerOptions",
+              details: `Encoding "opus" supports bit rates between 4000 and 650000. Bit rate ${bitRate} was ignored.`
+            });
+          } else {
+            queryParams.bit_rate = String(bitRate);
+          }
+        } else if (encoding === "aac") {
+          const bitRateNum = Number(bitRate);
+          if (bitRateNum < 4e3 || bitRateNum > 192e3) {
+            warnings.push({
+              type: "unsupported-setting",
+              setting: "providerOptions",
+              details: `Encoding "aac" supports bit rates between 4000 and 192000. Bit rate ${bitRate} was ignored.`
+            });
+          } else {
+            queryParams.bit_rate = String(bitRate);
+          }
+        } else if (["linear16", "mulaw", "alaw", "flac"].includes(encoding)) {
+          warnings.push({
+            type: "unsupported-setting",
+            setting: "providerOptions",
+            details: `Encoding "${encoding}" does not support bit_rate parameter. Bit rate ${bitRate} was ignored.`
+          });
+        } else {
+          queryParams.bit_rate = String(bitRate);
+        }
+      }
+      if (deepgramOptions.callback) {
+        queryParams.callback = deepgramOptions.callback;
+      }
+      if (deepgramOptions.callbackMethod) {
+        queryParams.callback_method = deepgramOptions.callbackMethod;
+      }
+      if (deepgramOptions.mipOptOut != null) {
+        queryParams.mip_opt_out = String(deepgramOptions.mipOptOut);
+      }
+      if (deepgramOptions.tag) {
+        if (Array.isArray(deepgramOptions.tag)) {
+          queryParams.tag = deepgramOptions.tag.join(",");
+        } else {
+          queryParams.tag = deepgramOptions.tag;
+        }
+      }
+    }
+    if (voice && voice !== this.modelId) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "voice",
+        details: `Deepgram TTS models embed the voice in the model ID. The voice parameter "${voice}" was ignored. Use the model ID to select a voice (e.g., "aura-2-helena-en").`
+      });
+    }
+    if (speed != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "speed",
+        details: `Deepgram TTS REST API does not support speed adjustment. Speed parameter was ignored.`
+      });
+    }
+    if (language) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "language",
+        details: `Deepgram TTS models are language-specific via the model ID. Language parameter "${language}" was ignored. Select a model with the appropriate language suffix (e.g., "-en" for English).`
+      });
+    }
+    if (instructions) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "instructions",
+        details: `Deepgram TTS REST API does not support instructions. Instructions parameter was ignored.`
+      });
+    }
+    return {
+      requestBody,
+      queryParams,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const { requestBody, queryParams, warnings } = await this.getArgs(options);
+    const {
+      value: audio,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await (0, import_provider_utils3.postJsonToApi)({
+      url: (() => {
+        const baseUrl = this.config.url({
+          path: "/v1/speak",
+          modelId: this.modelId
+        });
+        const queryString = new URLSearchParams(queryParams).toString();
+        return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+      })(),
+      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      body: requestBody,
+      failedResponseHandler: deepgramFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils3.createBinaryResponseHandler)(),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      audio,
+      warnings,
+      request: {
+        body: JSON.stringify(requestBody)
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+
 // src/version.ts
-var VERSION = true ? "2.0.0-beta.32" : "0.0.0-test";
+var VERSION = true ? "2.0.0-beta.34" : "0.0.0-test";
 
 // src/deepgram-provider.ts
 function createDeepgram(options = {}) {
-  const getHeaders = () => (0, import_provider_utils3.withUserAgentSuffix)(
+  const getHeaders = () => (0, import_provider_utils4.withUserAgentSuffix)(
     {
-      authorization: `Token ${(0, import_provider_utils3.loadApiKey)({
+      authorization: `Token ${(0, import_provider_utils4.loadApiKey)({
         apiKey: options.apiKey,
         environmentVariableName: "DEEPGRAM_API_KEY",
         description: "Deepgram"
@@ -228,6 +610,12 @@ function createDeepgram(options = {}) {
     headers: getHeaders,
     fetch: options.fetch
   });
+  const createSpeechModel = (modelId) => new DeepgramSpeechModel(modelId, {
+    provider: `deepgram.speech`,
+    url: ({ path }) => `https://api.deepgram.com${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
   const provider = function(modelId) {
     return {
       transcription: createTranscriptionModel(modelId)
@@ -236,6 +624,8 @@ function createDeepgram(options = {}) {
   provider.specificationVersion = "v3";
   provider.transcription = createTranscriptionModel;
   provider.transcriptionModel = createTranscriptionModel;
+  provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
   provider.languageModel = () => {
     throw new import_provider.NoSuchModelError({
       modelId: "unknown",
@@ -262,6 +652,7 @@ function createDeepgram(options = {}) {
 var deepgram = createDeepgram();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DeepgramSpeechModel,
   VERSION,
   createDeepgram,
   deepgram