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

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

@@ -1,6 +1,7 @@
 ---
 title: Composer
 description: Build custom message input UIs with full control over layout and behavior.
+platforms: ["react"]
 ---
 
 import { ComposerPrimitiveSample } from "@/components/docs/samples/composer-primitive";
@@ -505,7 +506,7 @@ The dropzone sets `data-dragging` when a file is being dragged over it, so you c
 `DictationTranscript` renders a `<span>` showing the interim speech-to-text transcript while the user is speaking.
 
 <Callout type="info">
-Voice input requires a `DictationAdapter` configured in your runtime. See [Speech & Dictation](/docs/guides/speech) for setup.
+Voice input requires a `DictationAdapter` configured in your runtime. See [Dictation](/docs/guides/dictation) for setup.
 </Callout>
 
 ### Custom Submit Behavior
@@ -525,6 +526,46 @@ Use `onSubmit` on `Root` to intercept submission:
 </ComposerPrimitive.Root>
 ```
 
+### Gate Sending on External State
+
+Sometimes you want users to type while sending is temporarily blocked, for example while tool configuration, auth, or the first model context is still loading. Disabling the entire thread via `isDisabled` works but also disables the text input, which feels broken.
+
+Use `isSendDisabled` on the runtime adapter to keep the input usable while blocking send:
+
+```tsx
+const runtime = useExternalStoreRuntime({
+  isSendDisabled: !toolsLoaded,
+  onNew,
+  messages,
+  // ...
+});
+```
+
+When `isSendDisabled` is `true`:
+
+- `composer.canSend` becomes `false`
+- `<ComposerPrimitive.Send>` is disabled
+- Enter and the `Cmd/Ctrl+Shift+Enter` steer hotkey become no-ops
+- `aui.composer().send()` short-circuits at the runtime, so direct calls cannot escape the gate
+
+Read the same flag from React with `<AuiIf>` to render hints alongside the input:
+
+```tsx
+<ComposerPrimitive.Root>
+  <ComposerPrimitive.Input placeholder="Ask anything..." />
+  <AuiIf condition={(s) => !s.composer.canSend}>
+    <p className="text-sm text-muted-foreground">Loading tools, hang on...</p>
+  </AuiIf>
+  <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+</ComposerPrimitive.Root>
+```
+
+`canSend` reflects the composer's own willingness to send (editing mode, non-empty content, `isSendDisabled` not set). Cross-thread gating like an in-flight run without queue support is layered on top by `<ComposerPrimitive.Send>` automatically.
+
+`isSendDisabled` only gates the thread composer. Saving an in-progress message edit is unaffected, since it is a per-message action rather than a new send.
+
+For the difference between `isDisabled` and `isSendDisabled`, see the [external store adapter reference](/docs/runtimes/custom/external-store).
+
 ### Ctrl+Enter to Submit
 
 ```tsx
@@ -536,6 +577,19 @@ Use `onSubmit` on `Root` to intercept submission:
 
 With `submitMode="ctrlEnter"`, plain Enter inserts a newline and Ctrl/Cmd+Enter submits.
 
+### Mobile / touch devices
+
+```tsx
+<ComposerPrimitive.Root>
+  <ComposerPrimitive.Input unstable_insertNewlineOnTouchEnter />
+  <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+</ComposerPrimitive.Root>
+```
+
+`unstable_insertNewlineOnTouchEnter` switches Enter to insert a newline on touch-primary devices (detected via `(pointer: coarse) and (not (any-pointer: fine))`), so the on-screen Return key never accidentally sends a half-finished message. Submission moves to the explicit Send button, matching WhatsApp, Slack, Discord, iMessage, ChatGPT, and Claude.ai.
+
+Desktop behavior is unchanged. A tablet paired with a hardware keyboard still gets `submitMode`'s usual semantics if you set `submitMode="ctrlEnter"` or `"none"` — the flag only downgrades the default `"enter"` mode.
+
 ### Floating Composer
 
 Primitives aren't bound to any layout. Here's how the floating composer on this docs site is built, using the same `ComposerPrimitive.Root` and `ComposerPrimitive.Input` positioned with CSS:

package/.docs/raw/docs/primitives/error.mdx

@@ -1,6 +1,7 @@
 ---
 title: Error
 description: Accessible error display for messages with automatic error text extraction.
