@ai-sdk/cartesia 0.0.1 → 3.0.2

package/dist/index.js

@@ -0,0 +1,724 @@
+// src/cartesia-provider.ts
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  loadApiKey,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
+
+// src/cartesia-transcription-model.ts
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  mediaTypeToExtension,
+  parseProviderOptions,
+  postFormDataToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+
+// src/cartesia-error.ts
+import { z } from "zod/v4";
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+var cartesiaErrorDataSchema = z.object({
+  error_code: z.string().nullish(),
+  title: z.string(),
+  message: z.string(),
+  request_id: z.string(),
+  doc_url: z.string().optional()
+});
+var cartesiaFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: cartesiaErrorDataSchema,
+  errorToMessage: (data) => `${data.title}: ${data.message}`
+});
+
+// src/cartesia-transcription-model-options.ts
+import { z as z2 } from "zod/v4";
+var cartesiaTranscriptionModelOptionsSchema = z2.object({
+  /** The language of the audio (ISO 639-1 code). Defaults to English. */
+  language: z2.string().nullish(),
+  /** The timestamp granularities to populate. Currently only `word` is supported. */
+  timestampGranularities: z2.array(z2.enum(["word"])).nullish()
+});
+
+// src/cartesia-transcription-model.ts
+var CartesiaTranscriptionModel = class _CartesiaTranscriptionModel {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _CartesiaTranscriptionModel(options.modelId, options.config);
+  }
+  async getArgs({
+    audio,
+    mediaType,
+    providerOptions
+  }) {
+    const warnings = [];
+    const cartesiaOptions = await parseProviderOptions({
+      provider: "cartesia",
+      providerOptions,
+      schema: cartesiaTranscriptionModelOptionsSchema
+    });
+    const formData = new FormData();
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
+    const fileExtension = mediaTypeToExtension(mediaType);
+    formData.append("model", this.modelId);
+    formData.append(
+      "file",
+      new File([blob], "audio", { type: mediaType }),
+      `audio.${fileExtension}`
+    );
+    if (cartesiaOptions) {
+      if (cartesiaOptions.language != null) {
+        formData.set("language", cartesiaOptions.language);
+      }
+      if (cartesiaOptions.timestampGranularities != null) {
+        for (const granularity of cartesiaOptions.timestampGranularities) {
+          formData.append("timestamp_granularities[]", granularity);
+        }
+      }
+    }
+    return {
+      formData,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    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 { formData, warnings } = await this.getArgs(options);
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postFormDataToApi({
+      url: this.config.url({
+        path: "/stt",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders((_e = (_d = this.config).headers) == null ? void 0 : _e.call(_d), options.headers),
+      formData,
+      failedResponseHandler: cartesiaFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        cartesiaTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      text: response.text,
+      segments: (_g = (_f = response.words) == null ? void 0 : _f.map((word) => ({
+        text: word.word,
+        startSecond: word.start,
+        endSecond: word.end
+      }))) != null ? _g : [],
+      language: (_h = response.language) != null ? _h : void 0,
+      durationInSeconds: (_i = response.duration) != null ? _i : void 0,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+var cartesiaTranscriptionResponseSchema = z3.object({
+  text: z3.string(),
+  language: z3.string().nullish(),
+  duration: z3.number().nullish(),
+  words: z3.array(
+    z3.object({
+      word: z3.string(),
+      start: z3.number(),
+      end: z3.number()
+    })
+  ).nullish()
+});
+
+// src/cartesia-speech-model.ts
+import {
+  combineHeaders as combineHeaders2,
+  createBinaryResponseHandler,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
+} from "@ai-sdk/provider-utils";
+
+// src/cartesia-speech-model-options.ts
+import { z as z4 } from "zod/v4";
+var cartesiaSpeechModelOptionsSchema = z4.object({
+  /** Container format for the output audio (raw, wav, mp3). */
+  container: z4.enum(["raw", "wav", "mp3"]).nullish(),
+  /** Encoding type for the audio output (pcm_f32le, pcm_s16le, pcm_mulaw, pcm_alaw). */
+  encoding: z4.enum(["pcm_f32le", "pcm_s16le", "pcm_mulaw", "pcm_alaw"]).nullish(),
+  /** Sample rate for the output audio in Hz (e.g. 8000, 16000, 22050, 24000, 44100, 48000). */
+  sampleRate: z4.union([
+    z4.literal(8e3),
+    z4.literal(16e3),
+    z4.literal(22050),
+    z4.literal(24e3),
+    z4.literal(44100),
+    z4.literal(48e3)
+  ]).nullish(),
+  /** Bitrate for mp3 output in bits per second (e.g. 32000, 64000, 128000, 192000). */
+  bitRate: z4.union([
+    z4.literal(32e3),
+    z4.literal(64e3),
+    z4.literal(96e3),
+    z4.literal(128e3),
+    z4.literal(192e3)
+  ]).nullish(),
+  /** Controls the speed of the generated speech. */
+  speed: z4.number().min(0.6).max(1.5).nullish(),
+  /** The language to generate speech in (ISO 639-1 code). */
+  language: z4.string().nullish()
+});
+
+// src/cartesia-speech-model.ts
+var DEFAULT_OUTPUT_FORMAT = {
+  container: "mp3",
+  sample_rate: 44100,
+  bit_rate: 128e3
+};
+var OUTPUT_FORMATS = {
+  alaw: { container: "raw", encoding: "pcm_alaw", sample_rate: 8e3 },
+  mp3: DEFAULT_OUTPUT_FORMAT,
+  mulaw: { container: "raw", encoding: "pcm_mulaw", sample_rate: 8e3 },
+  pcm: { container: "raw", encoding: "pcm_f32le", sample_rate: 44100 },
+  raw: { container: "raw", encoding: "pcm_f32le", sample_rate: 44100 },
+  wav: { container: "wav", encoding: "pcm_s16le", sample_rate: 44100 }
+};
+var SAMPLE_RATES = [8e3, 16e3, 22050, 24e3, 44100, 48e3];
+function isSampleRate(value) {
+  return SAMPLE_RATES.includes(value);
+}
+function resolveOutputFormat({
+  outputFormat,
+  providerOptions,
+  warnings
+}) {
+  var _a, _b, _c, _d;
+  const [formatName, sampleRateText, ...extraParts] = outputFormat.toLowerCase().split("_");
+  const mapped = OUTPUT_FORMATS[formatName];
+  let resolved = mapped ? { ...mapped } : { ...DEFAULT_OUTPUT_FORMAT };
+  if (!mapped) {
+    warnings.push({
+      type: "unsupported",
+      feature: "outputFormat",
+      details: `Unknown output format "${outputFormat}". Falling back to mp3. Use providerOptions.cartesia to configure container, encoding, and sampleRate directly.`
+    });
+  } else if (sampleRateText != null) {
+    const parsedRate = Number(sampleRateText);
+    if (extraParts.length === 0 && Number.isInteger(parsedRate) && isSampleRate(parsedRate)) {
+      resolved.sample_rate = parsedRate;
+    } else {
+      warnings.push({
+        type: "unsupported",
+        feature: "outputFormat",
+        details: `Unsupported Cartesia sample rate in output format "${outputFormat}". Using ${resolved.sample_rate} Hz instead.`
+      });
+    }
+  }
+  const container = (_a = providerOptions == null ? void 0 : providerOptions.container) != null ? _a : resolved.container;
+  const sampleRate = (_b = providerOptions == null ? void 0 : providerOptions.sampleRate) != null ? _b : resolved.sample_rate;
+  if (container === "mp3") {
+    if ((providerOptions == null ? void 0 : providerOptions.encoding) != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "providerOptions.cartesia.encoding",
+        details: "Cartesia MP3 output does not accept an encoding. The encoding option was ignored."
+      });
+    }
+    return {
+      container,
+      sample_rate: sampleRate,
+      bit_rate: (_c = providerOptions == null ? void 0 : providerOptions.bitRate) != null ? _c : resolved.container === "mp3" ? resolved.bit_rate : 128e3
+    };
+  }
+  if ((providerOptions == null ? void 0 : providerOptions.bitRate) != null) {
+    warnings.push({
+      type: "unsupported",
+      feature: "providerOptions.cartesia.bitRate",
+      details: "Cartesia raw and WAV output do not accept a bit rate. The bitRate option was ignored."
+    });
+  }
+  return {
+    container,
+    encoding: (_d = providerOptions == null ? void 0 : providerOptions.encoding) != null ? _d : resolved.container === "mp3" ? container === "wav" ? "pcm_s16le" : "pcm_f32le" : resolved.encoding,
+    sample_rate: sampleRate
+  };
+}
+var CartesiaSpeechModel = class _CartesiaSpeechModel {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _CartesiaSpeechModel(options.modelId, options.config);
+  }
+  async getArgs({
+    text,
+    voice,
+    outputFormat = "mp3",
+    instructions,
+    language,
+    speed,
+    providerOptions
+  }) {
+    var _a;
+    const warnings = [];
+    const cartesiaOptions = await parseProviderOptions2({
+      provider: "cartesia",
+      providerOptions,
+      schema: cartesiaSpeechModelOptionsSchema
+    });
+    if (!voice) {
+      throw new Error("Cartesia speech models require a `voice` to be set.");
+    }
+    const outputFormatObject = resolveOutputFormat({
+      outputFormat,
+      providerOptions: cartesiaOptions,
+      warnings
+    });
+    const requestBody = {
+      model_id: this.modelId,
+      transcript: text,
+      voice: {
+        mode: "id",
+        id: voice
+      },
+      output_format: outputFormatObject
+    };
+    if (language) {
+      requestBody.language = language;
+    }
+    if (cartesiaOptions) {
+      if (cartesiaOptions.language != null) {
+        requestBody.language = cartesiaOptions.language;
+      }
+    }
+    const resolvedSpeed = (_a = cartesiaOptions == null ? void 0 : cartesiaOptions.speed) != null ? _a : speed;
+    if (resolvedSpeed != null) {
+      if (resolvedSpeed >= 0.6 && resolvedSpeed <= 1.5) {
+        requestBody.generation_config = { speed: resolvedSpeed };
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "speed",
+          details: "Cartesia speed must be between 0.6 and 1.5. The speed option was ignored."
+        });
+      }
+    }
+    if (instructions) {
+      warnings.push({
+        type: "unsupported",
+        feature: "instructions",
+        details: `Cartesia speech models do not support instructions. Instructions parameter was ignored.`
+      });
+    }
+    return {
+      requestBody,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e;
+    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, warnings } = await this.getArgs(options);
+    const {
+      value: audio,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/tts/bytes",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders2((_e = (_d = this.config).headers) == null ? void 0 : _e.call(_d), options.headers),
+      body: requestBody,
+      failedResponseHandler: cartesiaFailedResponseHandler,
+      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/cartesia-realtime-model.ts
+import {
+  convertBase64ToUint8Array as convertBase64ToUint8Array2
+} from "@ai-sdk/provider-utils";
+var CartesiaRealtimeModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v4";
+    this.manualTranscript = {
+      duration: 0,
+      events: [],
+      text: ""
+    };
+    this.sessionCreated = false;
+    this.useTurnDetection = true;
+    this.modelId = modelId;
+    this.provider = config.provider;
+    this.config = config;
+  }
+  async doCreateClientSecret(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const expiresIn = options.expiresAfterSeconds;
+    if (expiresIn != null && (!Number.isInteger(expiresIn) || expiresIn <= 0 || expiresIn > 3600)) {
+      throw new Error(
+        "Cartesia realtime client secrets must expire between 1 and 3600 seconds."
+      );
+    }
+    const sessionConfig = options.sessionConfig;
+    const language = (_a = sessionConfig == null ? void 0 : sessionConfig.inputAudioTranscription) == null ? void 0 : _a.language;
+    if (language != null && language !== "en") {
+      throw new Error("Cartesia Ink 2 currently supports English only.");
+    }
+    const fetchFn = (_b = this.config.fetch) != null ? _b : fetch;
+    const response = await fetchFn(`${this.config.baseURL}/access-token`, {
+      method: "POST",
+      headers: {
+        ...this.config.headers(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        grants: { stt: true },
+        ...expiresIn != null ? { expires_in: expiresIn } : {}
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(
+        `Cartesia realtime client secret request failed: ${response.status} ${text}`
+      );
+    }
+    const data = await response.json();
+    if (typeof data.token !== "string" || data.token.length === 0) {
+      throw new Error(
+        "Cartesia realtime client secret response did not include a token."
+      );
+    }
+    const turnDetection = sessionConfig == null ? void 0 : sessionConfig.turnDetection;
+    const useTurnDetection = turnDetection === void 0 || turnDetection !== null && turnDetection.type !== "disabled";
+    const inputAudioFormat = sessionConfig == null ? void 0 : sessionConfig.inputAudioFormat;
+    const url = new URL(
+      useTurnDetection ? `${this.config.baseURL}/stt/turns/websocket` : `${this.config.baseURL}/stt/websocket`
+    );
+    url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+    url.searchParams.set("model", this.modelId);
+    url.searchParams.set(
+      "encoding",
+      resolveCartesiaEncoding(inputAudioFormat == null ? void 0 : inputAudioFormat.type)
+    );
+    url.searchParams.set(
+      "sample_rate",
+      String((_c = inputAudioFormat == null ? void 0 : inputAudioFormat.rate) != null ? _c : 24e3)
+    );
+    url.searchParams.set("cartesia_version", this.config.version);
+    if (!useTurnDetection && language != null) {
+      url.searchParams.set("language", language);
+    }
+    return {
+      token: data.token,
+      url: url.toString(),
+      ...expiresIn != null ? {
+        expiresAt: Math.floor(
+          ((_f = (_e = (_d = this.config._internal) == null ? void 0 : _d.currentDate) == null ? void 0 : _e.call(_d)) != null ? _f : /* @__PURE__ */ new Date()).getTime() / 1e3
+        ) + expiresIn
+      } : {}
+    };
+  }
+  getWebSocketConfig(options) {
+    const url = new URL(options.url);
+    this.useTurnDetection = url.pathname.includes("/stt/turns/websocket");
+    url.searchParams.set("access_token", options.token);
+    return { url: url.toString() };
+  }
+  parseServerEvent(raw) {
+    var _a, _b, _c, _d, _e;
+    const event = raw;
+    const requestId = (_a = event.request_id) != null ? _a : "cartesia-realtime";
+    let mapped;
+    switch (event.type) {
+      case "connected":
+        this.sessionCreated = true;
+        return {
+          type: "session-created",
+          sessionId: event.request_id,
+          raw
+        };
+      case "turn.start":
+        mapped = { type: "speech-started", itemId: requestId, raw };
+        break;
+      case "turn.resume":
+        mapped = [
+          { type: "speech-started", itemId: requestId, raw },
+          { type: "custom", rawType: event.type, raw }
+        ];
+        break;
+      case "turn.end":
+        mapped = [
+          { type: "speech-stopped", itemId: requestId, raw },
+          {
+            type: "input-transcription-completed",
+            itemId: requestId,
+            transcript: (_b = event.transcript) != null ? _b : "",
+            raw
+          }
+        ];
+        break;
+      case "transcript":
+        if (event.is_final === true) {
+          this.manualTranscript.text += (_c = event.text) != null ? _c : "";
+          this.manualTranscript.duration += (_d = event.duration) != null ? _d : 0;
+          this.manualTranscript.events.push(event);
+        }
+        mapped = { type: "custom", rawType: event.type, raw };
+        break;
+      case "flush_done":
+        mapped = this.finishManualTranscript(event, raw);
+        break;
+      case "done": {
+        if (this.manualTranscript.text.length > 0) {
+          const completed = this.finishManualTranscript(event, raw);
+          mapped = Array.isArray(completed) ? [...completed, { type: "custom", rawType: event.type, raw }] : [completed, { type: "custom", rawType: event.type, raw }];
+        } else {
+          mapped = { type: "custom", rawType: event.type, raw };
+        }
+        break;
+      }
+      case "error":
+        mapped = {
+          type: "error",
+          message: (_e = event.message) != null ? _e : "Unknown Cartesia realtime error",
+          code: event.error_code,
+          raw
+        };
+        break;
+      default:
+        mapped = { type: "custom", rawType: event.type, raw };
+        break;
+    }
+    return this.withSessionCreated(mapped, requestId, raw);
+  }
+  serializeClientEvent(event) {
+    switch (event.type) {
+      case "session-update":
+      case "input-audio-clear":
+      case "response-create":
+        return null;
+      case "input-audio-append":
+        return convertBase64ToUint8Array2(event.audio);
+      case "input-audio-commit":
+        return this.useTurnDetection ? null : "finalize";
+      default:
+        throw new Error(
+          `Cartesia Ink 2 does not support realtime client event "${event.type}".`
+        );
+    }
+  }
+  buildSessionConfig(_config) {
+    return null;
+  }
+  finishManualTranscript(event, raw) {
+    var _a;
+    const state = this.manualTranscript;
+    this.manualTranscript = { duration: 0, events: [], text: "" };
+    if (state.text.length === 0) {
+      return { type: "custom", rawType: event.type, raw };
+    }
+    return [
+      {
+        type: "audio-committed",
+        itemId: event.request_id,
+        raw
+      },
+      {
+        type: "input-transcription-completed",
+        itemId: (_a = event.request_id) != null ? _a : "cartesia-realtime",
+        transcript: state.text,
+        raw: {
+          event,
+          transcriptEvents: state.events,
+          duration: state.duration
+        }
+      }
+    ];
+  }
+  withSessionCreated(event, sessionId, raw) {
+    if (this.sessionCreated) {
+      return event;
+    }
+    this.sessionCreated = true;
+    const created = {
+      type: "session-created",
+      sessionId,
+      raw
+    };
+    return Array.isArray(event) ? [created, ...event] : [created, event];
+  }
+};
+function resolveCartesiaEncoding(type) {
+  switch (type) {
+    case void 0:
+    case "audio/pcm":
+      return "pcm_s16le";
+    case "audio/pcmu":
+      return "pcm_mulaw";
+    case "audio/pcma":
+      return "pcm_alaw";
+    default:
+      throw new Error(`Unsupported Cartesia realtime audio format: ${type}`);
+  }
+}
+
+// src/version.ts
+var VERSION = true ? "3.0.2" : "0.0.0-test";
+
+// src/cartesia-provider.ts
+var CARTESIA_API_VERSION = "2026-03-01";
+function createCartesia(options = {}) {
+  const getHeaders = () => {
+    var _a;
+    return withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: "CARTESIA_API_KEY",
+          description: "Cartesia"
+        })}`,
+        "Cartesia-Version": (_a = options.version) != null ? _a : CARTESIA_API_VERSION,
+        ...options.headers
+      },
+      `ai-sdk/cartesia/${VERSION}`
+    );
+  };
+  const createTranscriptionModel = (modelId) => new CartesiaTranscriptionModel(modelId, {
+    provider: `cartesia.transcription`,
+    url: ({ path }) => `https://api.cartesia.ai${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createSpeechModel = (modelId) => new CartesiaSpeechModel(modelId, {
+    provider: `cartesia.speech`,
+    url: ({ path }) => `https://api.cartesia.ai${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createRealtimeModel = (modelId) => {
+    var _a;
+    return new CartesiaRealtimeModel(modelId, {
+      provider: `cartesia.realtime`,
+      baseURL: "https://api.cartesia.ai",
+      version: (_a = options.version) != null ? _a : CARTESIA_API_VERSION,
+      headers: getHeaders,
+      fetch: options.fetch
+    });
+  };
+  const experimentalRealtimeFactory = Object.assign(
+    (modelId) => createRealtimeModel(modelId),
+    {
+      getToken: async (tokenOptions) => {
+        const secret = await createRealtimeModel(
+          tokenOptions.model
+        ).doCreateClientSecret({
+          sessionConfig: tokenOptions.sessionConfig,
+          expiresAfterSeconds: tokenOptions.expiresAfterSeconds
+        });
+        return {
+          token: secret.token,
+          url: secret.url,
+          expiresAt: secret.expiresAt
+        };
+      }
+    }
+  );
+  const provider = function(modelId) {
+    return {
+      speech: createSpeechModel(modelId)
+    };
+  };
+  provider.specificationVersion = "v4";
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
+  provider.experimental_realtime = experimentalRealtimeFactory;
+  provider.languageModel = (modelId) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: "languageModel",
+      message: "Cartesia does not provide language models"
+    });
+  };
+  provider.embeddingModel = (modelId) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: "embeddingModel",
+      message: "Cartesia does not provide embedding models"
+    });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: "imageModel",
+      message: "Cartesia does not provide image models"
+    });
+  };
+  return provider;
+}
+var cartesia = createCartesia();
+export {
+  CartesiaRealtimeModel,
+  CartesiaSpeechModel,
+  CartesiaTranscriptionModel,
+  VERSION,
+  cartesia,
+  createCartesia
+};
+//# sourceMappingURL=index.js.map