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

package/.docs/raw/docs/migrations/toolkit-tools.mdx

@@ -0,0 +1,226 @@
+---
+title: Migrating Tools to Toolkits
+description: Move makeAssistantTool, useAssistantTool, makeAssistantToolUI, and useAssistantToolUI registrations to the toolkit API.
+---
+
+The component and hook based tool APIs are deprecated:
+
+- `makeAssistantTool`
+- `useAssistantTool`
+- `makeAssistantToolUI`
+- `useAssistantToolUI`
+
+Use a toolkit registered with `Tools({ toolkit })` instead. Toolkits keep the model contract, browser execution, and tool-call rendering in one named map, which avoids duplicate registrations and makes the client/backend split explicit.
+
+## Before
+
+```tsx
+import { AssistantRuntimeProvider, makeAssistantTool } from "@assistant-ui/react";
+import { useChatRuntime } from "@assistant-ui/react-ai-sdk";
+import { z } from "zod";
+
+const WeatherTool = makeAssistantTool({
+  toolName: "get_weather",
+  description: "Get the current weather for a city.",
+  parameters: z.object({
+    city: z.string(),
+  }),
+  execute: async ({ city }) => fetchWeather(city),
+  render: ({ args, result }) => (
+    <WeatherCard city={args.city} weather={result} />
+  ),
+});
+
+export function App() {
+  const runtime = useChatRuntime({ api: "/api/chat" });
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <WeatherTool />
+      <Thread />
+    </AssistantRuntimeProvider>
+  );
+}
+```
+
+## After
+
+```tsx title="app/toolkit.tsx"
+"use generative";
+
+import { defineToolkit } from "@assistant-ui/react";
+import { z } from "zod";
+
+export default defineToolkit({
+  get_weather: {
+    description: "Get the current weather for a city.",
+    parameters: z.object({
+      city: z.string(),
+    }),
+    execute: async ({ city }) => {
+      "use client";
+      return fetchWeather(city);
+    },
+    render: ({ args, result }) => (
+      <WeatherCard city={args.city} weather={result} />
+    ),
+  },
+});
+```
+
+```tsx title="app/MyRuntimeProvider.tsx"
+"use client";
+
+import {
+  AssistantRuntimeProvider,
+  Tools,
+  useAui,
+} from "@assistant-ui/react";
+import { useChatRuntime } from "@assistant-ui/react-ai-sdk";
+import toolkit from "./toolkit";
+
+export function App() {
+  const runtime = useChatRuntime({ api: "/api/chat" });
+  const aui = useAui({
+    tools: Tools({ toolkit }),
+  });
+
+  return (
+    <AssistantRuntimeProvider aui={aui} runtime={runtime}>
+      <Thread />
+    </AssistantRuntimeProvider>
+  );
+}
+```
+
+## Mechanical Steps
+
+1. Create a `Toolkit` object.
+2. Move each `toolName` into the toolkit key.
+3. Move `description`, `parameters`, `execute`, `providerOptions`, `render`, `renderText`, and `display` onto the toolkit entry.
+4. Register the toolkit once with `useAui({ tools: Tools({ toolkit }) })`.
+5. Remove `<Tool />`, `<ToolUI />`, `useAssistantTool(...)`, and `useAssistantToolUI(...)` registrations.
+
+## UI-Only Tool Renderers
+
+If you used `makeAssistantToolUI` or `useAssistantToolUI` for a backend, MCP, or LangGraph tool, the tool executes elsewhere, so there is no `execute` to author. That makes it a **render-only** entry, which belongs in a plain `satisfies Toolkit` object — not a `"use generative"` file (a generative tool must declare an `execute`). Author an explicit `type: "backend"` with just a `render`:
+
+```tsx
+// app/tool-ui.tsx
+"use client";
+
+import type { Toolkit } from "@assistant-ui/react";
+
+export const toolkit = {
+  web_search: {
+    type: "backend",
+    render: ({ args, result }) => (
+      <SearchResults query={args.query} results={result?.results ?? []} />
+    ),
+  },
+} satisfies Toolkit;
+```
+
+Register it like any toolkit: `useAui({ tools: Tools({ toolkit }) })`. Render-only entries upload no schema and run no browser code — they only attach UI for matching tool-call message parts.
+
+For a one-off renderer that should only affect a particular message surface, use `MessagePrimitive.Parts` inline tool render overrides instead of a global registration.
+
+## Dynamic Tools
+
+If a tool needs component state or props, keep the toolkit contract in a `"use generative"` file and use `stubTool()` for the executor. The component that owns the state supplies the real executor with `useAuiToolOverrides(...)`:
+
+<Callout type="warn">
+  `useAuiToolOverrides` is experimental and its API may change.
+</Callout>
+
+```tsx title="task-board-toolkit.tsx"
+"use generative";
+
+import { defineToolkit, stubTool } from "@assistant-ui/react";
+import { z } from "zod";
+
+export type Task = { id: string; title: string };
+
+export default defineToolkit({
+  add_task: {
+    description: "Add a task to the board.",
+    parameters: z.object({ title: z.string() }),
+    execute: stubTool(),
+    renderText: {
+      running: "Adding task",
+      complete: "Task added",
+    },
+  },
+});
+```
+
+```tsx title="TaskBoard.tsx"
+import { AuiProvider, Tools, useAui, useAuiToolOverrides } from "@assistant-ui/react";
+import { useState, type Dispatch, type SetStateAction } from "react";
+import type { Task } from "./task-board-toolkit";
+import toolkit from "./task-board-toolkit";
+
+function TaskBoard() {
+  const [tasks, setTasks] = useState<Task[]>([]);
+
+  const aui = useAui({
+    tools: Tools({ toolkit }),
+  });
+
+  return (
+    <AuiProvider value={aui}>
+      <TaskBoardToolOverrides setTasks={setTasks} />
+      <TaskList tasks={tasks} />
+    </AuiProvider>
+  );
+}
+
+function TaskBoardToolOverrides({
+  setTasks,
+}: {
+  setTasks: Dispatch<SetStateAction<Task[]>>;
+}) {
+  useAuiToolOverrides({
+    add_task: {
+      execute: async ({ title }) => {
+        setTasks((prev) => [
+          ...prev,
+          { id: crypto.randomUUID(), title },
+        ]);
+        return { ok: true };
+      },
+    },
+  });
+  return null;
+}
+```
+
+This keeps the model-facing contract in the toolkit file while the component owns the stateful executor.
+
+## Generative Toolkits
+
+For tools authored in a `"use generative"` file, export a toolkit with `defineToolkit(...)`. The compiler splits backend, frontend, and human tools for you. This is the default shape to use for docs and copy-paste examples:
+
+```tsx
+"use generative";
+
+import { defineToolkit } from "@assistant-ui/react";
+import { z } from "zod";
+
+export default defineToolkit({
+  create_chart: {
+    description: "Create a chart for the user.",
+    parameters: z.object({
+      title: z.string(),
+      values: z.array(z.number()),
+    }),
+    execute: async ({ title, values }) => {
+      "use client";
+      return renderChart(title, values);
+    },
+    render: ChartTool,
+  },
+});
+```
+
+Frontend and human tools produced by the generative compiler already have their schema defaults on the backend, so the client no longer re-uploads those schemas.

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

