assemblyai 4.34.5 → 4.35.0

package/dist/streaming.browser.mjs

@@ -531,6 +531,24 @@ function toInt16View(audio) {
 }
 const defaultStreamingUrl = "wss://streaming.assemblyai.com/v3/ws";
 const terminateSessionMessage = `{"type":"Terminate"}`;
+const DEFAULT_CONNECT_TIMEOUT_MS = 1000;
+const DEFAULT_MAX_CONNECTION_RETRIES = 2;
+const DEFAULT_CONNECTION_RETRY_DELAY_MS = 500;
+/**
+ * Close/error codes that signal a permanent client-side problem (auth,
+ * billing, malformed config). A retry would hit the same failure, so the
+ * connection is never retried on these.
+ */
+const NON_RETRYABLE_CLOSE_CODES = new Set([
+    StreamingErrorType.BadSampleRate,
+    StreamingErrorType.AuthFailed,
+    StreamingErrorType.InsufficientFunds,
+    StreamingErrorType.FreeTierUser,
+    StreamingErrorType.BadSchema,
+]);
+function isRetryableCloseCode(code) {
+    return code !== 1000 && !NON_RETRYABLE_CLOSE_CODES.has(code);
+}
 /**
  * Per-send chunk cap in milliseconds for the dual-channel mixer. The streaming
  * server rejects audio messages longer than 1000 ms (`Input Duration Error`).
@@ -739,12 +757,81 @@ class StreamingTranscriber {
     on(event, listener) {
         this.listeners[event] = listener;
     }
-    connect() {
-        return new Promise((resolve) => {
-            if (this.socket) {
-                throw new Error("Already connected");
+    /**
+     * Open the streaming session.
+     *
+     * Resolves with the server's `Begin` event once the handshake completes. A
+     * single attempt is bounded by `connectTimeout` (default 1000ms); transient
+     * failures (timeout, network drop, unexpected close) are retried up to
+     * `maxConnectionRetries` times (default 2), waiting `connectionRetryDelay`
+     * (default 500ms) between attempts. Permanent failures (auth, insufficient
+     * funds, malformed config) are not retried.
+     *
+     * Unlike previously, a failed connection now rejects this promise rather
+     * than only invoking the `error` listener — necessary for the caller (and
+     * the retry loop) to observe the failure.
+     */
+    async connect() {
+        if (this.socket) {
+            throw new Error("Already connected");
+        }
+        const maxRetries = this.params.maxConnectionRetries ?? DEFAULT_MAX_CONNECTION_RETRIES;
+        const retryDelay = this.params.connectionRetryDelay ?? DEFAULT_CONNECTION_RETRY_DELAY_MS;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await this.connectOnce();
+            }
+            catch (err) {
+                lastError = err;
+                const retryable = err.retryable === true;
+                if (!retryable || attempt === maxRetries) {
+                    throw err;
+                }
+                console.warn(`Streaming connect attempt ${attempt + 1}/${maxRetries + 1} failed (${err.message}); retrying`);
+                if (retryDelay > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
             }
+        }
+        // The loop above always returns or throws; this only satisfies the type
+        // checker that a value is produced on every path.
+        throw lastError ?? new Error("Failed to connect to streaming server");
+    }
+    connectOnce() {
+        return new Promise((resolve, reject) => {
             const url = this.connectionUrl();
+            const timeoutMs = this.params.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT_MS;
+            // `settled` flips once this attempt has resolved (`Begin`) or rejected
+            // (timeout / pre-`Begin` close / error). Before it flips the socket
+            // handlers drive this promise; after it flips they revert to normal
+            // runtime dispatch (close / error / message listeners).
+            let settled = false;
+            let timer;
+            const failAttempt = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                this.discardPendingSocket();
+                reject(error);
+            };
+            const succeed = (begin) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                resolve(begin);
+            };
+            if (timeoutMs > 0) {
+                timer = setTimeout(() => {
+                    const err = new StreamingError(`Streaming connection timed out after ${timeoutMs}ms`);
+                    err.retryable = true;
+                    failAttempt(err);
+                }, timeoutMs);
+            }
             if (this.token) {
                 this.socket = factory(url.toString());
             }
@@ -765,6 +852,15 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
                         reason = StreamingErrorMessages[code];
                     }
                 }
