@assistant-ui/mcp-docs-server 0.1.29 → 0.1.30

package/.docs/raw/docs/(reference)/api-reference/primitives/composer.mdx

@@ -416,76 +416,124 @@ import { AuiIf } from "@assistant-ui/react";
 </AuiIf>
 ```
 
-## Mention Primitives (Unstable)
+## Trigger Popover Primitives (Unstable)
 
 <Callout type="warn">
   These primitives are under the `Unstable_` prefix and may change without notice.
 </Callout>
 
-Primitives for an @-mention picker in the composer. See the [Mention component guide](/docs/ui/mention) for a pre-built implementation.
+Unified primitives for any character-triggered popover (`@` mentions, `/` slash commands, `:` emoji, etc.). Multiple triggers coexist under a single `TriggerPopoverRoot`. See the [Mentions guide](/docs/guides/mentions) and [Slash Commands guide](/docs/guides/slash-commands) for full documentation and the [ComposerTriggerPopover component](/docs/ui/composer-trigger-popover) for a pre-built implementation.
 
 ### Anatomy
 
 ```tsx
 import { ComposerPrimitive } from "@assistant-ui/react";
+import { unstable_defaultDirectiveFormatter } from "@assistant-ui/core";
 
 const Composer = () => (
-  <ComposerPrimitive.Unstable_MentionRoot adapter={mentionAdapter}>
+  <ComposerPrimitive.Unstable_TriggerPopoverRoot>
     <ComposerPrimitive.Root>
       <ComposerPrimitive.Input />
-      <ComposerPrimitive.Unstable_MentionPopover>
-        <ComposerPrimitive.Unstable_MentionCategories>
+
+      <ComposerPrimitive.Unstable_TriggerPopover
+        char="@"
+        adapter={mention.adapter}
+      >
+        <ComposerPrimitive.Unstable_TriggerPopover.Directive
+          {...mention.directive}
+        />
+        <ComposerPrimitive.Unstable_TriggerPopoverCategories>
           {(categories) =>
             categories.map((cat) => (
-              <ComposerPrimitive.Unstable_MentionCategoryItem
+              <ComposerPrimitive.Unstable_TriggerPopoverCategoryItem
                 key={cat.id}
                 categoryId={cat.id}
               >
                 {cat.label}
-              </ComposerPrimitive.Unstable_MentionCategoryItem>
+              </ComposerPrimitive.Unstable_TriggerPopoverCategoryItem>
             ))
           }
-        </ComposerPrimitive.Unstable_MentionCategories>
-        <ComposerPrimitive.Unstable_MentionItems>
+        </ComposerPrimitive.Unstable_TriggerPopoverCategories>
+        <ComposerPrimitive.Unstable_TriggerPopoverItems>
           {(items) =>
             items.map((item) => (
-              <ComposerPrimitive.Unstable_MentionItem
+              <ComposerPrimitive.Unstable_TriggerPopoverItem
                 key={item.id}
                 item={item}
               >
                 {item.label}
-              </ComposerPrimitive.Unstable_MentionItem>
+              </ComposerPrimitive.Unstable_TriggerPopoverItem>
             ))
           }
-        </ComposerPrimitive.Unstable_MentionItems>
-        <ComposerPrimitive.Unstable_MentionBack>
+        </ComposerPrimitive.Unstable_TriggerPopoverItems>
+        <ComposerPrimitive.Unstable_TriggerPopoverBack>
           Back
-        </ComposerPrimitive.Unstable_MentionBack>
-      </ComposerPrimitive.Unstable_MentionPopover>
+        </ComposerPrimitive.Unstable_TriggerPopoverBack>
+      </ComposerPrimitive.Unstable_TriggerPopover>
     </ComposerPrimitive.Root>
-  </ComposerPrimitive.Unstable_MentionRoot>
+  </ComposerPrimitive.Unstable_TriggerPopoverRoot>
 );
 ```
 
-### Unstable_MentionRoot
+### Unstable_TriggerPopoverRoot
+
+Root provider that groups one or more `TriggerPopover` declarations. Owns the shared `ComposerInputPluginRegistry` that routes cursor and keyboard events to each registered trigger.
+
+No props.
+
+### Unstable_TriggerPopover
+
+Declares a trigger and renders its popover container. Only renders its DOM (and children) while this trigger is active in the composer input. Each declaration has an isolated scope — sub-primitives placed inside read state from this declaration only.
+
+| Prop | Type | Default | Description |
+| --- | --- | --- | --- |
+| `char` | `string` | — | Character(s) that activate the trigger (e.g. `"@"`, `"/"`) — unique within the root |
+| `adapter` | `Unstable_TriggerAdapter` | — | Provides categories, items, and search |
+
+Selection behavior is declared by rendering **exactly one** behavior sub-primitive inside the `TriggerPopover`:
+
+- [`Unstable_TriggerPopover.Directive`](#unstable_triggerpopoverdirective) — inserts `:type[label]{name=id}` into the composer on selection (mention behavior).
+- [`Unstable_TriggerPopover.Action`](#unstable_triggerpopoveraction) — fires `onExecute` on selection; leaves a directive chip as an audit trail by default.
+
+Renders a `<div>` with `role="listbox"` when open.
+
+### Unstable_TriggerPopover.Directive
+
+Behavior sub-primitive. Placed inside a `<Unstable_TriggerPopover>`. Renders nothing — registers an `"directive"` behavior with its parent. Exactly one behavior sub-primitive is allowed per `TriggerPopover`.
+
+| Prop | Type | Default | Description |
+| --- | --- | --- | --- |
+| `formatter` | `Unstable_DirectiveFormatter` | `unstable_defaultDirectiveFormatter` | Serializes the selected item into composer text (and parses it back). |
+| `onInserted` | `(item) => void` | — | Fires after the directive text has been inserted. |
+
+### Unstable_TriggerPopover.Action
 
-Provider that wraps the composer with mention trigger detection, keyboard navigation, and popover state.
+Behavior sub-primitive. Placed inside a `<Unstable_TriggerPopover>`. Renders nothing — registers an `"action"` behavior with its parent. Exactly one behavior sub-primitive is allowed per `TriggerPopover`.
 
 | Prop | Type | Default | Description |
 | --- | --- | --- | --- |
-| `adapter` | `Unstable_MentionAdapter` | — | Provides categories, items, and search |
-| `trigger` | `string` | `"@"` | Character(s) that activate the popover |
-| `formatter` | `Unstable_DirectiveFormatter` | Default | Serializer/parser for mention directives |
+| `formatter` | `Unstable_DirectiveFormatter` | `unstable_defaultDirectiveFormatter` | Serializes the audit-trail chip (unused when `removeOnExecute` is true). |
+| `onExecute` | `(item) => void` | — | Called the moment an item is selected — typically routes to a handler map. Required. |
+| `removeOnExecute` | `boolean` | `false` | When `true`, strips the trigger text from the composer instead of leaving a chip. |
 
-### Unstable_MentionPopover
+### Unstable_TriggerBehavior
 
-Container that only renders when a mention trigger is active. Renders a `<div>` with `role="listbox"`.
+Union type returned by the two behavior sub-primitives and consumed internally by the popover resources. Exported for advanced use cases (e.g. custom sub-primitives).
 
-### Unstable_MentionCategories
+```ts
+import type { Unstable_TriggerBehavior } from "@assistant-ui/react";
+
+// Equivalent shape:
+// Unstable_TriggerBehavior =
+//   | { kind: "directive"; formatter: Unstable_DirectiveFormatter; onInserted?: (item) => void }
+//   | { kind: "action"; formatter: Unstable_DirectiveFormatter; onExecute: (item) => void; removeOnExecute?: boolean }
+```
+
+### Unstable_TriggerPopoverCategories
 
 Renders the top-level category list. Accepts a render function `(categories) => ReactNode`. Hidden when a category is selected or when in search mode.
 
-### Unstable_MentionCategoryItem
+### Unstable_TriggerPopoverCategoryItem
 
 A button that drills into a category. Renders `role="option"` with automatic `data-highlighted` and `aria-selected` when keyboard-navigated.
 
@@ -493,25 +541,26 @@ A button that drills into a category. Renders `role="option"` with automatic `da
 | --- | --- | --- |
 | `categoryId` | `string` | The category to select on click |
 
