@meshagent/meshagent-agents 0.43.3 → 0.44.1

package/dist/browser/chat-client.js

@@ -6,12 +6,13 @@ 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 }) {
+    constructor({ message, createdAt, attachment }) {
         this.message = message;
+        this.createdAt = createdAt ?? dateOrNull(message.createdAt) ?? new Date();
         this.attachment = attachment;
     }
     get payload() {
-        return this.message.toJson();
+        return { ...this.message.toJson(), created_at: this.createdAt.toISOString() };
     }
 }
 exports.AgentMessageEvent = AgentMessageEvent;
@@ -203,7 +204,7 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             this.notifyListeners();
         });
     }
-    async startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, omitContent = false, }) {
+    async startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, toolChoice, 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({
@@ -218,6 +219,7 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             realtimeProtocol: nonEmptyTrimmed(realtimeProtocol),
             senderName: resolvedSenderName,
             clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
+            toolChoice: toolChoice?.toJson(),
         });
         const completer = new meshagent_1.Completer();
         this.pendingStartRequests.set(resolvedMessageId, completer);
@@ -232,7 +234,10 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             }
             const session = this.openThread(threadPath, { load: false, drainPendingEvents: false });
             if (!omitContent) {
-                session.addAgentMessage(new AgentMessageEvent({ message: payload }));
+                session.addAgentMessage(new AgentMessageEvent({
+                    message: this.resolvedStartThreadMessage({ payload, threadPath }),
+                    createdAt: dateOrNull(payload.createdAt) ?? undefined,
+                }));
             }
             this.drainPendingSessionEvents(threadPath, session);
             return new ChatThreadStartResult({
@@ -247,6 +252,23 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             this.pendingStartRequests.delete(resolvedMessageId);
         }
     }
+    resolvedStartThreadMessage({ payload, threadPath, }) {
+        return new agent_messages_js_1.TurnStart({
+            threadId: threadPath,
+            messageId: payload.messageId,
+            senderName: payload.senderName,
+            content: payload.content,
+            backend: payload.backend,
+            provider: payload.provider,
+            model: payload.model,
+            voice: payload.voice,
+            outputModalities: payload.outputModalities,
+            instructions: payload.instructions,
+            mcp: payload.mcp,
+            clientToolkits: payload.clientToolkits,
+            toolkits: payload.toolkits,
+        });
+    }
     drainPendingSessionEvents(threadPath, session) {
         const pendingEvents = this.pendingSessionEventsByPath.get(threadPath);
         if (pendingEvents == null) {
@@ -257,16 +279,11 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             session.addAgentMessage(event);
         }
     }
-    handleAgentMessage(message, { attachment } = {}) {
+    handleAgentMessage(message, { createdAt, 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 }));
+        this.eventQueue.add(new AgentMessageEvent({ message, createdAt, attachment }));
         const sourceMessageId = sourceMessageIdFor(message);
         if ((message.type === agent_messages_js_1.agentThreadStartedType || message.type === agent_messages_js_1.agentThreadStartRejectedType) &&
             sourceMessageId != null &&
@@ -281,7 +298,7 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             this.notifyListeners();
             return;
         }
