@assistant-ui/mcp-docs-server 0.1.35 → 0.1.38

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

@@ -68,6 +68,10 @@ time, the same way a live run never stores them.
 
 `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.
+
 ## Thread list (experimental)
 
 <Callout type="warn">
@@ -131,6 +135,25 @@ await runtime.unstable_submitInterruptResponses(
 );
 ```
 
+### 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. With no pending interrupts it 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 } },
+]);
+```
+
 ## Supported events
 
 The runtime parses the AG-UI event stream and maps each event type to assistant-ui state.
@@ -178,7 +201,7 @@ The runtime parses the AG-UI event stream and maps each event type to assistant-
     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"
+    href="/docs/runtimes/ag-ui/overview"
   />
   <Card
     title="Quickstart"

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

@@ -3,7 +3,7 @@ title: AI SDK v6
 description: Integrate Vercel AI SDK v6 with assistant-ui for streaming chat.
 ---
 
-Current-version integration. Requires `ai@^6` and `@ai-sdk/react@^3`. For older versions see the [overview](/docs/runtimes/ai-sdk).
+Current-version integration. Requires `ai@^6` and `@ai-sdk/react@^3`. For older versions see the [overview](/docs/runtimes/ai-sdk/overview).
 
 ## Quickstart
 

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

@@ -299,6 +299,54 @@ runtime.thread.import(repo);
 
 Each message must have an explicit `id` and `parentId`; messages with the same `parentId` create branches. Parents must appear before children in the array.
 
+### Exporting a snapshot
+
+`thread.import()` has a counterpart, `thread.export()`, which captures the current thread (including its full branch tree) as a serializable `ExportedMessageRepository`. Use it to persist a conversation and re-import it later:
+
+```tsx
+// capture the current thread as a serializable snapshot
+const repo = runtime.thread.export();
+await saveToBackend(JSON.stringify(repo));
+
+// later, restore it into a runtime
+runtime.thread.import(repo);
+```
+
+The exported shape round-trips through `thread.import()` directly, so the same value is both your persistence format and what you load back.
+
+### Persisting branch selection
+
+If you store the full branch tree outside assistant-ui, persist the selected branch head too and pass it back as `messageRepository.headId`. `setMessages` still performs the branch switch; `unstable_onBranchChange` is an additional signal that fires after an explicit `switchToBranch` action, such as a BranchPicker click.
+
+```tsx
+const runtime = useExternalStoreRuntime({
+  messageRepository: {
+    messages: storedMessages,
+    headId: selectedHeadId,
+  },
+  setMessages: (messages) => {
+    setVisibleMessages(messages);
+  },
+  unstable_onBranchChange: ({ headId, visibleMessageIds }) => {
+    saveSelectedBranch({
+      headId,
+      visibleMessageIds,
+    });
+  },
+  onNew,
+});
+```
+
+`headId` is the canonical persisted head of the visible branch. Optimistic or transient message ids are not surfaced there. `visibleMessageIds` is the currently visible path in order, which can include an optimistic leaf while `headId` points to its persisted ancestor.
+
+The callback only fires for explicit branch switches, and consecutive switches that resolve to the same canonical head are de-duped. It does not fire on adapter resync, `messageRepository` reset, append, edit/regenerate, content-only updates, or while the thread is running.
+
+<Callout type="warn">
+  `unstable_onBranchChange` is under active development and may change without
+  notice. It complements `setMessages`; it does not enable branch switching by
+  itself.
+</Callout>
+
 ## Tool calling
 
 Handle tool results by updating the matching tool-call entry:
@@ -717,6 +765,12 @@ useExternalStoreRuntime({
       type: "(messages: readonly T[]) => void",
       description: "Update messages (required for branch switching).",
     },
+    {
+      name: "unstable_onBranchChange",
+      type: "(event: ExternalStoreBranchChange) => void",
+      description:
+        "Called after an explicit branch switch with the canonical persisted head id and visible message path. Complements setMessages and is unstable.",
+    },
     {
       name: "onEdit",
       type: "(message: AppendMessage) => Promise<void>",

package/.docs/raw/docs/runtimes/eve/overview.mdx

@@ -0,0 +1,100 @@
+---
+title: Eve Runtime
+description: Connect an Eve agent to assistant-ui with useEveAgentRuntime, eve/next, durable sessions, streaming messages, and human-in-the-loop approvals.
+---
+
+import { VercelIcon } from "@/components/icons/vercel";
+
+`@assistant-ui/eve` integrates assistant-ui with [Eve](https://eve.dev/), Vercel's filesystem-first framework for durable agents. It wraps Eve's `useEveAgent` hook and exposes it as an assistant-ui `ExternalStoreRuntime`, so Eve owns the session stream while assistant-ui renders messages, reasoning, dynamic tool calls, and approval requests.
+
+## When to use it
+
+Pick the Eve runtime when:
+
+- You want your agent implementation to live under `agent/` and be served by `eve/next`.
+- You want Eve sessions, continuation tokens, NDJSON streaming, and local development tooling.
+- You want assistant-ui to render Eve messages and human-in-the-loop tool approvals without writing a custom runtime adapter.
+
+## Architecture
+
+The Next.js app mounts Eve with `withEve()` and assistant-ui's registry transform with `withAui()`:
+
+```ts title="next.config.ts"
+import { withAui } from "@assistant-ui/next";
+import type { NextConfig } from "next";
+import { withEve } from "eve/next";
+
+const nextConfig: NextConfig = {};
+
+export default withEve(withAui(nextConfig));
+```
+
+On the client, `useEveAgentRuntime()` calls Eve's React hook and converts Eve message parts into assistant-ui thread messages:
+
+```tsx title="app/page.tsx"
+"use client";
+
+import { Thread } from "@/components/assistant-ui/thread";
+import { useEveAgentRuntime } from "@assistant-ui/eve";
+import { AssistantRuntimeProvider } from "@assistant-ui/react";
+
+export default function Home() {
+  const runtime = useEveAgentRuntime();
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <Thread />
+    </AssistantRuntimeProvider>
+  );
+}
+```
+
+## Requirements
+
+- Node.js 24 or higher.
+- React 18 or 19.
+- An Eve app mounted with `eve/next`.
+- A model credential for the model configured in `agent/agent.ts`.
+
+Eve's default gateway model ids route through the [Vercel AI Gateway](https://vercel.com/docs/ai-gateway). Use `AI_GATEWAY_API_KEY` or Vercel OIDC, or configure a direct provider `LanguageModel`.
+
+## Install
+
+<PlatformTabs>
+<Tab value="React">
+
+<InstallCommand npm={["@assistant-ui/react", "@assistant-ui/eve", "eve"]} />
+
+</Tab>
+<Tab value="React Native">
+
+Eve's browser hook talks to the Eve HTTP channel. There is not a React Native Eve runtime package yet.
+
+</Tab>
+<Tab value="React Ink">
+
+Use Eve's terminal UI directly for command-line agent sessions. There is not an Ink Eve runtime package yet.
+
+</Tab>
+</PlatformTabs>
+
+## Auth note
+
+Eve's built-in `eve` channel accepts localhost during development and trusted Vercel OIDC callers. It does not automatically admit browser users in production. Before deploying a public app, add `agent/channels/eve.ts` and wire the channel to your application auth.
+
+## Next
+
+<Cards>
+  <Card
+    icon={<VercelIcon width={20} height={20} />}
+    title="Quickstart"
+    description="Scaffold the Eve template or add Eve to an existing assistant-ui app."
+    href="/docs/runtimes/eve/quickstart"
+  />
+  <Card
+    icon={<VercelIcon width={20} height={20} />}
+    title="Eve channel"
+    description="Routes, auth, session creation, and stream events in the default Eve HTTP channel."
+    href="https://eve.dev/docs/channels/eve"
+  />
+</Cards>

package/.docs/raw/docs/runtimes/eve/quickstart.mdx

@@ -0,0 +1,143 @@
+---
+title: Quickstart
+description: From-template and manual setup paths to a working Eve agent chat in assistant-ui.
+---
+
+Two paths to a running Eve-powered assistant-ui app. The template is fastest; the manual path is what you adapt when integrating into an existing Next.js project.
+
+## From the template
+
+<PlatformTabs>
+<Tab value="React">
+
+```sh
+npx create-assistant-ui@latest -t eve my-app
+cd my-app
+```
+
+Set a model credential:
+
+```sh title=".env.local"
+AI_GATEWAY_API_KEY=your-api-key
+```
+
+```sh
+npm run dev
+```
+
+Open http://localhost:3000 and send a message. The template includes:
+
+- `agent/agent.ts` for Eve runtime config.
+- `agent/instructions.md` for the always-on system prompt.
+- `next.config.ts` with `withEve(withAui(nextConfig))`.
+- `app/page.tsx` with `useEveAgentRuntime()`.
+
+</Tab>
+<Tab value="React Native">
+
+There is not a React Native Eve template yet.
+
+</Tab>
+<Tab value="React Ink">
+
+Use Eve's terminal UI directly for command-line agent sessions.
+
+</Tab>
+</PlatformTabs>
+
+## Manual setup in an existing app
+
+<Steps>
+<Step>
+
+### Install dependencies
+
+<InstallCommand npm={["@assistant-ui/react", "@assistant-ui/eve", "eve"]} />
+
+</Step>
+<Step>
+
+### Mount Eve in Next.js
+
+```ts title="next.config.ts"
+import { withAui } from "@assistant-ui/next";
+import type { NextConfig } from "next";
+import { withEve } from "eve/next";
+
+const nextConfig: NextConfig = {};
+
+export default withEve(withAui(nextConfig));
+```
+
+</Step>
+<Step>
+
+### Add an Eve agent
+
+```ts title="agent/agent.ts"
+import { defineAgent } from "eve";
+
+export default defineAgent({
+  model: "anthropic/claude-sonnet-4.6",
+});
+```
+
+```md title="agent/instructions.md"
+You are a concise assistant. Use tools when they are available.
+```
+
+</Step>
+<Step>
+
+### Create the runtime
+
+```tsx title="app/page.tsx"
+"use client";
+
+import { Thread } from "@/components/assistant-ui/thread";
+import { useEveAgentRuntime } from "@assistant-ui/eve";
+import { AssistantRuntimeProvider } from "@assistant-ui/react";
+
+export default function Home() {
+  const runtime = useEveAgentRuntime();
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <Thread />
+    </AssistantRuntimeProvider>
+  );
+}
+```
+
+</Step>
+</Steps>
+
+## Production auth
+
+The default Eve channel is convenient for local development. For production browser users, define `agent/channels/eve.ts` and replace the default auth policy with your app's auth.
+
+```ts title="agent/channels/eve.ts"
+import { localDev, vercelOidc } from "eve/channels/auth";
+import { eveChannel } from "eve/channels/eve";
+
+export default eveChannel({
+  auth: [localDev(), vercelOidc()],
+});
+```
+
+That example keeps the development defaults. Swap in your Clerk, Auth.js, OIDC, or JWT verification before going live.
+
+## Next
+
+<Cards>
+  <Card
+    title="Eve overview"
+    description="Architecture, requirements, and runtime behavior."
+    href="/docs/runtimes/eve/overview"
+  />
+  <Card
+    title="API reference"
+    description="useEveAgentRuntime and message conversion helpers."
+    href="/docs/api-reference/integrations/eve"
+  />
+</Cards>

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

@@ -3,7 +3,7 @@ title: Quickstart
 description: Minimal API route and client setup with createAdkApiRoute.
 ---
 
-Four steps to a working ADK chat. Assumes you have already installed the package and have ADK ready on the server side; if not, start at [overview](/docs/runtimes/google-adk).
+Four steps to a working ADK chat. Assumes you have already installed the package and have ADK ready on the server side; if not, start at [overview](/docs/runtimes/google-adk/overview).
 
 <Steps>
 <Step>