@meshagent/meshagent-agents 0.43.2 → 0.44.0

package/dist/browser/thread-storage.js

@@ -313,10 +313,12 @@ class AgentThreadStorageRepository extends ThreadStorageRepository {
                 this.handleEvent(next.value);
             }
         })();
-        await new Promise((resolve) => {
+        const ready = new Promise((resolve) => {
             this.pendingOpen = { resolve };
-            void this.requestList();
         });
+        await this.chatClient.sendAgentMessage(new agent_messages_js_1.WatchThreads(), { ignoreOffline: true });
+        await this.requestList();
+        await ready;
     }
     async close() {
         this.closed = true;
@@ -325,6 +327,7 @@ class AgentThreadStorageRepository extends ThreadStorageRepository {
         this.pendingListMessageId = undefined;
         this.pendingOpen?.resolve();
         this.pendingOpen = undefined;
+        await this.chatClient.sendAgentMessage(new agent_messages_js_1.UnwatchThreads(), { ignoreOffline: true }).catch(() => undefined);
     }
     entries() {
         return [...this.entriesByPath.values()];

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

@@ -19,6 +19,8 @@ export declare const agentParticipantDisconnectType = "meshagent.agent.participa
 export declare const agentThreadDeleteType = "meshagent.agent.thread.delete";
 export declare const agentThreadRenameType = "meshagent.agent.thread.rename";
 export declare const agentThreadListType = "meshagent.agent.thread.list";
+export declare const agentThreadWatchType = "meshagent.agent.thread.watch";
+export declare const agentThreadUnwatchType = "meshagent.agent.thread.unwatch";
 export declare const agentThreadListedType = "meshagent.agent.thread.listed";
 export declare const agentThreadCreatedType = "meshagent.agent.thread.created";
 export declare const agentThreadUpdatedType = "meshagent.agent.thread.updated";
@@ -170,6 +172,7 @@ export declare class AgentProviderInfo {
     readonly name: string;
     readonly friendlyName: string;
     readonly description?: string;
+    readonly backend?: string;
     readonly defaultModel: string;
     readonly models: AgentModelInfo[];
     constructor(params: JsonMap);
@@ -238,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;
 }
@@ -271,6 +275,8 @@ export declare const ParticipantDisconnect: MessageCtor;
 export declare const DeleteThread: MessageCtor;
 export declare const RenameThread: MessageCtor;
 export declare const ListThreads: MessageCtor;
+export declare const WatchThreads: MessageCtor;
+export declare const UnwatchThreads: MessageCtor;
 export declare const ThreadsListed: MessageCtor;
 export declare const ThreadCreated: MessageCtor;
 export declare const ThreadUpdated: MessageCtor;

package/dist/esm/agent-messages.js

@@ -18,6 +18,8 @@ export const agentParticipantDisconnectType = "meshagent.agent.participant.disco
 export const agentThreadDeleteType = "meshagent.agent.thread.delete";
 export const agentThreadRenameType = "meshagent.agent.thread.rename";
 export const agentThreadListType = "meshagent.agent.thread.list";
+export const agentThreadWatchType = "meshagent.agent.thread.watch";
+export const agentThreadUnwatchType = "meshagent.agent.thread.unwatch";
 export const agentThreadListedType = "meshagent.agent.thread.listed";
 export const agentThreadCreatedType = "meshagent.agent.thread.created";
 export const agentThreadUpdatedType = "meshagent.agent.thread.updated";
@@ -476,6 +478,7 @@ export class AgentProviderInfo {
         this.name = String(params.name);
         this.friendlyName = String(params.friendlyName ?? params.friendly_name);
         this.description = stringOrNull(params.description);
+        this.backend = stringOrNull(params.backend);
         this.defaultModel = String(params.defaultModel ?? params.default_model);
         this.models = Array.isArray(params.models) ? params.models.map((entry) => entry instanceof AgentModelInfo ? entry : AgentModelInfo.fromJson(requiredObjectValue(entry))) : [];
     }
@@ -487,6 +490,7 @@ export class AgentProviderInfo {
             name: this.name,
             friendly_name: this.friendlyName,
             ...(this.description != null ? { description: this.description } : {}),
+            ...(this.backend != null ? { backend: this.backend } : {}),
             default_model: this.defaultModel,
             models: this.models.map((entry) => entry.toJson()),
         };
@@ -608,11 +612,12 @@ export class AgentContextWindowUsage {
         this.compactionThreshold = intOrNull(params.compactionThreshold ?? params.compaction_threshold);
     }
     static fromJson(json) {
+        const usedTokens = intOrNull(json.used_tokens ?? json.usedTokens) ?? 0;
         return new AgentContextWindowUsage({
-            usedTokens: requiredInt(json, "used_tokens"),
-            totalTokens: intOrNull(json.total_tokens),
-            compactionMode: stringOrNull(json.compaction_mode),
-            compactionThreshold: intOrNull(json.compaction_threshold),
+            usedTokens,
+            totalTokens: intOrNull(json.total_tokens ?? json.totalTokens),
+            compactionMode: stringOrNull(json.compaction_mode ?? json.compactionMode),
+            compactionThreshold: intOrNull(json.compaction_threshold ?? json.compactionThreshold),
         });
     }
     toJson() {
@@ -628,16 +633,18 @@ function omitUndefined(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
 export class AgentMessage {
-    constructor({ type, messageId, message_id, senderName, sender_name }) {
+    constructor({ type, messageId, message_id, senderName, sender_name, createdAt, created_at }) {
         this.type = String(type);
         const resolvedMessageId = stringOrNull(messageId ?? message_id)?.trim();
         this.messageId = resolvedMessageId == null || resolvedMessageId.length === 0 ? uuidv4() : resolvedMessageId;
         this.senderName = stringOrNull(senderName ?? sender_name);
+        this.createdAt = stringOrNull(createdAt ?? created_at) ?? new Date().toISOString();
     }
     toJson() {
         return {
             type: this.type,
             message_id: this.messageId,
+            created_at: this.createdAt,
             ...(this.senderName != null ? { sender_name: this.senderName } : {}),
         };
     }
@@ -701,6 +708,7 @@ function makeMessageClass({ type, base = "message", fields = [], }) {
             const params = {
                 messageId: stringOrNull(json.message_id),
                 senderName: stringOrNull(json.sender_name),
+                createdAt: stringOrNull(json.created_at),
             };
             if (base !== "message") {
                 params.threadId = requiredString(json, "thread_id");
@@ -852,6 +860,7 @@ const turnOptions = [
     s("turnId"),
     contentList("content"),
     s("provider"),
+    s("backend"),
     s("model"),
     s("voice"),
     sl("outputModalities"),
@@ -886,6 +895,7 @@ export const StartThread = makeMessageClass({
         s("name"),
         s("realtimeProtocol"),
         s("provider"),
+        s("backend"),
         s("model"),
         s("voice"),
         sl("outputModalities"),
@@ -909,6 +919,8 @@ export const ParticipantDisconnect = makeMessageClass({ type: agentParticipantDi
 export const DeleteThread = makeMessageClass({ type: agentThreadDeleteType, base: "thread" });
 export const RenameThread = makeMessageClass({ type: agentThreadRenameType, base: "thread", fields: [s("name", "name", true)] });
 export const ListThreads = makeMessageClass({ type: agentThreadListType, fields: [{ prop: "limit", json: "limit", from: (value) => intOrNull(value) ?? 200, default: () => 200, always: true }, { prop: "offset", json: "offset", from: (value) => intOrNull(value) ?? 0, default: () => 0, always: true }] });
+export const WatchThreads = makeMessageClass({ type: agentThreadWatchType });
+export const UnwatchThreads = makeMessageClass({ type: agentThreadUnwatchType });
 export const ThreadsListed = makeMessageClass({ type: agentThreadListedType, fields: [s("sourceMessageId", "source_message_id", true), objList("threads", "threads", AgentThreadListEntry.fromJson, true), i("total"), i("offset"), i("limit")] });
 export const ThreadCreated = makeMessageClass({ type: agentThreadCreatedType, fields: [obj("thread", "thread", AgentThreadListEntry.fromJson, true)] });
 export const ThreadUpdated = makeMessageClass({ type: agentThreadUpdatedType, fields: [obj("thread", "thread", AgentThreadListEntry.fromJson, true)] });
@@ -917,8 +929,8 @@ export const CapabilitiesRequest = makeMessageClass({ type: agentCapabilitiesReq
 export const CapabilitiesResponse = makeMessageClass({ type: agentCapabilitiesResponseType, base: "thread", fields: [s("sourceMessageId", "source_message_id", true), s("version", "version", true), objList("toolkits", "toolkits", ToolkitCapabilities.fromJson, true)] });
 export const ModelsRequest = makeMessageClass({ type: agentModelsRequestType });
 export const ModelsResponse = makeMessageClass({ type: agentModelsResponseType, fields: [s("sourceMessageId", "source_message_id", true), objList("providers", "providers", AgentProviderInfo.fromJson, true)] });
-export const ChangeModel = makeMessageClass({ type: agentModelChangeType, base: "thread", fields: [s("provider"), s("model"), s("voice")] });
-export const AgentModelChanged = makeMessageClass({ type: agentModelChangedType, base: "thread", fields: [s("sourceMessageId"), s("provider", "provider", true), s("model", "model", true), s("voice"), audioFormat("inputFormat"), audioFormat("outputFormat"), s("turnDetection"), sl("outputModalities", "output_modalities", ["text"], true), sl("realtimeProtocols", "realtime_protocols", [], true)] });
+export const ChangeModel = makeMessageClass({ type: agentModelChangeType, base: "thread", fields: [s("backend"), s("provider"), s("model"), s("voice")] });
+export const AgentModelChanged = makeMessageClass({ type: agentModelChangedType, base: "thread", fields: [s("sourceMessageId"), s("backend"), s("provider", "provider", true), s("model", "model", true), s("voice"), audioFormat("inputFormat"), audioFormat("outputFormat"), s("turnDetection"), sl("outputModalities", "output_modalities", ["text"], true), sl("realtimeProtocols", "realtime_protocols", [], true), { prop: "supportsAttachments", json: "supports_attachments", from: (value) => value === true, default: () => false }, sl("accepts", "accepts", [], true)] });
 export const ThreadCleared = makeMessageClass({ type: agentThreadClearedType, base: "thread", fields: [s("sourceMessageId", "source_message_id", true)] });
 export const TurnStartAccepted = makeMessageClass({ type: agentTurnStartAcceptedType, base: "thread", fields: [s("turnId"), s("sourceMessageId", "source_message_id", true), contentList("content")] });
 export const TurnStartRejected = makeMessageClass({ type: agentTurnStartRejectedType, base: "thread", fields: [s("sourceMessageId", "source_message_id", true), obj("error", "error", AgentError.fromJson, true)] });

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, 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;
@@ -78,6 +80,7 @@ export declare class ChatThreadStartResult {
 export declare abstract class BaseChatClient extends ChangeEmitter {
     private readonly sessionsByPath;
     private readonly pendingStartRequests;
+    private readonly pendingSessionEventsByPath;
     private readonly eventQueue;
     private _connectionStatus?;
     get events(): AsyncIterable<AgentMessageEvent>;
@@ -88,16 +91,19 @@ export declare abstract class BaseChatClient extends ChangeEmitter {
     agentParticipant(): RemoteParticipant | null;
     localParticipantName(): string | undefined;
     protected cleanParticipantName(value: string | undefined): string | undefined;
-    openThread(threadPath: string, { load, sinceTurn, reloadIfOpen }?: {
+    openThread(threadPath: string, { load, sinceTurn, reloadIfOpen, drainPendingEvents, }?: {
         load?: boolean;
         sinceTurn?: string;
         reloadIfOpen?: boolean;
+        drainPendingEvents?: boolean;
     }): ChatThreadSession;
-    startThread({ messageId, message, attachments, name, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, omitContent, }: {
+    private openSession;
+    startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, toolChoice, omitContent, }: {
         messageId?: string;
         message: string;
         attachments: string[];
         name?: string;
+        backend?: string;
         provider?: string;
         model?: string;
         voice?: string;
@@ -105,13 +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>;
-    handleAgentMessage(message: AgentMessage, { attachment }?: {
+    private drainPendingSessionEvents;
+    handleAgentMessage(message: AgentMessage, { createdAt, attachment }?: {
+        createdAt?: Date;
         attachment?: Uint8Array;
     }): void;
     emitConnectionStatus({ status, message, reason, retryDelay, }: {
@@ -126,9 +136,7 @@ export declare class MessagingChatClient extends BaseChatClient {
     readonly room: RoomClient;
     readonly agentName?: string;
     private readonly pendingParticipantWaits;
-    private readonly roomAbortController;
     private started;
-    private roomPump?;
     constructor({ room, agentName }: {
         room: RoomClient;
         agentName?: string;
@@ -145,17 +153,24 @@ export declare class MessagingChatClient extends BaseChatClient {
         ignoreOffline?: boolean;
     }): Promise<void>;
     private readonly onMessagingChanged;
-    private consumeRoomEvents;
-    private onRoomEvent;
+    private readonly onMessagingMessage;
 }
 export declare class ChatThreadSession extends ChangeEmitter {
     private readonly client;
     readonly threadPath: string;
     private readonly _messages;
+    private readonly messageIndexes;
+    private readonly localAgentMessageIds;
+    private readonly pendingLocalInputMessageIds;
+    private readonly mergedDeltaMessageIds;
     private readonly pendingInputsById;
     private openState;
     private loadStateValue;
     private lastCompletedTurnIdValue?;
+    private activeTurnIdValue?;
+    private threadStatusValue?;
+    private currentModelValue?;
+    private modelsResponseValue?;
     private lastAgentMessageType?;
     private lastAgentMessageAt?;
     constructor({ client, threadPath }: {
@@ -168,15 +183,21 @@ export declare class ChatThreadSession extends ChangeEmitter {
     get loadState(): ChatThreadSessionLoadState;
     get isLoading(): boolean;
     get lastCompletedTurnId(): string | undefined;
+    get activeTurnId(): string | undefined;
+    get threadStatus(): InstanceType<typeof AgentThreadStatus> | undefined;
+    get currentModel(): InstanceType<typeof AgentModelChanged> | undefined;
+    get modelsResponse(): InstanceType<typeof ModelsResponse> | undefined;
     open({ load, sinceTurn }?: {
         load?: boolean;
         sinceTurn?: string;
     }): Promise<void>;
+    private resetReplayState;
     close(): Promise<void>;
     requestModels({ ignoreOffline }?: {
         ignoreOffline?: boolean;
     }): Promise<void>;
-    changeModel({ provider, model, voice }: {
+    changeModel({ backend, provider, model, voice }: {
+        backend?: string;
         provider: string;
         model: string;
         voice?: string;
@@ -187,18 +208,20 @@ export declare class ChatThreadSession extends ChangeEmitter {
         requestId: string;
         response: Content;
     }): Promise<void>;
-    sendText({ messageId, text, attachments, steer, turnId, 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[];
         steer?: boolean;
         turnId?: string;
+        backend?: string;
         provider?: string;
         model?: string;
         voice?: string;
         outputModalities?: string[];
         senderName?: string;
         clientToolkits?: ClientToolkitDescription[];
+        toolChoice?: ToolChoice;
     }): Promise<string>;
     sendRealtimeAudioChunk({ chunk, format }: {
         chunk: Uint8Array;
@@ -214,6 +237,14 @@ export declare class ChatThreadSession extends ChangeEmitter {
     deleteThread(threadPath: string): Promise<void>;
     renameThread(threadPath: string, name: string): Promise<void>;
     addAgentMessage(event: AgentMessageEvent): void;
+    private updateSessionState;
+    private updatePendingInputsForMessage;
+    private appendRenderableMessage;
+    private appendMessage;
+    private upsertItemMessage;
+    private appendOrMergeDelta;
+    private indexMessagesFrom;
+    private applyActiveModel;
     markClosed({ notify }?: {
         notify?: boolean;
     }): void;