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

package/.docs/organized/code-examples/with-react-ink.md

@@ -17,10 +17,10 @@
     "@assistant-ui/react-ink": "workspace:*",
     "@assistant-ui/react-ink-markdown": "workspace:*",
     "ink": "^7.0.5",
-    "react": "^19.2.6"
+    "react": "^19.2.7"
   },
   "devDependencies": {
-    "@types/react": "^19.2.15",
+    "@types/react": "^19.2.17",
     "esbuild": "^0.28.0",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3"
@@ -37,74 +37,36 @@ import { Box, Text } from "ink";
 import {
   AssistantRuntimeProvider,
   useLocalRuntime,
-  type ChatModelAdapter,
+  StatusBarPrimitive,
 } from "@assistant-ui/react-ink";
 import { Thread } from "./components/thread.js";
-
-const createDemoAdapter = (): ChatModelAdapter => ({
-  async *run({ messages }) {
-    const lastUserMessage = messages.filter((m) => m.role === "user").at(-1);
-
-    const userText =
-      lastUserMessage?.content
-        .filter((p) => p.type === "text")
-        .map((p) => ("text" in p ? p.text : ""))
-        .join("") ?? "";
-
-    // Simulate streaming with a markdown-rich response
-    const response = `## Response to your question
-
-You asked: **"${userText}"**
-
-Here's a quick example in JavaScript:
-
-\`\`\`js
-const promise = new Promise((resolve, reject) => {
-  setTimeout(() => resolve("done!"), 1000);
-});
-
-promise.then(result => console.log(result));
-\`\`\`
-
-### Key points
-
-- A \`Promise\` represents an **async operation**
-- It can be *pending*, *fulfilled*, or *rejected*
-- Use \`.then()\` and \`.catch()\` to handle results
-
-> Promises are the foundation of modern async JavaScript.
-
-| Method | Purpose |
-|--------|---------|
-| \`.then()\` | Handle success |
-| \`.catch()\` | Handle errors |
-| \`.finally()\` | Run cleanup |
-
-Learn more at [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).`;
-    const words = response.split(" ");
-
-    let accumulated = "";
-    for (const word of words) {
-      accumulated += (accumulated ? " " : "") + word;
-      yield { content: [{ type: "text" as const, text: accumulated }] };
-      await new Promise((r) => setTimeout(r, 50));
-    }
-  },
-});
+import { createScriptedAdapter, MODEL_NAME } from "./scripted-adapter.js";
+import { ApplyPatchToolUI } from "./tools.js";
+
+const StatusBar = () => (
+  <StatusBarPrimitive.Root>
+    <Text dimColor>
+      model: <StatusBarPrimitive.ModelName name={MODEL_NAME} /> ·{" "}
+      <StatusBarPrimitive.MessageCount /> · <StatusBarPrimitive.Status />
+    </Text>
+  </StatusBarPrimitive.Root>
+);
 
 export const App = () => {
-  const adapter = useMemo(() => createDemoAdapter(), []);
+  const adapter = useMemo(() => createScriptedAdapter(), []);
   const runtime = useLocalRuntime(adapter);
 
   return (
     <AssistantRuntimeProvider runtime={runtime}>
+      <ApplyPatchToolUI />
       <Box flexDirection="column" padding={1}>
-        <Text bold color="cyan">
-          assistant-ui Terminal Chat
-        </Text>
-        <Text dimColor>
-          Type a message and press Enter to send. Ctrl+C to exit.
-        </Text>
+        <Box>
+          <Text bold color="cyan">
+            demo-agent
+          </Text>
+          <Text dimColor>{"  ~/acme-app"}</Text>
+        </Box>
+        <StatusBar />
         <Box marginTop={1}>
           <Thread />
         </Box>
@@ -122,62 +84,68 @@ import { Box, Text } from "ink";
 import {
   ThreadPrimitive,
   ComposerPrimitive,
-  useAuiState,
+  MessagePrimitive,
+  ErrorPrimitive,
+  LoadingPrimitive,
+  LiveChecklist,
 } from "@assistant-ui/react-ink";
 import { MarkdownText } from "@assistant-ui/react-ink-markdown";
 
-const UserMessage = () => {
-  const text = useAuiState((s) =>
-    s.message.parts
-      .filter((p) => p.type === "text")
-      .map((p) => ("text" in p ? p.text : ""))
-      .join(""),
-  );
-
-  return (
+const UserMessage = () => (
+  <MessagePrimitive.Root>
     <Box marginBottom={1}>
       <Text bold color="green">
         You:{" "}
       </Text>
-      <Text wrap="wrap">{text}</Text>
+      <MessagePrimitive.Content
+        renderText={({ part }) => <Text wrap="wrap">{part.text}</Text>}
+      />
     </Box>
-  );
-};
+  </MessagePrimitive.Root>
+);
 
-const AssistantMessage = () => {
-  const text = useAuiState((s) =>
-    s.message.parts
-      .filter((p) => p.type === "text")
-      .map((p) => ("text" in p ? p.text : ""))
-      .join(""),
-  );
-
-  return (
+const AssistantMessage = () => (
+  <MessagePrimitive.Root>
     <Box flexDirection="column" marginBottom={1}>
       <Text bold color="blue">
         AI:
       </Text>
-      <MarkdownText text={text} />
+      <MessagePrimitive.Content
+        renderText={({ part }) => <MarkdownText text={part.text} />}
+        renderReasoning={({ part }) => (
+          <Text dimColor italic>
+            {part.text}
+          </Text>
+        )}
+      />
+      <LiveChecklist title="Plan" showProgress marginTop={1} />
+      <ErrorPrimitive.Root>
+        <ErrorPrimitive.Message />
+      </ErrorPrimitive.Root>
     </Box>
-  );
-};
-
-const StatusIndicator = () => {
-  const isRunning = useAuiState((s) => s.thread.isRunning);
-  if (!isRunning) return null;
-  return (
-    <Box marginBottom={1}>
-      <Text color="yellow">Thinking...</Text>
-    </Box>
-  );
-};
+  </MessagePrimitive.Root>
+);
+
+const Loading = () => (
+  <LoadingPrimitive.Root marginBottom={1}>
+    <LoadingPrimitive.Spinner />
+    <Text> </Text>
+    <LoadingPrimitive.Text>Working</LoadingPrimitive.Text>
+    <Text> </Text>
+    <LoadingPrimitive.ElapsedTime />
+  </LoadingPrimitive.Root>
+);
 
 export const Thread = () => {
   return (
     <ThreadPrimitive.Root>
       <ThreadPrimitive.Empty>
-        <Box marginBottom={1}>
-          <Text dimColor>No messages yet. Start typing below!</Text>
+        <Box flexDirection="column" marginBottom={1}>
+          <Text>
+            Working in this project. <Text color="yellow">fetchUser()</Text> is
+            flaky in prod and has no retry logic.
+          </Text>
+          <Text dimColor>{'  try: "make fetchUser retry on failure"'}</Text>
         </Box>
       </ThreadPrimitive.Empty>
 
@@ -187,13 +155,14 @@ export const Thread = () => {
         }
       </ThreadPrimitive.Messages>
 
-      <StatusIndicator />
+      <Loading />
 
       <Box borderStyle="round" borderColor="gray" paddingX={1}>
         <Text color="gray">{"> "}</Text>
         <ComposerPrimitive.Input
           submitOnEnter
-          placeholder="Type a message..."
+          multiLine
+          placeholder="Type a message... (Enter to send)"
           autoFocus
         />
       </Box>
@@ -242,6 +211,232 @@ render(<App />);
 
 ```
 
+## src/scripted-adapter.ts
+
+```typescript
+import type {
+  ChatModelAdapter,
+  ThreadAssistantMessagePart,
+} from "@assistant-ui/react-ink";
+
+export const MODEL_NAME = "demo-agent";
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+const RETRY_PATCH = `--- a/src/retry.ts
++++ b/src/retry.ts
+@@ -1,6 +1,18 @@
+ export async function fetchUser(id: string) {
+-  const res = await fetch(\`/api/users/\${id}\`);
+-  return res.json();
++  return retry(() => fetch(\`/api/users/\${id}\`).then((r) => r.json()));
++}
++
++export async function retry<T>(fn: () => Promise<T>, attempts = 3): Promise<T> {
++  let lastError: unknown;
++  for (let i = 0; i <= attempts; i++) {
++    try {
++      return await fn();
++    } catch (err) {
++      lastError = err;
++      await new Promise((r) => setTimeout(r, 2 ** i * 100));
++    }
++  }
++  throw lastError;
+ }
+`;
+
+const RETRY_PATCH_FIX = `--- a/src/retry.ts
++++ b/src/retry.ts
+@@ -6,7 +6,7 @@ export async function retry<T>(fn: () => Promise<T>, attempts = 3): Promise<T> {
+   let lastError: unknown;
+-  for (let i = 0; i <= attempts; i++) {
++  for (let i = 0; i < attempts; i++) {
+     try {
+       return await fn();
+     } catch (err) {
+`;
+
+const isTaskRequest = (text: string) =>
+  /fetch|retry|resilient|flaky|backoff|robust|network|\byes\b|sure|\bok\b|go ahead|do it|please/i.test(
+    text,
+  );
+
+const lastUserText = (
+  messages: readonly { role: string; content: readonly { type: string }[] }[],
+) => {
+  const last = messages.filter((m) => m.role === "user").at(-1);
+  return (
+    last?.content
+      .filter((p): p is { type: "text"; text: string } => p.type === "text")
+      .map((p) => p.text)
+      .join("") ?? ""
+  );
+};
+
+async function* streamText(
+  parts: ThreadAssistantMessagePart[],
+  index: number,
+  text: string,
+  delay: number,
+): AsyncGenerator<{ content: ThreadAssistantMessagePart[] }> {
+  for (const word of text.split(" ")) {
+    const p = parts[index] as Extract<
+      ThreadAssistantMessagePart,
+      { type: "text" | "reasoning" }
+    >;
+    parts[index] = { ...p, text: p.text ? `${p.text} ${word}` : word };
+    yield { content: [...parts] };
+    await sleep(delay);
+  }
+}
+
+async function* runAgentScript(): AsyncGenerator<{
+  content: ThreadAssistantMessagePart[];
+}> {
+  const parts: ThreadAssistantMessagePart[] = [];
+  const emit = () => ({ content: [...parts] });
+  const setResult = (result: unknown, isError = false) => {
+    parts[parts.length - 1] = {
+      ...parts[parts.length - 1],
+      result,
+      ...(isError ? { isError: true } : {}),
+    } as ThreadAssistantMessagePart;
+  };
+  const pushToolCall = (
+    toolCallId: string,
+    toolName: string,
+    args: Record<string, string>,
+  ) =>
+    parts.push({
+      type: "tool-call",
+      toolCallId,
+      toolName,
+      args,
+      argsText: JSON.stringify(args),
+    });
+
+  const reasoningIdx = parts.push({ type: "reasoning", text: "" }) - 1;
+  yield* streamText(
+    parts,
+    reasoningIdx,
+    "Let me look at how fetchUser is implemented, wrap it in retry-with-backoff, and run the tests to make sure it holds up.",
+    20,
+  );
+
+  pushToolCall("read-1", "read_file", { path: "src/retry.ts" });
+  yield emit();
+  await sleep(500);
+  setResult("12 lines read");
+  yield emit();
+  await sleep(300);
+
+  pushToolCall("patch-1", "apply_patch", {
+    path: "src/retry.ts",
+    patch: RETRY_PATCH,
+  });
+  yield emit();
+  await sleep(600);
+  setResult({ applied: true });
+  yield emit();
+  await sleep(300);
+
+  pushToolCall("test-1", "run_tests", { command: "pnpm test retry" });
+  yield emit();
+  await sleep(700);
+  setResult(
+    "FAIL src/retry.test.ts - retry() ran 4 times, expected 3 (off-by-one in loop bound)",
+    true,
+  );
+  yield emit();
+  await sleep(400);
+
+  const noteIdx = parts.push({ type: "text", text: "" }) - 1;
+  yield* streamText(
+    parts,
+    noteIdx,
+    "The loop bound was off by one. Tightening it and re-running.",
+    20,
+  );
+
+  pushToolCall("patch-2", "apply_patch", {
+    path: "src/retry.ts",
+    patch: RETRY_PATCH_FIX,
+  });
+  yield emit();
+  await sleep(500);
+  setResult({ applied: true });
+  yield emit();
+  await sleep(300);
+
+  pushToolCall("test-2", "run_tests", { command: "pnpm test retry" });
+  yield emit();
+  await sleep(600);
+  setResult("PASS src/retry.test.ts (3 passed)");
+  yield emit();
+  await sleep(300);
+
+  const summary = `### Done
+
+Added a \`retry()\` helper and routed \`fetchUser\` through it:
+
+- exponential backoff (\`100ms\`, \`200ms\`, \`400ms\`)
+- rethrows the **last error** after exhausting attempts
+- fixed an off-by-one that ran one extra attempt
+
+Tests are green.`;
+  const summaryIdx = parts.push({ type: "text", text: "" }) - 1;
+  yield* streamText(parts, summaryIdx, summary, 15);
+}
+
+async function* runProposalReply(): AsyncGenerator<{
+  content: ThreadAssistantMessagePart[];
+}> {
+  const response = `I'm set up to work in this repo. The obvious thing to fix is the flaky \`fetchUser()\` call in \`src/retry.ts\` — it has no retry logic, so a single network blip fails the request.
+
+Want me to wrap it in retry-with-backoff? Just say *make fetchUser retry on failure*.`;
+  let acc = "";
+  for (const word of response.split(" ")) {
+    acc += (acc ? " " : "") + word;
+    yield { content: [{ type: "text", text: acc }] };
+    await sleep(20);
+  }
+}
+
+export const createScriptedAdapter = (): ChatModelAdapter => ({
+  run({ messages }) {
+    return isTaskRequest(lastUserText(messages))
+      ? runAgentScript()
+      : runProposalReply();
+  },
+});
+
+```
+
+## src/tools.tsx
+
+```tsx
+import { Box, Text } from "ink";
+import { makeAssistantToolUI, DiffView } from "@assistant-ui/react-ink";
+
+export const ApplyPatchToolUI = makeAssistantToolUI<
+  { path: string; patch: string },
+  unknown
+>({
+  toolName: "apply_patch",
+  render: ({ args }) => {
+    if (!args?.patch) return null;
+    return (
+      <Box flexDirection="column" marginBottom={1}>
+        <Text color="cyan">edit {args.path}</Text>
+        <DiffView patch={args.patch} showLineNumbers />
+      </Box>
+    );
+  },
+});
+
+```
+
 ## tsconfig.json
 
 ```json

package/.docs/organized/code-examples/with-react-router.md

@@ -773,30 +773,30 @@ export default function Home() {
   "dependencies": {
     "@assistant-ui/react": "workspace:*",
     "@assistant-ui/react-markdown": "workspace:*",
-    "@react-router/node": "^7.16.0",
-    "@react-router/serve": "^7.16.0",
+    "@react-router/node": "^7.17.0",
+    "@react-router/serve": "^7.17.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "eventsource-parser": "^3.1.0",
-    "isbot": "^5.1.40",
+    "isbot": "^5.1.41",
     "lucide-react": "^1.17.0",
-    "openai": "^6.39.1",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
-    "react-router": "^7.16.0",
+    "openai": "^6.42.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "react-router": "^7.17.0",
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.6.0"
   },
   "devDependencies": {
-    "@react-router/dev": "^7.16.0",
+    "@react-router/dev": "^7.17.0",
     "@tailwindcss/vite": "^4.3.0",
-    "@types/node": "^25.9.1",
-    "@types/react": "^19.2.15",
+    "@types/node": "^25.9.2",
+    "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "tailwindcss": "^4.3.0",
     "tw-animate-css": "^1.4.0",
     "typescript": "^6.0.3",
-    "vite": "^8.0.14",
+    "vite": "^8.0.16",
     "vite-tsconfig-paths": "^6.1.1"
   }
 }

package/.docs/organized/code-examples/with-resumable-stream.md

@@ -514,22 +514,22 @@ export default withAui(nextConfig);
     "start": "next start"
   },
   "dependencies": {
-    "@ai-sdk/openai": "^3.0.67",
-    "@ai-sdk/react": "^3.0.195",
+    "@ai-sdk/openai": "^3.0.68",
+    "@ai-sdk/react": "^3.0.199",
     "@assistant-ui/react": "workspace:*",
     "@assistant-ui/react-ai-sdk": "workspace:*",
     "@assistant-ui/react-markdown": "workspace:*",
     "@assistant-ui/store": "workspace:*",
     "@assistant-ui/tap": "workspace:*",
     "@assistant-ui/ui": "workspace:*",
-    "ai": "^6.0.193",
+    "ai": "^6.0.197",
     "assistant-stream": "workspace:*",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react": "^1.17.0",
-    "next": "^16.2.6",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
+    "next": "^16.2.7",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
     "redis": "^6.0.0",
     "tailwind-merge": "^3.6.0",
     "zod": "^4.4.3"
@@ -538,8 +538,8 @@ export default withAui(nextConfig);
     "@assistant-ui/next": "workspace:*",
     "@assistant-ui/x-buildutils": "workspace:*",
     "@tailwindcss/postcss": "^4.3.0",
-    "@types/node": "^25.9.1",
-    "@types/react": "^19.2.15",
+    "@types/node": "^25.9.2",
+    "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "postcss": "^8.5.15",
     "tailwindcss": "^4.3.0",