@elevenlabs/elevenlabs-js 2.19.0 → 2.20.0

package/serialization/types/WhatsAppConversationInfo.d.ts

@@ -0,0 +1,10 @@
+import * as serializers from "../index";
+import * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+export declare const WhatsAppConversationInfo: core.serialization.ObjectSchema<serializers.WhatsAppConversationInfo.Raw, ElevenLabs.WhatsAppConversationInfo>;
+export declare namespace WhatsAppConversationInfo {
+    interface Raw {
+        whatsapp_business_account_id: string;
+        whatsapp_user_id: string;
+    }
+}

package/{dist/serialization/types/WhatsAppChangeCalls.js → serialization/types/WhatsAppConversationInfo.js}

@@ -34,9 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WhatsAppChangeCalls = void 0;
+exports.WhatsAppConversationInfo = void 0;
 const core = __importStar(require("../../core"));
-const WhatsAppCalls_1 = require("./WhatsAppCalls");
-exports.WhatsAppChangeCalls = core.serialization.object({
-    value: WhatsAppCalls_1.WhatsAppCalls,
+exports.WhatsAppConversationInfo = core.serialization.object({
+    whatsappBusinessAccountId: core.serialization.property("whatsapp_business_account_id", core.serialization.string()),
+    whatsappUserId: core.serialization.property("whatsapp_user_id", core.serialization.string()),
 });

package/serialization/types/index.d.ts

@@ -77,6 +77,7 @@ export * from "./AgentConfigApiModelWorkflowOverrideOutput";
 export * from "./AgentConfigOverrideInput";
 export * from "./AgentConfigOverrideOutput";
 export * from "./AgentConfigOverrideConfig";
+export * from "./AgentDefinitionSource";
 export * from "./AgentFailureResponseExample";
 export * from "./AgentMetadata";
 export * from "./AgentMetadataResponseModel";
@@ -623,6 +624,7 @@ export * from "./TimeRange";
 export * from "./TokenResponseModel";
 export * from "./Tool";
 export * from "./ToolAnnotations";
+export * from "./ToolExecutionMode";
 export * from "./ToolMockConfig";
 export * from "./ToolRequestModelToolConfig";
 export * from "./ToolRequestModel";
@@ -698,16 +700,7 @@ export * from "./WebhookToolApiSchemaConfigOutput";
 export * from "./WebhookToolConfigInput";
 export * from "./WebhookToolConfigOutput";
 export * from "./WebhookUsageType";
-export * from "./WhatsAppBusinessAccountChangesItem";
-export * from "./WhatsAppBusinessAccount";
-export * from "./WhatsAppCallDirection";
-export * from "./WhatsAppCall";
-export * from "./WhatsAppCalls";
-export * from "./WhatsAppChangeCalls";
-export * from "./WhatsAppChangeMessages";
-export * from "./WhatsAppEventRequest";
-export * from "./WhatsAppMetadata";
-export * from "./WhatsAppSession";
+export * from "./WhatsAppConversationInfo";
 export * from "./WidgetConfigInputAvatar";
 export * from "./WidgetConfig";
 export * from "./WidgetConfigOutputAvatar";

package/serialization/types/index.js

@@ -93,6 +93,7 @@ __exportStar(require("./AgentConfigApiModelWorkflowOverrideOutput"), exports);
 __exportStar(require("./AgentConfigOverrideInput"), exports);
 __exportStar(require("./AgentConfigOverrideOutput"), exports);
 __exportStar(require("./AgentConfigOverrideConfig"), exports);
+__exportStar(require("./AgentDefinitionSource"), exports);
 __exportStar(require("./AgentFailureResponseExample"), exports);
 __exportStar(require("./AgentMetadata"), exports);
 __exportStar(require("./AgentMetadataResponseModel"), exports);
@@ -639,6 +640,7 @@ __exportStar(require("./TimeRange"), exports);
 __exportStar(require("./TokenResponseModel"), exports);
 __exportStar(require("./Tool"), exports);
 __exportStar(require("./ToolAnnotations"), exports);
+__exportStar(require("./ToolExecutionMode"), exports);
 __exportStar(require("./ToolMockConfig"), exports);
 __exportStar(require("./ToolRequestModelToolConfig"), exports);
 __exportStar(require("./ToolRequestModel"), exports);
@@ -714,16 +716,7 @@ __exportStar(require("./WebhookToolApiSchemaConfigOutput"), exports);
 __exportStar(require("./WebhookToolConfigInput"), exports);
 __exportStar(require("./WebhookToolConfigOutput"), exports);
 __exportStar(require("./WebhookUsageType"), exports);
-__exportStar(require("./WhatsAppBusinessAccountChangesItem"), exports);
-__exportStar(require("./WhatsAppBusinessAccount"), exports);
-__exportStar(require("./WhatsAppCallDirection"), exports);
-__exportStar(require("./WhatsAppCall"), exports);
-__exportStar(require("./WhatsAppCalls"), exports);
-__exportStar(require("./WhatsAppChangeCalls"), exports);
-__exportStar(require("./WhatsAppChangeMessages"), exports);
-__exportStar(require("./WhatsAppEventRequest"), exports);
-__exportStar(require("./WhatsAppMetadata"), exports);
-__exportStar(require("./WhatsAppSession"), exports);
+__exportStar(require("./WhatsAppConversationInfo"), exports);
 __exportStar(require("./WidgetConfigInputAvatar"), exports);
 __exportStar(require("./WidgetConfig"), exports);
 __exportStar(require("./WidgetConfigOutputAvatar"), exports);

package/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "v2.19.0";
+export declare const SDK_VERSION = "v2.20.0";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "v2.19.0";
+exports.SDK_VERSION = "v2.20.0";

package/wrapper/ElevenLabsClient.d.ts

@@ -2,6 +2,7 @@ import { ElevenLabsClient as FernClient } from "../Client";
 import type * as core from "../core";
 import { WebhooksClient } from "./webhooks";
 import { Music } from "./music";
+import { SpeechToText } from "./speechToText";
 export declare namespace ElevenLabsClient {
     interface Options extends FernClient.Options {
         /**
@@ -14,7 +15,9 @@ export declare namespace ElevenLabsClient {
 export declare class ElevenLabsClient extends FernClient {
     private _customWebhooks;
     private _customMusic;
+    private _customSpeechToText;
     constructor(options?: ElevenLabsClient.Options);
     get webhooks(): WebhooksClient;
     get music(): Music;
+    get speechToText(): SpeechToText;
 }

package/wrapper/ElevenLabsClient.js

@@ -38,6 +38,7 @@ const Client_1 = require("../Client");
 const errors = __importStar(require("../errors"));
 const webhooks_1 = require("./webhooks");
 const music_1 = require("./music");
+const speechToText_1 = require("./speechToText");
 class ElevenLabsClient extends Client_1.ElevenLabsClient {
     constructor(options = {}) {
         var _a;
@@ -63,5 +64,11 @@ class ElevenLabsClient extends Client_1.ElevenLabsClient {
         }
         return this._customMusic;
     }
+    get speechToText() {
+        if (!this._customSpeechToText) {
+            this._customSpeechToText = new speechToText_1.SpeechToText(this._options);
+        }
+        return this._customSpeechToText;
+    }
 }
 exports.ElevenLabsClient = ElevenLabsClient;

package/wrapper/index.d.ts

@@ -2,3 +2,5 @@ export { ElevenLabsClient } from "./ElevenLabsClient";
 export { Music, type SongMetadata, type MultipartResponse } from "./music";
 export { play } from "./play";
 export { stream } from "./stream";
+export { SpeechToText } from "./speechToText";
+export { RealtimeConnection, RealtimeEvents, AudioFormat, CommitStrategy, type AudioOptions, type UrlOptions } from "./realtime";

package/wrapper/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stream = exports.play = exports.Music = exports.ElevenLabsClient = void 0;
+exports.CommitStrategy = exports.AudioFormat = exports.RealtimeEvents = exports.RealtimeConnection = exports.SpeechToText = exports.stream = exports.play = exports.Music = exports.ElevenLabsClient = void 0;
 var ElevenLabsClient_1 = require("./ElevenLabsClient");
 Object.defineProperty(exports, "ElevenLabsClient", { enumerable: true, get: function () { return ElevenLabsClient_1.ElevenLabsClient; } });
 var music_1 = require("./music");
@@ -9,3 +9,10 @@ var play_1 = require("./play");
 Object.defineProperty(exports, "play", { enumerable: true, get: function () { return play_1.play; } });
 var stream_1 = require("./stream");
 Object.defineProperty(exports, "stream", { enumerable: true, get: function () { return stream_1.stream; } });
+var speechToText_1 = require("./speechToText");
+Object.defineProperty(exports, "SpeechToText", { enumerable: true, get: function () { return speechToText_1.SpeechToText; } });
+var realtime_1 = require("./realtime");
+Object.defineProperty(exports, "RealtimeConnection", { enumerable: true, get: function () { return realtime_1.RealtimeConnection; } });
+Object.defineProperty(exports, "RealtimeEvents", { enumerable: true, get: function () { return realtime_1.RealtimeEvents; } });
+Object.defineProperty(exports, "AudioFormat", { enumerable: true, get: function () { return realtime_1.AudioFormat; } });
+Object.defineProperty(exports, "CommitStrategy", { enumerable: true, get: function () { return realtime_1.CommitStrategy; } });

package/wrapper/realtime/connection.d.ts

@@ -0,0 +1,179 @@
+import WebSocket from "ws";
+import type { ChildProcess } from "node:child_process";
+/**
+ * Events emitted by the RealtimeConnection.
+ */
+export declare enum RealtimeEvents {
+    /** Emitted when the session is successfully started */
+    SESSION_STARTED = "session_started",
+    /** Emitted when a partial (interim) transcript is available */
+    PARTIAL_TRANSCRIPT = "partial_transcript",
+    /** Emitted when a final transcript is available */
+    FINAL_TRANSCRIPT = "final_transcript",
+    /** Emitted when a final transcript with timestamps is available */
+    FINAL_TRANSCRIPT_WITH_TIMESTAMPS = "final_transcript_with_timestamps",
+    /** Emitted when an error occurs */
+    ERROR = "error",
+    /** Emitted when the WebSocket connection is opened */
+    OPEN = "open",
+    /** Emitted when the WebSocket connection is closed */
+    CLOSE = "close"
+}
+/**
+ * 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();
+  * ```
+ */
+export declare class RealtimeConnection {
+    private websocket;
+    private eventEmitter;
+    private ffmpegProcess;
+    private currentSampleRate;
+    constructor(sampleRate: number);
+    /**
+     * @internal
+     * Used internally by ScribeRealtime to attach the WebSocket after connection is created.
+     */
+    setWebSocket(websocket: WebSocket): void;
+    /**
+     * @internal
+     * Used internally by ScribeRealtime to attach ffmpeg process for cleanup.
+     */
+    setFfmpegProcess(ffmpegProcess: ChildProcess): void;
+    /**
+     * 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: RealtimeEvents, listener: (...args: unknown[]) => void): void;
+    /**
+     * 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: RealtimeEvents, listener: (...args: unknown[]) => void): void;
+    /**
+     * 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: {
+        audioBase64: string;
+        commit?: boolean;
+        sampleRate?: number;
+    }): void;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    private cleanup;
+}

package/wrapper/realtime/connection.js

@@ -0,0 +1,261 @@
+"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);
+                    this.close();
+                    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/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/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; } });