hume 0.10.4-beta.2 → 0.10.4-beta.3

package/api/resources/empathicVoice/resources/chat/client/Socket.js

@@ -75,15 +75,9 @@ class ChatSocket {
             (_b = (_a = this.eventHandlers).close) === null || _b === void 0 ? void 0 : _b.call(_a, event);
         };
         this.handleError = (event) => {
-            var _a, _b, _c, _d, _e, _f;
-            try {
-                const message = (_a = event.message) !== null && _a !== void 0 ? _a : `core.ReconnectingWebSocket error (${JSON.stringify(event)})`;
-                (_c = (_b = this.eventHandlers).error) === null || _c === void 0 ? void 0 : _c.call(_b, new Error(message));
-            }
-            catch (_g) {
-                const message = (_d = event.message) !== null && _d !== void 0 ? _d : `core.ReconnectingWebSocket error (unable to stringify)`;
-                (_f = (_e = this.eventHandlers).error) === null || _f === void 0 ? void 0 : _f.call(_e, new Error(message));
-            }
+            var _a, _b;
+            // Create and dispatch a new Error object using the message from the standardized event.
+            (_b = (_a = this.eventHandlers).error) === null || _b === void 0 ? void 0 : _b.call(_a, new Error(event.message));
         };
         this.socket = socket;
         this.socket.addEventListener("open", this.handleOpen);

package/core/websocket/ws.d.ts

