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

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

@@ -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. */}
@@ -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} />
 
@@ -64,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.",
@@ -72,7 +71,7 @@ const toolkit = {
     execute: async ({ city }: { city: string }) => fetchWeather(city),
     render: WeatherToolUI,
   },
-} satisfies Toolkit;
+});
 ```
 
 ```ts
@@ -89,4 +88,95 @@ context, while each tool renderer is registered with the tools scope for
 message rendering.
 
 <ParametersTable {...Tools} />
+
+### defineMcpToolkit
+
+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, ExportedMessageRepository, GenerativeUIRender, GenerativeUIRenderError, InMemoryThreadList, McpAppRenderer, McpAppsRemoteHost, SingleThreadList, getMcpAppFromToolPart } from "@/generated/typeDocs";
+import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, InMemoryThreadList, SingleThreadList } from "@/generated/typeDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
 {/* Do not edit manually. */}
@@ -22,40 +22,15 @@ import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, ExportedMessageRep
 
 <ParametersTable {...ChainOfThoughtClient} />
 
-### DevToolsHooks
-
-<ParametersTable {...DevToolsHooks} />
-
-### ExportedMessageRepository
-
-<ParametersTable {...ExportedMessageRepository} />
-
-### GenerativeUIRender
-
-Internal renderer. Resolves a GenerativeUISpec against the consumer
-allowlist. Used by `MessagePrimitive.GenerativeUI` and by
-`MessagePrimitive.Parts` when handling a `generative-ui` part.
+### createMessageQueue
 
-<ParametersTable {...GenerativeUIRender} />
-
-### GenerativeUIRenderError
-
-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 {...GenerativeUIRenderError} />
-
-### getMcpAppFromToolPart
-
-Returns MCP app metadata for a tool-call part that points at a `ui://`
-resource.
+```ts
+const createMessageQueue: (driver: MessageQueueDriver) => MessageQueueController;
+```
 
-Returns `undefined` when the part has no MCP app metadata or the metadata
-does not reference an assistant-ui MCP app resource.
+### DevToolsHooks
 
-<ParametersTable {...getMcpAppFromToolPart} />
+<ParametersTable {...DevToolsHooks} />
 
 ### InMemoryThreadList
 
@@ -67,33 +42,6 @@ does not reference an assistant-ui MCP app resource.
 const Interactables: () => ResourceElement<ClientOutput<"interactables">, undefined>;
 ```
 
-### makeAssistantVisible
-
-```ts
-const makeAssistantVisible: <T extends ComponentType<any>>(Component: T, config?: { clickable?: boolean | undefined; editable?: boolean | undefined; }) => T;
-```
-
-### 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} />
-
 ### SingleThreadList
 
 A minimal threads scope that wraps a single thread.

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/{(docs)/copilots → copilots}/model-context.mdx

@@ -38,43 +38,51 @@ const ReadableComponent = makeAssistantVisible(MyComponent);
 
 Tools are functions that the assistant can use to interact with your application. They can be provided through various mechanisms:
 
-```tsx
+```tsx title="app/form-toolkit.tsx"
+"use generative";
+
+import { defineToolkit } from "@assistant-ui/react";
+import { z } from "zod";
+
+export default defineToolkit({
+  submitForm: {
+    description: "Submit the form with the user's details.",
+    parameters: z.object({
+      email: z.string().email(),
+      name: z.string(),
+    }),
+    execute: async ({ email, name }) => {
+      "use client";
+      // Implementation
+      return { success: true };
+    },
+    renderText: { running: "Submitting…", complete: "Submitted" },
+  },
+});
+```
+
+```tsx title="app/Form.tsx"
 import {
+  AuiProvider,
   makeAssistantVisible,
-  makeAssistantTool,
-  tool,
+  Tools,
+  useAui,
 } from "@assistant-ui/react";
-import { z } from "zod";
+import toolkit from "./form-toolkit";
 
 // Via makeAssistantVisible's clickable option
 const ClickableButton = makeAssistantVisible(Button, {
   clickable: true, // Provides a click tool
 });
 
-// Via makeAssistantTool
-const submitForm = tool({
-  parameters: z.object({
-    email: z.string().email(),
-    name: z.string(),
-  }),
-  execute: async ({ email, name }) => {
-    // Implementation
-    return { success: true };
-  },
-});
-
-const SubmitFormTool = makeAssistantTool({
-  ...submitForm,
-  toolName: "submitForm"
-});
-
 // Use in your component
 function Form() {
+  const aui = useAui({ tools: Tools({ toolkit }) });
+
   return (
-    <div>
+    <AuiProvider value={aui}>
       <form>{/* form fields */}</form>
-      <SubmitFormTool />
-    </div>
+    </AuiProvider>
   );
 }
 ```
