@meshagent/meshagent-tailwind 0.38.4 → 0.39.1

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

@@ -22,16 +22,52 @@ export interface UseChatThreadResult {
     localParticipantName: string;
     cancelRequest?: () => void;
 }
-export interface ThreadStatus {
-    text: string | null;
-    mode: string | null;
-    startedAt: Date | null;
-    supportsAgentMessages: boolean;
+export declare class PendingAgentMessage {
+    readonly messageId: string;
+    readonly messageType: string;
+    readonly threadPath: string;
+    readonly text: string;
+    readonly attachments: string[];
+    readonly senderName?: string;
+    readonly awaitingAcceptance: boolean;
+    readonly awaitingOnline: boolean;
+    constructor({ messageId, messageType, threadPath, text, attachments, senderName, awaitingAcceptance, awaitingOnline, }: {
+        messageId: string;
+        messageType: string;
+        threadPath: string;
+        text: string;
+        attachments: string[];
+        senderName?: string;
+        awaitingAcceptance?: boolean;
+        awaitingOnline?: boolean;
+    });
+    static fromQueueJson(json: Record<string, unknown>): PendingAgentMessage;
 }
+export declare class ChatThreadStatusState {
+    readonly text?: string;
+    readonly startedAt?: Date;
+    readonly mode?: string;
+    readonly turnId?: string;
+    readonly pendingMessages: PendingAgentMessage[];
+    readonly pendingItemId?: string;
+    readonly supportsAgentMessages: boolean;
+    constructor({ text, startedAt, mode, turnId, pendingMessages, pendingItemId, supportsAgentMessages, }: {
+        text?: string;
+        startedAt?: Date;
+        mode?: string;
+        turnId?: string;
+        pendingMessages?: PendingAgentMessage[];
+        pendingItemId?: string;
+        supportsAgentMessages?: boolean;
+    });
+    get hasStatus(): boolean;
+}
+export type ThreadStatus = ChatThreadStatusState;
 export interface UseThreadStatusProps {
     room: RoomClient;
     path: string;
     agentName?: string;
+    previous?: ChatThreadStatusState;
 }
 export declare function formatThreadStatusText(text: string, startedAt?: Date | null): string;
 export declare function useChatThread({ room, path, participants, participantNames, initialMessage, includeLocalParticipant, agentName, }: UseChatThreadProps): UseChatThreadResult;

package/dist/esm/chat-hooks.js

@@ -4,6 +4,103 @@ import {
 } from "@meshagent/meshagent";
 import { subscribe, useDocumentChanged, useRoomParticipants } from "@meshagent/meshagent-react";
 import { MeshagentFileUpload, fileToAsyncIterable } from "./file-attachment";
+const agentTurnSteerType = "meshagent.agent.turn.steer";
+class PendingAgentMessage {
+  messageId;
+  messageType;
+  threadPath;
+  text;
+  attachments;
+  senderName;
+  awaitingAcceptance;
+  awaitingOnline;
+  constructor({
+    messageId,
+    messageType,
+    threadPath,
+    text,
+    attachments,
+    senderName,
+    awaitingAcceptance = false,
+    awaitingOnline = false
+  }) {
+    this.messageId = messageId;
+    this.messageType = messageType;
+    this.threadPath = threadPath;
+    this.text = text;
+    this.attachments = attachments;
+    this.senderName = senderName;
+    this.awaitingAcceptance = awaitingAcceptance;
+    this.awaitingOnline = awaitingOnline;
+  }
+  static fromQueueJson(json) {
+    const content = json["content"];
+    const textParts = [];
+    const attachments = [];
+    if (Array.isArray(content)) {
+      for (const item of content) {
+        if (item == null || typeof item !== "object") {
+          continue;
+        }
+        const obj = item;
+        const type = obj["type"];
+        if (type === "text") {
+          const text = obj["text"];
+          if (typeof text === "string" && text.trim().length > 0) {
+            textParts.push(text);
+          }
+        } else if (type === "file") {
+          const url = obj["url"];
+          if (typeof url === "string" && url.trim().length > 0) {
+            attachments.push(url);
+          }
+        }
+      }
+    }
+    const senderName = json["sender_name"];
+    const messageType = json["message_type"];
+    const messageId = json["message_id"];
+    const threadPath = json["thread_id"];
+    return new PendingAgentMessage({
+      messageId: typeof messageId === "string" ? messageId : crypto.randomUUID(),
+      messageType: typeof messageType === "string" ? messageType : agentTurnSteerType,
+      threadPath: typeof threadPath === "string" ? threadPath : "",
+      text: textParts.join("\n\n"),
+      attachments,
+      senderName: typeof senderName === "string" && senderName.trim().length > 0 ? senderName.trim() : void 0,
+      awaitingOnline: false
+    });
+  }
+}
+class ChatThreadStatusState {
+  text;
+  startedAt;
+  mode;
+  turnId;
+  pendingMessages;
+  pendingItemId;
+  supportsAgentMessages;
+  constructor({
+    text,
+    startedAt,
+    mode,
+    turnId,
+    pendingMessages = [],
+    pendingItemId,
+    supportsAgentMessages: supportsAgentMessages2 = false
+  }) {
+    this.text = text;
+    this.startedAt = startedAt;
+    this.mode = mode;
+    this.turnId = turnId;
+    this.pendingMessages = pendingMessages;
+    this.pendingItemId = pendingItemId;
+    this.supportsAgentMessages = supportsAgentMessages2;
+  }
+  get hasStatus() {
+    return this.text != null && this.text.trim().length > 0;
+  }
+}
 function getParticipantName(participant) {
   const name = participant.getAttribute("name");
   return typeof name === "string" ? name.trim() : "";
@@ -86,73 +183,161 @@ function threadStatusAttributeCandidates(path, prefix) {
   }
   return [`${prefix}.${path}`, `${prefix}./${path}`];
 }
-function resolveThreadStatus({ room, path, agentName }) {
-  const normalizedAgentName = agentName?.trim();
-  const remoteParticipants = room.messaging.remoteParticipants;
-  const candidates = normalizedAgentName && normalizedAgentName !== "" ? remoteParticipants.filter((participant) => getParticipantName(participant) === normalizedAgentName) : remoteParticipants.filter((participant) => participant.role === "agent" || supportsAgentMessages(participant));
-  const textKeys = threadStatusAttributeCandidates(path, "thread.status.text");
-  const legacyKeys = threadStatusAttributeCandidates(path, "thread.status");
-  const modeKeys = threadStatusAttributeCandidates(path, "thread.status.mode");
-  const startedAtKeys = threadStatusAttributeCandidates(path, "thread.status.started_at");
-  let text = null;
-  let mode = null;
-  let startedAt = null;
-  let hasAgentMessageSupport = false;
+function parsePendingMessagesStatus(participant, path) {
+  for (const key of threadStatusAttributeCandidates(
+    path,
+    "thread.status.pending_messages"
+  )) {
+    const value = participant.getAttribute(key);
+    if (typeof value !== "string" || value.trim().length === 0) {
+      continue;
+    }
+    try {
+      const decoded = JSON.parse(value.trim());
+      if (decoded != null && typeof decoded === "object" && !Array.isArray(decoded)) {
+        return decoded;
+      }
+    } catch (_) {
+    }
+  }
+  return void 0;
+}
+function resolveThreadStatus({
+  room,
+  path,
+  agentName,
+  previous
+}) {
+  const keyCandidates = threadStatusAttributeCandidates(path, "thread.status");
+  const textKeyCandidates = threadStatusAttributeCandidates(path, "thread.status.text");
+  const modeKeyCandidates = threadStatusAttributeCandidates(path, "thread.status.mode");
+  const startedAtKeyCandidates = threadStatusAttributeCandidates(path, "thread.status.started_at");
+  const pendingItemIdKeyCandidates = threadStatusAttributeCandidates(path, "thread.status.pending_item_id");
+  const candidates = agentName != null ? room.messaging.remoteParticipants.filter(
+    (participant) => participant.getAttribute("name") === agentName
+  ) : room.messaging.remoteParticipants.filter(
+    (participant) => participant.role === "agent" || supportsAgentMessages(participant)
+  );
+  let nextStatus;
+  let nextMode;
+  let nextStartedAt;
+  let nextTurnId;
+  let nextPendingMessages = [];
+  let nextPendingItemId;
+  let nextSupportsAgentMessages = false;
   for (const participant of candidates) {
-    hasAgentMessageSupport = hasAgentMessageSupport || supportsAgentMessages(participant);
-    if (text === null) {
-      for (const key of [...textKeys, ...legacyKeys]) {
+    if (supportsAgentMessages(participant)) {
+      nextSupportsAgentMessages = true;
+    }
+    if (nextStatus == null) {
+      for (const key of textKeyCandidates) {
         const value = participant.getAttribute(key);
-        if (typeof value === "string" && value.trim() !== "") {
-          text = value.trim();
+        if (typeof value === "string" && value.trim().length > 0) {
+          nextStatus = value.trim();
           break;
         }
       }
     }
-    if (mode === null) {
-      for (const key of modeKeys) {
+    if (nextStatus == null) {
+      for (const key of keyCandidates) {
         const value = participant.getAttribute(key);
-        if (typeof value !== "string") {
-          continue;
-        }
-        const normalized = value.trim().toLowerCase();
-        if (normalized === "busy" || normalized === "steerable") {
-          mode = normalized;
+        if (typeof value === "string" && value.trim().length > 0) {
+          nextStatus = value.trim();
           break;
         }
       }
     }
-    if (startedAt === null) {
-      for (const key of startedAtKeys) {
+    const pendingStatus = parsePendingMessagesStatus(participant, path);
+    if (pendingStatus != null && typeof pendingStatus === "object") {
+      if (nextTurnId == null) {
+        const turnId = pendingStatus["turn_id"];
+        if (typeof turnId === "string" && turnId.trim().length > 0) {
+          nextTurnId = turnId.trim();
+        }
+      }
+      if (nextPendingMessages.length === 0) {
+        const messages = pendingStatus["messages"];
+        if (Array.isArray(messages)) {
+          nextPendingMessages = messages.flatMap((item) => {
+            if (item != null && typeof item === "object") {
+              return [
+                PendingAgentMessage.fromQueueJson(
+                  item
+                )
+              ];
+            }
+            return [];
+          });
+        }
+      }
+    }
+    if (nextMode == null) {
+      for (const key of modeKeyCandidates) {
+        const value = participant.getAttribute(key);
+        if (typeof value === "string") {
+          const normalized = value.trim().toLowerCase();
+          if (normalized === "busy" || normalized === "steerable") {
+            nextMode = normalized;
+            break;
+          }
+        }
+      }
+    }
+    if (nextStartedAt == null) {
+      for (const key of startedAtKeyCandidates) {
         const value = participant.getAttribute(key);
-        if (typeof value !== "string" || value.trim() === "") {
+        if (typeof value !== "string") {
           continue;
         }
-        const parsed = new Date(value);
+        const normalized = value.trim();
+        if (normalized.length === 0) {
+          continue;
+        }
+        const parsed = new Date(normalized);
         if (!Number.isNaN(parsed.getTime())) {
-          startedAt = parsed;
+          nextStartedAt = parsed;
+          break;
+        }
+      }
+    }
+    if (nextPendingItemId == null) {
+      for (const key of pendingItemIdKeyCandidates) {
+        const value = participant.getAttribute(key);
+        if (typeof value === "string" && value.trim().length > 0) {
+          nextPendingItemId = value.trim();
           break;
         }
       }
     }
+    if (nextStatus != null && nextMode != null && nextStartedAt != null && nextTurnId != null && nextPendingItemId != null) {
+      break;
+    }
   }
-  if (text === null) {
-    return {
-      text: null,
-      mode: null,
-      startedAt: null,
-      supportsAgentMessages: hasAgentMessageSupport
-    };
+  if (nextStatus == null) {
+    return new ChatThreadStatusState({
+      supportsAgentMessages: nextSupportsAgentMessages
+    });
   }
-  return {
-    text,
-    mode: mode ?? "busy",
-    startedAt,
-    supportsAgentMessages: hasAgentMessageSupport
-  };
+  nextMode ??= "busy";
+  nextStartedAt ??= previous?.hasStatus === true ? previous.startedAt : /* @__PURE__ */ new Date();
+  return new ChatThreadStatusState({
+    text: nextStatus,
+    startedAt: nextStartedAt,
+    mode: nextMode,
+    turnId: nextTurnId,
+    pendingMessages: nextPendingMessages,
+    pendingItemId: nextPendingItemId,
+    supportsAgentMessages: nextSupportsAgentMessages
+  });
+}
+function pendingMessagesEqual(left, right) {
+  return left.length === right.length && left.every((message, index) => {
+    const other = right[index];
+    return message.messageId === other.messageId && message.messageType === other.messageType && message.text === other.text && stringArraysEqual(message.attachments, other.attachments) && message.senderName === other.senderName;
+  });
 }
 function threadStatusEquals(left, right) {
-  return left.text === right.text && left.mode === right.mode && left.startedAt?.getTime() === right.startedAt?.getTime() && left.supportsAgentMessages === right.supportsAgentMessages;
+  return left.text === right.text && left.mode === right.mode && left.startedAt?.getTime() === right.startedAt?.getTime() && left.turnId === right.turnId && left.pendingItemId === right.pendingItemId && pendingMessagesEqual(left.pendingMessages, right.pendingMessages) && left.supportsAgentMessages === right.supportsAgentMessages;
 }
 function formatThreadStatusText(text, startedAt) {
   if (!(startedAt instanceof Date) || Number.isNaN(startedAt.getTime())) {
@@ -337,8 +522,15 @@ function useThreadStatus({ room, path, agentName }) {
   const [status, setStatus] = useState(() => resolveThreadStatus({ room, path, agentName }));
   useEffect(() => {
     const updateStatus = () => {
-      const nextStatus = resolveThreadStatus({ room, path, agentName });
-      setStatus((currentStatus) => threadStatusEquals(currentStatus, nextStatus) ? currentStatus : nextStatus);
+      setStatus((currentStatus) => {
+        const nextStatus = resolveThreadStatus({
+          room,
+          path,
+          agentName,
+          previous: currentStatus
+        });
+        return threadStatusEquals(currentStatus, nextStatus) ? currentStatus : nextStatus;
+      });
     };
     const roomSubscription = subscribe(room.listen(), {
       next: (event) => {
@@ -349,23 +541,22 @@ function useThreadStatus({ room, path, agentName }) {
         updateStatus();
       }
     });
-    const handleParticipantsChanged = () => {
-      updateStatus();
-    };
-    room.messaging.on("participant_added", handleParticipantsChanged);
-    room.messaging.on("participant_removed", handleParticipantsChanged);
-    room.messaging.on("messaging_enabled", handleParticipantsChanged);
+    room.messaging.on("participant_added", updateStatus);
+    room.messaging.on("participant_removed", updateStatus);
+    room.messaging.on("messaging_enabled", updateStatus);
     updateStatus();
     return () => {
       roomSubscription.unsubscribe();
-      room.messaging.off("participant_added", handleParticipantsChanged);
-      room.messaging.off("participant_removed", handleParticipantsChanged);
-      room.messaging.off("messaging_enabled", handleParticipantsChanged);
+      room.messaging.off("participant_added", updateStatus);
+      room.messaging.off("participant_removed", updateStatus);
+      room.messaging.off("messaging_enabled", updateStatus);
     };
   }, [agentName, path, room]);
   return status;
 }
 export {
+  ChatThreadStatusState,
+  PendingAgentMessage,
   formatThreadStatusText,
   useChatThread,
   useThreadStatus