@@ -22,19 +22,16 @@ For new grouped reasoning/tool-call UI, use `MessagePrimitive.GroupedParts`. `Ch
   </Tab>
   <Tab>
 ```tsx
-import { MessagePrimitive } from "@assistant-ui/react";
+import { MessagePrimitive, groupPartByType } from "@assistant-ui/react";
 
 function AssistantMessage() {
   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) {
@@ -67,17 +64,14 @@ function AssistantMessage() {
 Group reasoning and tool-call parts directly in your assistant message:
 
 ```tsx
-import { MessagePrimitive } from "@assistant-ui/react";
+import { MessagePrimitive, groupPartByType } from "@assistant-ui/react";
 
 <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) {

package/.docs/raw/docs/primitives/composer.mdx

@@ -526,6 +526,46 @@ Use `onSubmit` on `Root` to intercept submission:
 </ComposerPrimitive.Root>
 ```
 
+### Gate Sending on External State
+
+Sometimes you want users to type while sending is temporarily blocked, for example while tool configuration, auth, or the first model context is still loading. Disabling the entire thread via `isDisabled` works but also disables the text input, which feels broken.
+
+Use `isSendDisabled` on the runtime adapter to keep the input usable while blocking send:
+
+```tsx
+const runtime = useExternalStoreRuntime({
+  isSendDisabled: !toolsLoaded,
+  onNew,
+  messages,
+  // ...
+});
+```
+
+When `isSendDisabled` is `true`:
+
+- `composer.canSend` becomes `false`
+- `<ComposerPrimitive.Send>` is disabled
+- Enter and the `Cmd/Ctrl+Shift+Enter` steer hotkey become no-ops
+- `aui.composer().send()` short-circuits at the runtime, so direct calls cannot escape the gate
+
+Read the same flag from React with `<AuiIf>` to render hints alongside the input:
+
+```tsx
+<ComposerPrimitive.Root>
+  <ComposerPrimitive.Input placeholder="Ask anything..." />
+  <AuiIf condition={(s) => !s.composer.canSend}>
+    <p className="text-sm text-muted-foreground">Loading tools, hang on...</p>
+  </AuiIf>
+  <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+</ComposerPrimitive.Root>
+```
+
+`canSend` reflects the composer's own willingness to send (editing mode, non-empty content, `isSendDisabled` not set). Cross-thread gating like an in-flight run without queue support is layered on top by `<ComposerPrimitive.Send>` automatically.
+
+`isSendDisabled` only gates the thread composer. Saving an in-progress message edit is unaffected, since it is a per-message action rather than a new send.
+
+For the difference between `isDisabled` and `isSendDisabled`, see the [external store adapter reference](/docs/runtimes/custom/external-store).
+
 ### Ctrl+Enter to Submit
 
 ```tsx
@@ -537,6 +577,19 @@ Use `onSubmit` on `Root` to intercept submission:
 
 With `submitMode="ctrlEnter"`, plain Enter inserts a newline and Ctrl/Cmd+Enter submits.
 
+### Mobile / touch devices
+
+```tsx
+<ComposerPrimitive.Root>
+  <ComposerPrimitive.Input unstable_insertNewlineOnTouchEnter />
+  <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+</ComposerPrimitive.Root>
+```
+
+`unstable_insertNewlineOnTouchEnter` switches Enter to insert a newline on touch-primary devices (detected via `(pointer: coarse) and (not (any-pointer: fine))`), so the on-screen Return key never accidentally sends a half-finished message. Submission moves to the explicit Send button, matching WhatsApp, Slack, Discord, iMessage, ChatGPT, and Claude.ai.
+
+Desktop behavior is unchanged. A tablet paired with a hardware keyboard still gets `submitMode`'s usual semantics if you set `submitMode="ctrlEnter"` or `"none"` — the flag only downgrades the default `"enter"` mode.
+
 ### Floating Composer
 
 Primitives aren't bound to any layout. Here's how the floating composer on this docs site is built, using the same `ComposerPrimitive.Root` and `ComposerPrimitive.Input` positioned with CSS:

package/.docs/raw/docs/primitives/index.mdx

@@ -1,6 +1,6 @@
 ---
-title: Overview
-description: Unstyled, accessible building blocks for AI chat interfaces.
+title: Headless Chat Primitives
+description: Unstyled, accessible Radix-style building blocks for React AI chat interfaces — Thread, Composer, Message, and more, ready to compose with assistant-ui.
 platforms: ["react"]
 ---
 

package/.docs/raw/docs/primitives/message.mdx

@@ -117,7 +117,7 @@ For most new code, prefer `MessagePrimitive.Parts` with a `children` render func
 Tool call parts resolve in this order:
 
 1. **`tools.Override`**: if provided inline through the deprecated `components` prop, handles **all** tool calls
-2. **Globally registered tools**: tools registered via `makeAssistantTool` / `useAssistantToolUI`
+2. **Globally registered tools**: tools registered via `Tools({ toolkit })`
 3. **`tools.by_name[toolName]`**: per-`MessagePrimitive.Parts` inline overrides from the deprecated `components` prop
 4. **`tools.Fallback`**: catch-all for unmatched tool calls from the deprecated `components` prop
 5. **`part.toolUI`**: the resolved tool UI exposed directly in the children render function
@@ -250,17 +250,16 @@ Renders each content part with type-based component resolution.
 
 ### GroupedParts
 
-Groups adjacent message parts into a nested tree. Use `groupBy` to return group keys for parts that should be grouped, then switch on `part.type` in the render function. Group cases render `children`; leaf cases render their own UI.
+Groups adjacent message parts into a nested tree. Use `groupBy` to map each part to a group-key path, then switch on `part.type` in the render function. Group cases render `children`; leaf cases render their own UI. Prefer the `groupPartByType` helper for the common `part.type → path` case.
 
 ```tsx
+import { MessagePrimitive, groupPartByType } from "@assistant-ui/react";
+
 <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) {
@@ -514,7 +513,7 @@ import { MessagePrimitive, AuiIf } from "@assistant-ui/react";
 </MessagePrimitive.Root>;
 ```
 
-`s.message.status` is a discriminated union of `running | requires-action | complete | incomplete`, defined only on assistant messages. The `role === "assistant"` guard keeps the predicate type-safe. For tool-call-driven generative UI that defers rendering inside the part itself, see [Deferred Rendering](/docs/guides/tool-ui#deferred-rendering) in the Generative UI guide.
+`s.message.status` is a discriminated union of `running | requires-action | complete | incomplete`, defined only on assistant messages. The `role === "assistant"` guard keeps the predicate type-safe. For tool-call-driven generative UI that defers rendering inside the part itself, see [Deferred Rendering](/docs/tools/tool-ui#deferred-rendering) in the Generative UI guide.
 
 ### Legacy and Unstable APIs
 

package/.docs/raw/docs/primitives/suggestion.mdx

@@ -128,6 +128,15 @@ When `send={false}`, the `clearComposer` prop controls whether the suggestion re
 - **`clearComposer={true}`** (default): replaces the current composer text
 - **`clearComposer={false}`**: appends the suggestion to the existing text
 
+### Static configuration vs. runtime suggestions
+
+There are two separate data flows for suggestions:
+
+- **Static configuration** flows through the `suggestions` scope. Pass an array to `Suggestions(...)` in your runtime provider; render it with `ThreadPrimitive.Suggestions`. Best for welcome screen prompts.
+- **Runtime / dynamic suggestions** flow through `thread.suggestions`. Populate it via `SuggestionAdapter` (local runtime) or the `suggestions` field on `useExternalStoreRuntime`; render it with the shadcn `ThreadFollowupSuggestions` component or your own component reading `useAuiState((s) => s.thread.suggestions)`. Best for follow up prompts after a turn.
+
+See [Suggested Prompts](/docs/guides/suggestions) for end to end examples.
+
 ### ThreadPrimitive.Suggestion (Legacy)
 
 `ThreadPrimitive.Suggestion` is a self-contained button that takes a `prompt` prop directly. The newer pattern (`ThreadPrimitive.Suggestions` + `SuggestionPrimitive` parts) is preferred for structured suggestions with title and description:

package/.docs/raw/docs/react-native/hooks.mdx

@@ -55,8 +55,8 @@ Subscribe to events without causing re-renders.
 ```tsx
 import { useAuiEvent } from "@assistant-ui/react-native";
 
-useAuiEvent("thread.runStart", (payload) => {
-  console.log("Run started:", payload);
+useAuiEvent("thread.modelContextUpdate", ({ threadId }) => {
+  console.log("Model context updated:", threadId);
 });
 ```
 
@@ -114,52 +114,46 @@ 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-native";
-
-useAssistantTool({
-  toolName: "get_weather",
-  description: "Get the current weather for a city",
-  parameters: {
-    type: "object",
-    properties: {
-      city: { type: "string" },
+```tsx title="weather-toolkit.tsx"
+import type { Toolkit } from "@assistant-ui/react-native";
+import { Text, View } from "react-native";
+
+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 }) => (
+      <View>
+        <Text>{args.city}: {result?.temperature}°F</Text>
+      </View>
+    ),
   },
-  render: ({ args, result }) => (
-    <View>
-      <Text>{args.city}: {result?.temperature}°F</Text>
-    </View>
-  ),
-});
+} satisfies Toolkit;
 ```
 
-### useAssistantToolUI
+```tsx title="ToolProvider.tsx"
+import { AuiProvider, Tools, useAui } from "@assistant-ui/react-native";
+import { toolkit } from "./weather-toolkit";
 
