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

package/.docs/raw/docs/runtimes/custom/assistant-transport.mdx

@@ -300,6 +300,7 @@ aui-state:[{"type":"set","path":["status"],"value":"completed"}]
   initialState: T,
   api: string,
   resumeApi?: string,
+  resumeStateApi?: string,
   protocol?: "data-stream" | "assistant-transport",
   converter: (state: T, connectionMetadata: ConnectionMetadata) => AssistantTransportState,
   headers?: Record<string, string> | Headers | (() => Promise<Record<string, string> | Headers>),
@@ -307,7 +308,7 @@ aui-state:[{"type":"set","path":["status"],"value":"completed"}]
   prepareSendCommandsRequest?: (body: SendCommandsRequestBody) => Record<string, unknown> | Promise<Record<string, unknown>>,
   capabilities?: { edit?: boolean },
   adapters?: { attachments?: AttachmentAdapter; history?: ThreadHistoryAdapter },
-  onResponse?: (response: Response) => void,
+  onResponse?: (response: Response) => void | Promise<void>,
   onFinish?: () => void,
   onError?: (error: Error, params: { commands: AssistantTransportCommand[]; updateState: (updater: (state: T) => T) => void }) => void | Promise<void>,
   onCancel?: (params: { commands: AssistantTransportCommand[]; updateState: (updater: (state: T) => T) => void; error?: Error }) => void
@@ -519,6 +520,23 @@ const runtime = useAssistantTransportRuntime({
 });
 ```
 
+Setting `resumeStateApi` additionally hydrates resumed runs from the server-retained starting state. It requires a sync server that serves the initial-state route; do not configure it against a server without one, since a failing preflight fails the resume closed:
+
+```tsx
+const runtime = useAssistantTransportRuntime({
+  // ...
+  resumeStateApi: "http://localhost:8010/initial-state",
+});
+```
+
+Before resuming, the runtime posts `{ threadId }` to `resumeStateApi`. The endpoint must return the state that started the active run together with its identity:
+
+```json
+{ "runId": "8b3a...", "state": { "messages": [] } }
+```
+
+The runtime replaces its local base with this snapshot and includes `runId` in the resume request; the request carries no `state`, since the server replays from the snapshot it retained. A sync server should reject the resume when that ID no longer identifies the same run, preventing replay operations from being applied to a drifted or replaced base state. When no run is active, the endpoint responds `204 No Content` and the runtime skips the resume without raising an error. On a resume, `runId` takes precedence over fields supplied through `body` and survives `prepareSendCommandsRequest`; any `state` either of them supplies is stripped.
+
 ```tsx
 import { useAui } from "@assistant-ui/react";
 import { useEffect, useRef } from "react";

package/.docs/raw/docs/runtimes/custom/external-store.mdx

@@ -207,6 +207,7 @@ Each handler enables a specific UI feature.
 | `onEdit` | Message edit button |
 | `onReload` | Regenerate button |
 | `onCancel` | Cancel button while generating |
+| `onRefetchThread` | `threads.reloadMainThread()` refetching the open thread in place |
 | `onAddToolResult` | Client-side tool result handoff |
 | `queue` | Queueing messages sent while a run is in progress |
 
