@meshagent/meshagent-tailwind 0.39.9 → 0.40.1

package/dist/cjs/meetings/meeting-scope.js

@@ -0,0 +1,309 @@
+"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 meeting_scope_exports = {};
+__export(meeting_scope_exports, {
+  MeetingController: () => MeetingController,
+  MeetingScope: () => MeetingScope,
+  PendingLocalMediaState: () => PendingLocalMediaState,
+  firstEnabledVideoPublication: () => firstEnabledVideoPublication,
+  useMeetingController: () => useMeetingController
+});
+module.exports = __toCommonJS(meeting_scope_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_livekit_client = require("livekit-client");
+var import_wake_lock = require("./wake-lock");
+class PendingLocalMediaState {
+  listeners = /* @__PURE__ */ new Set();
+  cameraAwaitingEnableConfirmation = false;
+  microphoneAwaitingEnableConfirmation = false;
+  _cameraPending = false;
+  _microphonePending = false;
+  _cameraUnavailable = false;
+  _microphoneUnavailable = false;
+  get cameraPending() {
+    return this._cameraPending;
+  }
+  get microphonePending() {
+    return this._microphonePending;
+  }
+  get cameraUnavailable() {
+    return this._cameraUnavailable;
+  }
+  get microphoneUnavailable() {
+    return this._microphoneUnavailable;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  setCameraPending(value, { awaitEnableConfirmation = false } = {}) {
+    if (this._cameraPending === value && this.cameraAwaitingEnableConfirmation === awaitEnableConfirmation) {
+      return;
+    }
+    this._cameraPending = value;
+    this.cameraAwaitingEnableConfirmation = value && awaitEnableConfirmation;
+    this.notify();
+  }
+  setMicrophonePending(value, { awaitEnableConfirmation = false } = {}) {
+    if (this._microphonePending === value && this.microphoneAwaitingEnableConfirmation === awaitEnableConfirmation) {
+      return;
+    }
+    this._microphonePending = value;
+    this.microphoneAwaitingEnableConfirmation = value && awaitEnableConfirmation;
+    this.notify();
+  }
+  setCameraUnavailable(value) {
+    if (this._cameraUnavailable === value) {
+      return;
+    }
+    this._cameraUnavailable = value;
+    this.notify();
+  }
+  setMicrophoneUnavailable(value) {
+    if (this._microphoneUnavailable === value) {
+      return;
+    }
+    this._microphoneUnavailable = value;
+    this.notify();
+  }
+  setPending({
+    cameraPending,
+    microphonePending,
+    cameraAwaitEnableConfirmation = false,
+    microphoneAwaitEnableConfirmation = false
+  }) {
+    const nextCameraAwaiting = cameraPending && cameraAwaitEnableConfirmation;
+    const nextMicrophoneAwaiting = microphonePending && microphoneAwaitEnableConfirmation;
+    if (this._cameraPending === cameraPending && this._microphonePending === microphonePending && this.cameraAwaitingEnableConfirmation === nextCameraAwaiting && this.microphoneAwaitingEnableConfirmation === nextMicrophoneAwaiting) {
+      return;
+    }
+    this._cameraPending = cameraPending;
+    this._microphonePending = microphonePending;
+    this.cameraAwaitingEnableConfirmation = nextCameraAwaiting;
+    this.microphoneAwaitingEnableConfirmation = nextMicrophoneAwaiting;
+    this.notify();
+  }
+  syncFromLocalParticipant(participant, disconnected) {
+    if (disconnected) {
+      this.clear();
+      return;
+    }
+    if (this.cameraAwaitingEnableConfirmation && participant?.isCameraEnabled) {
+      this.setCameraPending(false);
+    }
+    if (participant?.isCameraEnabled) {
+      this.setCameraUnavailable(false);
+    }
+    if (this.microphoneAwaitingEnableConfirmation && participant?.isMicrophoneEnabled) {
+      this.setMicrophonePending(false);
+    }
+    if (participant?.isMicrophoneEnabled) {
+      this.setMicrophoneUnavailable(false);
+    }
+  }
+  clear() {
+    if (!this._cameraPending && !this._microphonePending && !this.cameraAwaitingEnableConfirmation && !this.microphoneAwaitingEnableConfirmation && !this._cameraUnavailable && !this._microphoneUnavailable) {
+      return;
+    }
+    this._cameraPending = false;
+    this._microphonePending = false;
+    this.cameraAwaitingEnableConfirmation = false;
+    this.microphoneAwaitingEnableConfirmation = false;
+    this._cameraUnavailable = false;
+    this._microphoneUnavailable = false;
+    this.notify();
+  }
+  dispose() {
+    this.listeners.clear();
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+}
+class MeetingController {
+  room;
+  livekitRoom;
+  pendingLocalMedia = new PendingLocalMediaState();
+  listeners = /* @__PURE__ */ new Set();
+  _config = null;
+  _configurationError = null;
+  constructor({ room, roomOptions }) {
+    this.room = room;
+    this.livekitRoom = new import_livekit_client.Room(roomOptions);
+    const roomEvents = [
+      import_livekit_client.RoomEvent.ConnectionStateChanged,
+      import_livekit_client.RoomEvent.Connected,
+      import_livekit_client.RoomEvent.Disconnected,
+      import_livekit_client.RoomEvent.ParticipantConnected,
+      import_livekit_client.RoomEvent.ParticipantDisconnected,
+      import_livekit_client.RoomEvent.TrackPublished,
+      import_livekit_client.RoomEvent.TrackSubscribed,
+      import_livekit_client.RoomEvent.TrackUnpublished,
+      import_livekit_client.RoomEvent.TrackUnsubscribed,
+      import_livekit_client.RoomEvent.TrackMuted,
+      import_livekit_client.RoomEvent.TrackUnmuted,
+      import_livekit_client.RoomEvent.LocalTrackPublished,
+      import_livekit_client.RoomEvent.LocalTrackUnpublished,
+      import_livekit_client.RoomEvent.ActiveSpeakersChanged,
+      import_livekit_client.RoomEvent.ParticipantAttributesChanged,
+      import_livekit_client.RoomEvent.ParticipantNameChanged,
+      import_livekit_client.RoomEvent.MediaDevicesChanged
+    ];
+    for (const eventName of roomEvents) {
+      this.livekitRoom.on(eventName, this.onRoomChanged);
+    }
+  }
+  get config() {
+    return this._config;
+  }
+  get configurationError() {
+    return this._configurationError;
+  }
+  get isConnected() {
+    return this.livekitRoom.state !== import_livekit_client.ConnectionState.Disconnected;
+  }
+  get hasParticipantsWithVideo() {
+    const localHasVideo = Array.from(this.livekitRoom.localParticipant.videoTrackPublications.values()).some((publication) => !publication.isMuted);
+    const remoteHasVideo = Array.from(this.livekitRoom.remoteParticipants.values()).some((participant) => Array.from(participant.videoTrackPublications.values()).some((publication) => !publication.isMuted));
+    return localHasVideo || remoteHasVideo;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  async configure({ breakoutRoom } = {}) {
+    if (this.livekitRoom.state !== import_livekit_client.ConnectionState.Disconnected) {
+      throw new Error("You cannot reconfigure while the controller is connected");
+    }
+    this._config = null;
+    this._configurationError = null;
+    this.notify();
+    try {
+      this._config = await this.room.livekit.getConnectionInfo({ breakoutRoom });
+      this.notify();
+    } catch (error) {
+      this._configurationError = error;
+      this.notify();
+      throw error;
+    }
+  }
+  async connect(options) {
+    const config = this._config;
+    if (config == null) {
+      throw new Error("The controller has not been configured");
+    }
+    const cameraEnabled = options?.camera?.enabled === true;
+    const microphoneEnabled = options?.microphone?.enabled === true;
+    this.pendingLocalMedia.setCameraUnavailable(false);
+    this.pendingLocalMedia.setMicrophoneUnavailable(false);
+    this.pendingLocalMedia.setPending({
+      cameraPending: cameraEnabled,
+      microphonePending: microphoneEnabled,
+      cameraAwaitEnableConfirmation: cameraEnabled,
+      microphoneAwaitEnableConfirmation: microphoneEnabled
+    });
+    const { camera: _camera, microphone: _microphone, ...connectOptions } = options ?? {};
+    try {
+      await this.livekitRoom.connect(config.url, config.token, connectOptions);
+      const localParticipant = this.livekitRoom.localParticipant;
+      await Promise.all([
+        cameraEnabled ? localParticipant.setCameraEnabled(true).then(() => this.pendingLocalMedia.setCameraUnavailable(false)).catch((error) => {
+          this.pendingLocalMedia.setCameraPending(false);
+          this.pendingLocalMedia.setCameraUnavailable(true);
+          console.warn("unable to enable camera after connecting", error);
+        }) : Promise.resolve(this.pendingLocalMedia.setCameraPending(false)),
+        microphoneEnabled ? localParticipant.setMicrophoneEnabled(true).then(() => this.pendingLocalMedia.setMicrophoneUnavailable(false)).catch((error) => {
+          this.pendingLocalMedia.setMicrophonePending(false);
+          this.pendingLocalMedia.setMicrophoneUnavailable(true);
+          console.warn("unable to enable microphone after connecting", error);
+        }) : Promise.resolve(this.pendingLocalMedia.setMicrophonePending(false))
+      ]);
+      this.syncPendingLocalMediaState();
+    } catch (error) {
+      this.pendingLocalMedia.clear();
+      throw error;
+    }
+  }
+  async disconnect() {
+    this.pendingLocalMedia.clear();
+    await this.livekitRoom.disconnect();
+  }
+  dispose() {
+    this.livekitRoom.removeAllListeners();
+    this.pendingLocalMedia.dispose();
+    this.listeners.clear();
+  }
+  onRoomChanged = () => {
+    this.syncPendingLocalMediaState();
+    this.notify();
+  };
+  syncPendingLocalMediaState() {
+    this.pendingLocalMedia.syncFromLocalParticipant(
+      this.livekitRoom.localParticipant,
+      this.livekitRoom.state === import_livekit_client.ConnectionState.Disconnected
+    );
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+}
+const MeetingControllerContext = (0, import_react.createContext)(null);
+function useMeetingController(controller) {
+  const contextController = (0, import_react.useContext)(MeetingControllerContext);
+  const resolved = controller ?? contextController;
+  if (resolved == null) {
+    throw new Error("useMeetingController must be used within MeetingScope or receive a controller");
+  }
+  (0, import_react.useSyncExternalStore)(
+    (listener) => resolved.subscribe(listener),
+    () => resolved.livekitRoom.state,
+    () => resolved.livekitRoom.state
+  );
+  return resolved;
+}
+function MeetingScope({
+  client,
+  breakoutRoom,
+  roomOptions,
+  children
+}) {
+  const controller = (0, import_react.useMemo)(() => new MeetingController({ room: client, roomOptions }), [client, roomOptions]);
+  (0, import_react.useEffect)(() => {
+    void controller.configure({ breakoutRoom });
+    return () => {
+      if (controller.isConnected) {
+        void controller.disconnect().catch((error) => {
+          console.warn("unable to disconnect", error);
+        });
+      }
+      controller.dispose();
+    };
+  }, [breakoutRoom, controller]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_wake_lock.WakeLocker, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MeetingControllerContext.Provider, { value: controller, children: typeof children === "function" ? children(controller) : children }) });
+}
+function firstEnabledVideoPublication(participant) {
+  return Array.from(participant.videoTrackPublications.values()).find(
+    (publication) => !publication.isMuted && publication.source === import_livekit_client.Track.Source.Camera && publication.videoTrack != null
+  );
+}

package/dist/cjs/meetings/meetings.d.ts

@@ -0,0 +1,5 @@
+export * from "./audio-visualization";
+export * from "./controls";
+export * from "./meeting-scope";
+export * from "./participants";
+export * from "./wake-lock";

package/dist/cjs/meetings/meetings.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var meetings_exports = {};
+module.exports = __toCommonJS(meetings_exports);
+__reExport(meetings_exports, require("./audio-visualization"), module.exports);
+__reExport(meetings_exports, require("./controls"), module.exports);
+__reExport(meetings_exports, require("./meeting-scope"), module.exports);
+__reExport(meetings_exports, require("./participants"), module.exports);
+__reExport(meetings_exports, require("./wake-lock"), module.exports);

package/dist/cjs/meetings/participants.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement } from "react";
+import { Participant, Room } from "livekit-client";
+import { MeetingController } from "./meeting-scope";
+export declare function ParticipantCamerasList({ controller: providedController, spacing, className, }: {
+    controller?: MeetingController;
+    spacing?: number;
+    className?: string;
+}): ReactElement;
+export declare function ParticipantTile({ room, participant, className, }: {
+    room: Room;
+    participant: Participant;
+    className?: string;
+}): ReactElement;

package/dist/cjs/meetings/participants.js

@@ -0,0 +1,154 @@
+"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 participants_exports = {};
+__export(participants_exports, {
+  ParticipantCamerasList: () => ParticipantCamerasList,
+  ParticipantTile: () => ParticipantTile
+});
+module.exports = __toCommonJS(participants_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_livekit_client = require("livekit-client");
+var import_lucide_react = require("lucide-react");
+var import_utils = require("../lib/utils");
+var import_audio_visualization = require("./audio-visualization");
+var import_meeting_scope = require("./meeting-scope");
+function useParticipantSnapshot(participant) {
+  (0, import_react.useSyncExternalStore)(
+    (listener) => {
+      const events = [
+        "trackPublished",
+        "trackSubscribed",
+        "trackUnpublished",
+        "trackUnsubscribed",
+        "trackMuted",
+        "trackUnmuted",
+        "localTrackPublished",
+        "localTrackUnpublished",
+        "participantNameChanged",
+        "isSpeakingChanged",
+        "attributesChanged"
+      ];
+      for (const eventName of events) {
+        participant.on(eventName, listener);
+      }
+      return () => {
+        for (const eventName of events) {
+          participant.off(eventName, listener);
+        }
+      };
+    },
+    () => `${participant.isMicrophoneEnabled}:${participant.isCameraEnabled}:${participant.name ?? ""}:${participant.isSpeaking}`,
+    () => ""
+  );
+}
+function useRoomSnapshot(room) {
+  (0, import_react.useSyncExternalStore)(
+    (listener) => {
+      const events = [
+        "participantConnected",
+        "participantDisconnected",
+        "trackPublished",
+        "trackSubscribed",
+        "trackUnpublished",
+        "trackUnsubscribed",
+        "trackMuted",
+        "trackUnmuted",
+        "localTrackPublished",
+        "localTrackUnpublished",
+        "activeSpeakersChanged"
+      ];
+      for (const eventName of events) {
+        room.on(eventName, listener);
+      }
+      return () => {
+        for (const eventName of events) {
+          room.off(eventName, listener);
+        }
+      };
+    },
+    () => `${room.remoteParticipants.size}:${room.localParticipant.sid}:${room.activeSpeakers.length}`,
+    () => ""
+  );
+}
+function ParticipantCamerasList({
+  controller: providedController,
+  spacing = 10,
+  className
+}) {
+  const controller = (0, import_meeting_scope.useMeetingController)(providedController);
+  const room = controller.livekitRoom;
+  useRoomSnapshot(room);
+  const participants = [
+    room.localParticipant,
+    ...Array.from(room.remoteParticipants.values())
+  ];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      className: (0, import_utils.cn)("flex h-full overflow-x-auto", className),
+      style: { gap: spacing },
+      children: participants.map((participant) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        ParticipantTile,
+        {
+          room,
+          participant,
+          className: "h-full min-h-40 min-w-64"
+        },
+        participant.sid || participant.identity
+      ))
+    }
+  );
+}
+function TrackVideo({ publication }) {
+  const ref = (0, import_react.useRef)(null);
+  const track = publication.videoTrack;
+  (0, import_react.useEffect)(() => {
+    const element = ref.current;
+    if (element == null || track == null) {
+      return void 0;
+    }
+    track.attach(element);
+    return () => {
+      track.detach(element);
+    };
+  }, [track]);
+  if (track == null) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("video", { ref, autoPlay: true, playsInline: true, muted: publication.source === import_livekit_client.Track.Source.Camera && publication.isLocal, className: "h-full w-full object-cover" });
+}
+function ParticipantTile({
+  room,
+  participant,
+  className
+}) {
+  useParticipantSnapshot(participant);
+  const publication = (0, import_meeting_scope.firstEnabledVideoPublication)(participant);
+  const muted = !participant.isMicrophoneEnabled;
+  const displayName = participant.name?.trim() || participant.identity || "Participant";
+  const isAgent = participant.kind === import_livekit_client.ParticipantKind.AGENT;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: (0, import_utils.cn)("aspect-[4/3] overflow-hidden rounded-md border bg-muted", className), children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "relative h-full w-full", children: [
+    publication != null ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TrackVideo, { publication }) : isAgent ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_audio_visualization.AudioWave, { room, participant }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "flex h-full w-full items-center justify-center bg-foreground text-background", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "text-4xl font-semibold", children: displayName.slice(0, 1).toUpperCase() }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "absolute bottom-2 left-2 flex max-w-[calc(100%-1rem)] items-center gap-1 rounded-md border border-white/15 bg-black/60 px-3 py-2 text-xs font-medium text-white", children: [
+      muted ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_lucide_react.MicOff, { className: "h-4 w-4 text-red-400" }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_lucide_react.Mic, { className: "h-4 w-4" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "truncate", children: displayName })
+    ] })
+  ] }) });
+}

