@meshagent/meshagent-agents 0.43.0

package/dist/esm/change-emitter.d.ts

@@ -0,0 +1,8 @@
+type Listener = () => void;
+export declare class ChangeEmitter {
+    private readonly listeners;
+    addListener(listener: Listener): void;
+    removeListener(listener: Listener): void;
+    protected notifyListeners(): void;
+}
+export {};

package/dist/esm/change-emitter.js

@@ -0,0 +1,16 @@
+export class ChangeEmitter {
+    constructor() {
+        this.listeners = new Set();
+    }
+    addListener(listener) {
+        this.listeners.add(listener);
+    }
+    removeListener(listener) {
+        this.listeners.delete(listener);
+    }
+    notifyListeners() {
+        for (const listener of [...this.listeners]) {
+            listener();
+        }
+    }
+}

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

@@ -0,0 +1,225 @@
+import { RemoteParticipant } from "@meshagent/meshagent";
+import type { RoomClient, Content } from "@meshagent/meshagent";
+import { AgentMessage, AgentConnectionStatus } from "./agent-messages.js";
+import type { AgentPayload, JsonMap, ClientToolkitDescription } from "./agent-messages.js";
+import { ChangeEmitter } from "./change-emitter.js";
+export declare class AgentMessageEvent {
+    readonly message: AgentMessage;
+    readonly attachment?: Uint8Array;
+    constructor({ message, attachment }: {
+        message: AgentMessage;
+        attachment?: Uint8Array;
+    });
+    get payload(): AgentPayload;
+}
+export declare class PendingAgentInput {
+    readonly messageId: string;
+    readonly messageType: string;
+    readonly threadPath: string;
+    readonly payload: AgentMessage;
+    readonly createdAt: Date;
+    readonly awaitingAcceptance: boolean;
+    readonly awaitingApplication: boolean;
+    readonly awaitingOnline: boolean;
+    constructor({ messageId, messageType, threadPath, payload, createdAt, awaitingAcceptance, awaitingApplication, awaitingOnline, }: {
+        messageId: string;
+        messageType: string;
+        threadPath: string;
+        payload: AgentMessage;
+        createdAt: Date;
+        awaitingAcceptance?: boolean;
+        awaitingApplication?: boolean;
+        awaitingOnline?: boolean;
+    });
+    copyWith({ awaitingAcceptance, awaitingApplication, awaitingOnline, }: {
+        awaitingAcceptance?: boolean;
+        awaitingApplication?: boolean;
+        awaitingOnline?: boolean;
+    }): PendingAgentInput;
+}
+export declare enum ChatThreadSessionLoadPhase {
+    Idle = "idle",
+    Loading = "loading",
+    Loaded = "loaded",
+    Failed = "failed"
+}
+export declare class ChatThreadSessionLoadState {
+    readonly phase: ChatThreadSessionLoadPhase;
+    readonly startedAt?: Date;
+    readonly completedAt?: Date;
+    readonly requestMessageId?: string;
+    readonly sinceTurn?: string;
+    readonly error?: string;
+    readonly lastMessageType?: string;
+    readonly lastMessageAt?: Date;
+    constructor({ phase, startedAt, completedAt, requestMessageId, sinceTurn, error, lastMessageType, lastMessageAt, }: {
+        phase: ChatThreadSessionLoadPhase;
+        startedAt?: Date;
+        completedAt?: Date;
+        requestMessageId?: string;
+        sinceTurn?: string;
+        error?: string;
+        lastMessageType?: string;
+        lastMessageAt?: Date;
+    });
+    static idle(): ChatThreadSessionLoadState;
+    get isLoading(): boolean;
+}
+export declare class ChatThreadStartResult {
+    readonly session: ChatThreadSession;
+    readonly threadPath: string;
+    readonly realtimeConnection?: JsonMap;
+    constructor({ session, threadPath, realtimeConnection }: {
+        session: ChatThreadSession;
+        threadPath: string;
+        realtimeConnection?: JsonMap;
+    });
+}
+export declare abstract class BaseChatClient extends ChangeEmitter {
+    private readonly sessionsByPath;
+    private readonly pendingStartRequests;
+    private readonly eventQueue;
+    private _connectionStatus?;
+    get events(): AsyncIterable<AgentMessageEvent>;
+    get connectionStatus(): InstanceType<typeof AgentConnectionStatus> | undefined;
+    get sessions(): ChatThreadSession[];
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    agentParticipant(): RemoteParticipant | null;
+    localParticipantName(): string | undefined;
+    protected cleanParticipantName(value: string | undefined): string | undefined;
+    openThread(threadPath: string, { load, sinceTurn, reloadIfOpen }?: {
+        load?: boolean;
+        sinceTurn?: string;
+        reloadIfOpen?: boolean;
+    }): ChatThreadSession;
+    startThread({ messageId, message, attachments, name, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, omitContent, }: {
+        messageId?: string;
+        message: string;
+        attachments: string[];
+        name?: string;
+        provider?: string;
+        model?: string;
+        voice?: string;
+        outputModalities?: string[];
+        realtimeProtocol?: string;
+        senderName?: string;
+        clientToolkits?: ClientToolkitDescription[];
+        omitContent?: boolean;
+    }): Promise<ChatThreadStartResult>;
+    abstract sendAgentMessage(message: AgentMessage, options?: {
+        attachment?: Uint8Array;
+        ignoreOffline?: boolean;
+    }): Promise<void>;
+    handleAgentMessage(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): void;
+    emitConnectionStatus({ status, message, reason, retryDelay, }: {
+        status: string;
+        message?: string;
+        reason?: string;
+        retryDelay?: number;
+    }): void;
+    removeThreadSession(threadPath: string): void;
+}
+export declare class MessagingChatClient extends BaseChatClient {
+    readonly room: RoomClient;
+    readonly agentName?: string;
+    private readonly pendingParticipantWaits;
+    private readonly roomAbortController;
+    private started;
+    private roomPump?;
+    constructor({ room, agentName }: {
+        room: RoomClient;
+        agentName?: string;
+    });
+    localParticipantName(): string | undefined;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    agentParticipant(): RemoteParticipant | null;
+    waitForAgentParticipant({ waitKey }?: {
+        waitKey?: string;
+    }): Promise<RemoteParticipant>;
+    sendAgentMessage(message: AgentMessage, { attachment, ignoreOffline }?: {
+        attachment?: Uint8Array;
+        ignoreOffline?: boolean;
+    }): Promise<void>;
+    private readonly onMessagingChanged;
+    private consumeRoomEvents;
+    private onRoomEvent;
+}
+export declare class ChatThreadSession extends ChangeEmitter {
+    private readonly client;
+    readonly threadPath: string;
+    private readonly _messages;
+    private readonly pendingInputsById;
+    private openState;
+    private loadStateValue;
+    private lastCompletedTurnIdValue?;
+    private lastAgentMessageType?;
+    private lastAgentMessageAt?;
+    constructor({ client, threadPath }: {
+        client: BaseChatClient;
+        threadPath: string;
+    });
+    get messages(): AgentMessageEvent[];
+    get pendingInputs(): PendingAgentInput[];
+    get isOpen(): boolean;
+    get loadState(): ChatThreadSessionLoadState;
+    get isLoading(): boolean;
+    get lastCompletedTurnId(): string | undefined;
+    open({ load, sinceTurn }?: {
+        load?: boolean;
+        sinceTurn?: string;
+    }): Promise<void>;
+    close(): Promise<void>;
+    requestModels({ ignoreOffline }?: {
+        ignoreOffline?: boolean;
+    }): Promise<void>;
+    changeModel({ provider, model, voice }: {
+        provider: string;
+        model: string;
+        voice?: string;
+    }): Promise<void>;
+    interruptTurn(turnId: string): Promise<void>;
+    respondToClientToolCall({ turnId, requestId, response }: {
+        turnId: string;
+        requestId: string;
+        response: Content;
+    }): Promise<void>;
+    sendText({ messageId, text, attachments, steer, turnId, provider, model, voice, outputModalities, senderName, clientToolkits, }: {
+        messageId?: string;
+        text: string;
+        attachments: string[];
+        steer?: boolean;
+        turnId?: string;
+        provider?: string;
+        model?: string;
+        voice?: string;
+        outputModalities?: string[];
+        senderName?: string;
+        clientToolkits?: ClientToolkitDescription[];
+    }): Promise<string>;
+    sendRealtimeAudioChunk({ chunk, format }: {
+        chunk: Uint8Array;
+        format: JsonMap;
+    }): Promise<void>;
+    commitRealtimeAudio({ turnId, provider, model, voice, outputModalities, }: {
+        turnId: string;
+        provider?: string;
+        model?: string;
+        voice?: string;
+        outputModalities?: string[];
+    }): Promise<string>;
+    deleteThread(threadPath: string): Promise<void>;
+    renameThread(threadPath: string, name: string): Promise<void>;
+    addAgentMessage(event: AgentMessageEvent): void;
+    markClosed({ notify }?: {
+        notify?: boolean;
+    }): void;
+    private loadingStateForOpen;
+    private failedLoadState;
+    private setLoadState;
+    private markPending;
+    private updatePending;
+}