+                // A close before `Begin` is a failed connection attempt — reject so
+                // connect() can retry (or surface a permanent failure).
+                if (!settled) {
+                    const err = new StreamingError(reason || `Streaming connection closed (code=${code})`);
+                    err.code = code;
+                    err.retryable = isRetryableCloseCode(code);
+                    failAttempt(err);
+                    return;
+                }
                 // Stop the flush timer when the socket is gone (server-initiated close,
                 // network drop, etc.) — otherwise subsequent ticks call send() on a
                 // closed socket and spam the error listener.
@@ -775,25 +871,37 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
                 this.listeners.close?.(code, reason);
             };
             this.socket.onerror = (event) => {
-                if (event.error)
-                    this.listeners.error?.(event.error);
-                else
-                    this.listeners.error?.(new Error(event.message));
+                const error = event.error ?? new Error(event.message);
+                // A socket error before `Begin` is a failed attempt → reject/retry.
+                if (!settled) {
+                    error.retryable = true;
+                    failAttempt(error);
+                    return;
+                }
+                this.listeners.error?.(error);
             };
             this.socket.onmessage = ({ data }) => {
                 const message = JSON.parse(data.toString());
                 if ("error" in message) {
                     const err = new StreamingError(message.error);
                     if ("error_code" in message) {
-                        err.code =
-                            message.error_code;
+                        err.code = message.error_code;
+                    }
+                    // A server error frame before `Begin` fails the attempt; the code
+                    // decides whether a retry is worthwhile.
+                    if (!settled) {
+                        const attemptErr = err;
+                        attemptErr.retryable =
+                            err.code === undefined ? true : isRetryableCloseCode(err.code);
+                        failAttempt(attemptErr);
+                        return;
                     }
                     this.listeners.error?.(err);
                     return;
                 }
                 switch (message.type) {
                     case "Begin": {
-                        resolve(message);
+                        succeed(message);
                         this.listeners.open?.(message);
                         break;
                     }
@@ -840,6 +948,20 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
             };
         });
     }
