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

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

@@ -1,6 +1,7 @@
 ---
 title: Message
 description: Build custom message rendering with content parts, attachments, and hover state.
+platforms: ["react"]
 ---
 
 import { MessagePrimitiveSample } from "@/components/docs/samples/message-primitive";
@@ -108,7 +109,7 @@ Runtime setup: primitives require runtime context. Wrap your UI in `AssistantRun
 ```
 
 <Callout type="info">
-For most new `MessagePrimitive.Parts` code, prefer the `children` render function. Grouped Chain of Thought is the current exception: it plugs into `MessagePrimitive.Parts` via `components.ChainOfThought`.
+For most new code, prefer `MessagePrimitive.Parts` with a `children` render function. When you need adjacent grouping, use `MessagePrimitive.GroupedParts`.
 </Callout>
 
 ### Tool Resolution
@@ -145,7 +146,7 @@ Returning `null` still allows registered tool UIs and data renderer UIs to rende
 
 - `ToolGroup` wraps consecutive tool-call parts
 - `ReasoningGroup` wraps consecutive reasoning parts
-- `components.ChainOfThought` takes over all reasoning and tool-call rendering (mutually exclusive with `ToolGroup`, `ReasoningGroup`, `tools`, and `Reasoning`). Despite the deprecation of `components` in general, this is still the current way to wire grouped Chain of Thought.
+- `components.ChainOfThought` takes over all reasoning and tool-call rendering (mutually exclusive with `ToolGroup`, `ReasoningGroup`, `tools`, and `Reasoning`). This legacy path is deprecated; use `MessagePrimitive.GroupedParts` for grouped Chain of Thought in new code.
 - `data.by_name` and `data.Fallback` let you route custom data part types
 - `Quote` renders quoted message references from metadata
 - `Empty` and `Unstable_Audio` are available for edge and experimental rendering paths
@@ -187,7 +188,7 @@ Returning `null` still allows registered tool UIs and data renderer UIs to rende
 />
 ```
 
-For new code, use the `children` render function instead.
+For new code, use the `children` render function or `GroupedParts` instead.
 
 ### Hover State
 
@@ -247,6 +248,45 @@ Renders each content part with type-based component resolution.
 
 <PrimitivesTypeTable type="MessagePrimitivePartsProps" parameters={MessagePrimitiveDocs.Parts.props} />
 
+### 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.
+
+```tsx
+<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;
+  }}
+>
+  {({ part, children }) => {
+    switch (part.type) {
+      case "group-chainOfThought":
+        return <div>{children}</div>;
+      case "group-reasoning":
+        return <ReasoningRoot>{children}</ReasoningRoot>;
+      case "group-tool":
+        return <ToolGroupRoot>{children}</ToolGroupRoot>;
+      case "text":
+        return <MarkdownText />;
+      case "reasoning":
+        return <Reasoning {...part} />;
+      case "tool-call":
+        return part.toolUI ?? <ToolFallback {...part} />;
+      case "data":
+        return part.dataRendererUI;
+      default:
+        return null;
+    }
+  }}
+</MessagePrimitive.GroupedParts>
+```
+
+<PrimitivesTypeTable type="MessagePrimitiveGroupedPartsProps" parameters={MessagePrimitiveDocs.GroupedParts.props} />
+
 ### Content
 
 Legacy alias for `Parts`.
@@ -340,7 +380,7 @@ Renders quote metadata when the current message includes a quote. Place it above
 
 ### Unstable_PartsGrouped
 
-Groups consecutive parts by a custom grouping function *(unstable)*.
+Groups parts by a custom grouping function *(unstable; use `GroupedParts` for adjacent grouping)*.
 
 ```tsx
 <MessagePrimitive.Unstable_PartsGrouped
@@ -453,9 +493,32 @@ import { ErrorPrimitive, MessagePrimitive } from "@assistant-ui/react";
 
 `ErrorPrimitive.Root` renders a `<div>` container with `role="alert"` and `ErrorPrimitive.Message` renders a `<span>` that displays the error text. `Root` always renders. Only `Message` conditionally returns `null` when there is no error. Wrap in `<MessagePrimitive.Error>` if you want the entire block to be conditional. See the [ErrorPrimitive API Reference](/docs/api-reference/primitives/error) for full details.
 
