@meshagent/meshagent-tailwind 0.38.2 → 0.38.3

package/dist/esm/conversation-descriptor.js

@@ -0,0 +1,280 @@
+import { RemoteParticipant as MeshagentRemoteParticipant } from "@meshagent/meshagent";
+const defaultUntitledThreadName = "New Chat";
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+var ChatAgentConversationKind = /* @__PURE__ */ ((ChatAgentConversationKind2) => {
+  ChatAgentConversationKind2[ChatAgentConversationKind2["Chat"] = 0] = "Chat";
+  ChatAgentConversationKind2[ChatAgentConversationKind2["VoiceOnly"] = 1] = "VoiceOnly";
+  ChatAgentConversationKind2[ChatAgentConversationKind2["Meeting"] = 2] = "Meeting";
+  return ChatAgentConversationKind2;
+})(ChatAgentConversationKind || {});
+var ChatThreadDisplayMode = /* @__PURE__ */ ((ChatThreadDisplayMode2) => {
+  ChatThreadDisplayMode2[ChatThreadDisplayMode2["SingleThread"] = 0] = "SingleThread";
+  ChatThreadDisplayMode2[ChatThreadDisplayMode2["MultiThreadComposer"] = 1] = "MultiThreadComposer";
+  return ChatThreadDisplayMode2;
+})(ChatThreadDisplayMode || {});
+class ChatAgentConversationDescriptor {
+  constructor({
+    kind,
+    chatThreadDisplayMode = 0 /* SingleThread */,
+    threadDir = null,
+    threadListPath = null
+  }) {
+    this.kind = kind;
+    this.chatThreadDisplayMode = chatThreadDisplayMode;
+    this.threadDir = threadDir;
+    this.threadListPath = threadListPath;
+  }
+  static chat({
+    chatThreadDisplayMode = 0 /* SingleThread */,
+    threadDir = null,
+    threadListPath = null
+  } = {}) {
+    return new ChatAgentConversationDescriptor({
+      kind: 0 /* Chat */,
+      chatThreadDisplayMode,
+      threadDir,
+      threadListPath
+    });
+  }
+  static voiceOnly() {
+    return new ChatAgentConversationDescriptor({
+      kind: 1 /* VoiceOnly */
+    });
+  }
+  static meeting() {
+    return new ChatAgentConversationDescriptor({
+      kind: 2 /* Meeting */
+    });
+  }
+  kind;
+  chatThreadDisplayMode;
+  threadDir;
+  threadListPath;
+  get isChat() {
+    return this.kind === 0 /* Chat */;
+  }
+  get isVoiceOnly() {
+    return this.kind === 1 /* VoiceOnly */;
+  }
+  get isMeeting() {
+    return this.kind === 2 /* Meeting */;
+  }
+  get isMultiThreadChat() {
+    return this.isChat && this.chatThreadDisplayMode === 1 /* MultiThreadComposer */;
+  }
+}
+function firstAgent(service) {
+  return service.agents?.[0] ?? null;
+}
+function defaultThreadDocumentDir(agentName) {
+  const trimmed = agentName?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  return `.threads/${trimmed}`;
+}
+function threadListPathFromThreadDir(threadDir) {
+  const normalized = normalizedThreadDir(threadDir);
+  if (normalized === null) {
+    return null;
+  }
+  return `${normalized}/index.threadl`;
+}
+function basename(path) {
+  const segments = path.split("/");
+  return segments[segments.length - 1] ?? path;
+}
+function participantDisplayName(participant) {
+  return normalizedAnnotationString(participant.getAttribute("name"));
+}
+function participantSupportsVoice(participant) {
+  return participant.getAttribute("supports_voice") === true;
+}
+function participantSupportsChatOverride(participant) {
+  const value = participant.getAttribute("supports_chat");
+  return typeof value === "boolean" ? value : null;
+}
+function participantSupportsChat(participant) {
+  return participantSupportsChatOverride(participant) ?? true;
+}
+function normalizedAnnotationString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized === "" ? null : normalized;
+}
+function chatThreadDisplayModeFromAnnotation(value) {
+  return normalizedAnnotationString(value) === "default-new" ? 1 /* MultiThreadComposer */ : 0 /* SingleThread */;
+}
+function normalizedThreadDir(threadDir) {
+  const trimmed = threadDir?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.replace(/\/+$/u, "");
+}
+function participantThreadDir(participant) {
+  return normalizedThreadDir(normalizedAnnotationString(participant.getAttribute("meshagent.chatbot.thread-dir")));
+}
+function participantThreadListPath(participant) {
+  const threadListPath = normalizedAnnotationString(participant.getAttribute("meshagent.chatbot.thread-list"));
+  return threadListPath ?? threadListPathFromThreadDir(participantThreadDir(participant));
+}
+function participantConversationDescriptor(participant) {
+  const supportsVoice = participantSupportsVoice(participant);
+  const supportsChat = participantSupportsChatOverride(participant);
+  const threadDir = participantThreadDir(participant);
+  const threadListPath = participantThreadListPath(participant);
+  const hasThreadAnnotations = normalizedAnnotationString(participant.getAttribute("meshagent.chatbot.threading")) !== null || threadDir !== null || threadListPath !== null;
+  if (supportsChat === false) {
+    return supportsVoice ? ChatAgentConversationDescriptor.voiceOnly() : null;
+  }
+  if (supportsVoice && supportsChat !== true && !hasThreadAnnotations) {
+    return ChatAgentConversationDescriptor.voiceOnly();
+  }
+  if (hasThreadAnnotations || participantSupportsChat(participant)) {
+    return ChatAgentConversationDescriptor.chat({
+      chatThreadDisplayMode: chatThreadDisplayModeFromAnnotation(
+        participant.getAttribute("meshagent.chatbot.threading")
+      ),
+      threadDir,
+      threadListPath
+    });
+  }
+  if (supportsVoice) {
+    return ChatAgentConversationDescriptor.voiceOnly();
+  }
+  return null;
+}
+function serviceThreadDir(service) {
+  return normalizedThreadDir(firstAgent(service)?.annotations?.["meshagent.chatbot.thread-dir"]);
+}
+function serviceThreadListPath(service, { remoteParticipants = [] } = {}) {
+  const annotationPath = normalizedAnnotationString(
+    firstAgent(service)?.annotations?.["meshagent.chatbot.thread-list"]
+  );
+  if (annotationPath !== null) {
+    return annotationPath;
+  }
+  const threadDir = serviceThreadDir(service);
+  const threadListPath = threadListPathFromThreadDir(threadDir);
+  if (threadListPath !== null) {
+    return threadListPath;
+  }
+  const agentName = firstAgent(service)?.name;
+  if (!agentName || agentName.trim() === "") {
+    return null;
+  }
+  for (const participant of remoteParticipants) {
+    if (participant.getAttribute("name") === agentName) {
+      return participantThreadListPath(participant);
+    }
+  }
+  return null;
+}
+function serviceConversationDescriptor(service, { remoteParticipants = [] } = {}) {
+  const type = firstAgent(service)?.annotations?.["meshagent.agent.type"];
+  if (type === "VoiceBot") {
+    return ChatAgentConversationDescriptor.voiceOnly();
+  }
+  if (type === "MeetingTranscriber") {
+    return ChatAgentConversationDescriptor.meeting();
+  }
+  if (type !== "ChatBot") {
+    return null;
+  }
+  return ChatAgentConversationDescriptor.chat({
+    chatThreadDisplayMode: chatThreadDisplayModeFromAnnotation(
+      firstAgent(service)?.annotations?.["meshagent.chatbot.threading"]
+    ),
+    threadDir: serviceThreadDir(service),
+    threadListPath: serviceThreadListPath(service, { remoteParticipants })
+  });
+}
+function conversationDescriptorForParticipant(participant, {
+  services,
+  remoteParticipants
+}) {
+  if (!(participant instanceof MeshagentRemoteParticipant)) {
+    return null;
+  }
+  const displayName = participantDisplayName(participant);
+  if (displayName !== null) {
+    for (const service of services) {
+      if (firstAgent(service)?.name !== displayName) {
+        continue;
+      }
+      const descriptor = serviceConversationDescriptor(service, { remoteParticipants });
+      if (descriptor !== null) {
+        return descriptor;
+      }
+    }
+  }
+  return participantConversationDescriptor(participant);
+}
+function resolvedThreadListPath(threadListPath, {
+  threadDir,
+  agentName
+} = {}) {
+  const normalizedPath = normalizedAnnotationString(threadListPath);
+  if (normalizedPath !== null) {
+    return normalizedPath;
+  }
+  const normalizedDir = normalizedThreadDir(threadDir);
+  if (normalizedDir !== null) {
+    return `${normalizedDir}/index.threadl`;
+  }
+  const defaultThreadDir = defaultThreadDocumentDir(agentName);
+  return defaultThreadDir === null ? null : `${defaultThreadDir}/index.threadl`;
+}
+function chatDocumentPath(agentName, {
+  threadDir,
+  fallbackPath = ".threads/main.thread"
+} = {}) {
+  const normalizedDir = normalizedThreadDir(threadDir);
+  if (normalizedDir !== null) {
+    return `${normalizedDir}/main.thread`;
+  }
+  const defaultThreadDir = defaultThreadDocumentDir(agentName);
+  if (defaultThreadDir !== null) {
+    return `${defaultThreadDir}/main.thread`;
+  }
+  return fallbackPath;
+}
+function defaultThreadDisplayNameFromPath(path) {
+  const basenamePath = basename(path);
+  const rawName = basenamePath.endsWith(".thread") ? basenamePath.slice(0, -".thread".length) : basenamePath;
+  const trimmed = rawName.trim();
+  if (!trimmed || uuidPattern.test(trimmed)) {
+    return defaultUntitledThreadName;
+  }
+  const normalized = trimmed.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim();
+  if (!normalized) {
+    return defaultUntitledThreadName;
+  }
+  return normalized.split(" ").filter((segment) => segment !== "").map((segment) => segment.length === 1 ? segment.toUpperCase() : `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`).join(" ");
+}
+export {
+  ChatAgentConversationDescriptor,
+  ChatAgentConversationKind,
+  ChatThreadDisplayMode,
+  chatDocumentPath,
+  chatThreadDisplayModeFromAnnotation,
+  conversationDescriptorForParticipant,
+  defaultThreadDisplayNameFromPath,
+  defaultUntitledThreadName,
+  normalizedAnnotationString,
+  normalizedThreadDir,
+  participantConversationDescriptor,
+  participantDisplayName,
+  participantSupportsChat,
+  participantSupportsChatOverride,
+  participantSupportsVoice,
+  participantThreadDir,
+  participantThreadListPath,
+  resolvedThreadListPath,
+  serviceConversationDescriptor,
+  serviceThreadDir,
+  serviceThreadListPath
+};

