@meshagent/meshagent-tailwind 0.38.2 → 0.38.3

package/dist/cjs/chat-hooks.js

@@ -0,0 +1,390 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chat_hooks_exports = {};
+__export(chat_hooks_exports, {
+  formatThreadStatusText: () => formatThreadStatusText,
+  useChatThread: () => useChatThread,
+  useThreadStatus: () => useThreadStatus
+});
+module.exports = __toCommonJS(chat_hooks_exports);
+var import_react = require("react");
+var import_meshagent = require("@meshagent/meshagent");
+var import_meshagent_react = require("@meshagent/meshagent-react");
+var import_file_attachment = require("./file-attachment");
+function getParticipantName(participant) {
+  const name = participant.getAttribute("name");
+  return typeof name === "string" ? name.trim() : "";
+}
+function matchesParticipantName(participant, participantName) {
+  const normalizedParticipantName = participantName?.trim();
+  if (!normalizedParticipantName) {
+    return true;
+  }
+  return getParticipantName(participant) === normalizedParticipantName;
+}
+function ensureParticipants(document, localParticipant, includeLocalParticipant, participants, participantNames) {
+  const nextParticipants = [
+    ...participants,
+    ...includeLocalParticipant ? [localParticipant] : []
+  ];
+  const existing = /* @__PURE__ */ new Set();
+  const children = document.root.getChildren();
+  for (const child of children) {
+    if (child.tagName !== "members") {
+      continue;
+    }
+    const members = child.getChildren();
+    for (const member of members) {
+      const name = getParticipantName(member);
+      if (name !== "") {
+        existing.add(name);
+      }
+    }
+    for (const participant of nextParticipants) {
+      const name = getParticipantName(participant);
+      if (name !== "" && !existing.has(name)) {
+        child.createChildElement("member", { name });
+        existing.add(name);
+      }
+    }
+    for (const name of participantNames) {
+      const trimmed = name.trim();
+      if (trimmed !== "" && !existing.has(trimmed)) {
+        child.createChildElement("member", { name: trimmed });
+        existing.add(trimmed);
+      }
+    }
+  }
+}
+function mapThreadElements(document) {
+  const children = document.root.getChildren();
+  const thread = children.find((child) => child.tagName === "messages");
+  return [...thread?.getChildren() ?? []];
+}
+function getDocumentParticipantNames(document) {
+  const children = document.root.getChildren();
+  const membersElement = children.find((child) => child.tagName === "members");
+  const members = membersElement?.getChildren() ?? [];
+  const participantNames = [];
+  for (const member of members) {
+    const name = getParticipantName(member);
+    if (name !== "") {
+      participantNames.push(name);
+    }
+  }
+  return participantNames;
+}
+function stringArraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function getOnlineParticipants(roomParticipants, participantNames) {
+  const participantSet = new Set(participantNames);
+  return Array.from(roomParticipants).filter((participant) => {
+    const name = getParticipantName(participant);
+    return name !== "" && participantSet.has(name);
+  });
+}
+function supportsAgentMessages(participant) {
+  return participant.getAttribute("supports_agent_messages") === true;
+}
+function threadStatusAttributeCandidates(path, prefix) {
+  if (path.startsWith("/")) {
+    return [`${prefix}.${path}`, `${prefix}.${path.slice(1)}`];
+  }
+  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;
+  for (const participant of candidates) {
+    hasAgentMessageSupport = hasAgentMessageSupport || supportsAgentMessages(participant);
+    if (text === null) {
+      for (const key of [...textKeys, ...legacyKeys]) {
+        const value = participant.getAttribute(key);
+        if (typeof value === "string" && value.trim() !== "") {
+          text = value.trim();
+          break;
+        }
+      }
+    }
+    if (mode === null) {
+      for (const key of modeKeys) {
+        const value = participant.getAttribute(key);
+        if (typeof value !== "string") {
+          continue;
+        }
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "busy" || normalized === "steerable") {
+          mode = normalized;
+          break;
+        }
+      }
+    }
+    if (startedAt === null) {
+      for (const key of startedAtKeys) {
+        const value = participant.getAttribute(key);
+        if (typeof value !== "string" || value.trim() === "") {
+          continue;
+        }
+        const parsed = new Date(value);
+        if (!Number.isNaN(parsed.getTime())) {
+          startedAt = parsed;
+          break;
+        }
+      }
+    }
+  }
+  if (text === null) {
+    return {
+      text: null,
+      mode: null,
+      startedAt: null,
+      supportsAgentMessages: hasAgentMessageSupport
+    };
+  }
+  return {
+    text,
+    mode: mode ?? "busy",
+    startedAt,
+    supportsAgentMessages: hasAgentMessageSupport
+  };
+}
+function threadStatusEquals(left, right) {
+  return left.text === right.text && left.mode === right.mode && left.startedAt?.getTime() === right.startedAt?.getTime() && left.supportsAgentMessages === right.supportsAgentMessages;
+}
+function formatThreadStatusText(text, startedAt) {
+  if (!(startedAt instanceof Date) || Number.isNaN(startedAt.getTime())) {
+    return text;
+  }
+  const elapsedSeconds = Math.max(0, Math.floor((Date.now() - startedAt.getTime()) / 1e3));
+  return elapsedSeconds === 0 ? text : `${text} (${elapsedSeconds}s)`;
+}
+function getRetryDelayMs(retryCount) {
+  return Math.min(6e4, 500 * 2 ** retryCount);
+}
+async function closeDocument(room, path) {
+  try {
+    await room.sync.close(path);
+  } catch {
+  }
+}
+function useChatThread({
+  room,
+  path,
+  participants,
+  participantNames,
+  initialMessage,
+  includeLocalParticipant,
+  agentName
+}) {
+  const [document, setDocument] = (0, import_react.useState)(null);
+  const [messages, setMessages] = (0, import_react.useState)(() => document ? mapThreadElements(document) : []);
+  const [attachments, setAttachments] = (0, import_react.useState)([]);
+  const [documentParticipantNames, setDocumentParticipantNames] = (0, import_react.useState)(() => document ? getDocumentParticipantNames(document) : []);
+  const initialMessageSentRef = (0, import_react.useRef)(false);
+  const syncDocumentState = (0, import_react.useCallback)((nextDocument) => {
+    const nextMessages = mapThreadElements(nextDocument);
+    const nextParticipantNames = getDocumentParticipantNames(nextDocument);
+    setMessages(nextMessages);
+    setDocumentParticipantNames((current) => stringArraysEqual(current, nextParticipantNames) ? current : nextParticipantNames);
+  }, []);
+  (0, import_react.useEffect)(() => {
+    let cancelled = false;
+    let opened = false;
+    let retryCount = 0;
+    setDocument(null);
+    setMessages([]);
+    setDocumentParticipantNames([]);
+    initialMessageSentRef.current = false;
+    void (async () => {
+      while (!cancelled) {
+        try {
+          const nextDocument = await room.sync.open(path);
+          if (cancelled) {
+            await closeDocument(room, path);
+            return;
+          }
+          opened = true;
+          setDocument(nextDocument);
+          syncDocumentState(nextDocument);
+          return;
+        } catch (error) {
+          if (cancelled) {
+            return;
+          }
+          setDocument(null);
+          setMessages([]);
+          setDocumentParticipantNames([]);
+          console.error("Failed to open document:", error);
+          await new Promise((resolve) => {
+            window.setTimeout(resolve, getRetryDelayMs(retryCount));
+          });
+          retryCount += 1;
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+      if (opened) {
+        void closeDocument(room, path);
+      }
+    };
+  }, [path, room, syncDocumentState]);
+  (0, import_react.useEffect)(() => {
+    if (!document || !room.localParticipant) {
+      return;
+    }
+    ensureParticipants(
+      document,
+      room.localParticipant,
+      includeLocalParticipant ?? true,
+      participants ?? [],
+      participantNames ?? []
+    );
+    setDocumentParticipantNames((current) => {
+      const nextParticipantNames = getDocumentParticipantNames(document);
+      return stringArraysEqual(current, nextParticipantNames) ? current : nextParticipantNames;
+    });
+  }, [document, includeLocalParticipant, participantNames, participants, room.localParticipant]);
+  (0, import_meshagent_react.useDocumentChanged)({
+    document,
+    onChanged: syncDocumentState
+  });
+  const selectAttachments = (0, import_react.useCallback)((files) => {
+    const nextAttachments = files.map((file) => new import_file_attachment.MeshagentFileUpload(
+      room,
+      `uploaded-files/${file.name}`,
+      (0, import_file_attachment.fileToAsyncIterable)(file),
+      file.size
+    ));
+    setAttachments((current) => [...current, ...nextAttachments]);
+  }, [room]);
+  const roomParticipants = (0, import_meshagent_react.useRoomParticipants)(room);
+  const onlineParticipants = (0, import_react.useMemo)(
+    () => getOnlineParticipants(roomParticipants, documentParticipantNames),
+    [roomParticipants, documentParticipantNames]
+  );
+  const sendMessage = (0, import_react.useCallback)((message) => {
+    const children = document?.root.getChildren() ?? [];
+    const thread = children.find((child) => child.tagName === "messages");
+    if (!thread) {
+      return;
+    }
+    const authorName = getParticipantName(room.localParticipant);
+    const messageElement = thread.createChildElement("message", {
+      id: message.id,
+      text: message.text,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      author_name: authorName,
+      author_ref: null
+    });
+    for (const attachmentPath of message.attachments) {
+      messageElement.createChildElement("file", { path: attachmentPath });
+    }
+    for (const participant of onlineParticipants) {
+      if (!matchesParticipantName(participant, agentName)) {
+        continue;
+      }
+      room.messaging.sendMessage({
+        to: participant,
+        type: "chat",
+        message: {
+          path,
+          text: message.text,
+          attachments: message.attachments.map((attachmentPath) => ({ path: attachmentPath }))
+        }
+      });
+    }
+  }, [agentName, document, onlineParticipants, path, room]);
+  (0, import_react.useEffect)(() => {
+    if (!document || !initialMessage || initialMessageSentRef.current) {
+      return;
+    }
+    initialMessageSentRef.current = true;
+    sendMessage(initialMessage);
+  }, [document, initialMessage, sendMessage]);
+  const cancelRequest = (0, import_react.useCallback)(() => {
+    for (const participant of onlineParticipants) {
+      if (!matchesParticipantName(participant, agentName)) {
+        continue;
+      }
+      if (participant.role !== "agent") {
+        continue;
+      }
+      room.messaging.sendMessage({
+        to: participant,
+        type: "cancel",
+        message: { path }
+      });
+    }
+  }, [agentName, onlineParticipants, path, room]);
+  return {
+    document,
+    messages,
+    sendMessage,
+    selectAttachments,
+    attachments,
+    setAttachments,
+    schemaFileExists: true,
+    onlineParticipants,
+    localParticipantName: room.localParticipant ? getParticipantName(room.localParticipant) : "",
+    cancelRequest
+  };
+}
+function useThreadStatus({ room, path, agentName }) {
+  const [status, setStatus] = (0, import_react.useState)(() => resolveThreadStatus({ room, path, agentName }));
+  (0, import_react.useEffect)(() => {
+    const updateStatus = () => {
+      const nextStatus = resolveThreadStatus({ room, path, agentName });
+      setStatus((currentStatus) => threadStatusEquals(currentStatus, nextStatus) ? currentStatus : nextStatus);
+    };
+    const roomSubscription = (0, import_meshagent_react.subscribe)(room.listen(), {
+      next: (event) => {
+        if (event instanceof import_meshagent.RoomMessageEvent) {
+          updateStatus();
+          return;
+        }
+        updateStatus();
+      }
+    });
+    const handleParticipantsChanged = () => {
+      updateStatus();
+    };
+    room.messaging.on("participant_added", handleParticipantsChanged);
+    room.messaging.on("participant_removed", handleParticipantsChanged);
+    room.messaging.on("messaging_enabled", handleParticipantsChanged);
+    updateStatus();
+    return () => {
+      roomSubscription.unsubscribe();
+      room.messaging.off("participant_added", handleParticipantsChanged);
+      room.messaging.off("participant_removed", handleParticipantsChanged);
+      room.messaging.off("messaging_enabled", handleParticipantsChanged);
+    };
+  }, [agentName, path, room]);
+  return status;
+}

package/dist/cjs/chat-message.d.ts

@@ -0,0 +1,11 @@
+export interface ChatMessageArgs {
+    id: string;
+    text: string;
+    attachments?: string[];
+}
+export declare class ChatMessage {
+    id: string;
+    text: string;
+    attachments: string[];
+    constructor({ id, text, attachments }: ChatMessageArgs);
+}

package/dist/cjs/chat-message.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chat_message_exports = {};
+__export(chat_message_exports, {
+  ChatMessage: () => ChatMessage
+});
+module.exports = __toCommonJS(chat_message_exports);
+class ChatMessage {
+  id;
+  text;
+  attachments;
+  constructor({ id, text, attachments }) {
+    this.id = id;
+    this.text = text;
+    this.attachments = attachments ?? [];
+  }
+}

package/dist/cjs/components/ui/button.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
     size?: "default" | "sm" | "lg" | "icon" | null | undefined;
 } & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
 declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {

package/dist/cjs/conversation-descriptor.d.ts

@@ -0,0 +1,59 @@
+import type { Participant, RemoteParticipant, ServiceSpec } from "@meshagent/meshagent";
+export declare const defaultUntitledThreadName = "New Chat";
+export declare enum ChatAgentConversationKind {
+    Chat = 0,
+    VoiceOnly = 1,
+    Meeting = 2
+}
+export declare enum ChatThreadDisplayMode {
+    SingleThread = 0,
+    MultiThreadComposer = 1
+}
+export declare class ChatAgentConversationDescriptor {
+    private constructor();
+    static chat({ chatThreadDisplayMode, threadDir, threadListPath, }?: {
+        chatThreadDisplayMode?: ChatThreadDisplayMode;
+        threadDir?: string | null;
+        threadListPath?: string | null;
+    }): ChatAgentConversationDescriptor;
+    static voiceOnly(): ChatAgentConversationDescriptor;
+    static meeting(): ChatAgentConversationDescriptor;
+    readonly kind: ChatAgentConversationKind;
+    readonly chatThreadDisplayMode: ChatThreadDisplayMode;
+    readonly threadDir: string | null;
+    readonly threadListPath: string | null;
+    get isChat(): boolean;
+    get isVoiceOnly(): boolean;
+    get isMeeting(): boolean;
+    get isMultiThreadChat(): boolean;
+}
+export declare function participantDisplayName(participant: RemoteParticipant): string | null;
+export declare function participantSupportsVoice(participant: RemoteParticipant): boolean;
+export declare function participantSupportsChatOverride(participant: RemoteParticipant): boolean | null;
+export declare function participantSupportsChat(participant: RemoteParticipant): boolean;
+export declare function normalizedAnnotationString(value: unknown): string | null;
+export declare function chatThreadDisplayModeFromAnnotation(value: unknown): ChatThreadDisplayMode;
+export declare function normalizedThreadDir(threadDir?: string | null): string | null;
+export declare function participantThreadDir(participant: RemoteParticipant): string | null;
+export declare function participantThreadListPath(participant: RemoteParticipant): string | null;
+export declare function participantConversationDescriptor(participant: RemoteParticipant): ChatAgentConversationDescriptor | null;
+export declare function serviceThreadDir(service: ServiceSpec): string | null;
+export declare function serviceThreadListPath(service: ServiceSpec, { remoteParticipants }?: {
+    remoteParticipants?: Iterable<RemoteParticipant>;
+}): string | null;
+export declare function serviceConversationDescriptor(service: ServiceSpec, { remoteParticipants }?: {
+    remoteParticipants?: Iterable<RemoteParticipant>;
+}): ChatAgentConversationDescriptor | null;
+export declare function conversationDescriptorForParticipant(participant: Participant, { services, remoteParticipants, }: {
+    services: Iterable<ServiceSpec>;
+    remoteParticipants: Iterable<RemoteParticipant>;
+}): ChatAgentConversationDescriptor | null;
+export declare function resolvedThreadListPath(threadListPath?: string | null, { threadDir, agentName, }?: {
+    threadDir?: string | null;
+    agentName?: string | null;
+}): string | null;
+export declare function chatDocumentPath(agentName?: string | null, { threadDir, fallbackPath, }?: {
+    threadDir?: string | null;
+    fallbackPath?: string;
+}): string;
+export declare function defaultThreadDisplayNameFromPath(path: string): string;