@meshagent/meshagent-agents 0.43.3 → 0.44.1

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

@@ -1,13 +1,15 @@
 import { RemoteParticipant } from "@meshagent/meshagent";
 import type { RoomClient, Content } from "@meshagent/meshagent";
-import { AgentMessage, AgentModelChanged, AgentThreadStatus, ModelsResponse, AgentConnectionStatus } from "./agent-messages.js";
+import { AgentMessage, AgentModelChanged, AgentThreadStatus, ModelsResponse, ToolChoice, 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 createdAt: Date;
     readonly attachment?: Uint8Array;
-    constructor({ message, attachment }: {
+    constructor({ message, createdAt, attachment }: {
         message: AgentMessage;
+        createdAt?: Date;
         attachment?: Uint8Array;
     });
     get payload(): AgentPayload;
@@ -96,7 +98,7 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
         drainPendingEvents?: boolean;
     }): ChatThreadSession;
     private openSession;
-    startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, omitContent, }: {
+    startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, toolChoice, omitContent, }: {
         messageId?: string;
         message: string;
         attachments: string[];
@@ -109,14 +111,17 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
         realtimeProtocol?: string;
         senderName?: string;
         clientToolkits?: ClientToolkitDescription[];
+        toolChoice?: ToolChoice;
         omitContent?: boolean;
     }): Promise<ChatThreadStartResult>;
+    private resolvedStartThreadMessage;
     abstract sendAgentMessage(message: AgentMessage, options?: {
         attachment?: Uint8Array;
         ignoreOffline?: boolean;
     }): Promise<void>;
     private drainPendingSessionEvents;
