@elevenlabs/elevenlabs-js 2.19.0 → 2.20.1

package/dist/wrapper/realtime/connection.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeConnection = exports.RealtimeEvents = void 0;
+const ws_1 = __importDefault(require("ws"));
+const node_events_1 = require("node:events");
+/**
+ * Events emitted by the RealtimeConnection.
+ */
+var RealtimeEvents;
+(function (RealtimeEvents) {
+    /** Emitted when the session is successfully started */
+    RealtimeEvents["SESSION_STARTED"] = "session_started";
+    /** Emitted when a partial (interim) transcript is available */
+    RealtimeEvents["PARTIAL_TRANSCRIPT"] = "partial_transcript";
+    /** Emitted when a final transcript is available */
+    RealtimeEvents["FINAL_TRANSCRIPT"] = "final_transcript";
+    /** Emitted when a final transcript with timestamps is available */
+    RealtimeEvents["FINAL_TRANSCRIPT_WITH_TIMESTAMPS"] = "final_transcript_with_timestamps";
+    /** Emitted when an error occurs */
+    RealtimeEvents["ERROR"] = "error";
+    /** Emitted when the WebSocket connection is opened */
+    RealtimeEvents["OPEN"] = "open";
+    /** Emitted when the WebSocket connection is closed */
+    RealtimeEvents["CLOSE"] = "close";
+})(RealtimeEvents || (exports.RealtimeEvents = RealtimeEvents = {}));
+/**
+ * Manages a real-time transcription WebSocket connection.
+ *
+ * @remarks
+ * **Node.js only**: This class uses Node.js-specific WebSocket implementation.
+ *
+ * @example
+ * ```typescript
+ * const connection = await client.speechToText.realtime.connect({
+ *     modelId: "scribe_realtime_v2",
+ *     audioFormat: AudioFormat.PCM_16000,
+ *     sampleRate: 16000,
+ * });
+ *
+ * connection.on(RealtimeEvents.SESSION_STARTED, (data) => {
+ *     console.log("Session started");
+ * });
+ *
+ * connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
+ *     console.log("Partial:", data.transcript);
+ * });
+ *
+ * connection.on(RealtimeEvents.FINAL_TRANSCRIPT, (data) => {
+ *     console.log("Final:", data.transcript);
+ *     connection.close();
+ * });
+ *
+ * // Send audio data
+ * connection.send({ audioBase64: base64String });
+ *
+ * // Commit and close
+ * connection.commit();
+  * ```
+ */
+class RealtimeConnection {
+    constructor(sampleRate) {
+        this.websocket = null;
+        this.eventEmitter = new node_events_1.EventEmitter();
+        this.ffmpegProcess = null;
+        this.currentSampleRate = 16000;
+        this.currentSampleRate = sampleRate;
+    }
+    /**
+     * @internal
+     * Used internally by ScribeRealtime to attach the WebSocket after connection is created.
+     */
+    setWebSocket(websocket) {
+        this.websocket = websocket;
+        // If WebSocket is already open, emit OPEN event immediately
+        if (this.websocket.readyState === ws_1.default.OPEN) {
+            this.eventEmitter.emit(RealtimeEvents.OPEN);
+        }
+        else {
+            // Otherwise, wait for the open event
+            this.websocket.on("open", () => {
+                this.eventEmitter.emit(RealtimeEvents.OPEN);
+            });
+        }
+        this.websocket.on("message", (event) => {
+            const data = JSON.parse(event.toString());
+            switch (data.message_type) {
+                case "session_started":
+                    this.eventEmitter.emit(RealtimeEvents.SESSION_STARTED, data);
+                    break;
+                case "partial_transcript":
+                    this.eventEmitter.emit(RealtimeEvents.PARTIAL_TRANSCRIPT, data);
+                    break;
+                case "final_transcript":
+                    this.eventEmitter.emit(RealtimeEvents.FINAL_TRANSCRIPT, data);
+                    break;
+                case "final_transcript_with_timestamps":
+                    this.eventEmitter.emit(RealtimeEvents.FINAL_TRANSCRIPT_WITH_TIMESTAMPS, data);
+                    break;
+            }
+        });
+        this.websocket.on("error", (error) => {
+            this.eventEmitter.emit(RealtimeEvents.ERROR, error);
+        });
+        this.websocket.on("close", () => {
+            this.eventEmitter.emit(RealtimeEvents.CLOSE);
+            this.cleanup();
+        });
+    }
+    /**
+     * @internal
+     * Used internally by ScribeRealtime to attach ffmpeg process for cleanup.
+     */
+    setFfmpegProcess(ffmpegProcess) {
+        this.ffmpegProcess = ffmpegProcess;
+    }
+    /**
+     * Attaches an event listener for the specified event.
+     *
+     * @param event - The event to listen for (use RealtimeEvents enum)
+     * @param listener - The callback function to execute when the event fires
+     *
+     * @example
+     * ```typescript
+     * connection.on(RealtimeEvents.SESSION_STARTED, (data) => {
+     *     console.log("Session started", data);
+     * });
+     *
+     * connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
+     *     console.log("Partial:", data.transcript);
+     * });
+     *
+     * connection.on(RealtimeEvents.FINAL_TRANSCRIPT, (data) => {
+     *     console.log("Final:", data.transcript);
+     * });
+     * ```
+     */
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    /**
+     * Removes an event listener for the specified event.
+     *
+     * @param event - The event to stop listening for
+     * @param listener - The callback function to remove
+     *
+     * @example
+     * ```typescript
+     * const handler = (data) => console.log(data);
+     * connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, handler);
+     *
+     * // Later, remove the listener
+     * connection.off(RealtimeEvents.PARTIAL_TRANSCRIPT, handler);
+     * ```
+     */
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    /**
+     * Sends audio data to the transcription service.
+     *
+     * @param data - Audio data configuration
+     * @param data.audioBase64 - Base64-encoded audio data
+     * @param data.commit - Whether to commit the transcription after this chunk. You likely want to use connection.commit() instead (default: false)
+     * @param data.sampleRate - Sample rate of the audio (default: configured sample rate)
+     *
+     * @throws {Error} If the WebSocket connection is not open
+     *
+     * @example
+     * ```typescript
+     * // Send audio chunk without committing
+     * connection.send({
+     *     audioBase64: base64EncodedAudio,
+     * });
+     *
+     * // Send audio chunk with custom sample rate
+     * connection.send({
+     *     audioBase64: base64EncodedAudio,
+     *     sampleRate: 16000,
+     * });
+     * ```
+     */
+    send(data) {
+        var _a, _b;
+        if (!this.websocket || this.websocket.readyState !== ws_1.default.OPEN) {
+            throw new Error("WebSocket is not connected");
+        }
+        const message = {
+            message_type: "input_audio_chunk",
+            audio_base_64: data.audioBase64,
+            commit: (_a = data.commit) !== null && _a !== void 0 ? _a : false,
+            sample_rate: (_b = data.sampleRate) !== null && _b !== void 0 ? _b : this.currentSampleRate,
+        };
+        this.websocket.send(JSON.stringify(message));
+    }
+    /**
+     * Commits the transcription, signaling that all audio has been sent.
+     * This finalizes the transcription and triggers a FINAL_TRANSCRIPT event.
+     *
+     * @throws {Error} If the WebSocket connection is not open
+     *
+     * @remarks
+     * Only needed when using CommitStrategy.MANUAL.
+     * When using CommitStrategy.VAD, commits are handled automatically by the server.
+     *
+     * @example
+     * ```typescript
+     * // Send all audio chunks
+     * for (const chunk of audioChunks) {
+     *     connection.send({ audioBase64: chunk });
+     * }
+     *
+     * // Finalize the transcription
+     * connection.commit();
+     * ```
+     */
+    commit() {
+        if (!this.websocket || this.websocket.readyState !== ws_1.default.OPEN) {
+            throw new Error("WebSocket is not connected");
+        }
+        const message = {
+            message_type: "input_audio_chunk",
+            audio_base_64: "",
+            commit: true,
+            sample_rate: this.currentSampleRate,
+        };
+        this.websocket.send(JSON.stringify(message));
+    }
+    /**
+     * Closes the WebSocket connection and cleans up resources.
+     * This will terminate any ongoing transcription and stop ffmpeg processes if running.
+     *
+     * @remarks
+     * After calling close(), this connection cannot be reused.
+     * Create a new connection if you need to start transcribing again.
+     *
+     * @example
+     * ```typescript
+     * connection.on(RealtimeEvents.FINAL_TRANSCRIPT, (data) => {
+     *     console.log("Final:", data.transcript);
+     *     connection.close();
+     * });
+     * ```
+     */
+    close() {
+        this.cleanup();
+        if (this.websocket) {
+            this.websocket.close();
+        }
+    }
+    cleanup() {
+        if (this.ffmpegProcess) {
+            this.ffmpegProcess.kill();
+            this.ffmpegProcess = null;
+        }
+    }
+}
+exports.RealtimeConnection = RealtimeConnection;

