@ai-matrx/chat 0.1.74 → 0.2.0

package/dist/public-chat/types/cx-tables.d.ts

@@ -0,0 +1,194 @@
+/**
+ * cx_ Database Table Types
+ *
+ * Canonical row/insert/update shapes come from `types/database.types.ts`.
+ * Content-block helpers below are for parsing JSON columns in the UI.
+ */
+import type { Database } from "../../host/db-types.js";
+import type { AudioMediaPart, DecisionAnswersPart, DocumentMediaPart, ImageMediaPart, VideoMediaPart, YouTubeMediaPart } from "@ai-matrx/agents/generated/stream-events";
+import type { PermissionLevel } from "../../ui/permission-levels.js";
+type ChatSchema = Database["chat"];
+export type CxConversation = ChatSchema["Tables"]["conversation"]["Row"];
+export type CxConversationInsert = ChatSchema["Tables"]["conversation"]["Insert"];
+export type CxConversationUpdate = ChatSchema["Tables"]["conversation"]["Update"];
+/** Common status values (DB column is unconstrained string) */
+export type CxConversationStatus = "active" | "completed" | "archived";
+/** Canonical row shape — 1:1 with `public.cx_message` (see types/database.types.ts). */
+export type CxMessage = ChatSchema["Tables"]["message"]["Row"];
+export type CxMessageInsert = ChatSchema["Tables"]["message"]["Insert"];
+export type CxMessageUpdate = ChatSchema["Tables"]["message"]["Update"];
+/**
+ * One entry in cx_message.content_history JSON — snapshot before an edit.
+ * At rest the column is Json; narrow when reading known-good rows.
+ */
+export interface CxContentHistoryEntry {
+    content: CxContentBlock[];
+    saved_at: string;
+}
+/**
+ * Roles used in cx_message.role.
+ * - user/assistant/system: standard roles
+ * - tool: tool-result placeholder row (content is usually [])
+ * - output: OpenAI-style intermediate thinking/reasoning output (content is thinking blocks only)
+ */
+export type CxMessageRole = "user" | "assistant" | "output" | "system" | "tool";
+/** DB status — NOT the same as UI streaming status */
+export type CxMessageDbStatus = "active" | "condensed" | "summary" | "deleted";
+/** Plain text content — the main display body */
+export interface CxTextContent {
+    type: "text";
+    text: string;
+    id?: string;
+    citations?: unknown[];
+    /**
+     * Open metadata bag (mirrors the python-generated `TextPart.metadata`).
+     * Carries `__ir` — the content-ir `IrEnvelopeCache` stamped at stream
+     * commit (`assembleMessageParts`) so reloads reuse parsed envelopes
+     * instead of re-parsing. See `@ai-matrx/content-ir` (core/envelope-cache).
+     */
+    metadata?: Record<string, unknown>;
+}
+export interface CxThinkingSummaryItem {
+    type: string;
+    text: string;
+}
+/** AI thinking/reasoning — collapsible section */
+export interface CxThinkingContent {
+    type: "thinking";
+    text: string;
+    provider?: string;
+    signature?: string;
+    signature_encoding?: string;
+    summary?: CxThinkingSummaryItem[];
+    metadata?: Record<string, unknown>;
+}
+/** Media attachments — always the generated chat.message.content contract. */
+export type CxMediaContent = ImageMediaPart | AudioMediaPart | VideoMediaPart | DocumentMediaPart | YouTubeMediaPart;
+/**
+ * Tool call — AI requests a tool (assistant/output messages).
+ * `id` is the join key to cx_tool_call.call_id for all providers.
+ */
+export interface CxToolCallContent {
+    type: "tool_call";
+    /**
+     * Wire-format tool call id. The server now persists this as `call_id` on
+     * every tool_call content block (matches `cx_tool_call.call_id`). The
+     * legacy pre-migration shape used `id` instead. Renderers normalise both
+     * via `call_id ?? id`.
+     */
+    call_id: string;
+    /** Legacy field — pre-migration persisted rows that haven't been touched. */
+    id?: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+/**
+ * Tool result — response from a tool.
+ * In V2, role="tool" messages always have content: [] (empty).
+ * Tool output lives in cx_tool_call.output, joined via cx_tool_call.call_id.
+ */
+export interface CxToolResultContent {
+    type: "tool_result";
+    call_id?: string;
+    tool_use_id?: string;
+    name: string;
+    content: unknown;
+    is_error?: boolean;
+}
+export interface CxCodeExecContent {
+    type: "code_exec";
+    language: string;
+    code: string;
+}
+export interface CxCodeResultContent {
+    type: "code_result";
+    output: string;
+    outcome: string;
+}
+export interface CxWebSearchContent {
+    type: "web_search";
+    id?: string;
+    status?: string;
+    metadata?: {
+        action?: Record<string, unknown>;
+    };
+}
+/**
+ * A decision turn's answers — the WHOLE content of that turn (a decision
+ * holder writes no prose at all).
+ *
+ * Not re-declared here: it is the server's own generated part contract, so a
+ * field the decision kind gains arrives with the next type generation instead
+ * of drifting into a second hand-written shape.
+ */
+export type CxDecisionAnswersContent = DecisionAnswersPart;
+/** Union of all content block types stored in cx_message.content */
+export type CxContentBlock = CxTextContent | CxThinkingContent | CxMediaContent | CxToolCallContent | CxToolResultContent | CxCodeExecContent | CxCodeResultContent | CxWebSearchContent | CxDecisionAnswersContent;
+/**
+ * @deprecated Use CxContentBlock instead. Kept for backward compatibility.
+ * Content is stored as a jsonb array of parts.
+ */
+export interface CxMessageContent {
+    type: string;
+    text?: string;
+    url?: string;
+    language?: string;
+    [key: string]: unknown;
+}
+export interface CxMedia {
+    id: string;
+    conversation_id: string | null;
+    created_by: string | null;
+    kind: CxMediaKind;
+    url: string;
+    mime_type: string | null;
+    file_size_bytes: number | null;
+    created_at: string;
+    deleted_at: string | null;
+    metadata: Record<string, unknown>;
+}
+export type CxMediaKind = "image" | "file" | "audio" | "video" | "youtube" | "webpage";
+export interface CxMediaInsert {
+    id?: string;
+    conversation_id?: string | null;
+    kind: CxMediaKind;
+    url: string;
+    mime_type?: string | null;
+    file_size_bytes?: number | null;
+    metadata?: Record<string, unknown>;
+}
+/** Lifecycle event stored in cx_tool_call.execution_events */
+export interface CxToolExecutionEvent {
+    event: "tool_started" | "tool_progress" | "tool_step" | "tool_result_preview" | "tool_completed" | "tool_error";
+    call_id: string;
+    tool_name: string;
+    timestamp: number;
+    message: string;
+    show_spinner: boolean;
+    data: Record<string, unknown>;
+}
+export type CxToolCallStatus = "pending" | "running" | "completed" | "error";
+export type CxToolType = "local" | "external_mcp" | "agent";
+export type CxToolCall = ChatSchema["Tables"]["tool_call"]["Row"];
+/** A conversation summary for the sidebar history list */
+export interface CxConversationSummary {
+    id: string;
+    title: string | null;
+    status: CxConversationStatus;
+    message_count: number;
+    created_at: string;
+    updated_at: string;
+}
+/** A shared conversation summary for the sidebar "Shared with Me" section */
+export interface SharedCxConversationSummary extends CxConversationSummary {
+    permission_level: PermissionLevel;
+    owner_email: string | null;
+}
+/** A full conversation with all its messages and tool calls, used when loading a chat */
+export interface CxConversationWithMessages {
+    conversation: CxConversation;
+    messages: CxMessage[];
+    /** Tool call records for this conversation, keyed by call_id for fast lookup */
+    toolCalls?: CxToolCall[];
+}
+export {};

package/dist/quick-actions/components/QuickChatSheet.d.ts

@@ -0,0 +1,69 @@
+/** The conversation on screen, reported so a host can bring it back after a reload. */
+export interface QuickChatConversationRef {
+    conversationId: string;
+    agentId: string;
+}
+interface QuickChatSheetProps {
+    className?: string;
+    /**
+     * A conversation to open: one handed off live by another canonical composer,
+     * or (with `resumeAgentId`) one a host remembered and is bringing back.
+     */
+    initialConversationId?: string;
+    /**
+     * The agent of a remembered `initialConversationId` that is not in memory —
+     * the sheet resumes it through the canonical reopen sequence instead of
+     * waiting for a live handoff.
+     */
+    resumeAgentId?: string;
+    /**
+     * Who draws the controls (history toggle, new chat). `"inline"` (default)
+     * draws the sheet's own row; `"host"` draws none and takes `showHistory` /
+     * `newChatSignal` from the host's chrome (a canvas tab header).
+     */
+    chrome?: "inline" | "host";
+    /** `chrome="host"`: whether the conversation history column is open. */
+    showHistory?: boolean;
+    /** `chrome="host"`: each change starts a fresh conversation. */
+    newChatSignal?: number;
+    /** Separates two sheets mounted at once (two canvas tabs) — surface + launcher keys. */
+    instanceKey?: string;
+    /** Called whenever the conversation on screen changes. */
+    onConversationChange?: (ref: QuickChatConversationRef) => void;
+}
+/**
+ * QuickChatSheet — pop-over chat that mirrors the live `/chat` route.
+ *
+ * Like `/chat`, it is agent-first: a compact agent picker switches the active
+ * agent (starting a fresh conversation with it), the transcript + input are the
+ * route's own `AgentConversationColumn` (centered), and an optional history
+ * sidebar lets you jump to any past conversation.
+ *
+ * Two conversation modes share one column:
+ *  - **live** — `useAgentLauncher(agentId)` owns a fresh conversation. Switching
+ *    agent or hitting "New chat" bumps `session`, minting a new surface key so
+ *    the launcher starts a brand-new conversation.
+ *  - **loaded** — a history row was clicked; we hydrate that conversation and
+ *    render it. "New chat" returns to live mode.
+ *
+ * **Include page context** (off by default — Quick Chat is a context-free chat
+ * you can open over anything). On, the conversation in the panel is stamped
+ * with the surface the person is looking at, which is the ONE mechanism the
+ * header Agents menu uses too: `smartExecute` → `refreshSurfaceScope` re-reads
+ * that surface's live values through the agent↔surface binding layers on every
+ * send. Off, the stamp and the surface-owned values are cleared, so the toggle
+ * never says "off" while page values still ride along. The conversation is
+ * still LAUNCHED with `surfaceName: null` either way — the stamp is applied
+ * after, so flipping the toggle never mints a new conversation.
+ *
+ * Rendered as bare content — surrounding chrome (the canvas tab header, which
+ * also carries the history / new-chat controls with `chrome="host"`, or the
+ * Utilities Hub tab) is supplied by the consumer.
+ *
+ * The starting agent is the `chat.default_new_chat` MANDATE (same as `/chat/new`):
+ * the wrapper resolves it (system default → the user's own binding) before the
+ * body mounts. Loud on failure — a skeleton while resolving, an error panel if
+ * the mandate can't resolve; never a hardcoded fallback agent.
+ */
+export declare function QuickChatSheet(props: QuickChatSheetProps): import("react").JSX.Element;
+export {};

package/dist/quick-actions/components/QuickChatSheet.js

@@ -0,0 +1,302 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { MessageSquarePlus, PanelLeft } from "lucide-react";
+import { Button } from "@ai-matrx/design-system/controls";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger
+} from "@ai-matrx/design-system";
+import { cn } from "@ai-matrx/design-system";
+import { useAppDispatch, useAppSelector } from "../../store/hooks.js";
+import { useAgentLauncher } from "../../agents/hooks/useAgentLauncher.js";
+import { AgentConversationColumn } from "../../agents/components/shared/AgentConversationColumn.js";
+import { ChatHistorySidebar } from "../../agents/components/chat/ChatHistorySidebar.js";
+import { ChatRoomSkeleton } from "../../agents/components/chat/ChatRoomSkeleton.js";
+import { DEFAULT_NEW_CHAT_MANDATE_KEY } from "../../agents/components/chat/chat-quick-actions.config.js";
+import { useMandate } from "../../mandates/useMandate.js";
+import { resumeConversation } from "../../agents/redux/execution-system/thunks/resume-conversation.thunk.js";
+import {
+  registerSurface,
+  unregisterSurface
+} from "../../agents/redux/surfaces/surfaces.slice.js";
+import { selectHasMessages } from "../../agents/redux/execution-system/messages/messages.selectors.js";
+import { clearFocus } from "../../agents/redux/execution-system/conversation-focus/conversation-focus.slice.js";
+import { ErrorAlchemyMenu } from "../../host/ui-slots.js";
+import { asClause } from "@ai-matrx/kit/text";
+import { WorkspaceGate } from "../../host/ui-slots.js";
+import { useComposerMode } from "../../agents/components/inputs/smart-input/composer/useComposerMode.js";
+import { useCompactInputMaxHeight } from "../../agents/components/inputs/smart-input/composer/useCompactInputMaxHeight.js";
+const SOURCE_FEATURE = "chat";
+const HISTORY_SCOPE = "quick-chat";
+function panelSurfaceKey(instanceKey) {
+  return instanceKey ? `quick-chat:panel:${instanceKey}` : "quick-chat:panel";
+}
+function liveSurfaceKey(agentId, session, instanceKey) {
+  return instanceKey ? `quick-chat:live:${instanceKey}:${agentId}:${session}` : `quick-chat:live:${agentId}:${session}`;
+}
+function loadedSurfaceKey(conversationId) {
+  return `quick-chat:loaded:${conversationId}`;
+}
+function QuickChatSheet(props) {
+  const { className, initialConversationId, resumeAgentId } = props;
+  const handedOffAgentId = useAppSelector(
+    (state) => initialConversationId ? state.conversations.byConversationId[initialConversationId]?.agentId : void 0
+  );
+  const { mandate, loading, error, organizationPending } = useMandate(DEFAULT_NEW_CHAT_MANDATE_KEY);
+  const waitingForHandoff = Boolean(initialConversationId && !handedOffAgentId && !resumeAgentId);
+  if (loading || waitingForHandoff) {
+    return /* @__PURE__ */ jsx("div", { className: cn("flex h-full flex-col overflow-hidden", className), children: /* @__PURE__ */ jsx(ChatRoomSkeleton, {}) });
+  }
+  if (organizationPending) {
+    return /* @__PURE__ */ jsx("div", { className: cn("flex h-full flex-col overflow-hidden", className), children: /* @__PURE__ */ jsx(WorkspaceGate, { blocked: true, sentence: "Chat needs a workspace to open.", children: /* @__PURE__ */ jsx(ChatRoomSkeleton, {}) }) });
+  }
+  if (error || !mandate) {
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "flex h-full flex-col items-center justify-center gap-2 px-6 text-center",
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-foreground", children: "Chat is unavailable right now." }),
+          /* @__PURE__ */ jsxs("p", { className: "max-w-sm text-xs text-muted-foreground", children: [
+            "The default chat agent could not be resolved",
+            asClause(error ? ` \u2014 ${error}` : ""),
+            ". Check your override on the Mandates page, or try again shortly.",
+            /* @__PURE__ */ jsx(ErrorAlchemyMenu, {})
+          ] })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    QuickChatSheetBody,
+    {
+      ...props,
+      initialAgentId: handedOffAgentId || resumeAgentId || mandate.agentId,
+      needsResume: Boolean(initialConversationId && !handedOffAgentId)
+    }
+  );
+}
+function QuickChatSheetBody({
+  className,
+  initialAgentId,
+  initialConversationId,
+  needsResume,
+  chrome = "inline",
+  showHistory: hostShowHistory = false,
+  newChatSignal = 0,
+  instanceKey = "",
+  onConversationChange
+}) {
+  const dispatch = useAppDispatch();
+  const panelSurface = panelSurfaceKey(instanceKey);
+  const [agentId, setAgentId] = useState(initialAgentId);
+  const [launchMandateKey, setLaunchMandateKey] = useState(void 0);
+  const { mode: composerMode } = useComposerMode();
+  const { measureRef, maxInputHeightPx } = useCompactInputMaxHeight();
+  const [session, setSession] = useState(0);
+  const [loadedConversationId, setLoadedConversationId] = useState(initialConversationId ?? null);
+  const [inlineShowHistory, setShowHistory] = useState(false);
+  const showHistory = chrome === "host" ? hostShowHistory : inlineShowHistory;
+  const [resuming, setResuming] = useState(needsResume);
+  const [seenNewChatSignal, setSeenNewChatSignal] = useState(newChatSignal);
+  if (newChatSignal !== seenNewChatSignal) {
+    setSeenNewChatSignal(newChatSignal);
+    setLoadedConversationId(null);
+    setResuming(false);
+    setSession((s) => s + 1);
+  }
+  const loadAbortRef = useRef(null);
+  const activeSurfaceKeyRef = useRef(null);
+  const resumeStartedRef = useRef(false);
+  useEffect(() => {
+    if (!needsResume || !initialConversationId || resumeStartedRef.current) return;
+    resumeStartedRef.current = true;
+    dispatch(
+      resumeConversation({
+        conversationId: initialConversationId,
+        agentId: initialAgentId,
+        surfaceKey: loadedSurfaceKey(initialConversationId),
+        sourceFeature: SOURCE_FEATURE
+      })
+    ).unwrap().catch((error) => {
+      console.error("[QuickChatSheet] could not bring the conversation back:", error);
+      setLoadedConversationId(null);
+    }).finally(() => setResuming(false));
+  }, [dispatch, needsResume, initialConversationId, initialAgentId]);
+  useEffect(() => {
+    dispatch(
+      registerSurface({
+        surfaceKey: panelSurface,
+        kind: "widget"
+      })
+    );
+    return () => {
+      dispatch(unregisterSurface(panelSurface));
+      const key = activeSurfaceKeyRef.current;
+      if (key) dispatch(clearFocus(key));
+    };
+  }, [dispatch, panelSurface]);
+  const currentLiveSurfaceKey = liveSurfaceKey(agentId, session, instanceKey);
+  const { conversationId: liveConversationId } = useAgentLauncher(agentId, {
+    surfaceKey: currentLiveSurfaceKey,
+    sourceFeature: SOURCE_FEATURE,
+    ...launchMandateKey ? { mandateKey: launchMandateKey } : {},
+    // Quick Chat mirrors /chat: it is its own primary conversation and can be
+    // opened over any page, so inheriting the page below would be accidental.
+    runtime: { surfaceName: null },
+    ready: !loadedConversationId,
+    config: { responseDensity: "compact" }
+  });
+  const isLoaded = !!loadedConversationId;
+  const conversationId = loadedConversationId ?? liveConversationId ?? null;
+  const surfaceKey = isLoaded ? loadedSurfaceKey(loadedConversationId) : currentLiveSurfaceKey;
+  const hasMessages = useAppSelector(selectHasMessages(conversationId ?? ""));
+  useEffect(() => {
+    if (conversationId && hasMessages && !resuming) onConversationChange?.({ conversationId, agentId });
+  }, [conversationId, agentId, hasMessages, resuming, onConversationChange]);
+  useEffect(() => {
+    activeSurfaceKeyRef.current = surfaceKey;
+  }, [surfaceKey]);
+  const bodyRef = useRef(null);
+  useEffect(() => {
+    if (!conversationId) return void 0;
+    let tries = 0;
+    const id = window.setInterval(() => {
+      const ta = bodyRef.current?.querySelector("textarea");
+      if (ta) {
+        ta.focus();
+        window.clearInterval(id);
+      } else if (++tries > 25) {
+        window.clearInterval(id);
+      }
+    }, 100);
+    return () => window.clearInterval(id);
+  }, [conversationId]);
+  const handleNewChat = useCallback(() => {
+    loadAbortRef.current?.abort();
+    setLoadedConversationId(null);
+    setSession((s) => s + 1);
+  }, []);
+  const handleSelectAgent = useCallback(
+    (id, via) => {
+      if (id === agentId && !loadedConversationId && via?.mandateKey === launchMandateKey) return;
+      loadAbortRef.current?.abort();
+      setLoadedConversationId(null);
+      setAgentId(id);
+      setLaunchMandateKey(via?.mandateKey);
+      setSession((s) => s + 1);
+    },
+    [agentId, loadedConversationId, launchMandateKey]
+  );
+  const handleOpenConversation = useCallback(
+    async (conv) => {
+      const targetSurfaceKey = loadedSurfaceKey(conv.conversationId);
+      loadAbortRef.current?.abort();
+      const ctrl = new AbortController();
+      loadAbortRef.current = ctrl;
+      try {
+        if (!conv.agentId) {
+          console.error(
+            "[QuickChatSheet] conversation has no agent \u2014 cannot reopen",
+            conv.conversationId
+          );
+          return;
+        }
+        setAgentId(conv.agentId);
+        await dispatch(
+          resumeConversation({
+            conversationId: conv.conversationId,
+            agentId: conv.agentId,
+            surfaceKey: targetSurfaceKey,
+            sourceFeature: SOURCE_FEATURE,
+            signal: ctrl.signal
+          })
+        ).unwrap();
+        if (ctrl.signal.aborted) return;
+        setLoadedConversationId(conv.conversationId);
+      } catch (error) {
+        if (ctrl.signal.aborted) return;
+        console.error("[QuickChatSheet] Failed to open conversation:", error);
+      }
+    },
+    [dispatch]
+  );
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex h-full flex-col overflow-hidden", className), children: [
+    chrome === "inline" ? /* @__PURE__ */ jsxs("div", { className: "flex h-10 shrink-0 items-center gap-1 border-b border-border px-2", children: [
+      /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+        /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            icon: /* @__PURE__ */ jsx(PanelLeft, {}),
+            variant: showHistory ? "outline" : "quiet",
+            className: "shrink-0",
+            onClick: () => setShowHistory((v) => !v),
+            "aria-label": "Toggle conversation history"
+          }
+        ) }),
+        /* @__PURE__ */ jsx(TooltipContent, { children: "Conversations" })
+      ] }) }),
+      /* @__PURE__ */ jsx("div", { className: "min-w-0 flex-1" }),
+      /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(Tooltip, { children: [
+        /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            icon: /* @__PURE__ */ jsx(MessageSquarePlus, {}),
+            variant: "quiet",
+            onClick: handleNewChat,
+            children: "New chat"
+          }
+        ) }),
+        /* @__PURE__ */ jsx(TooltipContent, { children: "Start a fresh conversation" })
+      ] }) })
+    ] }) : null,
+    /* @__PURE__ */ jsxs("div", { ref: bodyRef, className: "@container flex min-h-0 flex-1", children: [
+      showHistory && /* @__PURE__ */ jsx("div", { className: "w-64 shrink-0 border-r border-border @max-[520px]:w-full @max-[520px]:border-r-0", children: /* @__PURE__ */ jsx(
+        ChatHistorySidebar,
+        {
+          scopeId: HISTORY_SCOPE,
+          surfaceId: "chat",
+          activeConversationId: conversationId,
+          onOpenConversation: handleOpenConversation,
+          openInPlace: true,
+          excludeSourceFeatures: ["voice-agent"]
+        }
+      ) }),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: cn(
+            "flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden",
+            showHistory && "@max-[520px]:hidden"
+          ),
+          children: conversationId && !resuming ? /* @__PURE__ */ jsx("div", { ref: measureRef, className: "flex min-h-0 flex-1 overflow-hidden justify-center", children: /* @__PURE__ */ jsx(
+            AgentConversationColumn,
+            {
+              conversationId,
+              surfaceKey,
+              constrainWidth: true,
+              edgeToEdgeScroll: true,
+              smartInputProps: {
+                composer: {
+                  size: "compact",
+                  mode: composerMode,
+                  agent: { onSelectAgent: handleSelectAgent },
+                  maxInputHeightPx
+                }
+              }
+            }
+          ) }) : /* @__PURE__ */ jsx(ChatRoomSkeleton, {})
+        }
+      )
+    ] })
+  ] });
+}
+export {
+  QuickChatSheet
+};