@meshagent/meshagent-tailwind 0.41.4 → 0.41.6

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.41.6]
+- Added convenience dataset helpers and toolkit-config support to the TypeScript SDK, expanding room- and dataset-aware workflows.
+- Extended the TypeScript storage client download URL API with an optional `download` flag so callers can request attachment-style links.
+- Updated the TypeScript agent/chat packages to support room shell and room storage toolkits with richer threaded chat behavior.
+- Improved Powerboards meetings with meeting previews, camera-grid handling, and video-chat collapse fixes.
+- Added syntax-highlighted file previews to the React UI, including `react-syntax-highlighter@^16.1.1` and `@types/react-syntax-highlighter@^15.5.13`.
+
+## [0.41.5]
+- Stability
+
 ## [0.41.4]
 - Stability
 

package/README.md

@@ -38,6 +38,39 @@ MeshAgent removes the infrastructure headaches of building and shipping AI Agent
 
 Follow our [Getting Started Documentation](https://docs.meshagent.com/introduction/get_started) to setup your MeshAgent account, create your first project, and start building agents!
 
+## Meetings
+
+The meeting components use a connected `RoomClient` to request LiveKit credentials before joining a meeting. Wrap `MeetingView` in `MeetingScope` and pass the same room client used by the rest of your app:
+
+```tsx
+import { MeetingScope, MeetingView } from "@meshagent/meshagent-tailwind";
+import type { RoomClient } from "@meshagent/meshagent";
+
+export function MeetingPanel({ roomClient }: { roomClient: RoomClient }) {
+	return (
+		<MeetingScope client={roomClient}>
+			<MeetingView />
+		</MeetingScope>
+	);
+}
+```
+
+`MeetingScope` configures its controller with `roomClient.livekit.getConnectionInfo({ breakoutRoom: "" })` and `MeetingView` uses that connection info when the user starts the main meeting. If you are building a custom meeting UI, request the connection info before calling LiveKit's `connect`:
+
+```ts
+import { Room } from "livekit-client";
+import type { RoomClient } from "@meshagent/meshagent";
+
+const livekitRoom = new Room();
+const connectionInfo = await roomClient.livekit.getConnectionInfo({
+	breakoutRoom: "",
+});
+
+await livekitRoom.connect(connectionInfo.url, connectionInfo.token);
+```
+
+Pass a non-empty `breakoutRoom` to `MeetingScope` or `roomClient.livekit.getConnectionInfo({ breakoutRoom })` when the meeting should join a specific breakout room.
+
 ## Next Steps and Examples
 
 To see examples of agents in action and to start building your own agents check out the MeshAgent docs at [docs.meshagent.com](https://docs.meshagent.com/)

package/dist/cjs/chat/chat-thread.js

@@ -259,7 +259,7 @@ function MarkdownBlock({ text }) {
             children
           }
         ),
-        p: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { ...props, className: "mb-2 last:mb-0", children }),
+        p: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { ...props, className: "mb-2 last:mb-0 overflow-hidden max-w-full", children }),
         table: ({ children, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "my-4 w-full overflow-x-auto", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
           "table",
           {
@@ -299,6 +299,17 @@ function MarkdownBlock({ text }) {
             className: "mb-2 ml-6 list-decimal last:mb-0",
             children
           }
+        ),
+        a: ({ children, href, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "a",
+          {
+            ...props,
+            href,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            className: "text-primary underline overflow-ellipsis inline-block max-w-full overflow-x-hidden",
+            children
+          }
         )
       },
       children: text
@@ -394,10 +405,7 @@ function ThreadAttachment({ room, attachment, onImageSettled }) {
   }
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FileAttachment, { room, path });
 }