package/dist/wrapper/realtime/index.d.ts

@@ -0,0 +1,2 @@
+export { RealtimeConnection, RealtimeEvents } from "./connection";
+export { ScribeRealtime, AudioFormat, CommitStrategy, type AudioOptions, type UrlOptions } from "./scribe";

package/dist/wrapper/realtime/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommitStrategy = exports.AudioFormat = exports.ScribeRealtime = exports.RealtimeEvents = exports.RealtimeConnection = void 0;
+var connection_1 = require("./connection");
+Object.defineProperty(exports, "RealtimeConnection", { enumerable: true, get: function () { return connection_1.RealtimeConnection; } });
+Object.defineProperty(exports, "RealtimeEvents", { enumerable: true, get: function () { return connection_1.RealtimeEvents; } });
+var scribe_1 = require("./scribe");
+Object.defineProperty(exports, "ScribeRealtime", { enumerable: true, get: function () { return scribe_1.ScribeRealtime; } });
+Object.defineProperty(exports, "AudioFormat", { enumerable: true, get: function () { return scribe_1.AudioFormat; } });
+Object.defineProperty(exports, "CommitStrategy", { enumerable: true, get: function () { return scribe_1.CommitStrategy; } });

package/dist/wrapper/realtime/scribe.d.ts

