@assistant-ui/mcp-docs-server 0.1.38 → 0.2.0

package/.docs/raw/docs/migrations/v0-15.mdx

@@ -0,0 +1,156 @@
+---
+title: Migration to v0.15
+description: Drops the v0.12-era legacy runtime hooks, the deprecated tools map, and the "mcp-app" group key. Scope accessors become properties.
+---
+
+Version 0.15 finishes the deprecation cycle started in v0.12: the legacy context hooks are removed in favor of `useAui` / `useAuiState`, and `aui` scope accessors become properties.
+
+## Migrate with an AI Agent
+
+Paste this into an AI coding agent to run the migration for you:
+
+```text
+Migrate this codebase from assistant-ui v0.14 to v0.15.
+
+1. Read the migration guide: https://assistant-ui.com/docs/migrations/v0-15
+2. Run `npx assistant-ui@latest upgrade` to apply the codemods.
+3. Apply the remaining changes from the guide by hand:
+   - Replace removed legacy hooks with the useAui / useAuiState
+     equivalents from the guide's mapping table.
+   - Replace availability checks with `aui.<scope>.source != null`.
+   - Replace `s.tools.tools` reads with `s.tools.toolUIs`.
+   - Replace the "mcp-app" groupPartByType key with "standalone-tool-call".
+4. Typecheck, build, and run tests; fix any remaining fallout.
+```
+
+## Automatic Migration
+
+```bash
+npx assistant-ui@latest upgrade
+```
+
+This runs the `v0-15/aui-accessor-calls-to-properties` codemod, which rewrites nullary accessor calls (`aui.thread()`) to property access (`aui.thread`).
+
+## Scope Accessors Are Properties
+
+Nullary scope accessors are now properties. Calling them still works but is deprecated:
+
+```ts
+// Before
+aui.thread().getState();
+aui.threads().switchToNewThread();
+
+// After
+aui.thread.getState();
+aui.threads.switchToNewThread();
+```
+
+Selecting an unavailable scope no longer throws: `aui.thread` always succeeds and is always truthy. Its `source` is `null` when the scope is unavailable, and any other property read (or a call) throws. Check availability via:
+
+```ts
+if (aui.thread.source != null) {
+  // scope is available
+}
+```
+
+Accessors expose `source`, `query`, and `name` selection metadata as properties — previously found on the accessor function, now on the same names on the proxy. These three names are reserved and never resolve to scope methods.
+
+## Legacy Context Hooks Removed
+
+The v0.12-era runtime hooks are removed. Replace state reads with `useAuiState` and actions with `useAui`:
+
+| Removed                                                       | Replacement                                     |
+| ------------------------------------------------------------- | ----------------------------------------------- |
+| `useAssistantRuntime()`                                        | `useAui()`                                      |
+| `useThreadList(selector)`                                      | `useAuiState((s) => s.threads)`                 |
+| `useThreadRuntime()`                                           | `useAui().thread`                               |
+| `useThread(selector)`                                          | `useAuiState((s) => s.thread)`                  |
+| `useThreadComposer(selector)`                                  | `useAuiState((s) => s.thread.composer)`         |
+| `useThreadModelContext(selector)`                              | `useAuiState((s) => s.thread.modelContext)`     |
+| `useMessageRuntime()`                                          | `useAui().message`                              |
+| `useMessage(selector)`                                         | `useAuiState((s) => s.message)`                 |
+| `useEditComposer(selector)`                                    | `useAuiState((s) => s.message.composer)`        |
+| `useComposerRuntime()`                                         | `useAui().composer`                             |
+| `useComposer(selector)`                                        | `useAuiState((s) => s.composer)`                |
+| `useMessagePartRuntime()`                                      | `useAui().part`                                 |
+| `useMessagePart(selector)`                                     | `useAuiState((s) => s.part)`                    |
+| `useAttachmentRuntime()`                                       | `useAui().attachment`                           |
+| `useAttachment(selector)`                                      | `useAuiState((s) => s.attachment)`              |
+| `useThreadListItemRuntime()`                                   | `useAui().threadListItem`                       |
+| `useThreadListItem(selector)`                                  | `useAuiState((s) => s.threadListItem)`          |
+
+The attachment variants (`useThreadComposerAttachment(Runtime)`, `useEditComposerAttachment(Runtime)`, `useMessageAttachment(Runtime)`) are removed with them; use `useAui().attachment` / `useAuiState((s) => s.attachment)`.
+
+```tsx
+// Before
+const runtime = useAssistantRuntime();
+const isRunning = useThread((s) => s.isRunning);
+runtime.threads.switchToNewThread();
+
+// After
+const aui = useAui();
+const isRunning = useAuiState((s) => s.thread.isRunning);
+aui.threads.switchToNewThread();
+```
+
+## `ToolsState.tools` Removed
+
+The component-only tool-UI map is replaced by `toolUIs`, whose entries carry the renderer alongside its presentation options:
+
+```tsx
+// Before
+const Render = useAuiState((s) => s.tools.tools[toolName]?.[0]);
+
+// After
+const Render = useAuiState((s) => s.tools.toolUIs[toolName]?.[0]?.render);
+```
+
+## `"mcp-app"` Group Key Removed
+
+`groupPartByType` no longer accepts the `"mcp-app"` key. Use `"standalone-tool-call"`, a superset that matches MCP-app tool calls plus any tool call whose registered UI opts into standalone display:
+
+```tsx
+// Before
+groupPartByType({
+  "tool-call": ["group-tool"],
+  "mcp-app": [],
+});
+
+// After
+groupPartByType({
+  "tool-call": ["group-tool"],
+  "standalone-tool-call": [],
+});
+```
+
+## `useAui` `{ parent }` Config Removed
+
+The second argument (`useAui(clients, { parent })`) is removed. Provide the parent via context instead: wrap with `AuiProvider` and call the context form beneath it.
+
+```tsx
+// Before
+const aui = useAui(scopes, { parent });
+
+// After
+const Scoped = ({ children }) => {
+  const aui = useAui(scopes); // extends the AuiProvider parent
+  return <AuiProvider value={aui}>{children}</AuiProvider>;
+};
+
+<AuiProvider value={parent}>
+  <Scoped />
+</AuiProvider>;
+```
+
+Where `{ parent: null }` was used to detach from context, `<AuiProvider value={null}>` now provides an isolated empty root (experimental).
+
+## Still Deprecated (not removed)
+
+- Primitive `If` components (`ThreadPrimitive.If`, `MessagePrimitive.If`, `ThreadPrimitive.Empty`) — replaced by `AuiIf`. The codemod migrates these.
+- `useMessagePartText` / `useMessagePartReasoning` / `useMessagePartSource` / `useMessagePartImage` / `useMessagePartFile` / `useMessagePartData` — use `useAuiState` to select and narrow `s.part`.
+- The `components` prop on primitives — replaced by the children render function pattern (see the [v0.14 guide](/docs/migrations/v0-14)).
+
+## Getting Help
+
+- File issues at https://github.com/assistant-ui/assistant-ui/issues
+- See the [deprecation policy](/docs/migrations/deprecation-policy) for the support window