+platforms: ["react"]
 ---
 
 import { ErrorPrimitiveSample } from "@/components/docs/samples/error-primitive";

package/.docs/raw/docs/primitives/index.mdx

@@ -1,6 +1,7 @@
 ---
-title: Overview
-description: Unstyled, accessible building blocks for AI chat interfaces.
+title: Headless Chat Primitives
+description: Unstyled, accessible Radix-style building blocks for React AI chat interfaces — Thread, Composer, Message, and more, ready to compose with assistant-ui.
+platforms: ["react"]
 ---
 
 Primitives are the foundation of assistant-ui. They are unstyled, accessible React components that handle all the wiring for AI chat, including state management, keyboard shortcuts, auto-scrolling, streaming, and tool calls, so you can focus entirely on your UI.
@@ -84,7 +85,7 @@ Additional primitive references:
 - [ThreadListItemPrimitive](/docs/api-reference/primitives/thread-list-item)
 - [ThreadListItemMorePrimitive](/docs/api-reference/primitives/thread-list-item-more)
 - [ActionBarMorePrimitive](/docs/api-reference/primitives/action-bar-more)
-- [AssistantIf (`AuiIf`)](/docs/api-reference/primitives/assistant-if)
+- [AuiIf](/docs/api-reference/primitives/assistant-if)
 
 ## Common Mistakes
 

package/.docs/raw/docs/primitives/message.mdx

@@ -1,6 +1,7 @@
 ---
 title: Message
 description: Build custom message rendering with content parts, attachments, and hover state.
+platforms: ["react"]
 ---
 
 import { MessagePrimitiveSample } from "@/components/docs/samples/message-primitive";
@@ -108,7 +109,7 @@ Runtime setup: primitives require runtime context. Wrap your UI in `AssistantRun
 ```
 
 <Callout type="info">
-For most new `MessagePrimitive.Parts` code, prefer the `children` render function. Grouped Chain of Thought is the current exception: it plugs into `MessagePrimitive.Parts` via `components.ChainOfThought`.
+For most new code, prefer `MessagePrimitive.Parts` with a `children` render function. When you need adjacent grouping, use `MessagePrimitive.GroupedParts`.
 </Callout>
 
 ### Tool Resolution
@@ -145,7 +146,7 @@ Returning `null` still allows registered tool UIs and data renderer UIs to rende
 
 - `ToolGroup` wraps consecutive tool-call parts
 - `ReasoningGroup` wraps consecutive reasoning parts
-- `components.ChainOfThought` takes over all reasoning and tool-call rendering (mutually exclusive with `ToolGroup`, `ReasoningGroup`, `tools`, and `Reasoning`). Despite the deprecation of `components` in general, this is still the current way to wire grouped Chain of Thought.
+- `components.ChainOfThought` takes over all reasoning and tool-call rendering (mutually exclusive with `ToolGroup`, `ReasoningGroup`, `tools`, and `Reasoning`). This legacy path is deprecated; use `MessagePrimitive.GroupedParts` for grouped Chain of Thought in new code.
 - `data.by_name` and `data.Fallback` let you route custom data part types
 - `Quote` renders quoted message references from metadata
 - `Empty` and `Unstable_Audio` are available for edge and experimental rendering paths
