@assistant-ui/mcp-docs-server 0.1.39 → 0.2.1

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

@@ -4,7 +4,7 @@ description: Reference for projects still on AI SDK v6. New projects should use
 ---
 
 <Callout type="warn">
-AI SDK v6 is a legacy version. New projects should use [AI SDK v7](/docs/runtimes/ai-sdk/v7). v6 users stay on `@assistant-ui/react-ai-sdk@1.x`; the latest line targets v7+.
+AI SDK v6 is a legacy version. New projects should use [AI SDK v7](/docs/runtimes/ai-sdk/v7). v6 users pin `@assistant-ui/react-ai-sdk@1.3.40` (the last v6-compatible release); later releases target v7.
 </Callout>
 
 Requires `ai@^6` and `@ai-sdk/react@^3`. For other versions see the [overview](/docs/runtimes/ai-sdk/overview).
@@ -52,17 +52,17 @@ npm init -y
 <PlatformTabs>
 <Tab value="React">
 
-<InstallCommand npm={["@assistant-ui/react", "@assistant-ui/react-ai-sdk", "ai@^6", "@ai-sdk/react@^3", "@ai-sdk/openai", "zod"]} />
+<InstallCommand npm={["@assistant-ui/react", "@assistant-ui/react-ai-sdk@1.3.40", "ai@^6", "@ai-sdk/react@^3", "@ai-sdk/openai", "zod"]} />
 
 </Tab>
 <Tab value="React Native">
 
-<InstallCommand expo={["@assistant-ui/react-native", "@assistant-ui/react-ai-sdk", "ai@^6", "@ai-sdk/react@^3", "@ai-sdk/openai", "zod"]} />
+<InstallCommand expo={["@assistant-ui/react-native", "@assistant-ui/react-ai-sdk@1.3.40", "ai@^6", "@ai-sdk/react@^3", "@ai-sdk/openai", "zod"]} />
 
 </Tab>
 <Tab value="React Ink">
 
-<InstallCommand npm={["@assistant-ui/react-ink", "@assistant-ui/react-ai-sdk", "ai@^6", "@ai-sdk/react@^3", "@ai-sdk/openai", "zod", "ink", "react"]} />
+<InstallCommand npm={["@assistant-ui/react-ink", "@assistant-ui/react-ai-sdk@1.3.40", "ai@^6", "@ai-sdk/react@^3", "@ai-sdk/openai", "zod", "ink", "react"]} />
 
 </Tab>
 </PlatformTabs>
