@meshagent/meshagent 0.37.1 → 0.38.0

package/dist/browser/room-client.d.ts

@@ -1,23 +1,52 @@
-import { Protocol } from "./protocol";
-import { LocalParticipant } from "./participant";
-import { SyncClient } from "./sync-client";
+import { DatabaseClient } from "./database-client";
 import { DeveloperClient } from "./developer-client";
-import { StorageClient } from "./storage-client";
+import { type EventHandler, type EventName } from "./event-emitter";
 import { MessagingClient } from "./messaging-client";
+import { MemoryClient } from "./memory-client";
+import { LocalParticipant } from "./participant";
+import { Protocol, ProtocolCloseKind, ProtocolFactory, type MessageHandler } from "./protocol";
 import { QueuesClient } from "./queues-client";
-import { DatabaseClient } from "./database-client";
-import { AgentsClient, ToolkitDescription } from "./agent-client";
+import { Content } from "./response";
+import { RoomEvent } 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 { RoomEvent } from "./room-event";
-import { type Content } from "./response";
+import { StorageClient } from "./storage-client";
+import { SyncClient } from "./sync-client";
+import { AgentsClient, ToolkitDescription } from "./agent-client";
+import { ContainersClient } from "./containers-client";
 interface RequestHeader {
-    [key: string]: any;
+    [key: string]: unknown;
+}
+export declare class RoomProtocolProxy {
+    private readonly _room;
+    private readonly _handlers;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    _bind(protocol: Protocol): void;
+    _unbind(protocol: Protocol): void;
+    addHandler(type: string, handler: MessageHandler): void;
+    removeHandler(type: string, handler: MessageHandler): void;
+    getHandler(type: string): MessageHandler | undefined;
+    send(type: string, data: Uint8Array, { id }?: {
+        id?: number;
+    }): Promise<void>;
+    sendNowait(type: string, data: Uint8Array, { id }?: {
+        id?: number;
+    }): number;
+    getNextMessageId(): number;
+    get done(): Promise<unknown>;
+    waitForClose(): Promise<void>;
+    get closeKind(): ProtocolCloseKind | null;
+    get closeReason(): string | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get token(): string | null;
+    get url(): string | null;
 }
 export declare class RoomClient {
-    protocol: Protocol;
+    readonly protocol: RoomProtocolProxy;
     readonly sync: SyncClient;
     readonly storage: StorageClient;
     readonly developer: DeveloperClient;
@@ -29,26 +58,133 @@ export declare class RoomClient {
     readonly containers: ContainersClient;
     readonly memory: MemoryClient;
     readonly services: ServicesClient;
-    private _pendingRequests;
-    private _ready;
+    _protocolInstance: Protocol;
+    _entered: boolean;
+    _allowDisconnectedRequests: boolean;
+    private readonly _protocolFactory;
+    private readonly _reconnectTimeout;
+    private readonly _eventsController;
+    private readonly _eventEmitter;
+    private readonly _pendingRequests;
+    private readonly _toolCallStreams;
+    private readonly _ignoredResponseLabels;
+    private readonly _ready;
+    private readonly _roomClosed;
+    private _connectionReady;
+    private _localParticipantReady;
+    private _connected;
+    private _closing;
     private _localParticipant;
-    private _eventsController;
-    private _toolCallStreams;
-    constructor({ protocol }: {
-        protocol: Protocol;
+    private _lifecycleTask;
+    private _terminalState;
+    private _closeKind;
+    private _closeReason;
+    private _doneHandler?;
+    private _errorHandler?;
+    private _terminalCallbacksInvoked;
+    private _roomName;
+    private _roomUrl;
+    private _sessionId;
+    private static readonly RECONNECT_RETRY_INTERVAL_MS;
+    private readonly _handleRoomReadyBound;
+    private readonly _handleRoomStatusBound;
+    private readonly _handleParticipantBound;
+    private readonly _handleResponseBound;
+    private readonly _handleToolCallResponseChunkBound;
+    constructor({ protocolFactory, reconnectTimeout, }?: {
+        protocolFactory?: ProtocolFactory | null;
+        reconnectTimeout?: number | null;
     });
     get localParticipant(): LocalParticipant | null;
-    get ready(): Promise<boolean>;
-    start({ onDone, onError }?: {
+    get ready(): Promise<void>;
+    get isConnected(): boolean;
+    get isClosed(): boolean;
+    get isClosing(): boolean;
+    get closeKind(): ProtocolCloseKind | null;
+    get closeReason(): string | null;
+    get roomName(): string | null;
+    get roomUrl(): string | null;
+    get sessionId(): string | null;
+    isActiveProtocol(protocol: Protocol): boolean;
+    on(eventName: EventName, callback: EventHandler<RoomEvent>): void;
+    off(eventName: EventName, callback: EventHandler<RoomEvent>): void;
+    emit(event: RoomEvent): void;
+    listen(): AsyncIterable<RoomEvent>;
+    waitForClose(): Promise<void>;
+    waitUntilConnected(): Promise<void>;
+    _waitUntilConnectedForMessages(): Promise<void>;
+    private _markConnected;
+    private _markDisconnected;
+    private _completeRoomClosed;
+    private _invokeTerminalCallbacks;
+    private _formatClosedMessage;
+    private _connectionFailureReason;
+    private _protocolTerminalState;
+    private _clientClosedTerminalState;
+    private _unexpectedCloseTerminalState;
+    private _setStartupTerminalState;
+    private _setTerminalState;
+    _raiseIfTerminal(): void;
+    _raiseIfTerminalForMessages(): void;
+    _disconnectedError({ baseMessage }: {
+        baseMessage: string;
+    }): RoomServerException;
+    _messageDisconnectedError({ baseMessage, }: {
+        baseMessage: string;
+    }): RoomServerException;
+    private _startupException;
+    private _finalizeInitialStartupRetryFailure;
+    _coerceMessageSendError(error: RoomServerException): RoomServerException;
+    _messageStopError(): RoomServerException;
+    private _failPendingRequests;
+    private _failToolCallStreams;
+    private _failPendingWork;
+    private _openProtocol;
+    start({ onDone, onError, }?: {
         onDone?: () => void;
-        onError?: (error: Error) => void;
+        onError?: (error: unknown) => void;
     }): Promise<void>;
+    private _completeReconnect;
+    private _replaceProtocol;
+    private _remainingReconnectTimeout;
+    private _attemptInitialProtocolStartup;
+    private _attemptReconnect;
+    private _formatDuration;
+    private _reconnectTimeoutReason;
+    private _timedOutRetryResult;
+    private _closeAfterUnexpectedDisconnect;
+    private _closeProtocol;
+    private _retryProtocolConnection;
+    private _reconnect;
+    private _connectionLifecycle;
     dispose(): void;
+    _sendProtocolNowait({ type, data, label, messageId, expectResponse, }: {
+        type: string;
+        data: Uint8Array;
+        label: string;
+        messageId?: number;
+        expectResponse?: boolean;
+    }): number | null;
+    _sendRoomRequestNowait(type: string, request: Record<string, unknown>, { data, label, expectResponse, }: {
+        data?: Uint8Array;
+        label: string;
+        expectResponse?: boolean;
+    }): number | null;
+    invokeNowait({ toolkit, tool, input, participantId, onBehalfOfId, callerContext, }: {
+        toolkit: string;
+        tool: string;
+        input?: Content;
+        participantId?: string;
+        onBehalfOfId?: string;
+        callerContext?: Record<string, unknown>;
+    }): void;
+    _sendLocalAttributesNowait(attributes: Record<string, unknown>): void;
+    _resendLocalAttributesNowait(): void;
     sendRequest(type: string, request: RequestHeader, data?: Uint8Array): Promise<Content>;
     call(params: {
         name: string;
         url: string;
-        arguments: Record<string, any>;
+        arguments: Record<string, unknown>;
     }): Promise<void>;
     listToolkits(params?: {
         participantId?: string;
@@ -58,11 +194,11 @@ export declare class RoomClient {
     invoke(params: {
         toolkit: string;
         tool: string;
-        arguments?: Record<string, any>;
-        input?: Record<string, any> | Content;
+        arguments?: Record<string, unknown>;
+        input?: Record<string, unknown> | Content;
         participantId?: string;
         onBehalfOfId?: string;
-        callerContext?: Record<string, any>;
+        callerContext?: Record<string, unknown>;
     }): Promise<Content>;
     invokeWithStreamInput(params: {
         toolkit: string;
@@ -70,7 +206,7 @@ export declare class RoomClient {
         input: AsyncIterable<Content>;
         participantId?: string;
         onBehalfOfId?: string;
-        callerContext?: Record<string, any>;
+        callerContext?: Record<string, unknown>;
     }): Promise<Content>;
     invokeStream(params: {
         toolkit: string;
@@ -78,17 +214,17 @@ export declare class RoomClient {
         input: AsyncIterable<Content>;
         participantId?: string;
         onBehalfOfId?: string;
-        callerContext?: Record<string, any>;
+        callerContext?: Record<string, unknown>;
     }): Promise<AsyncIterable<Content>>;
     private _sendToolCallRequestChunk;
     private _streamInvokeToolRequestChunks;
     private _decodeToolCallContent;
     private _handleToolCallResponseChunk;
     private _handleResponse;
+    private _handleRoomStatus;
     private _handleRoomReady;
     private _onParticipantInit;
     private _handleParticipant;
-    emit(event: RoomEvent): void;
-    listen(): AsyncIterable<RoomEvent>;
+    private _emitStatus;
 }
 export {};