-    handleAgentMessage(message: AgentMessage, { attachment }?: {
+    handleAgentMessage(message: AgentMessage, { createdAt, attachment }?: {
+        createdAt?: Date;
         attachment?: Uint8Array;
     }): void;
     emitConnectionStatus({ status, message, reason, retryDelay, }: {
@@ -132,6 +137,11 @@ export declare class MessagingChatClient extends BaseChatClient {
     readonly agentName?: string;
     private readonly pendingParticipantWaits;
     private started;
+    private agentParticipantId?;
+    private hasConnected;
+    private waitingForParticipant;
+    private roomAbortController?;
+    private messagingListenersAttached;
     constructor({ room, agentName }: {
         room: RoomClient;
         agentName?: string;
@@ -139,6 +149,8 @@ export declare class MessagingChatClient extends BaseChatClient {
     localParticipantName(): string | undefined;
     start(): Promise<void>;
     stop(): Promise<void>;
+    private attachMessagingListeners;
+    private detachMessagingListeners;
     agentParticipant(): RemoteParticipant | null;
     waitForAgentParticipant({ waitKey }?: {
         waitKey?: string;
@@ -148,6 +160,10 @@ export declare class MessagingChatClient extends BaseChatClient {
         ignoreOffline?: boolean;
     }): Promise<void>;
     private readonly onMessagingChanged;
+    private readonly onMessagingParticipantChanged;
+    private readonly onMessagingParticipantRemoved;
+    private startRoomStatusListener;
+    private reopenOpenSessions;
     private readonly onMessagingMessage;
 }
 export declare class ChatThreadSession extends ChangeEmitter {
@@ -186,6 +202,7 @@ export declare class ChatThreadSession extends ChangeEmitter {
         load?: boolean;
         sinceTurn?: string;
     }): Promise<void>;
+    private resetReplayState;
     close(): Promise<void>;
     requestModels({ ignoreOffline }?: {
         ignoreOffline?: boolean;
@@ -202,7 +219,7 @@ export declare class ChatThreadSession extends ChangeEmitter {
         requestId: string;
         response: Content;
     }): Promise<void>;
-    sendText({ messageId, text, attachments, steer, turnId, backend, provider, model, voice, outputModalities, senderName, clientToolkits, }: {
+    sendText({ messageId, text, attachments, steer, turnId, backend, provider, model, voice, outputModalities, senderName, clientToolkits, toolChoice, }: {
         messageId?: string;
         text: string;
         attachments: string[];
@@ -215,6 +232,7 @@ export declare class ChatThreadSession extends ChangeEmitter {
         outputModalities?: string[];
         senderName?: string;
         clientToolkits?: ClientToolkitDescription[];
+        toolChoice?: ToolChoice;
     }): Promise<string>;
     sendRealtimeAudioChunk({ chunk, format }: {
         chunk: Uint8Array;

package/dist/esm/chat-client.js

@@ -1,14 +1,15 @@
 import { Completer, } from "@meshagent/meshagent";
 import { v4 as uuidv4 } from "uuid";
-import { AgentMessage as AgentMessageFactory, AgentAudioGenerationDelta, AgentAudioTranscriptionDelta, AgentRealtimeAudioChunk, AgentRealtimeAudioCommit, AgentFileContentDelta, AgentModelChanged, AgentReasoningContentDelta, AgentTextContentDelta, AgentThreadStatus, AgentToolCallArgumentsDelta, AgentToolCallLogDelta, ChangeModel, CloseThread, DeleteThread, ModelsResponse, ModelsRequest, OpenThread, RenameThread, StartThread, AgentConnectionStatus, TurnInterrupt, TurnStart, TurnSteer, AgentClientToolCallRequested, AgentClientToolCallResponse, agentInputContent, agentAudioGenerationDeltaType, agentAudioTranscriptionDeltaType, agentFileContentDeltaType, agentImageGenerationCompletedType, agentImageGenerationPartialType, agentModelChangedType, agentModelsResponseType, agentReasoningContentDeltaType, agentRoomMessageType, agentTextContentDeltaType, agentThreadClearedType, agentThreadLoadedType, agentConnectionStatusType, agentThreadStatusType, agentThreadStartType, agentThreadStartRejectedType, agentThreadStartedType, agentToolCallArgumentsDeltaType, agentToolCallLogDeltaType, agentTurnEndedType, agentTurnStartAcceptedType, agentTurnStartRejectedType, agentTurnStartType, agentTurnStartedType, agentTurnSteerAcceptedType, agentTurnSteerRejectedType, agentTurnSteerType, agentTurnSteeredType, } from "./agent-messages.js";
+import { AgentMessage as AgentMessageFactory, AgentAudioGenerationDelta, AgentAudioTranscriptionDelta, AgentRealtimeAudioChunk, AgentRealtimeAudioCommit, AgentFileContentDelta, AgentModelChanged, AgentReasoningContentDelta, AgentTextContentDelta, AgentThreadStatus, AgentToolCallArgumentsDelta, AgentToolCallLogDelta, ChangeModel, CloseThread, DeleteThread, ModelsResponse, ModelsRequest, OpenThread, RenameThread, StartThread, AgentConnectionStatus, TurnInterrupt, TurnStart, TurnSteer, AgentClientToolCallRequested, AgentClientToolCallResponse, agentInputContent, agentAudioGenerationDeltaType, agentAudioTranscriptionDeltaType, agentFileContentDeltaType, agentImageGenerationCompletedType, agentImageGenerationPartialType, agentModelChangedType, agentModelsResponseType, agentReasoningContentDeltaType, agentRoomMessageType, agentTextContentDeltaType, agentThreadClearedType, agentThreadCreatedType, agentThreadDeletedType, agentThreadLoadedType, agentThreadListedType, agentThreadUpdatedType, agentConnectionStatusType, agentThreadStatusType, agentThreadStartType, agentThreadStartRejectedType, agentThreadStartedType, agentToolCallArgumentsDeltaType, agentToolCallLogDeltaType, agentToolCallEndedType, agentToolCallInProgressType, agentToolCallPendingType, agentToolCallStartedType, agentSecretRequestedType, agentTurnEndedType, agentTurnInterruptAcceptedType, agentTurnInterruptedType, agentTurnStartAcceptedType, agentTurnStartRejectedType, agentTurnStartType, agentTurnStartedType, agentTurnSteerAcceptedType, agentTurnSteerRejectedType, agentTurnSteerType, agentTurnSteeredType, agentUsageUpdatedType, } from "./agent-messages.js";
 import { ChangeEmitter } from "./change-emitter.js";
 export 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() };
     }
 }
 function agentRoomMessageFromEvent(event) {
@@ -196,7 +197,7 @@ export class BaseChatClient extends 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() === "" ? uuidv4() : messageId.trim();
         const resolvedSenderName = this.cleanParticipantName(senderName) ?? this.localParticipantName();
         const payload = new StartThread({
@@ -211,6 +212,7 @@ export class BaseChatClient extends ChangeEmitter {
             realtimeProtocol: nonEmptyTrimmed(realtimeProtocol),
             senderName: resolvedSenderName,
             clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
+            toolChoice: toolChoice?.toJson(),
         });
         const completer = new Completer();
         this.pendingStartRequests.set(resolvedMessageId, completer);
@@ -225,7 +227,10 @@ export class BaseChatClient extends 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({
@@ -240,6 +245,23 @@ export class BaseChatClient extends ChangeEmitter {
             this.pendingStartRequests.delete(resolvedMessageId);
         }
     }
+    resolvedStartThreadMessage({ payload, threadPath, }) {
+        return new 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) {
@@ -250,16 +272,11 @@ export class BaseChatClient extends ChangeEmitter {
             session.addAgentMessage(event);
         }
     }
-    handleAgentMessage(message, { attachment } = {}) {
+    handleAgentMessage(message, { createdAt, 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 }));
+        this.eventQueue.add(new AgentMessageEvent({ message, createdAt, attachment }));
         const sourceMessageId = sourceMessageIdFor(message);
         if ((message.type === agentThreadStartedType || message.type === agentThreadStartRejectedType) &&
             sourceMessageId != null &&
@@ -274,7 +291,7 @@ export class BaseChatClient extends 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);
@@ -295,11 +312,6 @@ export class BaseChatClient extends 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) {
@@ -317,10 +329,50 @@ export 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);
@@ -329,6 +381,12 @@ export class MessagingChatClient extends BaseChatClient {
             }
             this.notifyListeners();
         };
+        this.onMessagingParticipantChanged = () => {
+            this.onMessagingChanged();
+        };
+        this.onMessagingParticipantRemoved = () => {
+            this.onMessagingChanged();
+        };
         this.onMessagingMessage = (event) => {
             this.onMessagingChanged();
             const roomMessage = agentRoomMessageFromEvent(event);
@@ -336,14 +394,19 @@ export 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(AgentMessageFactory.fromJson(roomMessage.message), { attachment: roomMessage.attachment });
+            this.handleAgentMessage(AgentMessageFactory.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");
@@ -354,12 +417,18 @@ export 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."));
@@ -367,12 +436,35 @@ export 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;
             }
@@ -397,7 +489,13 @@ export 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: agentRoomMessageType,
@@ -406,6 +504,49 @@ export 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 });
+        }
+    }
+}
+function isThreadListMessage(message) {
+    return message.type === agentThreadListedType
+        || message.type === agentThreadCreatedType
+        || message.type === agentThreadUpdatedType
+        || message.type === agentThreadDeletedType;
 }
 export class ChatThreadSession extends ChangeEmitter {
     constructor({ client, threadPath }) {
@@ -454,6 +595,9 @@ export class ChatThreadSession extends ChangeEmitter {
     async open({ load = true, sinceTurn } = {}) {
         if (this.openState) {
             if (load) {
+                if (sinceTurn == null) {
+                    this.resetReplayState();
+                }
                 const openThread = new OpenThread({ threadId: this.threadPath, load: true, sinceTurn });
                 this.setLoadState(this.loadingStateForOpen(openThread, sinceTurn));
                 try {
@@ -484,6 +628,17 @@ export class ChatThreadSession extends 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;
@@ -515,7 +670,7 @@ export class ChatThreadSession extends 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() === "" ? uuidv4() : messageId.trim();
         const currentModel = this.currentModelValue;
         const resolvedBackend = nonEmptyTrimmed(backend) ?? currentModel?.backend;
@@ -544,6 +699,7 @@ export class ChatThreadSession extends ChangeEmitter {
                 voice: resolvedVoice,
                 outputModalities: resolvedOutputModalities,
                 clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
+                toolChoice: toolChoice?.toJson(),
             });
         this.localAgentMessageIds.add(resolvedMessageId);
         this.pendingLocalInputMessageIds.add(resolvedMessageId);
@@ -593,9 +749,9 @@ export class ChatThreadSession extends 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();
     }
@@ -661,7 +817,7 @@ export class ChatThreadSession extends ChangeEmitter {
             }), { notify: false });
         }
     }
-    updatePendingInputsForMessage(message) {
+    updatePendingInputsForMessage(message, createdAt) {
         const type = message.type;
         const messageId = message.messageId;
         const sourceMessageId = sourceMessageIdFor(message);
@@ -675,7 +831,7 @@ export class ChatThreadSession extends ChangeEmitter {
                     messageType: type,
                     threadPath: this.threadPath,
                     payload: message,
-                    createdAt: new Date(),
+                    createdAt,
                     awaitingAcceptance: true,
                     awaitingApplication: true,
                 }));
@@ -714,6 +870,31 @@ export class ChatThreadSession extends ChangeEmitter {
             }
             return;
         }
+        if (message.type === 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 === agentToolCallPendingType || message.type === agentToolCallInProgressType || message.type === agentToolCallStartedType) {
+            const itemId = normalizedString(message.itemId);
+            if (itemId != null) {
+                this.upsertItemMessage(`tool_call:${itemId}`, event);
+            }
+            return;
+        }
+        if (message.type === agentSecretRequestedType) {
+            this.appendMessage(event);
+            return;
+        }
+        if (message.type === agentModelChangedType) {
+            this.appendMessage(event);
+            return;
+        }
         if (message.type === agentThreadStartType || message.type === agentTurnStartType || message.type === agentTurnSteerType) {
             if (agentInputText(message.content).trim() !== "") {
                 this.appendMessage(event);
@@ -729,6 +910,18 @@ export class ChatThreadSession extends ChangeEmitter {
             if (agentInputText(message.content).trim() !== "") {
                 this.appendMessage(event, { beforePendingLocalInputs: true });
             }
+            else {
+                this.appendMessage(event);
+            }
+            return;
+        }
+        if (message.type === agentTurnStartedType ||
+            message.type === agentTurnSteeredType ||
+            message.type === agentTurnStartRejectedType ||
+            message.type === agentTurnSteerRejectedType ||
+            message.type === agentTurnInterruptAcceptedType ||
+            message.type === agentTurnInterruptedType) {
+            this.appendMessage(event);
             return;
         }
         if (isMergeableDelta(message)) {
@@ -742,6 +935,10 @@ export class ChatThreadSession extends ChangeEmitter {
             }
             return;
         }
+        if (message.type === agentUsageUpdatedType) {
+            this.appendMessage(event);
+            return;
+        }
         if (message instanceof AgentClientToolCallRequested) {
             this.appendMessage(event);
         }
@@ -794,7 +991,7 @@ export class ChatThreadSession extends 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) {
@@ -958,6 +1155,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/esm/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/esm/thread-storage.js

@@ -1,6 +1,6 @@
 import { Field, Schema, Utf8, tableFromArrays, } from "apache-arrow";
 import { ChangeEmitter } from "./change-emitter.js";
-import { DeleteThread, ListThreads, RenameThread, } from "./agent-messages.js";
+import { DeleteThread, ListThreads, RenameThread, UnwatchThreads, WatchThreads, } from "./agent-messages.js";
 export const defaultUntitledThreadName = "New Chat";
 const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 export class ThreadListEntry {
@@ -304,10 +304,12 @@ export 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 WatchThreads(), { ignoreOffline: true });
+        await this.requestList();
+        await ready;
     }
     async close() {
         this.closed = true;
@@ -316,6 +318,7 @@ export class AgentThreadStorageRepository extends ThreadStorageRepository {
         this.pendingListMessageId = undefined;
         this.pendingOpen?.resolve();
         this.pendingOpen = undefined;
+        await this.chatClient.sendAgentMessage(new UnwatchThreads(), { ignoreOffline: true }).catch(() => undefined);
     }
     entries() {
         return [...this.entriesByPath.values()];
@@ -355,6 +358,12 @@ export 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;
@@ -374,6 +383,13 @@ export class AgentThreadStorageRepository extends ThreadStorageRepository {
             }
         }
     }
+    async reconnectWatch() {
+        if (this.closed) {
+            return;
+        }
+        await this.chatClient.sendAgentMessage(new WatchThreads(), { ignoreOffline: true });
+        await this.requestList();
+    }
     handleThreadsListed(message) {
         const nextEntries = new Map();
         for (const thread of message.threads) {

package/dist/node/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;