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

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 { useAssistantDataUI, useAssistantToolUI } from "@/generated/typeDocs";
+import { McpAppRenderer, McpAppsRemoteHost, getMcpAppFromToolPart, useAssistantDataUI, useAssistantToolUI } from "@/generated/typeDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
 {/* Do not edit manually. */}
@@ -26,6 +26,16 @@ directly for a renderer scope, or prefer [useAssistantDataUI](/docs/api-referenc
 const DataRenderers: () => ResourceElement<ClientOutput<"dataRenderers">, undefined>;
 ```
 
+### getMcpAppFromToolPart
+
+Returns MCP app metadata for a tool-call part that points at a `ui://`
+resource.
+
+Returns `undefined` when the part has no MCP app metadata or the metadata
+does not reference an assistant-ui MCP app resource.
+
+<ParametersTable {...getMcpAppFromToolPart} />
+
 ### makeAssistantDataUI
 
 Creates a React component that registers a named data-part renderer when
@@ -44,6 +54,12 @@ const makeAssistantDataUI: <T = any>(dataUI: AssistantDataUIProps<T>) => Assista
 
 ### makeAssistantToolUI
 
+<Callout type="warn">
+<strong>Deprecated.</strong> Put `render`/`renderText` on the matching toolkit entry, or use
+`MessagePrimitive.Parts` inline tool render overrides for per-message UI.
+See https://assistant-ui.com/docs/migrations/toolkit-tools.
+</Callout>
+
 Creates a React component that registers a tool-call renderer when rendered.
 
 Use this to package reusable display components for tools whose definitions
@@ -55,11 +71,38 @@ type AssistantToolUIProps = {
   toolName: string;
   /** Component rendered for matching tool-call message parts. */
   render: ToolCallMessagePartComponent<TArgs, TResult>;
+  /**
+   * How the UI is presented relative to the chain-of-thought trace. Set
+   * `"standalone"` to surface it on its own (e.g. human-in-the-loop or
+   * generative UI for a backend/MCP tool). Defaults to `"inline"`.
+   */
+  display?: "standalone" | "inline";
 };
 
 const makeAssistantToolUI: <TArgs, TResult>(tool: AssistantToolUIProps<TArgs, TResult>) => AssistantToolUI;
 ```
 
+### 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
 
 Registers a renderer for named `data` message parts while the component is
@@ -69,11 +112,16 @@ mounted.
 
 ### useAssistantToolUI
 
+<Callout type="warn">
+<strong>Deprecated.</strong> Put `render`/`renderText` on the matching toolkit entry, or use
+`MessagePrimitive.Parts` inline tool render overrides for per-message UI.
+See https://assistant-ui.com/docs/migrations/toolkit-tools.
+</Callout>
+
 Registers a tool-call renderer while the component is mounted.
 
-This only affects rendering. Pair it with [useAssistantTool](/docs/api-reference/tools/component-tools#useassistanttool),
-[Tools](/docs/api-reference/tools/toolkits#tools), or a backend tool registry to expose the actual tool
-definition to the model.
+This only affects rendering. Pair it with [Tools](/docs/api-reference/tools/toolkits#tools) or a backend tool
+registry to expose the actual tool definition to the model.
 
 <ParametersTable {...useAssistantToolUI} />
 {/* api-reference:end */}

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

@@ -11,7 +11,7 @@ import { ToolDefinition, Tools, tool } from "@/generated/typeDocs";
 {/* api-manual:start */}
 A `Toolkit` is a named map of model-facing tool definitions. The `Tools` resource installs a toolkit into an assistant subtree, registering each tool with the model context and each `render` component with the tool-call renderer scope.
 
-Use these APIs when you want a tool's availability to follow your runtime or provider tree rather than the mount state of a specific React component. For tools whose lifetime should follow a specific UI surface, see [Component Tools](/docs/api-reference/tools/component-tools).
+Use these APIs when you want a tool's availability to follow your runtime or provider tree. The older component-scoped registration APIs are deprecated; see [Migrating Tools to Toolkits](/docs/migrations/toolkit-tools).
 {/* api-manual:end */}
 
 {/* api-reference:start */}
@@ -26,7 +26,7 @@ Defines a model tool with its argument schema, execution behavior, and
 optional model-output conversion.
 
 This helper keeps reusable tool definitions type-checked and convenient to
-export for a [Toolkit](/docs/api-reference/tools/toolkits#toolkit), [Tools](/docs/api-reference/tools/toolkits#tools), or [useAssistantTool](/docs/api-reference/tools/component-tools#useassistanttool).
+export for a [Toolkit](/docs/api-reference/tools/toolkits#toolkit) registered with [Tools](/docs/api-reference/tools/toolkits#tools).
 Inference from parameter schemas is currently limited, so provide generic
 arguments when you need precise args or result types.
 
@@ -49,11 +49,10 @@ const getWeather = tool<{ city: string }, string>({
 
 Tool definition accepted by the React tool registry.
 
-Extends the core tool contract with a render component. Human tools rely on
-the renderer to collect input from the user. Frontend tools execute in the
-browser and require a UI surface for their progress and result. Backend
-tools execute server-side and may omit a renderer. The `render` component is
-required for frontend and human tools and optional for backend tools.
+Extends the core tool contract with tool-call display options. Human tools
+rely on `render` to collect input from the user. Frontend tools execute in
+the browser and require either `render` or `renderText` for their progress
+and result. Backend tools execute server-side and may omit a renderer.
 
 <ParametersTable {...ToolDefinition} />
 

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, ExportedMessageRepository, GenerativeUIRender, GenerativeUIRenderError, InMemoryThreadList, McpAppRenderer, McpAppsRemoteHost, SingleThreadList, getMcpAppFromToolPart } from "@/generated/typeDocs";
+import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, InMemoryThreadList, SingleThreadList, defineMcpToolkit, defineToolkit, providerTool } from "@/generated/typeDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
 {/* Do not edit manually. */}
@@ -22,77 +22,77 @@ import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, ExportedMessageRep
 
 <ParametersTable {...ChainOfThoughtClient} />
 
-### DevToolsHooks
-
-<ParametersTable {...DevToolsHooks} />
-
-### ExportedMessageRepository
+### defineMcpToolkit
 
-<ParametersTable {...ExportedMessageRepository} />
+Defines MCP server tools as a spreadable toolkit fragment.
 
-### GenerativeUIRender
+<ParametersTable {...defineMcpToolkit} />
 
-Internal renderer. Resolves a GenerativeUISpec against the consumer
-allowlist. Used by `MessagePrimitive.GenerativeUI` and by
-`MessagePrimitive.Parts` when handling a `generative-ui` part.
+### defineToolkit
 
-<ParametersTable {...GenerativeUIRender} />
+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).
 
-### GenerativeUIRenderError
+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.
 
-Thrown when a generative-ui spec references a component name that is not
-present in the consumer-provided allowlist. The allowlist is the security
-boundary in the same-realm rendering path — there is no fallback by
-default. Pass `Fallback` to opt into a soft-fail UX.
+<ParametersTable {...defineToolkit} />
 
-<ParametersTable {...GenerativeUIRenderError} />
-
-### getMcpAppFromToolPart
+### DevToolsHooks
 
-Returns MCP app metadata for a tool-call part that points at a `ui://`
-resource.
+<ParametersTable {...DevToolsHooks} />
 
-Returns `undefined` when the part has no MCP app metadata or the metadata
-does not reference an assistant-ui MCP app resource.
+### hitl
 
-<ParametersTable {...getMcpAppFromToolPart} />
+<Callout type="warn">
+<strong>Deprecated.</strong> Use [hitlTool](/docs/api-reference/utilities/miscellaneous#hitltool).
+</Callout>
 
-### InMemoryThreadList
+```ts
+const hitl: typeof hitlTool;
+```
 
-<ParametersTable {...InMemoryThreadList} />
+### hitlTool
 
-### Interactables
+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`:
 
-```ts
-const Interactables: () => ResourceElement<ClientOutput<"interactables">, undefined>;
+```tsx
+confirm: { execute: hitlTool(), render: (props) => <Confirm {...props} /> }
 ```
 
-### makeAssistantVisible
+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.
 
 ```ts
-const makeAssistantVisible: <T extends ComponentType<any>>(Component: T, config?: { clickable?: boolean | undefined; editable?: boolean | undefined; }) => T;
+function hitlTool(): never;
 ```
 
-### McpAppRenderer
-
-Creates a tool-call renderer for MCP Apps embedded in assistant messages.
+### InMemoryThreadList
 
-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 {...InMemoryThreadList} />
 
-<ParametersTable {...McpAppRenderer} />
+### Interactables
 
-### McpAppsRemoteHost
+```ts
+const Interactables: () => ResourceElement<ClientOutput<"interactables">, undefined>;
+```
 
-Creates the default HTTP host for MCP App widgets.
+### providerTool
 
-The host POSTs widget requests to the configured route as `{ method,
-params }`, using the method names expected by the assistant-ui MCP Apps
-guide.
+Marks a tool as provider-executed. The use-generative compiler converts
+`execute: providerTool(...)` into a `type: "provider"` tool entry.
 
-<ParametersTable {...McpAppsRemoteHost} />
+<ParametersTable {...providerTool} />
 
 ### SingleThreadList
 
@@ -102,6 +102,18 @@ Mounts the provided thread resource element.
 
 <ParametersTable {...SingleThreadList} />
 
+### 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;
+```
+
 ### Suggestions
 
 ```ts

package/.docs/raw/docs/cloud/ai-sdk.mdx

@@ -3,8 +3,6 @@ title: AI SDK
 description: Add cloud persistence to your existing AI SDK app with a single hook.
 ---
 
-import { InstallCommand } from "@/components/docs/fumadocs/install/install-command";
-
 ## Overview
 
 The `@assistant-ui/cloud-ai-sdk` package provides a single hook that adds full message and thread persistence to any [AI SDK](https://sdk.vercel.ai/) application:

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

@@ -26,6 +26,7 @@ Return the same top-level group for reasoning and tool calls, with nested groups
 ```tsx
 import {
   MessagePrimitive,
+  groupPartByType,
 } from "@assistant-ui/react";
 import { MarkdownText } from "@/components/assistant-ui/markdown-text";
 import {
@@ -47,13 +48,10 @@ const AssistantMessage: FC = () => {
   return (
     <MessagePrimitive.Root>
       <MessagePrimitive.GroupedParts
-        groupBy={(part) => {
-          if (part.type === "reasoning")
-            return ["group-chainOfThought", "group-reasoning"];
-          if (part.type === "tool-call")
-            return ["group-chainOfThought", "group-tool"];
-          return null;
-        }}
+        groupBy={groupPartByType({
+          reasoning: ["group-chainOfThought", "group-reasoning"],
+          "tool-call": ["group-chainOfThought", "group-tool"],
+        })}
       >
         {({ part, children }) => {
           switch (part.type) {
@@ -162,5 +160,5 @@ See the complete [with-chain-of-thought example](https://github.com/assistant-ui
 ## Related Guides
 
 - [Reasoning](/docs/ui/reasoning) — reasoning UI primitives for grouped parts
-- [Generative UI](/docs/guides/tool-ui) — custom UI for tool calls
-- [Tools](/docs/guides/tools) — defining and using tools
+- [Generative UI](/docs/tools/tool-ui) — custom UI for tool calls
+- [Tools](/docs/tools/defining-tools) — defining and using tools

package/.docs/raw/docs/guides/context-api.mdx

@@ -219,6 +219,7 @@ aui.threads().getState();
 // ThreadListItem actions
 aui.threadListItem().switchTo();
 aui.threadListItem().rename(title);
+aui.threadListItem().updateCustom(custom);
 aui.threadListItem().archive();
 aui.threadListItem().unarchive();
 aui.threadListItem().delete();
@@ -517,7 +518,7 @@ The table below covers the most commonly used actions. For the full catalog, see
 | Scope          | Actions                                                                                                           | Use Cases                                  |
 | -------------- | ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
 | ThreadList     | `switchToNewThread()`, `switchToThread(id)`, `reload()`, `getLoadThreadsPromise()`, `item(selector)`, `thread("main")`, `getState()` | Thread navigation, creation, and sync |
-| ThreadListItem | `switchTo()`, `rename(title)`, `archive()`, `unarchive()`, `delete()`, `getState()`                              | Thread management operations               |
+| ThreadListItem | `switchTo()`, `rename(title)`, `updateCustom(custom)`, `archive()`, `unarchive()`, `delete()`, `getState()`      | Thread management operations               |
 | Thread         | `append(message)`, `startRun(config)`, `resumeRun(config)`, `cancelRun()`, `reset()`, `export()`, `import(repository)`, `message(selector)`, `composer()`, `getState()` | Message handling and conversation control |
 | Message        | `reload()`, `speak()`, `stopSpeaking()`, `submitFeedback(feedback)`, `switchToBranch(options)`, `getCopyText()`, `part(selector)`, `attachment(selector)`, `composer()`, `setIsCopied(value)`, `setIsHovering(value)`, `getState()` | Message interactions and regeneration |
 | Part           | `addToolResult(result)`, `resumeToolCall(result)`, `getState()`                                                   | Tool call result handling                  |

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

@@ -49,20 +49,11 @@ Customize how messages render, are edited, branched, and suggested.
 
 ## Tools & Generative UI
 
-Connect tools to the LLM and render their outputs as interactive UI.
+Tool calling and generative UI have their own [Tools](/docs/tools) section — defining toolkits, rendering tool calls, interactables, MCP, and multi-agent UIs.
 
 <Cards>
-  <Card title="Tools" href="/docs/guides/tools">
-    Define tools with the Toolkit API, stream args, handle cancellation, and integrate with AI SDK / LangGraph / LangChain.
-  </Card>
-  <Card title="Tool UI" href="/docs/guides/tool-ui">
-    Render tool calls and `DataMessagePart` into custom components, with fallback handling.
-  </Card>
-  <Card title="Interactables" href="/docs/guides/interactables">
-    Persisted, schema-validated interactive UI driven by AI state.
-  </Card>
-  <Card title="Multi-Agent" href="/docs/guides/multi-agent">
-    Sub-agent message attribution via `ToolCallMessagePart.messages` and LangGraph subgraph events.
+  <Card title="Tools" href="/docs/tools">
+    Define toolkits, render tool calls, connect MCP servers, and build generative UI.
   </Card>
 </Cards>
 

package/.docs/raw/docs/guides/mentions.mdx

@@ -144,7 +144,7 @@ Pass the adapter to `TriggerPopover` and declare a `Directive` sub-primitive to
 
 ```tsx
 import { ComposerPrimitive } from "@assistant-ui/react";
-import { unstable_defaultDirectiveFormatter } from "@assistant-ui/core";
+import { unstable_defaultDirectiveFormatter } from "@assistant-ui/react";
 
 <ComposerPrimitive.Unstable_TriggerPopoverRoot>
   <ComposerPrimitive.Root>
@@ -198,7 +198,7 @@ import { unstable_useMentionAdapter } from "@assistant-ui/react";
 
 const mention = unstable_useMentionAdapter();
 // → { adapter, directive } — spread into <ComposerTriggerPopover {...mention} />
-// Default: single "Tools" category reading from useAssistantTool registrations
+// Default: single "Tools" category reading from toolkit registrations
 ```
 
 **Custom items only (no tools):**
@@ -302,7 +302,7 @@ When `id` equals `label`, the `{name=…}` attribute is omitted for brevity:
 Implement `Unstable_DirectiveFormatter` to use a different format:
 
 ```ts
-import type { Unstable_DirectiveFormatter } from "@assistant-ui/core";
+import type { Unstable_DirectiveFormatter } from "@assistant-ui/react";
 
 const slashFormatter: Unstable_DirectiveFormatter = {
   serialize(item) {
@@ -516,5 +516,5 @@ Mentions and slash commands coexist on the same composer. See [Combining Slash C
 - [ComposerTriggerPopover UI Component](/docs/ui/composer-trigger-popover) — pre-built shadcn component
 - [DirectiveText UI Component](/docs/ui/directive-text) — renders mention chips in user messages
 - [Slash Commands Guide](/docs/guides/slash-commands) — `/` command system built on the same architecture
-- [Tools Guide](/docs/guides/tools) — register tools that appear in the mention picker
+- [Tools Guide](/docs/tools/defining-tools) — register tools that appear in the mention picker
 - [Composer Primitives](/docs/primitives/composer) — underlying composer primitives

package/.docs/raw/docs/guides/slash-commands.mdx

@@ -24,7 +24,7 @@ By default `Action` leaves a directive chip in the composer — giving the user
 
 ### 1. Define Commands with `unstable_useSlashCommandAdapter`
 
-Declare commands (data + `execute` bundled together, like `useAssistantTool`). The hook returns `{ adapter, action }` — wire both into a single `<TriggerPopover>`:
+Declare commands (data + `execute` bundled together, like a toolkit entry). The hook returns `{ adapter, action }` — wire both into a single `<TriggerPopover>`:
 
 ```tsx
 import {

package/.docs/raw/docs/guides/suggestions.mdx

@@ -308,5 +308,5 @@ The new API provides:
 ## Related
 
 - [Thread Component](/docs/ui/thread) - Main chat interface
-- [Tools Guide](/docs/guides/tools) - Configure assistant actions
+- [Tools Guide](/docs/tools/defining-tools) - Configure assistant actions
 - [Context API](/docs/guides/context-api) - Access assistant state

package/.docs/raw/docs/ink/hooks.mdx

@@ -60,6 +60,51 @@ useAuiEvent("thread.runStart", (payload) => {
 });
 ```
 
+### useNotification
+
+Ring the terminal bell and emit an OSC desktop notification when the assistant finishes a run, stops with an error, or pauses for human approval.
+
+```tsx
+import { useNotification } from "@assistant-ui/react-ink";
+
+useNotification();
+```
+
+Defaults:
+
+- `task-complete`: bell + OSC 9
+- `task-incomplete`: bell
+- `needs-input` (assistant message in `requires-action` with `reason: "interrupt"`): bell
+
+Pass `false` to suppress one trigger, or a `NotificationHandler` to override it:
+
+```tsx
+useNotification({
+  onTaskComplete: { osc: "osc99" },
+  onTaskIncomplete: false,
+  onNeedsInput: {
+    custom: (event) => myLogger.log(event),
+  },
+});
+```
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `enabled` | `boolean` | Master switch. Defaults to `true`. |
+| `onTaskComplete` | `NotificationHandler<"task-complete"> \| false` | Fired when the latest assistant message status flips to `complete` after a run was observed. |
+| `onTaskIncomplete` | `NotificationHandler<"task-incomplete"> \| false` | Fired when the latest assistant message status flips to `incomplete` after a run was observed. |
+| `onNeedsInput` | `NotificationHandler<"needs-input"> \| false` | Fired when the latest assistant message enters `requires-action` with `reason: "interrupt"`. Tool-call pauses are skipped. |
+
+`NotificationHandler<T>` fields (all optional, any combination):
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `bell` | `boolean` | Ring the terminal bell (`\x07`). |
+| `osc` | `boolean \| "osc9" \| "osc99" \| "osc777"` | Send an OSC notification. `true` is equivalent to `"osc9"`. |
+| `custom` | `(event: Extract<NotificationEvent, { type: T }>) => void` | User callback invoked with the event payload narrowed to this handler's type. |
+
+Notifications are deduplicated per `thread:message:status:reason` tuple, so passing an inline config object does not produce duplicate fires. `ringBell` and `sendOSCNotification(title, body?, variant?)` are also exported for imperative use. OSC support depends on the terminal emulator.
+
 ## Runtime Hooks
 
 ### useLocalRuntime
@@ -108,52 +153,44 @@ const runtime = useRemoteThreadListRuntime({
 
 ## Model Context Hooks
 
-### useAssistantTool
+### Tools
 
-Register a tool with an optional UI renderer. The tool definition is forwarded to the model, and when the model calls it, the `execute` function runs and the `render` component displays the result.
+Register tools with a toolkit. The tool definition is forwarded to the model, and when the model calls it, the `execute` function runs and the `render` component displays the result.
 
-```tsx
-import { useAssistantTool } from "@assistant-ui/react-ink";
+```tsx title="weather-toolkit.tsx"
+import type { Toolkit } from "@assistant-ui/react-ink";
 import { Text } from "ink";
 
-useAssistantTool({
-  toolName: "get_weather",
-  description: "Get the current weather for a city",
-  parameters: {
-    type: "object",
-    properties: {
-      city: { type: "string" },
+export const toolkit = {
+  get_weather: {
+    type: "frontend",
+    description: "Get the current weather for a city",
+    parameters: {
+      type: "object",
+      properties: {
+        city: { type: "string" },
+      },
+      required: ["city"],
     },
-    required: ["city"],
-  },
-  execute: async ({ city }) => {
-    const res = await fetch(`https://api.weather.example/${city}`);
-    return res.json();
+    execute: async ({ city }) => {
+      const res = await fetch(`https://api.weather.example/${city}`);
+      return res.json();
+    },
+    render: ({ args, result }) => (
+      <Text>{args.city}: {result?.temperature}°F</Text>
+    ),
   },
-  render: ({ args, result }) => (
-    <Text>{args.city}: {result?.temperature}°F</Text>
-  ),
-});
+} satisfies Toolkit;
 ```
 
-### useAssistantToolUI
-
-Register only a UI renderer for a tool (without tool definition or execute function).
-
-```tsx
-import { useAssistantToolUI } from "@assistant-ui/react-ink";
-import { Text } from "ink";
+```tsx title="ToolProvider.tsx"
+import { AuiProvider, Tools, useAui } from "@assistant-ui/react-ink";
+import { toolkit } from "./weather-toolkit";
 
-useAssistantToolUI({
-  toolName: "get_weather",
-  render: ({ args, result, status }) => (
-    <Text>
-      {status?.type === "running"
-        ? `Loading weather for ${args.city}...`
-        : `${args.city}: ${result?.temperature}°F`}
-    </Text>
-  ),
-});
+function ToolProvider({ children }: { children: React.ReactNode }) {
+  const aui = useAui({ tools: Tools({ toolkit }) });
+  return <AuiProvider value={aui}>{children}</AuiProvider>;
+}
 ```
 
 ### useAssistantInstructions
@@ -181,48 +218,9 @@ useAssistantDataUI({
   ),
 });
 ```
-### makeAssistantTool
-
-Create a component that registers a tool when mounted.
-
-```tsx
-import { makeAssistantTool } from "@assistant-ui/react-ink";
-import { Text } from "ink";
-
-const WeatherTool = makeAssistantTool({
-  toolName: "get_weather",
-  description: "Get weather",
-  parameters: { type: "object", properties: { city: { type: "string" } }, required: ["city"] },
-  execute: async ({ city }) => ({ temperature: 72 }),
-  render: ({ args, result }) => <Text>{args.city}: {result?.temperature}°F</Text>,
-});
-
-// Mount inside AssistantRuntimeProvider to register
-<WeatherTool />
-```
-
-### makeAssistantToolUI
+### Dynamic Tool Renderers
 
-Create a component that registers only a tool UI renderer (no tool definition or execute) when mounted.
-
-```tsx
-import { makeAssistantToolUI } from "@assistant-ui/react-ink";
-import { Text } from "ink";
-
-const WeatherToolUI = makeAssistantToolUI({
-  toolName: "get_weather",
-  render: ({ args, result, status }) => (
-    <Text>
-      {status?.type === "running"
-        ? `Loading weather for ${args.city}...`
-        : `${args.city}: ${result?.temperature}°F`}
-    </Text>
-  ),
-});
-
-// Mount inside AssistantRuntimeProvider to register
-<WeatherToolUI />
-```
+Use a toolkit with `useInlineRender` when the renderer closes over changing props.
 
 ### makeAssistantDataUI
 
@@ -247,16 +245,31 @@ const WeatherCardUI = makeAssistantDataUI({
 
 Wrap a render function component so that it always uses the latest version without re-creating a stable reference. Useful when passing a render prop inline and the function closes over changing state.
 
-```tsx
-import { useInlineRender } from "@assistant-ui/react-ink";
-
-const render = useInlineRender(({ args, result }) => (
-  <Text>{args.city}: {result?.temperature}°F</Text>
-));
+```tsx title="weather-toolkit.tsx"
+import { type Toolkit, useInlineRender } from "@assistant-ui/react-ink";
+import { Text } from "ink";
+import { useMemo } from "react";
 
-useAssistantToolUI({ toolName: "get_weather", render });
+export function useWeatherToolkit() {
+  const render = useInlineRender(({ args, result }) => (
+    <Text>{args.city}: {result?.temperature}°F</Text>
+  ));
+
+  return useMemo(
+    () =>
+      ({
+        get_weather: {
+          type: "backend",
+          render,
+        },
+      }) satisfies Toolkit,
+    [render],
+  );
+}
 ```
 
+Import the toolkit hook, pass its result to `useAui({ tools: Tools({ toolkit }) })`, and provide the returned `aui` with `AuiProvider`, as shown in the [Tools](#tools) section above.
+
 ## Runtime Providers
 
 ### AssistantRuntimeProvider

package/.docs/raw/docs/ink/migration.mdx

@@ -9,7 +9,7 @@ If you already have an assistant-ui web app, most of your code transfers directl
 
 - **Runtime setup** — `useLocalRuntime`, `ChatModelAdapter`, and all runtime options work identically.
 - **AI SDK integration** — `@assistant-ui/react-ai-sdk` works with React Ink. Your runtime setup transfers directly.
-- **Tool definitions** — `useAssistantTool`, `makeAssistantTool`, and tool UI renderers use the same API.
+- **Tool definitions** — `Tools({ toolkit })` and toolkit renderers use the same API.
 - **State hooks** — `useAuiState`, `useAui`, and selector patterns are the same.
 - **Backend code** — Your API routes, streaming endpoints, and server-side logic need zero changes.