@assistant-ui/mcp-docs-server 0.1.33 → 0.1.35

package/.docs/raw/docs/(docs)/architecture.mdx

@@ -7,18 +7,19 @@ import { Sparkles, PanelsTopLeft, Database, Terminal } from "lucide-react";
 
 ## assistant-ui is built on these main pillars:
 
-<div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-    <Card title='1. Frontend components'>
-        Shadcn UI chat components with built-in state management
-    </Card>
-
-    <Card title='2. Runtime'>
-        State management layer connecting UI to LLMs and backend services
-    </Card>
-
-    <Card title='3. Assistant Cloud'>
-        Hosted service for thread persistence, history, and user management
-    </Card>
+<div className="not-prose grid grid-cols-1 gap-4 md:grid-cols-3">
+  <Card
+    title="1. Frontend components"
+    description="Shadcn UI chat components with built-in state management"
+  />
+  <Card
+    title="2. Runtime"
+    description="State management layer connecting UI to LLMs and backend services"
+  />
+  <Card
+    title="3. Assistant Cloud"
+    description="Hosted service for thread persistence, history, and user management"
+  />
 </div>
 
 
@@ -56,60 +57,71 @@ Thread and message history can be stored by Assistant Cloud or by your own datab
 
 #### **1. Direct Integration with External Providers**
 
-```mermaid
-graph TD
+<Flow.Root
+  llm={`graph TD
     A[Frontend Components] --> B[Runtime]
-    B --> D[External Providers or LLM APIs]
-    
-    
-    classDef default color:#f8fafc,text-align:center
-    
-    style A fill:#e879f9,stroke:#2e1065,stroke-width:2px,color:#2e1065,font-weight:bold
-    style B fill:#93c5fd,stroke:#1e3a8a,stroke-width:2px,color:#1e3a8a,font-weight:bold
-    style D fill:#fca5a5,stroke:#7f1d1d,stroke-width:2px,color:#7f1d1d,font-weight:bold
-    
-    class A,B,C,D,E default
-```
+    B --> D[External Providers or LLM APIs]`}
+>
+  <Flow.Column>
+    <Flow.Node tone="pink">Frontend Components</Flow.Node>
+    <Flow.Arrow direction="down" length={36} />
+    <Flow.Node tone="blue">Runtime</Flow.Node>
+    <Flow.Arrow direction="down" length={36} />
+    <Flow.Node tone="red">External Providers or LLM APIs</Flow.Node>
+  </Flow.Column>
+</Flow.Root>
 
 #### **2. Using your own API endpoint**
 
-```mermaid
-graph TD
+<Flow.Root
+  llm={`graph TD
     A[Frontend Components] --> B[Runtime]
     B --> E[Your API Backend]
-    E --> D[External Providers or LLM APIs]
-    
-    
-    classDef default color:#f8fafc,text-align:center
-    
-    style A fill:#e879f9,stroke:#2e1065,stroke-width:2px,color:#2e1065,font-weight:bold
-    style B fill:#93c5fd,stroke:#1e3a8a,stroke-width:2px,color:#1e3a8a,font-weight:bold
-    style D fill:#fca5a5,stroke:#7f1d1d,stroke-width:2px,color:#7f1d1d,font-weight:bold
-    style E fill:#fca5a5,stroke:#7f1d1d,stroke-width:2px,color:#7f1d1d,font-weight:bold
-    
-    class A,B,C,D,E default
-```
+    E --> D[External Providers or LLM APIs]`}
+>
+  <Flow.Column>
+    <Flow.Node tone="pink">Frontend Components</Flow.Node>
+    <Flow.Arrow direction="down" length={36} />
+    <Flow.Node tone="blue">Runtime</Flow.Node>
+    <Flow.Arrow direction="down" length={36} />
+    <Flow.Node tone="red">Your API Backend</Flow.Node>
+    <Flow.Arrow direction="down" length={36} />
+    <Flow.Node tone="red">External Providers or LLM APIs</Flow.Node>
+  </Flow.Column>
+</Flow.Root>
 
 #### **3. With Assistant Cloud**
 
