@meshagent/meshagent-agents 0.43.0

package/dist/browser/chat-client.js

@@ -0,0 +1,642 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatThreadSession = exports.MessagingChatClient = exports.BaseChatClient = exports.ChatThreadStartResult = exports.ChatThreadSessionLoadState = exports.ChatThreadSessionLoadPhase = exports.PendingAgentInput = exports.AgentMessageEvent = void 0;
+const meshagent_1 = require("@meshagent/meshagent");
+const uuid_1 = require("uuid");
+const agent_messages_js_1 = require("./agent-messages.js");
+const change_emitter_js_1 = require("./change-emitter.js");
+class AgentMessageEvent {
+    constructor({ message, attachment }) {
+        this.message = message;
+        this.attachment = attachment;
+    }
+    get payload() {
+        return this.message.toJson();
+    }
+}
+exports.AgentMessageEvent = AgentMessageEvent;
+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,
+        });
+    }
+}
+exports.PendingAgentInput = PendingAgentInput;
+var ChatThreadSessionLoadPhase;
+(function (ChatThreadSessionLoadPhase) {
+    ChatThreadSessionLoadPhase["Idle"] = "idle";
+    ChatThreadSessionLoadPhase["Loading"] = "loading";
+    ChatThreadSessionLoadPhase["Loaded"] = "loaded";
+    ChatThreadSessionLoadPhase["Failed"] = "failed";
+})(ChatThreadSessionLoadPhase || (exports.ChatThreadSessionLoadPhase = ChatThreadSessionLoadPhase = {}));
+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;
+    }
+}
+exports.ChatThreadSessionLoadState = ChatThreadSessionLoadState;
+class ChatThreadStartResult {
+    constructor({ session, threadPath, realtimeConnection }) {
+        this.session = session;
+        this.threadPath = threadPath;
+        this.realtimeConnection = realtimeConnection;
+    }
+}
+exports.ChatThreadStartResult = ChatThreadStartResult;
+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));
+                },
+            }),
+        };
+    }
+}
+class BaseChatClient extends change_emitter_js_1.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() === "" ? (0, uuid_1.v4)() : messageId.trim();
+        const resolvedSenderName = this.cleanParticipantName(senderName) ?? this.localParticipantName();
+        const payload = new agent_messages_js_1.StartThread({
+            messageId: resolvedMessageId,
+            content: omitContent ? undefined : (0, agent_messages_js_1.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 meshagent_1.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 === agent_messages_js_1.agentThreadStartedType && response.realtimeConnection != null
+                    ? response.realtimeConnection.toJson()
+                    : undefined,
+            });
+        }
+        finally {
+            this.pendingStartRequests.delete(resolvedMessageId);
+        }
+    }
+    handleAgentMessage(message, { attachment } = {}) {
+        if (message.type === agent_messages_js_1.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 === agent_messages_js_1.agentThreadStartedType || message.type === agent_messages_js_1.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 agent_messages_js_1.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();
+        }
+    }
+}
+exports.BaseChatClient = BaseChatClient;
+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() === "" ? (0, uuid_1.v4)() : waitKey.trim();
+        const completer = new meshagent_1.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: agent_messages_js_1.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 meshagent_1.RoomMessageEvent) || event.message.type !== agent_messages_js_1.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(agent_messages_js_1.AgentMessage.fromJson(rawPayload), { attachment: event.message.attachment });
+        }
+    }
+}
+exports.MessagingChatClient = MessagingChatClient;
+class ChatThreadSession extends change_emitter_js_1.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 agent_messages_js_1.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 agent_messages_js_1.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 agent_messages_js_1.CloseThread({ threadId: this.threadPath }), { ignoreOffline: true });
+    }
+    requestModels({ ignoreOffline = false } = {}) {
+        return this.client.sendAgentMessage(new agent_messages_js_1.ModelsRequest({ messageId: (0, uuid_1.v4)() }), { ignoreOffline });
+    }
+    changeModel({ provider, model, voice }) {
+        return this.client.sendAgentMessage(new agent_messages_js_1.ChangeModel({
+            threadId: this.threadPath,
+            messageId: (0, uuid_1.v4)(),
+            provider,
+            model,
+            voice: nonEmptyTrimmed(voice),
+        }));
+    }
+    interruptTurn(turnId) {
+        return this.client.sendAgentMessage(new agent_messages_js_1.TurnInterrupt({ threadId: this.threadPath, turnId }));
+    }
+    respondToClientToolCall({ turnId, requestId, response }) {
+        return this.client.sendAgentMessage(new agent_messages_js_1.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() === "" ? (0, uuid_1.v4)() : messageId.trim();
+        const payload = steer
+            ? new agent_messages_js_1.TurnSteer({
+                threadId: this.threadPath,
+                messageId: resolvedMessageId,
+                senderName: nonEmptyTrimmed(senderName),
+                turnId: nonEmptyTrimmed(turnId) ?? resolvedMessageId,
+                content: (0, agent_messages_js_1.agentInputContent)({ text, attachments }),
+            })
+            : new agent_messages_js_1.TurnStart({
+                threadId: this.threadPath,
+                messageId: resolvedMessageId,
+                senderName: nonEmptyTrimmed(senderName),
+                content: (0, agent_messages_js_1.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 agent_messages_js_1.AgentRealtimeAudioChunk({
+            threadId: this.threadPath,
+            messageId: (0, uuid_1.v4)(),
+            format,
+        }), { attachment: chunk });
+    }
+    async commitRealtimeAudio({ turnId, provider, model, voice, outputModalities, }) {
+        const messageId = (0, uuid_1.v4)();
+        await this.client.sendAgentMessage(new agent_messages_js_1.AgentRealtimeAudioCommit({
+            threadId: this.threadPath,
+            messageId,
+            turnId,
+        }));
+        await this.client.sendAgentMessage(new agent_messages_js_1.TurnStart({
+            threadId: this.threadPath,
+            messageId: (0, uuid_1.v4)(),
+            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 agent_messages_js_1.DeleteThread({ threadId: threadPath }));
+    }
+    renameThread(threadPath, name) {
+        return this.client.sendAgentMessage(new agent_messages_js_1.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 === agent_messages_js_1.agentTurnStartType || type === agent_messages_js_1.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 === agent_messages_js_1.agentTurnStartAcceptedType || type === agent_messages_js_1.agentTurnSteerAcceptedType) {
+            this.updatePending(sourceMessageId, { awaitingAcceptance: false, awaitingApplication: true });
+        }
+        else if (type === agent_messages_js_1.agentTurnStartedType || type === agent_messages_js_1.agentTurnSteeredType) {
+            if (sourceMessageId != null) {
+                this.pendingInputsById.delete(sourceMessageId);
+            }
+        }
+        else if (type === agent_messages_js_1.agentTurnStartRejectedType || type === agent_messages_js_1.agentTurnSteerRejectedType) {
+            if (sourceMessageId != null) {
+                this.pendingInputsById.delete(sourceMessageId);
+            }
+        }
+        else if (type === agent_messages_js_1.agentTurnEndedType || type === agent_messages_js_1.agentThreadClearedType) {
+            this.pendingInputsById.clear();
+            if (message.type === agent_messages_js_1.agentTurnEndedType && "turnId" in message && typeof message.turnId === "string" && message.turnId.trim() !== "") {
+                this.lastCompletedTurnIdValue = message.turnId.trim();
+            }
+        }
+        else if (type === agent_messages_js_1.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,
+        }));
+    }
+}
+exports.ChatThreadSession = ChatThreadSession;
+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;
+}