package/dist/esm/file-attachment.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter, RoomClient } from "@meshagent/meshagent";
+export declare enum UploadStatus {
+    Initial = "initial",
+    Uploading = "uploading",
+    Completed = "completed",
+    Failed = "failed"
+}
+export declare abstract class FileAttachment extends EventEmitter<void> {
+    protected _status: UploadStatus;
+    path: string;
+    protected constructor({ path, initialStatus, }: {
+        path: string;
+        initialStatus?: UploadStatus;
+    });
+    get status(): UploadStatus;
+    protected set status(value: UploadStatus);
+    protected notifyChange(): void;
+    get filename(): string;
+    get size(): number;
+    get bytesUploaded(): number;
+}
+export type FileUpload = FileAttachment;
+export declare class MeshagentFileUpload extends FileAttachment {
+    readonly room: RoomClient;
+    readonly dataStream: AsyncIterable<Uint8Array>;
+    private readonly _done;
+    private readonly _downloadUrl;
+    private _resolveDone;
+    private _rejectDone;
+    private _resolveDownloadUrl;
+    private _rejectDownloadUrl;
+    private _bytesUploaded;
+    private _size;
+    constructor(room: RoomClient, path: string, dataStream: AsyncIterable<Uint8Array>, size?: number, autoStart?: boolean);
+    static deferred(room: RoomClient, path: string, dataStream: AsyncIterable<Uint8Array>, size?: number): MeshagentFileUpload;
+    get bytesUploaded(): number;
+    get size(): number;
+    set size(value: number);
+    get done(): Promise<void>;
+    get downloadUrl(): Promise<URL>;
+    startUpload(): void;
+    private _upload;
+    private _trackedStream;
+}
+export declare function fileToAsyncIterable(file: Blob): AsyncIterable<Uint8Array>;