-```mermaid
-graph TD
+<Flow.Root
+  llm={`graph TD
     A[Frontend Components] --> B[Runtime]
     B --> C[Cloud]
     E --> C
     C --> D[External Providers or LLM APIs]
-    B --> E[Your API Backend]
-    
-    classDef default color:#f8fafc,text-align:center
-    
-    style A fill:#e879f9,stroke:#2e1065,stroke-width:2px,color:#2e1065,font-weight:bold
-    style B fill:#93c5fd,stroke:#1e3a8a,stroke-width:2px,color:#1e3a8a,font-weight:bold
-    style C fill:#86efac,stroke:#064e3b,stroke-width:2px,color:#064e3b,font-weight:bold
-    style D fill:#fca5a5,stroke:#7f1d1d,stroke-width:2px,color:#7f1d1d,font-weight:bold
-    style E fill:#fca5a5,stroke:#7f1d1d,stroke-width:2px,color:#7f1d1d,font-weight:bold
-    
-    class A,B,C,D,E default
-```
+    B --> E[Your API Backend]`}
+>
+  <Flow.Canvas
+    edges={[
+      { from: "runtime", to: "backend", route: "down", fromOffset: -20 },
+      { from: "runtime", to: "cloud", route: "down", fromOffset: 20 },
+      { from: "cloud", to: "providers", route: "down" },
+    ]}
+  >
+    <Flow.Column>
+      <Flow.Node tone="pink">Frontend Components</Flow.Node>
+      <Flow.Arrow direction="down" length={36} />
+      <Flow.Node flowId="runtime" tone="blue">Runtime</Flow.Node>
+      <div className="h-10" aria-hidden />
+      <Flow.Row>
+        <Flow.Node flowId="backend" tone="red">Your API Backend</Flow.Node>
+        <Flow.Arrow length={48} />
+        <Flow.Node flowId="cloud" tone="green">Cloud</Flow.Node>
+      </Flow.Row>
+      <div className="h-10" aria-hidden />
+      <Flow.Node flowId="providers" tone="red">External Providers or LLM APIs</Flow.Node>
+    </Flow.Column>
+  </Flow.Canvas>
+</Flow.Root>
 
 ## Going deeper
 

package/.docs/raw/docs/(reference)/api-reference/external-store/message-conversion.mdx

