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

package/.docs/raw/docs/ink/primitives.mdx

@@ -475,7 +475,7 @@ Container `Box` for a single message.
 
 ### 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. Default terminal-safe renderers are provided for text, reasoning, source, image, file, and data parts.
+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. Default terminal-safe renderers are provided for text, reasoning, source, image, file, and data parts.
 
 ```tsx
 <MessagePrimitive.Parts>
@@ -509,7 +509,7 @@ Override part rendering with app-owned components when you need richer terminal
   Deprecated. Use `MessagePrimitive.Parts` instead. See the [v0.11 migration guide](/docs/migrations/v0-11) for details.
 </Callout>
 
-Renders message content parts using render props. Tool call and data parts automatically render registered tool UIs (via `useAssistantTool` / `useAssistantDataUI`), falling back to render props if provided.
+Renders message content parts using render props. Tool call and data parts automatically render registered toolkit renderers and data UIs (via `useAssistantDataUI`), falling back to render props if provided.
 
 ```tsx
 <MessagePrimitive.Content

package/.docs/raw/docs/integrations/frameworks/ai-sdk.mdx

@@ -52,7 +52,7 @@ Three versions of `ai` are supported. New projects should pick **v6**; v5 and v4
 AI SDK is the default choice for new projects on Next.js, Remix, or any framework with a Node-compatible API route. Pick it when:
 
 - You want a single direct path from the chat UI to your model with the smallest possible code surface.
-- You will compose with a framework like [Mastra](/docs/integrations/frameworks/mastra/overview), an [observability tool](/docs/integrations/observability/helicone), an [LLM gateway](/docs/integrations/gateways), or [tools through MCP](/docs/integrations/tools/mcp), all of which assume an AI SDK route.
+- You will compose with a framework like [Mastra](/docs/integrations/frameworks/mastra/overview), an [observability tool](/docs/integrations/observability/helicone), an [LLM gateway](/docs/integrations/gateways), or [tools through MCP](/docs/tools/mcp), all of which assume an AI SDK route.
 - You want first-party `frontendTools`, attachments, multi-step tool calls, token-usage metadata, and persisted history via `withFormat`.
 
 If you need streaming agent state (subgraph events, generative UI messages), look at [LangGraph](/docs/runtimes/langgraph) instead. If you have a different protocol-shaped backend (A2A, AG-UI, OpenCode), see [pick a runtime](/docs/runtimes/pick-a-runtime).

package/.docs/raw/docs/integrations/index.mdx

@@ -60,14 +60,14 @@ Framework integrations that pair with assistant-ui at the API-route layer.
 
 ## Tools
 
-Pluggable tool catalogs and protocols.
+Tool catalogs and protocols have their own [Tools](/docs/tools) section.
 
 <Cards>
   <Card
     icon={<McpIcon width={20} height={20} />}
     title="Model Context Protocol (MCP)"
     description="Connect any MCP server as a tool catalog through the AI SDK MCP client."
-    href="/docs/integrations/tools/mcp"
+    href="/docs/tools/mcp"
   />
 </Cards>
 

package/.docs/raw/docs/integrations/persistence/custom-adapter.mdx

@@ -65,7 +65,22 @@ export const messages = pgTable(
 );
 ```
 
-The four message columns (`id`, `parent_id`, `format`, `content`) are the contract `withFormat` writes against. `format` lets multiple runtimes coexist on one row (e.g., `"aisdk-v6"` from `useChatRuntime`, a different value from another runtime).
+The four message columns (`id`, `parent_id`, `format`, `content`) are the contract `withFormat` writes against. `format` records which adapter encoded the row so multiple runtimes can coexist on one table; `useChatRuntime` sets it from `fmt.format`.
+
+<Callout type="warn">
+  `content` is not arbitrary JSON. It must be the payload the active format adapter produced via `fmt.encode(item)`, and it is read back through `fmt.decode`; the route handlers below are a pass-through that never inspects it. For `useChatRuntime` (AI SDK v6) a valid stored row looks like:
+
+  ```json
+  {
+    "id": "msg_abc",
+    "parent_id": null,
+    "format": "ai-sdk/v6",
+    "content": { "role": "user", "parts": [{ "type": "text", "text": "hello" }] }
+  }
+  ```
+
+  A row that satisfies the column types but carries a different shape (e.g. `{ "foo": "bar" }`) is accepted on write, then fails history reload. Seed test data through the adapter, not by hand-crafting `content`.
+</Callout>
 
 ## Setup
 
@@ -678,7 +693,7 @@ Send a message in a fresh thread. Check the database:
 
 - The `threads` table has a new row with the current `userId`.
 - The `messages` table has at least two rows (user + assistant) for that thread.
-- `format` is `"aisdk-v6"` (or whatever AI SDK's current format string is).
+- `format` matches what `fmt.format` wrote (`"ai-sdk/v6"` for AI SDK v6) and `content` is the encoded `UIMessage` (a `role` plus `parts`), not a placeholder blob.
 - Reload the page; the thread list and the messages survive.
 
 </Step>

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/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/react-native/hooks.mdx

@@ -114,52 +114,46 @@ const runtime = useRemoteThreadListRuntime({
 
 ## Model Context Hooks
 
-### useAssistantTool
-
-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.
-
-```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" },
+### Tools
+
+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 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/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>

package/.docs/raw/docs/runtimes/a2a/client-and-hooks.mdx

@@ -19,6 +19,7 @@ const client = new A2AClient({
   headers: { Authorization: "Bearer <token>" },
   tenant: "my-org",
   extensions: ["urn:a2a:ext:my-extension"],
+  fetchOptions: { credentials: "include" },
 });
 ```
 
@@ -37,6 +38,7 @@ const runtime = useA2ARuntime({ client });
 | `headers` | `Record<string, string>` or `() => Record<string, string>` | Static or dynamic headers (e.g. for auth tokens). |
 | `tenant` | `string` | Tenant ID for multi-tenant servers (prepended to URL paths). |
 | `extensions` | `string[]` | Extension URIs to negotiate via `A2A-Extensions` header. |
+| `fetchOptions` | `RequestInit` (partial) | Extra fetch options applied to every request (e.g. `{ credentials: "include" }`). `headers`, `body`, `method`, and `signal` are managed internally. |
 
 ### Client methods
 
@@ -67,6 +69,7 @@ Pass either a pre-built `client` or a `baseUrl` (the runtime creates a client fo
 | `tenant` | `string` | Tenant ID for multi-tenant servers. Only used with `baseUrl`. |
 | `headers` | `Record<string, string>` or `() => Record<string, string>` | Headers for the auto-created client. |
 | `extensions` | `string[]` | Extension URIs to negotiate. Only used with `baseUrl`. |
+| `fetchOptions` | `RequestInit` (partial) | Extra fetch options for the auto-created client (e.g. `{ credentials: "include" }`). `headers`, `body`, `method`, and `signal` are managed internally. Only used with `baseUrl`. |
 | `contextId` | `string` | Initial context ID for the conversation. |
 | `configuration` | `A2ASendMessageConfiguration` | Default send message configuration. |
 | `onError` | `(error: Error) => void` | Error callback. |