+### Render After Stream Completes
+
+To render content only once the assistant message has finished streaming (a follow-up card, a feedback prompt, a generated component that should not flicker through partial states), gate it with [`AuiIf`](/docs/api-reference/primitives/assistant-if) on `s.message.status`:
+
+```tsx
+import { MessagePrimitive, AuiIf } from "@assistant-ui/react";
+
+<MessagePrimitive.Root>
+  <MessagePrimitive.Parts />
+
+  <AuiIf
+    condition={(s) =>
+      s.message.role === "assistant" &&
+      s.message.status?.type === "complete"
+    }
+  >
+    <FollowUpCard />
+  </AuiIf>
+</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.
+
 ### Legacy and Unstable APIs
 
-- `MessagePrimitive.Unstable_PartsGrouped` and `MessagePrimitive.Unstable_PartsGroupedByParentId` are unstable APIs for custom grouping.
+- `MessagePrimitive.Unstable_PartsGrouped` and `MessagePrimitive.Unstable_PartsGroupedByParentId` are unstable APIs for non-adjacent custom grouping.
 - `Unstable_PartsGroupedByParentId` is deprecated in favor of `Unstable_PartsGrouped`.
 
 ### Role-Based Styling

package/.docs/raw/docs/primitives/selection-toolbar.mdx

@@ -1,6 +1,7 @@
 ---
 title: SelectionToolbar
 description: A floating toolbar that appears when text is selected within a message.
+platforms: ["react"]
 ---
 
 import { SelectionToolbarPrimitiveSample } from "@/components/docs/samples/selection-toolbar-primitive";

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

@@ -1,6 +1,7 @@
 ---
 title: Suggestion
 description: Suggested prompts that users can click to quickly send or populate the composer.
+platforms: ["react"]
 ---
 
 import { SuggestionPrimitiveSample } from "@/components/docs/samples/suggestion-primitive";

package/.docs/raw/docs/primitives/thread-list.mdx

@@ -1,6 +1,7 @@
 ---
 title: ThreadList
 description: Multi-thread management for listing, creating, switching, archiving, and deleting conversations.
+platforms: ["react"]
 ---
 
 import { ThreadListPrimitiveSample } from "@/components/docs/samples/thread-list-primitive";
@@ -218,6 +219,44 @@ Renders a single thread at a specific index.
 
 <PrimitivesTypeTable type="ThreadListPrimitiveItemByIndexProps" parameters={ThreadListPrimitiveDocs.ItemByIndex.props} />
 
+#### LoadMore
+
+Button that appends the next page of threads. Renders a `<button>` element unless `asChild` is set, and is automatically disabled when the runtime is loading or when the adapter's last `list()` did not return a `nextCursor`. See [Threads concepts](/docs/runtimes/concepts/threads#paginating-the-thread-list) for the adapter contract.
+
+```tsx
+<ThreadListPrimitive.LoadMore className="rounded-lg border px-3 py-2 text-sm">
+  Load more
+</ThreadListPrimitive.LoadMore>
+```
+
+For scroll-driven loading, wrap `aui.threads().loadMore()` in your own `IntersectionObserver` at the application layer; assistant-ui ships the explicit button to keep the primitive surface predictable.
+
+```tsx
+import { useAui, useAuiState } from "@assistant-ui/react";
+import { useEffect, useRef } from "react";
+
+function LoadMoreSentinel() {
+  const aui = useAui();
+  const disabled = useAuiState(
+    (s) =>
+      !s.threads.hasMore || s.threads.isLoading || s.threads.isLoadingMore,
+  );
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el || disabled) return;
+    const observer = new IntersectionObserver(([entry]) => {
+      if (entry?.isIntersecting) aui.threads().loadMore();
+    });
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [aui, disabled]);
+
+  return disabled ? null : <div ref={ref} className="h-9" />;
+}
+```
+
 ### ThreadListItemPrimitive
 
 #### Root

package/.docs/raw/docs/primitives/thread.mdx

@@ -1,6 +1,7 @@
 ---
 title: Thread
 description: Build custom scrollable message containers with auto-scroll, empty states, and message rendering.
+platforms: ["react"]
 ---
 
 import { ThreadPrimitiveSample } from "@/components/docs/samples/thread-primitive";
@@ -123,7 +124,18 @@ By default, new messages appear at the bottom and scroll down. With `turnAnchor=
 </ThreadPrimitive.Viewport>
 ```
 
-This is what the shadcn Thread component uses by default. For scroll anchoring to work correctly, `ViewportSlack` is needed on the last assistant message to provide enough min-height for the user message to anchor at the top. This is included automatically in the shadcn component.
+When `turnAnchor="top"` is set, `MessagePrimitive.Root` automatically registers the latest assistant message as the top-anchor target and the preceding user message as the anchor — no additional component is required. The viewport itself manages a stable reserve element that provides the missing scroll range while the assistant response grows. This is the behavior used by the [Thread](/docs/ui/thread) component by default.
+
+Use `topAnchorMessageClamp` to control how much of a long user message remains visible when `turnAnchor="top"`. Messages up to `tallerThan` stay fully visible. For messages taller than that, `visibleHeight` controls how much of the message's bottom edge remains visible above the assistant response:
+
+```tsx
+<ThreadPrimitive.Viewport
+  turnAnchor="top"
+  topAnchorMessageClamp={{ tallerThan: "10em", visibleHeight: "6em" }}
+>
+  {/* messages */}
+</ThreadPrimitive.Viewport>
+```
 
 ### Viewport Scroll Options
 
@@ -274,18 +286,9 @@ Provides viewport context without rendering a scrollable element. Use this when
 
 ### ViewportSlack
 
-Adds min-height for scroll anchoring with `turnAnchor="top"`. It wraps its child element via `Slot` and does not render a DOM element of its own.
-
-```tsx
-<MessagePrimitive.Root>
-  <MessagePrimitive.Parts />
-  <ThreadPrimitive.ViewportSlack>
-    <div className="min-h-[40vh]" />
-  </ThreadPrimitive.ViewportSlack>
-</MessagePrimitive.Root>
-```
-
-Props: `fillClampThreshold` and `fillClampOffset` control how the slack height is calculated. `children` is required.
+<Callout type="warn">
+  `ThreadPrimitive.ViewportSlack` has been removed from the public API. Top-anchor target registration is handled automatically by `MessagePrimitive.Root` when `turnAnchor="top"`. Remove `ViewportSlack` from your tree; if you customized `fillClampThreshold` or `fillClampOffset` on `ViewportSlack` or `MessagePrimitive.Root`, replace those props with `topAnchorMessageClamp` on `ThreadPrimitive.Viewport`.
+</Callout>
 
 ### Messages
 

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

@@ -49,9 +49,7 @@ If you prefer to add assistant-ui to an existing Expo project, follow these step
 
 ### Install dependencies
 
-```sh
-npx expo install @assistant-ui/react-native @assistant-ui/react-ai-sdk
-```
+<InstallCommand expo={["@assistant-ui/react-native", "@assistant-ui/react-ai-sdk"]} />
 
   </Step>
   <Step>

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

@@ -29,9 +29,7 @@ If you already have an assistant-ui web app, most of your code transfers directl
 
 ### Install the React Native package
 
-```sh
-npx expo install @assistant-ui/react-native
-```
+<InstallCommand expo={["@assistant-ui/react-native"]} />
 
   </Step>
   <Step>

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

@@ -0,0 +1,396 @@
+---
+title: Client and hooks
+description: A2AClient, useA2ARuntime options, hooks, task states, artifacts, errors.
+---
+
+import { Network } from "lucide-react";
+
+Deep dive on the runtime's API surface. Start with [overview](/docs/runtimes/a2a) and [quickstart](/docs/runtimes/a2a/quickstart) if you have not already.
+
+## A2AClient
+
+The built-in `A2AClient` handles all communication with the A2A server: 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",
+  extensions: ["urn:a2a:ext:my-extension"],
+});
+```
+
+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. |
+| `basePath` | `string` | Optional path prefix for API endpoints (e.g. `"/v1"`). Does not affect agent card discovery. |
+| `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
+
+Pass either a pre-built `client` or a `baseUrl` (the runtime creates a client for you). Other options layer on top.
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `client` | `A2AClient` | Pre-built A2A client instance (provide this OR `baseUrl`). |
+| `baseUrl` | `string` | A2A server URL (creates a client automatically). |
+| `basePath` | `string` | Path prefix for API endpoints. Only used with `baseUrl`. |
+| `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`. |
+| `contextId` | `string` | Initial context ID for the conversation. |
+| `configuration` | `A2ASendMessageConfiguration` | Default send message configuration. |
+| `onError` | `(error: Error) => void` | Error callback. |
+| `onCancel` | `() => void` | Cancellation callback. |
+| `onArtifactComplete` | `(artifact: A2AArtifact) => void` | Fired when an incremental artifact finishes. |
+| `adapters.attachments` | `AttachmentAdapter` | Custom attachment handling. See [adapters](/docs/runtimes/concepts/adapters#attachment-adapter). |
+| `adapters.speech` | `SpeechSynthesisAdapter` | Text-to-speech. See [adapters](/docs/runtimes/concepts/adapters#speech-adapter). |
+| `adapters.feedback` | `FeedbackAdapter` | Feedback collection. See [adapters](/docs/runtimes/concepts/adapters#feedback-adapter). |
+| `adapters.history` | `ThreadHistoryAdapter` | Message persistence. See [adapters](/docs/runtimes/concepts/adapters#history-adapter). |
+| `adapters.threadList` | `UseA2AThreadListAdapter` | Thread switching. See [threads](/docs/runtimes/concepts/threads). |
+
+## Hooks
+
+### Task state
+
+`useA2ATask` returns the current A2A task object, including task state and status message.
+
+<PlatformTabs>
+<Tab value="React">
+
+```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>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Native">
+
+```tsx
+import { useA2ATask } from "@assistant-ui/react-a2a";
+import { Text, View } from "react-native";
+
+function TaskStatus() {
+  const task = useA2ATask();
+  if (!task) return null;
+  return (
+    <View>
+      <Text>
+        Task {task.id}: {task.status.state}
+      </Text>
+    </View>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Ink">
+
+```tsx
+import { useA2ATask } from "@assistant-ui/react-a2a";
+import { Text } from "ink";
+
+function TaskStatus() {
+  const task = useA2ATask();
+  if (!task) return null;
+  return (
+    <Text>
+      Task {task.id}: {task.status.state}
+    </Text>
+  );
+}
+```
+
+</Tab>
+</PlatformTabs>
+
+### Artifacts list
+
+`useA2AArtifacts` returns the artifacts generated by the current task.
+
+<PlatformTabs>
+<Tab value="React">
+
+```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>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Native">
+
+```tsx
+import { useA2AArtifacts } from "@assistant-ui/react-a2a";
+import { Text, View } from "react-native";
+
+function ArtifactList() {
+  const artifacts = useA2AArtifacts();
+  return (
+    <View>
+      {artifacts.map((artifact) => (
+        <Text key={artifact.artifactId}>
+          {artifact.name}: {artifact.parts.length} parts
+        </Text>
+      ))}
+    </View>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Ink">
+
+```tsx
+import { useA2AArtifacts } from "@assistant-ui/react-a2a";
+import { Box, Text } from "ink";
+
+function ArtifactList() {
+  const artifacts = useA2AArtifacts();
+  return (
+    <Box flexDirection="column">
+      {artifacts.map((artifact) => (
+        <Text key={artifact.artifactId}>
+          {artifact.name}: {artifact.parts.length} parts
+        </Text>
+      ))}
+    </Box>
+  );
+}
+```
+
+</Tab>
+</PlatformTabs>
+
+### Agent card
+
+`useA2AAgentCard` returns the agent card fetched from the server on initialization.
+
+<PlatformTabs>
+<Tab value="React">
+
+```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>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Native">
+
+```tsx
+import { useA2AAgentCard } from "@assistant-ui/react-a2a";
+import { Text, View } from "react-native";
+
+function AgentInfo() {
+  const card = useA2AAgentCard();
+  if (!card) return null;
+  return (
+    <View>
+      <Text>{card.name}</Text>
+      <Text>{card.description}</Text>
+      <Text>Skills: {card.skills.map((s) => s.name).join(", ")}</Text>
+    </View>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Ink">
+
+```tsx
+import { useA2AAgentCard } from "@assistant-ui/react-a2a";
+import { Box, Text } from "ink";
+
+function AgentInfo() {
+  const card = useA2AAgentCard();
+  if (!card) return null;
+  return (
+    <Box flexDirection="column">
+      <Text bold>{card.name}</Text>
+      <Text>{card.description}</Text>
+      <Text>Skills: {card.skills.map((s) => s.name).join(", ")}</Text>
+    </Box>
+  );
+}
+```
+
+</Tab>
+</PlatformTabs>
+
+## 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 or 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 sends 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 `useA2AArtifacts`.
+
+The runtime supports:
+
+- **Incremental artifact streaming** via `append` mode.
+- **Artifact completion notification** via the `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 the field is 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:
+
+```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`).
+
+## Feature support
+
+| 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 | Via [history adapter](/docs/runtimes/concepts/adapters#history-adapter) |
+| Thread list management | Via [thread list adapter](/docs/runtimes/concepts/threads) |
+
+## Related
+
+<Cards>
+  <Card
+    icon={<Network width={20} height={20} />}
+    title="A2A overview"
+    description="What A2A is and when to pick it."
+    href="/docs/runtimes/a2a"
+  />
+  <Card
+    title="Quickstart"
+    description="Minimal runtime + Thread setup."
+    href="/docs/runtimes/a2a/quickstart"
+  />
+  <Card
+    title="Adapters"
+    description="Attachments, speech, feedback, history, threads."
+    href="/docs/runtimes/concepts/adapters"
+  />
+</Cards>