@meshagent/meshagent-agents 0.47.0 → 0.47.1

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.47.1]
+- Added duplex messaging stream subscriptions and replay-state alignment in the TypeScript chat clients, bringing the NodeJS SDK in line with the new streaming model.
+- Reworked messaging and room client flow control so dispatch ordering, close behavior, and presence updates stay consistent under streaming loads.
+- Expanded stream and presence test coverage for the new messaging behavior.
+
 ## [0.47.0]
 - Improved TypeScript messaging clients so room delivery order and startup/presence behavior stay consistent.
 - Moved managed-agent client routing onto the Rust tunnel path and hardened agent chat-client event handling.

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

@@ -1,4 +1,4 @@
-import { RemoteParticipant } from "@meshagent/meshagent";
+import { MessagingStream, RemoteParticipant } from "@meshagent/meshagent";
 import type { RoomClient, Content } from "@meshagent/meshagent";
 import { AgentMessage, AgentModelChanged, AgentThreadStatus, ModelsResponse, ToolChoice, AgentConnectionStatus, AgentClientToolCallRequested } from "./agent-messages.js";
 import type { AgentPayload, JsonMap, ClientToolkitDescription } from "./agent-messages.js";
@@ -133,7 +133,30 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
     }): void;
     removeThreadSession(threadPath: string): void;
 }