@@ -187,7 +188,7 @@ Returning `null` still allows registered tool UIs and data renderer UIs to rende
 />
 ```
 
-For new code, use the `children` render function instead.
+For new code, use the `children` render function or `GroupedParts` instead.
 
 ### Hover State
 
@@ -247,6 +248,45 @@ Renders each content part with type-based component resolution.
 
 <PrimitivesTypeTable type="MessagePrimitivePartsProps" parameters={MessagePrimitiveDocs.Parts.props} />
 
+### GroupedParts
+
+Groups adjacent message parts into a nested tree. Use `groupBy` to return group keys for parts that should be grouped, then switch on `part.type` in the render function. Group cases render `children`; leaf cases render their own UI.
+
+```tsx
+<MessagePrimitive.GroupedParts
+  groupBy={(part) => {
+    if (part.type === "reasoning")
+      return ["group-chainOfThought", "group-reasoning"];
+    if (part.type === "tool-call")
+      return ["group-chainOfThought", "group-tool"];
+    return null;
+  }}
+>
+  {({ part, children }) => {
+    switch (part.type) {
+      case "group-chainOfThought":
+        return <div>{children}</div>;
+      case "group-reasoning":
+        return <ReasoningRoot>{children}</ReasoningRoot>;
+      case "group-tool":
+        return <ToolGroupRoot>{children}</ToolGroupRoot>;
+      case "text":
+        return <MarkdownText />;
+      case "reasoning":
+        return <Reasoning {...part} />;
+      case "tool-call":
+        return part.toolUI ?? <ToolFallback {...part} />;
+      case "data":
+        return part.dataRendererUI;
+      default:
+        return null;
+    }
+  }}
+</MessagePrimitive.GroupedParts>
+```
+
+<PrimitivesTypeTable type="MessagePrimitiveGroupedPartsProps" parameters={MessagePrimitiveDocs.GroupedParts.props} />
+
 ### Content
 
 Legacy alias for `Parts`.
@@ -340,7 +380,7 @@ Renders quote metadata when the current message includes a quote. Place it above
 
 ### Unstable_PartsGrouped
 
-Groups consecutive parts by a custom grouping function *(unstable)*.
+Groups parts by a custom grouping function *(unstable; use `GroupedParts` for adjacent grouping)*.
 
 ```tsx
 <MessagePrimitive.Unstable_PartsGrouped
@@ -453,9 +493,32 @@ import { ErrorPrimitive, MessagePrimitive } from "@assistant-ui/react";
 
 `ErrorPrimitive.Root` renders a `<div>` container with `role="alert"` and `ErrorPrimitive.Message` renders a `<span>` that displays the error text. `Root` always renders. Only `Message` conditionally returns `null` when there is no error. Wrap in `<MessagePrimitive.Error>` if you want the entire block to be conditional. See the [ErrorPrimitive API Reference](/docs/api-reference/primitives/error) for full details.
 
