@moxt-ai/mobius-sdk 0.0.3

package/dist/client.js

@@ -0,0 +1,624 @@
+import { AGENT_ACTIVITY_KIND, AGENT_CONTENT_KIND, AGENT_INSTALL_CANCEL_KIND, AGENT_INSTALL_CANCELLED_KIND, AGENT_INSTALL_COMPLETED_KIND, AGENT_INSTALL_FAILED_KIND, AGENT_INSTALL_PROGRESS_KIND, AGENT_INSTALL_REQUEST_KIND, AGENT_INSTALL_STARTED_KIND, AGENT_MESSAGE_DELTA_KIND, decodeAgentActivityEvent, decodeAgentContentEvent, decodeAgentInstallCancelCommand, decodeAgentInstallCancelledEvent, decodeAgentInstallCompletedEvent, decodeAgentInstallFailedEvent, decodeAgentInstallProgressEvent, decodeAgentInstallRequestCommand, decodeAgentInstallStartedEvent, decodeAgentMessageDeltaEvent, decodeCommittedSessionEvent, decodeMessageKind, decodeNativeSessionCancel, decodeNativeSessionCommand, decodeNativeSessionResult, decodeNativeSessionTurnForkRequest, decodeRecordedSessionEvent, decodeRuntimeStatusEvent, decodeSessionCancelCommand, decodeSessionCommandsUpdatedEvent, decodeSessionCompletedEvent, decodeSessionConfigUpdatedEvent, decodeSessionConfigureCommand, decodeSessionElicitationRequestedEvent, decodeSessionElicitationResolvedEvent, decodeSessionElicitationRespondCommand, decodeSessionFailedEvent, decodeSessionInfoUpdatedEvent, decodeSessionOperationFailedEvent, decodeSessionPermissionRequestedEvent, decodeSessionPermissionResolvedEvent, decodeSessionPermissionRespondCommand, decodeSessionPrepareCommand, decodeSessionPromptCommand, decodeSessionReadyEvent, decodeSessionStartedEvent, decodeSessionUsageUpdatedEvent, decodeWorkspaceEntriesEvent, decodeWorkspaceListCommand, encodeAgentInstallCancelCommand, encodeAgentInstallRequestCommand, encodeNativeSessionCancel, encodeNativeSessionCommand, encodeNativeSessionTurnForkRequest, encodeSessionCancelCommand, encodeSessionConfigureCommand, encodeSessionElicitationRespondCommand, encodeSessionPermissionRespondCommand, encodeSessionPrepareCommand, encodeSessionPromptCommand, encodeWorkspaceListCommand, NATIVE_SESSION_CANCEL_KIND, NATIVE_SESSION_REQUEST_KIND, NATIVE_SESSION_RESULT_KIND, NATIVE_SESSION_TURN_FORK_REQUEST_KIND, RUNTIME_STATUS_KIND, SESSION_CANCEL_KIND, SESSION_COMMANDS_UPDATED_KIND, SESSION_COMPLETED_KIND, SESSION_CONFIG_UPDATED_KIND, SESSION_CONFIGURE_KIND, SESSION_ELICITATION_REQUESTED_KIND, SESSION_ELICITATION_RESOLVED_KIND, SESSION_ELICITATION_RESPOND_KIND, SESSION_EVENT_COMMITTED_KIND, SESSION_FAILED_KIND, SESSION_INFO_UPDATED_KIND, SESSION_OPERATION_FAILED_KIND, SESSION_PERMISSION_REQUESTED_KIND, SESSION_PERMISSION_RESOLVED_KIND, SESSION_PERMISSION_RESPOND_KIND, SESSION_PREPARE_KIND, SESSION_PROMPT_KIND, SESSION_READY_KIND, SESSION_STARTED_KIND, SESSION_USAGE_UPDATED_KIND, SessionPromptDisposition, WORKSPACE_ENTRIES_KIND, WORKSPACE_LIST_KIND, } from "@moxt-ai/mobius-protocol";
+import ReconnectingWebSocket, {} from "partysocket/ws";
+const CONNECTION_TIMEOUT_MILLISECONDS = 15_000;
+const MAX_RECONNECTION_DELAY_MILLISECONDS = 10_000;
+const MIN_RECONNECTION_DELAY_MILLISECONDS = 500;
+const OPERATION_TIMEOUT_MILLISECONDS = 120_000;
+const INSTALLATION_TIMEOUT_MILLISECONDS = 11 * 60 * 1_000;
+const TERMINAL_RELAY_CLOSE_CODES = new Set([1002, 1003, 1007, 1008, 4003, 4008]);
+export class MobiusClientError extends Error {
+    code;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.code = code;
+        this.name = "MobiusClientError";
+    }
+}
+function readMessageText(event) {
+    if (typeof event.data !== "string") {
+        throw new MobiusClientError("invalid_protocol_message", "Relay sent a non-text WebSocket message");
+    }
+    return event.data;
+}
+function readInboundMessage(event) {
+    const encoded = readMessageText(event);
+    if (decodeMessageKind(encoded) !== SESSION_EVENT_COMMITTED_KIND) {
+        return encoded;
+    }
+    const committed = decodeCommittedSessionEvent(encoded);
+    decodeRecordedSessionEvent(committed.payload);
+    return committed.payload;
+}
+function readInboundCommittedSequence(event) {
+    const encoded = readMessageText(event);
+    if (decodeMessageKind(encoded) !== SESSION_EVENT_COMMITTED_KIND) {
+        throw new MobiusClientError("invalid_protocol_message", "Relay sent an uncommitted Session event");
+    }
+    return decodeCommittedSessionEvent(encoded).sequence;
+}
+function encodeOutboundMessage(encode) {
+    try {
+        return encode();
+    }
+    catch (error) {
+        throw new MobiusClientError("invalid_request", "The requested operation contains invalid data", {
+            cause: error,
+        });
+    }
+}
+function sendImmediately(socket, message) {
+    if (!socket.send(message)) {
+        throw new MobiusClientError("connection_closed", "Relay connection closed before the message was sent");
+    }
+}
+function shouldReconnectAfterClose(event) {
+    return !TERMINAL_RELAY_CLOSE_CODES.has(event.code);
+}
+function waitForOpen(socket) {
+    if (socket.readyState === WebSocket.OPEN) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const timeout = window.setTimeout(() => {
+            cleanup();
+            reject(new MobiusClientError("connection_timeout", "Timed out while connecting to the relay"));
+        }, CONNECTION_TIMEOUT_MILLISECONDS);
+        const cleanup = () => {
+            window.clearTimeout(timeout);
+            socket.removeEventListener("close", handleClose);
+            socket.removeEventListener("open", handleOpen);
+        };
+        const handleClose = (event) => {
+            if (shouldReconnectAfterClose(event)) {
+                return;
+            }
+            cleanup();
+            reject(new MobiusClientError("connection_rejected", "The relay rejected the WebSocket connection"));
+        };
+        const handleOpen = () => {
+            cleanup();
+            resolve();
+        };
+        socket.addEventListener("close", handleClose);
+        socket.addEventListener("open", handleOpen);
+    });
+}
+export class MobiusClient {
+    #onActivity;
+    #onProtocolError;
+    #onStatus;
+    #options;
+    #socket;
+    constructor(socket, options) {
+        this.#options = options;
+        this.#onActivity = options.onActivity ?? (() => undefined);
+        this.#onProtocolError = options.onProtocolError ?? (() => undefined);
+        this.#onStatus = options.onStatus ?? (() => undefined);
+        this.#socket = socket;
+        this.#socket.addEventListener("message", this.#handleChannelMessage);
+        this.#socket.addEventListener("close", this.#handleClose);
+    }
+    ready = async () => {
+        await waitForOpen(this.#socket);
+    };
+    listWorkspace = async (request, signal) => {
+        const requestId = request.requestId ?? crypto.randomUUID();
+        return await this.#requestReply(requestId, encodeOutboundMessage(() => encodeWorkspaceListCommand({
+            bindingId: request.bindingId,
+            directoryId: request.directoryId,
+            kind: WORKSPACE_LIST_KIND,
+            requestId,
+        })), WORKSPACE_ENTRIES_KIND, decodeWorkspaceEntriesEvent, (event) => event.requestId, signal);
+    };
+    prepareSession = async (request, signal) => {
+        const requestId = request.requestId ?? crypto.randomUUID();
+        return await this.#requestReply(requestId, encodeOutboundMessage(() => encodeSessionPrepareCommand({
+            additionalDirectoryIds: request.additionalDirectoryIds,
+            agentId: request.agentId,
+            bindingId: request.bindingId,
+            directoryId: request.directoryId,
+            kind: SESSION_PREPARE_KIND,
+            requestId,
+            sessionId: request.sessionId,
+        })), SESSION_READY_KIND, decodeSessionReadyEvent, (event) => event.requestId, signal);
+    };
+    manageNativeSession = async (command, signal) => {
+        signal.throwIfAborted();
+        return await this.#requestReply(command.requestId, encodeOutboundMessage(() => encodeNativeSessionCommand(command)), NATIVE_SESSION_RESULT_KIND, decodeNativeSessionResult, (event) => event.requestId, signal, () => {
+            try {
+                if (this.#socket.readyState === WebSocket.OPEN) {
+                    sendImmediately(this.#socket, encodeNativeSessionCancel({
+                        kind: NATIVE_SESSION_CANCEL_KIND,
+                        requestId: command.requestId,
+                        sessionId: command.sessionId,
+                    }));
+                }
+            }
+            catch {
+                // The local runtime also cancels requests when the connection closes.
+            }
+        });
+    };
+    forkSessionTurn = async (command, signal) => {
+        signal.throwIfAborted();
+        return await this.#requestReply(command.requestId, encodeOutboundMessage(() => encodeNativeSessionTurnForkRequest(command)), NATIVE_SESSION_RESULT_KIND, decodeNativeSessionResult, (event) => event.requestId, signal, () => {
+            try {
+                if (this.#socket.readyState === WebSocket.OPEN) {
+                    sendImmediately(this.#socket, encodeNativeSessionCancel({
+                        kind: NATIVE_SESSION_CANCEL_KIND,
+                        requestId: command.requestId,
+                        sessionId: command.sessionId,
+                    }));
+                }
+            }
+            catch {
+                // The local runtime also cancels requests when the connection closes.
+            }
+        });
+    };
+    configureSession = async (request, signal) => {
+        const requestId = request.requestId ?? crypto.randomUUID();
+        return await this.#requestReply(requestId, encodeOutboundMessage(() => encodeSessionConfigureCommand({
+            additionalDirectoryIds: request.additionalDirectoryIds,
+            agentId: request.agentId,
+            bindingId: request.bindingId,
+            booleanValue: request.booleanValue,
+            configId: request.configId,
+            directoryId: request.directoryId,
+            kind: SESSION_CONFIGURE_KIND,
+            requestId,
+            sessionId: request.sessionId,
+            value: request.value,
+            valueType: request.valueType,
+        })), SESSION_CONFIG_UPDATED_KIND, decodeSessionConfigUpdatedEvent, (event) => event.requestId, signal);
+    };
+    respondPermission = async (request) => await this.#requestReply(request.interactionId, encodeOutboundMessage(() => encodeSessionPermissionRespondCommand({
+        interactionId: request.interactionId,
+        kind: SESSION_PERMISSION_RESPOND_KIND,
+        optionId: request.optionId,
+        outcome: request.outcome,
+        sessionId: request.sessionId,
+    })), SESSION_PERMISSION_RESOLVED_KIND, decodeSessionPermissionResolvedEvent, (event) => event.interactionId);
+    respondElicitation = async (request) => await this.#requestReply(request.interactionId, encodeOutboundMessage(() => encodeSessionElicitationRespondCommand({
+        action: request.action,
+        content: request.content,
+        interactionId: request.interactionId,
+        kind: SESSION_ELICITATION_RESPOND_KIND,
+        sessionId: request.sessionId,
+    })), SESSION_ELICITATION_RESOLVED_KIND, decodeSessionElicitationResolvedEvent, (event) => event.interactionId);
+    cancel = (request) => {
+        if (this.#socket.readyState !== WebSocket.OPEN) {
+            throw new MobiusClientError("runtime_offline", "The relay connection is not open");
+        }
+        try {
+            sendImmediately(this.#socket, encodeOutboundMessage(() => encodeSessionCancelCommand({
+                commandId: request.commandId,
+                kind: SESSION_CANCEL_KIND,
+                sessionId: request.sessionId,
+            })));
+        }
+        catch (error) {
+            throw new MobiusClientError("connection_closed", "Could not send cancellation to the relay", {
+                cause: error,
+            });
+        }
+    };
+    cancelAgentInstallation = (request) => {
+        if (this.#socket.readyState !== WebSocket.OPEN) {
+            throw new MobiusClientError("runtime_offline", "The relay connection is not open");
+        }
+        try {
+            sendImmediately(this.#socket, encodeOutboundMessage(() => encodeAgentInstallCancelCommand({
+                kind: AGENT_INSTALL_CANCEL_KIND,
+                requestId: request.requestId,
+            })));
+        }
+        catch (error) {
+            throw new MobiusClientError("connection_closed", "Could not send Agent installation cancellation to the relay", { cause: error });
+        }
+    };
+    installAgent = async (request) => {
+        if (this.#socket.readyState !== WebSocket.OPEN) {
+            throw new MobiusClientError("runtime_offline", "The relay connection is not open");
+        }
+        const requestId = request.requestId ?? crypto.randomUUID();
+        let cleanupInstallation = () => undefined;
+        const result = new Promise((resolveInstallation, rejectInstallation) => {
+            const timeout = window.setTimeout(() => {
+                cleanup();
+                rejectInstallation(new MobiusClientError("installation_timeout", "Timed out while waiting for the local Agent installation"));
+            }, INSTALLATION_TIMEOUT_MILLISECONDS);
+            const cleanup = () => {
+                window.clearTimeout(timeout);
+                this.#socket.removeEventListener("message", handleMessage);
+                this.#socket.removeEventListener("close", handleClose);
+            };
+            cleanupInstallation = cleanup;
+            const handleClose = () => {
+                cleanup();
+                rejectInstallation(new MobiusClientError("connection_closed", "Relay connection closed while Agent installation was running"));
+            };
+            const handleMessage = (message) => {
+                try {
+                    const encoded = readInboundMessage(message);
+                    const kind = decodeMessageKind(encoded);
+                    if (kind === AGENT_INSTALL_COMPLETED_KIND) {
+                        const completed = decodeAgentInstallCompletedEvent(encoded);
+                        if (completed.requestId === requestId) {
+                            cleanup();
+                            resolveInstallation(completed);
+                        }
+                        return;
+                    }
+                    if (kind === AGENT_INSTALL_FAILED_KIND) {
+                        const failed = decodeAgentInstallFailedEvent(encoded);
+                        if (failed.requestId === requestId) {
+                            cleanup();
+                            rejectInstallation(new MobiusClientError(failed.code, failed.message));
+                        }
+                        return;
+                    }
+                    if (kind === AGENT_INSTALL_CANCELLED_KIND) {
+                        const cancelled = decodeAgentInstallCancelledEvent(encoded);
+                        if (cancelled.requestId === requestId) {
+                            cleanup();
+                            rejectInstallation(new MobiusClientError("installation_cancelled", "The local Agent installation was cancelled"));
+                        }
+                        return;
+                    }
+                    if (kind === SESSION_OPERATION_FAILED_KIND) {
+                        const failed = decodeSessionOperationFailedEvent(encoded);
+                        if (failed.requestId === requestId) {
+                            cleanup();
+                            rejectInstallation(new MobiusClientError(failed.code, failed.message));
+                        }
+                    }
+                }
+                catch (error) {
+                    cleanup();
+                    rejectInstallation(new MobiusClientError("invalid_protocol_message", "Received an invalid Agent installation message", { cause: error }));
+                }
+            };
+            this.#socket.addEventListener("message", handleMessage);
+            this.#socket.addEventListener("close", handleClose, { once: true });
+        });
+        try {
+            sendImmediately(this.#socket, encodeOutboundMessage(() => encodeAgentInstallRequestCommand({
+                agentId: request.agentId,
+                kind: AGENT_INSTALL_REQUEST_KIND,
+                requestId,
+            })));
+        }
+        catch (error) {
+            cleanupInstallation();
+            throw new MobiusClientError("connection_closed", "Could not send the Agent installation request to the relay", { cause: error });
+        }
+        return await result;
+    };
+    prompt = async (request) => {
+        if (this.#socket.readyState !== WebSocket.OPEN) {
+            throw new MobiusClientError("runtime_offline", "The relay connection is not open");
+        }
+        const commandId = request.commandId ?? crypto.randomUUID();
+        const sessionId = request.sessionId ?? crypto.randomUUID();
+        const outbound = encodeOutboundMessage(() => encodeSessionPromptCommand({
+            additionalDirectoryIds: request.additionalDirectoryIds ?? [],
+            agentId: request.agentId,
+            bindingId: request.bindingId,
+            commandId,
+            directoryId: request.directoryId ?? "default",
+            disposition: request.disposition ?? SessionPromptDisposition.Reject,
+            images: request.images ?? [],
+            kind: SESSION_PROMPT_KIND,
+            prompt: request.prompt,
+            resources: request.resources ?? [],
+            sessionId,
+            targetCommandId: request.targetCommandId ?? "",
+        }));
+        let cleanupPrompt = () => undefined;
+        const result = new Promise((resolve, reject) => {
+            const cleanup = () => {
+                this.#socket.removeEventListener("message", handleMessage);
+                this.#socket.removeEventListener("close", handleSocketClose);
+            };
+            cleanupPrompt = cleanup;
+            const handleSocketClose = () => {
+                cleanup();
+                reject(new MobiusClientError("connection_closed", "Relay connection closed while the request was running"));
+            };
+            const handleMessage = (event) => {
+                try {
+                    const encoded = readInboundMessage(event);
+                    const kind = decodeMessageKind(encoded);
+                    if (kind === SESSION_STARTED_KIND) {
+                        const message = decodeSessionStartedEvent(encoded);
+                        if (message.commandId === commandId) {
+                            request.observer?.onStarted?.(message.attemptId);
+                        }
+                        return;
+                    }
+                    if (kind === AGENT_MESSAGE_DELTA_KIND) {
+                        const message = decodeAgentMessageDeltaEvent(encoded);
+                        if (message.commandId === commandId) {
+                            request.observer?.onDelta?.(message.text, readInboundCommittedSequence(event));
+                        }
+                        return;
+                    }
+                    if (kind === AGENT_ACTIVITY_KIND) {
+                        const message = decodeAgentActivityEvent(encoded);
+                        if (message.commandId === commandId) {
+                            request.observer?.onActivity?.(message);
+                        }
+                        return;
+                    }
+                    if (kind === AGENT_CONTENT_KIND) {
+                        const message = decodeAgentContentEvent(encoded);
+                        if (message.commandId === commandId) {
+                            request.observer?.onContent?.(message);
+                        }
+                        return;
+                    }
+                    if (kind === SESSION_COMPLETED_KIND) {
+                        const message = decodeSessionCompletedEvent(encoded);
+                        if (message.commandId === commandId) {
+                            cleanup();
+                            resolve({
+                                sessionId: message.sessionId,
+                                stopReason: message.stopReason,
+                            });
+                        }
+                        return;
+                    }
+                    if (kind === SESSION_FAILED_KIND) {
+                        const message = decodeSessionFailedEvent(encoded);
+                        if (message.commandId === commandId) {
+                            cleanup();
+                            reject(new MobiusClientError(message.code, message.message));
+                        }
+                    }
+                }
+                catch (error) {
+                    cleanup();
+                    reject(new MobiusClientError("invalid_protocol_message", "Received an invalid message from the relay", { cause: error }));
+                }
+            };
+            this.#socket.addEventListener("message", handleMessage);
+            this.#socket.addEventListener("close", handleSocketClose, { once: true });
+        });
+        try {
+            sendImmediately(this.#socket, outbound);
+        }
+        catch (error) {
+            cleanupPrompt();
+            throw new MobiusClientError("connection_closed", "Could not send the request to the relay", {
+                cause: error,
+            });
+        }
+        return result;
+    };
+    #requestReply = async (requestId, outbound, expectedKind, decode, identify, signal, cancel) => {
+        signal?.throwIfAborted();
+        if (this.#socket.readyState !== WebSocket.OPEN) {
+            throw new MobiusClientError("runtime_offline", "The relay connection is not open");
+        }
+        let cleanupRequest = () => undefined;
+        const result = new Promise((resolve, reject) => {
+            const timeout = window.setTimeout(() => {
+                cleanup();
+                cancel?.();
+                reject(new MobiusClientError("operation_timeout", "Timed out while waiting for the local runtime"));
+            }, OPERATION_TIMEOUT_MILLISECONDS);
+            const cleanup = () => {
+                window.clearTimeout(timeout);
+                this.#socket.removeEventListener("message", handleMessage);
+                this.#socket.removeEventListener("close", handleClose);
+                signal?.removeEventListener("abort", handleAbort);
+            };
+            const handleAbort = () => {
+                cleanup();
+                cancel?.();
+                reject(signal?.reason ??
+                    new MobiusClientError("operation_cancelled", "Native session operation cancelled"));
+            };
+            cleanupRequest = cleanup;
+            const handleClose = () => {
+                cleanup();
+                reject(new MobiusClientError("connection_closed", "Relay connection closed while the operation was running"));
+            };
+            const handleMessage = (message) => {
+                try {
+                    const encoded = readInboundMessage(message);
+                    const kind = decodeMessageKind(encoded);
+                    if (kind === SESSION_OPERATION_FAILED_KIND) {
+                        const failure = decodeSessionOperationFailedEvent(encoded);
+                        if (failure.requestId === requestId) {
+                            cleanup();
+                            reject(new MobiusClientError(failure.code, failure.message));
+                        }
+                        return;
+                    }
+                    if (kind !== expectedKind) {
+                        return;
+                    }
+                    const event = decode(encoded);
+                    if (identify(event) === requestId) {
+                        cleanup();
+                        resolve(event);
+                    }
+                }
+                catch (error) {
+                    cleanup();
+                    reject(new MobiusClientError("invalid_protocol_message", "Received an invalid message from the relay", { cause: error }));
+                }
+            };
+            this.#socket.addEventListener("message", handleMessage);
+            this.#socket.addEventListener("close", handleClose, { once: true });
+            signal?.addEventListener("abort", handleAbort, { once: true });
+        });
+        try {
+            sendImmediately(this.#socket, outbound);
+        }
+        catch (error) {
+            cleanupRequest();
+            throw new MobiusClientError("connection_closed", "Could not send the operation to the relay", {
+                cause: error,
+            });
+        }
+        return await result;
+    };
+    close = () => {
+        this.#socket.removeEventListener("message", this.#handleChannelMessage);
+        this.#socket.removeEventListener("close", this.#handleClose);
+        this.#socket.close(1000, "Host closed");
+    };
+    #handleClose = (event) => {
+        if (shouldReconnectAfterClose(event)) {
+            this.#options.onReconnecting?.();
+            return;
+        }
+        this.#options.onUnavailable?.();
+    };
+    #handleChannelMessage = (event) => {
+        try {
+            const encoded = readInboundMessage(event);
+            const kind = decodeMessageKind(encoded);
+            if (kind === RUNTIME_STATUS_KIND) {
+                this.#onStatus(decodeRuntimeStatusEvent(encoded).online);
+                return;
+            }
+            if (kind === SESSION_PROMPT_KIND) {
+                decodeSessionPromptCommand(encoded);
+            }
+            else if (kind === NATIVE_SESSION_REQUEST_KIND) {
+                decodeNativeSessionCommand(encoded);
+            }
+            else if (kind === NATIVE_SESSION_TURN_FORK_REQUEST_KIND) {
+                decodeNativeSessionTurnForkRequest(encoded);
+            }
+            else if (kind === NATIVE_SESSION_CANCEL_KIND) {
+                decodeNativeSessionCancel(encoded);
+            }
+            else if (kind === NATIVE_SESSION_RESULT_KIND) {
+                this.#options.onNativeSessionResult?.(decodeNativeSessionResult(encoded));
+            }
+            else if (kind === SESSION_CANCEL_KIND) {
+                decodeSessionCancelCommand(encoded);
+            }
+            else if (kind === WORKSPACE_LIST_KIND) {
+                decodeWorkspaceListCommand(encoded);
+            }
+            else if (kind === WORKSPACE_ENTRIES_KIND) {
+                this.#options.onWorkspace?.(decodeWorkspaceEntriesEvent(encoded));
+            }
+            else if (kind === SESSION_PREPARE_KIND) {
+                decodeSessionPrepareCommand(encoded);
+            }
+            else if (kind === SESSION_READY_KIND) {
+                this.#options.onReady?.(decodeSessionReadyEvent(encoded));
+            }
+            else if (kind === SESSION_CONFIGURE_KIND) {
+                decodeSessionConfigureCommand(encoded);
+            }
+            else if (kind === SESSION_CONFIG_UPDATED_KIND) {
+                this.#options.onConfig?.(decodeSessionConfigUpdatedEvent(encoded));
+            }
+            else if (kind === SESSION_COMMANDS_UPDATED_KIND) {
+                this.#options.onCommands?.(decodeSessionCommandsUpdatedEvent(encoded));
+            }
+            else if (kind === SESSION_INFO_UPDATED_KIND) {
+                this.#options.onInfo?.(decodeSessionInfoUpdatedEvent(encoded));
+            }
+            else if (kind === SESSION_USAGE_UPDATED_KIND) {
+                this.#options.onUsage?.(decodeSessionUsageUpdatedEvent(encoded));
+            }
+            else if (kind === SESSION_PERMISSION_REQUESTED_KIND) {
+                this.#options.onPermission?.(decodeSessionPermissionRequestedEvent(encoded));
+            }
+            else if (kind === SESSION_PERMISSION_RESPOND_KIND) {
+                decodeSessionPermissionRespondCommand(encoded);
+            }
+            else if (kind === SESSION_PERMISSION_RESOLVED_KIND) {
+                this.#options.onPermissionResolved?.(decodeSessionPermissionResolvedEvent(encoded));
+            }
+            else if (kind === SESSION_ELICITATION_REQUESTED_KIND) {
+                this.#options.onElicitation?.(decodeSessionElicitationRequestedEvent(encoded));
+            }
+            else if (kind === SESSION_ELICITATION_RESPOND_KIND) {
+                decodeSessionElicitationRespondCommand(encoded);
+            }
+            else if (kind === SESSION_ELICITATION_RESOLVED_KIND) {
+                this.#options.onElicitationResolved?.(decodeSessionElicitationResolvedEvent(encoded));
+            }
+            else if (kind === SESSION_STARTED_KIND) {
+                decodeSessionStartedEvent(encoded);
+            }
+            else if (kind === AGENT_MESSAGE_DELTA_KIND) {
+                decodeAgentMessageDeltaEvent(encoded);
+            }
+            else if (kind === AGENT_ACTIVITY_KIND) {
+                decodeAgentActivityEvent(encoded);
+            }
+            else if (kind === AGENT_CONTENT_KIND) {
+                this.#options.onContent?.(decodeAgentContentEvent(encoded));
+            }
+            else if (kind === AGENT_INSTALL_REQUEST_KIND) {
+                decodeAgentInstallRequestCommand(encoded);
+            }
+            else if (kind === AGENT_INSTALL_CANCEL_KIND) {
+                decodeAgentInstallCancelCommand(encoded);
+            }
+            else if (kind === AGENT_INSTALL_STARTED_KIND) {
+                this.#options.onInstallStarted?.(decodeAgentInstallStartedEvent(encoded));
+            }
+            else if (kind === AGENT_INSTALL_PROGRESS_KIND) {
+                this.#options.onInstallProgress?.(decodeAgentInstallProgressEvent(encoded));
+            }
+            else if (kind === AGENT_INSTALL_COMPLETED_KIND) {
+                this.#options.onInstallCompleted?.(decodeAgentInstallCompletedEvent(encoded));
+            }
+            else if (kind === AGENT_INSTALL_FAILED_KIND) {
+                this.#options.onInstallFailed?.(decodeAgentInstallFailedEvent(encoded));
+            }
+            else if (kind === AGENT_INSTALL_CANCELLED_KIND) {
+                this.#options.onInstallCancelled?.(decodeAgentInstallCancelledEvent(encoded));
+            }
+            else if (kind === SESSION_COMPLETED_KIND) {
+                decodeSessionCompletedEvent(encoded);
+            }
+            else if (kind === SESSION_FAILED_KIND) {
+                decodeSessionFailedEvent(encoded);
+            }
+            else if (kind === SESSION_OPERATION_FAILED_KIND) {
+                decodeSessionOperationFailedEvent(encoded);
+            }
+            else {
+                throw new MobiusClientError("invalid_protocol_message", "Relay sent an unsupported message kind");
+            }
+            this.#onActivity();
+        }
+        catch (error) {
+            this.#onProtocolError(new MobiusClientError("invalid_protocol_message", "Received an invalid message from the relay", {
+                cause: error,
+            }));
+        }
+    };
+}
+export async function connectMobiusClient(options) {
+    const socket = new ReconnectingWebSocket(options.relayUrl, [], {
+        connectionTimeout: CONNECTION_TIMEOUT_MILLISECONDS,
+        maxEnqueuedMessages: 0,
+        maxReconnectionDelay: MAX_RECONNECTION_DELAY_MILLISECONDS,
+        minReconnectionDelay: MIN_RECONNECTION_DELAY_MILLISECONDS * (1 + Math.random()),
+        shouldReconnectOnClose: shouldReconnectAfterClose,
+    });
+    const client = new MobiusClient(socket, options);
+    try {
+        await client.ready();
+        return client;
+    }
+    catch (error) {
+        client.close();
+        throw error;
+    }
+}
+//# sourceMappingURL=client.js.map