@ai-sdk/elevenlabs 3.0.51 → 3.0.53

package/dist/index.js

@@ -1,881 +1,703 @@
-// src/elevenlabs-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
-import {
-  loadApiKey,
-  withUserAgentSuffix
-} from "@ai-sdk/provider-utils";
-
-// src/elevenlabs-transcription-model.ts
-import {
-  InvalidArgumentError,
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders,
-  convertBase64ToUint8Array,
-  convertToBase64,
-  connectToWebSocket,
-  createJsonResponseHandler,
-  mediaTypeToExtension,
-  parseProviderOptions,
-  postFormDataToApi,
-  safeParseJSON,
-  serializeModelOptions,
-  toWebSocketUrl,
-  waitForWebSocketBufferDrain,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE
-} from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
-
-// src/elevenlabs-error.ts
+import { InvalidArgumentError, NoSuchModelError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertBase64ToUint8Array, convertToBase64, 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 elevenlabsErrorDataSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    code: z.number()
-  })
-});
-var elevenlabsFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: elevenlabsErrorDataSchema,
-  errorToMessage: (data) => data.error.message
+//#region src/elevenlabs-error.ts
+const elevenlabsErrorDataSchema = z.object({ error: z.object({
+	message: z.string(),
+	code: z.number()
+}) });
+const elevenlabsFailedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema: elevenlabsErrorDataSchema,
+	errorToMessage: (data) => data.error.message
 });
