@assistant-ui/mcp-docs-server 0.1.23 → 0.1.25

package/.docs/raw/docs/runtimes/a2a/index.mdx

@@ -0,0 +1,294 @@
+---
+title: A2A Protocol
+description: Connect to A2A (Agent-to-Agent) v1.0 protocol servers.
+---
+
+`@assistant-ui/react-a2a` provides a runtime adapter for the [A2A (Agent-to-Agent) v1.0 protocol](https://github.com/a2aproject/A2A), enabling your assistant-ui frontend to communicate with any A2A-compliant agent server.
+
+## Requirements
+
+- An A2A v1.0 compatible agent server
+- React 18 or 19
+
+## Installation
+
+<InstallCommand npm={["@assistant-ui/react", "@assistant-ui/react-a2a"]} />
+
+## Getting Started
+
+<Steps>
+<Step>
+### Set up the Runtime Provider
+
+Create a runtime provider component that connects to your A2A server.
+
+```tsx title="app/MyRuntimeProvider.tsx"
+"use client";
+
+import { AssistantRuntimeProvider } from "@assistant-ui/react";
+import { useA2ARuntime } from "@assistant-ui/react-a2a";
+
+export function MyRuntimeProvider({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  const runtime = useA2ARuntime({
+    baseUrl: "http://localhost:9999",
+  });
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      {children}
+    </AssistantRuntimeProvider>
+  );
+}
+```
+
+</Step>
+<Step>
+### Add the Thread component
+
+```tsx title="app/page.tsx"
+import { Thread } from "@assistant-ui/react";
+import { MyRuntimeProvider } from "./MyRuntimeProvider";
+
+export default function Page() {
+  return (
+    <MyRuntimeProvider>
+      <Thread />
+    </MyRuntimeProvider>
+  );
+}
+```
+
+</Step>
+<Step>
+### Setup UI Components
+
+Follow the [UI Setup](/docs/ui) guide to setup the UI components.
+
+</Step>
+</Steps>
+
+## A2AClient
+
+The built-in `A2AClient` handles all communication with the A2A server, including JSON serialization, SSE streaming, ProtoJSON enum normalization, and structured error handling.
+
+```ts
+import { A2AClient } from "@assistant-ui/react-a2a";
+
+const client = new A2AClient({
+  baseUrl: "https://my-agent.example.com",
+  headers: { Authorization: "Bearer <token>" },
+  tenant: "my-org", // optional, for multi-tenant servers
+  extensions: ["urn:a2a:ext:my-extension"], // optional
+});
+```
+
+You can pass a pre-built client to `useA2ARuntime`:
+
+```tsx
+const runtime = useA2ARuntime({ client });
+```
+
+### Client Options
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `baseUrl` | `string` | Base URL of the A2A server |
+| `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 |
+
+### Client Methods
+
+| Method | Description |
+| --- | --- |
+| `sendMessage(message, configuration?, metadata?)` | Send a message (non-streaming) |
+| `streamMessage(message, configuration?, metadata?)` | Send a message with SSE streaming |
+| `getTask(taskId, historyLength?)` | Get a task by ID |
+| `listTasks(request?)` | List tasks with filtering and pagination |
+| `cancelTask(taskId, metadata?)` | Cancel an in-progress task |
+| `subscribeToTask(taskId)` | Subscribe to SSE updates for a task |
+| `getAgentCard()` | Fetch the agent card from `/.well-known/agent-card.json` |
+| `getExtendedAgentCard()` | Fetch the extended (authenticated) agent card |
+| `createTaskPushNotificationConfig(config)` | Create a push notification config |
+| `getTaskPushNotificationConfig(taskId, configId)` | Get a push notification config |
+| `listTaskPushNotificationConfigs(taskId)` | List push notification configs |
+| `deleteTaskPushNotificationConfig(taskId, configId)` | Delete a push notification config |
+
+## useA2ARuntime Options
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `client` | `A2AClient` | Pre-built A2A client instance (provide this OR `baseUrl`) |
+| `baseUrl` | `string` | A2A server URL (creates a client automatically) |
+| `headers` | see above | Headers for the auto-created client |
+| `contextId` | `string` | Initial context ID for the conversation |
+| `configuration` | `A2ASendMessageConfiguration` | Default send message configuration |
+| `onError` | `(error: Error) => void` | Error callback |
+| `onCancel` | `() => void` | Cancellation callback |
+| `adapters.attachments` | `AttachmentAdapter` | Custom attachment handling |
+| `adapters.speech` | `SpeechSynthesisAdapter` | Text-to-speech |
+| `adapters.feedback` | `FeedbackAdapter` | Feedback collection |
+| `adapters.history` | `ThreadHistoryAdapter` | Message persistence |
+| `adapters.threadList` | `UseA2AThreadListAdapter` | Thread switching |
+
+## Hooks
+
+### useA2ATask
+
+Returns the current A2A task object, including task state and status message.
+
+```tsx
+import { useA2ATask } from "@assistant-ui/react-a2a";
+
+function TaskStatus() {
+  const task = useA2ATask();
+
+  if (!task) return null;
+
+  return <div>Task {task.id}: {task.status.state}</div>;
+}
+```
+
+### useA2AArtifacts
+
+Returns the artifacts generated by the current task.
+
+```tsx
+import { useA2AArtifacts } from "@assistant-ui/react-a2a";
+
+function ArtifactList() {
+  const artifacts = useA2AArtifacts();
+
+  return (
+    <ul>
+      {artifacts.map((artifact) => (
+        <li key={artifact.artifactId}>
+          {artifact.name}: {artifact.parts.length} parts
+        </li>
+      ))}
+    </ul>
+  );
+}
+```
+
+### useA2AAgentCard
+
+Returns the agent card fetched from the server on initialization.
+
+```tsx
+import { useA2AAgentCard } from "@assistant-ui/react-a2a";
+
+function AgentInfo() {
+  const card = useA2AAgentCard();
+
+  if (!card) return null;
+
+  return (
+    <div>
+      <h3>{card.name}</h3>
+      <p>{card.description}</p>
+      <div>Skills: {card.skills.map((s) => s.name).join(", ")}</div>
+    </div>
+  );
+}
+```
+
+## Task States
+
+The A2A protocol defines 9 task states. The runtime maps them to assistant-ui message statuses:
+
+| A2A Task State | Description | Message Status |
+| --- | --- | --- |
+| `unspecified` | Unknown/default state | `running` |
+| `submitted` | Task acknowledged | `running` |
+| `working` | Task in progress | `running` |
+| `completed` | Task finished | `complete` |
+| `failed` | Task errored | `incomplete (error)` |
+| `canceled` | Task cancelled | `incomplete (cancelled)` |
+| `rejected` | Agent declined task | `incomplete (error)` |
+| `input_required` | Agent needs user input | `requires-action` |
+| `auth_required` | Authentication needed | `requires-action` |
+
+<Callout type="info">
+When a task enters `input_required`, the user can continue the conversation normally. The runtime will send the next message with the same `taskId` to resume the task.
+</Callout>
+
+## Artifacts
+
+A2A agents can produce artifacts (files, code, data) alongside their responses. Artifacts are accumulated during streaming and accessible via the `useA2AArtifacts` hook.
+
+The runtime supports:
+- **Incremental artifact streaming** via `append` mode
+- **Artifact completion notification** via `onArtifactComplete` callback
+- **Automatic reset** of artifacts on each new run
+
+```tsx
+const runtime = useA2ARuntime({
+  baseUrl: "http://localhost:9999",
+  onArtifactComplete: (artifact) => {
+    console.log("Artifact ready:", artifact.name);
+  },
+});
+```
+
+## Streaming vs Non-Streaming
+
+The runtime automatically selects the communication mode based on the agent's capabilities:
+
+- If the agent card indicates `capabilities.streaming: true` (or unset), the runtime uses `POST /message:stream` with SSE
+- If `capabilities.streaming: false`, the runtime falls back to `POST /message:send`
+
+## Error Handling
+
+The client throws `A2AError` instances with structured error information following the `google.rpc.Status` format:
+
+```tsx
+import { A2AError } from "@assistant-ui/react-a2a";
+
+const runtime = useA2ARuntime({
+  baseUrl: "http://localhost:9999",
+  onError: (error) => {
+    if (error instanceof A2AError) {
+      console.log(error.code);    // HTTP status code
+      console.log(error.status);  // e.g. "NOT_FOUND"
+      console.log(error.details); // google.rpc.ErrorInfo details
+    }
+  },
+});
+```
+
+## Multi-Tenancy
+
+For multi-tenant A2A servers, pass a `tenant` option to the client:
+
+```ts
+const client = new A2AClient({
+  baseUrl: "https://agent.example.com",
+  tenant: "my-org",
+});
+```
+
+This prepends `/{tenant}` to all API paths (e.g. `/my-org/message:send`).
+
+## Features
+
+| Feature | Supported |
+| --- | --- |
+| Streaming (SSE) | Yes |
+| Non-streaming fallback | Yes |
+| All 9 task states | Yes |
+| Artifacts (text, data, file) | Yes |
+| Agent card discovery | Yes |
+| Multi-tenancy | Yes |
+| Structured errors | Yes |
+| Push notifications CRUD | Yes |
+| Extension negotiation | Yes |
+| Task cancellation | Yes |
+| Message editing | Yes |
+| Message reload | Yes |
+| History persistence | Yes |
+| Thread list management | Yes |

package/.docs/raw/docs/runtimes/ai-sdk/v4-legacy.mdx

@@ -10,7 +10,7 @@ If you're using AI SDK v4 (legacy), you can integrate with assistant-ui using th
 
 <Callout type="warning">
   AI SDK v4 is now considered legacy. We recommend upgrading to [AI SDK
-  v5](/docs/runtimes/ai-sdk/use-chat) for improved features and better
+  v6](/docs/runtimes/ai-sdk/v6) for improved features and better
   TypeScript support. This documentation is provided for projects that haven't
   migrated yet.
 </Callout>
@@ -63,9 +63,9 @@ export async function POST(req: Request) {
 ```tsx
 "use client";
 
-import { Thread } from "@assistant-ui/react";
 import { AssistantRuntimeProvider } from "@assistant-ui/react";
 import { useDataStreamRuntime } from "@assistant-ui/react-data-stream";
+import { Thread } from "@/components/assistant-ui/thread";
 
 export default function Home() {
   const runtime = useDataStreamRuntime({
@@ -94,7 +94,7 @@ Alternatively, you can use the older version of the AI SDK integration package,
 <Callout type="warning">
   Version 0.1.10 of `@assistant-ui/react-ai-sdk` is no longer actively
   maintained. We recommend using the `@assistant-ui/react-data-stream` approach
-  or upgrading to AI SDK v5 for continued support.
+  or upgrading to AI SDK v6 for continued support.
 </Callout>
 
 With this legacy version, you would use the `useVercelUseChatRuntime` hook:
@@ -103,9 +103,9 @@ With this legacy version, you would use the `useVercelUseChatRuntime` hook:
 "use client";
 
 import { useChat } from "ai/react";
-import { Thread } from "@assistant-ui/react";
 import { AssistantRuntimeProvider } from "@assistant-ui/react";
 import { useVercelUseChatRuntime } from "@assistant-ui/react-ai-sdk";
+import { Thread } from "@/components/assistant-ui/thread";
 
 export default function Home() {
   const chat = useChat({
@@ -161,17 +161,17 @@ The `useDataStreamRuntime` hook accepts options similar to AI SDK v4's `useChat`
   already using AI SDK v4's `useChat` hook, making migration straightforward.
 </Callout>
 
-## Migration to AI SDK v5
+## Migration to AI SDK v6
 
-When you're ready to upgrade to AI SDK v5:
+When you're ready to upgrade to AI SDK v6:
 
 1. Replace `@assistant-ui/react-data-stream` with `@assistant-ui/react-ai-sdk`
-2. Update your backend to use AI SDK v5's `streamText` API
+2. Update your backend to use AI SDK v6's `streamText` API
 3. Switch from `useDataStreamRuntime` to `useChatRuntime`
 4. Take advantage of improved TypeScript support and automatic system/tool forwarding
 
-See our [AI SDK v5 documentation](/docs/runtimes/ai-sdk/use-chat) for the complete migration guide.
+See our [AI SDK v6 documentation](/docs/runtimes/ai-sdk/v6) for the complete migration guide.
 
 ## Example
 
-For a working example with AI SDK v4, you can adapt the patterns from our [AI SDK examples](https://github.com/assistant-ui/assistant-ui/tree/main/examples) using the `@assistant-ui/react-data-stream` package instead of the v5 integration.
+For a working example with AI SDK v4, you can adapt the patterns from our [AI SDK examples](https://github.com/assistant-ui/assistant-ui/tree/main/examples) using the `@assistant-ui/react-data-stream` package instead of the v6 integration.

package/.docs/raw/docs/runtimes/ai-sdk/v5-legacy.mdx

@@ -85,9 +85,7 @@ import { AssistantRuntimeProvider } from "@assistant-ui/react";
 import { useChatRuntime } from "@assistant-ui/react-ai-sdk";
 
 export default function Home() {
-  const runtime = useChatRuntime({
-    api: "/api/chat",
-  });
+  const runtime = useChatRuntime();
 
   return (
     <AssistantRuntimeProvider runtime={runtime}>
@@ -99,6 +97,18 @@ export default function Home() {
 }
 ```
 
+<Callout type="info">
+  `useChatRuntime` was introduced in `@assistant-ui/react-ai-sdk@0.11.3`. If you're using an older 0.x version, use `useVercelUseChatRuntime` with `useChat` from `ai/react` instead:
+
+  ```tsx
+  import { useChat } from "ai/react";
+  import { useVercelUseChatRuntime } from "@assistant-ui/react-ai-sdk";
+
+  const chat = useChat({ api: "/api/chat" });
+  const runtime = useVercelUseChatRuntime(chat);
+  ```
+</Callout>
+
   </Step>
 </Steps>
 
@@ -107,6 +117,7 @@ export default function Home() {
 | Feature | v5 | v6 |
 |---------|----|----|
 | **ai package** | `ai@^5` | `ai@^6` |
+| **@assistant-ui/react-ai-sdk** | `@0.x` | `@latest` |
 | **@ai-sdk/openai** | `@ai-sdk/openai@^1` | `@ai-sdk/openai@^3` |
 | **Message type** | `Message` | `UIMessage` |
 | **convertToModelMessages** | Sync | Async (`await`) |

package/.docs/raw/docs/runtimes/ai-sdk/v6.mdx

@@ -101,6 +101,59 @@ export default function Home() {
   </Step>
 </Steps>
 
+## Tracking Token Usage
+
+assistant-ui exports a `useThreadTokenUsage` hook to access thread-level token usage on the client.
+<Steps>
+  <Step>
+Use `messageMetadata` in your Next.js route to attach `usage` from `finish` and `modelId` from `finish-step`.
+```tsx
+import { streamText, convertToModelMessages } from "ai";
+import { frontendTools } from "@assistant-ui/react-ai-sdk";
+export async function POST(req: Request) {
+  const { messages, tools, modelName } = await req.json();
+  const result = streamText({
+    model: getModel(modelName),
+    messages: await convertToModelMessages(messages),
+    tools: frontendTools(tools),
+  });
+  return result.toUIMessageStreamResponse({
+    messageMetadata: ({ part }) => {
+      if (part.type === "finish") {
+        return {
+          usage: part.totalUsage,
+        };
+      }
+      if (part.type === "finish-step") {
+        return {
+          modelId: part.response.modelId,
+        };
+      }
+      return undefined;
+    },
+  });
+}
+```
+  </Step>
+  <Step>
+Use `useThreadTokenUsage` to render token usage on the client.
+
+```tsx
+"use client";
+
+import { useThreadTokenUsage } from "@assistant-ui/react-ai-sdk";
+
+export function TokenCounter() {
+  const usage = useThreadTokenUsage();
+
+  if (!usage) return null;
+
+  return <div>{usage.totalTokens} total tokens</div>;
+}
+```
+  </Step>
+</Steps>
+
 ## Key Changes from v5
 
 | Feature | v5 | v6 |

package/.docs/raw/docs/runtimes/assistant-transport.mdx

@@ -69,8 +69,11 @@ The backend endpoint receives POST requests with the following payload:
   state: T, // The previous state that the frontend has access to
   commands: AssistantTransportCommand[],
   system?: string,
-  tools?: ToolDefinition[],
-  threadId: string // The current thread/conversation identifier
+  tools?: Record<string, ToolJSONSchema>, // Tool definitions keyed by tool name
+  threadId: string | null, // The current thread/conversation identifier (null for new threads)
+  parentId?: string | null, // The parent message ID (included when editing or branching)
+  // ...callSettings (maxTokens, temperature, topP, presencePenalty, frequencyPenalty, seed)
+  // ...config (apiKey, baseUrl, modelName)
 }
 ```
 
@@ -333,15 +336,17 @@ The `useAssistantTransportRuntime` hook is used to configure the runtime. It acc
   initialState: T,
   api: string,
   resumeApi?: string,
+  protocol?: "data-stream" | "assistant-transport",
   converter: (state: T, connectionMetadata: ConnectionMetadata) => AssistantTransportState,
-  headers?: Record<string, string> | (() => Promise<Record<string, string>>),
-  body?: object,
+  headers: Record<string, string> | Headers | (() => Promise<Record<string, string> | Headers>),
+  body?: object | (() => Promise<object | undefined>),
   prepareSendCommandsRequest?: (body: SendCommandsRequestBody) => Record<string, unknown> | Promise<Record<string, unknown>>,
   capabilities?: { edit?: boolean },
+  adapters?: { attachments?: AttachmentAdapter; history?: ThreadHistoryAdapter },
   onResponse?: (response: Response) => void,
   onFinish?: () => void,
-  onError?: (error: Error) => void,
-  onCancel?: () => void
+  onError?: (error: Error, params: { commands: AssistantTransportCommand[]; updateState: (updater: (state: T) => T) => void }) => void | Promise<void>,
+  onCancel?: (params: { commands: AssistantTransportCommand[]; updateState: (updater: (state: T) => T) => void; error?: Error }) => void
 }
 ```
 
@@ -354,11 +359,13 @@ The state converter is the core of your frontend integration. It transforms your
   state: T, // Your agent's state
   connectionMetadata: {
     pendingCommands: Command[], // Commands not yet sent to backend
-    isSending: boolean // Whether a request is in flight
+    isSending: boolean, // Whether a request is in flight
+    toolStatuses: Record<string, ToolExecutionStatus> // Tool execution status tracking
   }
 ) => {
   messages: ThreadMessage[], // Messages to display
-  isRunning: boolean // Whether the agent is running
+  isRunning: boolean, // Whether the agent is running
+  state?: ReadonlyJSONValue // Optional custom agent state
 }
 ```
 
@@ -465,7 +472,7 @@ const runtime = useAssistantTransportRuntime({
   },
   onCancel: ({ commands, updateState }) => {
     console.log("Request cancelled");
-    console.log("Commands in transit or queued:", commands);
+    console.log("Commands (in-transit + queued, or queued-only if called after error):", commands);
 
     // Update state to reflect cancellation
     updateState((currentState) => ({
@@ -476,7 +483,7 @@ const runtime = useAssistantTransportRuntime({
 });
 ```
 
-> **Note:** `onError` receives commands that were in transit, while `onCancel` receives both in-transit and queued commands.
+> **Note:** `onError` receives commands that were in transit. `onCancel` receives both in-transit and queued commands when the user cancels directly; when called after an error, it only receives queued commands (in-transit commands are passed to `onError` instead).
 
 ## Custom Headers and Body
 
@@ -600,28 +607,55 @@ for command in request.commands:
   contact us for more information.
 </Callout>
 
-To enable resumability, you need to:
+When a user refreshes the page, switches tabs, or reconnects after a network interruption, the backend may still be generating a response. `resumeRun` allows the frontend to reconnect to the active backend stream.
 
-1. Pass a `resumeApi` URL to `useAssistantTransportRuntime` that points to your sync server
-2. Use the `unstable_resumeRun` API to resume a conversation
+### Setup
 
-```typescript
-import { useAui } from "@assistant-ui/react";
+Pass a `resumeApi` URL to `useAssistantTransportRuntime` that points to your sync server:
 
+```typescript
 const runtime = useAssistantTransportRuntime({
   // ... other options
   api: "http://localhost:8010/assistant",
   resumeApi: "http://localhost:8010/resume", // Sync server endpoint
-  // ... other options
 });
+```
 
-// Typically called on thread switch or mount to check if sync server has anything to resume
-const aui = useAui();
-aui.thread().unstable_resumeRun({
-  parentId: null, // Ignored (will be removed in a future version)
-});
+### Resuming on thread switch or page load
+
+When switching to a thread or mounting a component, check if the backend is still running and call `resumeRun`:
+
+```typescript
+import { useAui } from "@assistant-ui/react";
+import { useEffect, useRef } from "react";
+
+function useResumeOnMount(threadId: string) {
+  const aui = useAui();
+  const hasCheckedRef = useRef(false);
+
+  useEffect(() => {
+    if (hasCheckedRef.current) return;
+    hasCheckedRef.current = true;
+
+    const checkAndResume = async () => {
+      const status = await fetch(
+        `/api/sync-server/status/${threadId}`,
+      ).then((r) => r.json());
+
+      if (status.isRunning) {
+        const parentId =
+          aui.thread().getState().messages.at(-1)?.id ?? null;
+        aui.thread().resumeRun({ parentId });
+      }
+    };
+
+    checkAndResume();
+  }, [aui, threadId]);
+}
 ```
 
+For the AssistantTransport runtime, you do not need to pass a `stream` parameter — the runtime uses the configured `resumeApi` endpoint to reconnect.
+
 ## Accessing Runtime State
 
 Use the `useAssistantTransportState` hook to access the current agent state from any component:
@@ -684,12 +718,12 @@ If you're using `createMessageConverter`, you can access the original message fo
 
 ```typescript
 import { unstable_createMessageConverter as createMessageConverter } from "@assistant-ui/react";
-import { useMessage } from "@assistant-ui/react";
+import { useAuiState } from "@assistant-ui/react";
 
 const messageConverter = createMessageConverter(yourMessageConverter);
 
 function MyMessageComponent() {
-  const message = useMessage();
+  const message = useAuiState((s) => s.message);
 
   // Get the original message(s) from the converted ThreadMessage
   const originalMessage = messageConverter.toOriginalMessage(message);
@@ -764,7 +798,7 @@ export function MyRuntimeProvider({ children }) {
     },
     onCancel: ({ commands, updateState }) => {
       console.log("Request cancelled");
-      console.log("Commands in transit or queued:", commands);
+      console.log("Commands (in-transit + queued, or queued-only if called after error):", commands);
     },
   });
 
@@ -861,7 +895,7 @@ export function MyRuntimeProvider({ children }) {
     },
     onCancel: ({ commands, updateState }) => {
       console.log("Request cancelled");
-      console.log("Commands in transit or queued:", commands);
+      console.log("Commands (in-transit + queued, or queued-only if called after error):", commands);
     },
   });
 

package/.docs/raw/docs/runtimes/custom/custom-thread-list.mdx

@@ -6,7 +6,7 @@ description: Plug a custom thread database for multi-thread persistence.
 
 ## Overview
 
-`useRemoteThreadListRuntime` lets you plug a custom thread database into assistant-ui. It keeps the UI and local runtime logic in sync while you provide persistence, archiving, and metadata for every conversation. The hook is exported as `unstable_useRemoteThreadListRuntime`; we refer to it here as **Custom Thread List**.
+`useRemoteThreadListRuntime` lets you plug a custom thread database into assistant-ui. It keeps the UI and local runtime logic in sync while you provide persistence, archiving, and metadata for every conversation.
 
 ## When to Use
 
@@ -63,8 +63,8 @@ When the hook mounts it calls `list()` on your adapter, hydrates existing thread
     import {
       AssistantRuntimeProvider,
       useLocalRuntime,
-      unstable_useRemoteThreadListRuntime as useRemoteThreadListRuntime,
-      type unstable_RemoteThreadListAdapter as RemoteThreadListAdapter,
+      useRemoteThreadListRuntime,
+      type RemoteThreadListAdapter,
     } from "@assistant-ui/react";
     import { createAssistantStream } from "assistant-stream";
     import { myModelAdapter } from "./model-adapter"; // your chat model adapter
@@ -116,12 +116,12 @@ When the hook mounts it calls `list()` on your adapter, hydrates existing thread
           title: thread.title,
         };
       },
-      async generateTitle(remoteId, messages) {
+      async generateTitle(remoteId, unstable_messages) {
         return createAssistantStream(async (controller) => {
           const response = await fetch(`/api/threads/${remoteId}/title`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ messages }),
+            body: JSON.stringify({ messages: unstable_messages }),
           });
           const { title } = await response.json();
           controller.appendText(title);
@@ -198,6 +198,13 @@ When the hook mounts it calls `list()` on your adapter, hydrates existing thread
         "Return a streaming title generator. You can reuse your model endpoint or queue a background job.",
       required: true,
     },
+    {
+      name: "fetch",
+      type: "(threadId: string) => Promise<RemoteThreadMetadata>",
+      description:
+        "Fetch metadata for a specific thread. Used when switching to a thread not in the initial list.",
+      required: true,
+    },
     {
       name: "unstable_Provider",
       type: "ComponentType<PropsWithChildren>",
@@ -224,7 +231,7 @@ When implementing a custom history adapter, you must await thread initialization
 If you're building a history adapter that persists messages to your own database, use `aui.threadListItem().initialize()` to ensure the thread is fully initialized before saving:
 
 ```tsx
-import { useAui } from "@assistant-ui/react";
+import { useAui } from "@assistant-ui/store";
 
 // Inside your unstable_Provider component
 const aui = useAui();