package/.docs/raw/docs/primitives/chain-of-thought.mdx

@@ -5,6 +5,8 @@ platforms: ["react"]
 ---
 
 import { ChainOfThoughtPrimitiveSample } from "@/components/docs/samples/chain-of-thought-primitive";
+import { ChainOfThoughtPrimitiveSample as ChainOfThoughtPrimitiveSampleRadix } from "@/components/docs/samples/chain-of-thought-primitive.radix";
+import { Flavored } from "@/components/docs/contexts/flavor.server";
 import {
   ChainOfThoughtPrimitive as ChainOfThoughtPrimitiveDocs,
   MessagePrimitive as MessagePrimitiveDocs,
@@ -18,7 +20,10 @@ For new grouped reasoning/tool-call UI, use `MessagePrimitive.GroupedParts`. `Ch
 
 <Tabs items={["Preview", "Code"]}>
   <Tab>
-    <ChainOfThoughtPrimitiveSample />
+    <Flavored
+      base={<ChainOfThoughtPrimitiveSample />}
+      radix={<ChainOfThoughtPrimitiveSampleRadix />}
+    />
   </Tab>
   <Tab>
 ```tsx

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

@@ -165,6 +165,22 @@ Form container for message composition. Renders a `<form>` element unless `asChi
 </ComposerPrimitive.Root>
 ```
 
+#### Compact Mode
+
+Pass `compact` to opt into compact detection. While the input holds at most a single line of text and the composer has no attachments, quote, queued messages, or active dictation, the root renders a `data-compact` attribute. The prop only exposes this attribute for styling — it does not change the layout by itself. Target it with CSS to collapse the composer into a single row:
+
+```tsx
+<ComposerPrimitive.Root
+  compact
+  className="group/composer flex flex-col data-[compact]:flex-row data-[compact]:items-center"
+>
+  <ComposerPrimitive.Input placeholder="Ask anything..." />
+  <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+</ComposerPrimitive.Root>
+```
+
+Once the text wraps onto a second line, the composer expands and stays expanded until the input is cleared, so the layout doesn't oscillate at the wrap boundary.
+
 ### Input
 
 Text input with keyboard shortcuts. Renders a `<textarea>` element unless `asChild` is set.
@@ -554,7 +570,7 @@ 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
+- `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:
 

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

@@ -63,6 +63,31 @@ The toolbar only appears when the selection is entirely within a single message.
 
 `Root` returns `null` when there is no valid selection (collapsed selection, empty text, or no single-message match).
 
+### Quote Regions
+
+By default, any selected text inside a message can be quoted. For rich messages with tool cards, attachments, or custom controls, add `data-aui-quote-selectable` to the element that contains the message text. Once a message has a quote-selectable region, selections must stay inside the same marked region for the toolbar to appear.
+
+```tsx
+<MessagePrimitive.Root>
+  <div data-aui-quote-selectable="">
+    <MessagePrimitive.Parts />
+  </div>
+  <ToolCard />
+</MessagePrimitive.Root>
+```
+
+Set `data-aui-quote-selectable="false"` to exclude an element instead: on the message root it disables quoting for the entire message, and inside a quotable region it carves that subtree out. The nearest marker wins, and any value other than `"false"` (including empty) marks a quotable region.
+
+Apps know the message role at render time, so a role gate is a conditional attribute:
+
+```tsx
+const UserMessage = () => (
+  <MessagePrimitive.Root data-aui-quote-selectable="false">
+    <MessagePrimitive.Parts />
+  </MessagePrimitive.Root>
+);
+```
+
 ### Quote Action
 
 The `Quote` button does two things on click:

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

@@ -253,7 +253,7 @@ Button that appends the next page of threads. Renders a `<button>` element unles
 </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.
+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";
@@ -271,7 +271,7 @@ function LoadMoreSentinel() {
     const el = ref.current;
     if (!el || disabled) return;
     const observer = new IntersectionObserver(([entry]) => {
-      if (entry?.isIntersecting) aui.threads().loadMore();
+      if (entry?.isIntersecting) aui.threads.loadMore();
     });
     observer.observe(el);
     return () => observer.disconnect();

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

@@ -41,11 +41,11 @@ import { useAui } from "@assistant-ui/react-native";
 const aui = useAui();
 
 // Composer actions
-aui.composer().setText("Hello");
-aui.composer().send();
+aui.composer.setText("Hello");
+aui.composer.send();
 
 // Thread actions
-aui.thread().cancelRun();
+aui.thread.cancelRun();
 ```
 
 ### useAuiEvent

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

@@ -197,7 +197,7 @@ function Composer() {
     >
       <TextInput
         value={text}
-        onChangeText={(t) => aui.composer().setText(t)}
+        onChangeText={(t) => aui.composer.setText(t)}
         placeholder="Message..."
         multiline
         style={{
@@ -211,7 +211,7 @@ function Composer() {
         }}
       />
       <Pressable
-        onPress={() => aui.composer().send()}
+        onPress={() => aui.composer.send()}
         disabled={isEmpty}
         style={{
           marginLeft: 8,

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

@@ -31,7 +31,9 @@ Container `View` for the thread area.
 
 ### ThreadPrimitive.Messages
 
-`FlatList`-based message list with automatic runtime integration. Each message is wrapped in a scoped context so that `useAuiState((s) => s.message)` works inside the rendered component.
+Deprecated `FlatList`-based message list kept for backwards compatibility. It uses `ThreadPrimitive.MessagesFlatList` internally, but keeps the previous no-auto-scroll default so existing apps with custom scroll handling do not change behavior on upgrade.
+
+Use `ThreadPrimitive.MessagesFlatList` for new React Native threads.
 
 ```tsx
 <ThreadPrimitive.Messages>
@@ -53,7 +55,29 @@ You can also provide role-specific components:
 | Prop | Type | Description |
 |------|------|-------------|
 | `components` | `MessageComponents` | Component map — provide either a `Message` component (used for all roles) or role-specific `UserMessage`, `AssistantMessage`, and optionally `SystemMessage`. Edit composers can be set via `EditComposer` or role-specific variants (`UserEditComposer`, `AssistantEditComposer`, `SystemEditComposer`). |
-| `...rest` | `FlatListProps` | Standard FlatList props (except `data`, `renderItem`) |
+| `...rest` | `ThreadPrimitive.MessagesFlatList` props | Same props as `ThreadPrimitive.MessagesFlatList`, with the auto-scroll options defaulting to `false` on this deprecated wrapper |
+
+### ThreadPrimitive.MessagesFlatList
+
+Canonical React Native message viewport backed by `FlatList`. It scopes each row to its message, forwards refs to the underlying `FlatList`, and handles scroll-to-bottom behavior for common chat flows.
+
+```tsx
+<ThreadPrimitive.MessagesFlatList autoScroll>
+  {() => <MyMessage />}
+</ThreadPrimitive.MessagesFlatList>
+```
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `children` | `({ message }) => ReactNode` | Render function for each message |
+| `components` | `MessageComponents` | Component map alternative to `children` |
+| `autoScroll` | `boolean` | Automatically keeps the list at the bottom while it is already near the bottom. Defaults to `true` |
+| `scrollToBottomOnRunStart` | `boolean` | Scrolls to the bottom when a run starts. Defaults to `true` |
+| `scrollToBottomOnInitialize` | `boolean` | Scrolls to the bottom when messages first appear. Defaults to `true` |
+| `scrollToBottomOnThreadSwitch` | `boolean` | Scrolls to the bottom when switching threads. Defaults to `true` |
+| `...rest` | `FlatListProps` | Standard FlatList props, except `data`, `renderItem`, and `children` |
+
+The built-in auto-scroll behavior assumes the default, non-inverted `FlatList` direction.
 
 ### ThreadPrimitive.MessageByIndex
 
@@ -362,6 +386,29 @@ Renders message content parts using render-prop functions instead of the compone
 | `renderFile` | `(props: { part, index }) => ReactElement` | Renderer for file parts |
 | `renderData` | `(props: { part, index }) => ReactElement` | Fallback renderer for data parts not handled by registered data UIs |
 
+#### Rendering Markdown
+
+`MessagePrimitive.Content` renders text parts with React Native's `<Text>` by default, so markdown syntax is displayed as plain text. To render markdown, install a React Native markdown renderer and pass it through `renderText`:
+
+<InstallCommand npm={["react-native-markdown-display"]} />
+
+```tsx
+import Markdown from "react-native-markdown-display";
+import { MessagePrimitive } from "@assistant-ui/react-native";
+
+const AssistantMessage = () => {
+  return (
+    <MessagePrimitive.Root>
+      <MessagePrimitive.Content
+        renderText={({ part }) => (
+          <Markdown>{part.text}</Markdown>
+        )}
+      />
+    </MessagePrimitive.Root>
+  );
+};
+```
+
 ### MessagePrimitive.Parts
 
 Renders message content parts via a `components` prop. Tool call and data parts automatically render registered toolkit renderers and data UIs (via `useAssistantDataUI`), falling back to components provided here. A default `Text` component using React Native's `<Text>` is provided out of the box.
@@ -518,10 +565,20 @@ import { ActionBarPrimitive } from "@assistant-ui/react-native";
 
 ### ActionBarPrimitive.Copy
 
-`Pressable` that copies the message content. Supports function-as-children for copy state feedback.
+`Pressable` that copies the message content. Pass a platform clipboard writer through `copyToClipboard`. Supports function-as-children for copy state feedback.
 
 ```tsx
-<ActionBarPrimitive.Copy copiedDuration={3000}>
+import * as Clipboard from "expo-clipboard";
+
+const copyToClipboard = async (text: string) => {
+  const didCopy = await Clipboard.setStringAsync(text);
+  if (!didCopy) throw new Error("Clipboard write failed");
+};
+
+<ActionBarPrimitive.Copy
+  copiedDuration={3000}
+  copyToClipboard={copyToClipboard}
+>
   {({ isCopied }) => <Text>{isCopied ? "Copied!" : "Copy"}</Text>}
 </ActionBarPrimitive.Copy>
 ```
@@ -529,7 +586,7 @@ import { ActionBarPrimitive } from "@assistant-ui/react-native";
 | Prop | Type | Description |
 |------|------|-------------|
 | `copiedDuration` | `number` | Duration in ms to show "copied" state (default: 3000) |
-| `copyToClipboard` | `(text: string) => void` | Custom clipboard function |
+| `copyToClipboard` | `(text: string) => void \| Promise<void>` | Platform clipboard writer |
 
 ### ActionBarPrimitive.Edit
 

package/.docs/raw/docs/runtimes/ag-ui/agent-state.mdx

@@ -0,0 +1,124 @@
+---
+title: Agent state
+description: Read and optimistically update agent-owned state with useAgUiState and useAgUiSetState over AG-UI.
+---
+
+`useAgUiState` mirrors the state your AG-UI agent owns. It updates live while the agent runs. `useAgUiSetState` lets you apply optimistic local updates that are sent with the next run.
+
+## Basic usage
+
+```tsx
+import { useAgUiState, useAgUiSetState } from "@assistant-ui/react-ag-ui";
+import { useAuiState } from "@assistant-ui/react";
+
+type ResearchState = {
+  topic: string;
+  sources: string[];
+};
+
+const state = useAgUiState<ResearchState>();
+// state: ResearchState | undefined  (latest agent state; updates live while the agent runs)
+
+const setState = useAgUiSetState<ResearchState>();
+// setState(next | (prev) => next)   (optimistic local update; sent with the NEXT run)
+
+const isRunning = useAuiState((s) => s.thread.isRunning);
+// isRunning: boolean                (whether the thread is currently running)
+```
+
+## Example
+
+Render agent state beside the chat and push an optimistic update from a control in your UI:
+
+```tsx
+"use client";
+
+import { useAgUiState, useAgUiSetState } from "@assistant-ui/react-ag-ui";
+import { useAuiState } from "@assistant-ui/react";
+import { Thread } from "@/components/assistant-ui/thread";
+
+type ResearchState = {
+  topic: string;
+  sources: string[];
+};
+
+export function ResearchAssistant() {
+  const state = useAgUiState<ResearchState>();
+  const setState = useAgUiSetState<ResearchState>();
+  const isRunning = useAuiState((s) => s.thread.isRunning);
+
+  return (
+    <div className="flex h-full">
+      <aside className="w-72 border-r p-4">
+        <h2>Research state</h2>
+        {state ? (
+          <ul>
+            <li>Topic: {state.topic}</li>
+            <li>Sources: {state.sources.join(", ") || "none"}</li>
+          </ul>
+        ) : (
+          <p>No agent state yet.</p>
+        )}
+        <button
+          type="button"
+          disabled={isRunning}
+          onClick={() =>
+            setState((prev) => ({
+              topic: prev?.topic ?? "market analysis",
+              sources: [...(prev?.sources ?? []), "sec-filings"],
+            }))
+          }
+        >
+          Prefer SEC filings
+        </button>
+        {isRunning && <p>Agent is running…</p>}
+      </aside>
+      <main className="flex-1">
+        <Thread />
+      </main>
+    </div>
+  );
+}
+```
+
+The panel re-renders as `STATE_SNAPSHOT` and `STATE_DELTA` events arrive. The button updates the local snapshot immediately; that value is included as the `state` field of the next run input.
+
+## How state is synced
+
+The AG-UI protocol delivers agent state on the wire:
+
+- `STATE_SNAPSHOT` replaces the full client-side snapshot.
+- `STATE_DELTA` applies a JSON Patch to the current snapshot.
+
+The runtime applies both client-side, so `useAgUiState` always reflects the latest merged snapshot. Calling the setter from `useAgUiSetState` updates that same local snapshot. On the next run, the runtime automatically includes it as the `state` field of the run input.
+
+This works with any AG-UI agent (Mastra, Pydantic AI, CrewAI, LangGraph via AG-UI adapters, and other AG-UI-compliant servers).
+
+## Write-back timing
+
+`useAgUiSetState` is optimistic and local first. The value reaches the agent only when the next run starts. It is not a live channel into a run that is already in progress. Use it to stage preferences, filters, or other agent-owned fields that the next turn should see.
+
+## Relationship to other state
+
+Keep the three state layers distinct:
+
+- **Your app state** stays yours (React state, URL, a store). assistant-ui does not own it.
+- **`useAuiState`** reads assistant-ui's client state (messages, composer, thread status).
+- **`useAgUiState` / `useAgUiSetState`** mirror state the **agent** owns, synced over the AG-UI wire via snapshots and deltas.
+
+Use `useAgUiState` and `useAgUiSetState` for fields your agent maintains as shared state on the protocol. Use `useAuiState` for UI that depends on the chat thread itself. Use your own state for everything else.
+
+## Next
+
+<Cards>
+  <Card
+    title="Runtime options"
+    description="useAgUiRuntime options, adapters, supported events."
+    href="/docs/runtimes/ag-ui/runtime-options"
+  />
+  <Card
+    title="Quickstart"
+    description="Minimal HttpAgent + useAgUiRuntime setup."
+    href="/docs/runtimes/ag-ui/quickstart"
+  />
+</Cards>

package/.docs/raw/docs/runtimes/ag-ui/runtime-options.mdx

@@ -14,6 +14,7 @@ Reference for the runtime's API surface. Start with [quickstart](/docs/runtimes/
 | `agent` | `HttpAgent` | An AG-UI client agent (from `@ag-ui/client`). Required. |
 | `logger` | `Partial<Logger>` | Optional logger overrides. The runtime logs event-parser warnings and run lifecycle events. |
 | `showThinking` | `boolean` | Whether to render `THINKING_*` and `REASONING_*` events as visible reasoning. Defaults to `true`. |
+| `autoCancelPendingToolCalls` | `boolean` | Cancel unresolved client-side tool calls automatically when the user sends, edits, or reloads a message. Defaults to `true`. See [below](#auto-cancelling-pending-tool-calls). |
 | `onError` | `(e: Error) => void` | Error callback fired on `RUN_ERROR` events and protocol errors. |
 | `onCancel` | `() => void` | Cancellation callback fired when the user cancels a run. |
 | `adapters` | `UseAgUiRuntimeAdapters` | Standard adapter slots (see below). |
@@ -137,7 +138,9 @@ await runtime.unstable_submitInterruptResponses(
 
 ### Steering away from an interrupt
 
-When the user ignores the interrupt UI and just sends a new message, use the `useAgUiSteerAway` hook. Every open interrupt defaults to `status: "cancelled"`, the new message is appended, and the run resumes with `resume: ResumeEntry[]` on the wire. With no pending interrupts it behaves like a normal append.
+When the user ignores the interrupt UI and just sends a new message, use the `useAgUiSteerAway` hook. Every open interrupt defaults to `status: "cancelled"`, the new message is appended, and the run resumes with `resume: ResumeEntry[]` on the wire.
+
+The same hook also steers away from pending client-side tool calls. When the head assistant message is in `requires-action` with `reason: "tool-calls"` (frontend tools awaiting a result) and the user sends a new message, every unresolved tool call is cancelled with an error result, the message is completed, and a single fresh run starts with those cancellations in its history. Passing `responses` in this case throws, since responses only address interrupts. With nothing pending, `steerAway` behaves like a normal append.
 
 ```tsx
 const steerAway = useAgUiSteerAway();
@@ -154,6 +157,12 @@ await steerAway("continue without the file", [
 ]);
 ```
 
+### Auto-cancelling pending tool calls
+
+By default the runtime does the tool-call half of this automatically: when client-side tool calls are still unresolved and the user sends a new message, edits an earlier one, or reloads, every unresolved tool call receives the same cancellation error result, the assistant message is completed, and the run proceeds with those cancellations in its history. Set `autoCancelPendingToolCalls: false` to opt out, in which case pending tool calls stay unresolved on a plain send and [steering away](#steering-away-from-an-interrupt) remains the explicit way to cancel them.
+
+Pending interrupts are never auto-cancelled: sending while an interrupt is open still throws, and the interrupt must be answered with `useAgUiSubmitInterruptResponses` or discarded with `useAgUiSteerAway`.
+
 ## Supported events
 
 The runtime parses the AG-UI event stream and maps each event type to assistant-ui state.

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

@@ -11,16 +11,19 @@ import { VercelIcon } from "@/components/icons/vercel";
 
 | AI SDK | Runtime package | Docs |
 | --- | --- | --- |
-| `ai@^6` + `@ai-sdk/react@^3` | `@assistant-ui/react-ai-sdk` (latest) | [v6 (current)](/docs/runtimes/ai-sdk/v6) |
-| `ai@^5` + `@ai-sdk/react@^2` | `@assistant-ui/react-ai-sdk@0.x` | [v5 (legacy)](/docs/runtimes/ai-sdk/v5-legacy) |
+| `ai@^7` + `@ai-sdk/react@^4` | `@assistant-ui/react-ai-sdk@^1.4` (latest) | [v7 (current)](/docs/runtimes/ai-sdk/v7) |
+| `ai@^6` + `@ai-sdk/react@^3` | `@assistant-ui/react-ai-sdk@1.3.40` | [v6 (legacy)](/docs/runtimes/ai-sdk/v6-legacy) |
+| `ai@^5` + `@ai-sdk/react@^2` | `@assistant-ui/react-ai-sdk@1.1.21` | [v5 (legacy)](/docs/runtimes/ai-sdk/v5-legacy) |
 | `ai@^4` | `@assistant-ui/react-data-stream` | [v4 (legacy)](/docs/runtimes/ai-sdk/v4-legacy) |
 
-New projects should target v6. v5 and v4 are documented for projects that have not migrated yet; both have known compatibility gaps and receive no new features.
+New projects should target v7. v6, v5, and v4 are documented for projects that have not migrated yet; all have known compatibility gaps and receive no new features.
 
 ## Architecture
 
 `@assistant-ui/react-ai-sdk` is layered on `ExternalStoreRuntime` (see [architecture](/docs/runtimes/concepts/architecture)). Features that ship as runtime adapters work the same way they do everywhere else; see [adapters](/docs/runtimes/concepts/adapters).
 
+For reload-safe streaming (persist an in-flight response so the client can reconnect), see [Resumable Streams](/docs/guides/resumable-streams).
+
 ## Choosing useChatRuntime vs useAISDKRuntime
 
 Both ship in the same package.
@@ -33,9 +36,15 @@ Both ship in the same package.
 <Cards>
   <Card
     icon={<VercelIcon width={20} height={20} />}
-    title="v6 (current)"
+    title="v7 (current)"
     description="Quickstart, frontend tools, attachments, quotes, history, multi-step, useAISDKRuntime."
-    href="/docs/runtimes/ai-sdk/v6"
+    href="/docs/runtimes/ai-sdk/v7"
+  />
+  <Card
+    icon={<VercelIcon width={20} height={20} />}
+    title="v6 (legacy)"
+    description="Reference for projects still on AI SDK v6."
+    href="/docs/runtimes/ai-sdk/v6-legacy"
   />
   <Card
     icon={<VercelIcon width={20} height={20} />}