-function ChatBubble({
-  text,
-  mine
-}) {
+function ChatBubble({ text, mine }) {
   if (text.trim() === "") {
     return null;
   }
@@ -405,7 +413,7 @@ function ChatBubble({
     "div",
     {
       className: (0, import_utils.cn)(
-        "w-fit max-w-[85%] rounded-md px-4 py-3 text-sm leading-6 shadow-xs sm:max-w-2xl",
+        "w-fit max-w-[85%] rounded-md px-4 py-3 text-sm leading-6 shadow-xs sm:w-2xl",
         mine ? "bg-secondary/85 text-foreground" : "bg-muted/70 text-foreground"
       ),
       children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MarkdownBlock, { text })
@@ -474,10 +482,7 @@ function defaultEventHeadline(kind, state, eventName) {
   }
   return eventName.replace(/[._]/gu, " ");
 }
-function EventRow({
-  room,
-  message
-}) {
+function EventRow({ room, message }) {
   const method = getTrimmedStringAttribute(message, "method") || "agent/event";
   const eventName = getTrimmedStringAttribute(message, "name") || getTrimmedStringAttribute(message, "event_type") || method.replace(/\//gu, ".");
   const kind = getTrimmedStringAttribute(message, "kind").toLowerCase();

package/dist/cjs/chat/dataset-chat-thread.d.ts

@@ -1,8 +1,11 @@
 import type { ReactElement } from "react";
 import type { RoomClient } from "@meshagent/meshagent";
+import type { BaseChatClient } from "@meshagent/meshagent-agents";
 export interface DatasetChatThreadProps {
     room: RoomClient;
     path: string;
+    chatClient?: BaseChatClient;
+    disposeChatClient?: boolean;
     agentName?: string;
     emptyStateTitle?: string;
     emptyStateDescription?: string;
@@ -10,4 +13,4 @@ export interface DatasetChatThreadProps {
     initialShowCompletedToolCalls?: boolean;
     openFile?: (path: string) => void | Promise<void>;
 }
-export declare function DatasetChatThread({ room, path, agentName, emptyStateTitle, emptyStateDescription, inputPlaceholder, initialShowCompletedToolCalls, openFile, }: DatasetChatThreadProps): ReactElement;
+export declare function DatasetChatThread({ room, path, chatClient, disposeChatClient, agentName, emptyStateTitle, emptyStateDescription, inputPlaceholder, initialShowCompletedToolCalls, openFile, }: DatasetChatThreadProps): ReactElement;

package/dist/cjs/chat/dataset-chat-thread.js

@@ -34,7 +34,7 @@ module.exports = __toCommonJS(dataset_chat_thread_exports);
 var import_jsx_runtime = require("react/jsx-runtime");
 var import_react = require("react");
 var import_meshagent = require("@meshagent/meshagent");
-var import_meshagent_react = require("@meshagent/meshagent-react");
+var import_meshagent_agents = require("@meshagent/meshagent-agents");
 var import_lucide_react = require("lucide-react");
 var import_react_markdown = __toESM(require("react-markdown"));
 var import_rehype_highlight = __toESM(require("rehype-highlight"));
@@ -48,34 +48,6 @@ var import_file_attachment = require("./file-attachment");
 var import_chat_hooks = require("./chat-hooks");
 var import_utils = require("../lib/utils");
 var import_chat_thread = require("./chat-thread");
-const agentRoomMessageType = "agent-message";
-const agentTurnStartType = "meshagent.agent.turn.start";
-const agentTurnSteerType = "meshagent.agent.turn.steer";
-const agentTurnInterruptType = "meshagent.agent.turn.interrupt";
-const agentThreadOpenType = "meshagent.agent.thread.open";
-const agentThreadCloseType = "meshagent.agent.thread.close";
-const agentTurnStartAcceptedType = "meshagent.agent.turn.start.accepted";
-const agentTurnStartRejectedType = "meshagent.agent.turn.start.rejected";
-const agentTurnSteerAcceptedType = "meshagent.agent.turn.steer.accepted";
-const agentTurnSteerRejectedType = "meshagent.agent.turn.steer.rejected";
-const agentTurnStartedType = "meshagent.agent.turn.started";
-const agentTurnSteeredType = "meshagent.agent.turn.steered";
-const agentTextContentDeltaType = "meshagent.agent.text_content.delta";
-const agentTextContentEndedType = "meshagent.agent.text_content.ended";
-const agentReasoningContentStartedType = "meshagent.agent.reasoning_content.started";
-const agentReasoningContentDeltaType = "meshagent.agent.reasoning_content.delta";
-const agentReasoningContentEndedType = "meshagent.agent.reasoning_content.ended";
-const agentFileContentStartedType = "meshagent.agent.file_content.started";
-const agentFileContentDeltaType = "meshagent.agent.file_content.delta";
-const agentFileContentEndedType = "meshagent.agent.file_content.ended";
-const agentToolCallPendingType = "meshagent.agent.tool_call.pending";
-const agentToolCallInProgressType = "meshagent.agent.tool_call.in_progress";
-const agentToolCallStartedType = "meshagent.agent.tool_call.started";
-const agentToolCallEndedType = "meshagent.agent.tool_call.ended";
-const agentImageGenerationStartedType = "meshagent.agent.image_generation.started";
-const agentImageGenerationPartialType = "meshagent.agent.image_generation.partial";
-const agentImageGenerationCompletedType = "meshagent.agent.image_generation.completed";
-const agentImageGenerationFailedType = "meshagent.agent.image_generation.failed";
 const stickyBottomThresholdPx = 24;
 const maxPreviewEdgePx = 312.5;
 function createDatasetThreadModel() {
@@ -496,11 +468,11 @@ function timestampFromPayload(payload) {
 }
 function imageGenerationStatusFromType(type) {
   switch (type) {
-    case agentImageGenerationCompletedType:
+    case import_meshagent_agents.agentImageGenerationCompletedType:
       return "completed";
-    case agentImageGenerationFailedType:
+    case import_meshagent_agents.agentImageGenerationFailedType:
       return "failed";
-    case agentImageGenerationPartialType:
+    case import_meshagent_agents.agentImageGenerationPartialType:
       return "in_progress";
     default:
       return "pending";
@@ -668,7 +640,7 @@ function applyAgentMessagePayload(model, payload, path) {
   if (!type) {
     return false;
   }
-  if (type === agentTurnStartRejectedType || type === agentTurnSteerRejectedType) {
+  if (type === import_meshagent_agents.agentTurnStartRejectedType || type === import_meshagent_agents.agentTurnSteerRejectedType) {
     const sourceMessageId = stringValue(payload.source_message_id);
     return sourceMessageId ? model.agentRowsByItemId.delete(sourceMessageId) : false;
   }
@@ -676,14 +648,14 @@ function applyAgentMessagePayload(model, payload, path) {
   const turnId = payloadTurnId(payload);
   let changed = false;
   switch (type) {
-    case agentTurnStartAcceptedType:
-    case agentTurnSteerAcceptedType:
+    case import_meshagent_agents.agentTurnStartAcceptedType:
+    case import_meshagent_agents.agentTurnSteerAcceptedType:
       break;
-    case agentTurnStartedType:
-    case agentTurnSteeredType:
+    case import_meshagent_agents.agentTurnStartedType:
+    case import_meshagent_agents.agentTurnSteeredType:
       changed = materializeTurnInputPayload(model, payload) || changed;
       break;
-    case agentTextContentDeltaType:
+    case import_meshagent_agents.agentTextContentDeltaType:
       changed = appendAgentRowText({
         model,
         itemId,
@@ -693,7 +665,7 @@ function applyAgentMessagePayload(model, payload, path) {
         delta: String(payload.text ?? "")
       }) || changed;
       break;
-    case agentTextContentEndedType:
+    case import_meshagent_agents.agentTextContentEndedType:
       changed = upsertAgentRow({
         model,
         itemId,
@@ -705,7 +677,7 @@ function applyAgentMessagePayload(model, payload, path) {
         }
       }) || changed;
       break;
-    case agentReasoningContentStartedType:
+    case import_meshagent_agents.agentReasoningContentStartedType:
       changed = upsertAgentRow({
         model,
         itemId,
@@ -713,7 +685,7 @@ function applyAgentMessagePayload(model, payload, path) {
         data: { kind: "reasoning", role: "assistant", text: "" }
       }) || changed;
       break;
-    case agentReasoningContentDeltaType:
+    case import_meshagent_agents.agentReasoningContentDeltaType:
       changed = appendAgentRowText({
         model,
         itemId,
@@ -723,7 +695,7 @@ function applyAgentMessagePayload(model, payload, path) {
         delta: String(payload.text ?? "")
       }) || changed;
       break;
-    case agentReasoningContentEndedType:
+    case import_meshagent_agents.agentReasoningContentEndedType:
       changed = upsertAgentRow({
         model,
         itemId,
@@ -735,7 +707,7 @@ function applyAgentMessagePayload(model, payload, path) {
         }
       }) || changed;
       break;
-    case agentFileContentStartedType:
+    case import_meshagent_agents.agentFileContentStartedType:
       changed = upsertAgentRow({
         model,
         itemId,
@@ -743,17 +715,17 @@ function applyAgentMessagePayload(model, payload, path) {
         data: { kind: "file", role: "assistant", urls: [] }
       }) || changed;
       break;
-    case agentFileContentDeltaType:
-    case agentFileContentEndedType:
+    case import_meshagent_agents.agentFileContentDeltaType:
+    case import_meshagent_agents.agentFileContentEndedType:
       changed = appendAgentRowUrl({ model, itemId, turnId, url: payload.url }) || changed;
       break;
-    case agentToolCallPendingType:
-    case agentToolCallInProgressType:
-    case agentToolCallStartedType:
-    case agentToolCallEndedType: {
+    case import_meshagent_agents.agentToolCallPendingType:
+    case import_meshagent_agents.agentToolCallInProgressType:
+    case import_meshagent_agents.agentToolCallStartedType:
+    case import_meshagent_agents.agentToolCallEndedType: {
       const tool = String(payload.tool ?? payload.tool_name ?? payload.name ?? "");
       const isImageGeneration = tool.trim().toLowerCase() === "image_generation";
-      if (isImageGeneration && type === agentToolCallEndedType && payload.error == null) {
+      if (isImageGeneration && type === import_meshagent_agents.agentToolCallEndedType && payload.error == null) {
         break;
       }
       changed = upsertAgentRow({
@@ -772,15 +744,15 @@ function applyAgentMessagePayload(model, payload, path) {
           role: "assistant",
           toolkit: String(payload.toolkit ?? payload.toolkit_name ?? ""),
           tool,
-          status: type === agentToolCallEndedType ? "completed" : "running"
+          status: type === import_meshagent_agents.agentToolCallEndedType ? "completed" : "running"
         }
       }) || changed;
       break;
     }
-    case agentImageGenerationStartedType:
-    case agentImageGenerationPartialType:
-    case agentImageGenerationCompletedType:
-    case agentImageGenerationFailedType:
+    case import_meshagent_agents.agentImageGenerationStartedType:
+    case import_meshagent_agents.agentImageGenerationPartialType:
+    case import_meshagent_agents.agentImageGenerationCompletedType:
+    case import_meshagent_agents.agentImageGenerationFailedType:
       changed = upsertAgentRow({
         model,
         itemId,
@@ -1019,6 +991,26 @@ function describeError(error) {
   }
   return String(error);
 }
+function pendingAgentMessageFromInput(pending) {
+  const payload = pending.payload.toJson();
+  const parsed = import_chat_hooks.PendingAgentMessage.fromQueueJson({
+    ...payload,
+    message_type: pending.messageType,
+    created_at: pending.createdAt.toISOString()
+  });
+  return new import_chat_hooks.PendingAgentMessage({
+    messageId: parsed.messageId,
+    messageType: parsed.messageType,
+    threadPath: parsed.threadPath,
+    text: parsed.text,
+    attachments: parsed.attachments,
+    senderName: parsed.senderName,
+    createdAt: parsed.createdAt,
+    matchByContentOnly: parsed.matchByContentOnly,
+    awaitingAcceptance: pending.awaitingAcceptance,
+    awaitingOnline: pending.awaitingOnline
+  });
+}
 function MarkdownBlock({ text }) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
     import_react_markdown.default,
@@ -1435,24 +1427,11 @@ function EmptyState({
 function ErrorBanner({ message }) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "mx-auto w-full max-w-[912px] whitespace-pre-wrap rounded-md border border-destructive/30 bg-destructive/5 px-4 py-3 text-sm text-destructive", children: message });
 }
-function sendThreadSubscriptionMessage({
-  room,
-  agent,
-  messageType,
-  path
-}) {
-  void room.messaging.sendMessage({
-    to: agent,
-    type: agentRoomMessageType,
-    ignoreOffline: true,
-    message: {
-      payload: { type: messageType, thread_id: path }
-    }
-  }).catch(() => void 0);
-}
 function DatasetChatThread({
   room,
   path,
+  chatClient,
+  disposeChatClient = false,
   agentName,
   emptyStateTitle,
   emptyStateDescription,
@@ -1466,14 +1445,35 @@ function DatasetChatThread({
   const [sendError, setSendError] = (0, import_react.useState)(null);
   const [showCompletedToolCalls, setShowCompletedToolCalls] = (0, import_react.useState)(initialShowCompletedToolCalls);
   const status = (0, import_chat_hooks.useThreadStatus)({ room, path, agentName });
-  const agentParticipant = findAgentParticipant(room, agentName);
   const localParticipantName = getParticipantName(room.localParticipant);
   const scrollContainerRef = (0, import_react.useRef)(null);
   const contentRef = (0, import_react.useRef)(null);
   const stickToBottomRef = (0, import_react.useRef)(true);
+  const threadSessionRef = (0, import_react.useRef)(null);
+  const threadSessionCursorRef = (0, import_react.useRef)(0);
+  const [threadSessionVersion, setThreadSessionVersion] = (0, import_react.useState)(0);
+  const ownsChatClient = chatClient == null;
+  const activeChatClient = (0, import_react.useMemo)(
+    () => chatClient ?? new import_meshagent_agents.MessagingChatClient({ room, agentName }),
+    [agentName, chatClient, room]
+  );
+  const agentParticipant = activeChatClient.agentParticipant() ?? findAgentParticipant(room, agentName);
   const bumpModelVersion = (0, import_react.useCallback)(() => {
     setModelVersion((current) => current + 1);
   }, []);
+  (0, import_react.useEffect)(() => {
+    void activeChatClient.start();
+    const handleChange = () => {
+      setThreadSessionVersion((current) => current + 1);
+    };
+    activeChatClient.addListener(handleChange);
+    return () => {
+      activeChatClient.removeListener(handleChange);
+      if (ownsChatClient || disposeChatClient) {
+        void activeChatClient.stop();
+      }
+    };
+  }, [activeChatClient, disposeChatClient, ownsChatClient]);
   (0, import_react.useEffect)(() => {
     const model2 = createDatasetThreadModel();
     modelRef.current = model2;
@@ -1551,46 +1551,41 @@ function DatasetChatThread({
     };
   }, [bumpModelVersion, path, room]);
   (0, import_react.useEffect)(() => {
-    const subscription = (0, import_meshagent_react.subscribe)(room.listen(), {
-      next: (event) => {
-        if (!(event instanceof import_meshagent.RoomMessageEvent)) {
-          return;
-        }
-        if (event.message.type !== agentRoomMessageType) {
-          return;
-        }
-        const payload = event.message.message.payload;
-        if (!isRecord(payload)) {
-          return;
-        }
-        if (applyAgentMessagePayload(modelRef.current, payload, path)) {
-          bumpModelVersion();
+    if (isTmpThreadPath(path)) {
+      threadSessionRef.current = null;
+      threadSessionCursorRef.current = 0;
+      setThreadSessionVersion((current) => current + 1);
+      return;
+    }
+    const session = activeChatClient.openThread(path);
+    threadSessionRef.current = session;
+    threadSessionCursorRef.current = 0;
+    const drainSessionMessages = () => {
+      let changed = false;
+      const messages = session.messages;
+      while (threadSessionCursorRef.current < messages.length) {
+        const event = messages[threadSessionCursorRef.current];
+        threadSessionCursorRef.current += 1;
+        if (applyAgentMessagePayload(modelRef.current, event.payload, path)) {
+          changed = true;
         }
       }
-    });
-    return () => {
-      subscription.unsubscribe();
+      if (changed) {
+        bumpModelVersion();
+      }
+      setThreadSessionVersion((current) => current + 1);
     };
-  }, [bumpModelVersion, path, room]);
-  (0, import_react.useEffect)(() => {
-    if (!agentParticipant) {
-      return;
-    }
-    sendThreadSubscriptionMessage({
-      room,
-      agent: agentParticipant,
-      messageType: agentThreadOpenType,
-      path
-    });
+    session.addListener(drainSessionMessages);
+    drainSessionMessages();
     return () => {
-      sendThreadSubscriptionMessage({
-        room,
-        agent: agentParticipant,
-        messageType: agentThreadCloseType,
-        path
-      });
+      session.removeListener(drainSessionMessages);
+      if (threadSessionRef.current === session) {
+        threadSessionRef.current = null;
+        threadSessionCursorRef.current = 0;
+      }
+      void session.close().catch(() => void 0);
     };
-  }, [agentParticipant, path, room]);
+  }, [activeChatClient, bumpModelVersion, path]);
   const allMessages = (0, import_react.useMemo)(() => {
     const model2 = modelRef.current;
     const mergedRowsByItemId = /* @__PURE__ */ new Map();
@@ -1615,29 +1610,24 @@ function DatasetChatThread({
     for (const pending of status.pendingMessages) {
       combined.set(pending.messageId, pending);
     }
+    for (const pending of threadSessionRef.current?.pendingInputs ?? []) {
+      combined.set(pending.messageId, pendingAgentMessageFromInput(pending));
+    }
     const values = Array.from(combined.values()).filter((pending) => !allMessages.some((message) => datasetThreadMessageMatchesPendingAgentMessage(message, pending)));
     return [
       ...values.filter((message) => !message.awaitingAcceptance),
       ...values.filter((message) => message.awaitingAcceptance)
     ];
-  }, [allMessages, status.pendingMessages]);
-  const canInterruptActiveTurn = status.supportsAgentMessages && status.turnId != null;
+  }, [allMessages, status.pendingMessages, threadSessionVersion]);
+  const canInterruptActiveTurn = status.turnId != null && (status.supportsAgentMessages || agentParticipant != null || chatClient != null);
   const cancelTurn = (0, import_react.useCallback)(async () => {
-    if (!status.turnId?.trim() || !agentParticipant) {
+    const turnId = status.turnId?.trim();
+    const session = threadSessionRef.current;
+    if (!turnId || session == null) {
       return;
     }
-    await room.messaging.sendMessage({
-      to: agentParticipant,
-      type: agentRoomMessageType,
-      message: {
-        payload: {
-          type: agentTurnInterruptType,
-          thread_id: path,
-          turn_id: status.turnId
-        }
-      }
-    });
-  }, [agentParticipant, path, room, status.turnId]);
+    await session.interruptTurn(turnId);
+  }, [status.turnId, threadSessionVersion]);
   const selectAttachments = (0, import_react.useCallback)((files) => {
     const nextAttachments = files.map((file) => new import_file_attachment.MeshagentFileUpload(
       room,
@@ -1651,56 +1641,39 @@ function DatasetChatThread({
     if (message.text.trim() === "" && message.attachments.length === 0) {
       return;
     }
-    if (!agentParticipant) {
+    if (!agentParticipant && chatClient == null) {
       setSendError("This thread requires an online agent that supports agent messages.");
       return;
     }
+    const session = threadSessionRef.current;
+    if (session == null) {
+      setSendError("No thread session is open.");
+      return;
+    }
     const isSteer = status.mode === "steerable" && status.turnId != null;
     const normalizedAttachments = message.attachments.map(normalizeAgentAttachmentUrl).filter((attachment) => attachment !== null);
     const senderName = localParticipantName.trim() || void 0;
-    upsertAgentRow({
-      model: modelRef.current,
-      itemId: message.id,
-      turnId: null,
-      timestamp: /* @__PURE__ */ new Date(),
-      data: {
-        kind: "message",
-        role: "user",
-        text: message.text,
-        sender_name: senderName,
-        attachments: normalizedAttachments
-      }
-    });
-    bumpModelVersion();
     try {
-      const payload = {
-        type: isSteer ? agentTurnSteerType : agentTurnStartType,
-        thread_id: path,
-        message_id: message.id,
-        content: agentInputContent(message.text, message.attachments)
-      };
-      if (isSteer && status.turnId) {
-        payload.turn_id = status.turnId;
-      }
-      await room.messaging.sendMessage({
-        to: agentParticipant,
-        type: agentRoomMessageType,
-        message: { payload }
+      await session.sendText({
+        messageId: message.id,
+        text: message.text,
+        attachments: normalizedAttachments,
+        steer: isSteer,
+        turnId: status.turnId,
+        senderName
       });
       setSendError(null);
+      setThreadSessionVersion((current) => current + 1);
     } catch (error) {
-      modelRef.current.agentRowsByItemId.delete(message.id);
-      bumpModelVersion();
       setSendError(describeError(error));
     }
   }, [
     agentParticipant,
-    bumpModelVersion,
+    chatClient,
     localParticipantName,
-    path,
-    room,
     status.mode,
-    status.turnId
+    status.turnId,
+    threadSessionVersion
   ]);
   const hasWireBackedContent = modelRef.current.agentRowsByItemId.size > 0 || status.pendingMessages.length > 0 || pendingMessages.length > 0;
   const model = modelRef.current;
@@ -1832,8 +1805,8 @@ function DatasetChatThread({
         attachments,
         onFilesSelected: selectAttachments,
         setAttachments,
-        disabled: agentParticipant == null,
-        placeholder: inputPlaceholder ?? (agentParticipant ? "Type a message" : `Waiting for ${displayParticipantName(agentName ?? "agent")}`)
+        disabled: agentParticipant == null && chatClient == null,
+        placeholder: inputPlaceholder ?? (agentParticipant || chatClient ? "Type a message" : `Waiting for ${displayParticipantName(agentName ?? "agent")}`)
       }
     )
   ] });

package/dist/cjs/chat/multi-thread-view.d.ts

@@ -1,8 +1,11 @@
 import type { ReactElement } from "react";
 import { RoomClient } from "@meshagent/meshagent";
+import type { BaseChatClient } from "@meshagent/meshagent-agents";
 export type MultiThreadContentBuilder = (threadPath: string) => ReactElement;
 export interface MultiThreadViewProps {
     room: RoomClient;
+    chatClient?: BaseChatClient;
+    disposeChatClient?: boolean;
     agentName: string;
     builder: MultiThreadContentBuilder;
     toolkit?: string;
@@ -15,4 +18,4 @@ export interface MultiThreadViewProps {
     emptyStateTitle?: string;
     emptyStateDescription?: string;
 }
-export declare function MultiThreadView({ room, agentName, builder, toolkit, tool, selectedThreadPath, onSelectedThreadPathChanged, onSelectedThreadResolved, newThreadResetVersion, centerComposer, emptyStateTitle, emptyStateDescription, }: MultiThreadViewProps): ReactElement;
+export declare function MultiThreadView({ room, chatClient, disposeChatClient, agentName, builder, toolkit, tool, selectedThreadPath, onSelectedThreadPathChanged, onSelectedThreadResolved, newThreadResetVersion, centerComposer, emptyStateTitle, emptyStateDescription, }: MultiThreadViewProps): ReactElement;

package/dist/cjs/chat/multi-thread-view.js

@@ -30,6 +30,8 @@ function normalizeSelectedThreadPath(path) {
 }
 function MultiThreadView({
   room,
+  chatClient,
+  disposeChatClient = false,
   agentName,
   builder,
   toolkit = "chat",
@@ -68,6 +70,8 @@ function MultiThreadView({
     import_new_chat_thread.NewChatThread,
     {
       room,
+      chatClient,
+      disposeChatClient,
       agentName,
       builder,
       toolkit,

package/dist/cjs/chat/new-chat-thread.d.ts

@@ -1,8 +1,11 @@
 import type { ReactElement } from "react";
 import { RoomClient } from "@meshagent/meshagent";
+import type { BaseChatClient } from "@meshagent/meshagent-agents";
 export type NewChatThreadBuilder = (threadPath: string) => ReactElement;
 export interface NewChatThreadProps {
     room: RoomClient;
+    chatClient?: BaseChatClient;
+    disposeChatClient?: boolean;
     agentName: string;
     builder: NewChatThreadBuilder;
     toolkit?: string;
@@ -14,4 +17,4 @@ export interface NewChatThreadProps {
     emptyStateTitle?: string;
     emptyStateDescription?: string;
 }
-export declare function NewChatThread({ room, agentName, builder, toolkit, tool, selectedThreadPath, onThreadPathChanged, onThreadResolved, centerComposer, emptyStateTitle, emptyStateDescription, }: NewChatThreadProps): ReactElement;
+export declare function NewChatThread({ room, chatClient, disposeChatClient, agentName, builder, selectedThreadPath, onThreadPathChanged, onThreadResolved, centerComposer, emptyStateTitle, emptyStateDescription, }: NewChatThreadProps): ReactElement;