@meshagent/meshagent-tailwind 0.39.4 → 0.39.6

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.39.6]
+- Chat thread message sending now supports an “agent messages” mode: it selects participants that advertise agent-message support and sends `agent-message` payloads using `meshagent.agent.turn.start` / `meshagent.agent.turn.steer` types (including turn/thread scoping), with Promise-based sending and cancellation when recipients never materialize.
+- Chat UI/logic now determines the correct outbound message type (chat vs steer) and turn context from thread status, and passes that into message sending.
+- DatasetsClient now adds strongly typed `importFromStorage` and `exportToStorage` APIs with dataset storage format + import mode options, optional `namespace`/`branch` scoping, and `batch_size` support that is omitted when unset.
+- Unit tests were updated to verify the new import/export request payload shapes and defaults.
+
+## [0.39.5]
+- Stability
+
 ## [0.39.4]
 - Updated the Node/TS React dev package dependency graph to the newer `@meshagent/meshagent` and `@meshagent/meshagent-react` versions (`^0.38.4`) and upgraded supporting UI dependencies (including `shadcn` `^4.5.0`, `radix-ui` `^1.4.3`, and `lucide-react` `^0.525.0`).
 - Updated build tooling in the React dev package (new `build:js` / `build:types` scripts using TS configs) to match the updated packaging workflow.

package/dist/cjs/Chat.js

@@ -152,6 +152,9 @@ function ResolvedChatView({
   showNewThreadButton = false,
   onStartNewThread
 }) {
+  const threadStatus = (0, import_chat_hooks.useThreadStatus)({ room, path, agentName });
+  const useAgentMessages = threadStatus.supportsAgentMessages;
+  const messageType = useAgentMessages && threadStatus.mode === "steerable" && threadStatus.turnId ? "steer" : "chat";
   const {
     document,
     messages,
@@ -162,9 +165,16 @@ function ResolvedChatView({
     onlineParticipants,
     localParticipantName,
     cancelRequest
-  } = (0, import_chat_hooks.useChatThread)({ room, path, participants, agentName });
+  } = (0, import_chat_hooks.useChatThread)({
+    room,
+    path,
+    participants,
+    agentName,
+    useAgentMessages,
+    messageType,
+    turnId: threadStatus.turnId
+  });
   const { typing, thinking } = (0, import_meshagent_react.useRoomIndicators)({ room, path });
-  const threadStatus = (0, import_chat_hooks.useThreadStatus)({ room, path, agentName });
   const [showCompletedToolCalls, setShowCompletedToolCalls] = (0, import_react.useState)(false);
   const onTextChange = (0, import_react.useCallback)(() => {
     for (const participant of onlineParticipants) {

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

@@ -9,11 +9,14 @@ export interface UseChatThreadProps {
     includeLocalParticipant?: boolean;
     initialMessage?: ChatMessage;
     agentName?: string;
+    useAgentMessages?: boolean;
+    messageType?: string;
+    turnId?: string;
 }
 export interface UseChatThreadResult {
     document: MeshDocument | null;
     messages: Element[];
-    sendMessage: (message: ChatMessage) => void;
+    sendMessage: (message: ChatMessage) => Promise<void>;
     selectAttachments: (files: File[]) => void;
     attachments: FileUpload[];
     setAttachments: (attachments: FileUpload[]) => void;
@@ -70,5 +73,5 @@ export interface UseThreadStatusProps {
     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;
+export declare function useChatThread({ room, path, participants, participantNames, initialMessage, includeLocalParticipant, agentName, useAgentMessages, messageType, turnId, }: UseChatThreadProps): UseChatThreadResult;
 export declare function useThreadStatus({ room, path, agentName }: UseThreadStatusProps): ThreadStatus;

package/dist/cjs/chat-hooks.js

@@ -29,7 +29,15 @@ 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");
+const agentRoomMessageType = "agent-message";
+const agentTurnStartType = "meshagent.agent.turn.start";
 const agentTurnSteerType = "meshagent.agent.turn.steer";
+class ChatSendCancelledError extends Error {
+  constructor() {
+    super("chat send cancelled");
+    this.name = "ChatSendCancelledError";
+  }
+}
 class PendingAgentMessage {
   messageId;
   messageType;
@@ -202,6 +210,175 @@ function getOnlineParticipants(roomParticipants, participantNames) {
 function supportsAgentMessages(participant) {
   return participant.getAttribute("supports_agent_messages") === true;
 }
+function uniqueRemoteParticipantsById(participants) {
+  const seenParticipantIds = /* @__PURE__ */ new Set();
+  const uniqueParticipants = [];
+  for (const participant of participants) {
+    if (seenParticipantIds.has(participant.id)) {
+      continue;
+    }
+    seenParticipantIds.add(participant.id);
+    uniqueParticipants.push(participant);
+  }
+  return uniqueParticipants;
+}
+function getAgentParticipants({
+  room,
+  document,
+  participantName
+}) {
+  const normalizedParticipantName = participantName?.trim();
+  return uniqueRemoteParticipantsById(
+    getOnlineParticipants(room.messaging.remoteParticipants, getDocumentParticipantNames(document)).filter((participant) => {
+      if (normalizedParticipantName && getParticipantName(participant) !== normalizedParticipantName) {
+        return false;
+      }
+      return supportsAgentMessages(participant);
+    })
+  );
+}
+function matchingRecipients({
+  room,
+  document,
+  useAgentMessages,
+  participantName
+}) {
+  const normalizedParticipantName = participantName?.trim();
+  if (useAgentMessages) {
+    return getAgentParticipants({ room, document, participantName: normalizedParticipantName });
+  }
+  return uniqueRemoteParticipantsById(
+    getOnlineParticipants(room.messaging.remoteParticipants, getDocumentParticipantNames(document)).filter((participant) => {
+      if (!normalizedParticipantName) {
+        return true;
+      }
+      return getParticipantName(participant) === normalizedParticipantName;
+    })
+  );
+}
+function normalizeAgentAttachmentUrl(path) {
+  const trimmedPath = path.trim();
+  if (trimmedPath === "") {
+    return null;
+  }
+  try {
+    const url = new URL(trimmedPath);
+    if (url.protocol !== "") {
+      return trimmedPath;
+    }
+  } catch {
+  }
+  const roomPath = trimmedPath.startsWith("/") ? trimmedPath.slice(1) : trimmedPath;
+  return roomPath === "" ? null : `room:///${roomPath}`;
+}
+function agentInputContentFromMessage(message) {
+  const content = [];
+  if (message.text.trim() !== "") {
+    content.push({ type: "text", text: message.text });
+  }
+  for (const attachmentPath of message.attachments) {
+    const normalizedUrl = normalizeAgentAttachmentUrl(attachmentPath);
+    if (normalizedUrl !== null) {
+      content.push({ type: "file", url: normalizedUrl });
+    }
+  }
+  return content;
+}
+async function sendMessageToParticipant({
+  room,
+  participant,
+  path,
+  message,
+  messageType = "chat",
+  useAgentMessages = false,
+  turnId,
+  store = false
+}) {
+  if (message.text.trim() === "" && message.attachments.length === 0) {
+    return;
+  }
+  if (useAgentMessages) {
+    const isSteer = messageType === "steer";
+    const payload = {
+      type: isSteer ? agentTurnSteerType : agentTurnStartType,
+      thread_id: path,
+      message_id: message.id,
+      content: agentInputContentFromMessage(message)
+    };
+    if (isSteer && turnId?.trim()) {
+      payload.turn_id = turnId.trim();
+    }
+    await room.messaging.sendMessage({
+      to: participant,
+      type: agentRoomMessageType,
+      message: { payload }
+    });
+    return;
+  }
+  await room.messaging.sendMessage({
+    to: participant,
+    type: messageType,
+    message: {
+      path,
+      text: message.text,
+      attachments: message.attachments.map((attachmentPath) => ({ path: attachmentPath })),
+      store
+    }
+  });
+}
+function waitForRecipients({
+  room,
+  document,
+  messageId,
+  useAgentMessages,
+  participantName,
+  pendingRecipientWaits
+}) {
+  pendingRecipientWaits.get(messageId)?.();
+  return new Promise((resolve, reject) => {
+    let finished = false;
+    const eventNames = [
+      "participant_added",
+      "participant_removed",
+      "participant_attributes_updated",
+      "messaging_enabled"
+    ];
+    const finish = () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      for (const eventName of eventNames) {
+        room.messaging.off(eventName, listener);
+      }
+      if (pendingRecipientWaits.get(messageId) === cancel) {
+        pendingRecipientWaits.delete(messageId);
+      }
+    };
+    const cancel = () => {
+      finish();
+      reject(new ChatSendCancelledError());
+    };
+    const listener = () => {
+      const recipients = matchingRecipients({
+        room,
+        document,
+        useAgentMessages,
+        participantName
+      });
+      if (recipients.length === 0) {
+        return;
+      }
+      finish();
+      resolve(recipients);
+    };
+    pendingRecipientWaits.set(messageId, cancel);
+    for (const eventName of eventNames) {
+      room.messaging.on(eventName, listener);
+    }
+    listener();
+  });
+}
 function threadStatusAttributeCandidates(path, prefix) {
   if (path.startsWith("/")) {
     return [`${prefix}.${path}`, `${prefix}.${path.slice(1)}`];
@@ -387,13 +564,17 @@ function useChatThread({
   participantNames,
   initialMessage,
   includeLocalParticipant,
-  agentName
+  agentName,
+  useAgentMessages = false,
+  messageType = "chat",
+  turnId
 }) {
   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 pendingRecipientWaitsRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
   const syncDocumentState = (0, import_react.useCallback)((nextDocument) => {
     const nextMessages = mapThreadElements(nextDocument);
     const nextParticipantNames = getDocumentParticipantNames(nextDocument);
@@ -442,6 +623,14 @@ function useChatThread({
       }
     };
   }, [path, room, syncDocumentState]);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      for (const cancel of pendingRecipientWaitsRef.current.values()) {
+        cancel();
+      }
+      pendingRecipientWaitsRef.current.clear();
+    };
+  }, []);
   (0, import_react.useEffect)(() => {
     if (!document || !room.localParticipant) {
       return;
@@ -476,38 +665,68 @@ function useChatThread({
     () => getOnlineParticipants(roomParticipants, documentParticipantNames),
     [roomParticipants, documentParticipantNames]
   );
-  const sendMessage = (0, import_react.useCallback)((message) => {
+  const sendMessage = (0, import_react.useCallback)(async (message) => {
+    if (message.text.trim() === "" && message.attachments.length === 0) {
+      return;
+    }
+    const normalizedParticipantName = agentName?.trim();
+    const storeLocally = !normalizedParticipantName && !useAgentMessages;
     const children = document?.root.getChildren() ?? [];
-    const thread = children.find((child) => child.tagName === "messages");
-    if (!thread) {
+    const messagesElement = children.find((child) => child.tagName === "messages");
+    if (!document || !messagesElement) {
       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 });
+    if (storeLocally) {
+      const authorName = getParticipantName(room.localParticipant);
+      const messageElement = messagesElement.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;
+    let recipients = matchingRecipients({
+      room,
+      document,
+      useAgentMessages,
+      participantName: normalizedParticipantName
+    });
+    if (recipients.length === 0) {
+      const shouldWaitForRecipient = useAgentMessages || Boolean(normalizedParticipantName);
+      if (!shouldWaitForRecipient) {
+        throw new Error(`no matching recipients are available for '${path}'`);
       }
-      room.messaging.sendMessage({
-        to: participant,
-        type: "chat",
-        message: {
-          path,
-          text: message.text,
-          attachments: message.attachments.map((attachmentPath) => ({ path: attachmentPath }))
+      try {
+        recipients = await waitForRecipients({
+          room,
+          document,
+          messageId: message.id,
+          useAgentMessages,
+          participantName: normalizedParticipantName,
+          pendingRecipientWaits: pendingRecipientWaitsRef.current
+        });
+      } catch (error) {
+        if (error instanceof ChatSendCancelledError) {
+          return;
         }
-      });
+        throw error;
+      }
     }
-  }, [agentName, document, onlineParticipants, path, room]);
+    await Promise.all(recipients.map((participant) => sendMessageToParticipant({
+      room,
+      participant,
+      path,
+      message,
+      messageType,
+      useAgentMessages,
+      turnId,
+      store: Boolean(normalizedParticipantName) && getParticipantName(participant) === normalizedParticipantName
+    })));
+  }, [agentName, document, messageType, path, room, turnId, useAgentMessages]);
   (0, import_react.useEffect)(() => {
     if (!document || !initialMessage || initialMessageSentRef.current) {
       return;

package/dist/esm/Chat.js

@@ -129,6 +129,9 @@ function ResolvedChatView({
   showNewThreadButton = false,
   onStartNewThread
 }) {
+  const threadStatus = useThreadStatus({ room, path, agentName });
+  const useAgentMessages = threadStatus.supportsAgentMessages;
+  const messageType = useAgentMessages && threadStatus.mode === "steerable" && threadStatus.turnId ? "steer" : "chat";
   const {
     document,
     messages,
@@ -139,9 +142,16 @@ function ResolvedChatView({
     onlineParticipants,
     localParticipantName,
     cancelRequest
-  } = useChatThread({ room, path, participants, agentName });
+  } = useChatThread({
+    room,
+    path,
+    participants,
+    agentName,
+    useAgentMessages,
+    messageType,
+    turnId: threadStatus.turnId
+  });
   const { typing, thinking } = useRoomIndicators({ room, path });
-  const threadStatus = useThreadStatus({ room, path, agentName });
   const [showCompletedToolCalls, setShowCompletedToolCalls] = useState(false);
   const onTextChange = useCallback(() => {
     for (const participant of onlineParticipants) {

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

@@ -9,11 +9,14 @@ export interface UseChatThreadProps {
     includeLocalParticipant?: boolean;
     initialMessage?: ChatMessage;
     agentName?: string;
+    useAgentMessages?: boolean;
+    messageType?: string;
+    turnId?: string;
 }
 export interface UseChatThreadResult {
     document: MeshDocument | null;
     messages: Element[];
-    sendMessage: (message: ChatMessage) => void;
+    sendMessage: (message: ChatMessage) => Promise<void>;
     selectAttachments: (files: File[]) => void;
     attachments: FileUpload[];
     setAttachments: (attachments: FileUpload[]) => void;
@@ -70,5 +73,5 @@ export interface UseThreadStatusProps {
     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;
+export declare function useChatThread({ room, path, participants, participantNames, initialMessage, includeLocalParticipant, agentName, useAgentMessages, messageType, turnId, }: UseChatThreadProps): UseChatThreadResult;
 export declare function useThreadStatus({ room, path, agentName }: UseThreadStatusProps): ThreadStatus;

package/dist/esm/chat-hooks.js

@@ -4,7 +4,15 @@ import {
 } from "@meshagent/meshagent";
 import { subscribe, useDocumentChanged, useRoomParticipants } from "@meshagent/meshagent-react";
 import { MeshagentFileUpload, fileToAsyncIterable } from "./file-attachment";
+const agentRoomMessageType = "agent-message";
+const agentTurnStartType = "meshagent.agent.turn.start";
 const agentTurnSteerType = "meshagent.agent.turn.steer";
+class ChatSendCancelledError extends Error {
+  constructor() {
+    super("chat send cancelled");
+    this.name = "ChatSendCancelledError";
+  }
+}
 class PendingAgentMessage {
   messageId;
   messageType;
@@ -177,6 +185,175 @@ function getOnlineParticipants(roomParticipants, participantNames) {
 function supportsAgentMessages(participant) {
   return participant.getAttribute("supports_agent_messages") === true;
 }
+function uniqueRemoteParticipantsById(participants) {
+  const seenParticipantIds = /* @__PURE__ */ new Set();
+  const uniqueParticipants = [];
+  for (const participant of participants) {
+    if (seenParticipantIds.has(participant.id)) {
+      continue;
+    }
+    seenParticipantIds.add(participant.id);
+    uniqueParticipants.push(participant);
+  }
+  return uniqueParticipants;
+}
+function getAgentParticipants({
+  room,
+  document,
+  participantName
+}) {
+  const normalizedParticipantName = participantName?.trim();
+  return uniqueRemoteParticipantsById(
+    getOnlineParticipants(room.messaging.remoteParticipants, getDocumentParticipantNames(document)).filter((participant) => {
+      if (normalizedParticipantName && getParticipantName(participant) !== normalizedParticipantName) {
+        return false;
+      }
+      return supportsAgentMessages(participant);
+    })
+  );
+}
+function matchingRecipients({
+  room,
+  document,
+  useAgentMessages,
+  participantName
+}) {
+  const normalizedParticipantName = participantName?.trim();
+  if (useAgentMessages) {
+    return getAgentParticipants({ room, document, participantName: normalizedParticipantName });
+  }
+  return uniqueRemoteParticipantsById(
+    getOnlineParticipants(room.messaging.remoteParticipants, getDocumentParticipantNames(document)).filter((participant) => {
+      if (!normalizedParticipantName) {
+        return true;
+      }
+      return getParticipantName(participant) === normalizedParticipantName;
+    })
+  );
+}
+function normalizeAgentAttachmentUrl(path) {
+  const trimmedPath = path.trim();
+  if (trimmedPath === "") {
+    return null;
+  }
+  try {
+    const url = new URL(trimmedPath);
+    if (url.protocol !== "") {
+      return trimmedPath;
+    }
+  } catch {
+  }
+  const roomPath = trimmedPath.startsWith("/") ? trimmedPath.slice(1) : trimmedPath;
+  return roomPath === "" ? null : `room:///${roomPath}`;
+}
+function agentInputContentFromMessage(message) {
+  const content = [];
+  if (message.text.trim() !== "") {
+    content.push({ type: "text", text: message.text });
+  }
+  for (const attachmentPath of message.attachments) {
+    const normalizedUrl = normalizeAgentAttachmentUrl(attachmentPath);
+    if (normalizedUrl !== null) {
+      content.push({ type: "file", url: normalizedUrl });
+    }
+  }
+  return content;
+}
+async function sendMessageToParticipant({
+  room,
+  participant,
+  path,
+  message,
+  messageType = "chat",
+  useAgentMessages = false,
+  turnId,
+  store = false
+}) {
+  if (message.text.trim() === "" && message.attachments.length === 0) {
+    return;
+  }
+  if (useAgentMessages) {
+    const isSteer = messageType === "steer";
+    const payload = {
+      type: isSteer ? agentTurnSteerType : agentTurnStartType,
+      thread_id: path,
+      message_id: message.id,
+      content: agentInputContentFromMessage(message)
+    };
+    if (isSteer && turnId?.trim()) {
+      payload.turn_id = turnId.trim();
+    }
+    await room.messaging.sendMessage({
+      to: participant,
+      type: agentRoomMessageType,
+      message: { payload }
+    });
+    return;
+  }
+  await room.messaging.sendMessage({
+    to: participant,
+    type: messageType,
+    message: {
+      path,
+      text: message.text,
+      attachments: message.attachments.map((attachmentPath) => ({ path: attachmentPath })),
+      store
+    }
+  });
+}
+function waitForRecipients({
+  room,
+  document,
+  messageId,
+  useAgentMessages,
+  participantName,
+  pendingRecipientWaits
+}) {
+  pendingRecipientWaits.get(messageId)?.();
+  return new Promise((resolve, reject) => {
+    let finished = false;
+    const eventNames = [
+      "participant_added",
+      "participant_removed",
+      "participant_attributes_updated",
+      "messaging_enabled"
+    ];
+    const finish = () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      for (const eventName of eventNames) {
+        room.messaging.off(eventName, listener);
+      }
+      if (pendingRecipientWaits.get(messageId) === cancel) {
+        pendingRecipientWaits.delete(messageId);
+      }
+    };
+    const cancel = () => {
+      finish();
+      reject(new ChatSendCancelledError());
+    };
+    const listener = () => {
+      const recipients = matchingRecipients({
+        room,
+        document,
+        useAgentMessages,
+        participantName
+      });
+      if (recipients.length === 0) {
+        return;
+      }
+      finish();
+      resolve(recipients);
+    };
+    pendingRecipientWaits.set(messageId, cancel);
+    for (const eventName of eventNames) {
+      room.messaging.on(eventName, listener);
+    }
+    listener();
+  });
+}
 function threadStatusAttributeCandidates(path, prefix) {
   if (path.startsWith("/")) {
     return [`${prefix}.${path}`, `${prefix}.${path.slice(1)}`];
@@ -362,13 +539,17 @@ function useChatThread({
   participantNames,
   initialMessage,
   includeLocalParticipant,
-  agentName
+  agentName,
+  useAgentMessages = false,
+  messageType = "chat",
+  turnId
 }) {
   const [document, setDocument] = useState(null);
   const [messages, setMessages] = useState(() => document ? mapThreadElements(document) : []);
   const [attachments, setAttachments] = useState([]);
   const [documentParticipantNames, setDocumentParticipantNames] = useState(() => document ? getDocumentParticipantNames(document) : []);
   const initialMessageSentRef = useRef(false);
+  const pendingRecipientWaitsRef = useRef(/* @__PURE__ */ new Map());
   const syncDocumentState = useCallback((nextDocument) => {
     const nextMessages = mapThreadElements(nextDocument);
     const nextParticipantNames = getDocumentParticipantNames(nextDocument);
@@ -417,6 +598,14 @@ function useChatThread({
       }
     };
   }, [path, room, syncDocumentState]);
+  useEffect(() => {
+    return () => {
+      for (const cancel of pendingRecipientWaitsRef.current.values()) {
+        cancel();
+      }
+      pendingRecipientWaitsRef.current.clear();
+    };
+  }, []);
   useEffect(() => {
     if (!document || !room.localParticipant) {
       return;
@@ -451,38 +640,68 @@ function useChatThread({
     () => getOnlineParticipants(roomParticipants, documentParticipantNames),
     [roomParticipants, documentParticipantNames]
   );
-  const sendMessage = useCallback((message) => {
+  const sendMessage = useCallback(async (message) => {
+    if (message.text.trim() === "" && message.attachments.length === 0) {
+      return;
+    }
+    const normalizedParticipantName = agentName?.trim();
+    const storeLocally = !normalizedParticipantName && !useAgentMessages;
     const children = document?.root.getChildren() ?? [];
-    const thread = children.find((child) => child.tagName === "messages");
-    if (!thread) {
+    const messagesElement = children.find((child) => child.tagName === "messages");
+    if (!document || !messagesElement) {
       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 });
+    if (storeLocally) {
+      const authorName = getParticipantName(room.localParticipant);
+      const messageElement = messagesElement.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;
+    let recipients = matchingRecipients({
+      room,
+      document,
+      useAgentMessages,
+      participantName: normalizedParticipantName
+    });
+    if (recipients.length === 0) {
+      const shouldWaitForRecipient = useAgentMessages || Boolean(normalizedParticipantName);
+      if (!shouldWaitForRecipient) {
+        throw new Error(`no matching recipients are available for '${path}'`);
       }
-      room.messaging.sendMessage({
-        to: participant,
-        type: "chat",
-        message: {
-          path,
-          text: message.text,
-          attachments: message.attachments.map((attachmentPath) => ({ path: attachmentPath }))
+      try {
+        recipients = await waitForRecipients({
+          room,
+          document,
+          messageId: message.id,
+          useAgentMessages,
+          participantName: normalizedParticipantName,
+          pendingRecipientWaits: pendingRecipientWaitsRef.current
+        });
+      } catch (error) {
+        if (error instanceof ChatSendCancelledError) {
+          return;
         }
-      });
+        throw error;
+      }
     }
-  }, [agentName, document, onlineParticipants, path, room]);
+    await Promise.all(recipients.map((participant) => sendMessageToParticipant({
+      room,
+      participant,
+      path,
+      message,
+      messageType,
+      useAgentMessages,
+      turnId,
+      store: Boolean(normalizedParticipantName) && getParticipantName(participant) === normalizedParticipantName
+    })));
+  }, [agentName, document, messageType, path, room, turnId, useAgentMessages]);
   useEffect(() => {
     if (!document || !initialMessage || initialMessageSentRef.current) {
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent-tailwind",
-    "version": "0.39.4",
+    "version": "0.39.6",
     "description": "Meshagent Tailwind Components",
     "homepage": "https://github.com/meshagent/meshagent-tailwind",
     "scripts": {
@@ -32,8 +32,8 @@
         "CHANGELOG.md"
     ],
     "dependencies": {
-        "@meshagent/meshagent": "^0.39.4",
-        "@meshagent/meshagent-react": "^0.39.4",
+        "@meshagent/meshagent": "^0.39.6",
+        "@meshagent/meshagent-react": "^0.39.6",
         "@radix-ui/react-avatar": "^1.1.10",
         "@radix-ui/react-checkbox": "^1.3.2",
         "@radix-ui/react-dialog": "^1.1.14",