package/dist/cjs/meetings/wake-lock.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement, ReactNode } from "react";
+export declare function WakeLocker({ children }: {
+    children: ReactNode;
+}): ReactElement;

package/dist/cjs/meetings/wake-lock.js

@@ -0,0 +1,55 @@
+"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 wake_lock_exports = {};
+__export(wake_lock_exports, {
+  WakeLocker: () => WakeLocker
+});
+module.exports = __toCommonJS(wake_lock_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+let wakeLockRefCount = 0;
+let wakeLockSentinel = null;
+async function enableWakeLock() {
+  if (!("wakeLock" in navigator)) {
+    return;
+  }
+  wakeLockSentinel = await navigator.wakeLock.request("screen");
+}
+async function disableWakeLock() {
+  const sentinel = wakeLockSentinel;
+  wakeLockSentinel = null;
+  await sentinel?.release();
+}
+function WakeLocker({ children }) {
+  (0, import_react.useEffect)(() => {
+    wakeLockRefCount += 1;
+    if (wakeLockRefCount === 1) {
+      void enableWakeLock().catch(() => {
+      });
+    }
+    return () => {
+      wakeLockRefCount = Math.max(wakeLockRefCount - 1, 0);
+      if (wakeLockRefCount === 0) {
+        void disableWakeLock().catch(() => {
+        });
+      }
+    };
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+}

package/dist/esm/{ChatBotView.js → chat/chat-bot-view.js}

@@ -9,8 +9,9 @@ import {
   Pencil
 } from "lucide-react";
 import { useThreadStatus } from "./chat-hooks";
-import { Chat } from "./Chat";
-import { Button } from "./components/ui/button";
+import { ChatThread } from "./chat-thread";
+import { DatasetChatThread } from "./dataset-chat-thread";
+import { Button } from "../components/ui/button";
 import {
   Dialog,
   DialogClose,
@@ -19,17 +20,17 @@ import {
   DialogFooter,
   DialogHeader,
   DialogTitle
-} from "./components/ui/dialog";
-import { Input } from "./components/ui/input";
-import { Label } from "./components/ui/label";
-import { Spinner } from "./components/ui/spinner";
+} from "../components/ui/dialog";
+import { Input } from "../components/ui/input";
+import { Label } from "../components/ui/label";
+import { Spinner } from "../components/ui/spinner";
 import {
   ChatThreadDisplayMode,
   chatDocumentPath,
   defaultThreadDisplayNameFromPath,
   resolvedThreadListPath
 } from "./conversation-descriptor";
-import { cn } from "./lib/utils";
+import { cn } from "../lib/utils";
 import { MultiThreadView } from "./multi-thread-view";
 const multiThreadLayoutBreakpointPx = 920;
 import {
@@ -41,6 +42,9 @@ function normalizePath(path) {
   const normalized = path?.trim();
   return normalized ? normalized : null;
 }
+function isDatasetBackedThreadPath(path) {
+  return path.startsWith("dataset://") || path.startsWith("tmp://");
+}
 function parseDate(value) {
   const parsed = new Date(value);
   return Number.isNaN(parsed.getTime()) ? /* @__PURE__ */ new Date(0) : parsed;
@@ -479,19 +483,24 @@ function ChatBotView({
     closeRenameThreadDialog();
   }, [activeSelectedThreadPath, closeRenameThreadDialog, emitResolvedThread, renameThreadDialog]);
   if (threadDisplayMode !== ChatThreadDisplayMode.MultiThreadComposer) {
-    return /* @__PURE__ */ jsx(
-      Chat,
+    return isDatasetBackedThreadPath(resolvedSingleThreadPath) ? /* @__PURE__ */ jsx(
+      DatasetChatThread,
+      {
+        room,
+        path: resolvedSingleThreadPath,
+        agentName,
+        emptyStateTitle,
+        emptyStateDescription
+      }
+    ) : /* @__PURE__ */ jsx(
+      ChatThread,
       {
         room,
         path: resolvedSingleThreadPath,
         participants,
         agentName,
-        toolkit,
-        tool,
-        centerComposer,
         emptyStateTitle,
-        emptyStateDescription,
-        onThreadResolved
+        emptyStateDescription
       }
     );
   }
@@ -510,16 +519,22 @@ function ChatBotView({
       onSelectedThreadResolved: emitResolvedThread,
       newThreadResetVersion,
       centerComposer,
-      builder: (threadPath) => /* @__PURE__ */ jsx(
-        Chat,
+      builder: (threadPath) => isDatasetBackedThreadPath(threadPath) ? /* @__PURE__ */ jsx(
+        DatasetChatThread,
+        {
+          room,
+          path: threadPath,
+          agentName,
+          emptyStateTitle: startNewThreadTitle,
+          emptyStateDescription: startNewThreadDescription
+        }
+      ) : /* @__PURE__ */ jsx(
+        ChatThread,
         {
           room,
           path: threadPath,
           participants,
           agentName,
-          toolkit,
-          tool,
-          centerComposer,
           emptyStateTitle: startNewThreadTitle,
           emptyStateDescription: startNewThreadDescription
         }