@ai-sdk/deepgram 3.0.0-beta.3 → 3.0.0-beta.31

package/dist/index.mjs

@@ -1,650 +0,0 @@
-// src/deepgram-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
-import {
-  loadApiKey,
-  withUserAgentSuffix
-} from "@ai-sdk/provider-utils";
-
-// src/deepgram-transcription-model.ts
-import {
-  combineHeaders,
-  createJsonResponseHandler,
-  parseProviderOptions,
-  postToApi
-} from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod/v4";
-
-// src/deepgram-error.ts
-import { z } from "zod/v4";
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-var deepgramErrorDataSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    code: z.number()
-  })
-});
-var deepgramFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: deepgramErrorDataSchema,
-  errorToMessage: (data) => data.error.message
-});
-
-// src/deepgram-transcription-model.ts
-var deepgramTranscriptionModelOptionsSchema = z2.object({
-  /** Language to use for transcription. If not specified, Deepgram defaults to English. Use `detectLanguage: true` to enable automatic language detection. */
-  language: z2.string().nullish(),
-  /** Whether to enable automatic language detection. When true, Deepgram will detect the language of the audio. */
-  detectLanguage: z2.boolean().nullish(),
-  /** Whether to use smart formatting, which formats written-out numbers, dates, times, etc. */
-  smartFormat: z2.boolean().nullish(),
-  /** Whether to add punctuation to the transcript. */
-  punctuate: z2.boolean().nullish(),
-  /** Whether to format the transcript into paragraphs. */
-  paragraphs: z2.boolean().nullish(),
-  /** Whether to generate a summary of the transcript. Use 'v2' for the latest version or false to disable. */
-  summarize: z2.union([z2.literal("v2"), z2.literal(false)]).nullish(),
-  /** Whether to identify topics in the transcript. */
-  topics: z2.boolean().nullish(),
-  /** Whether to identify intents in the transcript. */
-  intents: z2.boolean().nullish(),
-  /** Whether to analyze sentiment in the transcript. */
-  sentiment: z2.boolean().nullish(),
-  /** Whether to detect and tag named entities in the transcript. */
-  detectEntities: z2.boolean().nullish(),
-  /** Specify terms or patterns to redact from the transcript. Can be a string or array of strings. */
-  redact: z2.union([z2.string(), z2.array(z2.string())]).nullish(),
-  /** String to replace redacted content with. */
-  replace: z2.string().nullish(),
-  /** Term or phrase to search for in the transcript. */
-  search: z2.string().nullish(),
-  /** Key term to identify in the transcript. */
-  keyterm: z2.string().nullish(),
-  /** Whether to identify different speakers in the audio. */
-  diarize: z2.boolean().nullish(),
-  /** Whether to segment the transcript into utterances. */
-  utterances: z2.boolean().nullish(),
-  /** Minimum duration of silence (in seconds) to trigger a new utterance. */
-  uttSplit: z2.number().nullish(),
-  /** Whether to include filler words (um, uh, etc.) in the transcript. */
-  fillerWords: z2.boolean().nullish()
-});
-var DeepgramTranscriptionModel = class {
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.config = config;
-    this.specificationVersion = "v3";
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async getArgs({
-    providerOptions
-  }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-    const warnings = [];
-    const deepgramOptions = await parseProviderOptions({
-      provider: "deepgram",
-      providerOptions,
-      schema: deepgramTranscriptionModelOptionsSchema
-    });
-    const body = {
-      model: this.modelId,
-      diarize: true
-    };
-    if (deepgramOptions) {
-      body.detect_entities = (_a = deepgramOptions.detectEntities) != null ? _a : void 0;
-      body.detect_language = (_b = deepgramOptions.detectLanguage) != null ? _b : void 0;
-      body.filler_words = (_c = deepgramOptions.fillerWords) != null ? _c : void 0;
-      body.language = (_d = deepgramOptions.language) != null ? _d : void 0;
-      body.punctuate = (_e = deepgramOptions.punctuate) != null ? _e : void 0;
-      body.redact = (_f = deepgramOptions.redact) != null ? _f : void 0;
-      body.search = (_g = deepgramOptions.search) != null ? _g : void 0;
-      body.smart_format = (_h = deepgramOptions.smartFormat) != null ? _h : void 0;
-      body.summarize = (_i = deepgramOptions.summarize) != null ? _i : void 0;
-      body.topics = (_j = deepgramOptions.topics) != null ? _j : void 0;
-      body.utterances = (_k = deepgramOptions.utterances) != null ? _k : void 0;
-      body.utt_split = (_l = deepgramOptions.uttSplit) != null ? _l : void 0;
-      if (typeof deepgramOptions.diarize === "boolean") {
-        body.diarize = deepgramOptions.diarize;
-      }
-    }
-    const queryParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(body)) {
-      if (value !== void 0) {
-        queryParams.append(key, String(value));
-      }
-    }
-    return {
-      queryParams,
-      warnings
-    };
-  }
-  async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
-    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 { queryParams, warnings } = await this.getArgs(options);
-    const {
-      value: response,
-      responseHeaders,
-      rawValue: rawResponse
-    } = await postToApi({
-      url: this.config.url({
-        path: "/v1/listen",
-        modelId: this.modelId
-      }) + "?" + queryParams.toString(),
-      headers: {
-        ...combineHeaders(this.config.headers(), options.headers),
-        "Content-Type": options.mediaType
-      },
-      body: {
-        content: options.audio,
-        values: options.audio
-      },
-      failedResponseHandler: deepgramFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        deepgramTranscriptionResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      text: (_g = (_f = (_e = (_d = response.results) == null ? void 0 : _d.channels.at(0)) == null ? void 0 : _e.alternatives.at(0)) == null ? void 0 : _f.transcript) != null ? _g : "",
-      segments: (_j = (_i = (_h = response.results) == null ? void 0 : _h.channels[0].alternatives[0].words) == null ? void 0 : _i.map((word) => ({
-        text: word.word,
-        startSecond: word.start,
-        endSecond: word.end
-      }))) != null ? _j : [],
-      language: (_m = (_l = (_k = response.results) == null ? void 0 : _k.channels.at(0)) == null ? void 0 : _l.detected_language) != null ? _m : void 0,
-      durationInSeconds: (_o = (_n = response.metadata) == null ? void 0 : _n.duration) != null ? _o : void 0,
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-        body: rawResponse
-      }
-    };
-  }
-};
-var deepgramTranscriptionResponseSchema = z2.object({
-  metadata: z2.object({
-    duration: z2.number()
-  }).nullish(),
-  results: z2.object({
-    channels: z2.array(
-      z2.object({
-        detected_language: z2.string().nullish(),
-        alternatives: z2.array(
-          z2.object({
-            transcript: z2.string(),
-            words: z2.array(
-              z2.object({
-                word: z2.string(),
-                start: z2.number(),
-                end: z2.number()
-              })
-            )
-          })
-        )
-      })
-    )
-  }).nullish()
-});
-
-// src/deepgram-speech-model.ts
-import {
-  combineHeaders as combineHeaders2,
-  createBinaryResponseHandler,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi
-} from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
-var deepgramSpeechModelOptionsSchema = z3.object({
-  /** Bitrate of the audio in bits per second. Can be a number or predefined enum value. */
-  bitRate: z3.union([z3.number(), z3.string()]).nullish(),
-  /** Container format for the output audio (mp3, wav, etc.). */
-  container: z3.string().nullish(),
-  /** Encoding type for the audio output (linear16, mulaw, alaw, etc.). */
-  encoding: z3.string().nullish(),
-  /** Sample rate for the output audio in Hz (8000, 16000, 24000, 44100, 48000). */
-  sampleRate: z3.number().nullish(),
-  /** URL to which we'll make the callback request. */
-  callback: z3.string().url().nullish(),
-  /** HTTP method by which the callback request will be made (POST or PUT). */
-  callbackMethod: z3.enum(["POST", "PUT"]).nullish(),
-  /** Opts out requests from the Deepgram Model Improvement Program. */
-  mipOptOut: z3.boolean().nullish(),
-  /** Label your requests for the purpose of identification during usage reporting. */
-  tag: z3.union([z3.string(), z3.array(z3.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 parseProviderOptions2({
-      provider: "deepgram",
-      providerOptions,
-      schema: deepgramSpeechModelOptionsSchema
-    });
-    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",
-                feature: "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",
-              feature: "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",
-              feature: "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",
-              feature: "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",
-              feature: "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",
-            feature: "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",
-              feature: "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",
-              feature: "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",
-              feature: "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",
-            feature: "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",
-        feature: "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",
-        feature: "speed",
-        details: `Deepgram TTS REST API does not support speed adjustment. Speed parameter was ignored.`
-      });
-    }
-    if (language) {
-      warnings.push({
-        type: "unsupported",
-        feature: "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",
-        feature: "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 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: combineHeaders2(this.config.headers(), options.headers),
-      body: requestBody,
-      failedResponseHandler: deepgramFailedResponseHandler,
-      successfulResponseHandler: 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 ? "3.0.0-beta.3" : "0.0.0-test";
-
-// src/deepgram-provider.ts
-function createDeepgram(options = {}) {
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      authorization: `Token ${loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "DEEPGRAM_API_KEY",
-        description: "Deepgram"
-      })}`,
-      ...options.headers
-    },
-    `ai-sdk/deepgram/${VERSION}`
-  );
-  const createTranscriptionModel = (modelId) => new DeepgramTranscriptionModel(modelId, {
-    provider: `deepgram.transcription`,
-    url: ({ path }) => `https://api.deepgram.com${path}`,
-    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)
-    };
-  };
-  provider.specificationVersion = "v3";
-  provider.transcription = createTranscriptionModel;
-  provider.transcriptionModel = createTranscriptionModel;
-  provider.speech = createSpeechModel;
-  provider.speechModel = createSpeechModel;
-  provider.languageModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "languageModel",
-      message: "Deepgram does not provide language models"
-    });
-  };
-  provider.embeddingModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "embeddingModel",
-      message: "Deepgram does not provide text embedding models"
-    });
-  };
-  provider.textEmbeddingModel = provider.embeddingModel;
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "imageModel",
-      message: "Deepgram does not provide image models"
-    });
-  };
-  return provider;
-}
-var deepgram = createDeepgram();
-export {
-  DeepgramSpeechModel,
-  VERSION,
-  createDeepgram,
-  deepgram
-};
-//# sourceMappingURL=index.mjs.map