@@ -47,6 +47,6 @@ const unstable_convertExternalMessages: <T extends WeakKey>(messages: T[], callb
 ### unstable_createMessageConverter
 
 ```ts
-const unstable_createMessageConverter: <T extends object>(callback: useExternalMessageConverter.Callback<T>) => { useThreadMessages: ({ messages, isRunning, joinStrategy, metadata, }: { messages: T[]; isRunning: boolean; joinStrategy?: "concat-content" | "none" | undefined; metadata?: useExternalMessageConverter.Metadata; }) => ThreadMessage[]; toThreadMessages: (messages: T[], isRunning?: boolean, metadata?: useExternalMessageConverter.Metadata) => ThreadMessage[]; toOriginalMessages: (input: ThreadState | ThreadMessage | ThreadMessage["content"][number]) => unknown[]; toOriginalMessage: (input: ThreadState | ThreadMessage | ThreadMessage["content"][number]) => {}; useOriginalMessage: () => {}; useOriginalMessages: () => unknown[]; };
+const unstable_createMessageConverter: <T extends object>(callback: useExternalMessageConverter.Callback<T>) => { useThreadMessages: ({ messages, isRunning, joinStrategy, metadata, }: { messages: T[]; isRunning: boolean; joinStrategy?: JoinStrategy | undefined; metadata?: useExternalMessageConverter.Metadata; }) => ThreadMessage[]; toThreadMessages: (messages: T[], isRunning?: boolean, metadata?: useExternalMessageConverter.Metadata) => ThreadMessage[]; toOriginalMessages: (input: ThreadState | ThreadMessage | ThreadMessage["content"][number]) => unknown[]; toOriginalMessage: (input: ThreadState | ThreadMessage | ThreadMessage["content"][number]) => {}; useOriginalMessage: () => {}; useOriginalMessages: () => unknown[]; };
 ```
 {/* api-reference:end */}

package/.docs/raw/docs/(reference)/api-reference/external-store/runtime.mdx

@@ -28,6 +28,9 @@ import { ExternalStoreAdapter, ExternalThread, ExternalThreadProps, ExternalThre
 
 ### ExternalThreadQueueAdapter
 
+The queue surface a runtime exposes so the composer can stay usable during a
+run and render the pending messages.
+
 <ParametersTable {...ExternalThreadQueueAdapter} />
 
 ### pickExternalStoreSharedOptions

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

@@ -3,7 +3,7 @@ title: Primitive Hooks
 description: Primitive hooks for reading scoped assistant-ui runtime state, viewport behavior, timing, and message part data inside React components.
 ---
 
-import { useAssistantRuntime, useAttachmentRuntime, useCloudThreadListAdapter, useComposerRuntime, useEditComposerAttachmentRuntime, useMessageAttachmentRuntime, useMessagePartData, useMessagePartRuntime, useMessageRuntime, useScrollLock, useThreadComposerAttachmentRuntime, useThreadListItemRuntime, useThreadRuntime, useThreadViewportAutoScroll } from "@/generated/typeDocs";
+import { unstable_useMessageStallDetection, useAssistantRuntime, useAttachmentRuntime, useCloudThreadListAdapter, useComposerRuntime, useEditComposerAttachmentRuntime, useMessageAttachmentRuntime, useMessagePartData, useMessagePartRuntime, useMessageRuntime, useScrollLock, useThreadComposerAttachmentRuntime, useThreadListItemRuntime, useThreadRuntime, useThreadViewportAutoScroll } from "@/generated/typeDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
 {/* Do not edit manually. */}
@@ -637,4 +637,47 @@ const useThreadViewport: { (): ThreadViewportState; <TSelected>(selector: (state
 ```ts
 const useThreadViewportStore: { (): ReadonlyStore<ThreadViewportState>; (options: { optional: true; }): ReadonlyStore<ThreadViewportState> | null; };
 ```
+
+### unstable_useComposerInputHistory
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Under active development and might change without notice.
+</Callout>
+
+Terminal-style input history for the thread composer: ArrowUp on an
+empty draft recalls previously sent user messages (newest first),
+ArrowDown steps back toward the newest and finally restores the draft
+that was being typed when browsing started.
+
+Recall only triggers when the caret is on the first/last line with no
+selection, so multi-line editing keeps native arrow behavior. The
+handler yields to an open mention/slash popover, to IME composition,
+to modifier keys, and to consumer handlers that already called
+`preventDefault`. It is inert on edit composers.
+
+```tsx
+const history = unstable_useComposerInputHistory();
+<ComposerPrimitive.Input {...history} />
+```
+
+```ts
+function unstable_useComposerInputHistory(): Unstable_ComposerInputHistory;
+```
+
+### unstable_useMessageStallDetection
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Under active development and might change without notice.
+</Callout>
+
+Detects mid-run output stalls on the current message: while the message is
+running, watches a fingerprint of its content (part count plus text,
+argument, and result sizes) and reports a stall once the fingerprint stops
+changing for `thresholdMs`. Useful for re-surfacing a "still working"
+indicator during tool think-time or provider stalls, after the first
+tokens have already streamed.
+
+Must be used inside a message scope.
+
+<ParametersTable {...unstable_useMessageStallDetection} />
 {/* api-reference:end */}

package/.docs/raw/docs/(reference)/api-reference/integrations/react-ai-sdk.mdx

@@ -36,6 +36,14 @@ const frontendTools: (tools: Record<string, ToolJSONSchema>) => ToolSet;
 
 ### generativeTools
 
+<Callout type="warn">
+<strong>Deprecated.</strong> Use [AISDKToolkit](/docs/api-reference/integrations/react-ai-sdk#aisdktoolkit) instead:
+`new AISDKToolkit({ toolkit }).tools({ frontend })`. It is a strict superset
+(it also opens MCP server connections), so it replaces `generativeTools`
+everywhere. The `frontendTools` option is named `frontend` on `.tools()`, and
+`.tools()` is async. `generativeTools` will be removed in a future version.
+</Callout>
+
 Builds an AI SDK `ToolSet` for server-side use with `streamText` /
 `generateText` from a generative `toolkit` and the frontend-uploaded tools.
 
@@ -44,15 +52,18 @@ Each toolkit tool's `execute` runs on the server. Pair this with the
 resolves to the server build — schema + `execute`, with `render` stripped) and
 pass it here. Tools without an `execute` are still exposed to the model but
 left for the client to fulfill. `frontendTools` lets the client contribute
-tools that aren't in the static toolkit. Use [AISDKToolkit](/docs/api-reference/integrations/react-ai-sdk#aisdktoolkit) when the
-toolkit contains MCP entries.
+tools that aren't in the static toolkit.
 
 ```ts
+// Define once at module scope so any MCP connections pool across requests.
+const aiToolkit = new AISDKToolkit({ toolkit: docsToolkit });
+
+// In your route handler:
 const { tools } = await req.json();
 streamText({
   model,
   messages,
-  tools: generativeTools({ toolkit: docsToolkit, frontendTools: tools }),
+  tools: await aiToolkit.tools({ frontend: tools }),
 });
 ```
 

package/.docs/raw/docs/(reference)/api-reference/model-context/context.mdx

@@ -29,7 +29,7 @@ const mergeModelContexts: (configSet: Set<ModelContextProvider>) => ModelContext
 ### ModelContextClient
 
 ```ts
-const ModelContextClient: () => ResourceElement<ClientOutput<"modelContext">, undefined>;
+const ModelContextClient: Resource<ClientOutput<"modelContext">, []>;
 ```
 
 ### ModelContextProvider

package/.docs/raw/docs/(reference)/api-reference/tools/rendering.mdx

@@ -3,7 +3,7 @@ title: Tool Rendering
 description: Register React renderers for assistant-ui tool calls, tool results, and model data parts.
 ---
 
-import { McpAppRenderer, McpAppsRemoteHost, getMcpAppFromToolPart, useAssistantDataUI, useAssistantToolUI } from "@/generated/typeDocs";
+import { DataRenderers, McpAppRenderer, McpAppsRemoteHost, getMcpAppFromToolPart, useAssistantDataUI, useAssistantToolUI } from "@/generated/typeDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
 {/* Do not edit manually. */}
@@ -16,15 +16,7 @@ import { McpAppRenderer, McpAppsRemoteHost, getMcpAppFromToolPart, useAssistantD
 
 ### DataRenderers
 
-Registers renderers for `data` message parts.
-
-Data renderers are looked up by the part's `name` field. Use this resource
-directly for a renderer scope, or prefer [useAssistantDataUI](/docs/api-reference/tools/rendering#useassistantdataui) /
-[makeAssistantDataUI](/docs/api-reference/tools/rendering#makeassistantdataui) when registering from React components.
-
-```ts
-const DataRenderers: () => ResourceElement<ClientOutput<"dataRenderers">, undefined>;
-```
+<ParametersTable {...DataRenderers} />
 
 ### getMcpAppFromToolPart
 
@@ -84,23 +76,10 @@ const makeAssistantToolUI: <TArgs, TResult>(tool: AssistantToolUIProps<TArgs, TR
 
 ### McpAppRenderer
 
-Creates a tool-call renderer for MCP Apps embedded in assistant messages.
-
-Compose this into the `Tools` resource through its `mcpApp` option. When a
-tool-call part carries `mcp.app` metadata for a `ui://` resource, the
-renderer loads that resource from the configured host and displays it in a
-sandboxed frame.
-
 <ParametersTable {...McpAppRenderer} />
 
 ### McpAppsRemoteHost
 
-Creates the default HTTP host for MCP App widgets.
-
-The host POSTs widget requests to the configured route as `{ method,
-params }`, using the method names expected by the assistant-ui MCP Apps
-guide.
-
 <ParametersTable {...McpAppsRemoteHost} />
 
 ### useAssistantDataUI

package/.docs/raw/docs/(reference)/api-reference/tools/status.mdx

@@ -39,4 +39,26 @@ function WeatherToolUI({
 ```ts
 const useToolArgsStatus: <TArgs extends Record<string, unknown> = Record<string, unknown>>() => ToolArgsStatus<TArgs>;
 ```
+
+### useToolCallElapsed
+
+Hook that returns the elapsed wall-clock time of the current tool call in
+milliseconds, ticking once per second while the call runs.
+
+Reads `part.timing`. Returns `undefined` when the part is not a tool call,
+carries no timing, ended without a recorded completion (the duration is
+unknown), or when no message part scope is available (so kit components
+stay renderable standalone, e.g. in docs previews).
+
+```tsx
+function ToolDuration() {
+  const elapsedMs = useToolCallElapsed();
+  if (elapsedMs === undefined) return null;
+  return <span>{(elapsedMs / 1000).toFixed(1)}s</span>;
+}
+```
+
+```ts
+const useToolCallElapsed: () => number;
+```
 {/* api-reference:end */}

package/.docs/raw/docs/(reference)/api-reference/tools/toolkits.mdx

@@ -3,7 +3,7 @@ title: Toolkits
 description: Define model-facing tools and compose them into named toolkits registered with an assistant-ui runtime scope.
 ---
 
-import { ToolDefinition, Tools, tool } from "@/generated/typeDocs";
+import { ToolDefinition, Tools, defineMcpToolkit, defineToolkit, providerTool, tool } from "@/generated/typeDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
 {/* Do not edit manually. */}
@@ -63,7 +63,7 @@ Named collection of tools exposed to the assistant model.
 Keys are the tool names the model receives and uses in tool calls.
 
 ```tsx
-const toolkit = {
+const toolkit = defineToolkit({
   get_weather: {
     type: "frontend",
     description: "Get the weather for a city.",
@@ -71,7 +71,7 @@ const toolkit = {
     execute: async ({ city }: { city: string }) => fetchWeather(city),
     render: WeatherToolUI,
   },
-} satisfies Toolkit;
+});
 ```
 
 ```ts
@@ -80,12 +80,96 @@ type Toolkit = Record<string, ToolDefinition<any, any>>;
 
 ### Tools
 
-Registers tools with model context and installs tool-call renderers.
+<ParametersTable {...Tools} />
 
-Mount this resource near an assistant subtree when you want to expose a
-group of tools declaratively. Tool definitions are registered with model
-context, while each tool renderer is registered with the tools scope for
-message rendering.
+### defineMcpToolkit
 
-<ParametersTable {...Tools} />
+Defines MCP server tools as a spreadable toolkit fragment.
+
+<ParametersTable {...defineMcpToolkit} />
+
+### defineToolkit
+
+Toolkit authoring helper. Accepts the permissive ToolkitDefinition
+(a generative `backend` tool may carry its server `execute`) and types the
+result as the canonical [Toolkit](/docs/api-reference/tools/toolkits#toolkit).
+
+In a `"use generative"` file, the compiler strips the wrapper per build so it
+can split schemas, renderers, and executors across the client/server boundary.
+Outside generative compilation, it returns the toolkit unchanged and can be
+used for plain frontend/backend/human toolkit objects.
+
+<ParametersTable {...defineToolkit} />
+
+### externalTool
+
+Marks a generative toolkit entry as an externally executed backend tool.
+
+Use this when another system (for example a backend route or LangGraph node)
+already defines and executes the tool, but assistant-ui should render its
+tool calls. The use-generative compiler omits `execute: externalTool()`
+entries from the server build and keeps a `type: "backend"` renderer on the
+client build.
+
+```ts
+function externalTool(): never;
+```
+
+### hitl
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Use [humanTool](/docs/api-reference/tools/toolkits#humantool).
+</Callout>
+
+```ts
+const hitl: typeof humanTool;
+```
+
+### hitlTool
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Use [humanTool](/docs/api-reference/tools/toolkits#humantool).
+</Callout>
+
+```ts
+const hitlTool: typeof humanTool;
+```
+
+### humanTool
+
+Marks a tool as **human-in-the-loop**: the agent pauses and the UI (`render`)
+supplies the result instead of code. Use it as the tool's `execute`:
+
+```tsx
+confirm: { execute: humanTool(), render: (props) => <Confirm {...props} /> }
+```
+
+Unlike [defineToolkit](/docs/api-reference/tools/toolkits#definetoolkit), it has **no runtime implementation**: a
+`"use generative"` compiler (e.g. `@assistant-ui/next` or `@assistant-ui/vite`)
+detects `execute: humanTool()`, drops it, and stamps the tool `type: "human"`.
+Reaching it at runtime means the module wasn't compiled (used outside a
+`"use generative"` file), so it throws.
+
+```ts
+function humanTool(): never;
+```
+
+### providerTool
+
+Marks a tool as provider-executed. The use-generative compiler converts
+`execute: providerTool(...)` into a `type: "provider"` tool entry.
+
+<ParametersTable {...providerTool} />
+
+### stubTool
+
+Marks a generative toolkit entry as a frontend tool whose executor will be
+supplied by `useAuiToolOverrides(...)`.
+
+`stubTool()` has no runtime implementation. It must be used inside a
+`"use generative"` toolkit file so the compiler can strip it.
+
+```ts
+function stubTool(): never;
+```
 {/* api-reference:end */}

package/.docs/raw/docs/(reference)/api-reference/utilities/miscellaneous.mdx

@@ -3,7 +3,7 @@ title: Utilities
 description: Miscellaneous @assistant-ui/react utilities for custom rendering, composition, and advanced assistant UI behavior.
 ---
 
-import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, InMemoryThreadList, SingleThreadList, defineMcpToolkit, defineToolkit, providerTool } from "@/generated/typeDocs";
+import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, InMemoryThreadList, Interactables, SingleThreadList, Suggestions, useSmooth } from "@/generated/typeDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
 {/* Do not edit manually. */}
@@ -22,60 +22,15 @@ import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, InMemoryThreadList
 
 <ParametersTable {...ChainOfThoughtClient} />
 
-### defineMcpToolkit
-
-Defines MCP server tools as a spreadable toolkit fragment.
-
-<ParametersTable {...defineMcpToolkit} />
-
-### defineToolkit
-
-Authoring helper for a `"use generative"` toolkit. Accepts the permissive
-ToolkitDefinition (a `backend` tool may carry its server `execute`)
-and types the result as the canonical [Toolkit](/docs/api-reference/tools/toolkits#toolkit).
-
-It has **no runtime implementation**. A `"use generative"` compiler (e.g.
-`@assistant-ui/next` or `@assistant-ui/vite`) strips the `defineToolkit(...)`
-wrapper (and its import) per build, so a correctly compiled
-`export default defineToolkit({...})` never calls this. If it *does* run, the
-module was not compiled by a use-generative loader — e.g. `defineToolkit` used
-outside a `"use generative"` file — which would ship a backend `execute` to the
-client. So it throws instead of silently leaking.
-
-<ParametersTable {...defineToolkit} />
-
-### DevToolsHooks
-
-<ParametersTable {...DevToolsHooks} />
-
-### hitl
-
-<Callout type="warn">
-<strong>Deprecated.</strong> Use [hitlTool](/docs/api-reference/utilities/miscellaneous#hitltool).
-</Callout>
+### createMessageQueue
 
 ```ts
-const hitl: typeof hitlTool;
-```
-
-### hitlTool
-
-Marks a tool as **human-in-the-loop**: the agent pauses and the UI (`render`)
-supplies the result instead of code. Use it as the tool's `execute`:
-
-```tsx
-confirm: { execute: hitlTool(), render: (props) => <Confirm {...props} /> }
+const createMessageQueue: (driver: MessageQueueDriver) => MessageQueueController;
 ```
 
-Like [defineToolkit](/docs/api-reference/utilities/miscellaneous#definetoolkit), it has **no runtime implementation**: a
-`"use generative"` compiler (e.g. `@assistant-ui/next` or `@assistant-ui/vite`)
-detects `execute: hitlTool()`, drops it, and stamps the tool `type: "human"`.
-Reaching it at runtime means the module wasn't compiled (used outside a
-`"use generative"` file), so it throws.
+### DevToolsHooks
 
-```ts
-function hitlTool(): never;
-```
+<ParametersTable {...DevToolsHooks} />
 
 ### InMemoryThreadList
 
@@ -83,54 +38,34 @@ function hitlTool(): never;
 
 ### Interactables
 
-```ts
-const Interactables: () => ResourceElement<ClientOutput<"interactables">, undefined>;
-```
-
-### providerTool
-
-Marks a tool as provider-executed. The use-generative compiler converts
-`execute: providerTool(...)` into a `type: "provider"` tool entry.
-
-<ParametersTable {...providerTool} />
+<ParametersTable {...Interactables} />
 
 ### SingleThreadList
 
-A minimal threads scope that wraps a single thread.
-Automatically provided by ExternalThread when no threads scope exists.
-Mounts the provided thread resource element.
-
 <ParametersTable {...SingleThreadList} />
 
-### stubTool
+### Suggestions
 
-Marks a generative toolkit entry as a frontend tool whose executor will be
-supplied by `useAuiToolOverrides(...)`.
+<ParametersTable {...Suggestions} />
 
-`stubTool()` has no runtime implementation. It must be used inside a
-`"use generative"` toolkit file so the compiler can strip it.
+### useSmooth
 
-```ts
-function stubTool(): never;
-```
+Animates streamed message part text with a typewriter-style reveal.
 
-### Suggestions
+Takes the current part state and a `smooth` argument: `false` disables,
+`true` uses the default rate, and a SmoothOptions object tunes
+the reveal. Returns the part state with `text` replaced by the revealed
+prefix and `status` reporting `running` until the reveal catches up.
 
-```ts
-const Suggestions: {
-  (): ResourceElement<
-    ClientOutput<"suggestions">,
-    undefined
-  >;
-  (
-    suggestions: SuggestionConfig[],
-  ): ResourceElement<
-    ClientOutput<"suggestions">,
-    SuggestionConfig[]
-  >;
-};
+```tsx
+const { text, status } = useSmooth(useMessagePartText(), {
+  drainMs: 500,
+  maxCharsPerFrame: 30,
+});
 ```
 
+<ParametersTable {...useSmooth} />
+
 ### unstable_defaultDirectiveFormatter
 
 Default directive formatter using the `:type[label]{name=id}` syntax.

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

@@ -60,7 +60,7 @@ const AssistantMessage: FC = () => {
             case "group-reasoning": {
               const running = part.status.type === "running";
               return (
-                <ReasoningRoot defaultOpen={running}>
+                <ReasoningRoot streaming={running}>
                   <ReasoningTrigger active={running} />
                   <ReasoningContent aria-busy={running}>
                     <ReasoningText>{children}</ReasoningText>

package/.docs/raw/docs/guides/index.mdx

@@ -68,6 +68,9 @@ Render specialized message content.
   <Card title="LaTeX" href="/docs/guides/latex">
     Render math via React Markdown or Streamdown, with streaming-safe escape rules.
   </Card>
+  <Card title="Thread Virtualization" href="/docs/guides/virtualization">
+    Render very long threads with @tanstack/react-virtual and per-index message rendering.
+  </Card>
 </Cards>
 
 ## Audio