@ai-matrx/chat 0.6.6 → 0.7.0

package/CHANGELOG.md

@@ -1,8 +1,42 @@
 # @ai-matrx/chat
 
+## 0.7.0
+### BREAKING: the exports map is explicit (no wildcards)
+
+- `exports` lists every public module by name (`scripts/public-modules.json`, ~900 subpaths + `./host` + `./host/react`);
+  the 22 `./<domain>/*` wildcards are gone. A module that no consumer imports is no longer addressable from outside the
+  package (the tarball still carries it for the modules that import it). `node scripts/sync-public-surface.mjs --write`
+  adds what the sibling repos import; `--check` (`pnpm check:public-surface`, part of `check:package`) fails on a wildcard,
+  a listed module with no source, a FRONT_DOOR entry that is not listed, or an in-repo import the map does not export.
+  matrx-frontend's `check:chat-public-subpaths` reports a real-but-unexported module as `NOT_EXPORTED`.
+- New stable door `@ai-matrx/chat/agents/engine` (`createInstanceFull`, `destroyInstance`, `patchConversation`, `loadConversation`,
+  `smartExecute`, `cancelExecution`, `setUserInputText`, `selectIsExecuting`, `selectLatestRequestStatus`): a host that drives one
+  conversation by hand no longer deep-imports the redux internals. FRONT_DOOR now also names the host extension points the
+  extension and desktop use (ui-slots, composer-extensions, tool-renderer registry, coding-session reply door, ChatHistorySidebar,
+  ChatPanel, CredentialCaptureCard).
+- 36 modules nothing imported (and nothing in the package used) are deleted.
+- The package's own `@ai-matrx/chat/<sub>` self-imports in `src/` resolve through this same map, so they count as consumers:
+  16 self-imported modules (`ui/checkbox`, `ui/tabs`, `ui/aspect-ratio-options`, …) were missing and every bundler build of the
+  package failed (workflow-studio's vite build, AI Dream release 2026-10-08). `check:public-surface` and `--write` now include them.
+
 ## 0.6.6
 ### Unreleased
 
+- **Configured tool rows** `@ai-matrx/chat/tool-call-visualization/configured-rows/{register,registries,transforms,ConfiguredToolRow,...}`:
+  one config-driven row (verb per phase, icon per action, result fields) any host registers its tools into with
+  `registerConfiguredToolRenderers(configs | { names, load }, { namePrefixes, stripPrefix })`. New renderer chrome
+  `"row"`: the shell draws the renderer directly in every phase. Hosts add icons (`registerRowIcons`), transforms
+  (`registerRowTransforms`) and field components (`registerRowFieldComponents`); a config never pulls the whole lucide set.
+  `AskUserResponse` / `EMPTY_ASK_RESPONSE` live in `ui-first-tools/tools/ask-response` (no zod); the research overlay tabs load lazily.
+
+- **Host door** `@ai-matrx/chat/agents/components/chat/chat-door` (`chatDoor`, `createChatDoor`): a host's own code,
+  outside every React tree, puts text in the open composer's draft, opens a conversation, starts a new chat, sends a
+  message to an agent/mandate with named variables, and reads the open conversation id. Work asked before the chat
+  mounts is held, then delivered; it is refused out loud (`ChatDoorNotReadyError`) if the chat never mounts.
+- **`ChatHost.microphone`** (`ChatMicrophonePort.requestPermission`): a host that cannot show the browser's
+  microphone prompt where the chat lives (an extension side panel) obtains the grant elsewhere; the voice capture
+  retries once after it resolves `true` (`withMicrophoneGrant`, exported from `/host`). Default none — unchanged.
+
 - **One "Archived" place for every conversation list** (Arman, 2026-10-08). The separate "Archived (N)" toggle
   and the "Trash" disclosure are gone; `ConversationArchiveSection` (was `ConversationTrashSection`) is the one
   closed-by-default section at the foot of `ConversationHistorySidebar`, listing archived AND deleted

package/README.md

@@ -4,7 +4,7 @@ The one AI Matrx **person ↔ agent** chat. (For person ↔ person threads, use
 [`@ai-matrx/messaging`](https://www.npmjs.com/package/@ai-matrx/messaging).)
 
 One chat, one renderer. The package is the whole chat (running agents, conversations, tool calls,
-streaming, context, surfaces, voice) as per-module subpaths over a host contract whose only required
+streaming, context, surfaces, voice) as explicit per-module subpaths (no wildcards: `scripts/public-modules.json`) over a host contract whose only required
 value is a `db`.
 
 ## Install

package/dist/agents/components/agent-widgets/AgentChatHistorySidebar.js

@@ -1,17 +1,18 @@
 "use client";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { useEffect, useState } from "react";
-import { ArchivedDisclosure } from "@ai-matrx/design-system";
+import { useEffect } from "react";
 import { useAppDispatch, useAppSelector } from "../../../store/hooks.js";
 import { ScrollArea } from "@ai-matrx/design-system";
 import { Loader2, MessageSquare, AlertCircle } from "lucide-react";
 import { selectInstanceAgentId } from "../../redux/execution-system/instance-ui-state/instance-ui-state.selectors.js";
 import { fetchAgentConversations } from "../../redux/conversation-list/conversation-list.thunks.js";
 import { makeSelectAgentConversations } from "../../redux/conversation-list/conversation-list.selectors.js";
-import { ItemRow } from "../../../host/ui-slots.js";
-import { buildConversationMenu } from "../conversation-actions/conversationActionRegistry.js";
-import { renameConversation } from "../../redux/conversation-list/conversation-row-actions.thunks.js";
+import {
+  ConversationListRow,
+  agentRunHref
+} from "../conversation-history/AgentConversationList.js";
 import { ErrorAlchemyMenu } from "../../../host/ui-slots.js";
+import { ConversationArchiveSection } from "../conversation-history/ConversationArchiveSection.js";
 const IDLE_CONVERSATIONS = {
   status: "idle",
   conversations: [],
@@ -27,7 +28,6 @@ function AgentChatHistorySidebar({
   const { status, conversations, archived, error } = useAppSelector(
     (state) => selectConversations ? selectConversations(state) : IDLE_CONVERSATIONS
   );
-  const [showArchived, setShowArchived] = useState(false);
   useEffect(() => {
     if (!agentId) return;
     if (status === "idle") {
@@ -53,46 +53,29 @@ function AgentChatHistorySidebar({
         ConversationRow,
         {
           conv,
-          agentId,
-          dispatch
+          agentId
         },
         conv.conversationId
-      )),
-      agentId && /* @__PURE__ */ jsx(
-        ArchivedDisclosure,
-        {
-          count: archived.length,
-          open: showArchived,
-          onOpenChange: setShowArchived,
-          className: "mx-1 mt-1",
-          children: archived.map((conv) => /* @__PURE__ */ jsx(
-            ConversationRow,
-            {
-              conv,
-              agentId,
-              dispatch
-            },
-            conv.conversationId
-          ))
-        }
-      )
-    ] }) })
+      ))
+    ] }) }),
+    agentId && /* @__PURE__ */ jsx(ConversationArchiveSection, { agentIds: [agentId] })
   ] });
 }
 function ConversationRow({
   conv,
-  agentId,
-  dispatch
+  agentId
 }) {
   const date = conv.updatedAt ? new Date(conv.updatedAt).toLocaleDateString(void 0, {
     month: "short",
     day: "numeric"
   }) : null;
-  const href = `/agents/go/${agentId}/run?conversationId=${conv.conversationId}`;
   const secondary = [`${conv.messageCount} msg`, date].filter(Boolean).join(" \xB7 ");
   return /* @__PURE__ */ jsx(
-    ItemRow,
+    ConversationListRow,
     {
+      conv,
+      href: agentRunHref(agentId, conv.conversationId),
+      linkRow: true,
       sourceFeature: "conversation",
       entity: {
         type: "conversation",
@@ -100,29 +83,7 @@ function ConversationRow({
         title: conv.title || "Untitled"
       },
       className: "mx-1",
-      size: "sm",
-      label: conv.title || "Untitled",
-      secondaryLabel: secondary || void 0,
-      href,
-      menu: () => buildConversationMenu({
-        conversationId: conv.conversationId,
-        title: conv.title,
-        isFavorite: conv.isFavorite ?? false,
-        isArchived: conv.status === "archived",
-        excludeFromKg: conv.excludeFromKg ?? false,
-        href,
-        dispatch
-      }),
-      rename: {
-        value: conv.title ?? "",
-        emptyFallback: "Untitled",
-        onCommit: (next) => void dispatch(
-          renameConversation({
-            conversationId: conv.conversationId,
-            title: next
-          })
-        )
-      }
+      secondaryLabel: secondary || void 0
     }
   );
 }

package/dist/agents/components/chat/chat-door.d.ts

@@ -0,0 +1,67 @@
+/**
+ * THE HOST DOOR — what a host's OWN code (outside every React tree, often before the chat has
+ * mounted) can ask of the chat: put words in the composer, open a conversation, start a new chat,
+ * send a message to an agent, read which conversation is open. A browser extension's right-click
+ * menu, a desktop app's deep link and a web page's "ask about this" button all use it.
+ *
+ * It rebuilds nothing: the draft goes through `appendToComposerDraft` (the same door a tool's "use
+ * this path" takes), a conversation opens through the host's navigation port, and a send is the
+ * one `launchAgentExecution`. Work asked of it before the chat exists is HELD and delivered the
+ * moment `<ChatProvider>` has mounted — never dropped, never run against a half-built store.
+ */
+import type { ChatNavigationPort } from "../../../host/contract.js";
+import { type ChatStoreSingleton } from "../../../store/store-singleton.js";
+import type { AnyMandateKey } from "@ai-matrx/agents/mandates";
+import type { ManagedAgentOptions } from "../../types/instance.types.js";
+/** A message to send: to an agent (or the agent a mandate resolves to), with named variables. */
+export interface ChatDoorSend {
+    /** The words the person would have typed. */
+    text: string;
+    agentId?: string;
+    mandateKey?: AnyMandateKey;
+    /** Agent variables by NAME. Structured information goes here, never inside `text`. */
+    variables?: Record<string, unknown>;
+    /** Continue THIS conversation (a heartbeat or a reopened thread); absent starts a new one. */
+    conversationId?: string | null;
+}
+/** The part of a navigation port the door moves; `address` is the memory port's own current address. */
+export type ChatDoorNavigation = Pick<ChatNavigationPort, "push"> & {
+    address?(): string;
+};
+/** What the door reads from the world. Tests hand it fakes; the default reads the live host. */
+export interface ChatDoorEnv {
+    /** The host's navigation port, or null while no chat is mounted. */
+    navigation(): ChatDoorNavigation | null;
+    /** The chat store, or null while no chat is mounted. */
+    store(): ChatStoreSingleton | null;
+    /** Runs one launch against the store. */
+    launch(options: ManagedAgentOptions, store: ChatStoreSingleton): Promise<{
+        conversationId: string;
+    }>;
+    /** The page's own address when the host's navigation port names none. */
+    pageAddress(): string;
+}
+export interface ChatDoor {
+    /** The conversation the chat shows now, or null (new-chat screen, history, no chat yet). */
+    currentConversationId(): string | null;
+    openConversation(conversationId: string): Promise<void>;
+    startNewChat(): Promise<void>;
+    /** Add `text` to the open composer's draft on its own line; nothing is sent. Held until a composer exists. */
+    putTextInDraft(text: string): Promise<void>;
+    /** Send `message` to an agent and show the conversation. Resolves with the conversation id. */
+    sendMessage(message: ChatDoorSend): Promise<{
+        conversationId: string;
+    }>;
+}
+export interface ChatDoorOptions {
+    /** How often held work re-checks that the chat has mounted. */
+    pollMs?: number;
+    /** How long held work waits for the chat to mount before it is refused out loud. */
+    timeoutMs?: number;
+}
+export declare class ChatDoorNotReadyError extends Error {
+    constructor();
+}
+export declare function createChatDoor(env: ChatDoorEnv, options?: ChatDoorOptions): ChatDoor;
+/** The door over the live host and store. */
+export declare const chatDoor: ChatDoor;

package/dist/agents/components/chat/chat-door.js

@@ -0,0 +1,100 @@
+import { getChatHost, isChatHostConfigured } from "../../../host/configure.js";
+import { getStoreSingleton } from "../../../store/store-singleton.js";
+import { appendToComposerDraft } from "../../redux/execution-system/instance-user-input/append-to-composer-draft.thunk.js";
+const CONVERSATION_ADDRESS = /^\/chat\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:[/?#]|$)/i;
+class ChatDoorNotReadyError extends Error {
+  constructor() {
+    super("The chat is not open, so this request could not be delivered to it.");
+    this.name = "ChatDoorNotReadyError";
+  }
+}
+function createChatDoor(env, options = {}) {
+  const pollMs = options.pollMs ?? 100;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const whenReady = () => new Promise((resolve, reject) => {
+    const started = Date.now();
+    const check = () => {
+      const navigation = env.navigation();
+      const store = env.store();
+      if (navigation && store) return resolve({ navigation, store });
+      if (Date.now() - started >= timeoutMs) return reject(new ChatDoorNotReadyError());
+      setTimeout(check, pollMs);
+    };
+    check();
+  });
+  const addressOf = (navigation) => navigation.address ? navigation.address() : env.pageAddress();
+  const conversationIn = (address) => CONVERSATION_ADDRESS.exec(address)?.[1]?.toLowerCase() ?? null;
+  const composerConversation = (navigation, store) => {
+    const open = conversationIn(addressOf(navigation));
+    if (open) return open;
+    const focus = store.getState().conversationFocus;
+    const key = focus?.lastSurfaceKey;
+    return key && focus.bySurface[key]?.input || null;
+  };
+  return {
+    currentConversationId() {
+      const navigation = env.navigation();
+      return navigation ? conversationIn(addressOf(navigation)) : null;
+    },
+    async openConversation(conversationId) {
+      const { navigation } = await whenReady();
+      navigation.push(`/chat/${conversationId}`);
+    },
+    async startNewChat() {
+      const { navigation } = await whenReady();
+      navigation.push("/chat/new");
+    },
+    async putTextInDraft(text) {
+      if (!text) return;
+      const { navigation, store } = await whenReady();
+      const started = Date.now();
+      for (; ; ) {
+        const conversationId = composerConversation(navigation, store);
+        if (conversationId) {
+          store.dispatch(appendToComposerDraft(conversationId, text));
+          return;
+        }
+        if (Date.now() - started >= timeoutMs) throw new ChatDoorNotReadyError();
+        await new Promise((r) => setTimeout(r, pollMs));
+      }
+    },
+    async sendMessage(message) {
+      const { navigation, store } = await whenReady();
+      if (!message.agentId && !message.mandateKey) {
+        throw new Error("sendMessage needs an agentId or a mandateKey");
+      }
+      const result = await env.launch(
+        {
+          ...message.agentId ? { agentId: message.agentId } : {},
+          ...message.mandateKey ? { mandateKey: message.mandateKey } : {},
+          ...message.conversationId ? { conversationId: message.conversationId } : {},
+          surfaceKey: `chat-door:${message.agentId ?? message.mandateKey}`,
+          sourceFeature: "agent-runner",
+          config: { displayMode: "direct", autoRun: true },
+          runtime: {
+            userInput: message.text,
+            ...message.variables && Object.keys(message.variables).length > 0 ? { variables: message.variables } : {}
+          },
+          onConversationCreated: (conversationId) => navigation.push(`/chat/${conversationId}`)
+        },
+        store
+      );
+      return { conversationId: result.conversationId };
+    }
+  };
+}
+const chatDoor = createChatDoor({
+  // A navigation port that keeps its own address (the memory port) names the open conversation.
+  navigation: () => isChatHostConfigured() ? getChatHost().navigation : null,
+  store: () => getStoreSingleton(),
+  async launch(options, store) {
+    const { launchAgentExecution } = await import("../../redux/execution-system/thunks/launch-agent-execution.thunk.js");
+    return store.dispatch(launchAgentExecution(options)).unwrap();
+  },
+  pageAddress: () => typeof window === "undefined" ? "/" : window.location.pathname + window.location.search
+});
+export {
+  ChatDoorNotReadyError,
+  chatDoor,
+  createChatDoor
+};

package/dist/agents/components/conversation-history/AgentConversationList.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The ONE agent conversation list — loader hook, row, version groups.
+ *
+ * Every "the runs of this agent" panel (the agent-run history window, the
+ * advanced-editor History tab, the agent chat history sidebar, the run sidebar
+ * menu) used to carry its own copy of: resolve the canonical agent id → read
+ * the per-agent cache → fetch when idle → group by version → draw an `ItemRow`
+ * with the conversation menu and inline rename. Variants are props now:
+ * `sourceFeature`, `href`, `trailing`, `secondaryLabel`, `surfaceKey`.
+ */
+import { type ReactNode } from "react";
+import type { ItemRowProps } from "../../../ui/item-types.js";
+import type { ConversationListItem, ConversationListLoadStatus } from "../../redux/conversation-list/conversation-list.types.js";
+import { type ConversationMenuContext } from "../conversation-actions/conversationActionRegistry.js";
+/** "10:42 AM" today · "Yesterday" · "3d ago" · "Oct 8". */
+export declare function formatConversationDate(iso: string | null): string;
+export interface ConversationVersionGroup {
+    versionNumber: number;
+    conversations: ConversationListItem[];
+}
+/** Highest version first; within a version, newest first. */
+export declare function groupConversationsByVersion(conversations: ConversationListItem[]): ConversationVersionGroup[];
+export declare function agentRunHref(agentId: string, conversationId: string): string;
+export interface AgentConversationListState {
+    canonicalAgentId: string | null;
+    agentName: string | null;
+    status: ConversationListLoadStatus;
+    error: string | null;
+    fetchedAt: string | null;
+    conversations: ConversationListItem[];
+    archived: ConversationListItem[];
+    versionGroups: ConversationVersionGroup[];
+    archivedGroups: ConversationVersionGroup[];
+}
+/**
+ * Resolve the agent, read its cached conversation list, and fetch it once when
+ * the cache is idle. Pass `null` for "no agent chosen yet".
+ */
+export declare function useAgentConversationList(agentId: string | null | undefined): AgentConversationListState;
+export interface ConversationListRowProps {
+    conv: ConversationListItem;
+    /** Runner link for new-tab / copy-link; also handed to the menu. */
+    href: string;
+    /** `ItemRow` source feature (drives the row's context-menu family). */
+    sourceFeature: ItemRowProps["sourceFeature"];
+    active?: boolean;
+    onOpen?: () => void;
+    openInPlace?: boolean;
+    /** Whether the row is a link (`href` on the row) or only a click target. */
+    linkRow?: boolean;
+    size?: ItemRowProps["size"];
+    /** Menu surface key, when the host has one. */
+    surfaceKey?: string;
+    /** Attach-To entity (omit for hosts whose menu already carries Share). */
+    entity?: ItemRowProps["entity"];
+    /** The row's owning agent, handed to the menu as a door. */
+    agent?: {
+        id: string;
+        name: string | null;
+    };
+    /** Source provenance context for the menu. */
+    source?: ConversationMenuContext["source"];
+    /** Overrides `conv.isFavorite` (a host that overlays pins itself). */
+    isFavorite?: boolean;
+    /** Label for a conversation with no title. */
+    untitled?: string;
+    kebabAriaLabel?: string;
+    /** Called after a rename or menu mutation lands (the host re-reads). */
+    onMutationSuccess?: () => void;
+    secondaryLabel?: string;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    className?: string;
+}
+export declare function ConversationListRow({ conv, href, sourceFeature, active, onOpen, openInPlace, linkRow, size, surfaceKey, entity, agent, source, isFavorite, untitled, kebabAriaLabel, onMutationSuccess, secondaryLabel, leading, trailing, className, }: ConversationListRowProps): import("react").JSX.Element;
+/** Version groups (newest version open) + the one "Archived" section (archived + deleted). */
+export declare function AgentVersionGroupedList({ agentId, list, selectedId, onSelect, sourceFeature, }: {
+    agentId: string;
+    list: Pick<AgentConversationListState, "versionGroups">;
+    selectedId: string | null;
+    onSelect: (id: string) => void;
+    sourceFeature: ItemRowProps["sourceFeature"];
+}): import("react").JSX.Element;

package/dist/agents/components/conversation-history/AgentConversationList.js

@@ -0,0 +1,252 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { ChevronDown, ChevronRight, MessageSquare } from "lucide-react";
+import { Button } from "@ai-matrx/design-system/controls";
+import { ItemRow } from "../../../host/ui-slots.js";
+import { useAppDispatch, useAppSelector } from "../../../store/hooks.js";
+import { selectAgentById } from "../../redux/agent-definition/selectors.js";
+import { fetchAgentConversations } from "../../redux/conversation-list/conversation-list.thunks.js";
+import { makeSelectAgentConversations } from "../../redux/conversation-list/conversation-list.selectors.js";
+import { renameConversation } from "../../redux/conversation-list/conversation-row-actions.thunks.js";
+import { ConversationArchiveSection } from "./ConversationArchiveSection.js";
+import {
+  buildConversationMenu
+} from "../conversation-actions/conversationActionRegistry.js";
+function formatConversationDate(iso) {
+  if (!iso) return "";
+  const d = new Date(iso);
+  const now = /* @__PURE__ */ new Date();
+  const diffDays = Math.floor((now.getTime() - d.getTime()) / 864e5);
+  if (diffDays === 0)
+    return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  if (diffDays === 1) return "Yesterday";
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return d.toLocaleDateString([], { month: "short", day: "numeric" });
+}
+function groupConversationsByVersion(conversations) {
+  const map = /* @__PURE__ */ new Map();
+  for (const conv of conversations) {
+    const v = conv.agentVersionNumber ?? 0;
+    const group = map.get(v);
+    if (group) group.push(conv);
+    else map.set(v, [conv]);
+  }
+  return Array.from(map.entries()).sort(([a], [b]) => b - a).map(([versionNumber, convs]) => ({
+    versionNumber,
+    conversations: [...convs].sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    )
+  }));
+}
+function agentRunHref(agentId, conversationId) {
+  return `/agents/go/${agentId}/run?conversationId=${conversationId}`;
+}
+function useAgentConversationList(agentId) {
+  const dispatch = useAppDispatch();
+  const agentName = useAppSelector(
+    (state) => agentId ? selectAgentById(state, agentId)?.name ?? null : null
+  );
+  const canonicalAgentId = useAppSelector((state) => {
+    if (!agentId) return null;
+    const agent = selectAgentById(state, agentId);
+    return agent?.parentAgentId ?? agent?.id ?? agentId;
+  });
+  const selectConversations = useMemo(
+    () => canonicalAgentId ? makeSelectAgentConversations(canonicalAgentId, null) : null,
+    [canonicalAgentId]
+  );
+  const entry = useAppSelector(
+    (state) => selectConversations ? selectConversations(state) : null
+  );
+  const status = entry?.status ?? "idle";
+  const conversations = entry?.conversations ?? EMPTY;
+  const archived = entry?.archived ?? EMPTY;
+  useEffect(() => {
+    if (canonicalAgentId && status === "idle") {
+      dispatch(
+        fetchAgentConversations({
+          agentId: canonicalAgentId,
+          versionFilter: null
+        })
+      );
+    }
+  }, [canonicalAgentId, status, dispatch]);
+  const versionGroups = useMemo(
+    () => groupConversationsByVersion(conversations),
+    [conversations]
+  );
+  const archivedGroups = useMemo(
+    () => groupConversationsByVersion(archived),
+    [archived]
+  );
+  return {
+    canonicalAgentId,
+    agentName,
+    status,
+    error: entry?.error ?? null,
+    fetchedAt: entry?.fetchedAt ?? null,
+    conversations,
+    archived,
+    versionGroups,
+    archivedGroups
+  };
+}
+const EMPTY = [];
+function ConversationListRow({
+  conv,
+  href,
+  sourceFeature,
+  active,
+  onOpen,
+  openInPlace,
+  linkRow = false,
+  size = "sm",
+  surfaceKey,
+  entity,
+  agent,
+  source,
+  isFavorite,
+  untitled = "Untitled",
+  kebabAriaLabel,
+  onMutationSuccess,
+  secondaryLabel,
+  leading,
+  trailing,
+  className
+}) {
+  const dispatch = useAppDispatch();
+  const title = conv.title?.trim() || untitled;
+  return /* @__PURE__ */ jsx(
+    ItemRow,
+    {
+      sourceFeature,
+      entity,
+      className,
+      size,
+      label: title,
+      secondaryLabel,
+      href: linkRow ? href : void 0,
+      active,
+      onOpen,
+      openInPlace,
+      leading,
+      kebabAriaLabel,
+      menu: () => buildConversationMenu({
+        conversationId: conv.conversationId,
+        title: conv.title,
+        isFavorite: isFavorite ?? conv.isFavorite ?? false,
+        isArchived: conv.status === "archived",
+        excludeFromKg: conv.excludeFromKg ?? false,
+        href,
+        ...surfaceKey ? { surfaceKey } : {},
+        ...agent ? { agent } : {},
+        ...source ? { source } : {},
+        ...onMutationSuccess ? { onMutationSuccess } : {},
+        dispatch
+      }),
+      rename: {
+        value: conv.title ?? "",
+        emptyFallback: untitled,
+        onCommit: async (next) => {
+          const result = await dispatch(
+            renameConversation({
+              conversationId: conv.conversationId,
+              title: next
+            })
+          );
+          if (renameConversation.fulfilled.match(result)) {
+            onMutationSuccess?.();
+          }
+        }
+      },
+      trailing
+    }
+  );
+}
+function VersionGroupRow({
+  group,
+  agentId,
+  selectedId,
+  onSelect,
+  defaultOpen,
+  sourceFeature
+}) {
+  const [open, setOpen] = useState(defaultOpen);
+  const hasActive = group.conversations.some(
+    (c) => c.conversationId === selectedId
+  );
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsxs(
+      Button,
+      {
+        variant: "quiet",
+        pressed: hasActive,
+        icon: open ? /* @__PURE__ */ jsx(ChevronDown, {}) : /* @__PURE__ */ jsx(ChevronRight, {}),
+        onClick: () => setOpen((v) => !v),
+        className: "w-full",
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "text-[11px] font-semibold text-muted-foreground uppercase tracking-wide flex-1 min-w-0 truncate", children: group.versionNumber ? `Version ${group.versionNumber}` : "Latest" }),
+          /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground/60 shrink-0 ml-1", children: group.conversations.length })
+        ]
+      }
+    ),
+    open && /* @__PURE__ */ jsx("div", { className: "pl-2", children: group.conversations.map((conv) => {
+      const date = formatConversationDate(conv.updatedAt);
+      return /* @__PURE__ */ jsx(
+        ConversationListRow,
+        {
+          conv,
+          href: agentRunHref(agentId, conv.conversationId),
+          sourceFeature,
+          active: conv.conversationId === selectedId,
+          onOpen: () => onSelect(conv.conversationId),
+          trailing: /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-1 text-[10px] text-muted-foreground/70", children: [
+            /* @__PURE__ */ jsx(MessageSquare, { className: "w-2.5 h-2.5 shrink-0" }),
+            conv.messageCount,
+            date ? ` \xB7 ${date}` : ""
+          ] })
+        },
+        conv.conversationId
+      );
+    }) })
+  ] });
+}
+function AgentVersionGroupedList({
+  agentId,
+  list,
+  selectedId,
+  onSelect,
+  sourceFeature
+}) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    list.versionGroups.map((group, i) => /* @__PURE__ */ jsx(
+      VersionGroupRow,
+      {
+        group,
+        agentId,
+        selectedId,
+        onSelect,
+        defaultOpen: i === 0,
+        sourceFeature
+      },
+      group.versionNumber
+    )),
+    /* @__PURE__ */ jsx(
+      ConversationArchiveSection,
+      {
+        agentIds: [agentId],
+        onOpen: onSelect,
+        className: "mt-1"
+      }
+    )
+  ] });
+}
+export {
+  AgentVersionGroupedList,
+  ConversationListRow,
+  agentRunHref,
+  formatConversationDate,
+  groupConversationsByVersion,
+  useAgentConversationList
+};