package/dist/esm/file-attachment.js

@@ -0,0 +1,151 @@
+import { EventEmitter } from "@meshagent/meshagent";
+var UploadStatus = /* @__PURE__ */ ((UploadStatus2) => {
+  UploadStatus2["Initial"] = "initial";
+  UploadStatus2["Uploading"] = "uploading";
+  UploadStatus2["Completed"] = "completed";
+  UploadStatus2["Failed"] = "failed";
+  return UploadStatus2;
+})(UploadStatus || {});
+class FileAttachment extends EventEmitter {
+  _status;
+  path;
+  constructor({
+    path,
+    initialStatus = "initial" /* Initial */
+  }) {
+    super();
+    this.path = path;
+    this._status = initialStatus;
+  }
+  get status() {
+    return this._status;
+  }
+  set status(value) {
+    if (this._status !== value) {
+      this._status = value;
+      this.notifyChange();
+    }
+  }
+  notifyChange() {
+    this.emit("change", void 0);
+  }
+  get filename() {
+    return this.path.split("/").pop() ?? "";
+  }
+  get size() {
+    return 0;
+  }
+  get bytesUploaded() {
+    return 0;
+  }
+}
+class MeshagentFileUpload extends FileAttachment {
+  room;
+  dataStream;
+  _done;
+  _downloadUrl;
+  _resolveDone;
+  _rejectDone;
+  _resolveDownloadUrl;
+  _rejectDownloadUrl;
+  _bytesUploaded = 0;
+  _size;
+  constructor(room, path, dataStream, size = 0, autoStart = true) {
+    super({ path });
+    this.room = room;
+    this.dataStream = dataStream;
+    this._size = size;
+    this._done = new Promise((resolve, reject) => {
+      this._resolveDone = resolve;
+      this._rejectDone = reject;
+    });
+    this._downloadUrl = new Promise((resolve, reject) => {
+      this._resolveDownloadUrl = resolve;
+      this._rejectDownloadUrl = reject;
+    });
+    if (autoStart) {
+      this.startUpload();
+    }
+  }
+  static deferred(room, path, dataStream, size = 0) {
+    return new MeshagentFileUpload(room, path, dataStream, size, false);
+  }
+  get bytesUploaded() {
+    return this._bytesUploaded;
+  }
+  get size() {
+    return this._size;
+  }
+  set size(value) {
+    this._size = value;
+  }
+  get done() {
+    return this._done;
+  }
+  get downloadUrl() {
+    return this._downloadUrl;
+  }
+  startUpload() {
+    if (this.status !== "initial" /* Initial */) {
+      throw new Error("upload already started or completed");
+    }
+    void this._upload();
+  }
+  async _upload() {
+    try {
+      this.status = "uploading" /* Uploading */;
+      const trackedStream = this._trackedStream();
+      await this.room.storage.uploadStream(this.path, trackedStream, {
+        overwrite: true,
+        size: this.size > 0 ? this.size : null
+      });
+      this._resolveDone();
+      this.status = "completed" /* Completed */;
+      const url = await this.room.storage.downloadUrl(this.path);
+      this._resolveDownloadUrl(new URL(url));
+    } catch (error) {
+      this.status = "failed" /* Failed */;
+      this._rejectDone(error);
+      this._rejectDownloadUrl(error);
+    }
+  }
+  async *_trackedStream() {
+    for await (const chunk of this.dataStream) {
+      yield chunk;
+      this._bytesUploaded += chunk.length;
+      this.notifyChange();
+    }
+  }
+}
+async function* fileToAsyncIterable(file) {
+  const chunkSize = 64 * 1024;
+  if (typeof file.stream === "function") {
+    const reader = file.stream().getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          return;
+        }
+        if (value != null) {
+          yield value;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  let offset = 0;
+  while (offset < file.size) {
+    const chunk = file.slice(offset, offset + chunkSize);
+    const buffer = await chunk.arrayBuffer();
+    yield new Uint8Array(buffer);
+    offset += chunkSize;
+  }
+}
+export {
+  FileAttachment,
+  MeshagentFileUpload,
+  UploadStatus,
+  fileToAsyncIterable
+};

package/dist/esm/index.d.ts

@@ -1,5 +1,10 @@
 export * from './Chat';
+export * from './ChatBotView';
 export * from './ChatInput';
 export * from './ChatThread';
 export * from './ChatTypingIndicator';
 export * from './FileUploader';
+export * from './chat-message';
+export * from './conversation-descriptor';
+export * from './file-attachment';
+export * from './multi-thread-view';

package/dist/esm/index.js

@@ -1,5 +1,10 @@
 export * from "./Chat";
+export * from "./ChatBotView";
 export * from "./ChatInput";
 export * from "./ChatThread";
 export * from "./ChatTypingIndicator";
 export * from "./FileUploader";
+export * from "./chat-message";
+export * from "./conversation-descriptor";
+export * from "./file-attachment";
+export * from "./multi-thread-view";

package/dist/esm/multi-thread-view.d.ts

@@ -0,0 +1,18 @@
+import type { ReactElement } from "react";
+import { RoomClient } from "@meshagent/meshagent";
+export type MultiThreadContentBuilder = (threadPath: string) => ReactElement;
+export interface MultiThreadViewProps {
+    room: RoomClient;
+    agentName: string;
+    builder: MultiThreadContentBuilder;
+    toolkit?: string;
+    tool?: string;
+    selectedThreadPath?: string | null;
+    onSelectedThreadPathChanged?: (path: string | null) => void;
+    onSelectedThreadResolved?: (path: string | null, displayName: string | null) => void;
+    newThreadResetVersion?: number;
+    centerComposer?: boolean;
+    emptyStateTitle?: string;
+    emptyStateDescription?: string;
+}
+export declare function MultiThreadView({ room, agentName, builder, toolkit, tool, selectedThreadPath, onSelectedThreadPathChanged, onSelectedThreadResolved, newThreadResetVersion, centerComposer, emptyStateTitle, emptyStateDescription, }: MultiThreadViewProps): ReactElement;

package/dist/esm/multi-thread-view.js

@@ -0,0 +1,68 @@
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { Chat } from "./Chat";
+function normalizeSelectedThreadPath(path) {
+  const normalized = path?.trim();
+  return normalized ? normalized : null;
+}
+function MultiThreadView({
+  room,
+  agentName,
+  builder,
+  toolkit = "chat",
+  tool = "new_thread",
+  selectedThreadPath,
+  onSelectedThreadPathChanged,
+  onSelectedThreadResolved,
+  newThreadResetVersion = 0,
+  centerComposer = true,
+  emptyStateTitle,
+  emptyStateDescription
+}) {
+  const controlledSelectedThreadPath = selectedThreadPath !== void 0 ? normalizeSelectedThreadPath(selectedThreadPath) : void 0;
+  const [internalSelectedThreadPath, setInternalSelectedThreadPath] = useState(() => controlledSelectedThreadPath ?? null);
+  useEffect(() => {
+    if (controlledSelectedThreadPath === void 0) {
+      return;
+    }
+    setInternalSelectedThreadPath(controlledSelectedThreadPath);
+  }, [controlledSelectedThreadPath]);
+  useEffect(() => {
+    if (controlledSelectedThreadPath !== void 0) {
+      return;
+    }
+    setInternalSelectedThreadPath(null);
+  }, [agentName, controlledSelectedThreadPath, room]);
+  const activeSelectedThreadPath = controlledSelectedThreadPath ?? internalSelectedThreadPath;
+  const composerKey = useMemo(
+    () => `new-thread-${agentName.trim()}-${newThreadResetVersion}`,
+    [agentName, newThreadResetVersion]
+  );
+  if (activeSelectedThreadPath !== null) {
+    return builder(activeSelectedThreadPath);
+  }
+  return /* @__PURE__ */ jsx(
+    Chat,
+    {
+      room,
+      agentName,
+      toolkit,
+      tool,
+      centerComposer,
+      emptyStateTitle,
+      emptyStateDescription,
+      onThreadResolved: (path, displayName) => {
+        const normalizedPath = normalizeSelectedThreadPath(path);
+        if (controlledSelectedThreadPath === void 0) {
+          setInternalSelectedThreadPath(normalizedPath);
+        }
+        onSelectedThreadPathChanged?.(normalizedPath);
+        onSelectedThreadResolved?.(normalizedPath, displayName);
+      }
+    },
+    composerKey
+  );
+}
+export {
+  MultiThreadView
+};

package/dist/esm/tools/ui-toolkit.d.ts

@@ -1,4 +1,4 @@
-import { Toolkit } from '@meshagent/meshagent';
+import { Toolkit } from "@meshagent/meshagent";
 export declare class UIToolkit extends Toolkit {
     constructor();
 }

package/dist/esm/tools/ui-toolkit.js

@@ -14,7 +14,8 @@ class UIToolkit extends Toolkit {
         new AskUserForFile(),
         new Toast(),
         new DisplayDocument()
-      ]
+      ],
+      rules: []
     });
   }
 }