@@ -92,7 +92,7 @@ export async function POST(req: Request) {
   const { messages }: { messages: UIMessage[] } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(messages), // async in v6
     tools: {
       get_current_weather: tool({
@@ -245,7 +245,7 @@ export async function POST(req: Request) {
   } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     system,
     messages: await convertToModelMessages(messages),
     tools: {
@@ -258,7 +258,7 @@ export async function POST(req: Request) {
 }
 ```
 
-Frontend tools are registered through `useAui` (see the [tools guide](/docs/tools/defining-tools)) and serialized for the backend via `frontendTools`.
+Frontend tools are registered through the provider's `config` (see the [tools guide](/docs/tools/defining-tools)) and serialized for the backend via `frontendTools`.
 
 ## Multi-step tool calls
 
@@ -276,7 +276,7 @@ export async function POST(req: Request) {
   const { messages } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(messages),
     tools: {
       /* ... */
@@ -305,7 +305,7 @@ export async function POST(req: Request) {
   const { messages } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(messages),
     tools: {
       deploy: tool({
@@ -356,9 +356,9 @@ Render the gate with a toolkit entry. The `approval` field carries the gate stat
 import { useChat } from "@ai-sdk/react";
 import {
   AssistantRuntimeProvider,
+  AuiConfig,
   defineToolkit,
   Tools,
-  useAui,
 } from "@assistant-ui/react";
 import { useAISDKRuntime } from "@assistant-ui/react-ai-sdk";
 import { lastAssistantMessageIsCompleteWithApprovalResponses } from "ai";
@@ -397,10 +397,9 @@ export default function Page() {
     sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithApprovalResponses,
   });
   const runtime = useAISDKRuntime(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>
   );
@@ -424,7 +423,7 @@ import { openai } from "@ai-sdk/openai";
 export async function POST(req: Request) {
   const { messages } = await req.json();
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(injectQuoteContext(messages)),
   });
   return result.toUIMessageStreamResponse();

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

@@ -3,7 +3,7 @@ title: AI SDK v7
 description: Integrate Vercel AI SDK v7 with assistant-ui for streaming chat.
 ---
 
-Current-version integration. Requires `ai@^7` and `@ai-sdk/react@^4`. For older versions see the [overview](/docs/runtimes/ai-sdk).
+Current-version integration. Requires `ai@^7` and `@ai-sdk/react@^4`. For older versions see the [overview](/docs/runtimes/ai-sdk/overview).
 
 ## Quickstart
 
@@ -90,7 +90,7 @@ export async function POST(req: Request) {
   const { messages }: { messages: UIMessage[] } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(messages), // async in v7
     tools: {
       get_current_weather: tool({
@@ -245,7 +245,7 @@ export async function POST(req: Request) {
   } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     system,
     messages: await convertToModelMessages(messages),
     tools: {
@@ -260,7 +260,7 @@ export async function POST(req: Request) {
 }
 ```
 
-Frontend tools are registered through `useAui` (see the [tools guide](/docs/tools/defining-tools)) and serialized for the backend via `frontendTools`.
+Frontend tools are registered through the provider's `config` (see the [tools guide](/docs/tools/defining-tools)) and serialized for the backend via `frontendTools`.
 
 ## Multi-step tool calls
 
@@ -280,7 +280,7 @@ export async function POST(req: Request) {
   const { messages } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(messages),
     tools: {
       /* ... */
@@ -311,7 +311,7 @@ export async function POST(req: Request) {
   const { messages } = await req.json();
 
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(messages),
     tools: {
       deploy: tool({
@@ -368,9 +368,9 @@ Render the gate with a toolkit entry. The `approval` field carries the gate stat
 import { useChat } from "@ai-sdk/react";
 import {
   AssistantRuntimeProvider,
+  AuiConfig,
   defineToolkit,
   Tools,
-  useAui,
 } from "@assistant-ui/react";
 import { useAISDKRuntime } from "@assistant-ui/react-ai-sdk";
 import { lastAssistantMessageIsCompleteWithApprovalResponses } from "ai";
@@ -410,10 +410,9 @@ export default function Page() {
     sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithApprovalResponses,
   });
   const runtime = useAISDKRuntime(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>
   );
@@ -439,7 +438,7 @@ import { openai } from "@ai-sdk/openai";
 export async function POST(req: Request) {
   const { messages } = await req.json();
   const result = streamText({
-    model: openai("gpt-5.4-mini"),
+    model: openai("gpt-5.6-luna"),
     messages: await convertToModelMessages(injectQuoteContext(messages)),
   });
   return createUIMessageStreamResponse({
@@ -601,7 +600,7 @@ Beyond transports and adapters, `useChatRuntime` accepts options that control th
 
 ### onThreadIdChange
 
-Called whenever the active thread's settled ID changes, e.g. to sync the active thread to a URL query param:
+Called whenever the runtime changes the active thread's settled ID, e.g. to sync the active thread to a URL query param. Changes supplied through the controlled `threadId` option are not echoed back through this callback.
 
 ```tsx
 const runtime = useChatRuntime({

package/.docs/raw/docs/runtimes/concepts/threads.mdx

@@ -149,7 +149,7 @@ const adapterWithHistory: RemoteThreadListAdapter = {
     const history = useMemo<ThreadHistoryAdapter>(
       () => ({
         async load() {
-          const { remoteId } = aui.threadListItem().getState();
+          const { remoteId } = aui.threadListItem.getState();
           if (!remoteId) return { messages: [] };
           const rows = await fetch(
             `/api/threads/${remoteId}/messages`,
@@ -157,7 +157,7 @@ const adapterWithHistory: RemoteThreadListAdapter = {
           return { messages: rows.map(toThreadMessage) };
         },
         async append({ message, parentId }) {
-          const { remoteId } = await aui.threadListItem().initialize();
+          const { remoteId } = await aui.threadListItem.initialize();
           await fetch(`/api/threads/${remoteId}/messages`, {
             method: "POST",
             body: JSON.stringify({ message, parentId }),
@@ -181,11 +181,11 @@ const adapterWithHistory: RemoteThreadListAdapter = {
 
 ### Avoiding the first-message race
 
-`append` may be called before the thread record exists in your backend. Always await `aui.threadListItem().initialize()` before writing:
+`append` may be called before the thread record exists in your backend. Always await `aui.threadListItem.initialize()` before writing:
 
 ```ts
 async append({ message, parentId }) {
-  const { remoteId } = await aui.threadListItem().initialize();
+  const { remoteId } = await aui.threadListItem.initialize();
   await saveMessage(remoteId, parentId, message);
 }
 ```
@@ -194,14 +194,14 @@ async append({ message, parentId }) {
 
 ### Reloading after async authentication
 
-If your adapter depends on a user that resolves asynchronously (oidc, `next-auth`, `better-auth`), the initial `list()` may run before the user is available. Call `aui.threads().reload()` after auth completes:
+If your adapter depends on a user that resolves asynchronously (oidc, `next-auth`, `better-auth`), the initial `list()` may run before the user is available. Call `aui.threads.reload()` after auth completes:
 
 ```tsx
 function ReloadOnAuth() {
   const aui = useAui();
   const { isLoading, user } = useAuth();
   useEffect(() => {
-    if (!isLoading && user) aui.threads().reload();
+    if (!isLoading && user) aui.threads.reload();
   }, [isLoading, user?.id]);
   return null;
 }
@@ -209,9 +209,48 @@ function ReloadOnAuth() {
 
 `reload()` discards in-flight responses from superseded calls, so it is safe to invoke on every auth transition.
 
+### Refetching the open thread
+
+`reload()` re-runs `list()`, which refreshes thread list metadata only. It does not touch the messages of the thread the user is looking at. When the open thread's server state changes out of band, so that nothing arrives over the stream (a human-in-the-loop interrupt raised by another process, a stalled stream, a status change picked up by polling), call `aui.threads.reloadMainThread()`:
+
+```tsx
+function RefetchOnInterrupt({ status }: { status: string }) {
+  const aui = useAui();
+  useEffect(() => {
+    if (status !== "interrupted") return;
+    aui.threads.reloadMainThread().catch(reportError);
+  }, [status]);
+  return null;
+}
+```
+
+What the promise means depends on the path. On the remount path, it resolves as soon as the replacement runtime attaches, which happens before that runtime's `load()` has started, so awaiting it does not mean the thread is fresh and a failed load cannot reach the caller. On the in-place path, it settles with the refetch itself and rejects when it fails, which is why the example above still handles the rejection.
+
+A thread that has not been sent yet is left alone because it holds no remote state.
+
+What happens to a run in progress depends on the path. The remount path drops the runtime that was rendering the run; whether the run itself stops is up to that hook's unmount cleanup, which core cannot enforce. On the in-place path the runtime that declared the capability decides, since core does not stop the run for it. Either way this belongs on an event rather than a short timer: drive it from a state change like the one above, or skip the call while `useAuiState((s) => s.thread.isRunning)` is true.
+
+How the refetch happens depends on the runtime, in one of three ways. When it declares the capability, the thread runtime is reused: composer drafts survive, existing messages stay rendered while the fresh state loads, and the returned promise settles with the refetch, rejecting if it fails. A remote thread list without the capability remounts the runtime hook instead, which re-runs `load()` at the cost of discarding unsent composer input, and resolves once the new runtime attaches. The single and in-memory thread lists hold no remote state and have no hook to remount, so there it resolves without doing anything.
+
+`useAuiState((s) => s.thread.capabilities.refetchThread)` reports which of those you would get, in place or not. It is not a signal for whether to offer a refresh at all: it is false on the remount path, where the call still does the work, and false again where the call does nothing.
+
+Both the LangGraph and Google ADK adapters register the in-place refetch capability when their runtime hook receives a `load` function; without one they fall back to the remount path. Other remote adapters take the remount path unless they provide the capability themselves.
+
+For an external store runtime, declare it with `onRefetchThread`, which is unrelated to `onReload` (that one re-generates an assistant message):
+
+```ts
+useExternalStoreRuntime({
+  messages,
+  onNew,
+  onRefetchThread: async () => {
+    setMessages(await fetchMessages(threadId));
+  },
+});
+```
+
 ### Paginating the thread list
 
-If your backend returns thread pages, return a `nextCursor` from `list()` and consume `aui.threads().hasMore` plus `aui.threads().loadMore()` in the UI. The runtime threads `params.after` back through `list()` on every `loadMore()`; the initial call passes no `params`, so treat a missing `after` as "first page". `reload()` resets the cursor so the next load starts from page 1 again.
+If your backend returns thread pages, return a `nextCursor` from `list()` and consume `aui.threads.hasMore` plus `aui.threads.loadMore()` in the UI. The runtime threads `params.after` back through `list()` on every `loadMore()`; the initial call passes no `params`, so treat a missing `after` as "first page". `reload()` resets the cursor so the next load starts from page 1 again.
 
 ```ts title="threadListAdapter.ts (excerpt)"
 async list({ after } = {}) {
@@ -271,7 +310,7 @@ A few invariants worth knowing when wiring a custom UI on top of `loadMore()`:
       name: "list",
       type: "(params?: { after?: string }) => Promise<{ threads: RemoteThreadMetadata[]; nextCursor?: string }>",
       description:
-        "Hydrate threads on mount. Each thread must include status and remoteId; title, externalId, and custom are optional. Return a `nextCursor` to enable `aui.threads().loadMore()`; the runtime will pass it back as `params.after` on the next call.",
+        "Hydrate threads on mount. Each thread must include status and remoteId; title, externalId, and custom are optional. Return a `nextCursor` to enable `aui.threads.loadMore()`; the runtime will pass it back as `params.after` on the next call.",
       required: true,
     },
     {
@@ -291,7 +330,7 @@ A few invariants worth knowing when wiring a custom UI on top of `loadMore()`:
       name: "updateCustom",
       type: "(remoteId: string, custom: Record<string, unknown> | undefined) => Promise<void>",
       description:
-        "Optional. Persist replacement custom metadata from `aui.threadListItem().updateCustom(custom)`.",
+        "Optional. Persist replacement custom metadata from `aui.threadListItem.updateCustom(custom)`.",
     },
     {
       name: "archive",
@@ -326,7 +365,7 @@ A few invariants worth knowing when wiring a custom UI on top of `loadMore()`:
     },
     {
       name: "unstable_Provider",
-      type: "ComponentType<PropsWithChildren>",
+      type: "RemoteThreadListProviderComponent",
       description:
         "Optional wrapper rendered around each active thread. Inject thread-scoped adapters (history, attachments) here.",
     },
@@ -361,7 +400,7 @@ function ThreadListItemMeta() {
 }
 ```
 
-`custom` is preserved across `rename`, `archive`, `unarchive`, and `generateTitle`. To replace it from your UI, implement `RemoteThreadListAdapter.updateCustom` and call `aui.threadListItem().updateCustom(custom)`. The cloud adapter persists this through `cloud.threads.update(threadId, { metadata })`. If your adapter mutates thread metadata through a separate application path, return the updated values from `fetch()` or call `aui.threads().reload()` to re-run `list()`.
+`custom` is preserved across `rename`, `archive`, `unarchive`, and `generateTitle`. To replace it from your UI, implement `RemoteThreadListAdapter.updateCustom` and call `aui.threadListItem.updateCustom(custom)`. The cloud adapter persists this through `cloud.threads.update(threadId, { metadata })`. If your adapter mutates thread metadata through a separate application path, return the updated values from `fetch()` or call `aui.threads.reload()` to re-run `list()`.
 
 ## ExternalStoreThreadListAdapter
 

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>),
@@ -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";
@@ -536,8 +554,8 @@ function useResumeOnMount(threadId: string) {
         r.json(),
       );
       if (status.isRunning) {
-        const parentId = aui.thread().getState().messages.at(-1)?.id ?? null;
-        aui.thread().resumeRun({ parentId });
+        const parentId = aui.thread.getState().messages.at(-1)?.id ?? null;
+        aui.thread.resumeRun({ parentId });
       }
     })();
   }, [aui, threadId]);

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,6 +421,26 @@ useEffect(() => {
 }, [isRunning, queue]);
 ```
 
+Queue policy on cancel, edit, and reload is host-owned. Call `queue.notifyCancelled()` in your `onCancel` handler before aborting so the cancelled run's settle pauses draining instead of dispatching the next item (the next send or run start resumes it), or call `queue.clear()` to drop the pending items. 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 () => {
+    queue.notifyCancelled(); // or queue.clear() to drop pending 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.
@@ -741,7 +764,7 @@ useExternalStoreRuntime({
       name: "isSendDisabled",
       type: "boolean",
       description:
-        "Blocks new-message sending while leaving the input usable. When true, the thread composer's canSend becomes false, the Send button is disabled, Enter and the steer hotkey are no-ops, and aui.composer().send() short-circuits. Edit composers (saving message edits) ignore this flag. Use this to gate sending on external React state (e.g. while tools or auth are still loading).",
+        "Blocks new-message sending while leaving the input usable. When true, the thread composer's canSend becomes false, the Send button is disabled, Enter and the steer hotkey are no-ops, and aui.composer.send() short-circuits. Edit composers (saving message edits) ignore this flag. Use this to gate sending on external React state (e.g. while tools or auth are still loading).",
       default: "false",
     },
     {
@@ -787,6 +810,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>
   );
@@ -595,7 +622,7 @@ async function* createCustomStream(): AsyncGenerator<ChatModelRunResult> {
   };
 }
 
-aui.thread().resumeRun({
+aui.thread.resumeRun({
   parentId: "message-id",
   stream: createCustomStream,
 });
@@ -617,8 +644,8 @@ function useStreamReconnect(threadId: string) {
         r.json(),
       );
       if (status.isRunning) {
-        const parentId = aui.thread().getState().messages.at(-1)?.id ?? null;
-        aui.thread().resumeRun({ parentId });
+        const parentId = aui.thread.getState().messages.at(-1)?.id ?? null;
+        aui.thread.resumeRun({ parentId });
       }
     })();
   }, [aui, threadId]);
@@ -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.