@@ -134,8 +142,8 @@ Multiple providers can be registered, and their contexts will be composed:
 
 2. **Tools**
 
-   - Use the tool() helper to define tool schemas and behavior
-   - Prefer makeAssistantTool for reusable tools
+   - Use toolkit entries to define tool schemas and behavior
+   - Prefer `Tools({ toolkit })` for reusable tools
    - Handle errors gracefully
    - Consider async operations and loading states
    - Use the built-in click tool when possible

package/.docs/raw/docs/{(docs)/copilots → copilots}/motivation.mdx

@@ -98,44 +98,50 @@ function SmartTransactionHistory() {
 }
 ```
 
-### 3. Creating Tools (makeAssistantTool)
+### 3. Creating Tools
 
 Let's add transaction-specific tools for the assistant:
 
-```tsx
-import { makeAssistantTool, tool } from "@assistant-ui/react";
+```tsx title="app/transaction-toolkit.tsx"
+"use generative";
+
+import { defineToolkit } from "@assistant-ui/react";
 import { z } from "zod";
 
-// Define a tool to analyze transactions
-const analyzeTransaction = tool({
-  parameters: z.object({
-    transactionId: z.string(),
-    merchantName: z.string(),
-  }),
-  execute: async ({ transactionId, merchantName }) => {
-    // Analyze transaction patterns, merchant reputation, etc.
-    return {
-      isSuspicious: false,
-      merchantRating: 4.5,
-      similarTransactions: 3,
-      refundEligible: true,
-    };
+export default defineToolkit({
+  analyzeTransaction: {
+    description: "Analyze a transaction's risk and refund eligibility.",
+    parameters: z.object({
+      transactionId: z.string(),
+      merchantName: z.string(),
+    }),
+    execute: async ({ transactionId, merchantName }) => {
+      "use client";
+      // Analyze transaction patterns, merchant reputation, etc.
+      return {
+        isSuspicious: false,
+        merchantRating: 4.5,
+        similarTransactions: 3,
+        refundEligible: true,
+      };
+    },
+    renderText: { running: "Analyzing transaction…", complete: "Analysis ready" },
   },
 });
+```
 
-// Create a tool component
-const TransactionAnalyzer = makeAssistantTool({
-  ...analyzeTransaction,
-  toolName: "analyzeTransaction",
-});
+```tsx title="app/SmartTransactionHistory.tsx"
+import { AuiProvider, Tools, useAui } from "@assistant-ui/react";
+import toolkit from "./transaction-toolkit";
 
 function SmartTransactionHistory() {
+  const aui = useAui({ tools: Tools({ toolkit }) });
+
   // Previous instructions...
   return (
-    <>
+    <AuiProvider value={aui}>
       <TransactionHistory transactions={transactions} />
-      <TransactionAnalyzer />
-    </>
+    </AuiProvider>
   );
 }
 ```
@@ -191,6 +197,6 @@ This creates a more intuitive and safer banking experience while maintaining the
 Learn more about each API:
 
 - [makeAssistantVisible](make-assistant-visible) for component understanding
-- [makeAssistantTool](make-assistant-tool) for transaction analysis
+- [Tools](/docs/tools/defining-tools) for transaction analysis
 - [useAssistantInstructions](use-assistant-instructions) for behavior guidance
 - [Model Context](model-context) for dynamic context management

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