@@ -0,0 +1,112 @@
+import type { SpeechToText } from "../../api/resources/speechToText/client/Client";
+import { RealtimeConnection } from "./connection";
+export declare enum AudioFormat {
+    PCM_8000 = "pcm_8000",
+    PCM_16000 = "pcm_16000",
+    PCM_22050 = "pcm_22050",
+    PCM_24000 = "pcm_24000",
+    PCM_44100 = "pcm_44100",
+    PCM_48000 = "pcm_48000",
+    ULAW_8000 = "ulaw_8000"
+}
+export declare enum CommitStrategy {
+    MANUAL = "manual",
+    VAD = "vad"
+}
+interface BaseOptions {
+    /**
+     * Strategy for committing transcriptions.
+     * @default CommitStrategy.MANUAL
+     */
+    commitStrategy?: CommitStrategy;
+    /**
+     * Silence threshold in seconds for VAD (Voice Activity Detection).
+     * Must be a positive number between 0.3 and 3.0
+     */
+    vadSilenceThresholdSecs?: number;
+    /**
+     * Threshold for voice activity detection.
+     * Must be between 0.1 and 0.9.
+     */
+    vadThreshold?: number;
+    /**
+     * Minimum speech duration in milliseconds.
+     * Must be a positive integer between 50 and 2000.
+     */
+    minSpeechDurationMs?: number;
+    /**
+     * Minimum silence duration in milliseconds.
+     * Must be a positive integer between 50 and 2000.
+     */
+    minSilenceDurationMs?: number;
+    /**
+     * Model ID to use for transcription.
+     * Must be a valid model ID.
+     */
+    modelId: string;
+    /**
+     * An ISO-639-1 or ISO-639-3 language_code corresponding to the language of the audio file.
+     * Can sometimes improve transcription performance if known beforehand.
+     */
+    languageCode?: string;
+}
+export interface AudioOptions extends BaseOptions {
+    audioFormat: AudioFormat;
+    sampleRate: number;
+    url?: never;
+}
+/**
+ * Options for streaming audio from a URL.
+ * @remarks
+ * **Node.js only**: Requires ffmpeg to be installed and available in PATH.
+ * This will not work in browsers, Deno, or Cloudflare Workers.
+ */
+export interface UrlOptions extends BaseOptions {
+    url: string;
+    audioFormat?: never;
+    sampleRate?: never;
+}
+/**
+ * Real-time speech-to-text transcription client.
+ * @remarks
+ * **Node.js only**: This class uses Node.js-specific APIs (WebSocket from 'ws', child_process).
+ * It will not work in browsers, Deno, or Cloudflare Workers without modifications.
+ */
+export declare class ScribeRealtime {
+    private options;
+    constructor(options?: SpeechToText.Options);
+    private getWebSocketUri;
+    private checkFfmpegInstalled;
+    private buildWebSocketUri;
+    /**
+     * Establishes a WebSocket connection for real-time speech-to-text transcription.
+     *
+     * @param options - Configuration options for the connection
+     * @returns A promise that resolves to a RealtimeConnection instance
+     *
+     * @remarks
+     * **Node.js only**: This method uses Node.js-specific APIs.
+     *
+     * When using `UrlOptions` with a URL, ffmpeg must be installed and available in PATH.
+     * The SDK will automatically convert the stream to 16kHz mono PCM format.
+     *
+     * @example
+     * ```typescript
+     * // Manual audio streaming
+     * const connection = await client.speechToText.realtime.connect({
+     *     modelId: "scribe_realtime_v2",
+     *     audioFormat: AudioFormat.PCM_16000,
+     *     sampleRate: 16000,
+     * });
+     *
+     * // Automatic URL streaming (requires ffmpeg)
+     * const connection = await client.speechToText.realtime.connect({
+     *     modelId: "scribe_realtime_v2",
+     *     url: "https://example.com/stream.mp3",
+     * });
+     * ```
+     */
+    connect(options: AudioOptions | UrlOptions): Promise<RealtimeConnection>;
+    private streamFromUrl;
+}
+export {};