-### Unstable_MentionItems
+### Unstable_TriggerPopoverItems
 
 Renders the item list for the active category or search results. Accepts a render function `(items) => ReactNode`. Hidden when no category is selected and not in search mode.
 
-### Unstable_MentionItem
+### Unstable_TriggerPopoverItem
 
-A button that inserts a mention into the composer. Renders `role="option"` with automatic `data-highlighted` and `aria-selected` when keyboard-navigated.
+A button that selects an item. Renders `role="option"` with automatic `data-highlighted` and `aria-selected` when keyboard-navigated.
 
 | Prop | Type | Description |
 | --- | --- | --- |
-| `item` | `Unstable_MentionItem` | The item to insert on click |
+| `item` | `Unstable_TriggerItem` | The item to select on click |
+| `index` | `number` | Optional index override for highlight matching |
 
-### Unstable_MentionBack
+### Unstable_TriggerPopoverBack
 
 A button that navigates back from items to the category list. Only renders when a category is active.
 
-### unstable_useMentionContext
+### unstable_useTriggerPopoverScopeContext
 
-Hook to access the mention popover state and actions from within `Unstable_MentionRoot`.
+Hook to access the popover state and actions for the nearest enclosing `Unstable_TriggerPopover`.
 
 ```tsx
 const {
@@ -527,19 +576,79 @@ const {
   goBack,
   close,
   handleKeyDown,
-  formatter,
-} = unstable_useMentionContext();
+} = unstable_useTriggerPopoverScopeContext();
 ```
 
