@meshagent/meshagent 0.37.2 → 0.38.0

package/dist/esm/room-client.js

@@ -1,32 +1,244 @@
 import { Completer } from "./completer";
-import { packMessage, splitMessageHeader, splitMessagePayload, unpackMessage } from "./utils";
-import { LocalParticipant } from "./participant";
-import { StreamController } from "./stream-controller";
-import { SyncClient } from "./sync-client";
+import { DatabaseClient } from "./database-client";
 import { DeveloperClient } from "./developer-client";
-import { StorageClient } from "./storage-client";
+import { EventEmitter } from "./event-emitter";
 import { MessagingClient } from "./messaging-client";
+import { MemoryClient } from "./memory-client";
+import { LocalParticipant } from "./participant";
+import { ProtocolCloseException, ProtocolCloseKind, ProtocolHandshakeException, ProtocolReconnectUnsupportedException, WebSocketClientProtocol, } from "./protocol";
 import { QueuesClient } from "./queues-client";
-import { DatabaseClient } from "./database-client";
-import { AgentsClient, ToolkitDescription } from "./agent-client";
+import { BinaryContent, ControlContent, EmptyContent, ErrorContent, FileContent, JsonContent, LinkContent, TextContent, unpackContent } from "./response";
+import { RoomStatusEvent } from "./room-event";
+import { RoomServerException } from "./room-server-client";
 import { SecretsClient } from "./secrets-client";
-import { ContainersClient } from "./containers-client";
-import { MemoryClient } from "./memory-client";
 import { ServicesClient } from "./services-client";
