@meshagent/meshagent-agents 0.46.4 → 0.47.1

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 }) {
@@ -168,6 +168,13 @@ export class BaseChatClient extends ChangeEmitter {
     localParticipantName() {
         return undefined;
     }
+    localParticipantId() {
+        return undefined;
+    }
+    isClientToolCallForLocalParticipant(request) {
+        const targetParticipantId = request.targetParticipantId?.trim();
+        return targetParticipantId == null || targetParticipantId === "" || targetParticipantId === this.localParticipantId();
+    }
     cleanParticipantName(value) {
         return nonEmptyTrimmed(value);
     }
@@ -273,6 +280,10 @@ export class BaseChatClient extends ChangeEmitter {
         }
     }
     handleAgentMessage(message, { createdAt, attachment } = {}) {
+        if (message instanceof AgentClientToolCallRequested &&
+            !this.isClientToolCallForLocalParticipant(message)) {
+            return;
+        }
         if (message.type === agentConnectionStatusType) {
             this._connectionStatus = message;
         }
@@ -324,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();
@@ -412,6 +455,9 @@ export class MessagingChatClient extends BaseChatClient {
         const name = this.room.localParticipant?.getAttribute("name");
         return typeof name === "string" ? this.cleanParticipantName(name) : undefined;
     }
+    localParticipantId() {
+        return this.room.localParticipant?.id;
+    }
     async start() {
         if (this.started) {
             return;
@@ -538,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
@@ -551,6 +713,8 @@ export class ChatThreadSession extends ChangeEmitter {
         this.messageIndexes = new Map();
         this.localAgentMessageIds = new Set();
         this.pendingLocalInputMessageIds = new Set();
+        this.resolvedInputMessageIds = new Set();
+        this.completedTurnIds = new Set();
         this.mergedDeltaMessageIds = new Set();
         this.pendingInputsById = new Map();
         this.openState = false;
@@ -629,6 +793,8 @@ export class ChatThreadSession extends ChangeEmitter {
         this.messageIndexes.clear();
         this.localAgentMessageIds.clear();
         this.pendingLocalInputMessageIds.clear();
+        this.resolvedInputMessageIds.clear();
+        this.completedTurnIds.clear();
         this.mergedDeltaMessageIds.clear();
         this.pendingInputsById.clear();
         this.lastCompletedTurnIdValue = undefined;
@@ -780,15 +946,19 @@ export class ChatThreadSession extends ChangeEmitter {
             return;
         }
         if (message.type === agentThreadStatusType && message instanceof AgentThreadStatus) {
-            this.threadStatusValue = message;
             const mode = normalizedString(message.mode);
             const status = normalizedString(message.status);
             const turnId = normalizedString(message.turnId);
-            if (status != null && mode === "steerable" && turnId != null) {
-                this.activeTurnIdValue = turnId;
+            if (status == null) {
+                this.threadStatusValue = undefined;
+                if (turnId != null && this.activeTurnIdValue === turnId) {
+                    this.activeTurnIdValue = undefined;
+                }
+                return;
             }
-            else if (status == null && turnId != null && this.activeTurnIdValue === turnId) {
-                this.activeTurnIdValue = undefined;
+            this.threadStatusValue = message;
+            if (mode === "steerable" && turnId != null) {
+                this.activeTurnIdValue = turnId;
             }
             return;
         }
@@ -816,21 +986,29 @@ export class ChatThreadSession extends ChangeEmitter {
     updatePendingInputsForMessage(message, createdAt) {
         const type = message.type;
         const messageId = message.messageId;
-        const sourceMessageId = sourceMessageIdFor(message);
+        const sourceMessageId = normalizedString(sourceMessageIdFor(message));
         if (type === agentThreadStartType || type === agentTurnStartType || type === agentTurnSteerType) {
             const normalizedMessageId = messageId.trim();
             if (normalizedMessageId !== "") {
+                const wasPending = this.pendingInputsById.has(normalizedMessageId);
+                const turnId = type === agentTurnStartType || type === agentTurnSteerType
+                    ? normalizedString(threadMessageValue(message, "turnId"))
+                    : undefined;
+                const wasAlreadyResolved = !wasPending && (this.resolvedInputMessageIds.has(normalizedMessageId) ||
+                    (turnId != null && this.completedTurnIds.has(turnId)));
                 this.localAgentMessageIds.add(normalizedMessageId);
                 this.pendingLocalInputMessageIds.add(normalizedMessageId);
-                this.markPending(new PendingAgentInput({
-                    messageId: normalizedMessageId,
-                    messageType: type,
-                    threadPath: this.threadPath,
-                    payload: message,
-                    createdAt,
-                    awaitingAcceptance: true,
-                    awaitingApplication: true,
-                }));
+                if (!wasAlreadyResolved) {
+                    this.markPending(new PendingAgentInput({
+                        messageId: normalizedMessageId,
+                        messageType: type,
+                        threadPath: this.threadPath,
+                        payload: message,
+                        createdAt,
+                        awaitingAcceptance: true,
+                        awaitingApplication: true,
+                    }));
+                }
             }
         }
         else if (type === agentThreadStartRejectedType) {
@@ -843,12 +1021,14 @@ export class ChatThreadSession extends ChangeEmitter {
         }
         else if (type === agentTurnStartedType || type === agentTurnSteeredType) {
             if (sourceMessageId != null) {
+                this.resolvedInputMessageIds.add(sourceMessageId);
                 this.pendingInputsById.delete(sourceMessageId);
                 this.pendingLocalInputMessageIds.delete(sourceMessageId);
             }
         }
         else if (type === agentTurnStartRejectedType || type === agentTurnSteerRejectedType) {
             if (sourceMessageId != null) {
+                this.resolvedInputMessageIds.add(sourceMessageId);
                 this.pendingInputsById.delete(sourceMessageId);
                 this.pendingLocalInputMessageIds.delete(sourceMessageId);
             }
@@ -856,6 +1036,15 @@ export class ChatThreadSession extends ChangeEmitter {
         else if (type === agentTurnEndedType || type === agentThreadClearedType) {
             this.pendingInputsById.clear();
             this.pendingLocalInputMessageIds.clear();
+            if (type === agentTurnEndedType) {
+                const turnId = normalizedString(threadMessageValue(message, "turnId"));
+                if (turnId != null)
+                    this.completedTurnIds.add(turnId);
+            }
+            else if (type === agentThreadClearedType) {
+                this.resolvedInputMessageIds.clear();
+                this.completedTurnIds.clear();
+            }
         }
     }
     appendRenderableMessage(event) {

package/dist/node/agent-messages.js

@@ -747,26 +747,16 @@ function makeMessageClass({ type, base = "message", fields = [], }) {
                 params.model = stringOrNull(json.model);
             }
             for (const field of fields) {
-                if (field.required) {
-                    if (field.from != null) {
-                        params[field.prop] = field.from(json[field.json], json);
+                if (!hasOwn(json, field.json)) {
+                    if (field.required) {
+                        if (field.from != null) {
+                            field.from(undefined, json);
+                        }
+                        throw new TypeError(`missing required field '${field.json}'`);
                     }
-                    else if (typeof json[field.json] === "string") {
-                        params[field.prop] = requiredString(json, field.json);
-                    }
-                    else if (typeof json[field.json] === "number") {
-                        params[field.prop] = json[field.json];
-                    }
-                    else {
-                        params[field.prop] = requiredMap(json, field.json);
-                    }
-                }
-                else if (hasOwn(json, field.json)) {
-                    params[field.prop] = field.from != null ? field.from(json[field.json], json) : json[field.json];
-                }
-                else if (field.default != null) {
-                    params[field.prop] = field.default(json);
+                    continue;
                 }
+                params[field.prop] = json[field.json];
             }
             return new this(params);
         }
@@ -990,10 +980,10 @@ exports.AgentToolCallLogDelta = makeMessageClass({ type: exports.agentToolCallLo
 exports.AgentToolCallEnded = makeMessageClass({ type: exports.agentToolCallEndedType, base: "llm", fields: [...contentPart, { prop: "namespace", json: "namespace", from: (value) => stringOrNull(value) ?? "meshagent", default: () => "meshagent", always: true }, s("callId"), s("toolkit"), s("tool"), { prop: "result", json: "result", from: contentOrNull, to: contentHeader }, obj("error", "error", AgentError.fromJson)] });
 exports.AgentToolCallApprovalRequested = makeMessageClass({ type: exports.agentToolCallApprovalRequestedType, base: "llm", fields: toolState.filter((field) => field.prop !== "argumentBytes") });
 exports.AgentSecretRequested = makeMessageClass({ type: exports.agentSecretRequestedType, base: "llm", fields: [...contentPart, s("requestId", "request_id", true), s("name", "name", true), s("scope")] });
-exports.AgentClientToolCallRequested = makeMessageClass({ type: exports.agentClientToolCallRequestedType, base: "llm", fields: [...contentPart, s("requestId", "request_id", true), s("toolkit", "toolkit", true), s("tool", "tool", true), m("arguments", "arguments", true)] });
-exports.AgentClientToolCallCancelled = makeMessageClass({ type: exports.agentClientToolCallCancelledType, base: "llm", fields: [...contentPart, s("requestId", "request_id", true), s("reason")] });
+exports.AgentClientToolCallRequested = makeMessageClass({ type: exports.agentClientToolCallRequestedType, base: "llm", fields: [...contentPart, s("requestId", "request_id", true), s("targetParticipantId"), s("toolkit", "toolkit", true), s("tool", "tool", true), m("arguments", "arguments", true)] });
+exports.AgentClientToolCallCancelled = makeMessageClass({ type: exports.agentClientToolCallCancelledType, base: "llm", fields: [...contentPart, s("requestId", "request_id", true), s("targetParticipantId"), s("reason")] });
 exports.AgentThreadStatus = makeMessageClass({ type: exports.agentThreadStatusType, base: "thread", fields: [s("status"), s("mode"), s("startedAt"), s("turnId"), s("pendingItemId"), i("totalBytes"), i("linesAdded"), i("linesRemoved")] });
-exports.AgentConnectionStatus = makeMessageClass({ type: exports.agentConnectionStatusType, fields: [s("status", "status", true), s("message"), s("reason"), n("retryInSeconds")] });
+exports.AgentConnectionStatus = makeMessageClass({ type: exports.agentConnectionStatusType, fields: [s("status", "status", true), s("message"), s("reason"), n("retryInSeconds"), s("participantId")] });
 exports.AgentThreadEvent = makeMessageClass({ type: exports.agentThreadEventType, base: "llm", fields: [m("event", "event", true)] });
 exports.AgentImageGenerationStarted = makeMessageClass({ type: exports.agentImageGenerationStartedType, base: "llm", fields: imageGeneration });
 exports.AgentImageGenerationPartial = makeMessageClass({ type: exports.agentImageGenerationPartialType, base: "llm", fields: [...imageGeneration, obj("image", "image", AgentGeneratedImage.fromJson), i("partialIndex")] });

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

@@ -1,6 +1,6 @@
-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 } from "./agent-messages.js";
+import { AgentMessage, AgentModelChanged, AgentThreadStatus, ModelsResponse, ToolChoice, AgentConnectionStatus, AgentClientToolCallRequested } from "./agent-messages.js";
 import type { AgentPayload, JsonMap, ClientToolkitDescription } from "./agent-messages.js";
 import { ChangeEmitter } from "./change-emitter.js";
 export declare class AgentMessageEvent {
@@ -90,6 +90,8 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
     stop(): Promise<void>;
     agentParticipant(): RemoteParticipant | null;
     localParticipantName(): string | undefined;
+    localParticipantId(): string | undefined;
+    isClientToolCallForLocalParticipant(request: InstanceType<typeof AgentClientToolCallRequested>): boolean;
     protected cleanParticipantName(value: string | undefined): string | undefined;
     openThread(threadPath: string, { load, sinceTurn, reloadIfOpen, drainPendingEvents, }?: {
         load?: boolean;
@@ -131,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;
@@ -146,6 +171,7 @@ export declare class MessagingChatClient extends BaseChatClient {
         agentName?: string;
     });
     localParticipantName(): string | undefined;
+    localParticipantId(): string | undefined;
     start(): Promise<void>;
     stop(): Promise<void>;
     private attachMessagingListeners;
@@ -164,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;
@@ -171,6 +208,8 @@ export declare class ChatThreadSession extends ChangeEmitter {
     private readonly messageIndexes;
     private readonly localAgentMessageIds;
     private readonly pendingLocalInputMessageIds;
+    private readonly resolvedInputMessageIds;
+    private readonly completedTurnIds;
     private readonly mergedDeltaMessageIds;
     private readonly pendingInputsById;
     private openState;