@ai-sdk/cartesia 3.0.45 → 3.0.47

package/dist/index.js

@@ -1,1052 +1,903 @@
-// src/cartesia-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
-import {
-  loadApiKey,
-  withUserAgentSuffix
-} from "@ai-sdk/provider-utils";
-
-// src/cartesia-transcription-model.ts
-import {
-  InvalidArgumentError,
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders,
-  connectToWebSocket,
-  convertBase64ToUint8Array,
-  createJsonResponseHandler,
-  mediaTypeToExtension,
-  parseProviderOptions,
-  postFormDataToApi,
-  postJsonToApi,
-  safeParseJSON,
-  serializeModelOptions,
-  toWebSocketUrl,
-  waitForWebSocketBufferDrain,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE
-} from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
-
-// src/cartesia-error.ts
+import { InvalidArgumentError, NoSuchModelError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertBase64ToUint8Array, createBinaryResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, loadApiKey, mediaTypeToExtension, parseProviderOptions, postFormDataToApi, postJsonToApi, safeParseJSON, serializeModelOptions, toWebSocketUrl, waitForWebSocketBufferDrain, withUserAgentSuffix } from "@ai-sdk/provider-utils";
 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()
+//#region src/cartesia-error.ts
+const 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}`
+const cartesiaFailedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema: cartesiaErrorDataSchema,
+	errorToMessage: (data) => `${data.title}: ${data.message}`
 });
-
-// src/cartesia-transcription-model-options.ts
-import { z as z2 } from "zod/v4";
-var cartesiaStreamingEncodingSchema = z2.enum([
-  "pcm_alaw",
-  "pcm_f16le",
-  "pcm_f32le",
-  "pcm_mulaw",
-  "pcm_s16le",
-  "pcm_s32le"
+//#endregion
+//#region src/cartesia-transcription-model-options.ts
+/** Raw audio encodings accepted by Ink 2 streaming transcription. */
+const cartesiaStreamingEncodingSchema = z.enum([
+	"pcm_alaw",
+	"pcm_f16le",
+	"pcm_f32le",
+	"pcm_mulaw",
+	"pcm_s16le",
+	"pcm_s32le"
 ]);
-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(),
-  /** Options for realtime Ink 2 transcription over WebSocket. */
-  streaming: z2.object({
-    /**
-     * Raw audio encoding sent to Ink 2. Defaults to the encoding inferred
-     * from `inputAudioFormat.type`.
-     */
-    encoding: cartesiaStreamingEncodingSchema.optional(),
-    /**
-     * Use Cartesia's native turn detection endpoint. Defaults to true.
-     * Disable this to finalize the transcript only when the audio stream ends.
-     */
-    turnDetection: z2.boolean().optional()
-  }).optional()
+const cartesiaTranscriptionModelOptionsSchema = z.object({
+	/** The language of the audio (ISO 639-1 code). Defaults to English. */
+	language: z.string().nullish(),
+	/** The timestamp granularities to populate. Currently only `word` is supported. */
+	timestampGranularities: z.array(z.enum(["word"])).nullish(),
+	/** Options for realtime Ink 2 transcription over WebSocket. */
+	streaming: z.object({
+		/**
+		* Raw audio encoding sent to Ink 2. Defaults to the encoding inferred
+		* from `inputAudioFormat.type`.
+		*/
+		encoding: cartesiaStreamingEncodingSchema.optional(),
+		/**
+		* Use Cartesia's native turn detection endpoint. Defaults to true.
+		* Disable this to finalize the transcript only when the audio stream ends.
+		*/
+		turnDetection: z.boolean().optional()
+	}).optional()
 });
-
-// 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
-    });
-    if (cartesiaOptions?.streaming != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "providerOptions.cartesia.streaming",
-        details: "Cartesia batch transcription does not support streaming options."
-      });
-    }
-    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) {
-    if (isStreamingTranscriptionModelId(this.modelId)) {
-      throw new UnsupportedFunctionalityError({
-        functionality: `non-streaming transcription with ${this.modelId}`
-      });
-    }
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__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(this.config.headers?.(), options.headers),
-      formData,
-      failedResponseHandler: cartesiaFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        cartesiaTranscriptionResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      text: response.text,
-      segments: response.words?.map((word) => ({
-        text: word.word,
-        startSecond: word.start,
-        endSecond: word.end
-      })) ?? [],
-      language: response.language ?? void 0,
-      durationInSeconds: response.duration ?? void 0,
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-        body: rawResponse
-      }
-    };
-  }
-  async doStream(options) {
-    if (!isStreamingTranscriptionModelId(this.modelId)) {
-      throw new UnsupportedFunctionalityError({
-        functionality: `streaming transcription with ${this.modelId}`
-      });
-    }
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const warnings = [];
-    const cartesiaOptions = await parseProviderOptions({
-      provider: "cartesia",
-      providerOptions: options.providerOptions,
-      schema: cartesiaTranscriptionModelOptionsSchema
-    });
-    if (cartesiaOptions?.language != null && cartesiaOptions.language !== "en") {
-      throw new InvalidArgumentError({
-        argument: "providerOptions",
-        message: "Cartesia Ink 2 currently supports English only."
-      });
-    }
-    if (cartesiaOptions?.timestampGranularities != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "providerOptions.cartesia.timestampGranularities",
-        details: "Cartesia streaming transcription does not support timestamp granularities."
-      });
-    }
-    const inferredEncoding = cartesiaEncodingFromInputAudioFormat(
-      options.inputAudioFormat.type
-    );
-    const encoding = cartesiaOptions?.streaming?.encoding ?? inferredEncoding;
-    if (encoding !== inferredEncoding && !(inferredEncoding === "pcm_s16le" && LINEAR_PCM_STREAMING_ENCODINGS.has(encoding))) {
-      warnings.push({
-        type: "other",
-        message: `providerOptions.cartesia.streaming.encoding '${encoding}' contradicts inputAudioFormat.type '${options.inputAudioFormat.type}' (inferred '${inferredEncoding}'); sending '${encoding}'.`
-      });
-    }
-    const token = await this.createStreamingAccessToken(options);
-    const useTurnDetection = cartesiaOptions?.streaming?.turnDetection !== false;
-    const url = buildCartesiaStreamingTranscriptionUrl({
-      baseURL: this.config.url({ path: "/", modelId: this.modelId }),
-      version: this.config.version ?? "2026-03-01",
-      modelId: this.modelId,
-      encoding,
-      inputAudioFormat: options.inputAudioFormat,
-      providerOptions: cartesiaOptions,
-      token,
-      useTurnDetection
-    });
-    const requestUrl = new URL(url);
-    requestUrl.searchParams.delete("access_token");
-    return {
-      request: { body: requestUrl.toString() },
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId
-      },
-      stream: createCartesiaStreamingTranscriptionStream({
-        webSocket: this.config.webSocket,
-        url,
-        warnings,
-        language: cartesiaOptions?.language ?? "en",
-        useTurnDetection,
-        audio: options.audio,
-        abortSignal: options.abortSignal,
-        includeRawChunks: options.includeRawChunks
-      })
-    };
-  }
-  async createStreamingAccessToken(options) {
-    const { value } = await postJsonToApi({
-      url: this.config.url({ path: "/access-token", modelId: this.modelId }),
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body: { grants: { stt: true } },
-      failedResponseHandler: cartesiaFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        cartesiaAccessTokenResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    return value.token;
-  }
+//#endregion
+//#region src/cartesia-transcription-model.ts
+var CartesiaTranscriptionModel = class CartesiaTranscriptionModel {
+	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);
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async getArgs({ audio, mediaType, providerOptions }) {
+		const warnings = [];
+		const cartesiaOptions = await parseProviderOptions({
+			provider: "cartesia",
+			providerOptions,
+			schema: cartesiaTranscriptionModelOptionsSchema
+		});
+		if (cartesiaOptions?.streaming != null) warnings.push({
+			type: "unsupported",
+			feature: "providerOptions.cartesia.streaming",
+			details: "Cartesia batch transcription does not support streaming options."
+		});
+		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) {
+		if (isStreamingTranscriptionModelId(this.modelId)) throw new UnsupportedFunctionalityError({ functionality: `non-streaming transcription with ${this.modelId}` });
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__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(this.config.headers?.(), options.headers),
+			formData,
+			failedResponseHandler: cartesiaFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(cartesiaTranscriptionResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			text: response.text,
+			segments: response.words?.map((word) => ({
+				text: word.word,
+				startSecond: word.start,
+				endSecond: word.end
+			})) ?? [],
+			language: response.language ?? void 0,
+			durationInSeconds: response.duration ?? void 0,
+			warnings,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			}
+		};
+	}
+	async doStream(options) {
+		if (!isStreamingTranscriptionModelId(this.modelId)) throw new UnsupportedFunctionalityError({ functionality: `streaming transcription with ${this.modelId}` });
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const warnings = [];
+		const cartesiaOptions = await parseProviderOptions({
+			provider: "cartesia",
+			providerOptions: options.providerOptions,
+			schema: cartesiaTranscriptionModelOptionsSchema
+		});
+		if (cartesiaOptions?.language != null && cartesiaOptions.language !== "en") throw new InvalidArgumentError({
+			argument: "providerOptions",
+			message: "Cartesia Ink 2 currently supports English only."
+		});
+		if (cartesiaOptions?.timestampGranularities != null) warnings.push({
+			type: "unsupported",
+			feature: "providerOptions.cartesia.timestampGranularities",
+			details: "Cartesia streaming transcription does not support timestamp granularities."
+		});
+		const inferredEncoding = cartesiaEncodingFromInputAudioFormat(options.inputAudioFormat.type);
+		const encoding = cartesiaOptions?.streaming?.encoding ?? inferredEncoding;
+		if (encoding !== inferredEncoding && !(inferredEncoding === "pcm_s16le" && LINEAR_PCM_STREAMING_ENCODINGS.has(encoding))) warnings.push({
+			type: "other",
+			message: `providerOptions.cartesia.streaming.encoding '${encoding}' contradicts inputAudioFormat.type '${options.inputAudioFormat.type}' (inferred '${inferredEncoding}'); sending '${encoding}'.`
+		});
+		const token = await this.createStreamingAccessToken(options);
+		const useTurnDetection = cartesiaOptions?.streaming?.turnDetection !== false;
+		const url = buildCartesiaStreamingTranscriptionUrl({
+			baseURL: this.config.url({
+				path: "/",
+				modelId: this.modelId
+			}),
+			version: this.config.version ?? "2026-03-01",
+			modelId: this.modelId,
+			encoding,
+			inputAudioFormat: options.inputAudioFormat,
+			providerOptions: cartesiaOptions,
+			token,
+			useTurnDetection
+		});
+		const requestUrl = new URL(url);
+		requestUrl.searchParams.delete("access_token");
+		return {
+			request: { body: requestUrl.toString() },
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId
+			},
+			stream: createCartesiaStreamingTranscriptionStream({
+				webSocket: this.config.webSocket,
+				url,
+				warnings,
+				language: cartesiaOptions?.language ?? "en",
+				useTurnDetection,
+				audio: options.audio,
+				abortSignal: options.abortSignal,
+				includeRawChunks: options.includeRawChunks
+			})
+		};
+	}
+	async createStreamingAccessToken(options) {
+		const { value } = await postJsonToApi({
+			url: this.config.url({
+				path: "/access-token",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body: { grants: { stt: true } },
+			failedResponseHandler: cartesiaFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(cartesiaAccessTokenResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		return value.token;
+	}
 };
-function createCartesiaStreamingTranscriptionStream({
-  webSocket,
-  url,
-  warnings,
-  language,
-  useTurnDetection,
-  audio,
-  abortSignal,
-  includeRawChunks
-}) {
-  let finished = false;
-  let cleanup = () => {
-  };
-  return new ReadableStream({
-    start: (controller) => {
-      const finalTexts = [];
-      let durationInSeconds = 0;
-      let audioReader;
-      let connection;
-      cleanup = (closeCode) => {
-        if (audioReader != null) {
-          void audioReader.cancel().catch(() => {
-          });
-        } else {
-          void audio.cancel().catch(() => {
-          });
-        }
-        connection?.close(closeCode);
-      };
-      const finishWithError = (error) => {
-        if (finished) return;
-        finished = true;
-        cleanup();
-        controller.error(error);
-      };
-      const finish = () => {
-        if (finished) return;
-        finished = true;
-        controller.enqueue({
-          type: "finish",
-          text: finalTexts.join(useTurnDetection ? " " : ""),
-          segments: [],
-          language,
-          ...durationInSeconds > 0 ? { durationInSeconds } : {}
-        });
-        controller.close();
-        cleanup(1e3);
-      };
-      const sendAudio = async (socket) => {
-        audioReader = audio.getReader();
-        try {
-          while (true) {
-            const { done, value } = await audioReader.read();
-            if (done || finished) break;
-            socket.send(
-              value instanceof Uint8Array ? value : convertBase64ToUint8Array(value)
-            );
-            await waitForWebSocketBufferDrain(socket);
-          }
-        } finally {
-          audioReader.releaseLock();
-          audioReader = void 0;
-        }
-        if (!finished) {
-          socket.send(
-            useTurnDetection ? JSON.stringify({ type: "close" }) : "finalize"
-          );
-        }
-      };
-      connection = connectToWebSocket({
-        url,
-        webSocket,
-        abortSignal,
-        onAbort: finishWithError,
-        onProcessingError: finishWithError,
-        onOpen: (socket) => {
-          controller.enqueue({ type: "stream-start", warnings });
-          void sendAudio(socket).catch(finishWithError);
-        },
-        onMessageText: async (text) => {
-          const parsed = await safeParseJSON({ text });
-          if (!parsed.success) return;
-          const raw = parsed.value;
-          if (includeRawChunks) {
-            controller.enqueue({ type: "raw", rawValue: raw });
-          }
-          switch (raw.type) {
-            case "turn.update":
-            case "turn.eager_end": {
-              controller.enqueue({
-                type: "transcript-partial",
-                id: raw.request_id,
-                text: raw.transcript ?? ""
-              });
-              break;
-            }
-            case "turn.end": {
-              const text2 = raw.transcript ?? "";
-              finalTexts.push(text2);
-              controller.enqueue({
-                type: "transcript-final",
-                id: raw.request_id,
-                text: text2
-              });
-              break;
-            }
-            case "transcript": {
-              const transcript = raw.text ?? "";
-              if (raw.is_final === true) {
-                finalTexts.push(transcript);
-                durationInSeconds += raw.duration ?? 0;
-                controller.enqueue({
-                  type: "transcript-final",
-                  id: raw.request_id,
-                  text: transcript
-                });
-              } else {
-                controller.enqueue({
-                  type: "transcript-partial",
-                  id: raw.request_id,
-                  text: transcript,
-                  ...raw.duration != null ? { durationInSeconds: raw.duration } : {}
-                });
-              }
-              break;
-            }
-            case "flush_done": {
-              connection?.socket?.send("close");
-              break;
-            }
-            case "done": {
-              finish();
-              break;
-            }
-            case "error": {
-              finishWithError(
-                new Error(
-                  raw.message ?? raw.error_code ?? "Cartesia streaming transcription error"
-                )
-              );
-              break;
-            }
-          }
-        },
-        onSocketError: () => {
-          finishWithError(new Error("Cartesia streaming transcription error"));
-        },
-        onClose: () => {
-          if (!finished) finish();
-        }
-      });
-    },
-    cancel: () => {
-      if (finished) return;
-      finished = true;
-      cleanup();
-    }
-  });
+function createCartesiaStreamingTranscriptionStream({ webSocket, url, warnings, language, useTurnDetection, audio, abortSignal, includeRawChunks }) {
+	let finished = false;
+	let cleanup = () => {};
+	return new ReadableStream({
+		start: (controller) => {
+			const finalTexts = [];
+			let durationInSeconds = 0;
+			let audioReader;
+			let connection;
+			cleanup = (closeCode) => {
+				if (audioReader != null) audioReader.cancel().catch(() => {});
+				else audio.cancel().catch(() => {});
+				connection?.close(closeCode);
+			};
+			const finishWithError = (error) => {
+				if (finished) return;
+				finished = true;
+				cleanup();
+				controller.error(error);
+			};
+			const finish = () => {
+				if (finished) return;
+				finished = true;
+				controller.enqueue({
+					type: "finish",
+					text: finalTexts.join(useTurnDetection ? " " : ""),
+					segments: [],
+					language,
+					...durationInSeconds > 0 ? { durationInSeconds } : {}
+				});
+				controller.close();
+				cleanup(1e3);
+			};
+			const sendAudio = async (socket) => {
+				audioReader = audio.getReader();
+				try {
+					while (true) {
+						const { done, value } = await audioReader.read();
+						if (done || finished) break;
+						socket.send(value instanceof Uint8Array ? value : convertBase64ToUint8Array(value));
+						await waitForWebSocketBufferDrain(socket);
+					}
+				} finally {
+					audioReader.releaseLock();
+					audioReader = void 0;
+				}
+				if (!finished) socket.send(useTurnDetection ? JSON.stringify({ type: "close" }) : "finalize");
+			};
+			connection = connectToWebSocket({
+				url,
+				webSocket,
+				abortSignal,
+				onAbort: finishWithError,
+				onProcessingError: finishWithError,
+				onOpen: (socket) => {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+					sendAudio(socket).catch(finishWithError);
+				},
+				onMessageText: async (text) => {
+					const parsed = await safeParseJSON({ text });
+					if (!parsed.success) return;
+					const raw = parsed.value;
+					if (includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: raw
+					});
+					switch (raw.type) {
+						case "turn.update":
+						case "turn.eager_end":
+							controller.enqueue({
+								type: "transcript-partial",
+								id: raw.request_id,
+								text: raw.transcript ?? ""
+							});
+							break;
+						case "turn.end": {
+							const text = raw.transcript ?? "";
+							finalTexts.push(text);
+							controller.enqueue({
+								type: "transcript-final",
+								id: raw.request_id,
+								text
+							});
+							break;
+						}
+						case "transcript": {
+							const transcript = raw.text ?? "";
+							if (raw.is_final === true) {
+								finalTexts.push(transcript);
+								durationInSeconds += raw.duration ?? 0;
+								controller.enqueue({
+									type: "transcript-final",
+									id: raw.request_id,
+									text: transcript
+								});
+							} else controller.enqueue({
+								type: "transcript-partial",
+								id: raw.request_id,
+								text: transcript,
+								...raw.duration != null ? { durationInSeconds: raw.duration } : {}
+							});
+							break;
+						}
+						case "flush_done":
+							connection?.socket?.send("close");
+							break;
+						case "done":
+							finish();
+							break;
+						case "error": finishWithError(new Error(raw.message ?? raw.error_code ?? "Cartesia streaming transcription error"));
+					}
+				},
+				onSocketError: () => {
+					finishWithError(/* @__PURE__ */ new Error("Cartesia streaming transcription error"));
+				},
+				onClose: () => {
+					if (!finished) finish();
+				}
+			});
+		},
+		cancel: () => {
+			if (finished) return;
+			finished = true;
+			cleanup();
+		}
+	});
 }
-var G711_STREAMING_ENCODINGS = /* @__PURE__ */ new Set([
-  "pcm_mulaw",
-  "pcm_alaw"
-]);
-var LINEAR_PCM_STREAMING_ENCODINGS = new Set(
-  cartesiaStreamingEncodingSchema.options.filter(
-    (encoding) => !G711_STREAMING_ENCODINGS.has(encoding)
-  )
-);
-function buildCartesiaStreamingTranscriptionUrl({
-  baseURL,
-  version,
-  modelId,
-  encoding,
-  inputAudioFormat,
-  providerOptions,
-  token,
-  useTurnDetection
-}) {
-  const url = toWebSocketUrl(
-    new URL(
-      useTurnDetection ? "/stt/turns/websocket" : "/stt/websocket",
-      baseURL
-    )
-  );
-  url.searchParams.set("model", modelId);
-  url.searchParams.set("encoding", encoding);
-  url.searchParams.set("sample_rate", String(inputAudioFormat.rate ?? 24e3));
-  url.searchParams.set("cartesia_version", version);
-  url.searchParams.set("access_token", token);
-  if (!useTurnDetection && providerOptions?.language != null) {
-    url.searchParams.set("language", providerOptions.language);
-  }
-  return url;
+/** G.711 companding laws — the only non-linear members of the encoding enum. */
+const G711_STREAMING_ENCODINGS = /* @__PURE__ */ new Set(["pcm_mulaw", "pcm_alaw"]);
+/**
+* Linear PCM encodings that legitimately widen generic `audio/pcm` input.
+* Derived from the option enum so a future linear encoding added there is
+* treated as widening-compatible by default; G.711 is a closed set (the
+* standard defines exactly two companding laws), so it is the hardcoded half.
+*/
+const LINEAR_PCM_STREAMING_ENCODINGS = new Set(cartesiaStreamingEncodingSchema.options.filter((encoding) => !G711_STREAMING_ENCODINGS.has(encoding)));
+function buildCartesiaStreamingTranscriptionUrl({ baseURL, version, modelId, encoding, inputAudioFormat, providerOptions, token, useTurnDetection }) {
+	const url = toWebSocketUrl(new URL(useTurnDetection ? "/stt/turns/websocket" : "/stt/websocket", baseURL));
+	url.searchParams.set("model", modelId);
+	url.searchParams.set("encoding", encoding);
+	url.searchParams.set("sample_rate", String(inputAudioFormat.rate ?? 24e3));
+	url.searchParams.set("cartesia_version", version);
+	url.searchParams.set("access_token", token);
+	if (!useTurnDetection && providerOptions?.language != null) url.searchParams.set("language", providerOptions.language);
+	return url;
 }
 function cartesiaEncodingFromInputAudioFormat(type) {
-  switch (type) {
-    case "audio/pcm":
-      return "pcm_s16le";
-    case "audio/pcmu":
-      return "pcm_mulaw";
-    case "audio/pcma":
-      return "pcm_alaw";
-    default:
-      throw new InvalidArgumentError({
-        argument: "inputAudioFormat",
-        message: `Unsupported Cartesia streaming audio format: ${type}`
-      });
-  }
+	switch (type) {
+		case "audio/pcm": return "pcm_s16le";
+		case "audio/pcmu": return "pcm_mulaw";
+		case "audio/pcma": return "pcm_alaw";
+		default: throw new InvalidArgumentError({
+			argument: "inputAudioFormat",
+			message: `Unsupported Cartesia streaming audio format: ${type}`
+		});
+	}
 }
 function isStreamingTranscriptionModelId(modelId) {
-  return modelId === "ink-2" || modelId.startsWith("ink-2-");
+	return modelId === "ink-2" || modelId.startsWith("ink-2-");
 }
-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()
-});
-var cartesiaAccessTokenResponseSchema = z3.object({
-  token: z3.string().min(1)
+const cartesiaTranscriptionResponseSchema = z.object({
+	text: z.string(),
+	language: z.string().nullish(),
+	duration: z.number().nullish(),
+	words: z.array(z.object({
+		word: z.string(),
+		start: z.number(),
+		end: z.number()
+	})).nullish()
 });
-
-// src/cartesia-speech-model.ts
-import {
-  combineHeaders as combineHeaders2,
-  createBinaryResponseHandler,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi as postJsonToApi2,
-  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()
+const cartesiaAccessTokenResponseSchema = z.object({ token: z.string().min(1) });
+//#endregion
+//#region src/cartesia-speech-model-options.ts
+const cartesiaSpeechModelOptionsSchema = z.object({
+	/** Container format for the output audio (raw, wav, mp3). */
+	container: z.enum([
+		"raw",
+		"wav",
+		"mp3"
+	]).nullish(),
+	/** Encoding type for the audio output (pcm_f32le, pcm_s16le, pcm_mulaw, pcm_alaw). */
+	encoding: z.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: z.union([
+		z.literal(8e3),
+		z.literal(16e3),
+		z.literal(22050),
+		z.literal(24e3),
+		z.literal(44100),
+		z.literal(48e3)
+	]).nullish(),
+	/** Bitrate for mp3 output in bits per second (e.g. 32000, 64000, 128000, 192000). */
+	bitRate: z.union([
+		z.literal(32e3),
+		z.literal(64e3),
+		z.literal(96e3),
+		z.literal(128e3),
+		z.literal(192e3)
+	]).nullish(),
+	/** Controls the speed of the generated speech. */
+	speed: z.number().min(.6).max(1.5).nullish(),
+	/** The language to generate speech in (ISO 639-1 code). */
+	language: z.string().nullish()
 });
-
-// src/cartesia-speech-model.ts
-var DEFAULT_OUTPUT_FORMAT = {
-  container: "mp3",
-  sample_rate: 44100,
-  bit_rate: 128e3
+//#endregion
+//#region src/cartesia-speech-model.ts
+const 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 }
+const 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];
+const SAMPLE_RATES = [
+	8e3,
+	16e3,
+	22050,
+	24e3,
+	44100,
+	48e3
+];
 function isSampleRate(value) {
-  return SAMPLE_RATES.includes(value);
+	return SAMPLE_RATES.includes(value);
 }
-function resolveOutputFormat({
-  outputFormat,
-  providerOptions,
-  warnings
-}) {
-  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 = providerOptions?.container ?? resolved.container;
-  const sampleRate = providerOptions?.sampleRate ?? resolved.sample_rate;
-  if (container === "mp3") {
-    if (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: providerOptions?.bitRate ?? (resolved.container === "mp3" ? resolved.bit_rate : 128e3)
-    };
-  }
-  if (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: providerOptions?.encoding ?? (resolved.container === "mp3" ? container === "wav" ? "pcm_s16le" : "pcm_f32le" : resolved.encoding),
-    sample_rate: sampleRate
-  };
+function resolveOutputFormat({ outputFormat, providerOptions, warnings }) {
+	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 = providerOptions?.container ?? resolved.container;
+	const sampleRate = providerOptions?.sampleRate ?? resolved.sample_rate;
+	if (container === "mp3") {
+		if (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: providerOptions?.bitRate ?? (resolved.container === "mp3" ? resolved.bit_rate : 128e3)
+		};
+	}
+	if (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: providerOptions?.encoding ?? (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
-  }) {
-    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 = cartesiaOptions?.speed ?? 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) {
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const { requestBody, warnings } = await this.getArgs(options);
-    const {
-      value: audio,
-      responseHeaders,
-      rawValue: rawResponse
-    } = await postJsonToApi2({
-      url: this.config.url({
-        path: "/tts/bytes",
-        modelId: this.modelId
-      }),
-      headers: combineHeaders2(this.config.headers?.(), 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
-      }
-    };
-  }
+var CartesiaSpeechModel = class CartesiaSpeechModel {
+	get provider() {
+		return this.config.provider;
+	}
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new CartesiaSpeechModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async getArgs({ text, voice, outputFormat = "mp3", instructions, language, speed, providerOptions }) {
+		const warnings = [];
+		const cartesiaOptions = await parseProviderOptions({
+			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 = cartesiaOptions?.speed ?? speed;
+		if (resolvedSpeed != null) {
+			if (resolvedSpeed >= .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) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__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: combineHeaders(this.config.headers?.(), 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";
+//#endregion
+//#region src/cartesia-realtime-model.ts
+/**
+* Realtime Ink model using Cartesia's STT WebSocket APIs.
+*/
 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) {
-    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 = sessionConfig?.inputAudioTranscription?.language;
-    if (language != null && language !== "en") {
-      throw new Error("Cartesia Ink 2 currently supports English only.");
-    }
-    const fetchFn = this.config.fetch ?? 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?.turnDetection;
-    const useTurnDetection = turnDetection === void 0 || turnDetection !== null && turnDetection.type !== "disabled";
-    const inputAudioFormat = 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?.type)
-    );
-    url.searchParams.set(
-      "sample_rate",
-      String(inputAudioFormat?.rate ?? 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(
-          (this.config._internal?.currentDate?.() ?? /* @__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) {
-    const event = raw;
-    const requestId = event.request_id ?? "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: event.transcript ?? "",
-            raw
-          }
-        ];
-        break;
-      case "transcript":
-        if (event.is_final === true) {
-          this.manualTranscript.text += event.text ?? "";
-          this.manualTranscript.duration += event.duration ?? 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: event.message ?? "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) {
-    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: event.request_id ?? "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];
-  }
+	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) {
+		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 = sessionConfig?.inputAudioTranscription?.language;
+		if (language != null && language !== "en") throw new Error("Cartesia Ink 2 currently supports English only.");
+		const response = await (this.config.fetch ?? fetch)(`${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?.turnDetection;
+		const useTurnDetection = turnDetection === void 0 || turnDetection !== null && turnDetection.type !== "disabled";
+		const inputAudioFormat = 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?.type));
+		url.searchParams.set("sample_rate", String(inputAudioFormat?.rate ?? 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((this.config._internal?.currentDate?.() ?? /* @__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) {
+		const event = raw;
+		const requestId = event.request_id ?? "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: event.transcript ?? "",
+					raw
+				}];
+				break;
+			case "transcript":
+				if (event.is_final === true) {
+					this.manualTranscript.text += event.text ?? "";
+					this.manualTranscript.duration += event.duration ?? 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: event.message ?? "Unknown Cartesia realtime error",
+					code: event.error_code,
+					raw
+				};
+				break;
+			default: mapped = {
+				type: "custom",
+				rawType: event.type,
+				raw
+			};
+		}
+		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 convertBase64ToUint8Array(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) {
+		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: event.request_id ?? "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}`);
-  }
+	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.45" : "0.0.0-test";
-
-// src/cartesia-provider.ts
-var CARTESIA_API_VERSION = "2026-03-01";
+//#endregion
+//#region src/version.ts
+const VERSION = "3.0.47";
+//#endregion
+//#region src/cartesia-provider.ts
+/**
+* The Cartesia API version sent with every request via the `Cartesia-Version`
+* header. See https://docs.cartesia.ai/api-reference/api-versioning
+*/
+const CARTESIA_API_VERSION = "2026-03-01";
+/**
+* Create a Cartesia provider instance.
+*/
 function createCartesia(options = {}) {
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      Authorization: `Bearer ${loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "CARTESIA_API_KEY",
-        description: "Cartesia"
-      })}`,
-      "Cartesia-Version": options.version ?? 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,
-    version: options.version ?? CARTESIA_API_VERSION,
-    webSocket: options.webSocket
-  });
-  const createSpeechModel = (modelId) => new CartesiaSpeechModel(modelId, {
-    provider: `cartesia.speech`,
-    url: ({ path }) => `https://api.cartesia.ai${path}`,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const createRealtimeModel = (modelId) => new CartesiaRealtimeModel(modelId, {
-    provider: `cartesia.realtime`,
-    baseURL: "https://api.cartesia.ai",
-    version: options.version ?? 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;
+	const getHeaders = () => withUserAgentSuffix({
+		Authorization: `Bearer ${loadApiKey({
+			apiKey: options.apiKey,
+			environmentVariableName: "CARTESIA_API_KEY",
+			description: "Cartesia"
+		})}`,
+		"Cartesia-Version": options.version ?? 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,
+		version: options.version ?? CARTESIA_API_VERSION,
+		webSocket: options.webSocket
+	});
+	const createSpeechModel = (modelId) => new CartesiaSpeechModel(modelId, {
+		provider: `cartesia.speech`,
+		url: ({ path }) => `https://api.cartesia.ai${path}`,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createRealtimeModel = (modelId) => new CartesiaRealtimeModel(modelId, {
+		provider: `cartesia.realtime`,
+		baseURL: "https://api.cartesia.ai",
+		version: options.version ?? 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
-};
+/**
+* Default Cartesia provider instance.
+*/
+const cartesia = createCartesia();
+//#endregion
+export { CartesiaRealtimeModel, CartesiaSpeechModel, CartesiaTranscriptionModel, VERSION, cartesia, createCartesia };
+
 //# sourceMappingURL=index.js.map