@@ -395,7 +396,9 @@ const runtime = useExternalStoreRuntime({
 
 By default, sending while the thread is running is disabled. Provide a `queue` adapter to buffer a message sent during a run and process it once the run settles. The pending message is exposed on `composer.queue` and renders through [`ComposerPrimitive.Queue`](/docs/api-reference/primitives/composer).
 
-The `createMessageQueue` helper owns the FIFO ordering and the in-flight guard. Supply a driver that runs a message, pass its `adapter` to the runtime, and tell the queue when a run starts (`notifyBusy()`, so concurrent sends buffer) and ends (`notifyIdle()`).
+The `createMessageQueue` helper owns the two-lane ordering and the in-flight guard: `steerItems` drain before `items`, and within each lane items drain in order. Supply a driver that runs a message, pass its `adapter` to the runtime, and tell the queue when a run starts (`notifyBusy()`, so concurrent sends buffer) and ends (`notifyIdle()`).
+
+A hand-rolled adapter must implement the same contract: `items` and `steerItems` expose the lanes (each item carries a required `parts` projection of its content), `enqueue`/`steer` add to a lane, and `move(queueItemId, placement)` repositions with fail-fast anchors — unknown ids or anchors throw rather than being coerced. Individual items are addressable through `composer.queueItem({ id })` (or by index).
 
 ```tsx
 import { useEffect, useRef, useState } from "react";
@@ -418,12 +421,36 @@ useEffect(() => {
 }, [isRunning, queue]);
 ```
 
+With a `createMessageQueue` adapter, cancelling pauses the queue for you: the runtime tells the queue before your `onCancel` runs, so the cancelled run's settle keeps the pending items instead of dispatching the next one, and the next send resumes draining. Call `queue.clear()` in `onCancel` instead if you want a cancel to drop them. A hand-rolled adapter has no such channel, so it owns its cancel policy the same way it owns the rest. Edit and reload stay host-owned: call `queue.clear()` in your `onEdit` and `onReload` handlers so stale items do not drain onto the new branch.
+
+```tsx
+const runtime = useExternalStoreRuntime({
+  // ...
+  onCancel: async () => {
+    // the runtime already paused the queue; clear() here to drop the items
+    await cancelRun();
+  },
+  onEdit: async (message) => {
+    queue.clear();
+    // ...
+  },
+  onReload: async (parentId) => {
+    queue.clear();
+    // ...
+  },
+});
+```
+
 ## Multi-thread
 
 `ExternalStoreRuntime` uses `ExternalStoreThreadListAdapter` (synchronous, inline). See [threads](/docs/runtimes/concepts/threads#externalstorethreadlistadapter) for the contract and best practices on keeping `currentThreadId` in sync with your store.
 
 ## Integration examples
 
+<Callout type="info">
+**Real-world example:** the [Claude Managed Agents guide](/docs/runtimes/claude-managed-agents) maps Anthropic-hosted agent sessions onto this runtime, with Anthropic's official [quickstart](https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/assistant-ui) as the runnable reference.
+</Callout>
+
 ### Redux
 
 ```tsx title="app/chatSlice.ts"
@@ -787,6 +814,12 @@ useExternalStoreRuntime({
       type: "() => Promise<void>",
       description: "Handler for cancelling the current generation.",
     },
+    {
+      name: "onRefetchThread",
+      type: "() => Promise<void>",
+      description:
+        "Handler for re-fetching this thread's state in place, driving threads.reloadMainThread(). Unrelated to onReload, which re-generates an assistant message.",
+    },
     {
       name: "onAddToolResult",
       type: "(options: AddToolResultOptions) => Promise<void> | Void",

package/.docs/raw/docs/runtimes/custom/local-runtime.mdx

@@ -353,7 +353,7 @@ const openai = new OpenAI();
 const MyModelAdapter: ChatModelAdapter = {
   async *run({ messages, abortSignal, context }) {
     const stream = await openai.chat.completions.create({
-      model: "gpt-5.4-mini",
+      model: "gpt-5.6-luna",
       messages: convertToOpenAIMessages(messages),
       stream: true,
       signal: abortSignal,
@@ -372,6 +372,34 @@ const MyModelAdapter: ChatModelAdapter = {
 
 Each yield replaces the previous content. Yield the full state every time, not deltas.
 
+### Only the last part streams
+
+A text or reasoning part reports `status.type === "running"` only while it is the last part of the message. Every earlier one reads as complete, and the components that react to streaming follow that status: the reasoning disclosure auto-opens and pins its live preview while its part is running, and part status indicators resolve the same way. Tool-call parts are exempt, since their status comes from whether they have a result.
+
+That makes an empty trailing part destructive. Yielding `[reasoning, text("")]` to reserve the text slot marks the reasoning part complete the moment the empty text part appears, even though reasoning is still streaming, and nothing in the UI signals why. Add a part on its first token instead of reserving it:
+
+```tsx
+let reasoning = "";
+let text = "";
+
+for await (const chunk of stream) {
+  const delta = chunk.choices[0]?.delta;
+  text += delta?.content ?? "";
+  // Reasoning deltas are provider-specific; read whichever field yours sends
+  reasoning += (delta as { reasoning?: string })?.reasoning ?? "";
+
+  // Include each part only once it has content
+  yield {
+    content: [
+      ...(reasoning ? [{ type: "reasoning" as const, text: reasoning }] : []),
+      ...(text ? [{ type: "text" as const, text }] : []),
+    ],
+  };
+}
+```
+
+Guard every text or reasoning part this way, not just the trailing one. An empty part that is never filled also renders as an empty block, and whichever part ends up last is the only one that can report `running`.
+
 ### Streaming with tool calls
 
 Accumulate tool calls in a `Map` outside the streaming loop so they persist across chunks:
@@ -379,7 +407,7 @@ Accumulate tool calls in a `Map` outside the streaming loop so they persist acro
 ```tsx
 async *run({ messages, abortSignal, context }) {
   const stream = await openai.chat.completions.create({
-    model: "gpt-5.4-mini",
+    model: "gpt-5.6-luna",
     messages: convertToOpenAIMessages(messages),
     tools: context.tools,
     stream: true,
@@ -415,7 +443,7 @@ If you build the `content` array fresh from the current chunk each iteration, to
 
 ## Tool calling
 
-`LocalRuntime` supports OpenAI-compatible function calling. Register tools through `useAui` so the runtime exposes them to your adapter via `context.tools`:
+`LocalRuntime` supports OpenAI-compatible function calling. Register tools through the provider's `config` so the runtime exposes them to your adapter via `context.tools`:
 
 ```tsx title="app/toolkit.tsx"
 "use generative";
@@ -440,15 +468,14 @@ export default defineToolkit({
 ```
 
 ```tsx title="app/MyRuntimeProvider.tsx"
-import { useAui, Tools } from "@assistant-ui/react";
+import { AuiConfig, Tools } from "@assistant-ui/react";
 import toolkit from "./toolkit";
 
 function MyRuntimeProvider({ children }: { children: React.ReactNode }) {
   const runtime = useLocalRuntime(MyModelAdapter);
-  const aui = useAui({ tools: Tools({ toolkit }) });
-
+  const config = AuiConfig({ tools: Tools({ toolkit }) });
   return (
-    <AssistantRuntimeProvider aui={aui} runtime={runtime}>
+    <AssistantRuntimeProvider runtime={runtime} config={config}>
       {children}
     </AssistantRuntimeProvider>
   );
@@ -627,7 +654,7 @@ function useStreamReconnect(threadId: string) {
 
 ## Queueing messages during a run
 
-Set `unstable_enableMessageQueue` to keep the composer usable while a run is in progress. A message sent during a run is held in `composer.queue` and sent once the run settles; steering a queued message runs it next.
+Set `unstable_enableMessageQueue` to keep the composer usable while a run is in progress. A message sent during a queued run steers by default — it lands in the steer lane, ahead of previously queued items; `send({ steer: false })` queues a follow-up behind them instead. Pending items are held in `composer.queue` and drain once the run settles.
 
 ```tsx
 const runtime = useLocalRuntime(MyModelAdapter, {
@@ -674,7 +701,7 @@ const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
 const OpenAIAdapter: ChatModelAdapter = {
   async *run({ messages, abortSignal, context }) {
     const stream = await openai.chat.completions.create({
-      model: "gpt-5.4-mini",
+      model: "gpt-5.6-luna",
       messages: messages.map((m) => ({
         role: m.role,
         content: m.content

package/.docs/raw/docs/runtimes/eve/overview.mdx

@@ -49,6 +49,57 @@ export default function Home() {
 }
 ```
 
+The `custom` bag of a per-turn `runConfig` is forwarded to Eve as
+`clientContext`, so `runConfig: { custom: { page: "/pricing" } }` arrives as
+`clientContext: { page: "/pricing" }`. An empty or absent bag is omitted, and
+every value must be JSON-serializable.
+
+Eve turns that object into a model context message, which is why the
+assistant-ui `custom` envelope is unwrapped: the envelope would put a literal
+`custom` key in the prompt. It is page or client context rather than run
+configuration, and it cannot select a model or change how the turn executes.
+Keep secrets, credentials, and personal data out of it, since the model reads
+it as message text.
+
+## Connector authorization
+
+When Eve pauses for connector authorization, the runtime emits an assistant
+data part named `authorization`. Its data includes `state`, `name`, and the
+available display fields such as `displayName`, `description`, `url`,
+`userCode`, `instructions`, and `expiresAt`. Completed parts may also include
+`outcome` and `reason`. `url` is present only when the connector supplied an
+`http(s)` address; the adapter drops other schemes so a renderer can link to it
+directly.
+
+The Eve template ships this renderer as `components/eve-authorization.tsx` and
+mounts it next to `<Thread />`. To add it to an existing app, register a data UI
+for the part and type it with the exported `EveAuthorizationData`:
+
+```tsx title="authorization-ui.tsx"
+import type { EveAuthorizationData } from "@assistant-ui/eve";
+import { makeAssistantDataUI } from "@assistant-ui/react";
+
+export const AuthorizationUI = makeAssistantDataUI<EveAuthorizationData>({
+  name: "authorization",
+  render: ({ data }) => (
+    <div>
+      {data.state === "required" ? (
+        <>
+          <p>{data.instructions ?? `Sign in to ${data.displayName ?? data.name}`}</p>
+          {data.userCode && <code>{data.userCode}</code>}
+          {data.url && <a href={data.url}>Continue to sign in</a>}
+        </>
+      ) : (
+        <p>{data.outcome ?? "Authorization completed"}</p>
+      )}
+    </div>
+  ),
+});
+```
+
+Mount `<AuthorizationUI />` inside the `AssistantRuntimeProvider` tree. The
+standard thread intentionally leaves unmatched data parts unrendered.
+
 ## Requirements
 
 - Node.js 24 or higher.

package/.docs/raw/docs/runtimes/eve/quickstart.mdx

@@ -1,9 +1,9 @@
 ---
 title: Quickstart
-description: From-template and manual setup paths to a working Eve agent chat in assistant-ui.
+description: Template, Eve CLI, and manual setup paths to a working Eve agent chat in assistant-ui.
 ---
 
-Two paths to a running Eve-powered assistant-ui app. The template is fastest; the manual path is what you adapt when integrating into an existing Next.js project.
+Three paths to a running Eve-powered assistant-ui app. The template is fastest, `eve add` drops assistant-ui into an Eve app you already have, and the manual path is what you adapt when integrating into an existing Next.js project.
 
 ## From the template
 
@@ -45,6 +45,55 @@ Use Eve's terminal UI directly for command-line agent sessions.
 </Tab>
 </PlatformTabs>
 
+## With the Eve CLI
+
+For an Eve app that already exists, register the assistant-ui registry once and install the chat page from it:
+
+```sh
+eve registry add @assistant-ui=https://r.assistant-ui.com/{name}.json
+eve add @assistant-ui/eve-chat --overwrite
+```
+
+`eve registry add` records the namespace in your `package.json`. `eve add` then installs `@assistant-ui/react` and `@assistant-ui/eve`, writes `app/page.tsx`, and writes the thread component together with everything it imports into `components/assistant-ui` and `components/ui`. It expects an Eve app that carries the Next.js Web Chat scaffold, because the installed files import `@/lib/utils` through the `@/*` alias that `eve init --channel-web-nextjs` sets up.
+
+`--overwrite` is global rather than per file. It is what lets the item replace the scaffold's own `app/page.tsx`, and it also replaces any `components/assistant-ui` or `components/ui` file already in the project, including `avatar`, `button`, `collapsible`, `dialog`, and `tooltip`, so install on a clean tree and read the diff before keeping it. A plain `eve add` skips every pre-existing file instead, which leaves `app/page.tsx` untouched. Inspect an item before installing it with `eve registry view @assistant-ui/eve-chat`, and browse the rest of the registry with `eve registry list --registry @assistant-ui`.
+
+That namespace serves the Radix flavor, which matches the shadcn components in Eve's Next.js scaffold. Point it at `https://r.assistant-ui.com/base/{name}.json` instead for a Base UI project.
+
+The Eve CLI writes registry files without editing CSS, so add the styles the reasoning and tool components animate with to `app/globals.css` yourself:
+
+```css title="app/globals.css"
+@import "tw-shimmer";
+
+@custom-variant data-open (&:where([data-state="open"], [data-open]:not([data-open="false"])));
+@custom-variant data-closed (&:where([data-state="closed"], [data-closed]:not([data-closed="false"])));
+
+@theme inline {
+  @keyframes collapsible-down {
+    from {
+      height: 0;
+    }
+    to {
+      height: var(
+        --radix-collapsible-content-height,
+        var(--collapsible-panel-height, auto)
+      );
+    }
+  }
+  @keyframes collapsible-up {
+    from {
+      height: var(
+        --radix-collapsible-content-height,
+        var(--collapsible-panel-height, auto)
+      );
+    }
+    to {
+      height: 0;
+    }
+  }
+}
+```
+
 ## Manual setup in an existing app
 
 <Steps>

package/.docs/raw/docs/runtimes/google-adk/hooks.mdx

@@ -389,9 +389,9 @@ Register the renderer with a backend toolkit entry inside `AssistantRuntimeProvi
 ```tsx
 import {
   AssistantRuntimeProvider,
+  AuiConfig,
   defineToolkit,
   Tools,
-  useAui,
 } from "@assistant-ui/react";
 import {
   createAdkStream,
@@ -410,10 +410,9 @@ function App() {
   const runtime = useAdkRuntime({
     stream: createAdkStream({ api: "/api/chat" }),
   });
-  const aui = useAui({ tools: Tools({ toolkit }) });
-
+  const config = AuiConfig({ tools: Tools({ toolkit }) });
   return (
-    <AssistantRuntimeProvider aui={aui} runtime={runtime}>
+    <AssistantRuntimeProvider runtime={runtime} config={config}>
       <Thread />
     </AssistantRuntimeProvider>
   );
@@ -426,9 +425,9 @@ function App() {
 ```tsx
 import {
   AssistantRuntimeProvider,
+  AuiConfig,
   defineToolkit,
   Tools,
-  useAui,
 } from "@assistant-ui/react-native";
 import {
   createAdkStream,
@@ -450,10 +449,9 @@ function App() {
   const runtime = useAdkRuntime({
     stream: createAdkStream({ api: `${API_URL}/api/chat` }),
   });
-  const aui = useAui({ tools: Tools({ toolkit }) });
-
+  const config = AuiConfig({ tools: Tools({ toolkit }) });
   return (
-    <AssistantRuntimeProvider aui={aui} runtime={runtime}>
+    <AssistantRuntimeProvider runtime={runtime} config={config}>
       <View style={{ flex: 1 }}>
         <Thread />
       </View>
@@ -468,9 +466,9 @@ function App() {
 ```tsx
 import {
   AssistantRuntimeProvider,
+  AuiConfig,
   defineToolkit,
   Tools,
-  useAui,
 } from "@assistant-ui/react-ink";
 import {
   createAdkStream,
@@ -490,10 +488,9 @@ function App() {
   const runtime = useAdkRuntime({
     stream: createAdkStream({ api: "http://localhost:3000/api/chat" }),
   });
-  const aui = useAui({ tools: Tools({ toolkit }) });
-
+  const config = AuiConfig({ tools: Tools({ toolkit }) });
   return (
-    <AssistantRuntimeProvider aui={aui} runtime={runtime}>
+    <AssistantRuntimeProvider runtime={runtime} config={config}>
       <Box flexDirection="column">
         <Thread />
       </Box>

package/.docs/raw/docs/runtimes/langchain.mdx

@@ -262,7 +262,7 @@ Follow the [Ink setup](/docs/ink).
 
 ### Forwarding per-run config
 
-When a message is sent, its `runConfig.custom` (for example a selected mode or model) is forwarded on the underlying `useStream().submit` call as `config.configurable`. Read it in the graph from `config["configurable"]`; on LangGraph v1 the same values are also reachable through the Runtime `context`, which `config.configurable` is aliased to. This lets per-run app config reach the graph without extra wiring.
+When a message is sent, its `runConfig.custom` (for example a selected mode or model) is forwarded on the underlying `useStream().submit` call as `config.configurable`. Automatic tool-result resumes and the interrupt helpers (`useLangChainRespond`, `useLangChainRespondAll`, and `useLangChainSubmit(null, { command })`) reuse that same recorded `configurable` unless the caller passes `config`. Raw `useLangChainSubmit` / `useLangChainSend` calls that start a new run do not inherit it. The recording is session-scoped and does not survive a reload. Read it in the graph from `config["configurable"]`; on LangGraph v1 the same values are also reachable through the Runtime `context`, which `config.configurable` is aliased to. This lets per-run app config reach the graph without extra wiring.
 
 ## Reading custom state keys
 

package/.docs/raw/docs/runtimes/langgraph/streaming.mdx

@@ -108,7 +108,7 @@ See [Generative UI](/docs/runtimes/langgraph/generative-ui) for full setup: enab
 
 ## Queueing messages during a run
 
-Set `unstable_enableMessageQueue` to keep the composer usable while a run is streaming. A message sent during a run is held in `composer.queue` and sent once the run settles; steering a queued message runs it next.
+Set `unstable_enableMessageQueue` to keep the composer usable while a run is streaming. A message sent during a queued run steers by default — it lands in the steer lane, ahead of previously queued items; `send({ steer: false })` queues a follow-up behind them instead. Pending items are held in `composer.queue` and drain once the run settles.
 
 ```tsx
 const runtime = useLangGraphRuntime({
@@ -119,6 +119,10 @@ const runtime = useLangGraphRuntime({
 
 Render the pending messages with [`ComposerPrimitive.Queue`](/docs/api-reference/primitives/composer) and [`QueueItemPrimitive`](/docs/api-reference/primitives/queue-item).
 
+## Per-run config
+
+When a message is sent, its `runConfig` is forwarded to `stream` and, if you use `unstable_createLangGraphStream`, posted as the LangGraph SDK run `config`. Automatic frontend tool-result resumes and `useLangGraphSendCommand` reuse the `runConfig` of the run that produced the pending tool call or interrupt. An explicit `runConfig` on `useLangGraphSend` still wins. A thread refetch that still carries the interrupt keeps that owner. History loaded without local ownership stays unconfigured on resume; the recording is session-scoped and does not survive a reload.
+
 ## Next
 
 <Cards>

package/.docs/raw/docs/runtimes/langgraph/tutorial/part-2.mdx

@@ -94,7 +94,7 @@ This simply displays the tool name and arguments passed to it, but not the resul
 
 import { Thread } from "@/components/assistant-ui/thread";
 import { PriceSnapshotToolUI } from "@/components/tools/price-snapshot/PriceSnapshotTool";
-import { AuiProvider, defineToolkit, Tools, useAui } from "@assistant-ui/react";
+import { AuiConfig, AuiProvider, defineToolkit, Tools, useAui } from "@assistant-ui/react";
 
 const toolkit = defineToolkit({
   price_snapshot: {
@@ -104,10 +104,10 @@ const toolkit = defineToolkit({
 });
 
 export default function Home() {
-  const aui = useAui({ tools: Tools({ toolkit }) });
-
+  const aui = useAui();
+  const config = AuiConfig({ tools: Tools({ toolkit }) });
   return (
-    <AuiProvider value={aui}>
+    <AuiProvider extends={aui} config={config}>
       <Thread />
     </AuiProvider>
   );
@@ -334,10 +334,10 @@ const toolkit = defineToolkit({
 });
 
 export default function Home() {
-  const aui = useAui({ tools: Tools({ toolkit }) });
-
+  const aui = useAui();
+  const config = AuiConfig({ tools: Tools({ toolkit }) });
   return (
-    <AuiProvider value={aui}>
+    <AuiProvider extends={aui} config={config}>
       <Thread />
     </AuiProvider>
   );

package/.docs/raw/docs/runtimes/langgraph/tutorial/part-3.mdx

@@ -212,7 +212,7 @@ export function TransactionConfirmationPending(props: TransactionConfirmation) {
 import { Thread } from "@/components/assistant-ui/thread";
 import { PriceSnapshotToolUI } from "@/components/tools/price-snapshot/PriceSnapshotTool";
 import { PurchaseStockToolUI } from "@/components/tools/purchase-stock/PurchaseStockTool";
-import { AuiProvider, defineToolkit, Tools, useAui } from "@assistant-ui/react";
+import { AuiConfig, AuiProvider, defineToolkit, Tools, useAui } from "@assistant-ui/react";
 
 const toolkit = defineToolkit({
   price_snapshot: {
@@ -226,10 +226,10 @@ const toolkit = defineToolkit({
 });
 
 export default function Home() {
-  const aui = useAui({ tools: Tools({ toolkit }) });
-
+  const aui = useAui();
+  const config = AuiConfig({ tools: Tools({ toolkit }) });
   return (
-    <AuiProvider value={aui}>
+    <AuiProvider extends={aui} config={config}>
       <Thread />
     </AuiProvider>
   );

package/.docs/raw/docs/runtimes/opencode/hooks.mdx

@@ -112,6 +112,7 @@ The returned `OpenCodeThreadState` includes:
 
 - `sessionId`, `session`, `sessionStatus`, `loadState`, `runState`
 - `messageOrder`, `messagesById`, `pendingUserMessages`
+- `childSessionsById` (OpenCode `task` child-session projections keyed by session ID)
 - `interactions.permissions` (pending + resolved), `interactions.questions` (pending + answered + rejected)
 - `unhandledEvents`, `sync` timestamps
 

package/.docs/raw/docs/runtimes/opencode/overview.mdx

@@ -28,6 +28,16 @@ If your backend is not OpenCode-based, see [picking a runtime](/docs/runtimes/pi
 - A running [OpenCode](https://opencode.ai/) server (defaults to `http://localhost:4096`).
 - React 18 or 19.
 
+## Sub-agent conversations
+
+OpenCode `task` tool calls expose their child session through tool metadata. The runtime loads those child sessions, keeps them synchronized from the same OpenCode event stream, and projects their transcripts into `ToolCallMessagePart.messages`. Parallel and recursively nested tasks are supported.
+
+Loading is eager, not keyed to what a renderer displays. Once a thread is subscribed, every `task` part in its transcript fetches its child session, and each child does the same for its own nested tasks, so a long session with many task calls fetches every sub-agent transcript whether or not any of them is expanded. Each child session is fetched once and then kept current from the event stream, so re-subscribing a thread does not refetch it.
+
+A `task` part carries `messages` only once its child session has loaded. While the child is still loading, the part projects as an ordinary tool call, so an empty `messages` array always means the sub-agent produced nothing rather than that its transcript is still in flight.
+
+Use assistant-ui's [`MessagePartPrimitive.Messages`](/docs/tools/multi-agent) inside a `task` tool renderer to display the child conversation. Nested conversations are read-only and inherit the parent thread's tool renderers.
+
 ## Install
 
 <InstallCommand npm={["@assistant-ui/react", "@assistant-ui/react-opencode", "@opencode-ai/sdk"]} />

package/.docs/raw/docs/runtimes/pick-a-runtime.mdx

@@ -6,6 +6,7 @@ description: Decision guide for choosing the right runtime, by framework or by f
 import { A2AIcon } from "@/components/icons/a2a";
 import { AdkIcon } from "@/components/icons/adk";
 import { AguiIcon } from "@/components/icons/agui";
+import { ClaudeIcon } from "@/components/icons/claude";
 import { CloudflareIcon } from "@/components/icons/cloudflare";
 import { LangChainIcon } from "@/components/icons/langchain";
 import { LangGraphIcon } from "@/components/icons/langgraph";
@@ -80,7 +81,7 @@ assistant-ui ships React adapter packages for these. Pick the matching card and
 
 ### Integration guides
 
-For frameworks without a dedicated adapter, these wiring guides route through one of the adapters above.
+For frameworks without a dedicated adapter, these wiring guides route through an existing runtime: an adapter above, or one of the core runtimes.
 
   <Cards>
     <Card
@@ -95,6 +96,12 @@ For frameworks without a dedicated adapter, these wiring guides route through on
       description="TypeScript agent framework. Wired through the Vercel AI SDK runtime."
       href="/docs/integrations/frameworks/mastra/overview"
     />
+    <Card
+      icon={<ClaudeIcon width={20} height={20} className="text-[#D97757]" />}
+      title="Claude Managed Agents"
+      description="Anthropic-hosted agent sessions. Wired through the external store runtime: event-log replay, approval gates, sessions as threads."
+      href="/docs/runtimes/claude-managed-agents"
+    />
   </Cards>
 
 </PlatformOnly>

package/.docs/raw/docs/tools/backend.mdx

@@ -42,7 +42,7 @@ export async function POST(req: Request) {
   const { messages, system, tools } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-nano"),
+    model: openai("gpt-5.6-luna"),
     system,
     messages: await convertToModelMessages(messages),
     tools: await aiToolkit.tools({ frontend: tools }),
@@ -79,7 +79,7 @@ export async function POST(req: Request) {
   const { messages, tools } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-nano"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(messages),
     tools: {
       ...frontendTools(tools ?? {}),

package/.docs/raw/docs/tools/defining-tools.mdx

@@ -115,21 +115,23 @@ The inner `"use client"` inside `execute` marks this as a **frontend** tool —
 
 ### Register the toolkit
 
-Import the toolkit in your runtime provider and pass it to `useAui` via `Tools`:
+Import the toolkit in your runtime provider and pass it to `config` via `Tools`:
 
 ```tsx title="app/MyRuntimeProvider.tsx"
 "use client";
 
-import { AssistantRuntimeProvider, Tools, useAui } from "@assistant-ui/react";
+import { AssistantRuntimeProvider, AuiConfig, Tools } from "@assistant-ui/react";
 import { useChatRuntime } from "@assistant-ui/react-ai-sdk";
 import toolkit from "./toolkit";
 
 export function MyRuntimeProvider({ children }: { children: React.ReactNode }) {
   const runtime = useChatRuntime();
-  const aui = useAui({ tools: Tools({ toolkit }) });
-
+  const config = AuiConfig({ tools: Tools({ toolkit }) });
   return (
-    <AssistantRuntimeProvider aui={aui} runtime={runtime}>
+    <AssistantRuntimeProvider
+      runtime={runtime}
+      config={config}
+    >
       {children}
     </AssistantRuntimeProvider>
   );
@@ -157,7 +159,7 @@ export async function POST(req: Request) {
   const { messages, tools } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-nano"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(messages),
     tools: await aiToolkit.tools({ frontend: tools }),
   });
@@ -192,6 +194,25 @@ The compiler also enforces, at build time:
 - a **frontend** tool declares a `render` or `renderText`;
 - a **human** tool declares a `render`.
 
+### Running without your own backend
+
+The client build skips uploading frontend/human schemas because it assumes your backend imported the same file's server build and already knows them. When no server of yours does — for example, cloud-hosted runs — that assumption breaks and the model never learns about those tools. Compile with the `backendless` option so the client keeps every schema uploadable, including the `present`/`prompt_user` schema of a `JSONGenerativeUI` component library:
+
+```ts title="next.config.ts"
+export default withAui({ ...yourConfig, aui: { backendless: true } });
+```
+
+```ts title="vite.config.ts"
+plugins: [aui({ backendless: true })];
+```
+
+```js title="metro.config.js"
+module.exports = withAui({
+  ...getDefaultConfig(__dirname),
+  aui: { backendless: true },
+});
+```
+
 ## Tool kinds
 
 ### Backend tools
@@ -368,7 +389,7 @@ export const toolkit = defineToolkit({
 });
 ```
 
-Register it exactly like a generative toolkit: `useAui({ tools: Tools({ toolkit }) })`. The key must match the tool name your backend or MCP server publishes. Render-only entries upload no schema and run no browser code — they only attach UI to matching tool-call message parts.
+Register it exactly like a generative toolkit: hoist `const config = AuiConfig({ tools: Tools({ toolkit }) })` in the component body and pass `config={config}`. The key must match the tool name your backend or MCP server publishes. Render-only entries upload no schema and run no browser code — they only attach UI to matching tool-call message parts.
 
 <Callout type="warn">
   This `{ type: "backend", render }` shape is **plain-toolkit only**. Inside a