-        const event = new AgentMessageEvent({ message, attachment });
+        const event = new AgentMessageEvent({ message, createdAt, attachment });
         const session = this.sessionsByPath.get(threadPath);
         if (session != null) {
             session.addAgentMessage(event);
@@ -302,11 +319,6 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
         });
         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) {
@@ -325,10 +337,50 @@ class MessagingChatClient extends BaseChatClient {
         super();
         this.pendingParticipantWaits = new Map();
         this.started = false;
+        this.hasConnected = false;
+        this.waitingForParticipant = false;
+        this.messagingListenersAttached = false;
         this.onMessagingChanged = () => {
             const participant = this.agentParticipant();
+            const participantId = participant?.id;
+            if (participantId !== this.agentParticipantId) {
+                if (participantId == null) {
+                    if (this.agentParticipantId != null) {
+                        this.waitingForParticipant = true;
+                        this.emitConnectionStatus({
+                            status: "disconnected",
+                            message: "Agent messaging disconnected",
+                            reason: "participant_disconnected",
+                        });
+                        this.emitConnectionStatus({
+                            status: "reconnecting",
+                            message: "Waiting for agent messaging",
+                            reason: "participant_disconnected",
+                        });
+                    }
+                    else if (this.started && this.waitingForParticipant) {
+                        this.emitConnectionStatus({
+                            status: "reconnecting",
+                            message: "Waiting for agent messaging",
+                            reason: "participant_offline",
+                        });
+                    }
+                }
+                else {
+                    const status = this.hasConnected ? "reconnected" : "connected";
+                    this.hasConnected = true;
+                    this.waitingForParticipant = false;
+                    this.emitConnectionStatus({
+                        status,
+                        message: status === "reconnected" ? "Agent messaging reconnected" : "Agent messaging connected",
+                    });
+                    if (status === "reconnected") {
+                        void this.reopenOpenSessions();
+                    }
+                }
+                this.agentParticipantId = participantId;
+            }
             if (participant != null) {
-                this.emitConnectionStatus({ status: "connected", message: "Agent messaging connected" });
                 for (const wait of this.pendingParticipantWaits.values()) {
                     if (!wait.completed) {
                         wait.complete(participant);
@@ -337,6 +389,12 @@ class MessagingChatClient extends BaseChatClient {
             }
             this.notifyListeners();
         };
+        this.onMessagingParticipantChanged = () => {
+            this.onMessagingChanged();
+        };
+        this.onMessagingParticipantRemoved = () => {
+            this.onMessagingChanged();
+        };
         this.onMessagingMessage = (event) => {
             this.onMessagingChanged();
             const roomMessage = agentRoomMessageFromEvent(event);
@@ -344,14 +402,19 @@ class MessagingChatClient extends BaseChatClient {
                 return;
             }
             const participant = this.agentParticipant();
-            if (participant == null || roomMessage.fromParticipantId !== participant.id) {
+            const fromSelectedAgent = participant != null && roomMessage.fromParticipantId === participant.id;
+            const fromParticipantlessThreadList = roomMessage.fromParticipantId == null && isThreadListMessage(roomMessage.message);
+            if (!fromSelectedAgent && !fromParticipantlessThreadList) {
                 return;
             }
-            this.handleAgentMessage(agent_messages_js_1.AgentMessage.fromJson(roomMessage.message), { attachment: roomMessage.attachment });
+            this.handleAgentMessage(agent_messages_js_1.AgentMessage.fromJson(roomMessage.message), {
+                createdAt: dateOrNull(roomMessage.message.created_at),
+                attachment: roomMessage.attachment,
+            });
         };
         this.room = room;
         this.agentName = agentName;
-        this.room.messaging.addListener("message", this.onMessagingMessage);
+        this.attachMessagingListeners();
     }
     localParticipantName() {
         const name = this.room.localParticipant?.getAttribute("name");
@@ -362,12 +425,18 @@ class MessagingChatClient extends BaseChatClient {
             return;
         }
         this.started = true;
+        this.attachMessagingListeners();
         this.room.messaging.start();
-        this.room.messaging.enable();
+        this.startRoomStatusListener();
+        await this.room.messaging.enable();
+        this.waitingForParticipant = true;
+        this.onMessagingChanged();
     }
     async stop() {
         this.started = false;
-        this.room.messaging.removeListener("message", this.onMessagingMessage);
+        this.roomAbortController?.abort();
+        this.roomAbortController = undefined;
+        this.detachMessagingListeners();
         for (const wait of this.pendingParticipantWaits.values()) {
             if (!wait.completed) {
                 wait.completeError(new Error("Chat client stopped while waiting for an agent participant."));
@@ -375,12 +444,35 @@ class MessagingChatClient extends BaseChatClient {
         }
         this.pendingParticipantWaits.clear();
     }
+    attachMessagingListeners() {
+        if (this.messagingListenersAttached) {
+            return;
+        }
+        this.room.messaging.addListener("message", this.onMessagingMessage);
+        this.room.messaging.addListener("participant_added", this.onMessagingParticipantChanged);
+        this.room.messaging.addListener("participant_removed", this.onMessagingParticipantRemoved);
+        this.room.messaging.addListener("messaging_enabled", this.onMessagingParticipantChanged);
+        this.messagingListenersAttached = true;
+    }
+    detachMessagingListeners() {
+        if (!this.messagingListenersAttached) {
+            return;
+        }
+        this.room.messaging.removeListener("messaging_enabled", this.onMessagingParticipantChanged);
+        this.room.messaging.removeListener("participant_removed", this.onMessagingParticipantRemoved);
+        this.room.messaging.removeListener("participant_added", this.onMessagingParticipantChanged);
+        this.room.messaging.removeListener("message", this.onMessagingMessage);
+        this.messagingListenersAttached = false;
+    }
     agentParticipant() {
         const normalizedAgentName = this.agentName?.trim();
         for (const participant of this.room.messaging.remoteParticipants) {
             if (normalizedAgentName != null && normalizedAgentName !== "" && participant.getAttribute("name") !== normalizedAgentName) {
                 continue;
             }
+            if (normalizedAgentName != null && normalizedAgentName !== "") {
+                return participant;
+            }
             if (participant.getAttribute("supports_agent_messages") === true) {
                 return participant;
             }
@@ -405,7 +497,13 @@ class MessagingChatClient extends BaseChatClient {
     }
     async sendAgentMessage(message, { attachment, ignoreOffline = false } = {}) {
         await this.start();
-        const participant = this.agentParticipant() ?? await this.waitForAgentParticipant({ waitKey: message.messageId });
+        let participant = this.agentParticipant();
+        if (participant == null) {
+            if (ignoreOffline) {
+                return;
+            }
+            participant = await this.waitForAgentParticipant({ waitKey: message.messageId });
+        }
         await this.room.messaging.sendMessage({
             to: participant,
             type: agent_messages_js_1.agentRoomMessageType,
@@ -414,8 +512,51 @@ class MessagingChatClient extends BaseChatClient {
             ignoreOffline,
         });
     }
+    startRoomStatusListener() {
+        if (this.roomAbortController != null) {
+            return;
+        }
+        const controller = new AbortController();
+        this.roomAbortController = controller;
+        void (async () => {
+            for await (const event of this.room.listen({ abortSignal: controller.signal })) {
+                if (controller.signal.aborted || event.name !== "room.status") {
+                    continue;
+                }
+                const status = String(event.status ?? "").trim().toLowerCase();
+                const message = String(event.message ?? "").trim();
+                if (status === "connected" || status === "ready" || status === "reconnected") {
+                    this.waitingForParticipant = true;
+                    this.onMessagingChanged();
+                }
+                else if (status === "disconnected" || status === "reconnecting" || status === "connecting") {
+                    this.agentParticipantId = undefined;
+                    this.waitingForParticipant = true;
+                    this.emitConnectionStatus({
+                        status: status === "disconnected" ? "disconnected" : "reconnecting",
+                        message: message !== "" ? message : status === "disconnected" ? "Agent messaging disconnected" : "Waiting for agent messaging",
+                        reason: message !== "" ? message : undefined,
+                    });
+                }
+            }
+        })().catch(() => undefined);
+    }
+    async reopenOpenSessions() {
+        for (const session of this.sessions) {
+            if (!session.isOpen) {
+                continue;
+            }
+            await session.open({ load: true, sinceTurn: session.lastCompletedTurnId });
+        }
+    }
 }
 exports.MessagingChatClient = MessagingChatClient;
+function isThreadListMessage(message) {
+    return message.type === agent_messages_js_1.agentThreadListedType
+        || message.type === agent_messages_js_1.agentThreadCreatedType
+        || message.type === agent_messages_js_1.agentThreadUpdatedType
+        || message.type === agent_messages_js_1.agentThreadDeletedType;
+}
 class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
     constructor({ client, threadPath }) {
         super();
@@ -463,6 +604,9 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
     async open({ load = true, sinceTurn } = {}) {
         if (this.openState) {
             if (load) {
+                if (sinceTurn == null) {
+                    this.resetReplayState();
+                }
                 const openThread = new agent_messages_js_1.OpenThread({ threadId: this.threadPath, load: true, sinceTurn });
                 this.setLoadState(this.loadingStateForOpen(openThread, sinceTurn));
                 try {
@@ -493,6 +637,17 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             throw error;
         }
     }
+    resetReplayState() {
+        this._messages.length = 0;
+        this.messageIndexes.clear();
+        this.localAgentMessageIds.clear();
+        this.pendingLocalInputMessageIds.clear();
+        this.mergedDeltaMessageIds.clear();
+        this.pendingInputsById.clear();
+        this.lastCompletedTurnIdValue = undefined;
+        this.lastAgentMessageType = undefined;
+        this.lastAgentMessageAt = undefined;
+    }
     async close() {
         if (!this.openState) {
             return;
@@ -524,7 +679,7 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             response,
         }));
     }
-    async sendText({ messageId, text, attachments, steer = false, turnId, backend, provider, model, voice, outputModalities, senderName, clientToolkits, }) {
+    async sendText({ messageId, text, attachments, steer = false, turnId, backend, provider, model, voice, outputModalities, senderName, clientToolkits, toolChoice, }) {
         const resolvedMessageId = messageId == null || messageId.trim() === "" ? (0, uuid_1.v4)() : messageId.trim();
         const currentModel = this.currentModelValue;
         const resolvedBackend = nonEmptyTrimmed(backend) ?? currentModel?.backend;
@@ -553,6 +708,7 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
                 voice: resolvedVoice,
                 outputModalities: resolvedOutputModalities,
                 clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
+                toolChoice: toolChoice?.toJson(),
             });
         this.localAgentMessageIds.add(resolvedMessageId);
         this.pendingLocalInputMessageIds.add(resolvedMessageId);
@@ -602,9 +758,9 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
         const message = event.message;
         const type = message.type;
         this.lastAgentMessageType = type;
-        this.lastAgentMessageAt = new Date();
+        this.lastAgentMessageAt = event.createdAt;
         this.updateSessionState(message);
-        this.updatePendingInputsForMessage(message);
+        this.updatePendingInputsForMessage(message, event.createdAt);
         this.appendRenderableMessage(event);
         this.notifyListeners();
     }
@@ -670,7 +826,7 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             }), { notify: false });
         }
     }
-    updatePendingInputsForMessage(message) {
+    updatePendingInputsForMessage(message, createdAt) {
         const type = message.type;
         const messageId = message.messageId;
         const sourceMessageId = sourceMessageIdFor(message);
@@ -684,7 +840,7 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
                     messageType: type,
                     threadPath: this.threadPath,
                     payload: message,
-                    createdAt: new Date(),
+                    createdAt,
                     awaitingAcceptance: true,
                     awaitingApplication: true,
                 }));
@@ -723,6 +879,31 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             }
             return;
         }
+        if (message.type === agent_messages_js_1.agentToolCallEndedType) {
+            const itemId = message.error == null ? undefined : normalizedString(message.itemId);
+            if (itemId != null) {
+                this.upsertItemMessage(`tool_call:${itemId}`, event);
+            }
+            else if (message.error != null) {
+                this.appendMessage(event);
+            }
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentToolCallPendingType || message.type === agent_messages_js_1.agentToolCallInProgressType || message.type === agent_messages_js_1.agentToolCallStartedType) {
+            const itemId = normalizedString(message.itemId);
+            if (itemId != null) {
+                this.upsertItemMessage(`tool_call:${itemId}`, event);
+            }
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentSecretRequestedType) {
+            this.appendMessage(event);
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentModelChangedType) {
+            this.appendMessage(event);
+            return;
+        }
         if (message.type === agent_messages_js_1.agentThreadStartType || message.type === agent_messages_js_1.agentTurnStartType || message.type === agent_messages_js_1.agentTurnSteerType) {
             if (agentInputText(message.content).trim() !== "") {
                 this.appendMessage(event);
@@ -738,6 +919,18 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             if (agentInputText(message.content).trim() !== "") {
                 this.appendMessage(event, { beforePendingLocalInputs: true });
             }
+            else {
+                this.appendMessage(event);
+            }
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentTurnStartedType ||
+            message.type === agent_messages_js_1.agentTurnSteeredType ||
+            message.type === agent_messages_js_1.agentTurnStartRejectedType ||
+            message.type === agent_messages_js_1.agentTurnSteerRejectedType ||
+            message.type === agent_messages_js_1.agentTurnInterruptAcceptedType ||
+            message.type === agent_messages_js_1.agentTurnInterruptedType) {
+            this.appendMessage(event);
             return;
         }
         if (isMergeableDelta(message)) {
@@ -751,6 +944,10 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             }
             return;
         }
+        if (message.type === agent_messages_js_1.agentUsageUpdatedType) {
+            this.appendMessage(event);
+            return;
+        }
         if (message instanceof agent_messages_js_1.AgentClientToolCallRequested) {
             this.appendMessage(event);
         }
@@ -803,7 +1000,7 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
         const existing = this._messages[existingIndex].message;
         const merged = mergeDeltaMessage(existing, message);
         if (merged != null) {
-            this._messages[existingIndex] = new AgentMessageEvent({ message: merged, attachment: event.attachment });
+            this._messages[existingIndex] = new AgentMessageEvent({ message: merged, createdAt: event.createdAt, attachment: event.attachment });
         }
     }
     indexMessagesFrom(start) {
@@ -968,6 +1165,16 @@ function normalizedString(value) {
     const normalized = value?.trim();
     return normalized == null || normalized === "" ? undefined : normalized;
 }
+function dateOrNull(value) {
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value;
+    }
+    if (typeof value !== "string" || value.trim() === "") {
+        return undefined;
+    }
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
 function nonEmptyTrimmed(value) {
     const normalized = value?.trim();
     return normalized == null || normalized === "" ? undefined : normalized;

package/dist/browser/thread-storage.d.ts

@@ -93,6 +93,7 @@ export declare class AgentThreadStorageRepository extends ThreadStorageRepositor
     renameThread(threadPath: string, name: string): Promise<void>;
     private requestList;
     private handleEvent;
+    private reconnectWatch;
     private handleThreadsListed;
     private upsertThread;
     private entryFromAgentThread;

package/dist/browser/thread-storage.js

@@ -313,10 +313,12 @@ class AgentThreadStorageRepository extends ThreadStorageRepository {
                 this.handleEvent(next.value);
             }
         })();