-Register only a UI renderer for a tool (without tool definition or execute function).
-
-```tsx
-import { useAssistantToolUI } from "@assistant-ui/react-native";
-
-useAssistantToolUI({
-  toolName: "get_weather",
-  render: ({ args, result, status }) => (
-    <View>
-      {status?.type === "running"
-        ? <Text>Loading weather for {args.city}...</Text>
-        : <Text>{args.city}: {result?.temperature}°F</Text>}
-    </View>
-  ),
-});
+function ToolProvider({ children }: { children: React.ReactNode }) {
+  const aui = useAui({ tools: Tools({ toolkit }) });
+  return <AuiProvider value={aui}>{children}</AuiProvider>;
+}
 ```
 
 ### useAssistantDataUI
@@ -193,49 +187,30 @@ useAssistantInstructions("You are a helpful weather assistant.");
 
 Wrap a tool UI component so that inline state updates (from a parent component's render) are reflected without remounting. Use this when the render function closes over props that change over time.
 
-```tsx
-import { useInlineRender } from "@assistant-ui/react-native";
-
-const stableRender = useInlineRender(({ args, result }) => (
-  <Text>{someOuterProp}: {result?.value}</Text>
-));
-
-useAssistantToolUI({ toolName: "my_tool", render: stableRender });
-```
-
-### makeAssistantTool
-
-Create a component that registers a tool when mounted. Useful for declarative tool registration.
-
-```tsx
-import { makeAssistantTool } from "@assistant-ui/react-native";
-
-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 />
+```tsx title="my-tool-toolkit.tsx"
+import { type Toolkit, useInlineRender } from "@assistant-ui/react-native";
+import { Text } from "react-native";
+import { useMemo } from "react";
+
+export function useMyToolToolkit(someOuterProp: string) {
+  const stableRender = useInlineRender(({ args, result }) => (
+    <Text>{someOuterProp}: {result?.value}</Text>
+  ));
+
+  return useMemo(
+    () =>
+      ({
+        my_tool: {
+          type: "backend",
+          render: stableRender,
+        },
+      }) satisfies Toolkit,
+    [stableRender],
+  );
+}
 ```
 
-### makeAssistantToolUI
-
-Create a component that registers only a tool UI renderer when mounted.
-
-```tsx
-import { makeAssistantToolUI } from "@assistant-ui/react-native";
-
-const WeatherToolUI = makeAssistantToolUI({
-  toolName: "get_weather",
-  render: ({ args, result }) => <Text>{args.city}: {result?.temperature}°F</Text>,
-});
-
-<WeatherToolUI />
-```
+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.
 
 ### makeAssistantDataUI
 

package/.docs/raw/docs/react-native/index.mdx

@@ -1,6 +1,6 @@
 ---
-title: Getting Started
-description: Build AI chat interfaces for iOS and Android with @assistant-ui/react-native.
+title: React Native AI Chat
+description: Build AI chat for iOS and Android with @assistant-ui/react-native — streaming, tools, attachments, and platform-native components from the same primitives as the web SDK.
 ---
 
 ## Quick Start
@@ -69,7 +69,7 @@ export const maxDuration = 30;
 export async function POST(req: Request) {
   const { messages } = await req.json();
   const result = streamText({
-    model: openai("gpt-4o-mini"),
+    model: openai("gpt-5.4-nano"),
     messages: await convertToModelMessages(messages),
   });
   return result.toUIMessageStreamResponse();
@@ -85,7 +85,7 @@ export const maxDuration = 30;
 export async function POST(req: Request) {
   const { messages } = await req.json();
   const result = streamText({
-    model: anthropic("claude-sonnet-4-20250514"),
+    model: anthropic("claude-sonnet-4-6"),
     messages: await convertToModelMessages(messages),
   });
   return result.toUIMessageStreamResponse();

package/.docs/raw/docs/react-native/migration.mdx

@@ -9,7 +9,7 @@ If you already have an assistant-ui web app, most of your code transfers directl
 
 - **Runtime setup** — `useChatRuntime`, `useLocalRuntime`, `ChatModelAdapter`, and all runtime options work identically.
 - **AI SDK integration** — `@assistant-ui/react-ai-sdk` works with React Native. Your `useChatRuntime` + `AssistantChatTransport` 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.
 

package/.docs/raw/docs/react-native/primitives.mdx

@@ -338,7 +338,7 @@ Container `View` for a single message.
 
 ### MessagePrimitive.Content
 
-Renders message content parts using render-prop functions instead of the component-map approach used by `MessagePrimitive.Parts`. Each part type receives a `part` object and its `index`. Registered tool UIs (via `useAssistantTool`) are automatically dispatched and take priority over `renderToolCall`.
+Renders message content parts using render-prop functions instead of the component-map approach used by `MessagePrimitive.Parts`. Each part type receives a `part` object and its `index`. Registered toolkit renderers are automatically dispatched and take priority over `renderToolCall`.
 
 ```tsx
 <MessagePrimitive.Content
@@ -364,7 +364,7 @@ Renders message content parts using render-prop functions instead of the compone
 
 ### MessagePrimitive.Parts
 
-Renders message content parts via a `components` prop. Tool call and data parts automatically render registered tool UIs (via `useAssistantTool` / `useAssistantDataUI`), falling back to components provided here. A default `Text` component using React Native's `<Text>` is provided out of the box.
+Renders message content parts via a `components` prop. Tool call and data parts automatically render registered toolkit renderers and data UIs (via `useAssistantDataUI`), falling back to components provided here. A default `Text` component using React Native's `<Text>` is provided out of the box.
 
 ```tsx
 <MessagePrimitive.Parts>