@assistant-ui/mcp-docs-server 0.1.34 → 0.1.36

package/.docs/raw/docs/runtimes/langchain.mdx

@@ -11,16 +11,16 @@ import { LangGraphIcon } from "@/components/icons/langgraph";
 
 Pick `react-langchain` over `react-langgraph` when:
 
+- You are scaffolding via `npx create-assistant-ui -t langchain` (the official template uses it).
 - Your app already depends on `@langchain/react` and uses `useStream` elsewhere.
 - You want to read custom state keys (`todos`, `files`, plans) reactively with `useLangChainState<T>(key)`.
 - You prefer a thin wrapper that stays pinned to upstream behavior.
 
 Pick `react-langgraph` instead when:
 
-- You are scaffolding via `npx create-assistant-ui -t langgraph` (the template uses it).
-- You need subgraph events, generative UI messages, message metadata, or end-to-end cancellation today.
+- You need a fully custom/bespoke backend stream (your own async generator) rather than `useStream`'s transport, or you're maintaining an existing `react-langgraph` app.
 
-Both adapters are first-class. `react-langchain` is newer and thinner; some features have not been ported yet (the [comparison](#comparison-with-react-langgraph) below has the full table).
+Both adapters are first-class and now at feature parity (the [comparison](#comparison-with-react-langgraph) below has the full table); `react-langchain` is the newer, thinner wrapper pinned to upstream `useStream`.
 
 ## Architecture
 
@@ -28,6 +28,8 @@ Both adapters are first-class. `react-langchain` is newer and thinner; some feat
 
 Shared adapters (attachments, speech, feedback) work the same way described in [adapters](/docs/runtimes/concepts/adapters). Cloud thread persistence is built in.
 
+`thread.isLoading` reflects `useStream`'s `isThreadLoading` (initial history hydration), separate from `isRunning` (a run being in-flight).
+
 ## Requirements
 
 - A LangGraph Cloud API server (locally via [LangGraph Studio](https://github.com/langchain-ai/langgraph-studio) or hosted via [LangSmith](https://www.langchain.com/langsmith)).
@@ -249,13 +251,18 @@ Follow the [Ink setup](/docs/ink).
 
 ## `useStreamRuntime` options
 
-`useStreamRuntime` accepts every option upstream `useStream` does, plus three assistant-ui-specific fields:
+`useStreamRuntime` accepts every option upstream `useStream` does, plus these assistant-ui-specific fields:
 
 | Option | Type | Description |
 | --- | --- | --- |
 | `cloud` | `AssistantCloud` | Optional. Persists threads via assistant-cloud. |
 | `adapters` | `{ attachments?, speech?, feedback? }` | Optional. Attachment, speech, and feedback adapters. |
 | `messagesKey` | `string` | The state key that holds messages. Defaults to `"messages"`. |
+| `uiStateKey` | `string` | The state key that holds generative `UIMessage`s. Defaults to `"ui"`. |
+
+### Forwarding per-run config
+
+When a message is sent, its `runConfig.custom` (for example a selected mode or model) is forwarded on the underlying `useStream().submit` call as `config.configurable`. Read it in the graph from `config["configurable"]`; on LangGraph v1 the same values are also reachable through the Runtime `context`, which `config.configurable` is aliased to. This lets per-run app config reach the graph without extra wiring.
 
 ## Reading custom state keys
 
@@ -347,7 +354,108 @@ Added in v0.0.2 — see issue [#3862](https://github.com/assistant-ui/assistant-
 
 ## Interrupts
 
-LangGraph interrupts pause the graph and wait for client input. `useLangChainInterruptState` exposes the current interrupt; `useLangChainSubmit` resumes the graph with a raw state update.
+LangGraph interrupts pause the graph and wait for client input. `useLangChainInterruptState` exposes the current interrupt; `useLangChainRespond` resumes it with a response payload, while `useLangChainSubmit` resumes the graph with a raw state update.
+
+`useLangChainRespond` is the cleaner resume path; it carries the response payload via `useStream().respond` and handles interrupt namespaces, so you don't have to construct a `Command`.
+
+<PlatformTabs>
+<Tab value="React">
+
+```tsx
+import {
+  useLangChainInterruptState,
+  useLangChainRespond,
+} from "@assistant-ui/react-langchain";
+
+function InterruptPrompt() {
+  const interrupt = useLangChainInterruptState();
+  const respond = useLangChainRespond();
+  if (!interrupt) return null;
+  return (
+    <div>
+      <pre>{JSON.stringify(interrupt.value, null, 2)}</pre>
+      <button onClick={() => respond({ approved: true })}>Approve</button>
+    </div>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Native">
+
+```tsx
+import {
+  useLangChainInterruptState,
+  useLangChainRespond,
+} from "@assistant-ui/react-langchain";
+import { Pressable, Text, View } from "react-native";
+
+function InterruptPrompt() {
+  const interrupt = useLangChainInterruptState();
+  const respond = useLangChainRespond();
+  if (!interrupt) return null;
+  return (
+    <View>
+      <Text>{JSON.stringify(interrupt.value, null, 2)}</Text>
+      <Pressable onPress={() => respond({ approved: true })}>
+        <Text>Approve</Text>
+      </Pressable>
+    </View>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Ink">
+
+```tsx
+import {
+  useLangChainInterruptState,
+  useLangChainRespond,
+} from "@assistant-ui/react-langchain";
+import { Box, Text, useInput } from "ink";
+
+function InterruptPrompt() {
+  const interrupt = useLangChainInterruptState();
+  const respond = useLangChainRespond();
+
+  useInput((input) => {
+    if (!interrupt || input !== "a") return;
+    respond({ approved: true });
+  });
+
+  if (!interrupt) return null;
+  return (
+    <Box flexDirection="column">
+      <Text>{JSON.stringify(interrupt.value, null, 2)}</Text>
+      <Text>Press a to approve.</Text>
+    </Box>
+  );
+}
+```
+
+</Tab>
+</PlatformTabs>
+
+When several interrupts are pending at once (e.g. parallel approvals), use `useLangChainRespondAll()` to resume them all in one run. Sequential `useLangChainRespond` calls can't, since the first resume starts a run and strands the rest.
+
+```tsx
+import {
+  useLangChainInterrupts,
+  useLangChainRespondAll,
+} from "@assistant-ui/react-langchain";
+
+const interrupts = useLangChainInterrupts();
+const respondAll = useLangChainRespondAll();
+// resume every pending interrupt with the same payload:
+await respondAll(
+  Object.fromEntries(
+    interrupts.flatMap((i) => (i.id ? [[i.id, { approved: true }]] : [])),
+  ),
+);
+```
+
+You can also resume with a raw `Command` via `useLangChainSubmit`:
 
 <PlatformTabs>
 <Tab value="React">
@@ -441,6 +549,243 @@ function InterruptPrompt() {
 </Tab>
 </PlatformTabs>
 
+## Tool calls
+
+`useLangChainToolCalls` exposes the root tool calls `useStream` assembles from the `tools` channel — each entry carries a `name`, `args`, and `id`. Use it to render pending or streamed tool calls and approval UIs. It defaults to an empty array, so you can `.map` without a guard.
+
+<PlatformTabs>
+<Tab value="React">
+
+```tsx
+import { useLangChainToolCalls } from "@assistant-ui/react-langchain";
+
+function PendingToolCalls() {
+  const toolCalls = useLangChainToolCalls();
+  return (
+    <ul>
+      {toolCalls.map((tc) => (
+        <li key={tc.id}>
+          {tc.name}: <code>{JSON.stringify(tc.args)}</code>
+        </li>
+      ))}
+    </ul>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Native">
+
+```tsx
+import { useLangChainToolCalls } from "@assistant-ui/react-langchain";
+import { Text, View } from "react-native";
+
+function PendingToolCalls() {
+  const toolCalls = useLangChainToolCalls();
+  return (
+    <View>
+      {toolCalls.map((tc) => (
+        <Text key={tc.id}>
+          {tc.name}: {JSON.stringify(tc.args)}
+        </Text>
+      ))}
+    </View>
+  );
+}
+```
+
+</Tab>
+<Tab value="React Ink">
+
+```tsx
+import { useLangChainToolCalls } from "@assistant-ui/react-langchain";
+import { Box, Text } from "ink";
+
+function PendingToolCalls() {
+  const toolCalls = useLangChainToolCalls();
+  return (
+    <Box flexDirection="column">
+      {toolCalls.map((tc) => (
+        <Text key={tc.id}>
+          {tc.name}: {JSON.stringify(tc.args)}
+        </Text>
+      ))}
+    </Box>
+  );
+}
+```
+
+</Tab>
+</PlatformTabs>
+
+## Subagent and subgraph discovery
+
+For multi-agent graphs, `useStream` tracks which subagents and subgraphs it has seen on the current run as cheap discovery maps. `useLangChainSubagents` and `useLangChainSubgraphs` surface those maps — keyed by namespace, each value a `SubagentDiscoverySnapshot` / `SubgraphDiscoverySnapshot`. Both default to a stable empty map, so you can iterate without a guard.
+
+These replace `react-langgraph`'s subgraph `eventHandlers`: v1 surfaces discovery as maps you read reactively rather than per-event callbacks.
+
+```tsx
+import {
+  useLangChainSubagents,
+  useLangChainSubgraphs,
+} from "@assistant-ui/react-langchain";
+
+function Discovered() {
+  const subagents = useLangChainSubagents();
+  const subgraphs = useLangChainSubgraphs();
+  return (
+    <ul>
+      {[...subagents.keys()].map((ns) => (
+        <li key={ns}>subagent: {ns}</li>
+      ))}
+      {[...subgraphs.keys()].map((ns) => (
+        <li key={ns}>subgraph: {ns}</li>
+      ))}
+    </ul>
+  );
+}
+```
+
+## Subagent and subgraph views
+
+The discovery maps above pair with v1's scoped selector hooks to render a subagent's or subgraph's own messages and tool calls. `useLangChainStream` exposes the underlying `useStream` handle; feed it to `useMessages(stream, target)` / `useToolCalls(stream, target)` from `@langchain/react`, with a `SubagentDiscoverySnapshot` / `SubgraphDiscoverySnapshot` from `useLangChainSubagents` / `useLangChainSubgraphs` as the target. `useLangChainStream` returns `undefined` outside the runtime provider.
+
+```tsx
+import {
+  useLangChainStream,
+  useLangChainSubagents,
+} from "@assistant-ui/react-langchain";
+import { useMessages, useToolCalls } from "@langchain/react";
+
+function SubagentCard({ stream, subagent }) {
+  const messages = useMessages(stream, subagent);
+  const toolCalls = useToolCalls(stream, subagent);
+  return (
+    <div>
+      <strong>{subagent.namespace.join("/")}</strong>
+      <pre>{messages.map((m) => m.content).join("\n")}</pre>
+      <ul>
+        {toolCalls.map((tc) => (
+          <li key={tc.id}>{tc.name}</li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+
+function Subagents() {
+  const stream = useLangChainStream();
+  const subagents = useLangChainSubagents();
+  if (!stream) return null;
+  return [...subagents.values()].map((s) => (
+    <SubagentCard key={s.namespace.join("/")} stream={stream} subagent={s} />
+  ));
+}
+```
+
+## Per-message metadata
+
+`useMessageMetadata` (from `@langchain/react`) reads per-message metadata (e.g. `parentCheckpointId`) for a given message id. Pair it with `useLangChainStream`, which returns `undefined` outside the runtime provider; guard the stream before calling the selector, since `useMessageMetadata` throws on an undefined stream.
+
+```tsx
+import { useLangChainStream } from "@assistant-ui/react-langchain";
+import { useMessageMetadata } from "@langchain/react";
+
+function MessageInfoView({
+  stream,
+  messageId,
+}: {
+  stream: NonNullable<ReturnType<typeof useLangChainStream>>;
+  messageId: string;
+}) {
+  const { parentCheckpointId } = useMessageMetadata(stream, messageId) ?? {};
+  // …render per-message metadata…
+}
+
+function MessageInfo({ messageId }: { messageId: string }) {
+  const stream = useLangChainStream();
+  if (!stream) return null;
+  return <MessageInfoView stream={stream} messageId={messageId} />;
+}
+```
+
+## Media
+
+The v1 media hooks surface multimodal media streamed by the agent. Feed the `useLangChainStream` handle to them — the same pattern as the views and metadata sections above.
+
+```tsx
+import { useLangChainStream } from "@assistant-ui/react-langchain";
+import { useImages, useAudio } from "@langchain/react";
+
+function MediaView({
+  stream,
+}: {
+  stream: NonNullable<ReturnType<typeof useLangChainStream>>;
+}) {
+  const images = useImages(stream);
+  // useAudio / useVideo / useFiles likewise
+  return <>{/* …render media… */}</>;
+}
+
+function Media() {
+  const stream = useLangChainStream();
+  if (!stream) return null;
+  return <MediaView stream={stream} />;
+}
+```
+
+## Generative UI
+
+Graphs can accumulate UI components in their state and attach each one to the assistant message that produced it. The runtime reads these from `stream.values[uiStateKey]` (default `"ui"`) and, for every `UIMessage` whose parent id matches an assistant message, emits a `data` part on that message. The parent id is read from `metadata.message_id` (Python SDK) or `metadata.id` (JS SDK). Pass `uiStateKey` if your graph stores them elsewhere.
+
+Register the components with `makeAssistantDataUI`, keyed by the `UIMessage`'s `name`, and mount the returned element once inside the runtime provider:
+
+```tsx
+import {
+  AssistantRuntimeProvider,
+  makeAssistantDataUI,
+  Thread,
+} from "@assistant-ui/react";
+import { useStreamRuntime } from "@assistant-ui/react-langchain";
+
+const ChartUI = makeAssistantDataUI({
+  name: "chart",
+  render: ({ data }) => <Chart points={data.points} />,
+});
+
+function App() {
+  const runtime = useStreamRuntime({
+    assistantId: "agent",
+    apiUrl: "http://localhost:2024",
+  });
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <ChartUI />
+      <Thread />
+    </AssistantRuntimeProvider>
+  );
+}
+```
+
+This covers two paths transparently. The **state-snapshot** path renders whatever UI the graph has committed to its state. The **live** path renders UI streamed over the `custom` channel by `push_ui_message` / `remove_ui_message` before (or instead of) it lands in state, so components appear as the graph emits them. The runtime accumulates the live events and merges them with the state snapshot, with the snapshot authoritative once a UI lands in state. Both feed the same `makeAssistantDataUI` renderers.
+
+The live path requires the graph's `streamMode` to include `"custom"` so the UI events reach the client.
+
+## Errors
+
+`useLangChainError` exposes the last run or hydration error from upstream `useStream().error`. It is untyped (`unknown`), so narrow it at the use site before rendering.
+
+```tsx
+import { useLangChainError } from "@assistant-ui/react-langchain";
+
+function ErrorBanner() {
+  const error = useLangChainError();
+  if (!error) return null;
+  return <div role="alert">{error instanceof Error ? error.message : String(error)}</div>;
+}
+```
+
 ## Message conversion
 
 `convertLangChainBaseMessage` transforms a LangChain `BaseMessage` into an assistant-ui message. Use it when building a custom `ExternalStoreAdapter` that consumes LangChain messages outside `useStreamRuntime`.
@@ -476,7 +821,7 @@ const runtime = useStreamRuntime({
 
 ## Comparison with `react-langgraph`
 
-Both packages connect assistant-ui to LangGraph backends. They are independent adapters for different upstream libraries; one is not a successor to the other.
+Both packages connect assistant-ui to LangGraph backends. They are independent adapters for different upstream libraries; one is not a successor to the other. The official `create-assistant-ui` template (`-t langchain`) ships `react-langchain`. The two are now at feature parity; `react-langgraph` remains the choice for a fully custom backend stream or an existing `react-langgraph` app.
 
 | Aspect | `react-langgraph` | `react-langchain` |
 | --- | --- | --- |
@@ -485,7 +830,7 @@ Both packages connect assistant-ui to LangGraph backends. They are independent a
 | Version | `0.13.x` | `0.0.x` |
 | Lines of source | ~7,500 | ~600 |
 | Built on | `useExternalStoreRuntime` | `useExternalStoreRuntime` |
-| `create-assistant-ui` template | `-t langgraph` | No template yet |
+| `create-assistant-ui` template | No template | `-t langchain` |
 
 ### Feature coverage
 
@@ -493,16 +838,32 @@ Both packages connect assistant-ui to LangGraph backends. They are independent a
 | --- | --- | --- |
 | Stream messages | Yes (`useLangGraphRuntime`) | Yes (`useStreamRuntime`) |
 | Interrupt state | Yes | Yes |
-| Send raw state update / resume command | Yes | Yes (`useLangChainSubmit`) |
+| Thread history loading state (`thread.isLoading`) | Yes | Yes |
+| Send raw state update / resume command | Yes | Yes (`useLangChainSubmit`; `useLangChainRespond` for payload resume) |
+| Forward per-run `runConfig` | Yes (whole object → `config`) | Yes (`custom` → `config.configurable`) |
 | Read arbitrary custom state key | No | Yes (`useLangChainState<T>(key)`) |
-| Per-message metadata (`messages-tuple`) | Yes | Not exposed |
-| Generative UI messages (LangSmith) | Yes | Not exposed |
-| Subgraph / namespaced stream events | Yes (via `eventHandlers`) | Not exposed |
-| End-to-end cancellation primitive | Yes (`unstable_createLangGraphStream`) | Not exposed |
-| Message accumulator utility | Yes (`LangGraphMessageAccumulator`) | Not exposed |
+| Root tool-calls projection | Via message parts | Yes (`useLangChainToolCalls`) |
+| File content parts in messages | Yes | Yes |
+| Regenerate (checkpoint fork) | Yes (`getCheckpointId`) | Yes (auto-resolved) |
+| Edit message (checkpoint fork) | Yes | Yes (auto-resolved) |
+| Per-message metadata (`messages-tuple`) | Yes | Yes (`useMessageMetadata` via `useLangChainStream`) |
+| Multimodal media (audio/image/video/file) | Via parts | Yes (v1 media hooks via `useLangChainStream`) |
+| Generative UI (state snapshot) | Yes | Yes (`uiStateKey`) |
+| Generative UI (live `push_ui_message`) | Yes | Yes (`streamMode: ["custom"]`) |
+| Subgraph / namespaced stream events | Yes (via `eventHandlers`) | Replaced by `useLangChainSubagents` / `useLangChainSubgraphs` + views |
+| Subagent discovery | Via `eventHandlers` | Yes (`useLangChainSubagents`) |
+| Subgraph discovery | Via `eventHandlers` | Yes (`useLangChainSubgraphs`) |
+| Subagent/subgraph message views | Via `eventHandlers` | Yes (via `useLangChainStream` + v1 selector hooks) |
+| End-to-end cancellation primitive | Yes (`unstable_createLangGraphStream`) | n/a — cancellation via `useStream().stop()` (Cancel button on by default) |
+| Message accumulator utility | Yes (`LangGraphMessageAccumulator`) | n/a — `useStream` owns accumulation |
+| Streaming timing (per-message) | Yes | Yes |
 | Cloud thread persistence | Yes | Yes |
 
-`react-langchain` is the newer, thinner wrapper. It delegates to upstream `useStream` rather than re-implementing the stream plumbing, which is why its footprint is smaller. Features absent today have not been ported, not deprecated.
+Per-message streaming timing is attached automatically to `message.metadata.timing` (no setup), matching `react-langgraph`. It captures time-to-first-token, total stream time, chunk count, and tokens/sec, computed from message growth while the run is in flight.
+
+`react-langchain` is the newer, thinner wrapper. It delegates to upstream `useStream` rather than re-implementing the stream plumbing, which is why its footprint is smaller.
+
+Regenerate works without configuration. Clicking regenerate resolves the server checkpoint to fork from (the checkpoint each message records as it streams in, falling back to a `stream.client.threads.getHistory(threadId)` id match for older turns), then re-runs with `submit(null, { forkFrom })`. It works on checkpoint-enabled backends (for example LangGraph Cloud) and degrades gracefully; when no checkpoint resolves the regenerate is a no-op. `react-langgraph` instead requires a user-supplied `getCheckpointId` callback. Editing a message forks from the same checkpoint and submits the edited human content instead of re-running the prior turn; editing the first message forks from the thread's initial checkpoint to restart it.
 
 ### Hook name mapping
 
@@ -510,11 +871,18 @@ Both packages connect assistant-ui to LangGraph backends. They are independent a
 | --- | --- | --- |
 | `useLangGraphRuntime` | `useStreamRuntime` | Options extend upstream `UseStreamOptions`; no `stream` / `create` / `load` to write. |
 | `useLangGraphInterruptState` | `useLangChainInterruptState` | Same return shape. |
-| `useLangGraphSendCommand` | `useLangChainSubmit` | `submit(values, { command })` replaces the dedicated hook. |
+| `useLangGraphSendCommand` | `useLangChainRespond` | Preferred resume; carries a payload via `stream.respond`. For a raw `Command`, use `useLangChainSubmit(null, { command })`. |
 | `useLangGraphSend` | _(use `runtime.thread.append`)_ | No direct equivalent; send turns through the runtime. |
-| `useLangGraphMessageMetadata` | _(not available)_ | Open an issue if you rely on this. |
-| `useLangGraphUIMessages` | _(not available)_ | Open an issue if you rely on this. |
+| `useLangGraphMessageMetadata` | _(use `useMessageMetadata(useLangChainStream(), id)`)_ | Per-message metadata via the upstream selector hook. |
+| `useLangGraphUIMessages` | _(UI renders as data parts; register with `makeAssistantDataUI`)_ | See [Generative UI](#generative-ui). |
 | _(none)_ | `useLangChainState<T>(key)` | New — reads any custom state key reactively. |
+| _(none)_ | `useLangChainToolCalls` | New — root tool calls assembled by `useStream`. |
+| _(none)_ | `useLangChainError()` | New — reads the last run/hydration error reactively. |
+| _(none)_ | `useLangChainRespondAll` | Resume multiple interrupts at one checkpoint (`stream.respondAll`). |
+| _(none)_ | `useLangChainInterrupts` | New — every interrupt pending at the checkpoint, each with `id` and `value`. |
+| _(via `eventHandlers`)_ | `useLangChainSubagents` | New — subagents discovered on the current run; replaces subgraph event handlers. |
+| _(via `eventHandlers`)_ | `useLangChainSubgraphs` | New — subgraphs discovered on the current run; replaces subgraph event handlers. |
+| _(none)_ | `useLangChainStream` | New — the raw `useStream` handle for v1's scoped `useMessages` / `useToolCalls` selector hooks. |
 
 ## Related
 
@@ -522,7 +890,7 @@ Both packages connect assistant-ui to LangGraph backends. They are independent a
   <Card
     icon={<LangGraphIcon width={20} height={20} className="text-[#1C3C3C] dark:text-[#5b9595]" />}
     title="LangGraph"
-    description="The full-featured adapter with subgraph events, UI messages, metadata."
+    description="The original LangGraph adapter, built on the raw SDK."
     href="/docs/runtimes/langgraph"
   />
   <Card

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

@@ -11,7 +11,7 @@ Two paths to a running chat against a LangGraph Cloud server. The template is fa
 <Tab value="React">
 
 ```sh
-npx create-assistant-ui@latest -t langgraph my-app
+npx create-assistant-ui@latest -t langchain my-app
 cd my-app
 ```
 

package/.docs/raw/docs/runtimes/langgraph/tutorial/part-1.mdx

@@ -8,7 +8,7 @@ description: Create a Next.js project with the LangGraph assistant-ui template.
 Run the following command to create a new Next.js project with the LangGraph assistant-ui template:
 
 ```sh
-npx create-assistant-ui@latest -t langgraph my-app
+npx create-assistant-ui@latest -t langchain my-app
 cd my-app
 ```
 

package/.docs/raw/docs/runtimes/pick-a-runtime.mdx

@@ -28,13 +28,19 @@ assistant-ui ships React adapter packages for these. Pick the matching card and
     icon={<VercelIcon width={20} height={20} />}
     title="Vercel AI SDK"
     description="useChat hook, streaming, tools, attachments, multi-step. v6 current; v5 / v4 legacy."
-    href="/docs/runtimes/ai-sdk"
+    href="/docs/runtimes/ai-sdk/overview"
+  />
+  <Card
+    icon={<VercelIcon width={20} height={20} />}
+    title="Eve"
+    description="Filesystem-first durable agents with eve/next, sessions, NDJSON streaming, and HITL."
+    href="/docs/runtimes/eve/overview"
   />
   <Card
     icon={<LangGraphIcon width={20} height={20} className="text-[#1C3C3C] dark:text-[#5b9595]" />}
     title="LangGraph"
     description="Direct integration with @langchain/langgraph-sdk. Subgraph events, UI messages, message metadata."
-    href="/docs/runtimes/langgraph"
+    href="/docs/runtimes/langgraph/overview"
   />
   <Card
     icon={<LangChainIcon width={20} height={20} className="text-[#7FC8FF]" />}
@@ -46,7 +52,7 @@ assistant-ui ships React adapter packages for these. Pick the matching card and
     icon={<AdkIcon width={20} height={20} />}
     title="Google ADK"
     description="ADK JS or Python agents. Tool confirmations, auth flows, multi-agent, code execution."
-    href="/docs/runtimes/google-adk"
+    href="/docs/runtimes/google-adk/overview"
   />
   <Card
     icon={<A2AIcon width={20} height={20} />}
@@ -58,14 +64,14 @@ assistant-ui ships React adapter packages for these. Pick the matching card and
     icon={<AguiIcon width={20} height={20} />}
     title="AG-UI Protocol"
     description="AG-UI agents (CopilotKit, custom servers). Streaming text, thinking, tool calls, state snapshots."
-    href="/docs/runtimes/ag-ui"
+    href="/docs/runtimes/ag-ui/overview"
   />
   <PlatformOnly platforms={["react"]}>
     <Card
       icon={<OpenCodeIcon width={20} height={20} />}
       title="OpenCode"
       description="OpenCode coding-agent server. Permission flows, questions, fork / revert. Experimental."
-      href="/docs/runtimes/opencode"
+      href="/docs/runtimes/opencode/overview"
     />
   </PlatformOnly>
 </Cards>
@@ -104,7 +110,7 @@ If you do not know your framework yet, or your backend is custom, pick by what y
 | Backend that already speaks the data stream protocol | [DataStream](/docs/runtimes/custom/data-stream) |
 | Stream full agent state snapshots (not just messages) | [AssistantTransport](/docs/runtimes/custom/assistant-transport) |
 
-If none of the framework adapters fits, start at [custom backend](/docs/runtimes/custom).
+If none of the framework adapters fits, start at [custom backend](/docs/runtimes/custom/overview).
 
 ## Shared concepts
 

package/.docs/raw/docs/tools/defining-tools.mdx

@@ -423,6 +423,10 @@ The compiler splits each file across the client/server boundary on its own, then
 - **Spread a default import** (`import weatherTools from "./tools/weather"`). Relative paths and `tsconfig` path aliases like `@/tools/weather` both resolve. Only the default export crosses the generative-module boundary, so a named import (or any opaque, non-generative import) is rejected.
 - You can also spread a local `defineToolkit(...)` or `defineMcpToolkit(...)` binding declared in the same file.
 
+The compiler checks static tool names across inline entries and compiler-visible
+spreads. If two fragments define the same tool name, the build warns that
+JavaScript object spread will keep the later tool definition.
+
 ### Add MCP server tools
 
 `defineMcpToolkit` exposes tools from an MCP server. For an MCP-only toolkit, export it directly: