@meshagent/meshagent-agents 0.47.0 → 0.48.0

package/dist/node/chat-client.d.ts

@@ -1,10 +1,12 @@
-import { RemoteParticipant } from "@meshagent/meshagent";
+import { MessagingStream, RemoteParticipant } from "@meshagent/meshagent";
 import type { RoomClient, Content } from "@meshagent/meshagent";
-import { AgentMessage, AgentModelChanged, AgentThreadStatus, ModelsResponse, ToolChoice, AgentConnectionStatus, AgentClientToolCallRequested } from "./agent-messages.js";
-import type { AgentPayload, JsonMap, ClientToolkitDescription } from "./agent-messages.js";
+import { AgentMessage, AgentFileContent, ThreadCreated, AgentConnectionStatus } from "./agent-messages.js";
+import type { AgentPayload, ClientToolkitDescription } from "./agent-messages.js";
 import { ChangeEmitter } from "./change-emitter.js";
+type JsonMap = Record<string, any>;
 export declare class AgentMessageEvent {
-    readonly message: AgentMessage;
+    private messageValue;
+    private readonly listeners;
     readonly createdAt: Date;
     readonly attachment?: Uint8Array;
     constructor({ message, createdAt, attachment }: {
@@ -12,7 +14,11 @@ export declare class AgentMessageEvent {
         createdAt?: Date;
         attachment?: Uint8Array;
     });
+    get message(): AgentMessage;
     get payload(): AgentPayload;
+    addEventListener(listener: () => void): void;
+    removeEventListener(listener: () => void): void;
+    replaceMessage(message: AgentMessage): void;
 }
 export declare class PendingAgentInput {
     readonly messageId: string;
@@ -77,12 +83,28 @@ export declare class ChatThreadStartResult {
         realtimeConnection?: JsonMap;
     });
 }
+export declare class PendingThreadStartCandidate {
+    readonly messageId: string;
+    readonly senderName?: string;
+    constructor({ messageId, senderName }: {
+        messageId: string;
+        senderName: string | undefined;
+    });
+}
+export type ThreadCreatedPendingStartMatcher = (message: InstanceType<typeof ThreadCreated>, candidates: PendingThreadStartCandidate[]) => string | undefined;
 export declare abstract class BaseChatClient extends ChangeEmitter {
+    readonly threadCreatedPendingStartMatcher?: ThreadCreatedPendingStartMatcher;
+    readonly deduplicateClientToolRequests: boolean;
     private readonly sessionsByPath;
     private readonly pendingStartRequests;
     private readonly pendingSessionEventsByPath;
     private readonly eventQueue;
+    private readonly claimedClientToolRequests;
     private _connectionStatus?;
+    constructor({ threadCreatedPendingStartMatcher, deduplicateClientToolRequests, }?: {
+        threadCreatedPendingStartMatcher?: ThreadCreatedPendingStartMatcher;
+        deduplicateClientToolRequests?: boolean;
+    });
     get events(): AsyncIterable<AgentMessageEvent>;
     get connectionStatus(): InstanceType<typeof AgentConnectionStatus> | undefined;
     get sessions(): ChatThreadSession[];
@@ -91,19 +113,17 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
     agentParticipant(): RemoteParticipant | null;
     localParticipantName(): string | undefined;
     localParticipantId(): string | undefined;
-    isClientToolCallForLocalParticipant(request: InstanceType<typeof AgentClientToolCallRequested>): boolean;
-    protected cleanParticipantName(value: string | undefined): string | undefined;
-    openThread(threadPath: string, { load, sinceTurn, reloadIfOpen, drainPendingEvents, }?: {
+    private clientToolRequestKey;
+    openThread(threadPath: string, { load, sinceTurn, reloadIfOpen, }?: {
         load?: boolean;
         sinceTurn?: string;
         reloadIfOpen?: boolean;
-        drainPendingEvents?: boolean;
     }): ChatThreadSession;
     private openSession;
-    startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, toolChoice, omitContent, }: {
+    startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, omitContent, }: {
         messageId?: string;
         message: string;
-        attachments: string[];
+        attachments: AgentFileContent[];
         name?: string;
         backend?: string;
         provider?: string;
@@ -113,7 +133,6 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
         realtimeProtocol?: string;
         senderName?: string;
         clientToolkits?: ClientToolkitDescription[];
-        toolChoice?: ToolChoice;
         omitContent?: boolean;
     }): Promise<ChatThreadStartResult>;
     private resolvedStartThreadMessage;
@@ -125,6 +144,7 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
         createdAt?: Date;
         attachment?: Uint8Array;
     }): void;
+    private acknowledgePendingStartFromThreadCreated;
     emitConnectionStatus({ status, message, reason, retryDelay, }: {
         status: string;
         message?: string;
@@ -133,7 +153,30 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
     }): void;
     removeThreadSession(threadPath: string): void;
 }
-export declare class MessagingChatClient extends BaseChatClient {
+export declare const messagingChatThreadSubscribeType = "meshagent.chat.thread.subscribe";
+export declare const messagingChatThreadListSubscribeType = "meshagent.chat.thread_list.subscribe";
+export declare class ThreadSubscribe {
+    readonly threadId: string;
+    readonly stream: MessagingStream;
+    constructor({ threadId, stream }: {
+        threadId: string;
+        stream: MessagingStream;
+    });
+    get closed(): boolean;
+    send(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class ThreadListSubscribe {
+    readonly stream: MessagingStream;
+    constructor({ stream }: {
+        stream: MessagingStream;
+    });
+    get closed(): boolean;
+    close(): Promise<void>;
+}
+export declare class BaseMessagingChatClient extends BaseChatClient {
     readonly room: RoomClient;
     readonly agentName?: string;
     private readonly pendingParticipantWaits;
@@ -143,9 +186,11 @@ export declare class MessagingChatClient extends BaseChatClient {
     private waitingForParticipant;
     private roomAbortController?;
     private messagingListenersAttached;
-    constructor({ room, agentName }: {
+    constructor({ room, agentName, threadCreatedPendingStartMatcher, deduplicateClientToolRequests, }: {
         room: RoomClient;
         agentName?: string;
+        threadCreatedPendingStartMatcher?: ThreadCreatedPendingStartMatcher;
+        deduplicateClientToolRequests?: boolean;
     });
     localParticipantName(): string | undefined;
     localParticipantId(): string | undefined;
@@ -154,8 +199,10 @@ export declare class MessagingChatClient extends BaseChatClient {
     private attachMessagingListeners;
     private detachMessagingListeners;
     agentParticipant(): RemoteParticipant | null;
-    waitForAgentParticipant({ waitKey }?: {
+    waitForAgentParticipant({ waitKey, signal, timeoutMs, }?: {
         waitKey?: string;
+        signal?: AbortSignal;
+        timeoutMs?: number;
     }): Promise<RemoteParticipant>;
     sendAgentMessage(message: AgentMessage, { attachment }?: {
         attachment?: Uint8Array;
@@ -167,6 +214,63 @@ export declare class MessagingChatClient extends BaseChatClient {
     private reopenOpenSessions;
     private readonly onMessagingMessage;
 }
+export declare class WebSocketChatClient extends BaseChatClient {
+    readonly url: URL;
+    readonly token: string;
+    readonly participantName?: string;
+    readonly protocols: string[];
+    readonly reconnect: boolean;
+    readonly reconnectInitialDelay: number;
+    readonly reconnectMaxDelay: number;
+    private webSocket?;
+    private receiveError?;
+    private closeCode?;
+    private closeReason?;
+    private started;
+    private stopping;
+    private connecting;
+    private reconnectAttempts;
+    private reconnectTimer?;
+    private assignedParticipantId?;
+    constructor({ url, token, participantName, protocols, reconnect, reconnectInitialDelay, reconnectMaxDelay, }: {
+        url: URL;
+        token: string;
+        participantName?: string;
+        protocols?: string[];
+        reconnect?: boolean;
+        reconnectInitialDelay?: number;
+        reconnectMaxDelay?: number;
+    });
+    get isConnected(): boolean;
+    localParticipantName(): string | undefined;
+    localParticipantId(): string | undefined;
+    start(): Promise<void>;
+    private connect;
+    stop(): Promise<void>;
+    sendAgentMessage(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+    private readonly onMessage;
+    private readonly onSocketError;
+    private readonly onSocketClose;
+    private detachSocketListeners;
+    private scheduleReconnect;
+    private nextReconnectDelay;
+    private reopenOpenSessions;
+    private resolvedProtocols;
+    private closedMessage;
+}
+export declare class MessagingChatClient extends BaseMessagingChatClient {
+    private readonly threadSubscriptions;
+    private threadListSubscription?;
+    private readonly streamTasks;
+    stop(): Promise<void>;
+    private supportsThreadSubscriptions;
+    private trackStream;
+    sendAgentMessage(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+}
 export declare class ChatThreadSession extends ChangeEmitter {
     private readonly client;
     readonly threadPath: string;
@@ -181,26 +285,15 @@ export declare class ChatThreadSession extends ChangeEmitter {
     private openState;
     private loadStateValue;
     private lastCompletedTurnIdValue?;
-    private activeTurnIdValue?;
-    private threadStatusValue?;
-    private currentModelValue?;
-    private modelsResponseValue?;
     private lastAgentMessageType?;
     private lastAgentMessageAt?;
-    constructor({ client, threadPath }: {
-        client: BaseChatClient;
-        threadPath: string;
-    });
+    private constructor();
     get messages(): AgentMessageEvent[];
     get pendingInputs(): PendingAgentInput[];
     get isOpen(): boolean;
     get loadState(): ChatThreadSessionLoadState;
     get isLoading(): boolean;
     get lastCompletedTurnId(): string | undefined;
-    get activeTurnId(): string | undefined;
-    get threadStatus(): InstanceType<typeof AgentThreadStatus> | undefined;
-    get currentModel(): InstanceType<typeof AgentModelChanged> | undefined;
-    get modelsResponse(): InstanceType<typeof ModelsResponse> | undefined;
     open({ load, sinceTurn }?: {
         load?: boolean;
         sinceTurn?: string;
@@ -220,10 +313,15 @@ export declare class ChatThreadSession extends ChangeEmitter {
         requestId: string;
         response: Content;
     }): Promise<void>;
-    sendText({ messageId, text, attachments, steer, turnId, backend, provider, model, voice, outputModalities, senderName, clientToolkits, toolChoice, }: {
+    claimClientToolCall(requestId: string): boolean;
+    finishClientToolCall(requestId: string, { responseSent }: {
+        responseSent: boolean;
+    }): void;
+    injectMessages(messages: readonly AgentMessage[]): Promise<void>;
+    sendText({ messageId, text, attachments, steer, turnId, backend, provider, model, voice, outputModalities, senderName, clientToolkits, }: {
         messageId?: string;
         text: string;
-        attachments: string[];
+        attachments: AgentFileContent[];
         steer?: boolean;
         turnId?: string;
         backend?: string;
@@ -233,14 +331,14 @@ export declare class ChatThreadSession extends ChangeEmitter {
         outputModalities?: string[];
         senderName?: string;
         clientToolkits?: ClientToolkitDescription[];
-        toolChoice?: ToolChoice;
     }): Promise<string>;
     sendRealtimeAudioChunk({ chunk, format }: {
         chunk: Uint8Array;
         format: JsonMap;
     }): Promise<void>;
-    commitRealtimeAudio({ turnId, provider, model, voice, outputModalities, }: {
+    commitRealtimeAudio({ turnId, backend, provider, model, voice, outputModalities, }: {
         turnId: string;
+        backend?: string;
         provider?: string;
         model?: string;
         voice?: string;
@@ -253,16 +351,12 @@ export declare class ChatThreadSession extends ChangeEmitter {
     private updatePendingInputsForMessage;
     private appendRenderableMessage;
     private appendMessage;
-    private upsertItemMessage;
     private appendOrMergeDelta;
     private indexMessagesFrom;
-    private applyActiveModel;
-    markClosed({ notify }?: {
-        notify?: boolean;
-    }): void;
     private loadingStateForOpen;
     private failedLoadState;
     private setLoadState;
     private markPending;
     private updatePending;
 }
+export {};