-        await new Promise((resolve) => {
+        const ready = new Promise((resolve) => {
             this.pendingOpen = { resolve };
-            void this.requestList();
         });
+        await this.chatClient.sendAgentMessage(new agent_messages_js_1.WatchThreads(), { ignoreOffline: true });
+        await this.requestList();
+        await ready;
     }
     async close() {
         this.closed = true;
@@ -325,6 +327,7 @@ class AgentThreadStorageRepository extends ThreadStorageRepository {
         this.pendingListMessageId = undefined;
         this.pendingOpen?.resolve();
         this.pendingOpen = undefined;
+        await this.chatClient.sendAgentMessage(new agent_messages_js_1.UnwatchThreads(), { ignoreOffline: true }).catch(() => undefined);
     }
     entries() {
         return [...this.entriesByPath.values()];
@@ -364,6 +367,12 @@ class AgentThreadStorageRepository extends ThreadStorageRepository {
     }
     handleEvent(event) {
         const message = event.message;
+        if (message.type === "meshagent.agent.connection.status") {
+            if (String(message.status ?? "").trim().toLowerCase() === "reconnected") {
+                void this.reconnectWatch();
+            }
+            return;
+        }
         if (message.type === "meshagent.agent.thread.listed") {
             this.handleThreadsListed(message);
             return;
@@ -383,6 +392,13 @@ class AgentThreadStorageRepository extends ThreadStorageRepository {
             }
         }
     }
+    async reconnectWatch() {
+        if (this.closed) {
+            return;
+        }
+        await this.chatClient.sendAgentMessage(new agent_messages_js_1.WatchThreads(), { ignoreOffline: true });
+        await this.requestList();
+    }
     handleThreadsListed(message) {
         const nextEntries = new Map();
         for (const thread of message.threads) {

package/dist/esm/agent-messages.d.ts

@@ -19,6 +19,8 @@ export declare const agentParticipantDisconnectType = "meshagent.agent.participa
 export declare const agentThreadDeleteType = "meshagent.agent.thread.delete";
 export declare const agentThreadRenameType = "meshagent.agent.thread.rename";
 export declare const agentThreadListType = "meshagent.agent.thread.list";
+export declare const agentThreadWatchType = "meshagent.agent.thread.watch";
+export declare const agentThreadUnwatchType = "meshagent.agent.thread.unwatch";
 export declare const agentThreadListedType = "meshagent.agent.thread.listed";
 export declare const agentThreadCreatedType = "meshagent.agent.thread.created";
 export declare const agentThreadUpdatedType = "meshagent.agent.thread.updated";
@@ -239,7 +241,8 @@ export declare abstract class AgentMessage {
     readonly type: string;
     readonly messageId: string;
     readonly senderName?: string;
-    protected constructor({ type, messageId, message_id, senderName, sender_name }: JsonMap);
+    readonly createdAt: string;
+    protected constructor({ type, messageId, message_id, senderName, sender_name, createdAt, created_at }: JsonMap);
     toJson(): JsonMap;
     static fromJson(json: JsonMap): AgentMessage;
 }
@@ -272,6 +275,8 @@ export declare const ParticipantDisconnect: MessageCtor;
 export declare const DeleteThread: MessageCtor;
 export declare const RenameThread: MessageCtor;
 export declare const ListThreads: MessageCtor;
+export declare const WatchThreads: MessageCtor;
+export declare const UnwatchThreads: MessageCtor;
 export declare const ThreadsListed: MessageCtor;
 export declare const ThreadCreated: MessageCtor;
 export declare const ThreadUpdated: MessageCtor;

package/dist/esm/agent-messages.js

@@ -18,6 +18,8 @@ export const agentParticipantDisconnectType = "meshagent.agent.participant.disco
 export const agentThreadDeleteType = "meshagent.agent.thread.delete";
 export const agentThreadRenameType = "meshagent.agent.thread.rename";
 export const agentThreadListType = "meshagent.agent.thread.list";
+export const agentThreadWatchType = "meshagent.agent.thread.watch";
+export const agentThreadUnwatchType = "meshagent.agent.thread.unwatch";
 export const agentThreadListedType = "meshagent.agent.thread.listed";
 export const agentThreadCreatedType = "meshagent.agent.thread.created";
 export const agentThreadUpdatedType = "meshagent.agent.thread.updated";
@@ -631,16 +633,18 @@ function omitUndefined(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
 export class AgentMessage {
-    constructor({ type, messageId, message_id, senderName, sender_name }) {
+    constructor({ type, messageId, message_id, senderName, sender_name, createdAt, created_at }) {
         this.type = String(type);
         const resolvedMessageId = stringOrNull(messageId ?? message_id)?.trim();
         this.messageId = resolvedMessageId == null || resolvedMessageId.length === 0 ? uuidv4() : resolvedMessageId;
         this.senderName = stringOrNull(senderName ?? sender_name);
+        this.createdAt = stringOrNull(createdAt ?? created_at) ?? new Date().toISOString();
     }
     toJson() {
         return {
             type: this.type,
             message_id: this.messageId,
+            created_at: this.createdAt,
             ...(this.senderName != null ? { sender_name: this.senderName } : {}),
         };
     }
@@ -704,6 +708,7 @@ function makeMessageClass({ type, base = "message", fields = [], }) {
             const params = {
                 messageId: stringOrNull(json.message_id),
                 senderName: stringOrNull(json.sender_name),
+                createdAt: stringOrNull(json.created_at),
             };
             if (base !== "message") {
                 params.threadId = requiredString(json, "thread_id");
@@ -914,6 +919,8 @@ export const ParticipantDisconnect = makeMessageClass({ type: agentParticipantDi
 export const DeleteThread = makeMessageClass({ type: agentThreadDeleteType, base: "thread" });
 export const RenameThread = makeMessageClass({ type: agentThreadRenameType, base: "thread", fields: [s("name", "name", true)] });
 export const ListThreads = makeMessageClass({ type: agentThreadListType, fields: [{ prop: "limit", json: "limit", from: (value) => intOrNull(value) ?? 200, default: () => 200, always: true }, { prop: "offset", json: "offset", from: (value) => intOrNull(value) ?? 0, default: () => 0, always: true }] });
+export const WatchThreads = makeMessageClass({ type: agentThreadWatchType });
+export const UnwatchThreads = makeMessageClass({ type: agentThreadUnwatchType });
 export const ThreadsListed = makeMessageClass({ type: agentThreadListedType, fields: [s("sourceMessageId", "source_message_id", true), objList("threads", "threads", AgentThreadListEntry.fromJson, true), i("total"), i("offset"), i("limit")] });
 export const ThreadCreated = makeMessageClass({ type: agentThreadCreatedType, fields: [obj("thread", "thread", AgentThreadListEntry.fromJson, true)] });
 export const ThreadUpdated = makeMessageClass({ type: agentThreadUpdatedType, fields: [obj("thread", "thread", AgentThreadListEntry.fromJson, true)] });