@meshagent/meshagent-agents 0.43.0

package/dist/esm/chat-client.js

@@ -0,0 +1,632 @@
+import { Completer, RoomMessageEvent, } from "@meshagent/meshagent";
+import { v4 as uuidv4 } from "uuid";
+import { AgentMessage as AgentMessageFactory, AgentRealtimeAudioChunk, AgentRealtimeAudioCommit, ChangeModel, CloseThread, DeleteThread, ModelsRequest, OpenThread, RenameThread, StartThread, AgentConnectionStatus, TurnInterrupt, TurnStart, TurnSteer, AgentClientToolCallResponse, agentInputContent, agentRoomMessageType, agentThreadClearedType, agentThreadLoadedType, agentConnectionStatusType, agentThreadStartRejectedType, agentThreadStartedType, agentTurnEndedType, agentTurnStartAcceptedType, agentTurnStartRejectedType, agentTurnStartType, agentTurnStartedType, agentTurnSteerAcceptedType, agentTurnSteerRejectedType, agentTurnSteerType, agentTurnSteeredType, } from "./agent-messages.js";
+import { ChangeEmitter } from "./change-emitter.js";
+export class AgentMessageEvent {
+    constructor({ message, attachment }) {
+        this.message = message;
+        this.attachment = attachment;
+    }
+    get payload() {
+        return this.message.toJson();
+    }
+}
+export class PendingAgentInput {
+    constructor({ messageId, messageType, threadPath, payload, createdAt, awaitingAcceptance = false, awaitingApplication = false, awaitingOnline = false, }) {
+        this.messageId = messageId;
+        this.messageType = messageType;
+        this.threadPath = threadPath;
+        this.payload = payload;
+        this.createdAt = createdAt;
+        this.awaitingAcceptance = awaitingAcceptance;
+        this.awaitingApplication = awaitingApplication;
+        this.awaitingOnline = awaitingOnline;
+    }
+    copyWith({ awaitingAcceptance, awaitingApplication, awaitingOnline, }) {
+        return new PendingAgentInput({
+            messageId: this.messageId,
+            messageType: this.messageType,
+            threadPath: this.threadPath,
+            payload: this.payload,
+            createdAt: this.createdAt,
+            awaitingAcceptance: awaitingAcceptance ?? this.awaitingAcceptance,
+            awaitingApplication: awaitingApplication ?? this.awaitingApplication,
+            awaitingOnline: awaitingOnline ?? this.awaitingOnline,
+        });
+    }
+}
+export var ChatThreadSessionLoadPhase;
+(function (ChatThreadSessionLoadPhase) {
+    ChatThreadSessionLoadPhase["Idle"] = "idle";
+    ChatThreadSessionLoadPhase["Loading"] = "loading";
+    ChatThreadSessionLoadPhase["Loaded"] = "loaded";
+    ChatThreadSessionLoadPhase["Failed"] = "failed";
+})(ChatThreadSessionLoadPhase || (ChatThreadSessionLoadPhase = {}));
+export class ChatThreadSessionLoadState {
+    constructor({ phase, startedAt, completedAt, requestMessageId, sinceTurn, error, lastMessageType, lastMessageAt, }) {
+        this.phase = phase;
+        this.startedAt = startedAt;
+        this.completedAt = completedAt;
+        this.requestMessageId = requestMessageId;
+        this.sinceTurn = sinceTurn;
+        this.error = error;
+        this.lastMessageType = lastMessageType;
+        this.lastMessageAt = lastMessageAt;
+    }
+    static idle() {
+        return new ChatThreadSessionLoadState({ phase: ChatThreadSessionLoadPhase.Idle });
+    }
+    get isLoading() {
+        return this.phase === ChatThreadSessionLoadPhase.Loading;
+    }
+}
+export class ChatThreadStartResult {
+    constructor({ session, threadPath, realtimeConnection }) {
+        this.session = session;
+        this.threadPath = threadPath;
+        this.realtimeConnection = realtimeConnection;
+    }
+}
+class EventQueue {
+    constructor() {
+        this.items = [];
+        this.waiters = [];
+    }
+    add(item) {
+        const waiter = this.waiters.shift();
+        if (waiter != null) {
+            waiter({ value: item, done: false });
+            return;
+        }
+        this.items.push(item);
+    }
+    get stream() {
+        return {
+            [Symbol.asyncIterator]: () => ({
+                next: async () => {
+                    const item = this.items.shift();
+                    if (item !== undefined) {
+                        return { value: item, done: false };
+                    }
+                    return new Promise((resolve) => this.waiters.push(resolve));
+                },
+            }),
+        };
+    }
+}
+export class BaseChatClient extends ChangeEmitter {
+    constructor() {
+        super(...arguments);
+        this.sessionsByPath = new Map();
+        this.pendingStartRequests = new Map();
+        this.eventQueue = new EventQueue();
+    }
+    get events() {
+        return this.eventQueue.stream;
+    }
+    get connectionStatus() {
+        return this._connectionStatus;
+    }
+    get sessions() {
+        return [...this.sessionsByPath.values()];
+    }
+    async start() { }
+    async stop() { }
+    agentParticipant() {
+        return null;
+    }
+    localParticipantName() {
+        return undefined;
+    }
+    cleanParticipantName(value) {
+        return nonEmptyTrimmed(value);
+    }
+    openThread(threadPath, { load = true, sinceTurn, reloadIfOpen = false } = {}) {
+        const normalized = threadPath.trim();
+        if (normalized === "") {
+            throw new TypeError("thread path cannot be empty");
+        }
+        const existing = this.sessionsByPath.get(normalized);
+        if (existing != null) {
+            if (!existing.isOpen || reloadIfOpen) {
+                void existing.open({ load, sinceTurn });
+            }
+            return existing;
+        }
+        const created = new ChatThreadSession({ client: this, threadPath: normalized });
+        this.sessionsByPath.set(normalized, created);
+        void created.open({ load, sinceTurn });
+        this.notifyListeners();
+        return created;
+    }
+    async startThread({ messageId, message, attachments, name, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, omitContent = false, }) {
+        const resolvedMessageId = messageId == null || messageId.trim() === "" ? uuidv4() : messageId.trim();
+        const resolvedSenderName = this.cleanParticipantName(senderName) ?? this.localParticipantName();
+        const payload = new StartThread({
+            messageId: resolvedMessageId,
+            content: omitContent ? undefined : agentInputContent({ text: message, attachments }),
+            name: nonEmptyTrimmed(name),
+            provider: nonEmptyTrimmed(provider),
+            model: nonEmptyTrimmed(model),
+            voice: nonEmptyTrimmed(voice),
+            outputModalities: outputModalities != null && outputModalities.length > 0 ? outputModalities : undefined,
+            realtimeProtocol: nonEmptyTrimmed(realtimeProtocol),
+            senderName: resolvedSenderName,
+            clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
+        });
+        const completer = new Completer();
+        this.pendingStartRequests.set(resolvedMessageId, completer);
+        try {
+            await this.sendAgentMessage(payload);
+            const response = await completer.fut;
+            const threadPath = "threadId" in response
+                ? String(response.threadId ?? "").trim()
+                : "";
+            if (threadPath === "") {
+                throw new Error("Agent did not return a thread_id for the new thread.");
+            }
+            const session = this.openThread(threadPath, { load: false });
+            if (!omitContent) {
+                session.addAgentMessage(new AgentMessageEvent({ message: payload }));
+            }
+            return new ChatThreadStartResult({
+                session,
+                threadPath,
+                realtimeConnection: response.type === agentThreadStartedType && response.realtimeConnection != null
+                    ? response.realtimeConnection.toJson()
+                    : undefined,
+            });
+        }
+        finally {
+            this.pendingStartRequests.delete(resolvedMessageId);
+        }
+    }
+    handleAgentMessage(message, { attachment } = {}) {
+        if (message.type === agentConnectionStatusType) {
+            this._connectionStatus = message;
+            for (const session of this.sessionsByPath.values()) {
+                if (session.isOpen) {
+                    session.addAgentMessage(new AgentMessageEvent({ message, attachment }));
+                }
+            }
+        }
+        this.eventQueue.add(new AgentMessageEvent({ message, attachment }));
+        const sourceMessageId = sourceMessageIdFor(message);
+        if ((message.type === agentThreadStartedType || message.type === agentThreadStartRejectedType) &&
+            sourceMessageId != null &&
+            sourceMessageId.trim() !== "") {
+            const pending = this.pendingStartRequests.get(sourceMessageId.trim());
+            if (pending != null && !pending.completed) {
+                pending.complete(message);
+            }
+        }
+        const threadPath = "threadId" in message ? String(message.threadId).trim() : "";
+        if (threadPath === "") {
+            this.notifyListeners();
+            return;
+        }
+        this.sessionsByPath.get(threadPath)?.addAgentMessage(new AgentMessageEvent({ message, attachment }));
+        this.notifyListeners();
+    }
+    emitConnectionStatus({ status, message, reason, retryDelay, }) {
+        const event = new AgentConnectionStatus({
+            status,
+            message,
+            reason,
+            retryInSeconds: retryDelay == null ? undefined : retryDelay / 1000,
+        });
+        this._connectionStatus = event;
+        this.eventQueue.add(new AgentMessageEvent({ message: event }));
+        for (const session of this.sessionsByPath.values()) {
+            if (session.isOpen) {
+                session.addAgentMessage(new AgentMessageEvent({ message: event }));
+            }
+        }
+        this.notifyListeners();
+    }
+    removeThreadSession(threadPath) {
+        const normalized = threadPath.trim();
+        const removed = this.sessionsByPath.get(normalized);
+        this.sessionsByPath.delete(normalized);
+        removed?.markClosed({ notify: false });
+        if (removed != null) {
+            this.notifyListeners();
+        }
+    }
+}
+export class MessagingChatClient extends BaseChatClient {
+    constructor({ room, agentName }) {
+        super();
+        this.pendingParticipantWaits = new Map();
+        this.roomAbortController = new AbortController();
+        this.started = false;
+        this.onMessagingChanged = () => {
+            const participant = this.agentParticipant();
+            if (participant != null) {
+                this.emitConnectionStatus({ status: "connected", message: "Agent messaging connected" });
+                for (const wait of this.pendingParticipantWaits.values()) {
+                    if (!wait.completed) {
+                        wait.complete(participant);
+                    }
+                }
+            }
+            this.notifyListeners();
+        };
+        this.room = room;
+        this.agentName = agentName;
+        this.room.messaging.addListener("message", this.onMessagingChanged);
+        this.roomPump = this.consumeRoomEvents();
+    }
+    localParticipantName() {
+        const name = this.room.localParticipant?.getAttribute("name");
+        return typeof name === "string" ? this.cleanParticipantName(name) : undefined;
+    }
+    async start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.room.messaging.start();
+        this.room.messaging.enable();
+    }
+    async stop() {
+        this.started = false;
+        this.roomAbortController.abort();
+        this.room.messaging.removeListener("message", this.onMessagingChanged);
+        for (const wait of this.pendingParticipantWaits.values()) {
+            if (!wait.completed) {
+                wait.completeError(new Error("Chat client stopped while waiting for an agent participant."));
+            }
+        }
+        this.pendingParticipantWaits.clear();
+        await this.roomPump?.catch(() => undefined);
+    }
+    agentParticipant() {
+        const normalizedAgentName = this.agentName?.trim();
+        for (const participant of this.room.messaging.remoteParticipants) {
+            if (normalizedAgentName != null && normalizedAgentName !== "" && participant.getAttribute("name") !== normalizedAgentName) {
+                continue;
+            }
+            if (participant.getAttribute("supports_agent_messages") === true) {
+                return participant;
+            }
+        }
+        return null;
+    }
+    async waitForAgentParticipant({ waitKey } = {}) {
+        const existing = this.agentParticipant();
+        if (existing != null) {
+            return existing;
+        }
+        const key = waitKey == null || waitKey.trim() === "" ? uuidv4() : waitKey.trim();
+        const completer = new Completer();
+        this.pendingParticipantWaits.set(key, completer);
+        this.onMessagingChanged();
+        try {
+            return await completer.fut;
+        }
+        finally {
+            this.pendingParticipantWaits.delete(key);
+        }
+    }
+    async sendAgentMessage(message, { attachment, ignoreOffline = false } = {}) {
+        await this.start();
+        const participant = this.agentParticipant() ?? await this.waitForAgentParticipant({ waitKey: message.messageId });
+        await this.room.messaging.sendMessage({
+            to: participant,
+            type: agentRoomMessageType,
+            message: message.toJson(),
+            attachment,
+            ignoreOffline,
+        });
+    }
+    async consumeRoomEvents() {
+        try {
+            for await (const event of this.room.listen({ abortSignal: this.roomAbortController.signal })) {
+                this.onRoomEvent(event);
+            }
+        }
+        catch {
+            if (!this.roomAbortController.signal.aborted) {
+                throw new Error("chat client room event listener stopped unexpectedly");
+            }
+        }
+    }
+    onRoomEvent(event) {
+        if (!(event instanceof RoomMessageEvent) || event.message.type !== agentRoomMessageType) {
+            return;
+        }
+        const participant = this.agentParticipant();
+        if (participant == null || event.message.fromParticipantId !== participant.id) {
+            return;
+        }
+        const message = event.message.message;
+        const rawPayload = typeof message.type === "string" ? message : message.payload;
+        if (rawPayload != null && typeof rawPayload === "object" && !Array.isArray(rawPayload)) {
+            this.handleAgentMessage(AgentMessageFactory.fromJson(rawPayload), { attachment: event.message.attachment });
+        }
+    }
+}
+export class ChatThreadSession extends ChangeEmitter {
+    constructor({ client, threadPath }) {
+        super();
+        this._messages = [];
+        this.pendingInputsById = new Map();
+        this.openState = false;
+        this.loadStateValue = ChatThreadSessionLoadState.idle();
+        this.client = client;
+        this.threadPath = threadPath;
+    }
+    get messages() {
+        return [...this._messages];
+    }
+    get pendingInputs() {
+        return [...this.pendingInputsById.values()];
+    }
+    get isOpen() {
+        return this.openState;
+    }
+    get loadState() {
+        return this.loadStateValue;
+    }
+    get isLoading() {
+        return this.loadStateValue.isLoading;
+    }
+    get lastCompletedTurnId() {
+        return this.lastCompletedTurnIdValue;
+    }
+    async open({ load = true, sinceTurn } = {}) {
+        if (this.openState) {
+            if (load) {
+                const openThread = new OpenThread({ threadId: this.threadPath, load: true, sinceTurn });
+                this.setLoadState(this.loadingStateForOpen(openThread, sinceTurn));
+                try {
+                    await this.client.sendAgentMessage(openThread, { ignoreOffline: true });
+                    await this.requestModels({ ignoreOffline: true });
+                }
+                catch (error) {
+                    this.setLoadState(this.failedLoadState(error));
+                    throw error;
+                }
+            }
+            return;
+        }
+        this.openState = true;
+        const openThread = new OpenThread({ threadId: this.threadPath, load, sinceTurn: load ? sinceTurn : undefined });
+        if (load) {
+            this.setLoadState(this.loadingStateForOpen(openThread, sinceTurn));
+        }
+        else {
+            this.notifyListeners();
+        }
+        try {
+            await this.client.sendAgentMessage(openThread, { ignoreOffline: true });
+            await this.requestModels({ ignoreOffline: true });
+        }
+        catch (error) {
+            this.setLoadState(this.failedLoadState(error));
+            throw error;
+        }
+    }
+    async close() {
+        if (!this.openState) {
+            return;
+        }
+        this.markClosed();
+        await this.client.sendAgentMessage(new CloseThread({ threadId: this.threadPath }), { ignoreOffline: true });
+    }
+    requestModels({ ignoreOffline = false } = {}) {
+        return this.client.sendAgentMessage(new ModelsRequest({ messageId: uuidv4() }), { ignoreOffline });
+    }
+    changeModel({ provider, model, voice }) {
+        return this.client.sendAgentMessage(new ChangeModel({
+            threadId: this.threadPath,
+            messageId: uuidv4(),
+            provider,
+            model,
+            voice: nonEmptyTrimmed(voice),
+        }));
+    }
+    interruptTurn(turnId) {
+        return this.client.sendAgentMessage(new TurnInterrupt({ threadId: this.threadPath, turnId }));
+    }
+    respondToClientToolCall({ turnId, requestId, response }) {
+        return this.client.sendAgentMessage(new AgentClientToolCallResponse({
+            threadId: this.threadPath,
+            turnId,
+            requestId,
+            response,
+        }));
+    }
+    async sendText({ messageId, text, attachments, steer = false, turnId, provider, model, voice, outputModalities, senderName, clientToolkits, }) {
+        const resolvedMessageId = messageId == null || messageId.trim() === "" ? uuidv4() : messageId.trim();
+        const payload = steer
+            ? new TurnSteer({
+                threadId: this.threadPath,
+                messageId: resolvedMessageId,
+                senderName: nonEmptyTrimmed(senderName),
+                turnId: nonEmptyTrimmed(turnId) ?? resolvedMessageId,
+                content: agentInputContent({ text, attachments }),
+            })
+            : new TurnStart({
+                threadId: this.threadPath,
+                messageId: resolvedMessageId,
+                senderName: nonEmptyTrimmed(senderName),
+                content: agentInputContent({ text, attachments }),
+                provider: nonEmptyTrimmed(provider),
+                model: nonEmptyTrimmed(model),
+                voice: nonEmptyTrimmed(voice),
+                outputModalities: outputModalities != null && outputModalities.length > 0 ? outputModalities : undefined,
+                clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
+            });
+        this.markPending(new PendingAgentInput({
+            messageId: resolvedMessageId,
+            messageType: payload.type,
+            threadPath: this.threadPath,
+            payload,
+            createdAt: new Date(),
+            awaitingAcceptance: true,
+            awaitingApplication: true,
+        }));
+        this.addAgentMessage(new AgentMessageEvent({ message: payload }));
+        try {
+            await this.client.sendAgentMessage(payload);
+            return resolvedMessageId;
+        }
+        catch (error) {
+            this.pendingInputsById.delete(resolvedMessageId);
+            this.notifyListeners();
+            throw error;
+        }
+    }
+    async sendRealtimeAudioChunk({ chunk, format }) {
+        await this.client.sendAgentMessage(new AgentRealtimeAudioChunk({
+            threadId: this.threadPath,
+            messageId: uuidv4(),
+            format,
+        }), { attachment: chunk });
+    }
+    async commitRealtimeAudio({ turnId, provider, model, voice, outputModalities, }) {
+        const messageId = uuidv4();
+        await this.client.sendAgentMessage(new AgentRealtimeAudioCommit({
+            threadId: this.threadPath,
+            messageId,
+            turnId,
+        }));
+        await this.client.sendAgentMessage(new TurnStart({
+            threadId: this.threadPath,
+            messageId: uuidv4(),
+            turnId,
+            provider: nonEmptyTrimmed(provider),
+            model: nonEmptyTrimmed(model),
+            voice: nonEmptyTrimmed(voice),
+            outputModalities: outputModalities != null && outputModalities.length > 0 ? outputModalities : undefined,
+        }));
+        return messageId;
+    }
+    deleteThread(threadPath) {
+        return this.client.sendAgentMessage(new DeleteThread({ threadId: threadPath }));
+    }
+    renameThread(threadPath, name) {
+        return this.client.sendAgentMessage(new RenameThread({ threadId: threadPath, name }));
+    }
+    addAgentMessage(event) {
+        this._messages.push(event);
+        const message = event.message;
+        const type = message.type;
+        this.lastAgentMessageType = type;
+        this.lastAgentMessageAt = new Date();
+        const messageId = message.messageId;
+        const sourceMessageId = sourceMessageIdFor(message);
+        if (type === agentTurnStartType || type === agentTurnSteerType) {
+            const normalizedMessageId = messageId.trim();
+            if (normalizedMessageId !== "") {
+                this.markPending(new PendingAgentInput({
+                    messageId: normalizedMessageId,
+                    messageType: type,
+                    threadPath: this.threadPath,
+                    payload: message,
+                    createdAt: new Date(),
+                    awaitingAcceptance: true,
+                    awaitingApplication: true,
+                }));
+            }
+        }
+        else if (type === agentTurnStartAcceptedType || type === agentTurnSteerAcceptedType) {
+            this.updatePending(sourceMessageId, { awaitingAcceptance: false, awaitingApplication: true });
+        }
+        else if (type === agentTurnStartedType || type === agentTurnSteeredType) {
+            if (sourceMessageId != null) {
+                this.pendingInputsById.delete(sourceMessageId);
+            }
+        }
+        else if (type === agentTurnStartRejectedType || type === agentTurnSteerRejectedType) {
+            if (sourceMessageId != null) {
+                this.pendingInputsById.delete(sourceMessageId);
+            }
+        }
+        else if (type === agentTurnEndedType || type === agentThreadClearedType) {
+            this.pendingInputsById.clear();
+            if (message.type === agentTurnEndedType && "turnId" in message && typeof message.turnId === "string" && message.turnId.trim() !== "") {
+                this.lastCompletedTurnIdValue = message.turnId.trim();
+            }
+        }
+        else if (type === agentThreadLoadedType) {
+            this.setLoadState(new ChatThreadSessionLoadState({
+                phase: ChatThreadSessionLoadPhase.Loaded,
+                startedAt: this.loadStateValue.startedAt,
+                completedAt: this.lastAgentMessageAt,
+                requestMessageId: this.loadStateValue.requestMessageId,
+                sinceTurn: this.loadStateValue.sinceTurn,
+                lastMessageType: type,
+                lastMessageAt: this.lastAgentMessageAt,
+            }), { notify: false });
+        }
+        this.notifyListeners();
+    }
+    markClosed({ notify = true } = {}) {
+        this.openState = false;
+        this.loadStateValue = new ChatThreadSessionLoadState({
+            phase: ChatThreadSessionLoadPhase.Idle,
+            lastMessageType: this.lastAgentMessageType,
+            lastMessageAt: this.lastAgentMessageAt,
+        });
+        if (notify) {
+            this.notifyListeners();
+        }
+    }
+    loadingStateForOpen(request, sinceTurn) {
+        return new ChatThreadSessionLoadState({
+            phase: ChatThreadSessionLoadPhase.Loading,
+            startedAt: new Date(),
+            requestMessageId: request.messageId,
+            sinceTurn,
+            lastMessageType: this.lastAgentMessageType,
+            lastMessageAt: this.lastAgentMessageAt,
+        });
+    }
+    failedLoadState(error) {
+        return new ChatThreadSessionLoadState({
+            phase: ChatThreadSessionLoadPhase.Failed,
+            startedAt: this.loadStateValue.startedAt,
+            completedAt: new Date(),
+            requestMessageId: this.loadStateValue.requestMessageId,
+            sinceTurn: this.loadStateValue.sinceTurn,
+            error: String(error),
+            lastMessageType: this.lastAgentMessageType,
+            lastMessageAt: this.lastAgentMessageAt,
+        });
+    }
+    setLoadState(loadState, { notify = true } = {}) {
+        this.loadStateValue = loadState;
+        if (notify) {
+            this.notifyListeners();
+        }
+    }
+    markPending(pending) {
+        this.pendingInputsById.set(pending.messageId, pending);
+    }
+    updatePending(messageId, { awaitingAcceptance, awaitingApplication, awaitingOnline, }) {
+        const normalized = messageId?.trim();
+        if (normalized == null || normalized === "") {
+            return;
+        }
+        const existing = this.pendingInputsById.get(normalized);
+        if (existing == null) {
+            return;
+        }
+        this.pendingInputsById.set(normalized, existing.copyWith({
+            awaitingAcceptance,
+            awaitingApplication,
+            awaitingOnline,
+        }));
+    }
+}
+function sourceMessageIdFor(message) {
+    const value = "sourceMessageId" in message ? message.sourceMessageId : undefined;
+    return typeof value === "string" ? value : undefined;
+}
+function nonEmptyTrimmed(value) {
+    const normalized = value?.trim();
+    return normalized == null || normalized === "" ? undefined : normalized;
+}