-
-// src/elevenlabs-transcription-model-options.ts
-import { z as z2 } from "zod/v4";
-var elevenLabsTranscriptionModelOptionsSchema = z2.object({
-  languageCode: z2.string().nullish(),
-  tagAudioEvents: z2.boolean().nullish().default(true),
-  numSpeakers: z2.number().int().min(1).max(32).nullish(),
-  timestampsGranularity: z2.enum(["none", "word", "character"]).nullish().default("word"),
-  diarize: z2.boolean().nullish().default(false),
-  fileFormat: z2.enum(["pcm_s16le_16", "other"]).nullish().default("other"),
-  streaming: z2.object({
-    commitStrategy: z2.enum(["manual", "vad"]).nullish(),
-    enableLogging: z2.boolean().nullish(),
-    filterBackgroundAudio: z2.boolean().nullish(),
-    includeLanguageDetection: z2.boolean().nullish(),
-    includeTimestamps: z2.boolean().nullish(),
-    keyterms: z2.array(z2.string().max(20)).max(50).nullish(),
-    minSilenceDurationMs: z2.number().int().min(50).max(2e3).nullish(),
-    minSpeechDurationMs: z2.number().int().min(50).max(2e3).nullish(),
-    noVerbatim: z2.boolean().nullish(),
-    previousText: z2.string().nullish(),
-    secondaryLanguages: z2.array(z2.string()).nullish(),
-    vadSilenceThresholdSecs: z2.number().min(0.3).max(3).nullish(),
-    vadThreshold: z2.number().min(0.1).max(0.9).nullish()
-  }).nullish()
+//#endregion
+//#region src/elevenlabs-transcription-model-options.ts
+const elevenLabsTranscriptionModelOptionsSchema = z.object({
+	languageCode: z.string().nullish(),
+	tagAudioEvents: z.boolean().nullish().default(true),
+	numSpeakers: z.number().int().min(1).max(32).nullish(),
+	timestampsGranularity: z.enum([
+		"none",
+		"word",
+		"character"
+	]).nullish().default("word"),
+	diarize: z.boolean().nullish().default(false),
+	fileFormat: z.enum(["pcm_s16le_16", "other"]).nullish().default("other"),
+	streaming: z.object({
+		commitStrategy: z.enum(["manual", "vad"]).nullish(),
+		enableLogging: z.boolean().nullish(),
+		filterBackgroundAudio: z.boolean().nullish(),
+		includeLanguageDetection: z.boolean().nullish(),
+		includeTimestamps: z.boolean().nullish(),
+		keyterms: z.array(z.string().max(20)).max(50).nullish(),
+		minSilenceDurationMs: z.number().int().min(50).max(2e3).nullish(),
+		minSpeechDurationMs: z.number().int().min(50).max(2e3).nullish(),
+		noVerbatim: z.boolean().nullish(),
+		previousText: z.string().nullish(),
+		secondaryLanguages: z.array(z.string()).nullish(),
+		vadSilenceThresholdSecs: z.number().min(.3).max(3).nullish(),
+		vadThreshold: z.number().min(.1).max(.9).nullish()
+	}).nullish()
 });
-
-// src/elevenlabs-transcription-model.ts
-var elevenLabsRealtimeErrorTypes = /* @__PURE__ */ new Set([
-  "auth_error",
-  "chunk_size_exceeded",
-  "commit_throttled",
-  "error",
-  "input_error",
-  "insufficient_audio_activity",
-  "queue_overflow",
-  "quota_exceeded",
-  "rate_limited",
-  "resource_exhausted",
-  "session_time_limit_exceeded",
-  "transcriber_error",
-  "unaccepted_terms"
+//#endregion
+//#region src/elevenlabs-transcription-model.ts
+const elevenLabsRealtimeErrorTypes = /* @__PURE__ */ new Set([
+	"auth_error",
+	"chunk_size_exceeded",
+	"commit_throttled",
+	"error",
+	"input_error",
+	"insufficient_audio_activity",
+	"queue_overflow",
+	"quota_exceeded",
+	"rate_limited",
+	"resource_exhausted",
+	"session_time_limit_exceeded",
+	"transcriber_error",
+	"unaccepted_terms"
 ]);
-var elevenLabsLateFinalizationErrorTypes = /* @__PURE__ */ new Set([
-  "commit_throttled",
-  "input_error",
-  "insufficient_audio_activity"
+const elevenLabsLateFinalizationErrorTypes = /* @__PURE__ */ new Set([
+	"commit_throttled",
+	"input_error",
+	"insufficient_audio_activity"
 ]);
-var finalCommitGracePeriodMs = 250;
+const finalCommitGracePeriodMs = 250;
 function isRealtimeTranscriptionModelId(modelId) {
-  return modelId === "scribe_v2_realtime";
+	return modelId === "scribe_v2_realtime";
 }
-var ElevenLabsTranscriptionModel = class _ElevenLabsTranscriptionModel {
-  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 _ElevenLabsTranscriptionModel(options.modelId, options.config);
-  }
-  async getArgs({
-    audio,
-    mediaType,
-    providerOptions
-  }) {
-    const warnings = [];
-    const elevenlabsOptions = await parseProviderOptions({
-      provider: "elevenlabs",
-      providerOptions,
-      schema: elevenLabsTranscriptionModelOptionsSchema
-    });
-    if (elevenlabsOptions?.streaming != null) {
-      warnings.push({
-        type: "unsupported",
-        feature: "providerOptions.elevenlabs.streaming",
-        details: "ElevenLabs batch transcription does not support streaming options."
-      });
-    }
-    const formData = new FormData();
-    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
-    formData.append("model_id", this.modelId);
-    const fileExtension = mediaTypeToExtension(mediaType);
-    formData.append(
-      "file",
-      new File([blob], "audio", { type: mediaType }),
-      `audio.${fileExtension}`
-    );
-    formData.append("diarize", "true");
-    if (elevenlabsOptions) {
-      const transcriptionModelOptions = {
-        language_code: elevenlabsOptions.languageCode ?? void 0,
-        tag_audio_events: elevenlabsOptions.tagAudioEvents ?? void 0,
-        num_speakers: elevenlabsOptions.numSpeakers ?? void 0,
-        timestamps_granularity: elevenlabsOptions.timestampsGranularity ?? void 0,
-        file_format: elevenlabsOptions.fileFormat ?? void 0
-      };
-      if (typeof elevenlabsOptions.diarize === "boolean") {
-        formData.append("diarize", String(elevenlabsOptions.diarize));
-      }
-      for (const key in transcriptionModelOptions) {
-        const value = transcriptionModelOptions[key];
-        if (value !== void 0) {
-          formData.append(key, String(value));
-        }
-      }
-    }
-    return {
-      formData,
-      warnings
-    };
-  }
-  async doGenerate(options) {
-    if (isRealtimeTranscriptionModelId(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: "/v1/speech-to-text",
-        modelId: this.modelId
-      }),
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      formData,
-      failedResponseHandler: elevenlabsFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        elevenlabsTranscriptionResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      text: response.text,
-      segments: response.words?.map((word) => ({
-        text: word.text,
-        startSecond: word.start ?? 0,
-        endSecond: word.end ?? 0
-      })) ?? [],
-      language: response.language_code,
-      durationInSeconds: response.words?.at(-1)?.end ?? void 0,
-      warnings,
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId,
-        headers: responseHeaders,
-        body: rawResponse
-      }
-    };
-  }
-  async doStream(options) {
-    if (!isRealtimeTranscriptionModelId(this.modelId)) {
-      throw new UnsupportedFunctionalityError({
-        functionality: `streaming transcription with ${this.modelId}`
-      });
-    }
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const elevenLabsOptions = await parseProviderOptions({
-      provider: "elevenlabs",
-      providerOptions: options.providerOptions,
-      schema: elevenLabsTranscriptionModelOptionsSchema
-    });
-    const streamingOptions = elevenLabsOptions?.streaming ?? void 0;
-    const warnings = [];
-    const rawElevenLabsOptions = options.providerOptions?.elevenlabs ?? {};
-    for (const option of [
-      "diarize",
-      "fileFormat",
-      "numSpeakers",
-      "tagAudioEvents",
-      "timestampsGranularity"
-    ]) {
-      if (rawElevenLabsOptions[option] != null) {
-        warnings.push({
-          type: "unsupported",
-          feature: `providerOptions.elevenlabs.${option}`,
-          details: `ElevenLabs realtime transcription does not support ${option}.`
-        });
-      }
-    }
-    if (streamingOptions?.filterBackgroundAudio === true && (streamingOptions.includeTimestamps === true || streamingOptions.includeLanguageDetection === true)) {
-      throw new InvalidArgumentError({
-        argument: "providerOptions",
-        message: "providerOptions.elevenlabs.streaming.filterBackgroundAudio cannot be combined with includeTimestamps or includeLanguageDetection"
-      });
-    }
-    const inputFormat = getElevenLabsRealtimeAudioFormat(
-      options.inputAudioFormat
-    );
-    const url = buildElevenLabsRealtimeTranscriptionUrl({
-      baseUrl: toWebSocketUrl(
-        this.config.url({
-          path: "/v1/speech-to-text/realtime",
-          modelId: this.modelId
-        })
-      ),
-      inputFormat: inputFormat.audioFormat,
-      languageCode: elevenLabsOptions?.languageCode ?? void 0,
-      modelId: this.modelId,
-      streamingOptions
-    });
-    return {
-      request: { body: url.toString() },
-      response: {
-        timestamp: currentDate,
-        modelId: this.modelId
-      },
-      stream: createElevenLabsRealtimeTranscriptionStream({
-        abortSignal: options.abortSignal,
-        audio: options.audio,
-        headers: combineHeaders(this.config.headers?.(), options.headers),
-        includeLanguageDetection: streamingOptions?.includeLanguageDetection === true,
-        includeRawChunks: options.includeRawChunks,
-        includeTimestamps: streamingOptions?.includeTimestamps === true,
-        language: elevenLabsOptions?.languageCode ?? void 0,
-        previousText: streamingOptions?.previousText ?? void 0,
-        sampleRate: inputFormat.sampleRate,
-        url,
-        warnings,
-        webSocket: this.config.webSocket
-      })
-    };
-  }
+var ElevenLabsTranscriptionModel = class ElevenLabsTranscriptionModel {
+	get provider() {
+		return this.config.provider;
+	}
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new ElevenLabsTranscriptionModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async getArgs({ audio, mediaType, providerOptions }) {
+		const warnings = [];
+		const elevenlabsOptions = await parseProviderOptions({
+			provider: "elevenlabs",
+			providerOptions,
+			schema: elevenLabsTranscriptionModelOptionsSchema
+		});
+		if (elevenlabsOptions?.streaming != null) warnings.push({
+			type: "unsupported",
+			feature: "providerOptions.elevenlabs.streaming",
+			details: "ElevenLabs batch transcription does not support streaming options."
+		});
+		const formData = new FormData();
+		const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
+		formData.append("model_id", this.modelId);
+		const fileExtension = mediaTypeToExtension(mediaType);
+		formData.append("file", new File([blob], "audio", { type: mediaType }), `audio.${fileExtension}`);
+		formData.append("diarize", "true");
+		if (elevenlabsOptions) {
+			const transcriptionModelOptions = {
+				language_code: elevenlabsOptions.languageCode ?? void 0,
+				tag_audio_events: elevenlabsOptions.tagAudioEvents ?? void 0,
+				num_speakers: elevenlabsOptions.numSpeakers ?? void 0,
+				timestamps_granularity: elevenlabsOptions.timestampsGranularity ?? void 0,
+				file_format: elevenlabsOptions.fileFormat ?? void 0
+			};
+			if (typeof elevenlabsOptions.diarize === "boolean") formData.append("diarize", String(elevenlabsOptions.diarize));
+			for (const key in transcriptionModelOptions) {
+				const value = transcriptionModelOptions[key];
+				if (value !== void 0) formData.append(key, String(value));
+			}
+		}
+		return {
+			formData,
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		if (isRealtimeTranscriptionModelId(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: "/v1/speech-to-text",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			formData,
+			failedResponseHandler: elevenlabsFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(elevenlabsTranscriptionResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			text: response.text,
+			segments: response.words?.map((word) => ({
+				text: word.text,
+				startSecond: word.start ?? 0,
+				endSecond: word.end ?? 0
+			})) ?? [],
+			language: response.language_code,
+			durationInSeconds: response.words?.at(-1)?.end ?? void 0,
+			warnings,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			}
+		};
+	}
+	async doStream(options) {
+		if (!isRealtimeTranscriptionModelId(this.modelId)) throw new UnsupportedFunctionalityError({ functionality: `streaming transcription with ${this.modelId}` });
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const elevenLabsOptions = await parseProviderOptions({
+			provider: "elevenlabs",
+			providerOptions: options.providerOptions,
+			schema: elevenLabsTranscriptionModelOptionsSchema
+		});
+		const streamingOptions = elevenLabsOptions?.streaming ?? void 0;
+		const warnings = [];
+		const rawElevenLabsOptions = options.providerOptions?.elevenlabs ?? {};
+		for (const option of [
+			"diarize",
+			"fileFormat",
+			"numSpeakers",
+			"tagAudioEvents",
+			"timestampsGranularity"
+		]) if (rawElevenLabsOptions[option] != null) warnings.push({
+			type: "unsupported",
+			feature: `providerOptions.elevenlabs.${option}`,
+			details: `ElevenLabs realtime transcription does not support ${option}.`
+		});
+		if (streamingOptions?.filterBackgroundAudio === true && (streamingOptions.includeTimestamps === true || streamingOptions.includeLanguageDetection === true)) throw new InvalidArgumentError({
+			argument: "providerOptions",
+			message: "providerOptions.elevenlabs.streaming.filterBackgroundAudio cannot be combined with includeTimestamps or includeLanguageDetection"
+		});
+		const inputFormat = getElevenLabsRealtimeAudioFormat(options.inputAudioFormat);
+		const url = buildElevenLabsRealtimeTranscriptionUrl({
+			baseUrl: toWebSocketUrl(this.config.url({
+				path: "/v1/speech-to-text/realtime",
+				modelId: this.modelId
+			})),
+			inputFormat: inputFormat.audioFormat,
+			languageCode: elevenLabsOptions?.languageCode ?? void 0,
+			modelId: this.modelId,
+			streamingOptions
+		});
+		return {
+			request: { body: url.toString() },
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId
+			},
+			stream: createElevenLabsRealtimeTranscriptionStream({
+				abortSignal: options.abortSignal,
+				audio: options.audio,
+				headers: combineHeaders(this.config.headers?.(), options.headers),
+				includeLanguageDetection: streamingOptions?.includeLanguageDetection === true,
+				includeRawChunks: options.includeRawChunks,
+				includeTimestamps: streamingOptions?.includeTimestamps === true,
+				language: elevenLabsOptions?.languageCode ?? void 0,
+				previousText: streamingOptions?.previousText ?? void 0,
+				sampleRate: inputFormat.sampleRate,
+				url,
+				warnings,
+				webSocket: this.config.webSocket
+			})
+		};
+	}
 };
 function getElevenLabsRealtimeAudioFormat(inputAudioFormat) {
-  const type = inputAudioFormat.type.toLowerCase();
-  const rate = inputAudioFormat.rate;
-  if (type === "audio/pcmu") {
-    if (rate != null && rate !== 8e3) {
-      throw new InvalidArgumentError({
-        argument: "inputAudioFormat",
-        message: "ElevenLabs only supports audio/pcmu at 8000 Hz"
-      });
-    }
-    return { audioFormat: "ulaw_8000", sampleRate: 8e3 };
-  }
-  const supportedPcmRates = [8e3, 16e3, 22050, 24e3, 44100, 48e3];
-  const pcmRate = rate ?? 16e3;
-  if (type !== "audio/pcm" || !supportedPcmRates.includes(pcmRate)) {
-    throw new InvalidArgumentError({
-      argument: "inputAudioFormat",
-      message: "ElevenLabs realtime transcription supports audio/pcm at 8000, 16000, 22050, 24000, 44100, or 48000 Hz, and audio/pcmu at 8000 Hz"
-    });
-  }
-  return { audioFormat: `pcm_${pcmRate}`, sampleRate: pcmRate };
+	const type = inputAudioFormat.type.toLowerCase();
+	const rate = inputAudioFormat.rate;
+	if (type === "audio/pcmu") {
+		if (rate != null && rate !== 8e3) throw new InvalidArgumentError({
+			argument: "inputAudioFormat",
+			message: "ElevenLabs only supports audio/pcmu at 8000 Hz"
+		});
+		return {
+			audioFormat: "ulaw_8000",
+			sampleRate: 8e3
+		};
+	}
+	const supportedPcmRates = [
+		8e3,
+		16e3,
+		22050,
+		24e3,
+		44100,
+		48e3
+	];
+	const pcmRate = rate ?? 16e3;
+	if (type !== "audio/pcm" || !supportedPcmRates.includes(pcmRate)) throw new InvalidArgumentError({
+		argument: "inputAudioFormat",
+		message: "ElevenLabs realtime transcription supports audio/pcm at 8000, 16000, 22050, 24000, 44100, or 48000 Hz, and audio/pcmu at 8000 Hz"
+	});
+	return {
+		audioFormat: `pcm_${pcmRate}`,
+		sampleRate: pcmRate
+	};
 }
-function buildElevenLabsRealtimeTranscriptionUrl({
-  baseUrl,
-  inputFormat,
-  languageCode,
-  modelId,
-  streamingOptions
-}) {
-  const url = new URL(baseUrl);
-  url.searchParams.set("model_id", modelId);
-  url.searchParams.set("audio_format", inputFormat);
-  const includeDetailedCommit = streamingOptions?.includeTimestamps === true || streamingOptions?.includeLanguageDetection === true;
-  const parameters = {
-    commit_strategy: streamingOptions?.commitStrategy,
-    enable_logging: streamingOptions?.enableLogging,
-    filter_background_audio: streamingOptions?.filterBackgroundAudio,
-    include_language_detection: streamingOptions?.includeLanguageDetection,
-    include_timestamps: includeDetailedCommit ? true : streamingOptions?.includeTimestamps,
-    language_code: languageCode,
-    min_silence_duration_ms: streamingOptions?.minSilenceDurationMs,
-    min_speech_duration_ms: streamingOptions?.minSpeechDurationMs,
-    no_verbatim: streamingOptions?.noVerbatim,
-    vad_silence_threshold_secs: streamingOptions?.vadSilenceThresholdSecs,
-    vad_threshold: streamingOptions?.vadThreshold
-  };
-  for (const [key, value] of Object.entries(parameters)) {
-    if (value != null) {
-      url.searchParams.set(key, String(value));
-    }
-  }
-  for (const keyterm of streamingOptions?.keyterms ?? []) {
-    url.searchParams.append("keyterms", keyterm);
-  }
-  for (const secondaryLanguage of streamingOptions?.secondaryLanguages ?? []) {
-    url.searchParams.append("secondary_languages", secondaryLanguage);
-  }
-  return url;
+function buildElevenLabsRealtimeTranscriptionUrl({ baseUrl, inputFormat, languageCode, modelId, streamingOptions }) {
+	const url = new URL(baseUrl);
+	url.searchParams.set("model_id", modelId);
+	url.searchParams.set("audio_format", inputFormat);
+	const includeDetailedCommit = streamingOptions?.includeTimestamps === true || streamingOptions?.includeLanguageDetection === true;
+	const parameters = {
+		commit_strategy: streamingOptions?.commitStrategy,
+		enable_logging: streamingOptions?.enableLogging,
+		filter_background_audio: streamingOptions?.filterBackgroundAudio,
+		include_language_detection: streamingOptions?.includeLanguageDetection,
+		include_timestamps: includeDetailedCommit ? true : streamingOptions?.includeTimestamps,
+		language_code: languageCode,
+		min_silence_duration_ms: streamingOptions?.minSilenceDurationMs,
+		min_speech_duration_ms: streamingOptions?.minSpeechDurationMs,
+		no_verbatim: streamingOptions?.noVerbatim,
+		vad_silence_threshold_secs: streamingOptions?.vadSilenceThresholdSecs,
+		vad_threshold: streamingOptions?.vadThreshold
+	};
+	for (const [key, value] of Object.entries(parameters)) if (value != null) url.searchParams.set(key, String(value));
+	for (const keyterm of streamingOptions?.keyterms ?? []) url.searchParams.append("keyterms", keyterm);
+	for (const secondaryLanguage of streamingOptions?.secondaryLanguages ?? []) url.searchParams.append("secondary_languages", secondaryLanguage);
+	return url;
 }
-function createElevenLabsRealtimeTranscriptionStream({
-  abortSignal,
-  audio,
-  headers,
-  includeLanguageDetection,
-  includeRawChunks,
-  includeTimestamps,
-  language,
-  previousText,
-  sampleRate,
-  url,
-  warnings,
-  webSocket
-}) {
-  let finished = false;
-  let cleanup = () => {
-  };
-  return new ReadableStream({
-    start: (controller) => {
-      let audioReader;
-      let connection;
-      let detectedLanguage = language;
-      let endOfInput = false;
-      let finalCommitGracePeriod;
-      let receivedPostInputCommit = false;
-      let segmentIndex = 0;
-      let sessionId;
-      let committedEventCount = 0;
-      let committedEventsAtEndOfInput = 0;
-      let finalCommitEventCount;
-      let timestampedCommitCount = 0;
-      const expectDetailedCommit = includeTimestamps || includeLanguageDetection;
-      const finalSegments = [];
-      const finalTexts = [];
-      cleanup = (closeCode) => {
-        clearTimeout(finalCommitGracePeriod);
-        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(" ").trim(),
-          segments: finalSegments,
-          language: detectedLanguage,
-          durationInSeconds: finalSegments.at(-1)?.endSecond
-        });
-        controller.close();
-        cleanup(1e3);
-      };
-      const scheduleFinish = () => {
-        clearTimeout(finalCommitGracePeriod);
-        finalCommitGracePeriod = setTimeout(finish, finalCommitGracePeriodMs);
-      };
-      const sendAudio = async (socket) => {
-        audioReader = audio.getReader();
-        let firstChunk = true;
-        try {
-          while (true) {
-            const { done, value } = await audioReader.read();
-            if (done || finished) break;
-            socket.send(
-              JSON.stringify({
-                message_type: "input_audio_chunk",
-                audio_base_64: convertToBase64(value),
-                commit: false,
-                sample_rate: sampleRate,
-                ...firstChunk && previousText != null ? { previous_text: previousText } : {}
-              })
-            );
-            firstChunk = false;
-            await waitForWebSocketBufferDrain(socket);
-          }
-        } finally {
-          audioReader.releaseLock();
-          audioReader = void 0;
-        }
-        if (!finished) {
-          committedEventsAtEndOfInput = committedEventCount;
-          endOfInput = true;
-          socket.send(
-            JSON.stringify({
-              message_type: "input_audio_chunk",
-              audio_base_64: "",
-              commit: true,
-              sample_rate: sampleRate
-            })
-          );
-        }
-      };
-      connection = connectToWebSocket({
-        abortSignal,
-        headers,
-        onAbort: finishWithError,
-        onClose: () => {
-          if (finished) return;
-          if (endOfInput && receivedPostInputCommit) {
-            finish();
-            return;
-          }
-          finishWithError(
-            new Error(
-              "ElevenLabs realtime transcription stream closed before completion."
-            )
-          );
-        },
-        onMessageText: async (text) => {
-          const parsed = await safeParseJSON({ text });
-          if (!parsed.success) return;
-          const raw = parsed.value;
-          if (includeRawChunks) {
-            controller.enqueue({ type: "raw", rawValue: raw });
-          }
-          if (raw.message_type != null && elevenLabsRealtimeErrorTypes.has(raw.message_type)) {
-            if (endOfInput && (committedEventCount > 0 || timestampedCommitCount > 0) && elevenLabsLateFinalizationErrorTypes.has(raw.message_type)) {
-              receivedPostInputCommit = true;
-              finish();
-              return;
-            }
-            finishWithError(
-              new Error(raw.error ?? "ElevenLabs realtime transcription error")
-            );
-            return;
-          }
-          switch (raw.message_type) {
-            case "session_started": {
-              sessionId = raw.session_id;
-              controller.enqueue({ type: "stream-start", warnings });
-              const socket = connection?.socket;
-              if (socket == null) {
-                finishWithError(new Error("WebSocket is not connected."));
-                break;
-              }
-              void sendAudio(socket).catch(finishWithError);
-              break;
-            }
-            case "partial_transcript": {
-              controller.enqueue({
-                type: "transcript-partial",
-                id: `${sessionId ?? "session"}:${segmentIndex}`,
-                text: raw.text ?? ""
-              });
-              break;
-            }
-            case "final_transcript":
-            case "committed_transcript": {
-              committedEventCount++;
-              const text2 = (raw.text ?? "").trim();
-              const id = `${sessionId ?? "session"}:${segmentIndex}`;
-              if (text2.length > 0) {
-                finalTexts.push(text2);
-                segmentIndex++;
-                controller.enqueue({
-                  type: "transcript-final",
-                  id,
-                  text: text2
-                });
-              }
-              if (endOfInput && committedEventCount > committedEventsAtEndOfInput) {
-                receivedPostInputCommit = true;
-                finalCommitEventCount = committedEventCount;
-                if (!expectDetailedCommit || raw.message_type === "final_transcript") {
-                  scheduleFinish();
-                }
-              }
-              break;
-            }
-            case "final_transcript_with_timestamps":
-            case "committed_transcript_with_timestamps": {
-              const text2 = (raw.text ?? "").trim();
-              const words = raw.words ?? [];
-              const timestampedWords = words.filter(
-                (word) => typeof word.start === "number" && typeof word.end === "number"
-              );
-              detectedLanguage = raw.language_code ?? detectedLanguage;
-              if (finalTexts[timestampedCommitCount] == null && text2.length > 0) {
-                const id = `${sessionId ?? "session"}:${segmentIndex++}`;
-                finalTexts.push(text2);
-                controller.enqueue({
-                  type: "transcript-final",
-                  id,
-                  text: text2,
-                  ...includeTimestamps ? {
-                    startSecond: timestampedWords[0]?.start,
-                    endSecond: timestampedWords.at(-1)?.end
-                  } : {}
-                });
-              }
-              timestampedCommitCount++;
-              if (includeTimestamps) {
-                finalSegments.push(
-                  ...timestampedWords.map((word) => ({
-                    text: word.text ?? "",
-                    startSecond: word.start,
-                    endSecond: word.end
-                  }))
-                );
-              }
-              if (endOfInput && timestampedCommitCount > committedEventsAtEndOfInput && (finalCommitEventCount == null || timestampedCommitCount >= finalCommitEventCount)) {
-                receivedPostInputCommit = true;
-                scheduleFinish();
-              }
-              break;
-            }
-          }
-        },
-        onProcessingError: finishWithError,
-        onSocketError: () => {
-          finishWithError(
-            new Error(
-              "ElevenLabs realtime transcription error." + (webSocket == null ? " Note: the native WebSocket implementation in browsers, Node.js, Deno, and Bun cannot send the xi-api-key header required by ElevenLabs. Pass a header-capable WebSocket implementation (e.g. the 'ws' package) via createElevenLabs({ webSocket })." : "")
-            )
-          );
-        },
-        url,
-        webSocket
-      });
-    },
-    cancel: () => {
-      if (finished) return;
-      finished = true;
-      cleanup();
-    }
-  });
+function createElevenLabsRealtimeTranscriptionStream({ abortSignal, audio, headers, includeLanguageDetection, includeRawChunks, includeTimestamps, language, previousText, sampleRate, url, warnings, webSocket }) {
+	let finished = false;
+	let cleanup = () => {};
+	return new ReadableStream({
+		start: (controller) => {
+			let audioReader;
+			let connection;
+			let detectedLanguage = language;
+			let endOfInput = false;
+			let finalCommitGracePeriod;
+			let receivedPostInputCommit = false;
+			let segmentIndex = 0;
+			let sessionId;
+			let committedEventCount = 0;
+			let committedEventsAtEndOfInput = 0;
+			let finalCommitEventCount;
+			let timestampedCommitCount = 0;
+			const expectDetailedCommit = includeTimestamps || includeLanguageDetection;
+			const finalSegments = [];
+			const finalTexts = [];
+			cleanup = (closeCode) => {
+				clearTimeout(finalCommitGracePeriod);
+				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(" ").trim(),
+					segments: finalSegments,
+					language: detectedLanguage,
+					durationInSeconds: finalSegments.at(-1)?.endSecond
+				});
+				controller.close();
+				cleanup(1e3);
+			};
+			const scheduleFinish = () => {
+				clearTimeout(finalCommitGracePeriod);
+				finalCommitGracePeriod = setTimeout(finish, finalCommitGracePeriodMs);
+			};
+			const sendAudio = async (socket) => {
+				audioReader = audio.getReader();
+				let firstChunk = true;
+				try {
+					while (true) {
+						const { done, value } = await audioReader.read();
+						if (done || finished) break;
+						socket.send(JSON.stringify({
+							message_type: "input_audio_chunk",
+							audio_base_64: convertToBase64(value),
+							commit: false,
+							sample_rate: sampleRate,
+							...firstChunk && previousText != null ? { previous_text: previousText } : {}
+						}));
+						firstChunk = false;
+						await waitForWebSocketBufferDrain(socket);
+					}
+				} finally {
+					audioReader.releaseLock();
+					audioReader = void 0;
+				}
+				if (!finished) {
+					committedEventsAtEndOfInput = committedEventCount;
+					endOfInput = true;
+					socket.send(JSON.stringify({
+						message_type: "input_audio_chunk",
+						audio_base_64: "",
+						commit: true,
+						sample_rate: sampleRate
+					}));
+				}
+			};
+			connection = connectToWebSocket({
+				abortSignal,
+				headers,
+				onAbort: finishWithError,
+				onClose: () => {
+					if (finished) return;
+					if (endOfInput && receivedPostInputCommit) {
+						finish();
+						return;
+					}
+					finishWithError(/* @__PURE__ */ new Error("ElevenLabs realtime transcription stream closed before completion."));
+				},
+				onMessageText: async (text) => {
+					const parsed = await safeParseJSON({ text });
+					if (!parsed.success) return;
+					const raw = parsed.value;
+					if (includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: raw
+					});
+					if (raw.message_type != null && elevenLabsRealtimeErrorTypes.has(raw.message_type)) {
+						if (endOfInput && (committedEventCount > 0 || timestampedCommitCount > 0) && elevenLabsLateFinalizationErrorTypes.has(raw.message_type)) {
+							receivedPostInputCommit = true;
+							finish();
+							return;
+						}
+						finishWithError(new Error(raw.error ?? "ElevenLabs realtime transcription error"));
+						return;
+					}
+					switch (raw.message_type) {
+						case "session_started": {
+							sessionId = raw.session_id;
+							controller.enqueue({
+								type: "stream-start",
+								warnings
+							});
+							const socket = connection?.socket;
+							if (socket == null) {
+								finishWithError(/* @__PURE__ */ new Error("WebSocket is not connected."));
+								break;
+							}
+							sendAudio(socket).catch(finishWithError);
+							break;
+						}
+						case "partial_transcript":
+							controller.enqueue({
+								type: "transcript-partial",
+								id: `${sessionId ?? "session"}:${segmentIndex}`,
+								text: raw.text ?? ""
+							});
+							break;
+						case "final_transcript":
+						case "committed_transcript": {
+							committedEventCount++;
+							const text = (raw.text ?? "").trim();
+							const id = `${sessionId ?? "session"}:${segmentIndex}`;
+							if (text.length > 0) {
+								finalTexts.push(text);
+								segmentIndex++;
+								controller.enqueue({
+									type: "transcript-final",
+									id,
+									text
+								});
+							}
+							if (endOfInput && committedEventCount > committedEventsAtEndOfInput) {
+								receivedPostInputCommit = true;
+								finalCommitEventCount = committedEventCount;
+								if (!expectDetailedCommit || raw.message_type === "final_transcript") scheduleFinish();
+							}
+							break;
+						}
+						case "final_transcript_with_timestamps":
+						case "committed_transcript_with_timestamps": {
+							const text = (raw.text ?? "").trim();
+							const timestampedWords = (raw.words ?? []).filter((word) => typeof word.start === "number" && typeof word.end === "number");
+							detectedLanguage = raw.language_code ?? detectedLanguage;
+							if (finalTexts[timestampedCommitCount] == null && text.length > 0) {
+								const id = `${sessionId ?? "session"}:${segmentIndex++}`;
+								finalTexts.push(text);
+								controller.enqueue({
+									type: "transcript-final",
+									id,
+									text,
+									...includeTimestamps ? {
+										startSecond: timestampedWords[0]?.start,
+										endSecond: timestampedWords.at(-1)?.end
+									} : {}
+								});
+							}
+							timestampedCommitCount++;
+							if (includeTimestamps) finalSegments.push(...timestampedWords.map((word) => ({
+								text: word.text ?? "",
+								startSecond: word.start,
+								endSecond: word.end
+							})));
+							if (endOfInput && timestampedCommitCount > committedEventsAtEndOfInput && (finalCommitEventCount == null || timestampedCommitCount >= finalCommitEventCount)) {
+								receivedPostInputCommit = true;
+								scheduleFinish();
+							}
+							break;
+						}
+					}
+				},
+				onProcessingError: finishWithError,
+				onSocketError: () => {
+					finishWithError(/* @__PURE__ */ new Error("ElevenLabs realtime transcription error." + (webSocket == null ? " Note: the native WebSocket implementation in browsers, Node.js, Deno, and Bun cannot send the xi-api-key header required by ElevenLabs. Pass a header-capable WebSocket implementation (e.g. the 'ws' package) via createElevenLabs({ webSocket })." : "")));
+				},
+				url,
+				webSocket
+			});
+		},
+		cancel: () => {
+			if (finished) return;
+			finished = true;
+			cleanup();
+		}
+	});
 }
-var elevenlabsTranscriptionResponseSchema = z3.object({
-  language_code: z3.string(),
-  language_probability: z3.number(),
-  text: z3.string(),
-  words: z3.array(
-    z3.object({
-      text: z3.string(),
-      type: z3.enum(["word", "spacing", "audio_event"]),
-      start: z3.number().nullish(),
-      end: z3.number().nullish(),
-      speaker_id: z3.string().nullish(),
-      characters: z3.array(
-        z3.object({
-          text: z3.string(),
-          start: z3.number().nullish(),
-          end: z3.number().nullish()
-        })
-      ).nullish()
-    })
-  ).nullish()
+const elevenlabsTranscriptionResponseSchema = z.object({
+	language_code: z.string(),
+	language_probability: z.number(),
+	text: z.string(),
+	words: z.array(z.object({
+		text: z.string(),
+		type: z.enum([
+			"word",
+			"spacing",
+			"audio_event"
+		]),
+		start: z.number().nullish(),
+		end: z.number().nullish(),
+		speaker_id: z.string().nullish(),
+		characters: z.array(z.object({
+			text: z.string(),
+			start: z.number().nullish(),
+			end: z.number().nullish()
+		})).nullish()
+	})).nullish()
 });
-
-// src/elevenlabs-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/elevenlabs-speech-model-options.ts
-import { z as z4 } from "zod/v4";
-var elevenLabsSpeechModelOptionsSchema = z4.object({
-  languageCode: z4.string().optional(),
-  voiceSettings: z4.object({
-    stability: z4.number().min(0).max(1).optional(),
-    similarityBoost: z4.number().min(0).max(1).optional(),
-    style: z4.number().min(0).max(1).optional(),
-    useSpeakerBoost: z4.boolean().optional()
-  }).optional(),
-  pronunciationDictionaryLocators: z4.array(
-    z4.object({
-      pronunciationDictionaryId: z4.string(),
-      versionId: z4.string().optional()
-    })
-  ).max(3).optional(),
-  seed: z4.number().min(0).max(4294967295).optional(),
-  previousText: z4.string().optional(),
-  nextText: z4.string().optional(),
-  previousRequestIds: z4.array(z4.string()).max(3).optional(),
-  nextRequestIds: z4.array(z4.string()).max(3).optional(),
-  applyTextNormalization: z4.enum(["auto", "on", "off"]).optional(),
-  applyLanguageTextNormalization: z4.boolean().optional(),
-  enableLogging: z4.boolean().optional()
+//#endregion
+//#region src/elevenlabs-speech-model-options.ts
+const elevenLabsSpeechModelOptionsSchema = z.object({
+	languageCode: z.string().optional(),
+	voiceSettings: z.object({
+		stability: z.number().min(0).max(1).optional(),
+		similarityBoost: z.number().min(0).max(1).optional(),
+		style: z.number().min(0).max(1).optional(),
+		useSpeakerBoost: z.boolean().optional()
+	}).optional(),
+	pronunciationDictionaryLocators: z.array(z.object({
+		pronunciationDictionaryId: z.string(),
+		versionId: z.string().optional()
+	})).max(3).optional(),
+	seed: z.number().min(0).max(4294967295).optional(),
+	previousText: z.string().optional(),
+	nextText: z.string().optional(),
+	previousRequestIds: z.array(z.string()).max(3).optional(),
+	nextRequestIds: z.array(z.string()).max(3).optional(),
+	applyTextNormalization: z.enum([
+		"auto",
+		"on",
+		"off"
+	]).optional(),
+	applyLanguageTextNormalization: z.boolean().optional(),
+	enableLogging: z.boolean().optional()
 });
-
-// src/elevenlabs-speech-model.ts
-var ElevenLabsSpeechModel = class _ElevenLabsSpeechModel {
-  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 _ElevenLabsSpeechModel(options.modelId, options.config);
-  }
-  async getArgs({
-    text,
-    voice = "21m00Tcm4TlvDq8ikWAM",
-    outputFormat = "mp3_44100_128",
-    instructions,
-    language,
-    speed,
-    providerOptions
-  }) {
-    const warnings = [];
-    const elevenLabsOptions = await parseProviderOptions2({
-      provider: "elevenlabs",
-      providerOptions,
-      schema: elevenLabsSpeechModelOptionsSchema
-    });
-    const requestBody = {
-      text,
-      model_id: this.modelId
-    };
-    const queryParams = {};
-    if (outputFormat) {
-      const formatMap = {
-        mp3: "mp3_44100_128",
-        mp3_32: "mp3_44100_32",
-        mp3_64: "mp3_44100_64",
-        mp3_96: "mp3_44100_96",
-        mp3_128: "mp3_44100_128",
-        mp3_192: "mp3_44100_192",
-        pcm: "pcm_44100",
-        pcm_16000: "pcm_16000",
-        pcm_22050: "pcm_22050",
-        pcm_24000: "pcm_24000",
-        pcm_44100: "pcm_44100",
-        ulaw: "ulaw_8000"
-      };
-      const mappedFormat = formatMap[outputFormat] || outputFormat;
-      queryParams.output_format = mappedFormat;
-    }
-    if (language) {
-      requestBody.language_code = language;
-    }
-    const voiceSettings = {};
-    if (speed != null) {
-      voiceSettings.speed = speed;
-    }
-    if (elevenLabsOptions) {
-      if (elevenLabsOptions.voiceSettings) {
-        if (elevenLabsOptions.voiceSettings.stability != null) {
-          voiceSettings.stability = elevenLabsOptions.voiceSettings.stability;
-        }
-        if (elevenLabsOptions.voiceSettings.similarityBoost != null) {
-          voiceSettings.similarity_boost = elevenLabsOptions.voiceSettings.similarityBoost;
-        }
-        if (elevenLabsOptions.voiceSettings.style != null) {
-          voiceSettings.style = elevenLabsOptions.voiceSettings.style;
-        }
-        if (elevenLabsOptions.voiceSettings.useSpeakerBoost != null) {
-          voiceSettings.use_speaker_boost = elevenLabsOptions.voiceSettings.useSpeakerBoost;
-        }
-      }
-      if (elevenLabsOptions.languageCode && !requestBody.language_code) {
-        requestBody.language_code = elevenLabsOptions.languageCode;
-      }
-      if (elevenLabsOptions.pronunciationDictionaryLocators) {
-        requestBody.pronunciation_dictionary_locators = elevenLabsOptions.pronunciationDictionaryLocators.map((locator) => ({
-          pronunciation_dictionary_id: locator.pronunciationDictionaryId,
-          ...locator.versionId && { version_id: locator.versionId }
-        }));
-      }
-      if (elevenLabsOptions.seed != null) {
-        requestBody.seed = elevenLabsOptions.seed;
-      }
-      if (elevenLabsOptions.previousText) {
-        requestBody.previous_text = elevenLabsOptions.previousText;
-      }
-      if (elevenLabsOptions.nextText) {
-        requestBody.next_text = elevenLabsOptions.nextText;
-      }
-      if (elevenLabsOptions.previousRequestIds) {
-        requestBody.previous_request_ids = elevenLabsOptions.previousRequestIds;
-      }
-      if (elevenLabsOptions.nextRequestIds) {
-        requestBody.next_request_ids = elevenLabsOptions.nextRequestIds;
-      }
-      if (elevenLabsOptions.applyTextNormalization) {
-        requestBody.apply_text_normalization = elevenLabsOptions.applyTextNormalization;
-      }
-      if (elevenLabsOptions.applyLanguageTextNormalization != null) {
-        requestBody.apply_language_text_normalization = elevenLabsOptions.applyLanguageTextNormalization;
-      }
-      if (elevenLabsOptions.enableLogging != null) {
-        queryParams.enable_logging = String(elevenLabsOptions.enableLogging);
-      }
-    }
-    if (Object.keys(voiceSettings).length > 0) {
-      requestBody.voice_settings = voiceSettings;
-    }
-    if (instructions) {
-      warnings.push({
-        type: "unsupported",
-        feature: "instructions",
-        details: `ElevenLabs speech models do not support instructions. Instructions parameter was ignored.`
-      });
-    }
-    return {
-      requestBody,
-      queryParams,
-      warnings,
-      voiceId: voice
-    };
-  }
-  async doGenerate(options) {
-    const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
-    const { requestBody, queryParams, warnings, voiceId } = await this.getArgs(options);
-    const {
-      value: audio,
-      responseHeaders,
-      rawValue: rawResponse
-    } = await postJsonToApi({
-      url: (() => {
-        const baseUrl = this.config.url({
-          path: `/v1/text-to-speech/${voiceId}`,
-          modelId: this.modelId
-        });
-        const queryString = new URLSearchParams(queryParams).toString();
-        return queryString ? `${baseUrl}?${queryString}` : baseUrl;
-      })(),
-      headers: combineHeaders2(this.config.headers?.(), options.headers),
-      body: requestBody,
-      failedResponseHandler: elevenlabsFailedResponseHandler,
-      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
-      }
-    };
-  }
+//#endregion
+//#region src/elevenlabs-speech-model.ts
+var ElevenLabsSpeechModel = class ElevenLabsSpeechModel {
+	get provider() {
+		return this.config.provider;
+	}
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new ElevenLabsSpeechModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+	}
+	async getArgs({ text, voice = "21m00Tcm4TlvDq8ikWAM", outputFormat = "mp3_44100_128", instructions, language, speed, providerOptions }) {
+		const warnings = [];
+		const elevenLabsOptions = await parseProviderOptions({
+			provider: "elevenlabs",
+			providerOptions,
+			schema: elevenLabsSpeechModelOptionsSchema
+		});
+		const requestBody = {
+			text,
+			model_id: this.modelId
+		};
+		const queryParams = {};
+		if (outputFormat) queryParams.output_format = {
+			mp3: "mp3_44100_128",
+			mp3_32: "mp3_44100_32",
+			mp3_64: "mp3_44100_64",
+			mp3_96: "mp3_44100_96",
+			mp3_128: "mp3_44100_128",
+			mp3_192: "mp3_44100_192",
+			pcm: "pcm_44100",
+			pcm_16000: "pcm_16000",
+			pcm_22050: "pcm_22050",
+			pcm_24000: "pcm_24000",
+			pcm_44100: "pcm_44100",
+			ulaw: "ulaw_8000"
+		}[outputFormat] || outputFormat;
+		if (language) requestBody.language_code = language;
+		const voiceSettings = {};
+		if (speed != null) voiceSettings.speed = speed;
+		if (elevenLabsOptions) {
+			if (elevenLabsOptions.voiceSettings) {
+				if (elevenLabsOptions.voiceSettings.stability != null) voiceSettings.stability = elevenLabsOptions.voiceSettings.stability;
+				if (elevenLabsOptions.voiceSettings.similarityBoost != null) voiceSettings.similarity_boost = elevenLabsOptions.voiceSettings.similarityBoost;
+				if (elevenLabsOptions.voiceSettings.style != null) voiceSettings.style = elevenLabsOptions.voiceSettings.style;
+				if (elevenLabsOptions.voiceSettings.useSpeakerBoost != null) voiceSettings.use_speaker_boost = elevenLabsOptions.voiceSettings.useSpeakerBoost;
+			}
+			if (elevenLabsOptions.languageCode && !requestBody.language_code) requestBody.language_code = elevenLabsOptions.languageCode;
+			if (elevenLabsOptions.pronunciationDictionaryLocators) requestBody.pronunciation_dictionary_locators = elevenLabsOptions.pronunciationDictionaryLocators.map((locator) => ({
+				pronunciation_dictionary_id: locator.pronunciationDictionaryId,
+				...locator.versionId && { version_id: locator.versionId }
+			}));
+			if (elevenLabsOptions.seed != null) requestBody.seed = elevenLabsOptions.seed;
+			if (elevenLabsOptions.previousText) requestBody.previous_text = elevenLabsOptions.previousText;
+			if (elevenLabsOptions.nextText) requestBody.next_text = elevenLabsOptions.nextText;
+			if (elevenLabsOptions.previousRequestIds) requestBody.previous_request_ids = elevenLabsOptions.previousRequestIds;
+			if (elevenLabsOptions.nextRequestIds) requestBody.next_request_ids = elevenLabsOptions.nextRequestIds;
+			if (elevenLabsOptions.applyTextNormalization) requestBody.apply_text_normalization = elevenLabsOptions.applyTextNormalization;
+			if (elevenLabsOptions.applyLanguageTextNormalization != null) requestBody.apply_language_text_normalization = elevenLabsOptions.applyLanguageTextNormalization;
+			if (elevenLabsOptions.enableLogging != null) queryParams.enable_logging = String(elevenLabsOptions.enableLogging);
+		}
+		if (Object.keys(voiceSettings).length > 0) requestBody.voice_settings = voiceSettings;
+		if (instructions) warnings.push({
+			type: "unsupported",
+			feature: "instructions",
+			details: `ElevenLabs speech models do not support instructions. Instructions parameter was ignored.`
+		});
+		return {
+			requestBody,
+			queryParams,
+			warnings,
+			voiceId: voice
+		};
+	}
+	async doGenerate(options) {
+		const currentDate = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date();
+		const { requestBody, queryParams, warnings, voiceId } = await this.getArgs(options);
+		const { value: audio, responseHeaders, rawValue: rawResponse } = await postJsonToApi({
+			url: (() => {
+				const baseUrl = this.config.url({
+					path: `/v1/text-to-speech/${voiceId}`,
+					modelId: this.modelId
+				});
+				const queryString = new URLSearchParams(queryParams).toString();
+				return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+			})(),
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body: requestBody,
+			failedResponseHandler: elevenlabsFailedResponseHandler,
+			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.51" : "0.0.0-test";
-
-// src/elevenlabs-provider.ts
+//#endregion
+//#region src/version.ts
+const VERSION = "3.0.53";
+//#endregion
+//#region src/elevenlabs-provider.ts
+/**
+* Create an ElevenLabs provider instance.
+*/
 function createElevenLabs(options = {}) {
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      "xi-api-key": loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "ELEVENLABS_API_KEY",
-        description: "ElevenLabs"
-      }),
-      ...options.headers
-    },
-    `ai-sdk/elevenlabs/${VERSION}`
-  );
-  const createTranscriptionModel = (modelId) => new ElevenLabsTranscriptionModel(modelId, {
-    provider: `elevenlabs.transcription`,
-    url: ({ path }) => `https://api.elevenlabs.io${path}`,
-    headers: getHeaders,
-    fetch: options.fetch,
-    webSocket: options.webSocket
-  });
-  const createSpeechModel = (modelId) => new ElevenLabsSpeechModel(modelId, {
-    provider: `elevenlabs.speech`,
-    url: ({ path }) => `https://api.elevenlabs.io${path}`,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const provider = function(modelId) {
-    return {
-      transcription: createTranscriptionModel(modelId)
-    };
-  };
-  provider.specificationVersion = "v4";
-  provider.transcription = createTranscriptionModel;
-  provider.transcriptionModel = createTranscriptionModel;
-  provider.speech = createSpeechModel;
-  provider.speechModel = createSpeechModel;
-  provider.languageModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "languageModel",
-      message: "ElevenLabs does not provide language models"
-    });
-  };
-  provider.embeddingModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "embeddingModel",
-      message: "ElevenLabs does not provide embedding models"
-    });
-  };
-  provider.textEmbeddingModel = provider.embeddingModel;
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "imageModel",
-      message: "ElevenLabs does not provide image models"
-    });
-  };
-  return provider;
+	const getHeaders = () => withUserAgentSuffix({
+		"xi-api-key": loadApiKey({
+			apiKey: options.apiKey,
+			environmentVariableName: "ELEVENLABS_API_KEY",
+			description: "ElevenLabs"
+		}),
+		...options.headers
+	}, `ai-sdk-elevenlabs/${VERSION}`);
+	const createTranscriptionModel = (modelId) => new ElevenLabsTranscriptionModel(modelId, {
+		provider: `elevenlabs.transcription`,
+		url: ({ path }) => `https://api.elevenlabs.io${path}`,
+		headers: getHeaders,
+		fetch: options.fetch,
+		webSocket: options.webSocket
+	});
+	const createSpeechModel = (modelId) => new ElevenLabsSpeechModel(modelId, {
+		provider: `elevenlabs.speech`,
+		url: ({ path }) => `https://api.elevenlabs.io${path}`,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const provider = function(modelId) {
+		return { transcription: createTranscriptionModel(modelId) };
+	};
+	provider.specificationVersion = "v4";
+	provider.transcription = createTranscriptionModel;
+	provider.transcriptionModel = createTranscriptionModel;
+	provider.speech = createSpeechModel;
+	provider.speechModel = createSpeechModel;
+	provider.languageModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "languageModel",
+			message: "ElevenLabs does not provide language models"
+		});
+	};
+	provider.embeddingModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "embeddingModel",
+			message: "ElevenLabs does not provide embedding models"
+		});
+	};
+	provider.textEmbeddingModel = provider.embeddingModel;
+	provider.imageModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "imageModel",
+			message: "ElevenLabs does not provide image models"
+		});
+	};
+	return provider;
 }
-var elevenLabs = createElevenLabs();
-export {
-  VERSION,
-  createElevenLabs,
-  elevenLabs,
-  elevenLabs as elevenlabs
-};
+/**
+* Default ElevenLabs provider instance.
+*/
+const elevenLabs = createElevenLabs();
+//#endregion
+export { VERSION, createElevenLabs, elevenLabs, elevenLabs as elevenlabs };
+
 //# sourceMappingURL=index.js.map