package/dist/wrapper/realtime/scribe.js

@@ -0,0 +1,265 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScribeRealtime = exports.CommitStrategy = exports.AudioFormat = void 0;
+const ws_1 = __importDefault(require("ws"));
+const connection_1 = require("./connection");
+const core = __importStar(require("../../core"));
+const environments = __importStar(require("../../environments"));
+var AudioFormat;
+(function (AudioFormat) {
+    AudioFormat["PCM_8000"] = "pcm_8000";
+    AudioFormat["PCM_16000"] = "pcm_16000";
+    AudioFormat["PCM_22050"] = "pcm_22050";
+    AudioFormat["PCM_24000"] = "pcm_24000";
+    AudioFormat["PCM_44100"] = "pcm_44100";
+    AudioFormat["PCM_48000"] = "pcm_48000";
+    AudioFormat["ULAW_8000"] = "ulaw_8000";
+})(AudioFormat || (exports.AudioFormat = AudioFormat = {}));
+var CommitStrategy;
+(function (CommitStrategy) {
+    CommitStrategy["MANUAL"] = "manual";
+    CommitStrategy["VAD"] = "vad";
+})(CommitStrategy || (exports.CommitStrategy = CommitStrategy = {}));
+/**
+ * Real-time speech-to-text transcription client.
+ * @remarks
+ * **Node.js only**: This class uses Node.js-specific APIs (WebSocket from 'ws', child_process).
+ * It will not work in browsers, Deno, or Cloudflare Workers without modifications.
+ */
+class ScribeRealtime {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getWebSocketUri() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Get base URL from options, preferring baseUrl, then environment, then default Production
+            const baseUrl = (_b = (_a = (yield core.Supplier.get(this.options.baseUrl))) !== null && _a !== void 0 ? _a : (yield core.Supplier.get(this.options.environment))) !== null && _b !== void 0 ? _b : environments.ElevenLabsEnvironment.Production;
+            // Convert HTTP(S) to WS(S)
+            const wsUrl = baseUrl.replace(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://");
+            return `${wsUrl}/v1/speech-to-text/realtime-beta`;
+        });
+    }
+    checkFfmpegInstalled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { execSync } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
+                const command = process.platform === "win32" ? "where ffmpeg" : "which ffmpeg";
+                execSync(command, { stdio: "ignore" });
+            }
+            catch (_a) {
+                throw new Error("ffmpeg is required for URL streaming but was not found. " +
+                    "Please install ffmpeg and ensure it is available in your PATH. " +
+                    "Visit https://ffmpeg.org/download.html for installation instructions.");
+            }
+        });
+    }
+    buildWebSocketUri(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const baseUri = yield this.getWebSocketUri();
+            const params = new URLSearchParams();
+            // Model ID is required, so no check required
+            params.append("model_id", options.modelId);
+            // Add optional parameters if provided, with validation
+            if (options.commitStrategy !== undefined) {
+                params.append("commit_strategy", options.commitStrategy);
+            }
+            if (options.vadSilenceThresholdSecs !== undefined) {
+                if (options.vadSilenceThresholdSecs <= 0.3 || options.vadSilenceThresholdSecs > 3.0) {
+                    throw new Error("vadSilenceThresholdSecs must be between 0.3 and 3.0");
+                }
+                params.append("vad_silence_threshold_secs", options.vadSilenceThresholdSecs.toString());
+            }
+            if (options.vadThreshold !== undefined) {
+                if (options.vadThreshold < 0.1 || options.vadThreshold > 0.9) {
+                    throw new Error("vadThreshold must be between 0.1 and 0.9");
+                }
+                params.append("vad_threshold", options.vadThreshold.toString());
+            }
+            if (options.minSpeechDurationMs !== undefined) {
+                if (options.minSpeechDurationMs <= 50 || options.minSpeechDurationMs > 2000) {
+                    throw new Error("minSpeechDurationMs must be between 50 and 2000");
+                }
+                params.append("min_speech_duration_ms", options.minSpeechDurationMs.toString());
+            }
+            if (options.minSilenceDurationMs !== undefined) {
+                if (options.minSilenceDurationMs <= 50 || options.minSilenceDurationMs > 2000) {
+                    throw new Error("minSilenceDurationMs must be between 50 and 2000");
+                }
+                params.append("min_silence_duration_ms", options.minSilenceDurationMs.toString());
+            }
+            if (options.languageCode !== undefined) {
+                params.append("language_code", options.languageCode);
+            }
+            const queryString = params.toString();
+            return queryString ? `${baseUri}?${queryString}` : baseUri;
+        });
+    }
+    /**
+     * Establishes a WebSocket connection for real-time speech-to-text transcription.
+     *
+     * @param options - Configuration options for the connection
+     * @returns A promise that resolves to a RealtimeConnection instance
+     *
+     * @remarks
+     * **Node.js only**: This method uses Node.js-specific APIs.
+     *
+     * When using `UrlOptions` with a URL, ffmpeg must be installed and available in PATH.
+     * The SDK will automatically convert the stream to 16kHz mono PCM format.
+     *
+     * @example
+     * ```typescript
+     * // Manual audio streaming
+     * const connection = await client.speechToText.realtime.connect({
+     *     modelId: "scribe_realtime_v2",
+     *     audioFormat: AudioFormat.PCM_16000,
+     *     sampleRate: 16000,
+     * });
+     *
+     * // Automatic URL streaming (requires ffmpeg)
+     * const connection = await client.speechToText.realtime.connect({
+     *     modelId: "scribe_realtime_v2",
+     *     url: "https://example.com/stream.mp3",
+     * });
+     * ```
+     */
+    connect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let apiKey = this.options.apiKey;
+            if (!apiKey) {
+                throw new Error("API key is required");
+            }
+            // Resolve API key if it's a function or promise
+            if (typeof apiKey === "function") {
+                apiKey = apiKey();
+            }
+            if (apiKey instanceof Promise) {
+                apiKey = yield apiKey;
+            }
+            if (!apiKey) {
+                throw new Error("API key is required");
+            }
+            if (!options.modelId) {
+                throw new Error("modelId is required");
+            }
+            // Create connection object first so users can attach event listeners before messages arrive
+            const sampleRate = "url" in options ? 16000 : options.sampleRate;
+            const connection = new connection_1.RealtimeConnection(sampleRate);
+            // Build WebSocket URI with query parameters
+            const uri = yield this.buildWebSocketUri(options);
+            return new Promise((resolve) => {
+                const websocket = new ws_1.default(uri, {
+                    headers: {
+                        "xi-api-key": apiKey,
+                    },
+                });
+                // Attach websocket to connection immediately so error handlers are registered
+                // This ensures errors during handshake (like 403) are properly emitted via event emitter
+                connection.setWebSocket(websocket);
+                // Resolve immediately with connection so users can attach listeners
+                resolve(connection);
+                websocket.on("open", () => {
+                    var _a;
+                    // If UrlOptions, start streaming from URL with ffmpeg
+                    if ("url" in options) {
+                        const commitStrategy = (_a = options.commitStrategy) !== null && _a !== void 0 ? _a : CommitStrategy.MANUAL;
+                        this.streamFromUrl(options, connection, commitStrategy);
+                    }
+                });
+            });
+        });
+    }
+    streamFromUrl(options, connection, commitStrategy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            // Check if ffmpeg is installed before attempting to use it
+            yield this.checkFfmpegInstalled();
+            // Dynamically import spawn to avoid bundling issues in non-Node.js environments
+            const { spawn } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
+            // Spawn ffmpeg to convert the stream to 16kHz mono PCM
+            const ffmpegProcess = spawn("ffmpeg", [
+                "-i", options.url,
+                "-f", "s16le", // 16-bit PCM, little-endian
+                "-acodec", "pcm_s16le", // PCM codec
+                "-ar", "16000", // 16kHz sample rate
+                "-ac", "1", // mono (1 channel)
+                "pipe:1" // output to stdout
+            ]);
+            connection.setFfmpegProcess(ffmpegProcess);
+            (_a = ffmpegProcess.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
+                const base64Audio = chunk.toString("base64");
+                connection.send({
+                    audioBase64: base64Audio,
+                });
+            });
+            (_b = ffmpegProcess.stdout) === null || _b === void 0 ? void 0 : _b.on("end", () => {
+                if (commitStrategy === CommitStrategy.MANUAL) {
+                    // Manual strategy: commit to finalize transcription, then close
+                    console.log("Stream ended, sending final commit");
+                    connection.commit();
+                }
+                // Close connection since no more audio will be sent
+                connection.close();
+            });
+            (_c = ffmpegProcess.stderr) === null || _c === void 0 ? void 0 : _c.on("data", (data) => {
+                // ffmpeg outputs progress info to stderr, only log errors
+                const message = data.toString();
+                if (message.includes("Error") || message.includes("error")) {
+                    console.error("ffmpeg error:", message);
+                }
+            });
+            ffmpegProcess.on("error", (error) => {
+                console.error("Failed to start ffmpeg:", error);
+            });
+            ffmpegProcess.on("close", (code) => {
+                console.log(`ffmpeg process exited with code ${code}`);
+            });
+        });
+    }
+}
+exports.ScribeRealtime = ScribeRealtime;

package/dist/wrapper/speechToText.d.ts

@@ -0,0 +1,6 @@
+import { SpeechToText as GeneratedSpeechToText } from "../api/resources/speechToText/client/Client";
+import { ScribeRealtime } from "./realtime";
+export declare class SpeechToText extends GeneratedSpeechToText {
+    private _realtime;
+    get realtime(): ScribeRealtime;
+}

package/dist/wrapper/speechToText.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechToText = void 0;
+const Client_1 = require("../api/resources/speechToText/client/Client");
+const realtime_1 = require("./realtime");
+class SpeechToText extends Client_1.SpeechToText {
+    get realtime() {
+        if (!this._realtime) {
+            this._realtime = new realtime_1.ScribeRealtime(this._options);
+        }
+        return this._realtime;
+    }
+}
+exports.SpeechToText = SpeechToText;