+### Render After Stream Completes
+
+To render content only once the assistant message has finished streaming (a follow-up card, a feedback prompt, a generated component that should not flicker through partial states), gate it with [`AuiIf`](/docs/api-reference/primitives/assistant-if) on `s.message.status`:
+
+```tsx
+import { MessagePrimitive, AuiIf } from "@assistant-ui/react";
+
+<MessagePrimitive.Root>
+  <MessagePrimitive.Parts />
+
+  <AuiIf
+    condition={(s) =>
+      s.message.role === "assistant" &&
+      s.message.status?.type === "complete"
+    }
+  >
+    <FollowUpCard />
+  </AuiIf>
+</MessagePrimitive.Root>;
+```
+
+`s.message.status` is a discriminated union of `running | requires-action | complete | incomplete`, defined only on assistant messages. The `role === "assistant"` guard keeps the predicate type-safe. For tool-call-driven generative UI that defers rendering inside the part itself, see [Deferred Rendering](/docs/guides/tool-ui#deferred-rendering) in the Generative UI guide.
+
 ### Legacy and Unstable APIs
 
-- `MessagePrimitive.Unstable_PartsGrouped` and `MessagePrimitive.Unstable_PartsGroupedByParentId` are unstable APIs for custom grouping.
+- `MessagePrimitive.Unstable_PartsGrouped` and `MessagePrimitive.Unstable_PartsGroupedByParentId` are unstable APIs for non-adjacent custom grouping.
 - `Unstable_PartsGroupedByParentId` is deprecated in favor of `Unstable_PartsGrouped`.
 
 ### Role-Based Styling

package/.docs/raw/docs/primitives/selection-toolbar.mdx

@@ -1,6 +1,7 @@
 ---
 title: SelectionToolbar
 description: A floating toolbar that appears when text is selected within a message.
+platforms: ["react"]
 ---
 
 import { SelectionToolbarPrimitiveSample } from "@/components/docs/samples/selection-toolbar-primitive";

package/.docs/raw/docs/primitives/suggestion.mdx

@@ -1,6 +1,7 @@
 ---
 title: Suggestion
 description: Suggested prompts that users can click to quickly send or populate the composer.
+platforms: ["react"]
 ---
 
 import { SuggestionPrimitiveSample } from "@/components/docs/samples/suggestion-primitive";
@@ -127,6 +128,15 @@ When `send={false}`, the `clearComposer` prop controls whether the suggestion re
 - **`clearComposer={true}`** (default): replaces the current composer text
 - **`clearComposer={false}`**: appends the suggestion to the existing text
 
+### Static configuration vs. runtime suggestions
+
+There are two separate data flows for suggestions:
+
+- **Static configuration** flows through the `suggestions` scope. Pass an array to `Suggestions(...)` in your runtime provider; render it with `ThreadPrimitive.Suggestions`. Best for welcome screen prompts.
+- **Runtime / dynamic suggestions** flow through `thread.suggestions`. Populate it via `SuggestionAdapter` (local runtime) or the `suggestions` field on `useExternalStoreRuntime`; render it with the shadcn `ThreadFollowupSuggestions` component or your own component reading `useAuiState((s) => s.thread.suggestions)`. Best for follow up prompts after a turn.
+
+See [Suggested Prompts](/docs/guides/suggestions) for end to end examples.
+
 ### ThreadPrimitive.Suggestion (Legacy)
 
 `ThreadPrimitive.Suggestion` is a self-contained button that takes a `prompt` prop directly. The newer pattern (`ThreadPrimitive.Suggestions` + `SuggestionPrimitive` parts) is preferred for structured suggestions with title and description:

package/.docs/raw/docs/primitives/thread-list.mdx

@@ -1,6 +1,7 @@
 ---
 title: ThreadList
 description: Multi-thread management for listing, creating, switching, archiving, and deleting conversations.
+platforms: ["react"]
 ---
 
 import { ThreadListPrimitiveSample } from "@/components/docs/samples/thread-list-primitive";
@@ -218,6 +219,44 @@ Renders a single thread at a specific index.
 
 <PrimitivesTypeTable type="ThreadListPrimitiveItemByIndexProps" parameters={ThreadListPrimitiveDocs.ItemByIndex.props} />
 
+#### LoadMore
+
+Button that appends the next page of threads. Renders a `<button>` element unless `asChild` is set, and is automatically disabled when the runtime is loading or when the adapter's last `list()` did not return a `nextCursor`. See [Threads concepts](/docs/runtimes/concepts/threads#paginating-the-thread-list) for the adapter contract.
+
+```tsx
+<ThreadListPrimitive.LoadMore className="rounded-lg border px-3 py-2 text-sm">
+  Load more
+</ThreadListPrimitive.LoadMore>
+```
+
+For scroll-driven loading, wrap `aui.threads().loadMore()` in your own `IntersectionObserver` at the application layer; assistant-ui ships the explicit button to keep the primitive surface predictable.
+
+```tsx
+import { useAui, useAuiState } from "@assistant-ui/react";
+import { useEffect, useRef } from "react";
+
+function LoadMoreSentinel() {
+  const aui = useAui();
+  const disabled = useAuiState(
+    (s) =>
+      !s.threads.hasMore || s.threads.isLoading || s.threads.isLoadingMore,
+  );
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el || disabled) return;
+    const observer = new IntersectionObserver(([entry]) => {
+      if (entry?.isIntersecting) aui.threads().loadMore();
+    });
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [aui, disabled]);
+
+  return disabled ? null : <div ref={ref} className="h-9" />;
+}
+```
+
 ### ThreadListItemPrimitive
 
 #### Root

package/.docs/raw/docs/primitives/thread.mdx

@@ -1,6 +1,7 @@
 ---
 title: Thread
 description: Build custom scrollable message containers with auto-scroll, empty states, and message rendering.
+platforms: ["react"]
 ---
 
 import { ThreadPrimitiveSample } from "@/components/docs/samples/thread-primitive";
@@ -123,7 +124,18 @@ By default, new messages appear at the bottom and scroll down. With `turnAnchor=
 </ThreadPrimitive.Viewport>
 ```
 
-This is what the shadcn Thread component uses by default. For scroll anchoring to work correctly, `ViewportSlack` is needed on the last assistant message to provide enough min-height for the user message to anchor at the top. This is included automatically in the shadcn component.
+When `turnAnchor="top"` is set, `MessagePrimitive.Root` automatically registers the latest assistant message as the top-anchor target and the preceding user message as the anchor — no additional component is required. The viewport itself manages a stable reserve element that provides the missing scroll range while the assistant response grows. This is the behavior used by the [Thread](/docs/ui/thread) component by default.
+
+Use `topAnchorMessageClamp` to control how much of a long user message remains visible when `turnAnchor="top"`. Messages up to `tallerThan` stay fully visible. For messages taller than that, `visibleHeight` controls how much of the message's bottom edge remains visible above the assistant response:
+
+```tsx
+<ThreadPrimitive.Viewport
+  turnAnchor="top"
+  topAnchorMessageClamp={{ tallerThan: "10em", visibleHeight: "6em" }}
+>
+  {/* messages */}
+</ThreadPrimitive.Viewport>
+```
 
 ### Viewport Scroll Options
 
@@ -274,18 +286,9 @@ Provides viewport context without rendering a scrollable element. Use this when
 
 ### ViewportSlack
 
-Adds min-height for scroll anchoring with `turnAnchor="top"`. It wraps its child element via `Slot` and does not render a DOM element of its own.
-
-```tsx
-<MessagePrimitive.Root>
-  <MessagePrimitive.Parts />
-  <ThreadPrimitive.ViewportSlack>
-    <div className="min-h-[40vh]" />
-  </ThreadPrimitive.ViewportSlack>
-</MessagePrimitive.Root>
-```
-
-Props: `fillClampThreshold` and `fillClampOffset` control how the slack height is calculated. `children` is required.
+<Callout type="warn">
+  `ThreadPrimitive.ViewportSlack` has been removed from the public API. Top-anchor target registration is handled automatically by `MessagePrimitive.Root` when `turnAnchor="top"`. Remove `ViewportSlack` from your tree; if you customized `fillClampThreshold` or `fillClampOffset` on `ViewportSlack` or `MessagePrimitive.Root`, replace those props with `topAnchorMessageClamp` on `ThreadPrimitive.Viewport`.
+</Callout>
 
 ### Messages
 

package/.docs/raw/docs/react-native/hooks.mdx

@@ -55,8 +55,8 @@ Subscribe to events without causing re-renders.
 ```tsx
 import { useAuiEvent } from "@assistant-ui/react-native";
 
-useAuiEvent("thread.runStart", (payload) => {
-  console.log("Run started:", payload);
+useAuiEvent("thread.modelContextUpdate", ({ threadId }) => {
+  console.log("Model context updated:", threadId);
 });
 ```
 

package/.docs/raw/docs/react-native/index.mdx

@@ -1,6 +1,6 @@
 ---
-title: Getting Started
-description: Build AI chat interfaces for iOS and Android with @assistant-ui/react-native.
+title: React Native AI Chat
+description: Build AI chat for iOS and Android with @assistant-ui/react-native — streaming, tools, attachments, and platform-native components from the same primitives as the web SDK.
 ---
 
 ## Quick Start
@@ -49,9 +49,7 @@ If you prefer to add assistant-ui to an existing Expo project, follow these step
 
 ### Install dependencies
 
-```sh
-npx expo install @assistant-ui/react-native @assistant-ui/react-ai-sdk
-```
+<InstallCommand expo={["@assistant-ui/react-native", "@assistant-ui/react-ai-sdk"]} />
 
   </Step>
   <Step>
@@ -71,7 +69,7 @@ export const maxDuration = 30;
 export async function POST(req: Request) {
   const { messages } = await req.json();
   const result = streamText({
-    model: openai("gpt-4o-mini"),
+    model: openai("gpt-5.4-nano"),
     messages: await convertToModelMessages(messages),
   });
   return result.toUIMessageStreamResponse();
@@ -87,7 +85,7 @@ export const maxDuration = 30;
 export async function POST(req: Request) {
   const { messages } = await req.json();
   const result = streamText({
-    model: anthropic("claude-sonnet-4-20250514"),
+    model: anthropic("claude-sonnet-4-6"),
     messages: await convertToModelMessages(messages),
   });
   return result.toUIMessageStreamResponse();

package/.docs/raw/docs/react-native/migration.mdx

@@ -29,9 +29,7 @@ If you already have an assistant-ui web app, most of your code transfers directl
 
 ### Install the React Native package
 
-```sh
-npx expo install @assistant-ui/react-native
-```
+<InstallCommand expo={["@assistant-ui/react-native"]} />
 
   </Step>
   <Step>