@ai-sdk/elevenlabs 3.0.12 → 3.0.14

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @ai-sdk/elevenlabs
 
+## 3.0.14
+
+### Patch Changes
+
+- 49fd7cd: Add streaming transcription support for ElevenLabs Scribe v2 Realtime through `experimental_streamTranscribe`.
+- Updated dependencies [1e2f324]
+  - @ai-sdk/provider@4.0.4
+  - @ai-sdk/provider-utils@5.0.13
+
+## 3.0.13
+
+### Patch Changes
+
+- Updated dependencies [02ffdcb]
+- Updated dependencies [76cb673]
+  - @ai-sdk/provider-utils@5.0.12
+
 ## 3.0.12
 
 ### Patch Changes

package/README.md

@@ -1,7 +1,7 @@
 # AI SDK - ElevenLabs Provider
 
 The **[ElevenLabs provider](https://ai-sdk.dev/providers/ai-sdk-providers/elevenlabs)** for the [AI SDK](https://ai-sdk.dev/docs)
-contains language model support for the ElevenLabs chat and completion APIs and embedding model support for the ElevenLabs embeddings API.
+contains speech generation plus batch and realtime transcription support for the ElevenLabs APIs.
 
 > **Deploying to Vercel?** With Vercel's AI Gateway you can access ElevenLabs (and hundreds of models from other providers) — no additional packages, API keys, or extra cost. [Get started with AI Gateway](https://vercel.com/ai-gateway).
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _ai_sdk_provider from '@ai-sdk/provider';
-import { TranscriptionModelV4, ProviderV4, SpeechModelV4 } from '@ai-sdk/provider';
-import { FetchFunction, WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@ai-sdk/provider-utils';
+import { TranscriptionModelV4, Experimental_TranscriptionModelV4StreamOptions, ProviderV4, SpeechModelV4 } from '@ai-sdk/provider';
+import { FetchFunction, WebSocketConstructor, WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 type ElevenLabsConfig = {
@@ -12,9 +12,10 @@ type ElevenLabsConfig = {
     headers?: () => Record<string, string | undefined>;
     fetch?: FetchFunction;
     generateId?: () => string;
+    webSocket?: WebSocketConstructor;
 };
 
-type ElevenLabsTranscriptionModelId = 'scribe_v1' | 'scribe_v1_experimental' | 'scribe_v2' | (string & {});
+type ElevenLabsTranscriptionModelId = 'scribe_v1' | 'scribe_v1_experimental' | 'scribe_v2' | 'scribe_v2_realtime' | (string & {});
 
 interface ElevenLabsTranscriptionModelConfig extends ElevenLabsConfig {
     _internal?: {
@@ -37,6 +38,7 @@ declare class ElevenLabsTranscriptionModel implements TranscriptionModelV4 {
     constructor(modelId: ElevenLabsTranscriptionModelId, config: ElevenLabsTranscriptionModelConfig);
     private getArgs;
     doGenerate(options: Parameters<TranscriptionModelV4['doGenerate']>[0]): Promise<Awaited<ReturnType<TranscriptionModelV4['doGenerate']>>>;
+    doStream(options: Experimental_TranscriptionModelV4StreamOptions): Promise<Awaited<ReturnType<NonNullable<TranscriptionModelV4['doStream']>>>>;
 }
 
 type ElevenLabsSpeechModelId = 'eleven_v3' | 'eleven_multilingual_v2' | 'eleven_flash_v2_5' | 'eleven_flash_v2' | 'eleven_turbo_v2_5' | 'eleven_turbo_v2' | 'eleven_monolingual_v1' | 'eleven_multilingual_v1' | (string & {});
@@ -73,6 +75,11 @@ interface ElevenLabsProviderSettings {
      * or to provide a custom fetch implementation for e.g. testing.
      */
     fetch?: FetchFunction;
+    /**
+     * Custom WebSocket implementation. Required in runtimes whose native
+     * WebSocket constructor does not support headers for realtime transcription.
+     */
+    webSocket?: WebSocketConstructor;
 }
 /**
  * Create an ElevenLabs provider instance.
@@ -124,6 +131,24 @@ declare const elevenLabsTranscriptionModelOptionsSchema: z.ZodObject<{
         pcm_s16le_16: "pcm_s16le_16";
         other: "other";
     }>>>>;
+    streaming: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        commitStrategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            manual: "manual";
+            vad: "vad";
+        }>>>;
+        enableLogging: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        filterBackgroundAudio: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        includeLanguageDetection: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        includeTimestamps: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        keyterms: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        minSilenceDurationMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        minSpeechDurationMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        noVerbatim: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        previousText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        secondaryLanguages: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        vadSilenceThresholdSecs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        vadThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 type ElevenLabsTranscriptionModelOptions = z.infer<typeof elevenLabsTranscriptionModelOptionsSchema>;
 

package/dist/index.js

@@ -8,14 +8,23 @@ import {
 } 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";
@@ -43,10 +52,49 @@ var elevenLabsTranscriptionModelOptionsSchema = z2.object({
   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")
+  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()
 });
 
 // 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"
+]);
+var elevenLabsLateFinalizationErrorTypes = /* @__PURE__ */ new Set([
+  "commit_throttled",
+  "input_error",
+  "insufficient_audio_activity"
+]);
+var finalCommitGracePeriodMs = 250;
+function isRealtimeTranscriptionModelId(modelId) {
+  return modelId === "scribe_v2_realtime";
+}
 var ElevenLabsTranscriptionModel = class _ElevenLabsTranscriptionModel {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -77,6 +125,13 @@ var ElevenLabsTranscriptionModel = class _ElevenLabsTranscriptionModel {
       providerOptions,
       schema: elevenLabsTranscriptionModelOptionsSchema
     });
+    if ((elevenlabsOptions == null ? void 0 : 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);
@@ -112,6 +167,11 @@ var ElevenLabsTranscriptionModel = class _ElevenLabsTranscriptionModel {
   }
   async doGenerate(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    if (isRealtimeTranscriptionModelId(this.modelId)) {
+      throw new UnsupportedFunctionalityError({
+        functionality: `non-streaming transcription with ${this.modelId}`
+      });
+    }
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
     const { formData, warnings } = await this.getArgs(options);
     const {
@@ -153,7 +213,385 @@ var ElevenLabsTranscriptionModel = class _ElevenLabsTranscriptionModel {
       }
     };
   }
+  async doStream(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    if (!isRealtimeTranscriptionModelId(this.modelId)) {
+      throw new UnsupportedFunctionalityError({
+        functionality: `streaming transcription with ${this.modelId}`
+      });
+    }
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const elevenLabsOptions = await parseProviderOptions({
+      provider: "elevenlabs",
+      providerOptions: options.providerOptions,
+      schema: elevenLabsTranscriptionModelOptionsSchema
+    });
+    const streamingOptions = (_d = elevenLabsOptions == null ? void 0 : elevenLabsOptions.streaming) != null ? _d : void 0;
+    const warnings = [];
+    const rawElevenLabsOptions = (_f = (_e = options.providerOptions) == null ? void 0 : _e.elevenlabs) != null ? _f : {};
+    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 == null ? void 0 : 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: (_g = elevenLabsOptions == null ? void 0 : elevenLabsOptions.languageCode) != null ? _g : 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((_i = (_h = this.config).headers) == null ? void 0 : _i.call(_h), options.headers),
+        includeLanguageDetection: (streamingOptions == null ? void 0 : streamingOptions.includeLanguageDetection) === true,
+        includeRawChunks: options.includeRawChunks,
+        includeTimestamps: (streamingOptions == null ? void 0 : streamingOptions.includeTimestamps) === true,
+        language: (_j = elevenLabsOptions == null ? void 0 : elevenLabsOptions.languageCode) != null ? _j : void 0,
+        previousText: (_k = streamingOptions == null ? void 0 : streamingOptions.previousText) != null ? _k : 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 != null ? 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
+}) {
+  var _a, _b;
+  const url = new URL(baseUrl);
+  url.searchParams.set("model_id", modelId);
+  url.searchParams.set("audio_format", inputFormat);
+  const includeDetailedCommit = (streamingOptions == null ? void 0 : streamingOptions.includeTimestamps) === true || (streamingOptions == null ? void 0 : streamingOptions.includeLanguageDetection) === true;
+  const parameters = {
+    commit_strategy: streamingOptions == null ? void 0 : streamingOptions.commitStrategy,
+    enable_logging: streamingOptions == null ? void 0 : streamingOptions.enableLogging,
+    filter_background_audio: streamingOptions == null ? void 0 : streamingOptions.filterBackgroundAudio,
+    include_language_detection: streamingOptions == null ? void 0 : streamingOptions.includeLanguageDetection,
+    include_timestamps: includeDetailedCommit ? true : streamingOptions == null ? void 0 : streamingOptions.includeTimestamps,
+    language_code: languageCode,
+    min_silence_duration_ms: streamingOptions == null ? void 0 : streamingOptions.minSilenceDurationMs,
+    min_speech_duration_ms: streamingOptions == null ? void 0 : streamingOptions.minSpeechDurationMs,
+    no_verbatim: streamingOptions == null ? void 0 : streamingOptions.noVerbatim,
+    vad_silence_threshold_secs: streamingOptions == null ? void 0 : streamingOptions.vadSilenceThresholdSecs,
+    vad_threshold: streamingOptions == null ? void 0 : streamingOptions.vadThreshold
+  };
+  for (const [key, value] of Object.entries(parameters)) {
+    if (value != null) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  for (const keyterm of (_a = streamingOptions == null ? void 0 : streamingOptions.keyterms) != null ? _a : []) {
+    url.searchParams.append("keyterms", keyterm);
+  }
+  for (const secondaryLanguage of (_b = streamingOptions == null ? void 0 : streamingOptions.secondaryLanguages) != null ? _b : []) {
+    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 == null ? void 0 : connection.close(closeCode);
+      };
+      const finishWithError = (error) => {
+        if (finished) return;
+        finished = true;
+        cleanup();
+        controller.error(error);
+      };
+      const finish = () => {
+        var _a;
+        if (finished) return;
+        finished = true;
+        controller.enqueue({
+          type: "finish",
+          text: finalTexts.join(" ").trim(),
+          segments: finalSegments,
+          language: detectedLanguage,
+          durationInSeconds: (_a = finalSegments.at(-1)) == null ? void 0 : _a.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) => {
+          var _a, _b, _c, _d, _e, _f, _g, _h;
+          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((_a = raw.error) != null ? _a : "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 == null ? void 0 : 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 != null ? sessionId : "session"}:${segmentIndex}`,
+                text: (_b = raw.text) != null ? _b : ""
+              });
+              break;
+            }
+            case "final_transcript":
+            case "committed_transcript": {
+              committedEventCount++;
+              const text2 = ((_c = raw.text) != null ? _c : "").trim();
+              const id = `${sessionId != null ? 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 = ((_d = raw.text) != null ? _d : "").trim();
+              const words = (_e = raw.words) != null ? _e : [];
+              const timestampedWords = words.filter(
+                (word) => typeof word.start === "number" && typeof word.end === "number"
+              );
+              detectedLanguage = (_f = raw.language_code) != null ? _f : detectedLanguage;
+              if (finalTexts[timestampedCommitCount] == null && text2.length > 0) {
+                const id = `${sessionId != null ? sessionId : "session"}:${segmentIndex++}`;
+                finalTexts.push(text2);
+                controller.enqueue({
+                  type: "transcript-final",
+                  id,
+                  text: text2,
+                  ...includeTimestamps ? {
+                    startSecond: (_g = timestampedWords[0]) == null ? void 0 : _g.start,
+                    endSecond: (_h = timestampedWords.at(-1)) == null ? void 0 : _h.end
+                  } : {}
+                });
+              }
+              timestampedCommitCount++;
+              if (includeTimestamps) {
+                finalSegments.push(
+                  ...timestampedWords.map((word) => {
+                    var _a2;
+                    return {
+                      text: (_a2 = word.text) != null ? _a2 : "",
+                      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();
+    }
+  });
+}
 var elevenlabsTranscriptionResponseSchema = z3.object({
   language_code: z3.string(),
   language_probability: z3.number(),
@@ -384,7 +822,7 @@ var ElevenLabsSpeechModel = class _ElevenLabsSpeechModel {
 };
 
 // src/version.ts
-var VERSION = true ? "3.0.12" : "0.0.0-test";
+var VERSION = true ? "3.0.14" : "0.0.0-test";
 
 // src/elevenlabs-provider.ts
 function createElevenLabs(options = {}) {
@@ -403,7 +841,8 @@ function createElevenLabs(options = {}) {
     provider: `elevenlabs.transcription`,
     url: ({ path }) => `https://api.elevenlabs.io${path}`,
     headers: getHeaders,
-    fetch: options.fetch
+    fetch: options.fetch,
+    webSocket: options.webSocket
   });
   const createSpeechModel = (modelId) => new ElevenLabsSpeechModel(modelId, {
     provider: `elevenlabs.speech`,