@assistant-ui/mcp-docs-server 0.2.3 → 0.3.0

package/.docs/raw/docs/runtimes/ag-ui/runtime-options.mdx

@@ -1,267 +0,0 @@
----
-title: Runtime options
-description: useAgUiRuntime options, adapters, message conversion, thread list.
----
-
-import { AguiIcon } from "@/components/icons/agui";
-
-Reference for the runtime's API surface. Start with [quickstart](/docs/runtimes/ag-ui/quickstart) if you have not already.
-
-## useAgUiRuntime options
-
-| Option | Type | Description |
-| --- | --- | --- |
-| `agent` | `HttpAgent` | An AG-UI client agent (from `@ag-ui/client`). Required. |
-| `logger` | `Partial<Logger>` | Optional logger overrides. The runtime logs event-parser warnings and run lifecycle events. |
-| `showThinking` | `boolean` | Whether to render `THINKING_*` and `REASONING_*` events as visible reasoning. Defaults to `true`. |
-| `autoCancelPendingToolCalls` | `boolean` | Cancel unresolved client-side tool calls automatically when the user sends, edits, or reloads a message. Defaults to `true`. See [below](#auto-cancelling-pending-tool-calls). |
-| `onError` | `(e: Error) => void` | Error callback fired on `RUN_ERROR` events and protocol errors. |
-| `onCancel` | `() => void` | Cancellation callback fired when a run is cancelled, including user cancel and runtime teardown. |
-| `adapters` | `UseAgUiRuntimeAdapters` | Standard adapter slots (see below). |
-
-## Adapter slots
-
-| Adapter | Slot | Notes |
-| --- | --- | --- |
-| Attachments | `adapters.attachments` | See [attachment adapter](/docs/runtimes/concepts/adapters#attachment-adapter). |
-| Speech | `adapters.speech` | Text-to-speech. See [speech adapter](/docs/runtimes/concepts/adapters#speech-adapter). |
-| Dictation | `adapters.dictation` | Speech-to-text input. |
-| Feedback | `adapters.feedback` | Thumbs up / down. See [feedback adapter](/docs/runtimes/concepts/adapters#feedback-adapter). |
-| History | `adapters.history` | Per-thread message persistence. |
-| Thread list | `adapters.threadList` | Multi-thread switching (experimental, see below). |
-
-## Loading conversation history
-
-If your backend exposes the persisted AG-UI messages of a conversation (for
-example a `GET /agents/state` endpoint), use `fromAgUiMessages` to convert them
-to assistant-ui messages and return them from the history adapter so the thread
-is restored on page load:
-
-```tsx
-import { fromAgUiMessages } from "@assistant-ui/react-ag-ui";
-import { ExportedMessageRepository } from "@assistant-ui/react";
-
-const runtime = useAgUiRuntime({
-  agent,
-  adapters: {
-    history: {
-      async load() {
-        const { messages } = await fetch("/agents/state").then((r) => r.json());
-        return ExportedMessageRepository.fromArray(fromAgUiMessages(messages));
-      },
-      async append({ message }) {
-        // persist the newly sent message on your backend
-      },
-    },
-  },
-});
-```
-
-Messages sent during the session are always forwarded to the agent through the
-run input, independent of `append`. A no-op `append` is therefore only safe when
-your backend already persists the conversation on its own; otherwise those
-messages are gone on the next page load.
-
-`fromAgUiMessages` accepts an optional second argument: pass
-`{ showThinking: false }` to match a runtime configured with
-`showThinking: false`, so the readable text of an imported reasoning message is
-dropped at conversion time, the same way a live run never stores it. An
-`encryptedValue` on that message is kept, because it is opaque state the agent
-needs back rather than something the option hides.
-
-Reasoning makes the round trip in the shape it arrived in. `fromAgUiMessages` imports a `reasoning` record as an assistant message holding a reasoning part, and the run input converts that part back into a standalone `reasoning` record instead of dropping it, so a reloaded thread keeps its reasoning history on the next run. A reasoning part on an assistant message that also has text or tool calls leaves as its own `reasoning` record placed ahead of that assistant record; the AG-UI message body carries no run identity, so the original position of reasoning within a run is not recoverable.
-
-The encrypted value survives with it. AG-UI describes it as an opaque chain-of-thought blob the client stores and forwards for state continuity, not as a signature computed over the text. An imported `ReasoningMessage` carrying `encryptedValue` keeps it at `providerMetadata.agui.encryptedValue` on the part, and a live run picks the same value up from the `REASONING_ENCRYPTED_VALUE` event (`subtype: "message"`, keyed by `entityId`), so reasoning from either source is re-emitted with the value intact and an agent that needs it back can replay it. A record whose readable `content` is empty and whose payload lives entirely in `encryptedValue`, the zero-data-retention shape AG-UI describes when an agent advertises `capabilities.reasoning.encrypted`, is preserved on the import path only. It has nothing to render by construction, so it never becomes a message or a part; it rides on `metadata.custom.agui.opaqueReasoning` of the message it sat next to on the wire and is replayed into the run input adjacent to that message. `showThinking` does not discard it. That option hides reasoning from the UI, and the encrypted value is opaque state the agent needs back rather than something rendered, so a hidden record keeps it and loses only the readable text. This is an import-path guarantee: a live run with `showThinking: false` opens no reasoning block, so a `REASONING_ENCRYPTED_VALUE` arriving during it resolves no slot and is not retained. The same thread therefore carries the value after a reload but not within the live session that produced it. A consumer calling `fromAgUiMessages` directly sees the metadata rather than a part.
-
-Three limits apply to that record. A live stream that emits no readable content produces no reasoning part, so the runtime has nothing to attach the value to; only `fromAgUiMessages` preserves it, whether you call it yourself or the runtime calls it for you while importing a `MESSAGES_SNAPSHOT`. A record that sat between an assistant message and its own tool result is replayed after that tool result rather than between the two, because the import folds the result into the assistant message and the boundary is gone by export. A record in a snapshot that contains no other message has nothing to anchor to and is dropped.
-
-Sending reasoning back is what the protocol asks for, and the inbound side has to handle it. `ag-ui-langgraph` is worth pinning for that reason: below 0.0.36 it raises `ValueError: Unsupported message role: reasoning` on the second turn of any thread that produced reasoning, because its converter recognised only the user, assistant, system, and tool roles. 0.0.36 skips inbound `reasoning` and `developer` records instead of raising, so the turn succeeds but the reasoning is discarded. 0.0.42 re-attaches an inbound `reasoning` record as a content block on the assistant message that follows it, encrypted content included, so the replay actually reaches the model; a record that no assistant message follows is still discarded there, which is what becomes of one replayed after the last message of a thread. Keep it at 0.0.36 or newer to avoid the error, and at 0.0.42 or newer for the replay to be worth anything.
-
-What a server does with a replayed record remains its own choice, so treat continuity as best effort rather than guaranteed. `ag-ui-langgraph` covers all three behaviours across those three versions, and another integration may pick any of them; an `encryptedValue` reaches the provider only where the server forwards it.
-
-`fromAgUiMessages` reconstructs the text, reasoning, and tool calls of each message. Multimodal user input (`image`, `audio`, `video`, and `document` parts, as well as legacy `binary` parts) is restored as attachments on the user message, so a backend that persists multimodal messages shows them again on reload and re-sends them on the next run. Legacy `binary` parts that only reference a file id are not restored.
-
-An assistant message whose tool call has no matching tool result is reconstructed with `requires-action` status, the same status the runtime derives for a pending tool call, so a reloaded human-in-the-loop call (for example an `ask_user` tool) is actionable rather than stuck. This matches how every other external-store runtime surfaces a pending tool call on reload. The AG-UI wire snapshot carries no run outcome, so a tool call that a successful run intentionally left without a result is also surfaced as actionable.
-
-Interrupts are restored when your backend persists them on the assistant message. The AG-UI message body has no interrupt field, so persist the runtime's own `metadata.custom.agui.interrupts` array alongside the message; `fromAgUiMessages` reads it back, reconstructs `requires-action` / `interrupt` status, and re-attaches the metadata, so `getPendingInterrupts`, `useAgUiInterrupts`, and `submitInterruptResponses` work on reload. When both a pending tool call and an interrupt are present on the same message, interrupt status wins. Without the persisted array, interrupt state cannot be reconstructed.
-
-## Building AG-UI run input
-
-`toAgUiMessages` is the converter the runtime uses to build `runAgent` input. Use it when you own the transport, for example an AG-UI WebSocket, and need the same conversion from `onNew`'s `AppendMessage`:
-
-```tsx
-import { toAgUiMessages } from "@assistant-ui/react-ag-ui";
-
-const [agUiMessage] = toAgUiMessages([message]);
-```
-
-`AppendMessage` has no `id`. The converter assigns one so the AG-UI message schema is satisfied. A caller-supplied id is kept. A generated id is new on every call, so convert once and send that object. Only `user`, `assistant`, `system`, `developer`, `tool`, and `reasoning` inputs are converted.
-
-## Thread list (experimental)
-
-<Callout type="warn">
-The thread list adapter is currently experimental and may change without notice.
-</Callout>
-
-`UseAgUiThreadListAdapter` lets you back the thread list with your own state.
-
-| Option | Type | Description |
-| --- | --- | --- |
-| `threadId` | `string` | The currently active thread ID. |
-| `onSwitchToNewThread` | `() => Promise<void>` | Called when the user creates a new thread. Reset your thread state here. |
-| `onSwitchToThread` | `(threadId: string) => Promise<{ messages, state? }>` | Called when the user switches threads. Return the persisted messages (and optional opaque state). |
-
-```tsx
-const runtime = useAgUiRuntime({
-  agent,
-  adapters: {
-    threadList: {
-      threadId: currentThreadId,
-      onSwitchToNewThread: async () => {
-        setCurrentThreadId(await createThread());
-      },
-      onSwitchToThread: async (id) => {
-        const { messages, state } = await loadThread(id);
-        setCurrentThreadId(id);
-        return { messages, state };
-      },
-    },
-  },
-});
-```
-
-## Interrupts (experimental)
-
-<Callout type="warn">
-The interrupt API is experimental and may change without notice.
-</Callout>
-
-When the agent emits `RUN_FINISHED` with `outcome = { type: "interrupt", interrupts: [...] }`, the active assistant message is marked `requires-action` with `reason: "interrupt"` and the `Interrupt[]` payload is written to `metadata.custom.agui.interrupts`. Render an approval / input UI from there.
-
-`useAgUiRuntime` returns an `AgUiAssistantRuntime` with two extra methods:
-
-| Method | Description |
-| --- | --- |
-| `unstable_getPendingInterrupts(): readonly AgUiInterrupt[]` | Snapshot of the open interrupts on the most recent assistant message. |
-| `unstable_submitInterruptResponses(responses: ResumeEntry[]): Promise<void>` | Submits one `ResumeEntry` per open interrupt and resumes the run. |
-
-`responses` must address every open interrupt; missing entries, unknown ids, or expired interrupts (`expiresAt`) reject before any network call. Each entry is `{ interruptId, status: "resolved" | "cancelled", payload? }`. The next `RunAgentInput` carries `resume: ResumeEntry[]`.
-
-```tsx
-const runtime = useAgUiRuntime({ agent });
-const pending = runtime.unstable_getPendingInterrupts();
-
-await runtime.unstable_submitInterruptResponses(
-  pending.map((i) => ({
-    interruptId: i.id,
-    status: "resolved",
-    payload: { approved: true },
-  })),
-);
-```
-
-### Steering away from an interrupt
-
-When the user ignores the interrupt UI and just sends a new message, use the `useAgUiSteerAway` hook. Every open interrupt defaults to `status: "cancelled"`, the new message is appended, and the run resumes with `resume: ResumeEntry[]` on the wire.
-
-The same hook also steers away from pending client-side tool calls. When the head assistant message is in `requires-action` with `reason: "tool-calls"` (frontend tools awaiting a result) and the user sends a new message, every unresolved tool call is cancelled with an error result, the message is completed, and a single fresh run starts with those cancellations in its history. Passing `responses` in this case throws, since responses only address interrupts. With nothing pending, `steerAway` behaves like a normal append.
-
-```tsx
-const steerAway = useAgUiSteerAway();
-
-// the user typed a new message instead of answering the interrupt
-await steerAway("actually, let's do something else");
-```
-
-The message accepts a plain string or a partial `AppendMessage` (the parent defaults to the current head, which is the interrupted assistant message). Pass `responses` to override the status of specific interrupts; the rest still default to cancelled.
-
-```tsx
-await steerAway("continue without the file", [
-  { interruptId: "tool-1", status: "resolved", payload: { approved: true } },
-]);
-```
-
-### Auto-cancelling pending tool calls
-
-By default the runtime does the tool-call half of this automatically: when client-side tool calls are still unresolved and the user sends a new message, edits an earlier one, or reloads, every unresolved tool call receives the same cancellation error result, the assistant message is completed, and the run proceeds with those cancellations in its history. Set `autoCancelPendingToolCalls: false` to opt out, in which case pending tool calls stay unresolved on a plain send and [steering away](#steering-away-from-an-interrupt) remains the explicit way to cancel them.
-
-Pending interrupts are never auto-cancelled: sending while an interrupt is open still throws, and the interrupt must be answered with `useAgUiSubmitInterruptResponses` or discarded with `useAgUiSteerAway`.
-
-## Supported events
-
-The runtime parses the AG-UI event stream and maps each event type to assistant-ui state.
-
-| Event | Effect |
-| --- | --- |
-| `RUN_STARTED` / `RUN_FINISHED` | Toggles thread `isRunning`. `RUN_FINISHED.outcome` is honored (success / interrupt). |
-| `RUN_CANCELLED` | Marks the in-flight assistant message as cancelled. |
-| `RUN_ERROR` | Marks the message as errored; fires `onError`. |
-| `TEXT_MESSAGE_START` / `_CONTENT` / `_END` | Streams text content into an assistant message. |
-| `TEXT_MESSAGE_CHUNK` | Appends a delta without explicit lifecycle. |
-| `THINKING_START` / `_END` | Wraps reasoning blocks (when `showThinking` is on). |
-| `THINKING_TEXT_MESSAGE_*` | Streams thinking text deltas. |
-| `REASONING_START` / `_MESSAGE_*` / `_END` | Streams structured reasoning per message. |
-| `TOOL_CALL_START` / `_ARGS` / `_END` | Streams tool calls into the current assistant message. |
-| `TOOL_CALL_CHUNK` | Streams tool deltas without explicit lifecycle. |
-| `TOOL_CALL_RESULT` | Attaches a tool result to a tool call. |
-| `STATE_SNAPSHOT` | Replaces the agent's external state. |
-| `STATE_DELTA` | Applies a JSON-patch-style delta to the agent's state. |
-| `MESSAGES_SNAPSHOT` | Replaces the full message list (used for thread restore). |
-| `CUSTOM` | Appended to the in-flight assistant message as a `data` part. |
-| `RAW` | Parsed and ignored; unrecognized wire event types are normalized into `RAW`. |
-
-### Custom events
-
-`CUSTOM` events are the protocol's extension mechanism for application-defined data. Each event is appended to the in-flight assistant message as a canonical `data` part in arrival order: `CUSTOM { name: "sources", value: {...} }` becomes `{ type: "data", name: "sources", data: {...} }`. Repeated names append separate parts, the `value` is passed through verbatim, and data parts reset with each run. Tool calls that carry a `parentMessageId` are anchored under that message rather than at their wire position, so a data part can render after a tool call that arrived later. A run that delivers its assistant message only through `MESSAGES_SNAPSHOT`, with no streamed text or tool calls, drops that run's data parts when the snapshot supersedes the in-flight message.
-
-Render them by registering a per-name renderer; parts without a registered renderer are not displayed, unless a `Data` fallback component is registered, in which case the fallback receives every custom event name, including the framework plumbing listed below.
-
-```tsx
-import { useAssistantDataUI } from "@assistant-ui/react";
-
-useAssistantDataUI({
-  name: "sources",
-  render: ({ data }) => <SourceList sources={data.sources} />,
-});
-```
-
-Data parts stay in the assistant-ui message but are not sent back to the agent, since the AG-UI assistant record has no field for them. History adapters, including the assistant-cloud one, persist them as part of the message JSON. Framework integrations emit their own plumbing over this channel (`on_interrupt`, `PredictState`, `Exit`, `hook_error`, `state_update_error`, `system:*`, `MultiAgentHandoff`), and those names surface as data parts like any other, so only register renderers for names your backend owns.
-
-## Feature support
-
-| Feature | Supported |
-| --- | --- |
-| Streaming text | Yes |
-| Thinking / reasoning blocks | Yes |
-| Tool calls and results | Yes |
-| Tool result handoff (client-side execution) | Yes |
-| State snapshots and deltas | Yes |
-| Custom events (as `data` parts) | Yes |
-| Cancellation | Yes |
-| Message editing | Yes |
-| Message reload | Yes |
-| Run resumption | Yes |
-| Interrupts (human-in-the-loop) | Experimental (`unstable_*` API, see [Interrupts](#interrupts-experimental)) |
-| Multi-thread | Experimental (`adapters.threadList`) |
-| History persistence | Via [history adapter](/docs/runtimes/concepts/adapters#history-adapter) |
-
-## Related
-
-<Cards>
-  <Card
-    icon={<AguiIcon width={20} height={20} />}
-    title="AG-UI overview"
-    description="What AG-UI is and when to pick it."
-    href="/docs/runtimes/ag-ui/overview"
-  />
-  <Card
-    title="Quickstart"
-    description="Minimal runtime + Thread setup."
-    href="/docs/runtimes/ag-ui/quickstart"
-  />
-  <Card
-    title="Adapters"
-    description="Attachments, speech, feedback, history, thread list."
-    href="/docs/runtimes/concepts/adapters"
-  />
-</Cards>

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

@@ -1,61 +0,0 @@
----
-title: Vercel AI SDK Runtime
-description: Connect the Vercel AI SDK to a React chat UI via assistant-ui — useChat hooks, custom transports, frontend tools, attachments, multi-step agents, and token usage.
----
-
-import { VercelIcon } from "@/components/icons/vercel";
-
-`@assistant-ui/ai-sdk` integrates assistant-ui with the [Vercel AI SDK](https://ai-sdk.dev/). It covers `useChat` flows, custom transports, frontend tools, attachments, quote context, multi-step agents, token usage, and cloud persistence.
-
-## Pick a version
-
-| AI SDK | Runtime package | Docs |
-| --- | --- | --- |
-| `ai@^7` + `@ai-sdk/react@^4` | `@assistant-ui/ai-sdk` (latest) | [v7 (current)](/docs/runtimes/ai-sdk/v7) |
-| `ai@^6` + `@ai-sdk/react@^3` | `@assistant-ui/react-ai-sdk@1.3.40` | [v6 (legacy)](/docs/runtimes/ai-sdk/v6-legacy) |
-| `ai@^5` + `@ai-sdk/react@^2` | `@assistant-ui/react-ai-sdk@1.1.21` | [v5 (legacy)](/docs/runtimes/ai-sdk/v5-legacy) |
-| `ai@^4` | `@assistant-ui/react-data-stream` | [v4 (legacy)](/docs/runtimes/ai-sdk/v4-legacy) |
-
-New projects should target v7. v6, v5, and v4 are documented for projects that have not migrated yet; all have known compatibility gaps and receive no new features.
-
-## Architecture
-
-`@assistant-ui/ai-sdk` is layered on `ExternalStoreRuntime` (see [architecture](/docs/runtimes/concepts/architecture)). Features that ship as runtime adapters work the same way they do everywhere else; see [adapters](/docs/runtimes/concepts/adapters).
-
-For reload-safe streaming (persist an in-flight response so the client can reconnect), see [Resumable Streams](/docs/guides/resumable-streams).
-
-## Choosing useChatRuntime vs useAISDKRuntime
-
-Both ship in the same package.
-
-- **`useChatRuntime`** (recommended) wraps the AI SDK's `useChat` hook and adds cloud thread support, the standard adapter slots, and `AssistantChatTransport` (which forwards system messages and frontend tools by default). Use this unless you have a reason not to.
-- **`useAISDKRuntime`** is a lower-level hook that takes an existing `useChat` instance you control directly. Use it when you need to share the chat instance with non-assistant-ui code or wire in a custom transport that does not inherit from `AssistantChatTransport`.
-
-## Next
-
-<Cards>
-  <Card
-    icon={<VercelIcon width={20} height={20} />}
-    title="v7 (current)"
-    description="Quickstart, frontend tools, attachments, quotes, history, multi-step, useAISDKRuntime."
-    href="/docs/runtimes/ai-sdk/v7"
-  />
-  <Card
-    icon={<VercelIcon width={20} height={20} />}
-    title="v6 (legacy)"
-    description="Reference for projects still on AI SDK v6."
-    href="/docs/runtimes/ai-sdk/v6-legacy"
-  />
-  <Card
-    icon={<VercelIcon width={20} height={20} />}
-    title="v5 (legacy)"
-    description="Reference for projects still on AI SDK v5."
-    href="/docs/runtimes/ai-sdk/v5-legacy"
-  />
-  <Card
-    icon={<VercelIcon width={20} height={20} />}
-    title="v4 (legacy)"
-    description="Reference for projects still on AI SDK v4."
-    href="/docs/runtimes/ai-sdk/v4-legacy"
-  />
-</Cards>

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

@@ -1,122 +0,0 @@
----
-title: AI SDK v4 (legacy)
-description: Reference for projects still on AI SDK v4. New projects should use v7.
----
-
-import { VercelIcon } from "@/components/icons/vercel";
-
-<Callout type="warn">
-AI SDK v4 is a legacy version. New projects should use [AI SDK v7](/docs/runtimes/ai-sdk/v7). v4 integrations use the older `@assistant-ui/react-data-stream` package, not `@assistant-ui/ai-sdk`.
-</Callout>
-
-## Why legacy
-
-Vercel ships AI SDK majors roughly yearly; v4 is three majors behind v7. The current `@assistant-ui/ai-sdk` package targets the current AI SDK major (v7) exclusively, so v4 users plug into [`@assistant-ui/react-data-stream`](/docs/runtimes/custom/data-stream) instead — the same data stream protocol that v4's `toDataStreamResponse()` emits.
-
-This page is reference for existing v4 projects. Plan to migrate to v7 when feasible.
-
-## Setup
-
-<Steps>
-<Step>
-
-### Install
-
-<InstallCommand npm={["@assistant-ui/react", "@assistant-ui/react-data-stream", "ai@^4"]} />
-
-</Step>
-<Step>
-
-### Backend route
-
-```ts title="@/app/api/chat/route.ts"
-import { streamText } from "ai";
-import { openai } from "@ai-sdk/openai";
-
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-  const result = streamText({ model: openai("gpt-5.6-luna"), messages });
-  return result.toDataStreamResponse();
-}
-```
-
-</Step>
-<Step>
-
-### Frontend
-
-```tsx title="@/app/page.tsx"
-"use client";
-
-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({ api: "/api/chat" });
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      <div className="h-full">
-        <Thread />
-      </div>
-    </AssistantRuntimeProvider>
-  );
-}
-```
-
-AI SDK v4's `toDataStreamResponse()` emits the data stream wire format with the
-`x-vercel-ai-data-stream: v1` response header, so `useDataStreamRuntime`
-detects it automatically. If a custom proxy strips or hides that header, pass
-`protocol: "data-stream"` explicitly.
-
-</Step>
-</Steps>
-
-`useDataStreamRuntime` accepts `api`, `initialMessages`, `onFinish`, `onError`, `headers`, `body`, and the standard `LocalRuntimeOptions`. For the full reference, see [Data Stream Protocol](/docs/runtimes/custom/data-stream).
-
-## Differences from v6
-
-| Feature | v4 | v6 |
-| --- | --- | --- |
-| `ai` package | `ai@^4` | `ai@^6` |
-| Runtime package | `@assistant-ui/react-data-stream` | `@assistant-ui/react-ai-sdk@1.3.40` |
-| Runtime hook | `useDataStreamRuntime` | `useChatRuntime` |
-| Response | `toDataStreamResponse()` | `toUIMessageStreamResponse()` |
-| Tool schema | `parameters: z.object({...})` | `inputSchema: zodSchema(z.object({...}))` |
-| Message type | (untyped) | `UIMessage` |
-
-## Migration to v7
-
-When you are ready to upgrade:
-
-1. Swap `@assistant-ui/react-data-stream` for `@assistant-ui/ai-sdk`.
-2. Update your backend to the current AI SDK's `streamText` (see [v7 docs](/docs/runtimes/ai-sdk/v7)).
-3. Switch the runtime hook from `useDataStreamRuntime` to `useChatRuntime`.
-
-AI SDK provides codemods at [ai-sdk.dev/docs/migration-guides](https://ai-sdk.dev/docs/migration-guides) that handle the package-side rewrites.
-
-## Alternative: react-ai-sdk@0.10.16
-
-An older release line of `@assistant-ui/react-ai-sdk` supported AI SDK v4 directly; its last release was `0.10.16`. It is no longer maintained and has no upgrade path; if you are starting a new v4 project, use `@assistant-ui/react-data-stream` instead.
-
-## Related
-
-<Cards>
-  <Card
-    icon={<VercelIcon width={20} height={20} />}
-    title="AI SDK v7"
-    description="Current integration; what new projects should target."
-    href="/docs/runtimes/ai-sdk/v7"
-  />
-  <Card
-    title="Data Stream Protocol"
-    description="The runtime v4 integrations are built on."
-    href="/docs/runtimes/custom/data-stream"
-  />
-  <Card
-    icon={<VercelIcon width={20} height={20} />}
-    title="AI SDK v5 (legacy)"
-    description="The intermediate legacy version."
-    href="/docs/runtimes/ai-sdk/v5-legacy"
-  />
-</Cards>

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

@@ -1,135 +0,0 @@
----
-title: AI SDK v5 (legacy)
-description: Reference for projects still on AI SDK v5. New projects should use v7.
----
-
-import { VercelIcon } from "@/components/icons/vercel";
-
-<Callout type="warn">
-AI SDK v5 is a legacy version. New projects should use [AI SDK v7](/docs/runtimes/ai-sdk/v7). v5 users pin `@assistant-ui/react-ai-sdk@1.1.21` (the last v5-compatible release); later releases target newer AI SDK majors.
-</Callout>
-
-## Why legacy
-
-AI SDK v6 introduced major API changes: async `convertToModelMessages`, a new tool schema, and `toUIMessageStreamResponse()`. v5 still works but no longer receives new features in `@assistant-ui/react-ai-sdk`. Pinning to `1.1.21` keeps you on the v5-compatible surface.
-
-This page is reference for existing v5 projects. Plan to migrate to v7 when feasible.
-
-## Setup
-
-<Steps>
-<Step>
-
-### Install v5-compatible versions
-
-<InstallCommand npm={["@assistant-ui/react", "@assistant-ui/react-ai-sdk@1.1.21", "ai@^5", "@ai-sdk/openai@^1", "zod"]} />
-
-</Step>
-<Step>
-
-### Backend route
-
-```ts title="@/app/api/chat/route.ts"
-import { openai } from "@ai-sdk/openai";
-import { streamText, tool } from "ai";
-import type { Message } from "ai";
-import { z } from "zod";
-
-export const maxDuration = 30;
-
-export async function POST(req: Request) {
-  const { messages }: { messages: Message[] } = await req.json();
-  const result = streamText({
-    model: openai("gpt-5.6-luna"),
-    messages,
-    tools: {
-      get_current_weather: tool({
-        description: "Get the current weather",
-        parameters: z.object({ city: z.string() }),
-        execute: async ({ city }) => `The weather in ${city} is sunny`,
-      }),
-    },
-  });
-  return result.toDataStreamResponse();
-}
-```
-
-</Step>
-<Step>
-
-### Frontend
-
-```tsx title="@/app/page.tsx"
-"use client";
-
-import { Thread } from "@/components/assistant-ui/thread";
-import { AssistantRuntimeProvider } from "@assistant-ui/react";
-import { useChatRuntime } from "@assistant-ui/react-ai-sdk";
-
-export default function Home() {
-  const runtime = useChatRuntime();
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      <div className="h-full">
-        <Thread />
-      </div>
-    </AssistantRuntimeProvider>
-  );
-}
-```
-
-</Step>
-</Steps>
-
-<Callout type="info">
-On `@assistant-ui/react-ai-sdk` versions older than 0.11.3, 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>
-
-## Differences from v6
-
-| Feature | v5 | v6 |
-| --- | --- | --- |
-| `ai` package | `ai@^5` | `ai@^6` |
-| `@assistant-ui/react-ai-sdk` | `@1.1.21` | `@1.3.40` |
-| `@ai-sdk/openai` | `^1` | `^3` |
-| Message type | `Message` | `UIMessage` |
-| `convertToModelMessages` | Sync | Async (`await`) |
-| Tool schema | `parameters: z.object({...})` | `inputSchema: zodSchema(z.object({...}))` |
-| Response | `toDataStreamResponse()` | `toUIMessageStreamResponse()` |
-
-## Migration to v6
-
-When you are ready to upgrade:
-
-1. Update `ai` from `@^5` to `@^6`, and `@assistant-ui/react-ai-sdk` to the latest line.
-2. Add `await` to `convertToModelMessages(...)` calls.
-3. Convert tool schemas: `parameters: z.object({...})` → `inputSchema: zodSchema(z.object({...}))`.
-4. Replace `toDataStreamResponse()` with `toUIMessageStreamResponse()`.
-5. Switch the `Message` type to `UIMessage`.
-
-AI SDK provides codemods at [ai-sdk.dev/docs/migration-guides/migration-guide-6-0](https://ai-sdk.dev/docs/migration-guides/migration-guide-6-0) that handle most of the package-side rewrites.
-
-## Related
-
-<Cards>
-  <Card
-    icon={<VercelIcon width={20} height={20} />}
-    title="AI SDK v7"
-    description="Current integration; what new projects should target."
-    href="/docs/runtimes/ai-sdk/v7"
-  />
-  <Card
-    icon={<VercelIcon width={20} height={20} />}
-    title="AI SDK v4 (legacy)"
-    description="The earlier legacy version using react-data-stream."
-    href="/docs/runtimes/ai-sdk/v4-legacy"
-  />
-</Cards>