-export declare class MessagingChatClient extends BaseChatClient {
+export declare const messagingChatThreadSubscribeType = "meshagent.chat.thread.subscribe";
+export declare const messagingChatThreadListSubscribeType = "meshagent.chat.thread_list.subscribe";
+export declare class ThreadSubscribe {
+    readonly threadId: string;
+    readonly stream: MessagingStream;
+    constructor({ threadId, stream }: {
+        threadId: string;
+        stream: MessagingStream;
+    });
+    get closed(): boolean;
+    send(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class ThreadListSubscribe {
+    readonly stream: MessagingStream;
+    constructor({ stream }: {
+        stream: MessagingStream;
+    });
+    get closed(): boolean;
+    close(): Promise<void>;
+}
+export declare class BaseMessagingChatClient extends BaseChatClient {
     readonly room: RoomClient;
     readonly agentName?: string;
     private readonly pendingParticipantWaits;
@@ -167,6 +190,17 @@ export declare class MessagingChatClient extends BaseChatClient {
     private reopenOpenSessions;
     private readonly onMessagingMessage;
 }
+export declare class MessagingChatClient extends BaseMessagingChatClient {
+    private readonly threadSubscriptions;
+    private threadListSubscription?;
+    private readonly streamTasks;
+    stop(): Promise<void>;
+    private supportsThreadSubscriptions;
+    private trackStream;
+    sendAgentMessage(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+}
 export declare class ChatThreadSession extends ChangeEmitter {
     private readonly client;
     readonly threadPath: string;

package/dist/browser/chat-client.js

@@ -1,6 +1,6 @@
 "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;
+exports.ChatThreadSession = exports.MessagingChatClient = exports.BaseMessagingChatClient = exports.ThreadListSubscribe = exports.ThreadSubscribe = exports.messagingChatThreadListSubscribeType = exports.messagingChatThreadSubscribeType = 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");
@@ -343,7 +343,41 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
     }
 }
 exports.BaseChatClient = BaseChatClient;
-class MessagingChatClient extends BaseChatClient {
+exports.messagingChatThreadSubscribeType = "meshagent.chat.thread.subscribe";
+exports.messagingChatThreadListSubscribeType = "meshagent.chat.thread_list.subscribe";
+class ThreadSubscribe {
+    constructor({ threadId, stream }) {
+        this.threadId = threadId;
+        this.stream = stream;
+    }
+    get closed() {
+        return this.stream.closed;
+    }
+    async send(message, { attachment } = {}) {
+        await this.stream.sendMessage({
+            type: agent_messages_js_1.agentRoomMessageType,
+            message: message.toJson(),
+            attachment,
+        });
+    }
+    async close() {
+        await this.stream.close();
+    }
+}
+exports.ThreadSubscribe = ThreadSubscribe;
+class ThreadListSubscribe {
+    constructor({ stream }) {
+        this.stream = stream;
+    }
+    get closed() {
+        return this.stream.closed;
+    }
+    async close() {
+        await this.stream.close();
+    }
+}
+exports.ThreadListSubscribe = ThreadListSubscribe;
+class BaseMessagingChatClient extends BaseChatClient {
     constructor({ room, agentName }) {
         super();
         this.pendingParticipantWaits = new Map();
@@ -560,6 +594,123 @@ class MessagingChatClient extends BaseChatClient {
         }
     }
 }
+exports.BaseMessagingChatClient = BaseMessagingChatClient;
+class MessagingChatClient extends BaseMessagingChatClient {
+    constructor() {
+        super(...arguments);
+        this.threadSubscriptions = new Map();
+        this.streamTasks = new Set();
+    }
+    async stop() {
+        const subscriptions = [
+            ...this.threadSubscriptions.values(),
+        ];
+        if (this.threadListSubscription != null) {
+            subscriptions.push(this.threadListSubscription);
+        }
+        this.threadSubscriptions.clear();
+        this.threadListSubscription = undefined;
+        await Promise.all(subscriptions.map(async (subscription) => subscription.close()));
+        await Promise.all(this.streamTasks);
+        await super.stop();
+    }
+    supportsThreadSubscriptions(participant) {
+        return participant.getAttribute("supports_messaging_streams") === true;
+    }
+    trackStream(subscription) {
+        const task = (async () => {
+            try {
+                for await (const event of subscription.stream) {
+                    if (event.kind !== "message" || event.message.type !== agent_messages_js_1.agentRoomMessageType) {
+                        continue;
+                    }
+                    const raw = event.message.message;
+                    if (typeof raw["type"] !== "string") {
+                        continue;
+                    }
+                    this.handleAgentMessage(agent_messages_js_1.AgentMessage.fromJson(raw), {
+                        createdAt: dateOrNull(raw["created_at"]),
+                        attachment: event.message.attachment,
+                    });
+                }
+            }
+            finally {
+                if (subscription instanceof ThreadSubscribe) {
+                    if (this.threadSubscriptions.get(subscription.threadId) === subscription) {
+                        this.threadSubscriptions.delete(subscription.threadId);
+                    }
+                }
+                else if (this.threadListSubscription === subscription) {
+                    this.threadListSubscription = undefined;
+                }
+            }
+        })();
+        this.streamTasks.add(task);
+        void task.finally(() => this.streamTasks.delete(task));
+    }
+    async sendAgentMessage(message, { attachment } = {}) {
+        await this.start();
+        const participant = this.agentParticipant();
+        if (participant == null) {
+            throw new Error("Agent messaging participant is not available.");
+        }
+        if (!this.supportsThreadSubscriptions(participant)) {
+            await super.sendAgentMessage(message, { attachment });
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentThreadOpenType) {
+            const previous = this.threadSubscriptions.get(message.threadId);
+            if (previous != null) {
+                await previous.close();
+            }
+            const stream = await this.room.messaging.stream({
+                to: participant,
+                type: exports.messagingChatThreadSubscribeType,
+                message: message.toJson(),
+                attachment,
+            });
+            const subscription = new ThreadSubscribe({ threadId: message.threadId, stream });
+            this.threadSubscriptions.set(message.threadId, subscription);
+            this.trackStream(subscription);
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentThreadCloseType) {
+            const subscription = this.threadSubscriptions.get(message.threadId);
+            if (subscription != null) {
+                this.threadSubscriptions.delete(message.threadId);
+                await subscription.close();
+                return;
+            }
+        }
+        if (message.type === agent_messages_js_1.agentThreadWatchType) {
+            await this.threadListSubscription?.close();
+            const stream = await this.room.messaging.stream({
+                to: participant,
+                type: exports.messagingChatThreadListSubscribeType,
+                message: message.toJson(),
+                attachment,
+            });
+            const subscription = new ThreadListSubscribe({ stream });
+            this.threadListSubscription = subscription;
+            this.trackStream(subscription);
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentThreadUnwatchType && this.threadListSubscription != null) {
+            const subscription = this.threadListSubscription;
+            this.threadListSubscription = undefined;
+            await subscription.close();
+            return;
+        }
+        if ("threadId" in message && typeof message.threadId === "string") {
+            const subscription = this.threadSubscriptions.get(message.threadId);
+            if (subscription != null) {
+                await subscription.send(message, { attachment });
+                return;
+            }
+        }
+        await super.sendAgentMessage(message, { attachment });
+    }
+}
 exports.MessagingChatClient = MessagingChatClient;
 function isThreadListMessage(message) {
     return message.type === agent_messages_js_1.agentThreadListedType

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

@@ -1,4 +1,4 @@
-import { RemoteParticipant } from "@meshagent/meshagent";
+import { MessagingStream, RemoteParticipant } from "@meshagent/meshagent";
 import type { RoomClient, Content } from "@meshagent/meshagent";
 import { AgentMessage, AgentModelChanged, AgentThreadStatus, ModelsResponse, ToolChoice, AgentConnectionStatus, AgentClientToolCallRequested } from "./agent-messages.js";
 import type { AgentPayload, JsonMap, ClientToolkitDescription } from "./agent-messages.js";
@@ -133,7 +133,30 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
     }): void;
     removeThreadSession(threadPath: string): void;
 }
-export declare class MessagingChatClient extends BaseChatClient {
+export declare const messagingChatThreadSubscribeType = "meshagent.chat.thread.subscribe";
+export declare const messagingChatThreadListSubscribeType = "meshagent.chat.thread_list.subscribe";
+export declare class ThreadSubscribe {
+    readonly threadId: string;
+    readonly stream: MessagingStream;
+    constructor({ threadId, stream }: {
+        threadId: string;
+        stream: MessagingStream;
+    });
+    get closed(): boolean;
+    send(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class ThreadListSubscribe {
+    readonly stream: MessagingStream;
+    constructor({ stream }: {
+        stream: MessagingStream;
+    });
+    get closed(): boolean;
+    close(): Promise<void>;
+}
+export declare class BaseMessagingChatClient extends BaseChatClient {
     readonly room: RoomClient;
     readonly agentName?: string;
     private readonly pendingParticipantWaits;
@@ -167,6 +190,17 @@ export declare class MessagingChatClient extends BaseChatClient {
     private reopenOpenSessions;
     private readonly onMessagingMessage;
 }
+export declare class MessagingChatClient extends BaseMessagingChatClient {
+    private readonly threadSubscriptions;
+    private threadListSubscription?;
+    private readonly streamTasks;
+    stop(): Promise<void>;
+    private supportsThreadSubscriptions;
+    private trackStream;
+    sendAgentMessage(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+}
 export declare class ChatThreadSession extends ChangeEmitter {
     private readonly client;
     readonly threadPath: string;

package/dist/esm/chat-client.js

@@ -1,6 +1,6 @@
 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, 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 { 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, agentThreadCloseType, agentThreadOpenType, agentThreadUnwatchType, agentThreadUpdatedType, agentThreadWatchType, 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, createdAt, attachment }) {
@@ -335,7 +335,39 @@ export class BaseChatClient extends ChangeEmitter {
         }
     }
 }
-export class MessagingChatClient extends BaseChatClient {
+export const messagingChatThreadSubscribeType = "meshagent.chat.thread.subscribe";
+export const messagingChatThreadListSubscribeType = "meshagent.chat.thread_list.subscribe";
+export class ThreadSubscribe {
+    constructor({ threadId, stream }) {
+        this.threadId = threadId;
+        this.stream = stream;
+    }
+    get closed() {
+        return this.stream.closed;
+    }
+    async send(message, { attachment } = {}) {
+        await this.stream.sendMessage({
+            type: agentRoomMessageType,
+            message: message.toJson(),
+            attachment,
+        });
+    }
+    async close() {
+        await this.stream.close();
+    }
+}
+export class ThreadListSubscribe {
+    constructor({ stream }) {
+        this.stream = stream;
+    }
+    get closed() {
+        return this.stream.closed;
+    }
+    async close() {
+        await this.stream.close();
+    }
+}
+export class BaseMessagingChatClient extends BaseChatClient {
     constructor({ room, agentName }) {
         super();
         this.pendingParticipantWaits = new Map();
@@ -552,6 +584,122 @@ export class MessagingChatClient extends BaseChatClient {
         }
     }
 }
+export class MessagingChatClient extends BaseMessagingChatClient {
+    constructor() {
+        super(...arguments);
+        this.threadSubscriptions = new Map();
+        this.streamTasks = new Set();
+    }
+    async stop() {
+        const subscriptions = [
+            ...this.threadSubscriptions.values(),
+        ];
+        if (this.threadListSubscription != null) {
+            subscriptions.push(this.threadListSubscription);
+        }
+        this.threadSubscriptions.clear();
+        this.threadListSubscription = undefined;
+        await Promise.all(subscriptions.map(async (subscription) => subscription.close()));
+        await Promise.all(this.streamTasks);
+        await super.stop();
+    }
+    supportsThreadSubscriptions(participant) {
+        return participant.getAttribute("supports_messaging_streams") === true;
+    }
+    trackStream(subscription) {
+        const task = (async () => {
+            try {
+                for await (const event of subscription.stream) {
+                    if (event.kind !== "message" || event.message.type !== agentRoomMessageType) {
+                        continue;
+                    }
+                    const raw = event.message.message;
+                    if (typeof raw["type"] !== "string") {
+                        continue;
+                    }
+                    this.handleAgentMessage(AgentMessageFactory.fromJson(raw), {
+                        createdAt: dateOrNull(raw["created_at"]),
+                        attachment: event.message.attachment,
+                    });
+                }
+            }
+            finally {
+                if (subscription instanceof ThreadSubscribe) {
+                    if (this.threadSubscriptions.get(subscription.threadId) === subscription) {
+                        this.threadSubscriptions.delete(subscription.threadId);
+                    }
+                }
+                else if (this.threadListSubscription === subscription) {
+                    this.threadListSubscription = undefined;
+                }
+            }
+        })();
+        this.streamTasks.add(task);
+        void task.finally(() => this.streamTasks.delete(task));
+    }
+    async sendAgentMessage(message, { attachment } = {}) {
+        await this.start();
+        const participant = this.agentParticipant();
+        if (participant == null) {
+            throw new Error("Agent messaging participant is not available.");
+        }
+        if (!this.supportsThreadSubscriptions(participant)) {
+            await super.sendAgentMessage(message, { attachment });
+            return;
+        }
+        if (message.type === agentThreadOpenType) {
+            const previous = this.threadSubscriptions.get(message.threadId);
+            if (previous != null) {
+                await previous.close();
+            }
+            const stream = await this.room.messaging.stream({
+                to: participant,
+                type: messagingChatThreadSubscribeType,
+                message: message.toJson(),
+                attachment,
+            });
+            const subscription = new ThreadSubscribe({ threadId: message.threadId, stream });
+            this.threadSubscriptions.set(message.threadId, subscription);
+            this.trackStream(subscription);
+            return;
+        }
+        if (message.type === agentThreadCloseType) {
+            const subscription = this.threadSubscriptions.get(message.threadId);
+            if (subscription != null) {
+                this.threadSubscriptions.delete(message.threadId);
+                await subscription.close();
+                return;
+            }
+        }
+        if (message.type === agentThreadWatchType) {
+            await this.threadListSubscription?.close();
+            const stream = await this.room.messaging.stream({
+                to: participant,
+                type: messagingChatThreadListSubscribeType,
+                message: message.toJson(),
+                attachment,
+            });
+            const subscription = new ThreadListSubscribe({ stream });
+            this.threadListSubscription = subscription;
+            this.trackStream(subscription);
+            return;
+        }
+        if (message.type === agentThreadUnwatchType && this.threadListSubscription != null) {
+            const subscription = this.threadListSubscription;
+            this.threadListSubscription = undefined;
+            await subscription.close();
+            return;
+        }
+        if ("threadId" in message && typeof message.threadId === "string") {
+            const subscription = this.threadSubscriptions.get(message.threadId);
+            if (subscription != null) {
+                await subscription.send(message, { attachment });
+                return;
+            }
+        }
+        await super.sendAgentMessage(message, { attachment });
+    }
+}
 function isThreadListMessage(message) {
     return message.type === agentThreadListedType
         || message.type === agentThreadCreatedType

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

@@ -1,4 +1,4 @@
-import { RemoteParticipant } from "@meshagent/meshagent";
+import { MessagingStream, RemoteParticipant } from "@meshagent/meshagent";
 import type { RoomClient, Content } from "@meshagent/meshagent";
 import { AgentMessage, AgentModelChanged, AgentThreadStatus, ModelsResponse, ToolChoice, AgentConnectionStatus, AgentClientToolCallRequested } from "./agent-messages.js";
 import type { AgentPayload, JsonMap, ClientToolkitDescription } from "./agent-messages.js";
@@ -133,7 +133,30 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
     }): void;
     removeThreadSession(threadPath: string): void;
 }
-export declare class MessagingChatClient extends BaseChatClient {
+export declare const messagingChatThreadSubscribeType = "meshagent.chat.thread.subscribe";
+export declare const messagingChatThreadListSubscribeType = "meshagent.chat.thread_list.subscribe";
+export declare class ThreadSubscribe {
+    readonly threadId: string;
+    readonly stream: MessagingStream;
+    constructor({ threadId, stream }: {
+        threadId: string;
+        stream: MessagingStream;
+    });
+    get closed(): boolean;
+    send(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class ThreadListSubscribe {
+    readonly stream: MessagingStream;
+    constructor({ stream }: {
+        stream: MessagingStream;
+    });
+    get closed(): boolean;
+    close(): Promise<void>;
+}
+export declare class BaseMessagingChatClient extends BaseChatClient {
     readonly room: RoomClient;
     readonly agentName?: string;
     private readonly pendingParticipantWaits;
@@ -167,6 +190,17 @@ export declare class MessagingChatClient extends BaseChatClient {
     private reopenOpenSessions;
     private readonly onMessagingMessage;
 }
+export declare class MessagingChatClient extends BaseMessagingChatClient {
+    private readonly threadSubscriptions;
+    private threadListSubscription?;
+    private readonly streamTasks;
+    stop(): Promise<void>;
+    private supportsThreadSubscriptions;
+    private trackStream;
+    sendAgentMessage(message: AgentMessage, { attachment }?: {
+        attachment?: Uint8Array;
+    }): Promise<void>;
+}
 export declare class ChatThreadSession extends ChangeEmitter {
     private readonly client;
     readonly threadPath: string;

package/dist/node/chat-client.js

@@ -1,6 +1,6 @@
 "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;
+exports.ChatThreadSession = exports.MessagingChatClient = exports.BaseMessagingChatClient = exports.ThreadListSubscribe = exports.ThreadSubscribe = exports.messagingChatThreadListSubscribeType = exports.messagingChatThreadSubscribeType = 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");
@@ -343,7 +343,41 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
     }
 }
 exports.BaseChatClient = BaseChatClient;
-class MessagingChatClient extends BaseChatClient {
+exports.messagingChatThreadSubscribeType = "meshagent.chat.thread.subscribe";
+exports.messagingChatThreadListSubscribeType = "meshagent.chat.thread_list.subscribe";
+class ThreadSubscribe {
+    constructor({ threadId, stream }) {
+        this.threadId = threadId;
+        this.stream = stream;
+    }
+    get closed() {
+        return this.stream.closed;
+    }
+    async send(message, { attachment } = {}) {
+        await this.stream.sendMessage({
+            type: agent_messages_js_1.agentRoomMessageType,
+            message: message.toJson(),
+            attachment,
+        });
+    }
+    async close() {
+        await this.stream.close();
+    }
+}
+exports.ThreadSubscribe = ThreadSubscribe;
+class ThreadListSubscribe {
+    constructor({ stream }) {
+        this.stream = stream;
+    }
+    get closed() {
+        return this.stream.closed;
+    }
+    async close() {
+        await this.stream.close();
+    }
+}
+exports.ThreadListSubscribe = ThreadListSubscribe;
+class BaseMessagingChatClient extends BaseChatClient {
     constructor({ room, agentName }) {
         super();
         this.pendingParticipantWaits = new Map();
@@ -560,6 +594,123 @@ class MessagingChatClient extends BaseChatClient {
         }
     }
 }
+exports.BaseMessagingChatClient = BaseMessagingChatClient;
+class MessagingChatClient extends BaseMessagingChatClient {
+    constructor() {
+        super(...arguments);
+        this.threadSubscriptions = new Map();
+        this.streamTasks = new Set();
+    }
+    async stop() {
+        const subscriptions = [
+            ...this.threadSubscriptions.values(),
+        ];
+        if (this.threadListSubscription != null) {
+            subscriptions.push(this.threadListSubscription);
+        }
+        this.threadSubscriptions.clear();
+        this.threadListSubscription = undefined;
+        await Promise.all(subscriptions.map(async (subscription) => subscription.close()));
+        await Promise.all(this.streamTasks);
+        await super.stop();
+    }
+    supportsThreadSubscriptions(participant) {
+        return participant.getAttribute("supports_messaging_streams") === true;
+    }
+    trackStream(subscription) {
+        const task = (async () => {
+            try {
+                for await (const event of subscription.stream) {
+                    if (event.kind !== "message" || event.message.type !== agent_messages_js_1.agentRoomMessageType) {
+                        continue;
+                    }
+                    const raw = event.message.message;
+                    if (typeof raw["type"] !== "string") {
+                        continue;
+                    }
+                    this.handleAgentMessage(agent_messages_js_1.AgentMessage.fromJson(raw), {
+                        createdAt: dateOrNull(raw["created_at"]),
+                        attachment: event.message.attachment,
+                    });
+                }
+            }
+            finally {
+                if (subscription instanceof ThreadSubscribe) {
+                    if (this.threadSubscriptions.get(subscription.threadId) === subscription) {
+                        this.threadSubscriptions.delete(subscription.threadId);
+                    }
+                }
+                else if (this.threadListSubscription === subscription) {
+                    this.threadListSubscription = undefined;
+                }
+            }
+        })();
+        this.streamTasks.add(task);
+        void task.finally(() => this.streamTasks.delete(task));
+    }
+    async sendAgentMessage(message, { attachment } = {}) {
+        await this.start();
+        const participant = this.agentParticipant();
+        if (participant == null) {
+            throw new Error("Agent messaging participant is not available.");
+        }
+        if (!this.supportsThreadSubscriptions(participant)) {
+            await super.sendAgentMessage(message, { attachment });
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentThreadOpenType) {
+            const previous = this.threadSubscriptions.get(message.threadId);
+            if (previous != null) {
+                await previous.close();
+            }
+            const stream = await this.room.messaging.stream({
+                to: participant,
+                type: exports.messagingChatThreadSubscribeType,
+                message: message.toJson(),
+                attachment,
+            });
+            const subscription = new ThreadSubscribe({ threadId: message.threadId, stream });
+            this.threadSubscriptions.set(message.threadId, subscription);
+            this.trackStream(subscription);
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentThreadCloseType) {
+            const subscription = this.threadSubscriptions.get(message.threadId);
+            if (subscription != null) {
+                this.threadSubscriptions.delete(message.threadId);
+                await subscription.close();
+                return;
+            }
+        }
+        if (message.type === agent_messages_js_1.agentThreadWatchType) {
+            await this.threadListSubscription?.close();
+            const stream = await this.room.messaging.stream({
+                to: participant,
+                type: exports.messagingChatThreadListSubscribeType,
+                message: message.toJson(),
+                attachment,
+            });
+            const subscription = new ThreadListSubscribe({ stream });
+            this.threadListSubscription = subscription;
+            this.trackStream(subscription);
+            return;
+        }
+        if (message.type === agent_messages_js_1.agentThreadUnwatchType && this.threadListSubscription != null) {
+            const subscription = this.threadListSubscription;
+            this.threadListSubscription = undefined;
+            await subscription.close();
+            return;
+        }
+        if ("threadId" in message && typeof message.threadId === "string") {
+            const subscription = this.threadSubscriptions.get(message.threadId);
+            if (subscription != null) {
+                await subscription.send(message, { attachment });
+                return;
+            }
+        }
+        await super.sendAgentMessage(message, { attachment });
+    }
+}
 exports.MessagingChatClient = MessagingChatClient;
 function isThreadListMessage(message) {
     return message.type === agent_messages_js_1.agentThreadListedType

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent-agents",
-    "version": "0.47.0",
+    "version": "0.47.1",
     "description": "Agent chat sessions and clients for Meshagent TypeScript applications.",
     "homepage": "https://github.com/meshagent/meshagent-agents-ts",
     "scripts": {
@@ -48,7 +48,7 @@
         "typescript": "^5.8.2"
     },
     "dependencies": {
-        "@meshagent/meshagent": "^0.47.0",
+        "@meshagent/meshagent": "^0.47.1",
         "apache-arrow": "^21.0.0",
         "uuid": "^14.0.0"
     },