+    /** Tear down a half-open socket from a failed connection attempt. */
+    discardPendingSocket() {
+        if (!this.socket)
+            return;
+        try {
+            if (this.socket.removeAllListeners)
+                this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        catch {
+            // Best-effort cleanup; a half-open socket may throw on close.
+        }
+        this.socket = undefined;
+    }
     /**
      * Returns a WritableStream that pumps PCM chunks into `sendAudio`. Single-channel
      * only — in dual-channel mode use `sendAudio(pcm, { channel })` directly, since
@@ -1113,6 +1235,16 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
         };
         this.send(JSON.stringify(message));
     }
+    /**
+     * Reset the server's inactivity timer. Only needed when the session was
+     * created with `inactivityTimeout` and no audio is being sent.
+     */
+    keepAlive() {
+        const message = {
+            type: "KeepAlive",
+        };
+        this.send(JSON.stringify(message));
+    }
     send(data) {
         if (!this.socket || this.socket.readyState !== this.socket.OPEN) {
             throw new Error("Socket is not open for communication");
@@ -1168,7 +1300,7 @@ if (typeof navigator !== "undefined" && navigator.userAgent) {
     defaultUserAgentString += navigator.userAgent;
 }
 const defaultUserAgent = {
-    sdk: { name: "JavaScript", version: "4.34.5" },
+    sdk: { name: "JavaScript", version: "4.35.0" },
 };
 if (typeof process !== "undefined") {
     if (process.versions.node && defaultUserAgentString.indexOf("Node") === -1) {

package/dist/streaming.cjs

@@ -579,6 +579,24 @@ function toInt16View(audio) {
 }
 const defaultStreamingUrl = "wss://streaming.assemblyai.com/v3/ws";
 const terminateSessionMessage = `{"type":"Terminate"}`;
+const DEFAULT_CONNECT_TIMEOUT_MS = 1000;
+const DEFAULT_MAX_CONNECTION_RETRIES = 2;
+const DEFAULT_CONNECTION_RETRY_DELAY_MS = 500;
+/**
+ * Close/error codes that signal a permanent client-side problem (auth,
+ * billing, malformed config). A retry would hit the same failure, so the
+ * connection is never retried on these.
+ */
+const NON_RETRYABLE_CLOSE_CODES = new Set([
+    StreamingErrorType.BadSampleRate,
+    StreamingErrorType.AuthFailed,
+    StreamingErrorType.InsufficientFunds,
+    StreamingErrorType.FreeTierUser,
+    StreamingErrorType.BadSchema,
+]);
+function isRetryableCloseCode(code) {
+    return code !== 1000 && !NON_RETRYABLE_CLOSE_CODES.has(code);
+}
 /**
  * Per-send chunk cap in milliseconds for the dual-channel mixer. The streaming
  * server rejects audio messages longer than 1000 ms (`Input Duration Error`).
@@ -785,12 +803,85 @@ class StreamingTranscriber {
     on(event, listener) {
         this.listeners[event] = listener;
     }
+    /**
+     * Open the streaming session.
+     *
+     * Resolves with the server's `Begin` event once the handshake completes. A
+     * single attempt is bounded by `connectTimeout` (default 1000ms); transient
+     * failures (timeout, network drop, unexpected close) are retried up to
+     * `maxConnectionRetries` times (default 2), waiting `connectionRetryDelay`
+     * (default 500ms) between attempts. Permanent failures (auth, insufficient
+     * funds, malformed config) are not retried.
+     *
+     * Unlike previously, a failed connection now rejects this promise rather
+     * than only invoking the `error` listener — necessary for the caller (and
+     * the retry loop) to observe the failure.
+     */
     connect() {
-        return new Promise((resolve) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             if (this.socket) {
                 throw new Error("Already connected");
             }
+            const maxRetries = (_a = this.params.maxConnectionRetries) !== null && _a !== void 0 ? _a : DEFAULT_MAX_CONNECTION_RETRIES;
+            const retryDelay = (_b = this.params.connectionRetryDelay) !== null && _b !== void 0 ? _b : DEFAULT_CONNECTION_RETRY_DELAY_MS;
+            let lastError;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                try {
+                    return yield this.connectOnce();
+                }
+                catch (err) {
+                    lastError = err;
+                    const retryable = err.retryable === true;
+                    if (!retryable || attempt === maxRetries) {
+                        throw err;
+                    }
+                    console.warn(`Streaming connect attempt ${attempt + 1}/${maxRetries + 1} failed (${err.message}); retrying`);
+                    if (retryDelay > 0) {
+                        yield new Promise((resolve) => setTimeout(resolve, retryDelay));
+                    }
+                }
+            }
+            // The loop above always returns or throws; this only satisfies the type
+            // checker that a value is produced on every path.
+            throw lastError !== null && lastError !== void 0 ? lastError : new Error("Failed to connect to streaming server");
+        });
+    }
+    connectOnce() {
+        return new Promise((resolve, reject) => {
+            var _a;
             const url = this.connectionUrl();
+            const timeoutMs = (_a = this.params.connectTimeout) !== null && _a !== void 0 ? _a : DEFAULT_CONNECT_TIMEOUT_MS;
+            // `settled` flips once this attempt has resolved (`Begin`) or rejected
+            // (timeout / pre-`Begin` close / error). Before it flips the socket
+            // handlers drive this promise; after it flips they revert to normal
+            // runtime dispatch (close / error / message listeners).
+            let settled = false;
+            let timer;
+            const failAttempt = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                this.discardPendingSocket();
+                reject(error);
+            };
+            const succeed = (begin) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                resolve(begin);
+            };
+            if (timeoutMs > 0) {
+                timer = setTimeout(() => {
+                    const err = new StreamingError(`Streaming connection timed out after ${timeoutMs}ms`);
+                    err.retryable = true;
+                    failAttempt(err);
+                }, timeoutMs);
+            }
             if (this.token) {
                 this.socket = factory(url.toString());
             }
@@ -808,6 +899,15 @@ class StreamingTranscriber {
                         reason = StreamingErrorMessages[code];
                     }
                 }
+                // A close before `Begin` is a failed connection attempt — reject so
+                // connect() can retry (or surface a permanent failure).
+                if (!settled) {
+                    const err = new StreamingError(reason || `Streaming connection closed (code=${code})`);
+                    err.code = code;
+                    err.retryable = isRetryableCloseCode(code);
+                    failAttempt(err);
+                    return;
+                }
                 // Stop the flush timer when the socket is gone (server-initiated close,
                 // network drop, etc.) — otherwise subsequent ticks call send() on a
                 // closed socket and spam the error listener.
@@ -818,11 +918,15 @@ class StreamingTranscriber {
                 (_b = (_a = this.listeners).close) === null || _b === void 0 ? void 0 : _b.call(_a, code, reason);
             };
             this.socket.onerror = (event) => {
-                var _a, _b, _c, _d;
-                if (event.error)
-                    (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, event.error);
-                else
-                    (_d = (_c = this.listeners).error) === null || _d === void 0 ? void 0 : _d.call(_c, new Error(event.message));
+                var _a, _b, _c;
+                const error = (_a = event.error) !== null && _a !== void 0 ? _a : new Error(event.message);
+                // A socket error before `Begin` is a failed attempt → reject/retry.
+                if (!settled) {
+                    error.retryable = true;
+                    failAttempt(error);
+                    return;
+                }
+                (_c = (_b = this.listeners).error) === null || _c === void 0 ? void 0 : _c.call(_b, error);
             };
             this.socket.onmessage = ({ data }) => {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
@@ -830,15 +934,23 @@ class StreamingTranscriber {
                 if ("error" in message) {
                     const err = new StreamingError(message.error);
                     if ("error_code" in message) {
-                        err.code =
-                            message.error_code;
+                        err.code = message.error_code;
+                    }
+                    // A server error frame before `Begin` fails the attempt; the code
+                    // decides whether a retry is worthwhile.
+                    if (!settled) {
+                        const attemptErr = err;
+                        attemptErr.retryable =
+                            err.code === undefined ? true : isRetryableCloseCode(err.code);
+                        failAttempt(attemptErr);
+                        return;
                     }
                     (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
                     return;
                 }
                 switch (message.type) {
                     case "Begin": {
-                        resolve(message);
+                        succeed(message);
                         (_d = (_c = this.listeners).open) === null || _d === void 0 ? void 0 : _d.call(_c, message);
                         break;
                     }
@@ -885,6 +997,20 @@ class StreamingTranscriber {
             };
         });
     }
+    /** Tear down a half-open socket from a failed connection attempt. */
+    discardPendingSocket() {
+        if (!this.socket)
+            return;
+        try {
+            if (this.socket.removeAllListeners)
+                this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        catch (_a) {
+            // Best-effort cleanup; a half-open socket may throw on close.
+        }
+        this.socket = undefined;
+    }
     /**
      * Returns a WritableStream that pumps PCM chunks into `sendAudio`. Single-channel
      * only — in dual-channel mode use `sendAudio(pcm, { channel })` directly, since
@@ -1158,6 +1284,16 @@ class StreamingTranscriber {
         };
         this.send(JSON.stringify(message));
     }
+    /**
+     * Reset the server's inactivity timer. Only needed when the session was
+     * created with `inactivityTimeout` and no audio is being sent.
+     */
+    keepAlive() {
+        const message = {
+            type: "KeepAlive",
+        };
+        this.send(JSON.stringify(message));
+    }
     send(data) {
         if (!this.socket || this.socket.readyState !== this.socket.OPEN) {
             throw new Error("Socket is not open for communication");

package/dist/streaming.mjs

@@ -577,6 +577,24 @@ function toInt16View(audio) {
 }
 const defaultStreamingUrl = "wss://streaming.assemblyai.com/v3/ws";
 const terminateSessionMessage = `{"type":"Terminate"}`;
+const DEFAULT_CONNECT_TIMEOUT_MS = 1000;
+const DEFAULT_MAX_CONNECTION_RETRIES = 2;
+const DEFAULT_CONNECTION_RETRY_DELAY_MS = 500;
+/**
+ * Close/error codes that signal a permanent client-side problem (auth,
+ * billing, malformed config). A retry would hit the same failure, so the
+ * connection is never retried on these.
+ */
+const NON_RETRYABLE_CLOSE_CODES = new Set([
+    StreamingErrorType.BadSampleRate,
+    StreamingErrorType.AuthFailed,
+    StreamingErrorType.InsufficientFunds,
+    StreamingErrorType.FreeTierUser,
+    StreamingErrorType.BadSchema,
+]);
+function isRetryableCloseCode(code) {
+    return code !== 1000 && !NON_RETRYABLE_CLOSE_CODES.has(code);
+}
 /**
  * Per-send chunk cap in milliseconds for the dual-channel mixer. The streaming
  * server rejects audio messages longer than 1000 ms (`Input Duration Error`).
@@ -783,12 +801,85 @@ class StreamingTranscriber {
     on(event, listener) {
         this.listeners[event] = listener;
     }
+    /**
+     * Open the streaming session.
+     *
+     * Resolves with the server's `Begin` event once the handshake completes. A
+     * single attempt is bounded by `connectTimeout` (default 1000ms); transient
+     * failures (timeout, network drop, unexpected close) are retried up to
+     * `maxConnectionRetries` times (default 2), waiting `connectionRetryDelay`
+     * (default 500ms) between attempts. Permanent failures (auth, insufficient
+     * funds, malformed config) are not retried.
+     *
+     * Unlike previously, a failed connection now rejects this promise rather
+     * than only invoking the `error` listener — necessary for the caller (and
+     * the retry loop) to observe the failure.
+     */
     connect() {
-        return new Promise((resolve) => {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             if (this.socket) {
                 throw new Error("Already connected");
             }
+            const maxRetries = (_a = this.params.maxConnectionRetries) !== null && _a !== void 0 ? _a : DEFAULT_MAX_CONNECTION_RETRIES;
+            const retryDelay = (_b = this.params.connectionRetryDelay) !== null && _b !== void 0 ? _b : DEFAULT_CONNECTION_RETRY_DELAY_MS;
+            let lastError;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                try {
+                    return yield this.connectOnce();
+                }
+                catch (err) {
+                    lastError = err;
+                    const retryable = err.retryable === true;
+                    if (!retryable || attempt === maxRetries) {
+                        throw err;
+                    }
+                    console.warn(`Streaming connect attempt ${attempt + 1}/${maxRetries + 1} failed (${err.message}); retrying`);
+                    if (retryDelay > 0) {
+                        yield new Promise((resolve) => setTimeout(resolve, retryDelay));
+                    }
+                }
+            }
+            // The loop above always returns or throws; this only satisfies the type
+            // checker that a value is produced on every path.
+            throw lastError !== null && lastError !== void 0 ? lastError : new Error("Failed to connect to streaming server");
+        });
+    }
+    connectOnce() {
+        return new Promise((resolve, reject) => {
+            var _a;
             const url = this.connectionUrl();
+            const timeoutMs = (_a = this.params.connectTimeout) !== null && _a !== void 0 ? _a : DEFAULT_CONNECT_TIMEOUT_MS;
+            // `settled` flips once this attempt has resolved (`Begin`) or rejected
+            // (timeout / pre-`Begin` close / error). Before it flips the socket
+            // handlers drive this promise; after it flips they revert to normal
+            // runtime dispatch (close / error / message listeners).
+            let settled = false;
+            let timer;
+            const failAttempt = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                this.discardPendingSocket();
+                reject(error);
+            };
+            const succeed = (begin) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                resolve(begin);
+            };
+            if (timeoutMs > 0) {
+                timer = setTimeout(() => {
+                    const err = new StreamingError(`Streaming connection timed out after ${timeoutMs}ms`);
+                    err.retryable = true;
+                    failAttempt(err);
+                }, timeoutMs);
+            }
             if (this.token) {
                 this.socket = factory(url.toString());
             }
@@ -806,6 +897,15 @@ class StreamingTranscriber {
                         reason = StreamingErrorMessages[code];
                     }
                 }
+                // A close before `Begin` is a failed connection attempt — reject so
+                // connect() can retry (or surface a permanent failure).
+                if (!settled) {
+                    const err = new StreamingError(reason || `Streaming connection closed (code=${code})`);
+                    err.code = code;
+                    err.retryable = isRetryableCloseCode(code);
+                    failAttempt(err);
+                    return;
+                }
                 // Stop the flush timer when the socket is gone (server-initiated close,
                 // network drop, etc.) — otherwise subsequent ticks call send() on a
                 // closed socket and spam the error listener.
@@ -816,11 +916,15 @@ class StreamingTranscriber {
                 (_b = (_a = this.listeners).close) === null || _b === void 0 ? void 0 : _b.call(_a, code, reason);
             };
             this.socket.onerror = (event) => {
-                var _a, _b, _c, _d;
-                if (event.error)
-                    (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, event.error);
-                else
-                    (_d = (_c = this.listeners).error) === null || _d === void 0 ? void 0 : _d.call(_c, new Error(event.message));
+                var _a, _b, _c;
+                const error = (_a = event.error) !== null && _a !== void 0 ? _a : new Error(event.message);
+                // A socket error before `Begin` is a failed attempt → reject/retry.
+                if (!settled) {
+                    error.retryable = true;
+                    failAttempt(error);
+                    return;
+                }
+                (_c = (_b = this.listeners).error) === null || _c === void 0 ? void 0 : _c.call(_b, error);
             };
             this.socket.onmessage = ({ data }) => {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
@@ -828,15 +932,23 @@ class StreamingTranscriber {
                 if ("error" in message) {
                     const err = new StreamingError(message.error);
                     if ("error_code" in message) {
-                        err.code =
-                            message.error_code;
+                        err.code = message.error_code;
+                    }
+                    // A server error frame before `Begin` fails the attempt; the code
+                    // decides whether a retry is worthwhile.
+                    if (!settled) {
+                        const attemptErr = err;
+                        attemptErr.retryable =
+                            err.code === undefined ? true : isRetryableCloseCode(err.code);
+                        failAttempt(attemptErr);
+                        return;
                     }
                     (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
                     return;
                 }
                 switch (message.type) {
                     case "Begin": {
-                        resolve(message);
+                        succeed(message);
                         (_d = (_c = this.listeners).open) === null || _d === void 0 ? void 0 : _d.call(_c, message);
                         break;
                     }
@@ -883,6 +995,20 @@ class StreamingTranscriber {
             };
         });
     }
+    /** Tear down a half-open socket from a failed connection attempt. */
+    discardPendingSocket() {
+        if (!this.socket)
+            return;
+        try {
+            if (this.socket.removeAllListeners)
+                this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        catch (_a) {
+            // Best-effort cleanup; a half-open socket may throw on close.
+        }
+        this.socket = undefined;
+    }
     /**
      * Returns a WritableStream that pumps PCM chunks into `sendAudio`. Single-channel
      * only — in dual-channel mode use `sendAudio(pcm, { channel })` directly, since
@@ -1156,6 +1282,16 @@ class StreamingTranscriber {
         };
         this.send(JSON.stringify(message));
     }
+    /**
+     * Reset the server's inactivity timer. Only needed when the session was
+     * created with `inactivityTimeout` and no audio is being sent.
+     */
+    keepAlive() {
+        const message = {
+            type: "KeepAlive",
+        };
+        this.send(JSON.stringify(message));
+    }
     send(data) {
         if (!this.socket || this.socket.readyState !== this.socket.OPEN) {
             throw new Error("Socket is not open for communication");