@@ -121,6 +121,15 @@ export declare class ReconnectingWebSocket {
     private _getNextDelay;
     private _wait;
     private _getNextUrl;
+    /**
+     * Handles the final "tear down" process when connection attempts must permanently stop
+     * (e.g., max retries reached, fatal configuration error).
+     * Releases locks, disables reconnection, dispatches final error and close events.
+     *
+     * @param error - The specific Error instance indicating the reason for termination.
+     * @param closeReason - The reason string to use for the final CloseEvent.
+     */
+    private _shutdown;
     private _connect;
     private _handleTimeout;
     private _disconnect;
@@ -128,7 +137,28 @@ export declare class ReconnectingWebSocket {
     private _callEventListener;
     private _handleOpen;
     private _handleMessage;
+    /**
+     * Adapts a raw error or event input into a standardized `Events.ErrorEvent`.
+     * This utility is called by `_handleError` to ensure it operates on a
+     * consistent error structure.
+     * @param rawErrorOrEventInput - The raw error data (e.g., Error instance, DOM Event, Events.ErrorEvent).
+     * @returns A standardized `Events.ErrorEvent` containing an underlying `Error` instance.
+     */
+    private _adaptError;
+    /**
+     * Core handler for all errors. It first standardizes the error input using `_adaptError`,
+     * then manages disconnection, dispatches the standardized error event, and initiates reconnection.
+     * @param rawErrorOrEventInput - The error data from any internal source.
+     */
     private _handleError;
+    /**
+     * Handles WebSocket close events, either native or synthesized internally.
+     *
+     * Adapts the event if necessary, manages state, dispatches standardized close events,
+     * and initiates reconnection if appropriate.
+     *
+     * @param eventInfo - Either an internal Events.CloseEvent or a native DOM CloseEvent.
+     */
     private _handleClose;
     private _removeListeners;
     private _addListeners;

package/core/websocket/ws.js

@@ -38,6 +38,7 @@ exports.ReconnectingWebSocket = void 0;
 const runtime_1 = require("../runtime");
 const Events = __importStar(require("./events"));
 const ws_1 = require("ws");
+const ABNORMAL_CLOSURE_CODE = 1006;
 const getGlobalWebSocket = () => {
     if (typeof WebSocket !== "undefined") {
         // @ts-ignore
@@ -115,33 +116,70 @@ class ReconnectingWebSocket {
             }
             this._listeners.message.forEach((listener) => this._callEventListener(event, listener));
         };
-        this._handleError = (event) => {
-            this._debug("error event", event.message);
-            this._disconnect(undefined, event.message === "TIMEOUT" ? "timeout" : undefined);
-            if (this.onerror) {
-                this.onerror(event);
-            }
+        /**
+         * Core handler for all errors. It first standardizes the error input using `_adaptError`,
+         * then manages disconnection, dispatches the standardized error event, and initiates reconnection.
+         * @param rawErrorOrEventInput - The error data from any internal source.
+         */
+        this._handleError = (rawErrorOrEventInput) => {
+            this._debug("Raw error/event received by _handleError, passing to _adaptError:", rawErrorOrEventInput);
+            const adaptedError = this._adaptError(rawErrorOrEventInput);
+            const { error, message } = adaptedError;
+            // Close with abnormal closure code so _handleClose will reconnect if there's a socket
+            this._disconnect(ABNORMAL_CLOSURE_CODE, message);
+            this._debug("Processed error. Dispatching Event:", message, error);
+            if (this.onerror)
+                this.onerror(adaptedError);
             this._debug("exec error listeners");
-            this._listeners.error.forEach((listener) => this._callEventListener(event, listener));
-            this._connect();
+            this._listeners.error.forEach((listener) => this._callEventListener(adaptedError, listener));
+            // If we never even got a ws instance, _disconnect returned early so we need to explicitly retry here
+            if (!this._ws && this._shouldReconnect) {
+                this._debug("Error before socket created; scheduling initial reconnect.");
+                this._connect();
+            }
         };
+        /**
+         * Handles WebSocket close events, either native or synthesized internally.
+         *
+         * Adapts the event if necessary, manages state, dispatches standardized close events,
+         * and initiates reconnection if appropriate.
+         *
+         * @param eventInfo - Either an internal Events.CloseEvent or a native DOM CloseEvent.
+         */
         this._handleClose = (event) => {
-            this._debug("close event");
+            this._debug("Raw close event received by _handleClose:", event);
+            // Adapt event if event is an instance of the (browser) native CloseEvent
+            const isNativeCloseEvent = typeof CloseEvent !== "undefined" && event instanceof CloseEvent;
+            const adaptedEvent = isNativeCloseEvent
+                ? new Events.CloseEvent(event.code, event.reason, this)
+                : event;
+            // Clean up state
             this._clearTimeouts();
-            if (event.code === 1000) {
+            this._ws = undefined;
+            this._connectLock = false;
+            // Determine reconnection intent
+            if (this._closeCalled) {
                 this._shouldReconnect = false;
+                this._debug("Reconnection stopped: RWS.close() was called.");
             }
-            if (this._shouldReconnect) {
-                this._connect();
-            }
-            if (this.onclose) {
-                this.onclose(event);
+            else if (adaptedEvent.code === 1000) {
+                this._shouldReconnect = false;
+                this._debug("Reconnection stopped: Received close code 1000 (intentional server close).");
             }
-            this._listeners.close.forEach((listener) => this._callEventListener(event, listener));
+            // Dispatch event to listeners
+            if (this.onclose)
+                this.onclose(adaptedEvent);
+            this._listeners.close.forEach((listener) => this._callEventListener(adaptedEvent, listener));
+            // Conditionally attempt reconnection
+            if (this._shouldReconnect)
+                this._connect();
         };
         this._url = url;
         this._protocols = protocols;
         this._options = options;
+        if (!isWebSocket(this._options.WebSocket)) {
+            throw Error("No valid WebSocket class provided");
+        }
         if (this._options.startClosed) {
             this._shouldReconnect = false;
         }
@@ -267,8 +305,8 @@ class ReconnectingWebSocket {
             this._connect();
         }
         else {
+            // If the socket is already connected then disconnect. The socket will conditionally reconnected in _handleClose
             this._disconnect(code, reason);
-            this._connect();
         }
     }
     /**
@@ -356,35 +394,73 @@ class ReconnectingWebSocket {
         }
         throw Error("Invalid URL");
     }
+    /**
+     * Handles the final "tear down" process when connection attempts must permanently stop
+     * (e.g., max retries reached, fatal configuration error).
+     * Releases locks, disables reconnection, dispatches final error and close events.
+     *
+     * @param error - The specific Error instance indicating the reason for termination.
+     * @param closeReason - The reason string to use for the final CloseEvent.
+     */
+    _shutdown(error, closeReason) {
+        this._debug("Terminating connection attempts. Reason:", error.message);
+        // Ensure state prevents further attempts
+        this._connectLock = false;
+        this._shouldReconnect = false;
+        // Dispatch error event
+        const errorEvent = this._adaptError(error);
+        if (this.onerror)
+            this.onerror(errorEvent);
+        this._listeners.error.forEach((listener) => this._callEventListener(errorEvent, listener));
+        // Dispatch close event
+        const closeEvent = new Events.CloseEvent(1000, closeReason, this);
+        if (this.onclose)
+            this.onclose(closeEvent);
+        this._listeners.close.forEach((listener) => this._callEventListener(closeEvent, listener));
+    }
     _connect() {
-        if (this._connectLock || !this._shouldReconnect) {
+        // Check locks and intent
+        if (this._connectLock) {
+            this._debug("Connection attempt already in progress.");
+            return;
+        }
+        if (!this._shouldReconnect) {
+            this._debug("Reconnection disabled, skipping connect attempt.");
             return;
         }
+        // Set lock for this attempt
         this._connectLock = true;
         const { maxRetries = DEFAULT.maxRetries, connectionTimeout = DEFAULT.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
+        // Max retries check
         if (this._retryCount >= maxRetries) {
-            this._debug("max retries reached", this._retryCount, ">=", maxRetries);
+            this._shutdown(new Error(`Max retries (${maxRetries}) reached. Giving up.`), "Max retries reached");
             return;
         }
+        // Prepare connection attempt
         this._retryCount++;
         this._debug("connect", this._retryCount);
         this._removeListeners();
-        if (!isWebSocket(WebSocket)) {
-            throw Error("No valid WebSocket class provided");
-        }
+        // Connection attempt
         this._wait()
             .then(() => this._getNextUrl(this._url))
             .then((url) => {
-            // close could be called before creating the ws
+            // Close could be called before creating the ws
             if (this._closeCalled) {
+                this._connectLock = false;
+                this._debug("Connection cancelled: ReconnectingWebSocket.close() called during setup.");
                 return;
             }
             this._debug("connect", { url, protocols: this._protocols });
             this._ws = this._protocols ? new WebSocket(url, this._protocols) : new WebSocket(url);
             this._ws.binaryType = this._binaryType;
-            this._connectLock = false;
             this._addListeners();
+            this._connectLock = false;
             this._connectTimeout = setTimeout(() => this._handleTimeout(), connectionTimeout);
+        })
+            .catch((error) => {
+            this._debug("Connection setup failed:", error);
+            this._connectLock = false;
+            this._handleError(error);
         });
     }
     _handleTimeout() {
@@ -419,6 +495,32 @@ class ReconnectingWebSocket {
             listener(event);
         }
     }
+    /**
+     * Adapts a raw error or event input into a standardized `Events.ErrorEvent`.
+     * This utility is called by `_handleError` to ensure it operates on a
+     * consistent error structure.
+     * @param rawErrorOrEventInput - The raw error data (e.g., Error instance, DOM Event, Events.ErrorEvent).
+     * @returns A standardized `Events.ErrorEvent` containing an underlying `Error` instance.
+     */
+    _adaptError(rawErrorOrEventInput) {
+        this._debug("Adapting raw error/event via _adaptError:", rawErrorOrEventInput);
+        let underlyingError;
+        if (rawErrorOrEventInput instanceof Events.ErrorEvent && rawErrorOrEventInput.error instanceof Error) {
+            return rawErrorOrEventInput;
+        }
+        if (rawErrorOrEventInput instanceof Error) {
+            underlyingError = rawErrorOrEventInput;
+        }
+        else if (typeof Event !== "undefined" &&
+            rawErrorOrEventInput instanceof Event &&
+            rawErrorOrEventInput.type === "error") {
+            underlyingError = new Error("WebSocket low-level error occurred (see browser/runtime console for native event details).");
+        }
+        else {
+            underlyingError = new Error(`Unknown WebSocket error. Raw data: ${String(rawErrorOrEventInput !== null && rawErrorOrEventInput !== void 0 ? rawErrorOrEventInput : "undefined")}`);
+        }
+        return new Events.ErrorEvent(underlyingError, this);
+    }
     _removeListeners() {
         if (!this._ws) {
             return;
@@ -438,7 +540,6 @@ class ReconnectingWebSocket {
         this._ws.addEventListener("open", this._handleOpen);
         this._ws.addEventListener("close", this._handleClose);
         this._ws.addEventListener("message", this._handleMessage);
-        // @ts-ignore
         this._ws.addEventListener("error", this._handleError);
     }
     _clearTimeouts() {

package/dist/api/resources/empathicVoice/resources/chat/client/Socket.js

@@ -75,15 +75,9 @@ class ChatSocket {
             (_b = (_a = this.eventHandlers).close) === null || _b === void 0 ? void 0 : _b.call(_a, event);
         };
         this.handleError = (event) => {
-            var _a, _b, _c, _d, _e, _f;
-            try {
-                const message = (_a = event.message) !== null && _a !== void 0 ? _a : `core.ReconnectingWebSocket error (${JSON.stringify(event)})`;
-                (_c = (_b = this.eventHandlers).error) === null || _c === void 0 ? void 0 : _c.call(_b, new Error(message));
-            }
-            catch (_g) {
-                const message = (_d = event.message) !== null && _d !== void 0 ? _d : `core.ReconnectingWebSocket error (unable to stringify)`;
-                (_f = (_e = this.eventHandlers).error) === null || _f === void 0 ? void 0 : _f.call(_e, new Error(message));
-            }
+            var _a, _b;
+            // Create and dispatch a new Error object using the message from the standardized event.
+            (_b = (_a = this.eventHandlers).error) === null || _b === void 0 ? void 0 : _b.call(_a, new Error(event.message));
         };
         this.socket = socket;
         this.socket.addEventListener("open", this.handleOpen);

package/dist/core/websocket/ws.d.ts

@@ -121,6 +121,15 @@ export declare class ReconnectingWebSocket {
     private _getNextDelay;
     private _wait;
     private _getNextUrl;
+    /**
+     * Handles the final "tear down" process when connection attempts must permanently stop
+     * (e.g., max retries reached, fatal configuration error).
+     * Releases locks, disables reconnection, dispatches final error and close events.
+     *
+     * @param error - The specific Error instance indicating the reason for termination.
+     * @param closeReason - The reason string to use for the final CloseEvent.
+     */
+    private _shutdown;
     private _connect;
     private _handleTimeout;
     private _disconnect;
@@ -128,7 +137,28 @@ export declare class ReconnectingWebSocket {
     private _callEventListener;
     private _handleOpen;
     private _handleMessage;
+    /**
+     * Adapts a raw error or event input into a standardized `Events.ErrorEvent`.
+     * This utility is called by `_handleError` to ensure it operates on a
+     * consistent error structure.
+     * @param rawErrorOrEventInput - The raw error data (e.g., Error instance, DOM Event, Events.ErrorEvent).
+     * @returns A standardized `Events.ErrorEvent` containing an underlying `Error` instance.
+     */
+    private _adaptError;
+    /**
+     * Core handler for all errors. It first standardizes the error input using `_adaptError`,
+     * then manages disconnection, dispatches the standardized error event, and initiates reconnection.
+     * @param rawErrorOrEventInput - The error data from any internal source.
+     */
     private _handleError;
+    /**
+     * Handles WebSocket close events, either native or synthesized internally.
+     *
+     * Adapts the event if necessary, manages state, dispatches standardized close events,
+     * and initiates reconnection if appropriate.
+     *
+     * @param eventInfo - Either an internal Events.CloseEvent or a native DOM CloseEvent.
+     */
     private _handleClose;
     private _removeListeners;
     private _addListeners;

package/dist/core/websocket/ws.js

@@ -38,6 +38,7 @@ exports.ReconnectingWebSocket = void 0;
 const runtime_1 = require("../runtime");
 const Events = __importStar(require("./events"));
 const ws_1 = require("ws");
+const ABNORMAL_CLOSURE_CODE = 1006;
 const getGlobalWebSocket = () => {
     if (typeof WebSocket !== "undefined") {
         // @ts-ignore
@@ -115,33 +116,70 @@ class ReconnectingWebSocket {
             }
             this._listeners.message.forEach((listener) => this._callEventListener(event, listener));
         };
-        this._handleError = (event) => {
-            this._debug("error event", event.message);
-            this._disconnect(undefined, event.message === "TIMEOUT" ? "timeout" : undefined);
-            if (this.onerror) {
-                this.onerror(event);
-            }
+        /**
+         * Core handler for all errors. It first standardizes the error input using `_adaptError`,
+         * then manages disconnection, dispatches the standardized error event, and initiates reconnection.
+         * @param rawErrorOrEventInput - The error data from any internal source.
+         */
+        this._handleError = (rawErrorOrEventInput) => {
+            this._debug("Raw error/event received by _handleError, passing to _adaptError:", rawErrorOrEventInput);
+            const adaptedError = this._adaptError(rawErrorOrEventInput);
+            const { error, message } = adaptedError;
+            // Close with abnormal closure code so _handleClose will reconnect if there's a socket
+            this._disconnect(ABNORMAL_CLOSURE_CODE, message);
+            this._debug("Processed error. Dispatching Event:", message, error);
+            if (this.onerror)
+                this.onerror(adaptedError);
             this._debug("exec error listeners");
-            this._listeners.error.forEach((listener) => this._callEventListener(event, listener));
-            this._connect();
+            this._listeners.error.forEach((listener) => this._callEventListener(adaptedError, listener));
+            // If we never even got a ws instance, _disconnect returned early so we need to explicitly retry here
+            if (!this._ws && this._shouldReconnect) {
+                this._debug("Error before socket created; scheduling initial reconnect.");
+                this._connect();
+            }
         };
+        /**
+         * Handles WebSocket close events, either native or synthesized internally.
+         *
+         * Adapts the event if necessary, manages state, dispatches standardized close events,
+         * and initiates reconnection if appropriate.
+         *
+         * @param eventInfo - Either an internal Events.CloseEvent or a native DOM CloseEvent.
+         */
         this._handleClose = (event) => {
-            this._debug("close event");
+            this._debug("Raw close event received by _handleClose:", event);
+            // Adapt event if event is an instance of the (browser) native CloseEvent
+            const isNativeCloseEvent = typeof CloseEvent !== "undefined" && event instanceof CloseEvent;
+            const adaptedEvent = isNativeCloseEvent
+                ? new Events.CloseEvent(event.code, event.reason, this)
+                : event;
+            // Clean up state
             this._clearTimeouts();
-            if (event.code === 1000) {
+            this._ws = undefined;
+            this._connectLock = false;
+            // Determine reconnection intent
+            if (this._closeCalled) {
                 this._shouldReconnect = false;
+                this._debug("Reconnection stopped: RWS.close() was called.");
             }
-            if (this._shouldReconnect) {
-                this._connect();
-            }
-            if (this.onclose) {
-                this.onclose(event);
+            else if (adaptedEvent.code === 1000) {
+                this._shouldReconnect = false;
+                this._debug("Reconnection stopped: Received close code 1000 (intentional server close).");
             }
-            this._listeners.close.forEach((listener) => this._callEventListener(event, listener));
+            // Dispatch event to listeners
+            if (this.onclose)
+                this.onclose(adaptedEvent);
+            this._listeners.close.forEach((listener) => this._callEventListener(adaptedEvent, listener));
+            // Conditionally attempt reconnection
+            if (this._shouldReconnect)
+                this._connect();
         };
         this._url = url;
         this._protocols = protocols;
         this._options = options;
+        if (!isWebSocket(this._options.WebSocket)) {
+            throw Error("No valid WebSocket class provided");
+        }
         if (this._options.startClosed) {
             this._shouldReconnect = false;
         }
@@ -267,8 +305,8 @@ class ReconnectingWebSocket {
             this._connect();
         }
         else {
+            // If the socket is already connected then disconnect. The socket will conditionally reconnected in _handleClose
             this._disconnect(code, reason);
-            this._connect();
         }
     }
     /**
@@ -356,35 +394,73 @@ class ReconnectingWebSocket {
         }
         throw Error("Invalid URL");
     }
+    /**
+     * Handles the final "tear down" process when connection attempts must permanently stop
+     * (e.g., max retries reached, fatal configuration error).
+     * Releases locks, disables reconnection, dispatches final error and close events.
+     *
+     * @param error - The specific Error instance indicating the reason for termination.
+     * @param closeReason - The reason string to use for the final CloseEvent.
+     */
+    _shutdown(error, closeReason) {
+        this._debug("Terminating connection attempts. Reason:", error.message);
+        // Ensure state prevents further attempts
+        this._connectLock = false;
+        this._shouldReconnect = false;
+        // Dispatch error event
+        const errorEvent = this._adaptError(error);
+        if (this.onerror)
+            this.onerror(errorEvent);
+        this._listeners.error.forEach((listener) => this._callEventListener(errorEvent, listener));
+        // Dispatch close event
+        const closeEvent = new Events.CloseEvent(1000, closeReason, this);
+        if (this.onclose)
+            this.onclose(closeEvent);
+        this._listeners.close.forEach((listener) => this._callEventListener(closeEvent, listener));
+    }
     _connect() {
-        if (this._connectLock || !this._shouldReconnect) {
+        // Check locks and intent
+        if (this._connectLock) {
+            this._debug("Connection attempt already in progress.");
+            return;
+        }
+        if (!this._shouldReconnect) {
+            this._debug("Reconnection disabled, skipping connect attempt.");
             return;
         }
+        // Set lock for this attempt
         this._connectLock = true;
         const { maxRetries = DEFAULT.maxRetries, connectionTimeout = DEFAULT.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
+        // Max retries check
         if (this._retryCount >= maxRetries) {
-            this._debug("max retries reached", this._retryCount, ">=", maxRetries);
+            this._shutdown(new Error(`Max retries (${maxRetries}) reached. Giving up.`), "Max retries reached");
             return;
         }
+        // Prepare connection attempt
         this._retryCount++;
         this._debug("connect", this._retryCount);
         this._removeListeners();
-        if (!isWebSocket(WebSocket)) {
-            throw Error("No valid WebSocket class provided");
-        }
+        // Connection attempt
         this._wait()
             .then(() => this._getNextUrl(this._url))
             .then((url) => {
-            // close could be called before creating the ws
+            // Close could be called before creating the ws
             if (this._closeCalled) {
+                this._connectLock = false;
+                this._debug("Connection cancelled: ReconnectingWebSocket.close() called during setup.");
                 return;
             }
             this._debug("connect", { url, protocols: this._protocols });
             this._ws = this._protocols ? new WebSocket(url, this._protocols) : new WebSocket(url);
             this._ws.binaryType = this._binaryType;
-            this._connectLock = false;
             this._addListeners();
+            this._connectLock = false;
             this._connectTimeout = setTimeout(() => this._handleTimeout(), connectionTimeout);
+        })
+            .catch((error) => {
+            this._debug("Connection setup failed:", error);
+            this._connectLock = false;
+            this._handleError(error);
         });
     }
     _handleTimeout() {
@@ -419,6 +495,32 @@ class ReconnectingWebSocket {
             listener(event);
         }
     }
+    /**
+     * Adapts a raw error or event input into a standardized `Events.ErrorEvent`.
+     * This utility is called by `_handleError` to ensure it operates on a
+     * consistent error structure.
+     * @param rawErrorOrEventInput - The raw error data (e.g., Error instance, DOM Event, Events.ErrorEvent).
+     * @returns A standardized `Events.ErrorEvent` containing an underlying `Error` instance.
+     */
+    _adaptError(rawErrorOrEventInput) {
+        this._debug("Adapting raw error/event via _adaptError:", rawErrorOrEventInput);
+        let underlyingError;
+        if (rawErrorOrEventInput instanceof Events.ErrorEvent && rawErrorOrEventInput.error instanceof Error) {
+            return rawErrorOrEventInput;
+        }
+        if (rawErrorOrEventInput instanceof Error) {
+            underlyingError = rawErrorOrEventInput;
+        }
+        else if (typeof Event !== "undefined" &&
+            rawErrorOrEventInput instanceof Event &&
+            rawErrorOrEventInput.type === "error") {
+            underlyingError = new Error("WebSocket low-level error occurred (see browser/runtime console for native event details).");
+        }
+        else {
+            underlyingError = new Error(`Unknown WebSocket error. Raw data: ${String(rawErrorOrEventInput !== null && rawErrorOrEventInput !== void 0 ? rawErrorOrEventInput : "undefined")}`);
+        }
+        return new Events.ErrorEvent(underlyingError, this);
+    }
     _removeListeners() {
         if (!this._ws) {
             return;
@@ -438,7 +540,6 @@ class ReconnectingWebSocket {
         this._ws.addEventListener("open", this._handleOpen);
         this._ws.addEventListener("close", this._handleClose);
         this._ws.addEventListener("message", this._handleMessage);
-        // @ts-ignore
         this._ws.addEventListener("error", this._handleError);
     }
     _clearTimeouts() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hume",
-    "version": "0.10.4-beta.2",
+    "version": "0.10.4-beta.3",
     "private": false,
     "repository": "https://github.com/HumeAI/hume-typescript-sdk",
     "main": "./index.js",