-### unstable_useToolMentionAdapter
+### unstable_useTriggerPopoverTriggers
+
+Hook to iterate every trigger registered under the current `Unstable_TriggerPopoverRoot`. Intended for input-level integrations (e.g. Lexical `DirectivePlugin`). Returns `ReadonlyMap<string, Unstable_RegisteredTrigger>`.
+
+### unstable_useMentionAdapter
 
-Hook that creates a `Unstable_MentionAdapter` from registered tools (via `useAssistantTool`).
+Returns a spreadable `{ adapter, directive }` bundle for `@` mentions. Reads tools registered via `useAssistantTool`, accepts explicit `items`, and supports multi-category drill-down.
 
 ```tsx
-import { unstable_useToolMentionAdapter } from "@assistant-ui/react";
+import {
+  unstable_useMentionAdapter,
+  type Unstable_Mention,
+} from "@assistant-ui/react";
+
+function MyComposer() {
+  // Default: tools from model context as a single "Tools" category
+  const mention = unstable_useMentionAdapter();
+
+  return (
+    <ComposerTriggerPopover char="@" {...mention} />
+  );
+}
+```
 
-const adapter = unstable_useToolMentionAdapter({
-  formatLabel: (name) => name.replaceAll("_", " "),
-  categoryLabel: "Tools",
+```tsx
+// Multi-category + tools appended as their own category
+const mention = unstable_useMentionAdapter({
+  categories: [
+    { id: "users", label: "Users", items: [/* ... */] },
+    { id: "files", label: "Files", items: [/* ... */] },
+  ],
+  includeModelContextTools: true,
 });
 ```
+
+Options:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `items` | `Unstable_Mention[]` | Flat list; ignored when `categories` is set. |
+| `categories` | `{ id, label, items: Unstable_Mention[] }[]` | Drill-down groups. |
+| `includeModelContextTools` | `boolean \| { category?, formatLabel?, icon? }` | Tools integration. Defaults to `true` iff neither `items` nor `categories`. |
+| `formatter` | `Unstable_DirectiveFormatter` | Override directive serialization. |
+| `onInserted` | `(item) => void` | Fires after the directive is inserted. |
+| `iconMap` | `Record<string, Unstable_IconComponent>` | `metadata.icon` / category id → React component. |
+| `fallbackIcon` | `Unstable_IconComponent` | Fallback when no `iconMap` entry matches. |
+
+Returns `{ adapter, directive, iconMap?, fallbackIcon? }`.
+
+### unstable_useSlashCommandAdapter
+
+Returns a spreadable `{ adapter, action }` bundle for slash commands. Commands are declared as data + inline `execute` callbacks; `execute` lives in the hook closure and is never attached to the returned `Unstable_TriggerItem`, keeping items JSON-serializable.
+
+```tsx
+import {
+  unstable_useSlashCommandAdapter,
+  type Unstable_SlashCommand,
+} from "@assistant-ui/react";
+
+const SLASH_COMMANDS: readonly Unstable_SlashCommand[] = [
+  { id: "summarize", execute: () => runSummarize(), icon: "FileText" },
+  { id: "translate", execute: () => runTranslate(), icon: "Languages" },
+];
+
+function MyComposer() {
+  const slash = unstable_useSlashCommandAdapter({ commands: SLASH_COMMANDS });
+  return (
+    <ComposerTriggerPopover char="/" {...slash} />
+  );
+}
+```
+
+Pass `removeOnExecute: true` on the hook options to strip the trigger text from the composer after executing. The hook also accepts `iconMap` / `fallbackIcon` options that flow into the returned bundle — `{...slash}` spreads them into `ComposerTriggerPopover`.

package/.docs/raw/docs/(reference)/api-reference/primitives/message-part.mdx

@@ -187,6 +187,8 @@ function MyComponent() {
 
 Each data component receives the full data part as props: `{ type: "data", name: string, data: T, status: MessagePartStatus }`.
 
+For a catch-all renderer (e.g. LangSmith's [`LoadExternalComponent`](/docs/runtimes/langgraph#dynamic-loading-with-fallback) loaded at runtime), pass `Fallback` via the inline `data` config on `MessagePrimitive.Parts`, or use the LangGraph adapter's [`uiComponents.fallback`](/docs/runtimes/langgraph#dynamic-loading-with-fallback) option.
+
 ### Messages (Sub-Agent)
 
 Renders nested messages from a tool call part's `messages` field. This is used in multi-agent setups where a sub-agent's conversation is embedded inside a tool call.

package/.docs/raw/docs/(reference)/api-reference/runtimes/thread-list-runtime.mdx

@@ -18,6 +18,10 @@ const aui = useAui();
 await aui.threads().switchToNewThread();
 await aui.threads().switchToThread(threadId);
 
+// Re-fetch the thread list from the remote adapter
+// (e.g. after async auth completes)
+await aui.threads().reload();
+
 // Access the main thread runtime
 const mainThread = aui.threads().main;
 

package/.docs/raw/docs/cloud/ai-sdk-assistant-ui.mdx

@@ -166,7 +166,7 @@ export default function ChatPage() {
               name: "history",
               type: "ThreadHistoryAdapter",
               description:
-                "Adapter for loading and saving thread history. Used to restore previous messages when switching threads.",
+                "Adapter for loading and saving thread history. Used to restore previous messages when switching threads. The adapter must implement `withFormat` when used with AI SDK — see [Persisting Chat History](/docs/runtimes/ai-sdk/v6#persisting-chat-history).",
             },
           ],
         },

package/.docs/raw/docs/primitives/composer.mdx

@@ -104,26 +104,31 @@ The primitive's behavior (keyboard handling, disabled state, form submission) is
 
 ### Unstable Trigger Popovers
 
-Composer includes an unstable **trigger popover** system for character-triggered popovers (e.g. `@` for mentions, `/` for slash commands). Multiple triggers can coexist on the same input.
-
-**Mentions** (`@` trigger) — insert directive text into the message:
+Composer includes an unstable **trigger popover** system for character-triggered popovers (e.g. `@` for mentions, `/` for slash commands). Multiple triggers coexist under a single `TriggerPopoverRoot`.
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionRoot adapter={mentionAdapter}>
+<ComposerPrimitive.Unstable_TriggerPopoverRoot>
   <ComposerPrimitive.Root>
-    <ComposerPrimitive.Input placeholder="Type @ to mention..." />
-    <ComposerPrimitive.Unstable_MentionPopover />
-  </ComposerPrimitive.Root>
-</ComposerPrimitive.Unstable_MentionRoot>
-```
-
-**Slash commands** (`/` trigger) — execute an action and clear the command text:
+    <ComposerPrimitive.Input placeholder="Type @ to mention, / for commands..." />
 
-```tsx
-<ComposerPrimitive.Unstable_SlashCommandRoot adapter={slashAdapter}>
-  <ComposerPrimitive.Root>
-    <ComposerPrimitive.Input placeholder="Type / for commands..." />
-    <ComposerPrimitive.Unstable_TriggerPopoverPopover>
+    {/* @ mention — inserts directive text into the message */}
+    <ComposerPrimitive.Unstable_TriggerPopover
+      char="@"
+      adapter={mentionAdapter}
+    >
+      <ComposerPrimitive.Unstable_TriggerPopover.Directive formatter={formatter} />
+      {/* popover UI */}
+    </ComposerPrimitive.Unstable_TriggerPopover>
+
+    {/* / slash command — runs a handler on selection; leaves an audit-trail chip by default */}
+    <ComposerPrimitive.Unstable_TriggerPopover
+      char="/"
+      adapter={slashAdapter}
+    >
+      <ComposerPrimitive.Unstable_TriggerPopover.Action
+        formatter={formatter}
+        onExecute={(item) => commandHandlers[item.id]?.()}
+      />
       <ComposerPrimitive.Unstable_TriggerPopoverItems>
         {(items) => items.map(item => (
           <ComposerPrimitive.Unstable_TriggerPopoverItem key={item.id} item={item}>
@@ -131,9 +136,9 @@ Composer includes an unstable **trigger popover** system for character-triggered
           </ComposerPrimitive.Unstable_TriggerPopoverItem>
         ))}
       </ComposerPrimitive.Unstable_TriggerPopoverItems>
-    </ComposerPrimitive.Unstable_TriggerPopoverPopover>
+    </ComposerPrimitive.Unstable_TriggerPopover>
   </ComposerPrimitive.Root>
-</ComposerPrimitive.Unstable_SlashCommandRoot>
+</ComposerPrimitive.Unstable_TriggerPopoverRoot>
 ```
 
 See the [Mentions guide](/docs/guides/mentions) and [Slash Commands guide](/docs/guides/slash-commands) for full documentation.
@@ -313,103 +318,130 @@ Clears the active quote from the composer. Renders a `<button>` element unless `
 </ComposerPrimitive.QuoteDismiss>
 ```
 
-### Unstable_MentionRoot
+### Unstable_TriggerPopoverRoot
 
-Provider that manages mention state and `@` trigger detection.
+Root provider that groups one or more `TriggerPopover` declarations and owns the shared input plugin registry.
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionRoot trigger="@" adapter={mentionAdapter}>
+<ComposerPrimitive.Unstable_TriggerPopoverRoot>
   <ComposerPrimitive.Root>
-    <LexicalComposerInput placeholder="Type @ to mention a tool..." />
-    <ComposerPrimitive.Unstable_MentionPopover />
+    <LexicalComposerInput placeholder="Type @ to mention, / for commands..." />
+    <ComposerPrimitive.Unstable_TriggerPopover char="@" adapter={mentionAdapter}>
+      <ComposerPrimitive.Unstable_TriggerPopover.Directive formatter={formatter} />
+      ...
+    </ComposerPrimitive.Unstable_TriggerPopover>
   </ComposerPrimitive.Root>
-</ComposerPrimitive.Unstable_MentionRoot>
+</ComposerPrimitive.Unstable_TriggerPopoverRoot>
 ```
 
-<PrimitivesTypeTable type="ComposerPrimitiveMentionRootProps" parameters={ComposerPrimitiveDocs.Unstable_MentionRoot.props} />
+### Unstable_TriggerPopover
 
-### Unstable_MentionPopover
-
-Container for the mention picker popover. It only renders while a trigger match is active.
+Declares a trigger (by `char`, `adapter`) and renders the popover container. Selection behavior is declared by rendering exactly one behavior sub-primitive inside — either `<Unstable_TriggerPopover.Directive>` (insert a directive on selection) or `<Unstable_TriggerPopover.Action>` (run `onExecute` on selection). Only renders its DOM (and children) while the trigger is active in the composer input.
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionPopover className="rounded-lg border bg-popover p-1 shadow-md">
-  <ComposerPrimitive.Unstable_MentionCategories>
+<ComposerPrimitive.Unstable_TriggerPopover
+  char="@"
+  adapter={mentionAdapter}
+  className="rounded-lg border bg-popover p-1 shadow-md"
+>
+  <ComposerPrimitive.Unstable_TriggerPopover.Directive formatter={formatter} />
+  <ComposerPrimitive.Unstable_TriggerPopoverCategories>
     {(categories) => categories.map((category) => (
-      <ComposerPrimitive.Unstable_MentionCategoryItem
+      <ComposerPrimitive.Unstable_TriggerPopoverCategoryItem
         key={category.id}
         categoryId={category.id}
       >
         {category.label}
-      </ComposerPrimitive.Unstable_MentionCategoryItem>
+      </ComposerPrimitive.Unstable_TriggerPopoverCategoryItem>
     ))}
-  </ComposerPrimitive.Unstable_MentionCategories>
-</ComposerPrimitive.Unstable_MentionPopover>
+  </ComposerPrimitive.Unstable_TriggerPopoverCategories>
+</ComposerPrimitive.Unstable_TriggerPopover>
+```
+
+Behavior is supplied by exactly one of two sub-primitives:
+
+- `<Unstable_TriggerPopover.Directive formatter={...} onInserted={...} />` — writes `:type[label]{name=id}` into the composer text (mention behavior)
+- `<Unstable_TriggerPopover.Action onExecute={...} removeOnExecute={...} />` — runs a callback on selection; leaves a directive chip behind by default (slash-command behavior)
+
+### Unstable_TriggerPopover.Directive
+
+Behavior sub-primitive. Registers the directive-insert behavior with its parent `TriggerPopover`. Renders nothing.
+
+```tsx
+<ComposerPrimitive.Unstable_TriggerPopover.Directive
+  formatter={unstable_defaultDirectiveFormatter}
+  onInserted={(item) => track("mention", item.id)}
+/>
+```
+
+### Unstable_TriggerPopover.Action
+
+Behavior sub-primitive. Registers the action behavior with its parent `TriggerPopover`. Renders nothing. By default leaves a directive chip behind after executing (audit trail); pass `removeOnExecute` to strip the trigger text entirely.
+
+```tsx
+<ComposerPrimitive.Unstable_TriggerPopover.Action
+  onExecute={(item) => commandHandlers[item.id]?.()}
+  removeOnExecute={false}
+/>
 ```
 
-### Unstable_MentionCategories
+### Unstable_TriggerPopoverCategories
 
-Render-function primitive for the top-level mention categories.
+Render-function primitive for the top-level category list. Only renders while no category is active and search mode is off.
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionCategories>
+<ComposerPrimitive.Unstable_TriggerPopoverCategories>
   {(categories) => categories.map((category) => (
-    <ComposerPrimitive.Unstable_MentionCategoryItem
+    <ComposerPrimitive.Unstable_TriggerPopoverCategoryItem
       key={category.id}
       categoryId={category.id}
     >
       {category.label}
-    </ComposerPrimitive.Unstable_MentionCategoryItem>
+    </ComposerPrimitive.Unstable_TriggerPopoverCategoryItem>
   ))}
-</ComposerPrimitive.Unstable_MentionCategories>
+</ComposerPrimitive.Unstable_TriggerPopoverCategories>
 ```
 
-<PrimitivesTypeTable type="ComposerPrimitiveMentionCategoriesProps" parameters={ComposerPrimitiveDocs.Unstable_MentionCategories.props} />
+### Unstable_TriggerPopoverCategoryItem
 
-### Unstable_MentionCategoryItem
-
-Button that selects a mention category and drills into its items.
+Button that selects a category and drills into its items.
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionCategoryItem categoryId="tools">
+<ComposerPrimitive.Unstable_TriggerPopoverCategoryItem categoryId="tools">
   Tools
-</ComposerPrimitive.Unstable_MentionCategoryItem>
+</ComposerPrimitive.Unstable_TriggerPopoverCategoryItem>
 ```
 
-### Unstable_MentionItems
+### Unstable_TriggerPopoverItems
 
-Render-function primitive for the items inside the currently selected category.
+Render-function primitive for the items inside the currently selected category (or global search results).
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionItems>
+<ComposerPrimitive.Unstable_TriggerPopoverItems>
   {(items) => items.map((item) => (
-    <ComposerPrimitive.Unstable_MentionItem key={item.id} item={item} />
+    <ComposerPrimitive.Unstable_TriggerPopoverItem key={item.id} item={item} />
   ))}
-</ComposerPrimitive.Unstable_MentionItems>
+</ComposerPrimitive.Unstable_TriggerPopoverItems>
 ```
 
-<PrimitivesTypeTable type="ComposerPrimitiveMentionItemsProps" parameters={ComposerPrimitiveDocs.Unstable_MentionItems.props} />
-
-### Unstable_MentionItem
+### Unstable_TriggerPopoverItem
 
-Selectable mention item inside the popover.
+Selectable item inside the popover.
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionItem item={item}>
+<ComposerPrimitive.Unstable_TriggerPopoverItem item={item}>
   {item.label}
-</ComposerPrimitive.Unstable_MentionItem>
+</ComposerPrimitive.Unstable_TriggerPopoverItem>
 ```
 
-<PrimitivesTypeTable type="ComposerPrimitiveMentionItemProps" parameters={ComposerPrimitiveDocs.Unstable_MentionItem.props} />
-
-### Unstable_MentionBack
+### Unstable_TriggerPopoverBack
 
 Back button used when drilling from categories into a specific item list.
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionBack className="rounded-md px-2 py-1 text-sm hover:bg-accent">
+<ComposerPrimitive.Unstable_TriggerPopoverBack className="rounded-md px-2 py-1 text-sm hover:bg-accent">
   Back
-</ComposerPrimitive.Unstable_MentionBack>
+</ComposerPrimitive.Unstable_TriggerPopoverBack>
 ```
 
 ## Patterns

package/.docs/raw/docs/runtimes/ai-sdk/v6.mdx

@@ -154,6 +154,63 @@ export function TokenCounter() {
   </Step>
 </Steps>
 
+## Persisting Chat History
+
+By default, messages live only in memory and reset on reload. To persist and restore history per thread, provide a `ThreadHistoryAdapter` via `adapters.history`.
+
+<Callout type="warn">
+  The adapter **must** implement `withFormat`. `useChatRuntime` persists history through `withFormat(fmt)` so messages round-trip as AI SDK `UIMessage` objects. An adapter without `withFormat` throws at runtime — `load` / `append` on the top level are unused in the AI SDK path.
+</Callout>
+
+<Callout type="info">
+  For server-side cloud persistence with zero adapter code, see the [AssistantCloud integration](/docs/cloud/ai-sdk-assistant-ui).
+</Callout>
+
+### Example
+
+```tsx
+"use client";
+
+import { useChatRuntime } from "@assistant-ui/react-ai-sdk";
+import type { ThreadHistoryAdapter } from "@assistant-ui/react";
+
+const historyAdapter: ThreadHistoryAdapter = {
+  // Required by the type — unused by useChatRuntime.
+  async load() {
+    return { headId: null, messages: [] };
+  },
+  async append() {},
+
+  // `fmt` encodes UIMessage ↔ storage rows (ai-sdk/v6 format).
+  withFormat: (fmt) => ({
+    async load() {
+      const rows = await fetch("/api/history").then((r) => r.json());
+      return { messages: rows.map(fmt.decode) };
+    },
+    async append(item) {
+      await fetch("/api/history", {
+        method: "POST",
+        body: JSON.stringify({
+          id: fmt.getId(item.message),
+          parent_id: item.parentId,
+          format: fmt.format,
+          content: fmt.encode(item),
+        }),
+      });
+    },
+  }),
+};
+
+function Chat() {
+  const runtime = useChatRuntime({
+    adapters: { history: historyAdapter },
+  });
+  // ...
+}
+```
+
+Each persisted row follows `{ id, parent_id, format, content }`; `fmt.encode` produces the `content` payload and `fmt.decode` reverses it, so your backend never needs to know about `UIMessage` internals.
+
 ## Key Changes from v5
 
 | Feature | v5 | v6 |

package/.docs/raw/docs/runtimes/custom/custom-thread-list.mdx

@@ -216,12 +216,58 @@ When the hook mounts it calls `list()` on your adapter, hydrates existing thread
 
 ## Thread Lifecycle Cheatsheet
 
-- `list()` hydrates threads on mount and during refreshes.
+- `list()` hydrates threads on mount. It runs once; call `runtime.threads.reload()` to re-fetch.
 - Creating a new conversation calls `initialize()` once the user sends the first message.
 - `archive`, `unarchive`, and `delete` are called optimistically; throw to revert the UI.
 - `generateTitle()` powers the automatic title button and expects an `AssistantStream`.
 - Provide a `runtimeHook` that always returns a fresh runtime instance per active thread.
 
+## Reloading After Async Authentication
+
+If your adapter depends on an authenticated user (e.g. an OIDC provider, `better-auth`, `next-auth`) and the auth state resolves asynchronously after `useRemoteThreadListRuntime` has mounted, the initial `list()` call may run before the user is available. Call `aui.threads().reload()` when auth completes to re-fetch with the authenticated request.
+
+```tsx title="app/ThreadListProvider.tsx"
+"use client";
+
+import { useEffect } from "react";
+import { useAuth } from "react-oidc-context";
+import {
+  AssistantRuntimeProvider,
+  useAui,
+  useLocalRuntime,
+  useRemoteThreadListRuntime,
+} from "@assistant-ui/react";
+
+function ReloadOnAuth() {
+  const aui = useAui();
+  const { isLoading, user } = useAuth();
+
+  useEffect(() => {
+    if (!isLoading && user) {
+      aui.threads().reload();
+    }
+  }, [isLoading, user?.id]);
+
+  return null;
+}
+
+export function ThreadListProvider({ children }) {
+  const runtime = useRemoteThreadListRuntime({
+    runtimeHook: () => useLocalRuntime(myModelAdapter),
+    adapter: useThreadListAdapter(),
+  });
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <ReloadOnAuth />
+      {children}
+    </AssistantRuntimeProvider>
+  );
+}
+```
+
+`reload()` replaces the cached load promise and discards any in-flight response from a superseded call, so it is safe to invoke multiple times (for example, on logout followed by a new login). `useAui` must be called inside `AssistantRuntimeProvider`, so the effect lives in a child component.
+
 ## Avoiding Race Conditions in History Adapters
 
 <Callout type="warn">