-import { RoomServerException } from "./room-server-client";
-import { BinaryContent, ControlContent, EmptyContent, ErrorContent, FileContent, JsonContent, LinkContent, TextContent, unpackContent } from "./response";
+import { StorageClient } from "./storage-client";
+import { StreamController } from "./stream-controller";
+import { SyncClient } from "./sync-client";
+import { splitMessageHeader, splitMessagePayload, packMessage, unpackMessage } from "./utils";
+import { AgentsClient, ToolkitDescription } from "./agent-client";
+import { ContainersClient } from "./containers-client";
+class ProtocolStartupFailure extends Error {
+    constructor({ kind, reason }) {
+        super(reason ?? kind);
+        this.name = "ProtocolStartupFailure";
+        this.kind = kind;
+        this.reason = reason;
+    }
+}
+class RoomClientTerminalState {
+    constructor({ requestMessage, toolCallMessage, messageSendMessage, }) {
+        this.requestMessage = requestMessage;
+        this.toolCallMessage = toolCallMessage;
+        this.messageSendMessage = messageSendMessage;
+    }
+    requestError() {
+        return new RoomServerException(this.requestMessage);
+    }
+    toolCallError() {
+        return new RoomServerException(this.toolCallMessage);
+    }
+    messageSendError() {
+        return new RoomServerException(this.messageSendMessage);
+    }
+}
+class RoomConnectionStatusException extends RoomServerException {
+    constructor({ statusCode, statusText, }) {
+        const normalizedStatusText = statusText?.trim();
+        super(normalizedStatusText == null || normalizedStatusText.length === 0
+            ? `websocket connect failed with status ${statusCode}`
+            : `websocket connect failed with status ${statusCode}: ${normalizedStatusText}`);
+        this.name = "RoomConnectionStatusException";
+        this.statusCode = statusCode;
+    }
+}
+function normalizeCloseReason(reason) {
+    if (reason == null) {
+        return null;
+    }
+    const normalized = reason.trim();
+    return normalized.length === 0 ? null : normalized;
+}
+function wrapRoomConnectionError(error) {
+    if (error instanceof RoomServerException) {
+        return error;
+    }
+    if (error instanceof ProtocolHandshakeException) {
+        return new RoomConnectionStatusException({
+            statusCode: error.statusCode,
+            statusText: error.statusText,
+        });
+    }
+    if (error instanceof ProtocolCloseException) {
+        return new RoomServerException(normalizeCloseReason(error.reason) ?? `room connection closed with status ${error.closeCode}`);
+    }
+    return new RoomServerException(`room connection error: ${String(error)}`);
+}
+function nonRetryableConnectFailureReason(error) {
+    if (error instanceof RoomConnectionStatusException
+        && (error.statusCode === 403 || error.statusCode === 404)) {
+        return error.message;
+    }
+    return null;
+}
+function roomClosedBeforeReadyError(protocol) {
+    return new RoomServerException(normalizeCloseReason(protocol.closeReason) ?? "room connection closed before request completed");
+}
+function getEnvironmentValue(name) {
+    if (typeof process === "undefined") {
+        return undefined;
+    }
+    return process.env?.[name];
+}
+function websocketRoomUrlFromEnvironment(roomName) {
+    const configuredBaseUrl = getEnvironmentValue("MESHAGENT_ROOM_URL")
+        ?? getEnvironmentValue("MESHAGENT_API_URL")
+        ?? "wss://api.meshagent.com";
+    let baseUrl = configuredBaseUrl;
+    if (baseUrl.startsWith("https:")) {
+        baseUrl = `wss:${baseUrl.slice("https:".length)}`;
+    }
+    else if (baseUrl.startsWith("http:")) {
+        baseUrl = `ws:${baseUrl.slice("http:".length)}`;
+    }
+    return `${baseUrl}/rooms/${roomName}`;
+}
+function createProtocolFactoryFromEnvironment() {
+    const roomName = getEnvironmentValue("MESHAGENT_ROOM");
+    const token = getEnvironmentValue("MESHAGENT_TOKEN");
+    if (roomName == null || roomName.trim().length === 0 || token == null || token.trim().length === 0) {
+        throw new Error("protocolFactory must be configured or MESHAGENT_ROOM and MESHAGENT_TOKEN must be set in the environment");
+    }
+    return WebSocketClientProtocol.createFactory({
+        url: websocketRoomUrlFromEnvironment(roomName),
+        token,
+    });
+}
+export class RoomProtocolProxy {
+    constructor({ room }) {
+        this._handlers = new Map();
+        this._room = room;
+    }
+    _bind(protocol) {
+        for (const [type, handler] of this._handlers.entries()) {
+            if (protocol.getHandler(type) === handler) {
+                continue;
+            }
+            protocol.addHandler(type, handler);
+        }
+    }
+    _unbind(protocol) {
+        for (const [type, handler] of this._handlers.entries()) {
+            const current = protocol.getHandler(type);
+            if (current === handler) {
+                protocol.removeHandler(type, handler);
+            }
+        }
+    }
+    addHandler(type, handler) {
+        if (this._handlers.has(type)) {
+            throw new Error(`already registered handler for ${type}`);
+        }
+        this._handlers.set(type, handler);
+        this._bind(this._room._protocolInstance);
+    }
+    removeHandler(type, handler) {
+        const registered = this._handlers.get(type);
+        if (registered !== handler) {
+            throw new Error(`handler mismatch for ${type}`);
+        }
+        this._handlers.delete(type);
+        if (this._room._protocolInstance.getHandler(type) === handler) {
+            this._room._protocolInstance.removeHandler(type, handler);
+        }
+    }
+    getHandler(type) {
+        return this._handlers.get(type);
+    }
+    async send(type, data, { id } = {}) {
+        if (this._room._entered && !this._room.isConnected && !this._room._allowDisconnectedRequests) {
+            throw this._room._disconnectedError({ baseMessage: "room connection is disconnected" });
+        }
+        await this._room._protocolInstance.send(type, data, id);
+    }
+    sendNowait(type, data, { id } = {}) {
+        if (this._room._entered && !this._room.isConnected && !this._room._allowDisconnectedRequests) {
+            throw this._room._disconnectedError({ baseMessage: "room connection is disconnected" });
+        }
+        return this._room._protocolInstance.sendNowait(type, data, { id });
+    }
+    getNextMessageId() {
+        if (this._room._entered && !this._room.isConnected && !this._room._allowDisconnectedRequests) {
+            throw this._room._disconnectedError({ baseMessage: "room connection is disconnected" });
+        }
+        return this._room._protocolInstance.getNextMessageId();
+    }
+    get done() {
+        return this._room.waitForClose();
+    }
+    async waitForClose() {
+        await this._room.waitForClose();
+    }
+    get closeKind() {
+        return this._room.closeKind;
+    }
+    get closeReason() {
+        return this._room.closeReason;
+    }
+    get isOpen() {
+        return this._room._protocolInstance.isOpen;
+    }
+    get isClosed() {
+        return this._room.isClosed;
+    }
+    get token() {
+        return this._room._protocolInstance.token;
+    }
+    get url() {
+        return this._room._protocolInstance.url;
+    }
+}
 export class RoomClient {
-    constructor({ protocol }) {
+    constructor({ protocolFactory = null, reconnectTimeout = null, } = {}) {
+        this._entered = false;
+        this._allowDisconnectedRequests = false;
+        this._eventsController = new StreamController();
+        this._eventEmitter = new EventEmitter();
         this._pendingRequests = new Map();
+        this._toolCallStreams = new Map();
+        this._ignoredResponseLabels = new Map();
         this._ready = new Completer();
+        this._roomClosed = new Completer();
+        this._connectionReady = new Completer();
+        this._localParticipantReady = new Completer();
+        this._connected = false;
+        this._closing = false;
         this._localParticipant = null;
-        this._eventsController = new StreamController();
-        this._toolCallStreams = new Map();
-        this.protocol = protocol;
-        protocol.addHandler("room_ready", this._handleRoomReady.bind(this));
-        protocol.addHandler("connected", this._handleParticipant.bind(this));
-        protocol.addHandler("__response__", this._handleResponse.bind(this));
-        protocol.addHandler("room.tool_call_response_chunk", this._handleToolCallResponseChunk.bind(this));
+        this._lifecycleTask = null;
+        this._terminalState = null;
+        this._closeKind = null;
+        this._closeReason = null;
+        this._terminalCallbacksInvoked = false;
+        this._roomName = null;
+        this._roomUrl = null;
+        this._sessionId = null;
+        this._handleRoomReadyBound = this._handleRoomReady.bind(this);
+        this._handleRoomStatusBound = this._handleRoomStatus.bind(this);
+        this._handleParticipantBound = this._handleParticipant.bind(this);
+        this._handleResponseBound = this._handleResponse.bind(this);
+        this._handleToolCallResponseChunkBound = this._handleToolCallResponseChunk.bind(this);
+        if (reconnectTimeout != null && reconnectTimeout < 0) {
+            throw new Error("reconnectTimeout must be null or non-negative");
+        }
+        this._protocolFactory = protocolFactory ?? createProtocolFactoryFromEnvironment();
+        this._reconnectTimeout = reconnectTimeout;
+        this._protocolInstance = this._protocolFactory();
+        this.protocol = new RoomProtocolProxy({ room: this });
+        this.protocol.addHandler("room_ready", this._handleRoomReadyBound);
+        this.protocol.addHandler("room.status", this._handleRoomStatusBound);
+        this.protocol.addHandler("connected", this._handleParticipantBound);
+        this.protocol.addHandler("__response__", this._handleResponseBound);
+        this.protocol.addHandler("room.tool_call_response_chunk", this._handleToolCallResponseChunkBound);
         this.sync = new SyncClient({ room: this });
         this.storage = new StorageClient({ room: this });
         this.developer = new DeveloperClient({ room: this });
@@ -45,33 +257,820 @@ export class RoomClient {
     get ready() {
         return this._ready.fut;
     }
-    async start({ onDone, onError } = {}) {
-        await this.messaging.start();
-        this.sync.start({ onDone, onError });
-        await this.ready;
+    get isConnected() {
+        return this._connected;
     }
-    dispose() {
-        for (const prKey of this._pendingRequests.keys()) {
-            const pr = this._pendingRequests.get(prKey);
-            pr?.reject(new Error("Disposed"));
-            this._pendingRequests.delete(prKey);
+    get isClosed() {
+        return this._closing || this._terminalState != null || this._roomClosed.completed;
+    }
+    get isClosing() {
+        return this._closing;
+    }
+    get closeKind() {
+        return this._closeKind ?? this._protocolInstance.closeKind;
+    }
+    get closeReason() {
+        return this._closeReason ?? normalizeCloseReason(this._protocolInstance.closeReason);
+    }
+    get roomName() {
+        return this._roomName;
+    }
+    get roomUrl() {
+        return this._roomUrl;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    isActiveProtocol(protocol) {
+        return protocol === this._protocolInstance;
+    }
+    on(eventName, callback) {
+        this._eventEmitter.on(eventName, callback);
+    }
+    off(eventName, callback) {
+        this._eventEmitter.off(eventName, callback);
+    }
+    emit(event) {
+        this._eventsController.add(event);
+        this._eventEmitter.emit(event.name, event);
+    }
+    listen() {
+        return this._eventsController.stream;
+    }
+    async waitForClose() {
+        await this._roomClosed.fut;
+    }
+    async waitUntilConnected() {
+        while (!this._connected) {
+            this._raiseIfTerminal();
+            if (this._roomClosed.completed) {
+                this._raiseIfTerminal();
+                throw this._disconnectedError({
+                    baseMessage: "room connection closed before reconnect completed",
+                });
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
         }
-        this.messaging.dispose();
-        this.sync.dispose();
-        for (const stream of this._toolCallStreams.values()) {
-            stream.close();
+    }
+    async _waitUntilConnectedForMessages() {
+        while (!this._connected) {
+            this._raiseIfTerminalForMessages();
+            if (this._roomClosed.completed) {
+                this._raiseIfTerminalForMessages();
+                throw this._messageDisconnectedError({
+                    baseMessage: "room connection closed before message send completed",
+                });
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
+    _markConnected() {
+        this._connected = true;
+        this._closeKind = null;
+        this._closeReason = null;
+    }
+    _markDisconnected({ reason, kind, }) {
+        this._connected = false;
+        this._closeKind = kind;
+        this._closeReason = normalizeCloseReason(reason);
+        this._ignoredResponseLabels.clear();
+    }
+    _completeRoomClosed() {
+        if (!this._roomClosed.completed) {
+            this._roomClosed.complete();
+        }
+    }
+    _invokeTerminalCallbacks({ useErrorCallback, error, }) {
+        if (this._terminalCallbacksInvoked) {
+            return;
+        }
+        this._terminalCallbacksInvoked = true;
+        if (useErrorCallback) {
+            this._errorHandler?.(error);
+            return;
+        }
+        this._doneHandler?.();
+    }
+    _formatClosedMessage({ baseMessage, protocol, closeReason, }) {
+        const normalized = normalizeCloseReason(closeReason) ??
+            normalizeCloseReason((protocol ?? this._protocolInstance).closeReason);
+        if (normalized == null) {
+            return baseMessage;
+        }
+        return `${baseMessage}: ${normalized}`;
+    }
+    _connectionFailureReason(error) {
+        if (error instanceof RoomServerException) {
+            return normalizeCloseReason(error.message);
+        }
+        return normalizeCloseReason(String(error));
+    }
+    _protocolTerminalState({ protocol } = {}) {
+        return new RoomClientTerminalState({
+            requestMessage: this._formatClosedMessage({
+                baseMessage: "room connection closed before request completed",
+                protocol,
+            }),
+            toolCallMessage: this._formatClosedMessage({
+                baseMessage: "room connection closed before tool call completed",
+                protocol,
+            }),
+            messageSendMessage: this._formatClosedMessage({
+                baseMessage: "room connection closed before message send completed",
+                protocol,
+            }),
+        });
+    }
+    _clientClosedTerminalState() {
+        return new RoomClientTerminalState({
+            requestMessage: "room client was closed before request completed",
+            toolCallMessage: "room client was closed before tool call completed",
+            messageSendMessage: "room client was closed before message send completed",
+        });
+    }
+    _unexpectedCloseTerminalState({ closeReason, }) {
+        return new RoomClientTerminalState({
+            requestMessage: this._formatClosedMessage({
+                baseMessage: "room connection unexpectedly closed before request completed",
+                closeReason,
+            }),
+            toolCallMessage: this._formatClosedMessage({
+                baseMessage: "room connection unexpectedly closed before tool call completed",
+                closeReason,
+            }),
+            messageSendMessage: this._formatClosedMessage({
+                baseMessage: "room connection unexpectedly closed before message send completed",
+                closeReason,
+            }),
+        });
+    }
+    _setStartupTerminalState({ closeKind, closeReason, protocol, }) {
+        const normalizedCloseReason = normalizeCloseReason(closeReason);
+        this._closeKind = closeKind;
+        this._closeReason = normalizedCloseReason;
+        if (closeKind === ProtocolCloseKind.ERROR) {
+            this._setTerminalState({
+                state: this._unexpectedCloseTerminalState({ closeReason: normalizedCloseReason }),
+            });
+        }
+        else if (closeKind === ProtocolCloseKind.CLIENT) {
+            this._setTerminalState({ state: this._clientClosedTerminalState() });
+        }
+        else {
+            this._setTerminalState({ state: this._protocolTerminalState({ protocol }) });
+        }
+        if (!this._ready.completed) {
+            this._ready.completeError(this._startupException({
+                closeKind,
+                closeReason: normalizedCloseReason,
+                protocol,
+            }));
+        }
+        this._completeRoomClosed();
+    }
+    _setTerminalState({ state }) {
+        if (this._terminalState == null) {
+            this._terminalState = state;
+        }
+        return this._terminalState;
+    }
+    _raiseIfTerminal() {
+        if (this._terminalState != null) {
+            throw this._terminalState.requestError();
+        }
+    }
+    _raiseIfTerminalForMessages() {
+        if (this._terminalState != null) {
+            throw this._terminalState.messageSendError();
+        }
+    }
+    _disconnectedError({ baseMessage }) {
+        return new RoomServerException(this._formatClosedMessage({
+            baseMessage,
+        }));
+    }
+    _messageDisconnectedError({ baseMessage, }) {
+        return new RoomServerException(this._formatClosedMessage({
+            baseMessage,
+        }));
+    }
+    _startupException({ closeKind, closeReason, protocol, }) {
+        const baseMessage = closeKind === ProtocolCloseKind.ERROR
+            ? "room connection unexpectedly closed before the room became ready"
+            : closeKind === ProtocolCloseKind.CLIENT
+                ? "room client was closed before the room became ready"
+                : "room connection closed before the room became ready";
+        return new RoomServerException(this._formatClosedMessage({
+            baseMessage,
+            protocol,
+            closeReason,
+        }));
+    }
+    _finalizeInitialStartupRetryFailure({ retryResult, }) {
+        const closeKind = retryResult.closeKind ?? null;
+        if (closeKind == null) {
+            throw new Error("initial startup retry failure requires a close kind");
+        }
+        this._setStartupTerminalState({
+            closeKind,
+            closeReason: retryResult.closeReason ?? null,
+            protocol: this._protocolInstance,
+        });
+        throw this._startupException({
+            closeKind,
+            closeReason: retryResult.closeReason ?? null,
+            protocol: this._protocolInstance,
+        });
+    }
+    _coerceMessageSendError(error) {
+        if (this._terminalState == null) {
+            return error;
+        }
+        if (error.message === this._terminalState.requestMessage ||
+            error.message === this._terminalState.toolCallMessage) {
+            return this._terminalState.messageSendError();
+        }
+        return error;
+    }
+    _messageStopError() {
+        if (this._closing && this._terminalState != null) {
+            return this._terminalState.messageSendError();
+        }
+        return new RoomServerException("Cannot send messages because messaging has been stopped");
+    }
+    _failPendingRequests(error) {
+        if (this._pendingRequests.size === 0) {
+            return;
+        }
+        const pending = [...this._pendingRequests.values()];
+        this._pendingRequests.clear();
+        for (const request of pending) {
+            if (!request.completed) {
+                request.completeError(error);
+            }
         }
+    }
+    async _failToolCallStreams({ error, }) {
+        if (this._toolCallStreams.size === 0) {
+            return;
+        }
+        const streams = [...this._toolCallStreams.values()];
         this._toolCallStreams.clear();
-        this.protocol.dispose();
+        for (const stream of streams) {
+            stream.add(new ErrorContent({ text: error.message }));
+            stream.close();
+        }
+    }
+    async _failPendingWork({ state, }) {
+        this._failPendingRequests(state.requestError());
+        await this._failToolCallStreams({ error: state.toolCallError() });
+    }
+    async _openProtocol({ initial }) {
+        const protocol = this._protocolInstance;
+        this._connectionReady = new Completer();
+        this._localParticipantReady = new Completer();
+        protocol.start({
+            onDone: () => {
+                const error = roomClosedBeforeReadyError(protocol);
+                if (!this._connectionReady.completed) {
+                    this._connectionReady.completeError(error);
+                }
+                if (!this._localParticipantReady.completed) {
+                    this._localParticipantReady.completeError(error);
+                }
+                if (!initial && !this._ready.completed) {
+                    this._ready.completeError(error);
+                }
+            },
+            onError: (error) => {
+                const wrapped = wrapRoomConnectionError(error);
+                if (!this._connectionReady.completed) {
+                    this._connectionReady.completeError(wrapped);
+                }
+                if (!this._localParticipantReady.completed) {
+                    this._localParticipantReady.completeError(wrapped);
+                }
+                if (!initial && !this._ready.completed) {
+                    this._ready.completeError(wrapped);
+                }
+            },
+        });
+        try {
+            await Promise.all([this._connectionReady.fut, this._localParticipantReady.fut]);
+        }
+        catch (error) {
+            const kind = protocol.closeKind ?? ProtocolCloseKind.ERROR;
+            if (!initial && kind !== ProtocolCloseKind.ERROR) {
+                throw new ProtocolStartupFailure({
+                    kind,
+                    reason: normalizeCloseReason(protocol.closeReason),
+                });
+            }
+            throw error;
+        }
+    }
+    async start({ onDone, onError, } = {}) {
+        if (this._entered) {
+            throw new RoomServerException("room client already started");
+        }
+        this._doneHandler = onDone;
+        this._errorHandler = onError;
+        try {
+            try {
+                await this._openProtocol({ initial: true });
+            }
+            catch (error) {
+                if (error instanceof ProtocolStartupFailure) {
+                    if (error.kind !== ProtocolCloseKind.ERROR || this._reconnectTimeout === 0) {
+                        this._setStartupTerminalState({
+                            closeKind: error.kind,
+                            closeReason: error.reason,
+                            protocol: this._protocolInstance,
+                        });
+                        throw this._startupException({
+                            closeKind: error.kind,
+                            closeReason: error.reason,
+                            protocol: this._protocolInstance,
+                        });
+                    }
+                    await this._closeProtocol(this._protocolInstance);
+                    const retryResult = await this._retryProtocolConnection({
+                        disconnectReason: error.reason,
+                        protocolFactoryFailureLogMessage: "unable to create replacement room protocol during initial startup",
+                        attemptFailureLogMessage: "room startup attempt failed",
+                        attempt: this._attemptInitialProtocolStartup.bind(this),
+                    });
+                    if (!retryResult.connected) {
+                        this._finalizeInitialStartupRetryFailure({ retryResult });
+                    }
+                }
+                else {
+                    const nonRetryableCloseReason = nonRetryableConnectFailureReason(error);
+                    if (nonRetryableCloseReason != null) {
+                        this._finalizeInitialStartupRetryFailure({
+                            retryResult: {
+                                connected: false,
+                                closeKind: ProtocolCloseKind.ERROR,
+                                closeReason: nonRetryableCloseReason,
+                            },
+                        });
+                    }
+                    const closeKind = this._protocolInstance.closeKind;
+                    const protocolCloseReason = normalizeCloseReason(this._protocolInstance.closeReason);
+                    if (closeKind != null && closeKind !== ProtocolCloseKind.ERROR) {
+                        this._setStartupTerminalState({
+                            closeKind,
+                            closeReason: protocolCloseReason,
+                            protocol: this._protocolInstance,
+                        });
+                        throw this._startupException({
+                            closeKind,
+                            closeReason: protocolCloseReason,
+                            protocol: this._protocolInstance,
+                        });
+                    }
+                    const closeReason = this._connectionFailureReason(error);
+                    if (this._reconnectTimeout === 0) {
+                        this._setStartupTerminalState({
+                            closeKind: ProtocolCloseKind.ERROR,
+                            closeReason,
+                            protocol: this._protocolInstance,
+                        });
+                        throw this._startupException({
+                            closeKind: ProtocolCloseKind.ERROR,
+                            closeReason,
+                            protocol: this._protocolInstance,
+                        });
+                    }
+                    console.debug("room startup attempt failed", error);
+                    await this._closeProtocol(this._protocolInstance);
+                    const retryResult = await this._retryProtocolConnection({
+                        disconnectReason: closeReason,
+                        protocolFactoryFailureLogMessage: "unable to create replacement room protocol during initial startup",
+                        attemptFailureLogMessage: "room startup attempt failed",
+                        attempt: this._attemptInitialProtocolStartup.bind(this),
+                    });
+                    if (!retryResult.connected) {
+                        this._finalizeInitialStartupRetryFailure({ retryResult });
+                    }
+                }
+            }
+            this.sync.start();
+            this.messaging.start();
+            this._entered = true;
+            this._markConnected();
+            this.messaging._onRoomReconnect();
+            this._lifecycleTask = this._connectionLifecycle();
+        }
+        catch (error) {
+            this.sync.dispose();
+            void this.messaging.stop();
+            this._protocolInstance.dispose();
+            throw error;
+        }
+        await this.ready;
+    }
+    async _completeReconnect() {
+        await this._openProtocol({ initial: false });
+        this._allowDisconnectedRequests = true;
+        try {
+            this._resendLocalAttributesNowait();
+            await this.sync._onRoomReconnect();
+            this.messaging._onRoomReconnect();
+            this._markConnected();
+        }
+        finally {
+            this._allowDisconnectedRequests = false;
+        }
+    }
+    _replaceProtocol(nextProtocol) {
+        const currentProtocol = this._protocolInstance;
+        this.protocol._unbind(currentProtocol);
+        this._protocolInstance = nextProtocol;
+        this.protocol._bind(nextProtocol);
+    }
+    _remainingReconnectTimeout(deadline) {
+        if (deadline == null) {
+            return null;
+        }
+        const remaining = deadline - Date.now();
+        return remaining <= 0 ? 0 : remaining;
+    }
+    async _attemptInitialProtocolStartup({ protocol, remaining, }) {
+        void protocol;
+        if (remaining == null) {
+            await this._openProtocol({ initial: false });
+            return;
+        }
+        await Promise.race([
+            this._openProtocol({ initial: false }),
+            new Promise((_resolve, reject) => {
+                setTimeout(() => reject(new Error("timeout")), remaining);
+            }),
+        ]);
+    }
+    async _attemptReconnect({ protocol, remaining, }) {
+        try {
+            if (remaining == null) {
+                await this._completeReconnect();
+            }
+            else {
+                await Promise.race([
+                    this._completeReconnect(),
+                    new Promise((_resolve, reject) => {
+                        setTimeout(() => reject(new Error("timeout")), remaining);
+                    }),
+                ]);
+            }
+        }
+        catch (error) {
+            if (error instanceof ProtocolStartupFailure) {
+                throw error;
+            }
+            if (error instanceof Error && error.message === "timeout") {
+                this._allowDisconnectedRequests = false;
+                await this.sync._onRoomDisconnect();
+                this.messaging._onRoomDisconnect({ reason: normalizeCloseReason(protocol.closeReason) });
+                throw error;
+            }
+            this._allowDisconnectedRequests = false;
+            await this.sync._onRoomDisconnect();
+            this.messaging._onRoomDisconnect({ reason: normalizeCloseReason(protocol.closeReason) });
+            throw error;
+        }
+    }
+    _formatDuration(milliseconds) {
+        if (milliseconds % 1000 === 0) {
+            return `${milliseconds / 1000}s`;
+        }
+        return `${milliseconds / 1000}s`;
+    }
+    _reconnectTimeoutReason({ disconnectReason, }) {
+        if (this._reconnectTimeout == null) {
+            throw new Error("reconnect timeout reason requires a configured timeout");
+        }
+        const timeoutDisplay = this._formatDuration(this._reconnectTimeout);
+        if (disconnectReason == null) {
+            return `room reconnect timed out after ${timeoutDisplay}`;
+        }
+        return `room reconnect timed out after ${timeoutDisplay} (${disconnectReason})`;
+    }
+    _timedOutRetryResult({ disconnectReason, }) {
+        if (this._reconnectTimeout == null) {
+            throw new Error("timed out retry result requires a configured timeout");
+        }
+        return {
+            connected: false,
+            closeKind: ProtocolCloseKind.ERROR,
+            closeReason: this._reconnectTimeoutReason({ disconnectReason }),
+        };
+    }
+    async _closeAfterUnexpectedDisconnect({ closeReason, }) {
+        const normalized = normalizeCloseReason(closeReason);
+        const state = this._unexpectedCloseTerminalState({ closeReason: normalized });
+        this._closeKind = ProtocolCloseKind.ERROR;
+        this._closeReason = normalized;
+        this._setTerminalState({ state });
+        this._completeRoomClosed();
+        this._invokeTerminalCallbacks({
+            useErrorCallback: true,
+            error: state.requestError(),
+        });
+    }
+    async _closeProtocol(protocol) {
+        protocol.dispose();
+        await protocol.waitForClose();
+    }
+    async _retryProtocolConnection({ disconnectReason, protocolFactoryFailureLogMessage, attemptFailureLogMessage, attempt, }) {
+        let failureReason = normalizeCloseReason(disconnectReason);
+        const recordFailureReason = (reason) => {
+            const normalizedReason = normalizeCloseReason(reason);
+            if (failureReason == null && normalizedReason != null) {
+                failureReason = normalizedReason;
+            }
+        };
+        const deadline = this._reconnectTimeout == null ? null : Date.now() + this._reconnectTimeout;
+        let firstAttempt = true;
+        while (!this._closing) {
+            if (firstAttempt) {
+                firstAttempt = false;
+                if (this._reconnectTimeout == null) {
+                    await new Promise((resolve) => setTimeout(resolve, RoomClient.RECONNECT_RETRY_INTERVAL_MS));
+                }
+            }
+            else {
+                const remaining = this._remainingReconnectTimeout(deadline);
+                if (remaining != null && remaining === 0) {
+                    return this._timedOutRetryResult({ disconnectReason: failureReason });
+                }
+                const delay = remaining == null
+                    ? RoomClient.RECONNECT_RETRY_INTERVAL_MS
+                    : Math.min(remaining, RoomClient.RECONNECT_RETRY_INTERVAL_MS);
+                if (delay > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+            const remaining = this._remainingReconnectTimeout(deadline);
+            if (remaining != null && remaining === 0) {
+                return this._timedOutRetryResult({ disconnectReason: failureReason });
+            }
+            let nextProtocol;
+            try {
+                nextProtocol = this._protocolFactory();
+            }
+            catch (error) {
+                if (error instanceof ProtocolReconnectUnsupportedException) {
+                    return {
+                        connected: false,
+                        closeKind: ProtocolCloseKind.ERROR,
+                        closeReason: failureReason,
+                    };
+                }
+                recordFailureReason(String(error));
+                console.debug(protocolFactoryFailureLogMessage, error);
+                continue;
+            }
+            this._replaceProtocol(nextProtocol);
+            try {
+                await attempt({ protocol: nextProtocol, remaining });
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === "timeout") {
+                    recordFailureReason(normalizeCloseReason(nextProtocol.closeReason));
+                    await this._closeProtocol(nextProtocol);
+                    return this._timedOutRetryResult({ disconnectReason: failureReason });
+                }
+                if (error instanceof ProtocolStartupFailure) {
+                    recordFailureReason(error.reason);
+                    await this._closeProtocol(nextProtocol);
+                    if (error.kind !== ProtocolCloseKind.ERROR) {
+                        return {
+                            connected: false,
+                            closeKind: error.kind,
+                            closeReason: error.reason,
+                        };
+                    }
+                    continue;
+                }
+                const nonRetryableCloseReason = nonRetryableConnectFailureReason(error);
+                if (nonRetryableCloseReason != null) {
+                    await this._closeProtocol(nextProtocol);
+                    return {
+                        connected: false,
+                        closeKind: ProtocolCloseKind.ERROR,
+                        closeReason: nonRetryableCloseReason,
+                    };
+                }
+                recordFailureReason(this._connectionFailureReason(error));
+                console.debug(attemptFailureLogMessage, error);
+                await this._closeProtocol(nextProtocol);
+                continue;
+            }
+            return { connected: true };
+        }
+        return {
+            connected: false,
+            closeKind: ProtocolCloseKind.CLIENT,
+            closeReason: this.closeReason,
+        };
+    }
+    async _reconnect({ disconnectReason, }) {
+        const retryResult = await this._retryProtocolConnection({
+            disconnectReason,
+            protocolFactoryFailureLogMessage: "unable to create replacement room protocol",
+            attemptFailureLogMessage: "room reconnect attempt failed",
+            attempt: this._attemptReconnect.bind(this),
+        });
+        if (retryResult.connected) {
+            this._emitStatus({
+                status: "reconnected",
+                message: "room connection restored",
+            });
+            return true;
+        }
+        const closeKind = retryResult.closeKind ?? null;
+        if (closeKind === ProtocolCloseKind.ERROR) {
+            const closeReason = retryResult.closeReason ?? null;
+            if (closeReason != null && closeReason.startsWith("room reconnect timed out after")) {
+                console.warn(`${closeReason}; closing room client`);
+            }
+            await this._closeAfterUnexpectedDisconnect({ closeReason });
+            return false;
+        }
+        if (closeKind == null) {
+            throw new Error("reconnect failure requires a close kind");
+        }
+        const state = this._protocolTerminalState({ protocol: this._protocolInstance });
+        this._setTerminalState({ state });
+        this._closeKind = closeKind;
+        this._closeReason = normalizeCloseReason(retryResult.closeReason ?? null);
+        this._completeRoomClosed();
+        this._invokeTerminalCallbacks({ useErrorCallback: false });
+        return false;
+    }
+    async _connectionLifecycle() {
+        while (true) {
+            const protocol = this._protocolInstance;
+            await protocol.done;
+            const closeKind = protocol.closeKind ?? ProtocolCloseKind.ERROR;
+            const closeReason = normalizeCloseReason(protocol.closeReason);
+            const state = this._protocolTerminalState({ protocol });
+            if (this._closing) {
+                this._completeRoomClosed();
+                return;
+            }
+            if (closeKind !== ProtocolCloseKind.ERROR) {
+                this._setTerminalState({ state });
+            }
+            this._markDisconnected({ reason: closeReason, kind: closeKind });
+            this._emitStatus({
+                status: "disconnected",
+                message: closeReason ?? "room connection lost",
+            });
+            await this.sync._onRoomDisconnect();
+            this.messaging._onRoomDisconnect({ reason: closeReason });
+            await this._failPendingWork({ state });
+            await this._closeProtocol(protocol);
+            if (closeKind === ProtocolCloseKind.ERROR) {
+                if (this._reconnectTimeout === 0) {
+                    if (closeReason == null) {
+                        console.warn("room connection lost; automatic reconnect disabled");
+                    }
+                    else {
+                        console.warn(`room connection lost (${closeReason}); automatic reconnect disabled`);
+                    }
+                    await this._closeAfterUnexpectedDisconnect({ closeReason });
+                    return;
+                }
+                if (closeReason == null) {
+                    console.warn("room connection lost; automatically attempting to reconnect");
+                }
+                else {
+                    console.warn(`room connection lost (${closeReason}); automatically attempting to reconnect`);
+                }
+                if (await this._reconnect({ disconnectReason: closeReason })) {
+                    continue;
+                }
+                return;
+            }
+            this._closeKind = closeKind;
+            this._closeReason = closeReason;
+            this._completeRoomClosed();
+            this._invokeTerminalCallbacks({ useErrorCallback: false });
+            return;
+        }
+    }
+    dispose() {
+        this._closing = true;
+        this._markDisconnected({
+            reason: this.closeReason,
+            kind: this.closeKind ?? ProtocolCloseKind.CLIENT,
+        });
+        const closingState = this._clientClosedTerminalState();
+        this._setTerminalState({ state: closingState });
+        this._failPendingRequests(closingState.requestError());
+        void this._failToolCallStreams({ error: closingState.toolCallError() });
+        this.sync.dispose();
+        void this.messaging.stop();
+        this._protocolInstance.dispose();
+        this._entered = false;
+        this._closeKind = ProtocolCloseKind.CLIENT;
+        this._completeRoomClosed();
+        this._invokeTerminalCallbacks({ useErrorCallback: false });
         this._localParticipant = null;
     }
+    _sendProtocolNowait({ type, data, label, messageId, expectResponse = false, }) {
+        try {
+            this._raiseIfTerminal();
+        }
+        catch (error) {
+            console.debug(`skipping ${label} because the room is closed`, error);
+            return null;
+        }
+        if (this._entered && !this._connected && !this._allowDisconnectedRequests) {
+            console.debug(`skipping ${label} while room is disconnected`);
+            return null;
+        }
+        const protocol = this._protocolInstance;
+        const resolvedMessageId = messageId ?? protocol.getNextMessageId();
+        if (expectResponse) {
+            this._ignoredResponseLabels.set(resolvedMessageId, label);
+        }
+        try {
+            protocol.sendNowait(type, data, { id: resolvedMessageId });
+        }
+        catch (error) {
+            this._ignoredResponseLabels.delete(resolvedMessageId);
+            if (this.isClosed) {
+                console.debug(`skipping ${label} because the room is closed`, error);
+            }
+            else {
+                console.warn(`unable to queue ${label}`, error);
+            }
+            return null;
+        }
+        return resolvedMessageId;
+    }
+    _sendRoomRequestNowait(type, request, { data, label, expectResponse = false, }) {
+        return this._sendProtocolNowait({
+            type,
+            data: packMessage(request, data),
+            label,
+            expectResponse,
+        });
+    }
+    invokeNowait({ toolkit, tool, input, participantId, onBehalfOfId, callerContext, }) {
+        const resolvedInput = input ?? new EmptyContent();
+        const packedInput = unpackMessage(resolvedInput.pack());
+        const request = {
+            toolkit,
+            tool,
+            participant_id: participantId,
+            on_behalf_of_id: onBehalfOfId,
+            caller_context: callerContext,
+            tool_call_id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+            arguments: packedInput[0],
+        };
+        this._sendRoomRequestNowait("room.invoke_tool", request, {
+            data: packedInput[1].length > 0 ? packedInput[1] : undefined,
+            label: `${toolkit}.${tool}`,
+            expectResponse: true,
+        });
+    }
+    _sendLocalAttributesNowait(attributes) {
+        this._sendProtocolNowait({
+            type: "set_attributes",
+            data: packMessage(attributes),
+            label: "local participant attribute update",
+        });
+    }
+    _resendLocalAttributesNowait() {
+        const localParticipant = this._localParticipant;
+        if (localParticipant == null) {
+            return;
+        }
+        const attributes = localParticipant._attributesSnapshot();
+        if (Object.keys(attributes).length === 0) {
+            return;
+        }
+        this._sendLocalAttributesNowait(attributes);
+    }
     async sendRequest(type, request, data) {
-        const requestId = this.protocol.getNextMessageId();
-        const pr = new Completer();
-        this._pendingRequests.set(requestId, pr);
-        const message = packMessage(request, data);
-        await this.protocol.send(type, message, requestId);
-        return await pr.fut;
+        this._raiseIfTerminal();
+        if (this._entered && !this._connected && !this._allowDisconnectedRequests) {
+            throw this._disconnectedError({ baseMessage: "room connection is disconnected" });
+        }
+        const requestId = this._protocolInstance.getNextMessageId();
+        const completer = new Completer();
+        this._pendingRequests.set(requestId, completer);
+        try {
+            await this._protocolInstance.send(type, packMessage(request, data), requestId);
+            return await completer.fut;
+        }
+        catch (error) {
+            this._pendingRequests.delete(requestId);
+            throw error;
+        }
     }
     async call(params) {
         await this.sendRequest("room.call", params);
@@ -146,7 +1145,7 @@ export class RoomClient {
         return await this.sendRequest("room.invoke_tool", request, requestData);
     }
     async invokeWithStreamInput(params) {
-        const toolCallId = `${Date.now()}-${this.protocol.getNextMessageId()}-${Math.random().toString(16).slice(2)}`;
+        const toolCallId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const request = {
             toolkit: params.toolkit,
             tool: params.tool,
@@ -177,7 +1176,7 @@ export class RoomClient {
         }
     }
     async invokeStream(params) {
-        const toolCallId = `${Date.now()}-${this.protocol.getNextMessageId()}-${Math.random().toString(16).slice(2)}`;
+        const toolCallId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
         const controller = new StreamController();
         const responseIterator = controller.stream[Symbol.asyncIterator]();
         this._toolCallStreams.set(toolCallId, controller);
@@ -199,7 +1198,7 @@ export class RoomClient {
         const requestTask = this._streamInvokeToolRequestChunks(toolCallId, params.input);
         void requestTask.catch((error) => {
             const stream = this._toolCallStreams.get(toolCallId);
-            if (!stream) {
+            if (stream == null) {
                 return;
             }
             stream.add(new ErrorContent({ text: `request stream failed: ${String(error)}` }));
@@ -249,8 +1248,8 @@ export class RoomClient {
         }
         return new JsonContent({ json: { chunk } });
     }
-    async _handleToolCallResponseChunk(protocol, messageId, type, data) {
-        if (!data) {
+    async _handleToolCallResponseChunk(protocol, _messageId, _type, data) {
+        if (!this.isActiveProtocol(protocol)) {
             return;
         }
         const [header, payload] = unpackMessage(data);
@@ -259,7 +1258,7 @@ export class RoomClient {
             return;
         }
         const stream = this._toolCallStreams.get(toolCallId);
-        if (!stream) {
+        if (stream == null) {
             return;
         }
         const content = this._decodeToolCallContent({ header, payload });
@@ -269,51 +1268,91 @@ export class RoomClient {
             this._toolCallStreams.delete(toolCallId);
         }
     }
-    async _handleResponse(protocol, messageId, type, data) {
-        if (!data) {
-            console.error("No data in response");
+    async _handleResponse(protocol, messageId, _type, data) {
+        if (!this.isActiveProtocol(protocol)) {
             return;
         }
         const response = unpackContent(data);
-        console.log("GOT RESPONSE", response);
-        if (!response) {
-            console.error("No response");
-            return;
-        }
-        if (this._pendingRequests.has(messageId)) {
-            const pr = this._pendingRequests.get(messageId);
+        const pending = this._pendingRequests.get(messageId);
+        if (pending != null) {
             this._pendingRequests.delete(messageId);
             if (response instanceof ErrorContent) {
-                pr.reject(new RoomServerException(response.text, response.code));
+                pending.completeError(new RoomServerException(response.text, response.code));
             }
             else {
-                pr.resolve(response);
+                pending.complete(response);
             }
+            return;
         }
-        else {
-            console.warn(`Received a response for a request that is not pending ${messageId}`);
+        const ignoredLabel = this._ignoredResponseLabels.get(messageId);
+        if (ignoredLabel != null) {
+            this._ignoredResponseLabels.delete(messageId);
+            if (response instanceof ErrorContent) {
+                console.warn(`one-way room request failed for ${ignoredLabel}: ${response.text}`);
+            }
         }
     }
-    async _handleRoomReady(protocol, messageId, type, data) {
-        const [message, _] = unpackMessage(data);
-        this._ready.complete(message["room_name"]);
+    async _handleRoomStatus(protocol, _messageId, _type, data) {
+        if (!this.isActiveProtocol(protocol)) {
+            return;
+        }
+        const [payload] = unpackMessage(data);
+        this.emit(RoomStatusEvent.fromJson(payload));
+    }
+    async _handleRoomReady(protocol, _messageId, _type, data) {
+        if (!this.isActiveProtocol(protocol)) {
+            return;
+        }
+        const [message] = unpackMessage(data);
+        this._roomName = typeof message["room_name"] === "string" ? message["room_name"] : null;
+        this._roomUrl = typeof message["room_url"] === "string" ? message["room_url"] : null;
+        this._sessionId = typeof message["session_id"] === "string" ? message["session_id"] : null;
+        if (!this._ready.completed) {
+            this._ready.complete();
+        }
+        if (!this._connectionReady.completed) {
+            this._connectionReady.complete();
+        }
     }
     _onParticipantInit(participantId, attributes) {
-        this._localParticipant = new LocalParticipant(this, participantId);
-        for (const k in attributes) {
-            this._localParticipant.setAttribute(k, attributes[k]);
+        if (this._localParticipant == null) {
+            this._localParticipant = new LocalParticipant(this, participantId);
+            this._localParticipant._setAttributes(attributes);
+        }
+        else {
+            const merged = { ...attributes, ...this._localParticipant._attributesSnapshot() };
+            this._localParticipant._replaceIdentity({
+                participantId,
+                attributes: merged,
+            });
+        }
+        if (!this._localParticipantReady.completed) {
+            this._localParticipantReady.complete();
         }
     }
-    async _handleParticipant(protocol, messageId, type, data) {
-        const [message, _] = unpackMessage(data);
+    async _handleParticipant(protocol, _messageId, _type, data) {
+        if (!this.isActiveProtocol(protocol)) {
+            return;
+        }
+        const [message] = unpackMessage(data);
         switch (message["type"]) {
-            case "init": this._onParticipantInit(message["participantId"], message["attributes"]);
+            case "init": {
+                const participantId = message["participantId"];
+                const attributes = message["attributes"];
+                if (typeof participantId === "string" &&
+                    typeof attributes === "object" &&
+                    attributes !== null &&
+                    !Array.isArray(attributes)) {
+                    this._onParticipantInit(participantId, attributes);
+                }
+                break;
+            }
+            default:
+                break;
         }
     }
-    emit(event) {
-        this._eventsController.add(event);
-    }
-    listen() {
-        return this._eventsController.stream;
+    _emitStatus({ status, message, }) {
+        this.emit(new RoomStatusEvent({ status, message }));
     }
 }
+RoomClient.RECONNECT_RETRY_INTERVAL_MS = 1000;