@assistant-ui/mcp-docs-server 0.1.27 → 0.1.29

package/.docs/raw/docs/(docs)/guides/slash-commands.mdx

@@ -0,0 +1,275 @@
+---
+title: Slash Commands
+description: Let users type / in the composer to trigger predefined actions from a popover picker.
+---
+
+Slash commands let users type `/` in the composer to open a popover, browse available commands, and execute one. Unlike [mentions](/docs/guides/mentions) (which insert text into the message), slash commands trigger **actions** — the `/command` text is removed from the composer and a callback fires.
+
+## How It Works
+
+```
+User types "/"  →  Trigger detected  →  Adapter provides commands
+                                              ↓
+              Command executed  ←  User selects command from popover
+                   ↓
+        "/command" text removed from composer
+```
+
+The slash command system is built on the same [trigger popover architecture](#trigger-popover-architecture) as mentions. It has two layers:
+
+1. **Adapter** — provides the list of available commands (flat list by default, or categorized for advanced use)
+2. **SlashCommandRoot** — a convenience wrapper that pre-configures the trigger character (`/`) and action-based select behavior
+
+## Quick Start
+
+### 1. Define Commands
+
+```tsx
+import {
+  unstable_useSlashCommandAdapter,
+  ComposerPrimitive,
+} from "@assistant-ui/react";
+
+// Define commands outside the component for a stable reference
+const COMMANDS = [
+  {
+    name: "summarize",
+    description: "Summarize the conversation",
+    execute: () => console.log("Summarize!"),
+  },
+  {
+    name: "translate",
+    description: "Translate text to another language",
+    execute: () => console.log("Translate!"),
+  },
+  {
+    name: "help",
+    description: "List all available commands",
+  },
+];
+
+function MyComposer() {
+  const slashAdapter = unstable_useSlashCommandAdapter({
+    commands: COMMANDS,
+  });
+
+  return (
+    <ComposerPrimitive.Unstable_SlashCommandRoot adapter={slashAdapter}>
+      <ComposerPrimitive.Root>
+        <ComposerPrimitive.Input placeholder="Type / for commands..." />
+        <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+
+        <ComposerPrimitive.Unstable_TriggerPopoverPopover className="popover">
+          <ComposerPrimitive.Unstable_TriggerPopoverItems>
+            {(items) =>
+              items.map((item, index) => (
+                <ComposerPrimitive.Unstable_TriggerPopoverItem
+                  key={item.id}
+                  item={item}
+                  index={index}
+                  className="popover-item"
+                >
+                  <strong>{item.label}</strong>
+                  {item.description && <span>{item.description}</span>}
+                </ComposerPrimitive.Unstable_TriggerPopoverItem>
+              ))
+            }
+          </ComposerPrimitive.Unstable_TriggerPopoverItems>
+        </ComposerPrimitive.Unstable_TriggerPopoverPopover>
+      </ComposerPrimitive.Root>
+    </ComposerPrimitive.Unstable_SlashCommandRoot>
+  );
+}
+```
+
+### 2. Handle Command Selection
+
+There are two ways to handle command execution:
+
+**Via `execute` on each item** — define the action inline in the command definition:
+
+```ts
+{ name: "summarize", execute: () => runSummarize() }
+```
+
+**Via `onSelect` prop** — handle all commands in one place:
+
+```tsx
+<ComposerPrimitive.Unstable_SlashCommandRoot
+  adapter={slashAdapter}
+  onSelect={(item) => {
+    switch (item.id) {
+      case "summarize": runSummarize(); break;
+      case "translate": runTranslate(); break;
+    }
+  }}
+>
+```
+
+Both `execute` and `onSelect` fire when a command is selected. Use whichever pattern fits your code.
+
+## Custom Adapter
+
+The `unstable_useSlashCommandAdapter` hook uses a **flat list** — all commands show immediately when `/` is typed, with search filtering as the user types. This is the recommended UX for most cases.
+
+For **categorized navigation** (drill-down into groups), build the adapter manually. Return categories from `categories()` and items from `categoryItems()`. The popover will show categories first, then items within the selected category:
+
+```ts
+import type { Unstable_SlashCommandAdapter } from "@assistant-ui/core";
+
+const adapter: Unstable_SlashCommandAdapter = {
+  categories() {
+    return [
+      { id: "actions", label: "Actions" },
+      { id: "export", label: "Export" },
+    ];
+  },
+
+  categoryItems(categoryId) {
+    if (categoryId === "actions") {
+      return [
+        { id: "summarize", type: "command", label: "/summarize", description: "Summarize the conversation" },
+        { id: "translate", type: "command", label: "/translate", description: "Translate text" },
+      ];
+    }
+    if (categoryId === "export") {
+      return [
+        { id: "pdf", type: "command", label: "/export pdf", description: "Export as PDF" },
+        { id: "markdown", type: "command", label: "/export md", description: "Export as Markdown" },
+      ];
+    }
+    return [];
+  },
+
+  // Optional — enables search across all categories
+  search(query) {
+    const lower = query.toLowerCase();
+    const all = [...this.categoryItems("actions"), ...this.categoryItems("export")];
+    return all.filter(
+      (item) => item.label.toLowerCase().includes(lower) || item.description?.toLowerCase().includes(lower),
+    );
+  },
+};
+```
+
+When using a categorized adapter, add `TriggerPopoverCategories` to your popover UI:
+
+```tsx
+<ComposerPrimitive.Unstable_TriggerPopoverPopover>
+  <ComposerPrimitive.Unstable_TriggerPopoverBack>← Back</ComposerPrimitive.Unstable_TriggerPopoverBack>
+  <ComposerPrimitive.Unstable_TriggerPopoverCategories>
+    {(categories) => categories.map((cat) => (
+      <ComposerPrimitive.Unstable_TriggerPopoverCategoryItem key={cat.id} categoryId={cat.id}>
+        {cat.label}
+      </ComposerPrimitive.Unstable_TriggerPopoverCategoryItem>
+    ))}
+  </ComposerPrimitive.Unstable_TriggerPopoverCategories>
+  <ComposerPrimitive.Unstable_TriggerPopoverItems>
+    {(items) => items.map((item, index) => (
+      <ComposerPrimitive.Unstable_TriggerPopoverItem key={item.id} item={item} index={index}>
+        {item.label}
+      </ComposerPrimitive.Unstable_TriggerPopoverItem>
+    ))}
+  </ComposerPrimitive.Unstable_TriggerPopoverItems>
+</ComposerPrimitive.Unstable_TriggerPopoverPopover>
+```
+
+## Combining with Mentions
+
+Slash commands and mentions can coexist on the same composer. Nest both roots — the [plugin protocol](#trigger-popover-architecture) ensures they don't conflict:
+
+```tsx
+<ComposerPrimitive.Unstable_MentionRoot adapter={mentionAdapter}>
+  <ComposerPrimitive.Unstable_SlashCommandRoot adapter={slashAdapter}>
+    <ComposerPrimitive.Root>
+      <ComposerPrimitive.Input placeholder="Type @ to mention, / for commands..." />
+      <ComposerPrimitive.Send>Send</ComposerPrimitive.Send>
+
+      {/* Mention popover — shows when @ is typed */}
+      <ComposerPrimitive.Unstable_MentionPopover>
+        <ComposerPrimitive.Unstable_MentionCategories>
+          {(categories) => categories.map((cat) => (
+            <ComposerPrimitive.Unstable_MentionCategoryItem key={cat.id} categoryId={cat.id}>
+              {cat.label}
+            </ComposerPrimitive.Unstable_MentionCategoryItem>
+          ))}
+        </ComposerPrimitive.Unstable_MentionCategories>
+        <ComposerPrimitive.Unstable_MentionItems>
+          {(items) => items.map((item) => (
+            <ComposerPrimitive.Unstable_MentionItem key={item.id} item={item}>
+              {item.label}
+            </ComposerPrimitive.Unstable_MentionItem>
+          ))}
+        </ComposerPrimitive.Unstable_MentionItems>
+      </ComposerPrimitive.Unstable_MentionPopover>
+
+      {/* Slash command popover — shows when / is typed */}
+      <ComposerPrimitive.Unstable_TriggerPopoverPopover>
+        <ComposerPrimitive.Unstable_TriggerPopoverItems>
+          {(items) => items.map((item, index) => (
+            <ComposerPrimitive.Unstable_TriggerPopoverItem key={item.id} item={item} index={index}>
+              {item.label}
+            </ComposerPrimitive.Unstable_TriggerPopoverItem>
+          ))}
+        </ComposerPrimitive.Unstable_TriggerPopoverItems>
+      </ComposerPrimitive.Unstable_TriggerPopoverPopover>
+    </ComposerPrimitive.Root>
+  </ComposerPrimitive.Unstable_SlashCommandRoot>
+</ComposerPrimitive.Unstable_MentionRoot>
+```
+
+Each root provides its own `TriggerPopoverContext`. When the user types `@`, the mention popover opens. When they type `/`, the slash command popover opens. Keyboard events route to whichever popover is active.
+
+## Keyboard Navigation
+
+Same keyboard bindings as mentions:
+
+| Key | Action |
+| --- | --- |
+| <Kbd>ArrowDown</Kbd> | Highlight next item |
+| <Kbd>ArrowUp</Kbd> | Highlight previous item |
+| <Kbd>Enter</Kbd> | Execute highlighted command / drill into category |
+| <Kbd>Escape</Kbd> | Close popover |
+| <Kbd>Backspace</Kbd> | Go back to categories (when query is empty) |
+
+## Trigger Popover Architecture
+
+Both mentions and slash commands are built on a generic **trigger popover** system:
+
+- `ComposerPrimitive.Unstable_TriggerPopoverRoot` — the generic root, parameterized by trigger character and select behavior
+- `ComposerPrimitive.Unstable_MentionRoot` — preset with `trigger="@"` and `onSelect: insertDirective`
+- `ComposerPrimitive.Unstable_SlashCommandRoot` — preset with `trigger="/"` and `onSelect: action`
+
+The trigger popover primitives (`TriggerPopoverPopover`, `TriggerPopoverItems`, etc.) are shared across both. You can also use `TriggerPopoverRoot` directly to build custom trigger systems with other characters (e.g. `:` for emoji).
+
+### ComposerInput Plugin Protocol
+
+Under the hood, each trigger root registers a **ComposerInputPlugin** with the composer input. This is a generic protocol that decouples the input from any specific trigger:
+
+```ts
+type ComposerInputPlugin = {
+  handleKeyDown(e: KeyboardEvent): boolean;
+  setCursorPosition(pos: number): void;
+};
+```
+
+The input iterates over registered plugins for keyboard events and cursor changes. This is what enables multiple trigger roots to coexist without conflict.
+
+## Primitives Reference
+
+| Primitive | Description |
+| --- | --- |
+| `Unstable_SlashCommandRoot` | Convenience wrapper — `TriggerPopoverRoot` with `trigger="/"` and action behavior |
+| `Unstable_TriggerPopoverRoot` | Generic root — configurable trigger character and select behavior |
+| `Unstable_TriggerPopoverPopover` | Container — only renders when a trigger is active (`role="listbox"`) |
+| `Unstable_TriggerPopoverCategories` | Render-function for the top-level category list |
+| `Unstable_TriggerPopoverCategoryItem` | Button that drills into a category (`role="option"`, auto `data-highlighted`) |
+| `Unstable_TriggerPopoverItems` | Render-function for items within the active category or search results |
+| `Unstable_TriggerPopoverItem` | Button that selects an item (`role="option"`, auto `data-highlighted`) |
+| `Unstable_TriggerPopoverBack` | Button that navigates back from items to categories |
+
+## Related
+
+- [Mentions Guide](/docs/guides/mentions) — `@`-mention system built on the same architecture
+- [Suggestions Guide](/docs/guides/suggestions) — static follow-up prompts (different from slash commands)
+- [Composer Primitives](/docs/primitives/composer) — underlying composer primitives

package/.docs/raw/docs/(docs)/guides/voice.mdx

@@ -303,14 +303,21 @@ const runtime = useChatRuntime({
 
 ## Example: LiveKit
 
-[LiveKit](https://livekit.io/) provides realtime voice via WebRTC rooms with transcription support.
+[LiveKit](https://livekit.io/) provides realtime voice via WebRTC rooms with transcription support. Unlike fully-hosted agent services, LiveKit follows a "bring-your-own-agent" model: the browser adapter only joins a room, and you run a separate **agent worker** that joins the same room and handles STT, LLM, and TTS. Without an agent in the room, the client will connect successfully but have nothing to talk to.
+
+### Prerequisites
+
+1. **A LiveKit server** — create a [LiveKit Cloud](https://cloud.livekit.io/) project (grab the URL, API Key, and API Secret from the project settings) or self-host `livekit-server`.
+2. **An agent worker** — built with the [LiveKit Agents SDK](https://docs.livekit.io/agents/) (Python or Node). The worker connects to your LiveKit server and is automatically dispatched into new rooms.
 
 ### Install Dependencies
 
 ```bash
-npm install livekit-client
+npm install livekit-client livekit-server-sdk
 ```
 
+`livekit-client` powers the browser adapter; `livekit-server-sdk` is used server-side to mint access tokens.
+
 ### Usage
 
 ```tsx
@@ -330,4 +337,4 @@ const runtime = useChatRuntime({
 });
 ```
 
-See the `examples/with-livekit` directory in the repository for a complete implementation including the adapter and token endpoint.
+See the [`with-livekit` example](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-livekit) for a complete implementation: the browser adapter, the token endpoint, and a minimal Python agent worker using the OpenAI Realtime API.

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

@@ -102,19 +102,42 @@ import { ComposerPrimitive } from "@assistant-ui/react";
 
 The primitive's behavior (keyboard handling, disabled state, form submission) is merged onto your element. Your styles, your component, primitive wiring.
 
-### Unstable Mentions
+### Unstable Trigger Popovers
 
-Composer also includes an unstable mention system for `@`-triggered popovers. It is built around `ComposerPrimitive.Unstable_MentionRoot` and intended for rich inputs like `LexicalComposerInput`.
+Composer includes an unstable **trigger popover** system for character-triggered popovers (e.g. `@` for mentions, `/` for slash commands). Multiple triggers can coexist on the same input.
+
+**Mentions** (`@` trigger) — insert directive text into the message:
 
 ```tsx
-<ComposerPrimitive.Unstable_MentionRoot>
+<ComposerPrimitive.Unstable_MentionRoot adapter={mentionAdapter}>
   <ComposerPrimitive.Root>
-    <LexicalComposerInput placeholder="Type @ to mention a tool..." />
+    <ComposerPrimitive.Input placeholder="Type @ to mention..." />
     <ComposerPrimitive.Unstable_MentionPopover />
   </ComposerPrimitive.Root>
 </ComposerPrimitive.Unstable_MentionRoot>
 ```
 
+**Slash commands** (`/` trigger) — execute an action and clear the command text:
+
+```tsx
+<ComposerPrimitive.Unstable_SlashCommandRoot adapter={slashAdapter}>
+  <ComposerPrimitive.Root>
+    <ComposerPrimitive.Input placeholder="Type / for commands..." />
+    <ComposerPrimitive.Unstable_TriggerPopoverPopover>
+      <ComposerPrimitive.Unstable_TriggerPopoverItems>
+        {(items) => items.map(item => (
+          <ComposerPrimitive.Unstable_TriggerPopoverItem key={item.id} item={item}>
+            {item.label}
+          </ComposerPrimitive.Unstable_TriggerPopoverItem>
+        ))}
+      </ComposerPrimitive.Unstable_TriggerPopoverItems>
+    </ComposerPrimitive.Unstable_TriggerPopoverPopover>
+  </ComposerPrimitive.Root>
+</ComposerPrimitive.Unstable_SlashCommandRoot>
+```
+
+See the [Mentions guide](/docs/guides/mentions) and [Slash Commands guide](/docs/guides/slash-commands) for full documentation.
+
 ## Parts
 
 ### Root

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

@@ -238,12 +238,12 @@ const aui = useAui();
 
 const history = useMemo<ThreadHistoryAdapter>(
   () => ({
-    async append(message) {
+    async append({ message, parentId }) {
       // Wait for initialization to complete and get the remoteId
       const { remoteId } = await aui.threadListItem().initialize();
 
       // Now safe to save the message using the remoteId
-      await saveMessageToDatabase(remoteId, message);
+      await saveMessageToDatabase(remoteId, parentId, message);
     },
     // ...
   }),

package/.docs/raw/docs/runtimes/custom/external-store.mdx

@@ -424,6 +424,44 @@ const onEdit = async (message: AppendMessage) => {
 };
 ```
 
+### Branching Support
+
+The `messages` array path assumes a linear conversation — each message's parent is the previous message. To support branching (e.g. regenerating responses creates alternative branches), use `ExportedMessageRepository.fromBranchableArray()` combined with `thread.import()`.
+
+Each message must have an explicit `id` and `parentId`. Messages with the same `parentId` create branches:
+
+```tsx
+import {
+  ExportedMessageRepository,
+  useExternalStoreRuntime,
+} from "@assistant-ui/react";
+
+// Your messages from the backend, each with an id and parentId
+const backendMessages = [
+  { id: "user-1", role: "user", content: "Hello", parentId: null },
+  { id: "asst-1", role: "assistant", content: "Hi!", parentId: "user-1" },
+  // A second response to the same user message = a branch
+  { id: "asst-2", role: "assistant", content: "Hey!", parentId: "user-1" },
+];
+
+// Convert to ExportedMessageRepository
+const repo = ExportedMessageRepository.fromBranchableArray(
+  backendMessages.map((m) => ({
+    message: { id: m.id, role: m.role, content: m.content },
+    parentId: m.parentId,
+  })),
+  { headId: "asst-1" }, // which branch to display initially
+);
+
+// Import into the runtime
+runtime.thread.import(repo);
+```
+
+<Callout type="warn">
+  Messages in the array must be ordered so that parents appear before their
+  children. Each message **must** have an `id` field set.
+</Callout>
+
 ### Tool Calling
 
 Support tool calls with proper result handling:

package/.docs/raw/docs/runtimes/custom/local.mdx

@@ -501,26 +501,69 @@ export function MyRuntimeProvider({ children }) {
               const { remoteId } = aui.threadListItem().getState();
               if (!remoteId) return { messages: [] };
 
-              const messages = await db.messages.findByThreadId(remoteId);
+              const rows = await db.messages.findByThreadId(remoteId);
               return {
-                messages: messages.map((m) => ({
-                  role: m.role,
-                  content: m.content,
-                  id: m.id,
-                  createdAt: new Date(m.createdAt),
-                })),
+                messages: rows.map((row) => {
+                  const common = {
+                    id: row.id,
+                    createdAt: new Date(row.createdAt),
+                  };
+                  // `content` is stored as JSON — parse back into message parts
+                  const content = JSON.parse(row.content);
+
+                  if (row.role === "user") {
+                    return {
+                      parentId: row.parentId,
+                      message: {
+                        ...common,
+                        role: "user" as const,
+                        content,
+                        attachments: [],
+                        metadata: { custom: {} },
+                      },
+                    };
+                  }
+                  if (row.role === "assistant") {
+                    return {
+                      parentId: row.parentId,
+                      message: {
+                        ...common,
+                        role: "assistant" as const,
+                        content,
+                        status: { type: "complete", reason: "stop" } as const,
+                        metadata: {
+                          custom: {},
+                          unstable_state: null,
+                          unstable_annotations: [],
+                          unstable_data: [],
+                          steps: [],
+                        },
+                      },
+                    };
+                  }
+                  return {
+                    parentId: row.parentId,
+                    message: {
+                      ...common,
+                      role: "system" as const,
+                      content,
+                      metadata: { custom: {} },
+                    },
+                  };
+                }),
               };
             },
 
-            async append(message) {
+            async append({ message, parentId }) {
               // Wait for initialization to get remoteId (safe to call multiple times)
               const { remoteId } = await aui.threadListItem().initialize();
 
               await db.messages.create({
                 threadId: remoteId,
-                role: message.role,
-                content: message.content,
+                parentId,
                 id: message.id,
+                role: message.role,
+                content: JSON.stringify(message.content),
                 createdAt: message.createdAt,
               });
             },
@@ -584,10 +627,10 @@ const aui = useAui();
 
 const history = useMemo<ThreadHistoryAdapter>(
   () => ({
-    async append(message) {
+    async append({ message, parentId }) {
       // Wait for initialization - safe to call multiple times
       const { remoteId } = await aui.threadListItem().initialize();
-      await db.messages.create({ threadId: remoteId, ...message });
+      await db.messages.create({ threadId: remoteId, parentId, ...message });
     },
     // ...
   }),
@@ -613,8 +656,9 @@ interface ThreadRecord {
 interface MessageRecord {
   id: string;
   threadId: string;
+  parentId: string | null;
   role: "user" | "assistant" | "system";
-  content: any; // Store as JSON
+  content: string; // JSON-encoded message content parts
   createdAt: Date;
 }
 ```
@@ -693,18 +737,21 @@ Persist and resume conversations:
 ```tsx
 const historyAdapter: ThreadHistoryAdapter = {
   async load() {
-    // Load messages from your storage
+    // Load messages from your storage.
+    // The API must return `{ messages: { parentId, message }[] }`
+    // where each `message` is a full ThreadMessage
+    // (including `metadata.custom`, plus `attachments` on user messages
+    // and `status` + the rest of `metadata` on assistant messages).
     const response = await fetch(`/api/thread/current`);
-    const { messages } = await response.json();
-    return { messages };
+    return await response.json();
   },
 
-  async append(message) {
+  async append({ message, parentId }) {
     // Save new message to storage
     await fetch(`/api/thread/messages`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ message }),
+      body: JSON.stringify({ message, parentId }),
     });
   },
 

package/.docs/raw/docs/runtimes/google-adk/index.mdx

@@ -317,6 +317,64 @@ function AuthUI() {
 
 `AdkAuthCredential` supports all ADK auth types: `apiKey`, `http`, `oauth2`, `openIdConnect`, `serviceAccount`.
 
+### Input Requests
+
+When an ADK Python 2.0+ Workflow's `RequestInput` node pauses execution to ask the user a question, ADK emits an `adk_request_input` function call marked as long-running. Respond with `useAdkSubmitInput` inside a tool UI — the helper wraps the answer as `{ result }` to match ADK's `unwrap_response` contract, so the Workflow node resumes with the unwrapped value:
+
+```tsx
+import { makeAssistantToolUI } from "@assistant-ui/react";
+import { useAdkSubmitInput } from "@assistant-ui/react-google-adk";
+
+type RequestInputArgs = {
+  interrupt_id?: string;
+  message?: string;
+  payload?: unknown;
+  response_schema?: unknown;
+};
+
+export const RequestInputToolUI = makeAssistantToolUI<RequestInputArgs, unknown>({
+  toolName: "adk_request_input",
+  render: function RequestInputUI({ toolCallId, args, result }) {
+    const submitInput = useAdkSubmitInput();
+
+    if (result !== undefined) {
+      return <p>Answered: {String(result)}</p>;
+    }
+
+    return (
+      <form
+        onSubmit={(e) => {
+          e.preventDefault();
+          const value = (
+            e.currentTarget.elements.namedItem("answer") as HTMLInputElement
+          ).value;
+          submitInput(toolCallId, value);
+        }}
+      >
+        <p>{args.message ?? "Please provide input:"}</p>
+        <input name="answer" autoFocus />
+        <button type="submit">Submit</button>
+      </form>
+    );
+  },
+});
+```
+
+Register the tool UI inside `AssistantRuntimeProvider`:
+
+```tsx
+<AssistantRuntimeProvider runtime={runtime}>
+  <RequestInputToolUI />
+  <Thread />
+</AssistantRuntimeProvider>
+```
+
+<Callout type="info">
+  `adk_request_input` is emitted only by ADK Python 2.0+ Workflow `RequestInput` nodes — ADK JS has no equivalent. Always respond via a tool UI with `useAdkSubmitInput`; HITL interrupts are automatically exempt from `autoCancelPendingToolCalls`, so typing a normal message in the composer will not overwrite the pending interrupt.
+</Callout>
+
+`useAdkSubmitInput` is sugar over the generic `addResult` — if you prefer, you can call `addResult({ result: value })` from inside the render function directly. The `{ result }` wrapper is required either way: the adapter JSON-stringifies the value before sending, and ADK's `unwrap_response` unwraps it on the backend before the Workflow node resumes.
+
 ### Artifacts
 
 Track file artifacts created or modified by the agent:
@@ -384,6 +442,8 @@ function PendingToolsIndicator() {
 }
 ```
 
+This hook reports every tool call ADK marked via `long_running_tool_ids`, including HITL interrupts. To respond to a specific HITL type, see [Tool Confirmations](#tool-confirmations), [Auth Requests](#auth-requests), or [Input Requests](#input-requests).
+
 ### Per-Message Metadata
 
 Access grounding, citation, and token usage metadata per message:
@@ -581,6 +641,7 @@ The resolved `checkpointId` is passed to your `stream` callback via `config.chec
 | `useAdkSend()` | Send raw ADK messages |
 | `useAdkConfirmTool()` | Confirm or deny a pending tool confirmation |
 | `useAdkSubmitAuth()` | Submit auth credentials for a pending auth request |
+| `useAdkSubmitInput()` | Submit the user's answer for a pending `adk_request_input` HITL interrupt |
 | `useAdkToolConfirmations()` | Pending tool confirmation requests |
 | `useAdkAuthRequests()` | Pending auth credential requests |
 | `useAdkLongRunningToolIds()` | IDs of long-running tools awaiting input |
@@ -596,6 +657,7 @@ The resolved `checkpointId` is passed to your `stream` callback via `config.chec
 | Tool calls & results | Supported |
 | Tool confirmations (`useAdkConfirmTool`) | Supported |
 | Auth credential flow (`useAdkSubmitAuth`) | Supported |
+| Workflow input requests (`useAdkSubmitInput`, ADK Python 2.0+) | Supported |
 | Multi-agent (author/branch tracking) | Supported |
 | Agent transfer events | Supported |
 | Escalation detection | Supported |