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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/mcp-docs-server",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "MCP server for assistant-ui documentation and examples",
   "keywords": [
     "mcp",
@@ -34,13 +34,13 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "gray-matter": "^4.0.3",
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
-    "tsx": "^4.21.0",
-    "vitest": "^4.1.5",
-    "@assistant-ui/x-buildutils": "0.0.6"
+    "@types/node": "^25.9.1",
+    "tsx": "^4.22.3",
+    "vitest": "^4.1.7",
+    "@assistant-ui/x-buildutils": "0.0.9"
   },
   "publishConfig": {
     "access": "public",

package/src/tools/tests/path-traversal.test.ts

@@ -26,7 +26,7 @@ describe("Path Traversal Security", () => {
 
     it("should handle multiple paths with one malicious", async () => {
       const result = await testContext.callTool("assistantUIDocs", {
-        paths: ["(docs)/index", "../../../../etc/passwd", "(docs)/guides"],
+        paths: ["(docs)/index", "../../../../etc/passwd", "guides"],
       });
 
       expect(result.results).toBeDefined();

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

@@ -1,65 +0,0 @@
----
-title: Message Branching
-description: Navigate between different conversation branches when editing or reloading messages.
----
-
-import { BranchingSample } from "@/components/docs/samples/branching";
-
-Switch between different conversation branches.
-
-<BranchingSample />
-
-A new branch is created when:
-
-- a user message is edited
-- an assistant message is reloaded
-
-Branches are automatically tracked by assistant-ui by observing changes to the `messages` array.
-
-## Enabling branch support
-
-You can show a branch picker by using `BranchPickerPrimitive`.
-
-```tsx {1, 8, 15-30}
-import { BranchPickerPrimitive } from "@assistant-ui/react";
-
-
-const Message = () => {
-  return (
-    <MessagePrimitive.Root>
-      ...
-      <BranchPicker /> {/* <-- show the branch picker */}
-      ...
-    </MessagePrimitive.Root>
-  );
-};
-
-
-const BranchPicker = () => {
-  return (
-    <BranchPickerPrimitive.Root hideWhenSingleBranch>
-      <BranchPickerPrimitive.Previous />
-      <BranchPickerPrimitive.Number /> / <BranchPickerPrimitive.Count />
-      <BranchPickerPrimitive.Next />
-    </BranchPickerPrimitive.Root>
-  );
-};
-```
-
-## API
-
-You can access the current branch state or navigate via the API as well.
-These APIs rely on the message scope and may only be called inside a message component.
-
-```tsx
-import { useAui, useAuiState } from "@assistant-ui/react";
-
-// read branch state
-const { branchNumber, branchCount } = useAuiState((s) => s.message);
-
-// navigation
-const aui = useAui();
-aui.message().switchToBranch({ position: "next" });
-aui.message().switchToBranch({ position: "previous" });
-aui.message().switchToBranch({ branchId: "some-id" });
-```

package/.docs/raw/docs/(docs)/guides/chain-of-thought.mdx

@@ -1,164 +0,0 @@
----
-title: Chain of Thought
-description: Group reasoning and tool calls into a collapsible accordion UI.
----
-
-LLMs often produce reasoning steps and tool calls in succession. Chain of Thought lets you visually group these consecutive parts into a single collapsible accordion, giving users a clean "thinking" UI.
-
-## Overview
-
-When a model like OpenAI's `o4-mini` responds, it may emit a sequence of reasoning tokens and tool calls before producing its final text answer. By default, these parts render individually. `ChainOfThoughtPrimitive` groups consecutive reasoning + tool-call parts together and renders them through a single component.
-
-Key benefits:
-
-- **Cleaner UI** — Collapse intermediate steps behind a "Thinking" toggle
-- **Better context** — Users see that reasoning and tool calls are related
-- **Built-in accordion** — Expand/collapse with a single click; collapsed by default
-
-## Quick Start
-
-<Steps>
-  <Step>
-
-### Pass a ChainOfThought component to MessagePrimitive.Parts
-
-`MessagePrimitive.Parts` accepts a `ChainOfThought` component. When provided, consecutive reasoning and tool-call parts are automatically grouped and rendered through it.
-
-```tsx
-import {
-  AuiIf,
-  ChainOfThoughtPrimitive,
-  MessagePrimitive,
-} from "@assistant-ui/react";
-import type { FC } from "react";
-
-const Reasoning: FC<{ text: string }> = ({ text }) => {
-  return (
-    <p className="whitespace-pre-wrap px-4 py-2 text-muted-foreground text-sm italic">
-      {text}
-    </p>
-  );
-};
-
-const ChainOfThought: FC = () => {
-  return (
-    <ChainOfThoughtPrimitive.Root className="my-2 rounded-lg border">
-      <ChainOfThoughtPrimitive.AccordionTrigger className="flex w-full cursor-pointer items-center gap-2 px-4 py-2 font-medium text-sm hover:bg-muted/50">
-        Thinking
-      </ChainOfThoughtPrimitive.AccordionTrigger>
-      <AuiIf condition={(s) => !s.chainOfThought.collapsed}>
-        <ChainOfThoughtPrimitive.Parts>
-          {({ part }) => {
-            if (part.type === "reasoning") return <Reasoning {...part} />;
-            if (part.type === "tool-call") return <ToolFallback {...part} />;
-            return null;
-          }}
-        </ChainOfThoughtPrimitive.Parts>
-      </AuiIf>
-    </ChainOfThoughtPrimitive.Root>
-  );
-};
-
-const AssistantMessage: FC = () => {
-  return (
-    <MessagePrimitive.Root>
-      <MessagePrimitive.Parts>
-        {({ part }) => {
-          if (part.type === "text") return <MarkdownText />;
-          return null;
-        }}
-      </MessagePrimitive.Parts>
-    </MessagePrimitive.Root>
-  );
-};
-```
-
-  </Step>
-  <Step>
-
-### Use a reasoning model
-
-Chain of Thought is most useful with models that produce reasoning tokens (e.g. OpenAI `o4-mini`). Here's an example backend route using the Vercel AI SDK:
-
-```tsx title="app/api/chat/route.ts"
-import { openai } from "@ai-sdk/openai";
-import { streamText, convertToModelMessages } from "ai";
-
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-
-  const result = streamText({
-    model: openai("o4-mini"),
-    messages: await convertToModelMessages(messages),
-  });
-
-  return result.toUIMessageStreamResponse();
-}
-```
-
-  </Step>
-</Steps>
-
-## API Reference
-
-### ChainOfThoughtPrimitive.Root
-
-Container element for the chain of thought group. Renders a `<div>`.
-
-### ChainOfThoughtPrimitive.AccordionTrigger
-
-A button that toggles the collapsed/expanded state. Collapsed by default.
-
-### ChainOfThoughtPrimitive.Parts
-
-Renders the grouped parts when expanded (nothing when collapsed).
-
-```tsx
-<AuiIf condition={(s) => !s.chainOfThought.collapsed}>
-  <ChainOfThoughtPrimitive.Parts>
-    {({ part }) => {
-      if (part.type === "reasoning") return <Reasoning {...part} />;
-      if (part.type === "tool-call") return <ToolFallback {...part} />;
-      return null;
-    }}
-  </ChainOfThoughtPrimitive.Parts>
-</AuiIf>
-```
-
-| Prop | Type | Description |
-| --- | --- | --- |
-| `components.Reasoning` | `FC<{ text: string }>` | Component to render reasoning parts |
-| `components.tools.Fallback` | `ToolCallMessagePartComponent` | Fallback component for tool-call parts |
-| `components.Layout` | `ComponentType<PropsWithChildren>` | Wrapper component around each rendered part when expanded |
-
-## Reading Collapsed State
-
-Use `AuiIf` to conditionally render based on the accordion state:
-
-```tsx
-import { AuiIf, ChainOfThoughtPrimitive } from "@assistant-ui/react";
-import { ChevronDownIcon, ChevronRightIcon } from "lucide-react";
-
-const ChainOfThoughtAccordionTrigger = () => {
-  return (
-    <ChainOfThoughtPrimitive.AccordionTrigger className="flex w-full cursor-pointer items-center gap-2 px-4 py-2 text-sm">
-      <AuiIf condition={(s) => s.chainOfThought.collapsed}>
-        <ChevronRightIcon className="size-4" />
-      </AuiIf>
-      <AuiIf condition={(s) => !s.chainOfThought.collapsed}>
-        <ChevronDownIcon className="size-4" />
-      </AuiIf>
-      Thinking
-    </ChainOfThoughtPrimitive.AccordionTrigger>
-  );
-};
-```
-
-## Full Example
-
-See the complete [with-chain-of-thought example](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-chain-of-thought) for a working implementation with tool calls and reasoning.
-
-## Related Guides
-
-- [Generative UI](/docs/guides/tool-ui) — Custom UI for tool calls
-- [Tools](/docs/guides/tools) — Defining and using tools

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

@@ -1,66 +0,0 @@
----
-title: Message Editing
-description: Allow users to edit their messages with custom editor interfaces.
----
-
-Give the user the ability to edit their message.
-
-## Enabling edit support
-
-You can show an editor interface by using `ComposerPrimitive`.
-
-```tsx {1-2,11,25,31-52}
-import { ComposerPrimitive, useAuiState } from "@assistant-ui/react";
-...
-
-const Thread = () => {
-  return (
-    <ThreadPrimitive.Root>
-      <ThreadPrimitive.Viewport>
-        ...
-        <ThreadPrimitive.Messages>
-          {({ message }) => {
-            // Show our new component during edit mode
-            return <MessageWithEditComposer />;
-          }}
-        </ThreadPrimitive.Messages>
-      </ThreadPrimitive.Viewport>
-      ...
-    </ThreadPrimitive.Root>
-  );
-};
-
-const UserMessage = () => {
-  return (
-    <MessagePrimitive.Root>
-      ...
-      <ActionBarPrimitive.Root>
-        ...
-        <ActionBarPrimitive.Edit /> {/* <-- add a button to enable edit mode */}
-      </ActionBarPrimitive.Root>
-    </MessagePrimitive.Root>
-  );
-};
-
-// define a wrapper component that handles both display and edit mode
-const MessageWithEditComposer = () => {
-  const isEditing = useAuiState((s) => s.composer.isEditing);
-  if (isEditing) return <EditComposer />;
-  return <UserMessage />;
-};
-
-// define the edit composer component
-const EditComposer = () => {
-  return (
-    // you can return a MessagePrimitive including a ComposerPrimitive, or only a ComposerPrimitive
-    <MessagePrimitive.Root>
-      ...
-      <ComposerPrimitive.Root>
-        <ComposerPrimitive.Input />
-        <ComposerPrimitive.Cancel />
-        <ComposerPrimitive.Send />
-      </ComposerPrimitive.Root>
-    </MessagePrimitive.Root>
-  );
-};
-```

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

@@ -1,38 +0,0 @@
----
-title: Text-to-Speech (Speech Synthesis)
-description: Read messages aloud with Web Speech API or custom TTS.
----
-
-import { SpeechSample } from "@/components/docs/samples/speech";
-
-assistant-ui supports text-to-speech via the `SpeechSynthesisAdapter` interface.
-
-<SpeechSample />
-
-## SpeechSynthesisAdapter
-
-Currently, the following speech synthesis adapters are supported:
-
-- `WebSpeechSynthesisAdapter`: Uses the browser's `Web Speech API`
-
-Support for other speech synthesis adapters is planned for the future.
-
-Passing a `SpeechSynthesisAdapter` to the runtime will enable text-to-speech support.
-
-## UI
-
-The default action bar does not include a speech button. You need to add `ActionBarPrimitive.Speak` and `ActionBarPrimitive.StopSpeaking` to your assistant message action bar manually. See the example above for a complete implementation.
-
-## Example
-
-The following example uses the `WebSpeechSynthesisAdapter`.
-
-```tsx
-import { WebSpeechSynthesisAdapter } from "@assistant-ui/react";
-
-const runtime = useChatRuntime({
-  adapters: {
-    speech: new WebSpeechSynthesisAdapter(),
-  },
-});
-```

package/.docs/raw/docs/(reference)/api-reference/context-providers/text-message-part-provider.mdx

@@ -1,40 +0,0 @@
----
-title: <TextMessagePartProvider />
-description: Context provider for reusing text components outside of message content.
----
-
-The `TextMessagePartProvider` provides data and APIs for `TextMessagePart` components.
-
-This is useful if you want to reuse the same `Text` component outside of a message text, e.g. with the `@assistant-ui/react-markdown` package.
-
-```tsx
-import { TextMessagePartProvider } from "@assistant-ui/react";
-
-const MyApp = () => {
-  return (
-    <TextMessagePartProvider text={"Hello!"}>
-      <MyMarkdownText />
-    </TextMessagePartProvider>
-  );
-};
-```
-
-#### Properties
-
-<ParametersTable
-  type="TextMessagePartProviderProps"
-  parameters={[
-    {
-      name: "text",
-      type: "string",
-      required: true,
-      description: "The text content to provide to child components.",
-    },
-    {
-      name: "isRunning",
-      type: "boolean",
-      required: false,
-      description: "Whether the text is still being streamed. Defaults to false.",
-    },
-  ]}
-/>

package/.docs/raw/docs/(reference)/api-reference/integrations/react-data-stream.mdx

@@ -1,260 +0,0 @@
----
-title: "@assistant-ui/react-data-stream"
-description: Hooks for connecting to data stream protocol endpoints and Assistant Cloud.
----
-
-Data Stream protocol integration for assistant-ui.
-
-
-## API Reference
-
-### `useDataStreamRuntime`
-
-Create a runtime that connects to a data stream protocol endpoint.
-
-```tsx
-import { useDataStreamRuntime } from "@assistant-ui/react-data-stream";
-
-const MyRuntimeProvider = ({ children }: { children: React.ReactNode }) => {
-  const runtime = useDataStreamRuntime({
-    api: "/api/chat",
-  });
-
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      {children}
-    </AssistantRuntimeProvider>
-  );
-};
-```
-
-<ParametersTable
-  parameters={[
-    {
-      name: "api",
-      type: "string",
-      description: "The API endpoint URL for the data stream protocol.",
-    },
-    {
-      name: "protocol",
-      type: '"ui-message-stream" | "data-stream"',
-      description: 'The streaming protocol to use. Defaults to "ui-message-stream". Use "data-stream" for legacy AI SDK compatibility.',
-    },
-    {
-      name: "onData",
-      type: "(data: { type: string; name: string; data: unknown; transient?: boolean }) => void",
-      description: "Optional callback for data-* parts. Only applies when using the ui-message-stream protocol.",
-    },
-    {
-      name: "onResponse",
-      type: "(response: Response) => void | Promise<void>",
-      description: "Optional callback called when a response is received.",
-    },
-    {
-      name: "onFinish",
-      type: "(message: ThreadMessage) => void",
-      description: "Optional callback called when a message is finished.",
-    },
-    {
-      name: "onError",
-      type: "(error: Error) => void",
-      description: "Optional callback called when an error occurs.",
-    },
-    {
-      name: "onCancel",
-      type: "() => void",
-      description: "Optional callback called when a request is cancelled.",
-    },
-    {
-      name: "credentials",
-      type: "RequestCredentials",
-      description: "Optional credentials mode for the fetch request.",
-    },
-    {
-      name: "headers",
-      type: "Record<string, string> | Headers | (() => Promise<Record<string, string> | Headers>)",
-      description: "Optional headers to include in the request.",
-    },
-    {
-      name: "body",
-      type: "object | (() => Promise<object | undefined>)",
-      description: "Optional additional body parameters to include in the request. Can be an object or an async function that returns one.",
-    },
-    {
-      name: "sendExtraMessageFields",
-      type: "boolean",
-      description: "Whether to include extra message fields like IDs in the request.",
-    },
-  ]}
-/>
-
-### `useCloudRuntime`
-
-Create a runtime that connects to Assistant Cloud using the data stream protocol.
-
-```tsx
-import { useCloudRuntime } from "@assistant-ui/react-data-stream";
-
-const MyRuntimeProvider = ({ children }: { children: React.ReactNode }) => {
-  const runtime = useCloudRuntime({
-    cloud: assistantCloud,
-    assistantId: "my-assistant-id",
-  });
-
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      {children}
-    </AssistantRuntimeProvider>
-  );
-};
-```
-
-<ParametersTable
-  parameters={[
-    {
-      name: "cloud",
-      type: "AssistantCloud",
-      description: "The Assistant Cloud instance.",
-    },
-    {
-      name: "assistantId",
-      type: "string",
-      description: "The ID of the assistant to connect to.",
-    },
-    {
-      name: "protocol",
-      type: '"ui-message-stream" | "data-stream"',
-      description: 'The streaming protocol to use. Defaults to "ui-message-stream". Use "data-stream" for legacy AI SDK compatibility.',
-    },
-    {
-      name: "onData",
-      type: "(data: { type: string; name: string; data: unknown; transient?: boolean }) => void",
-      description: "Optional callback for data-* parts. Only applies when using the ui-message-stream protocol.",
-    },
-    {
-      name: "onResponse",
-      type: "(response: Response) => void | Promise<void>",
-      description: "Optional callback called when a response is received.",
-    },
-    {
-      name: "onFinish",
-      type: "(message: ThreadMessage) => void",
-      description: "Optional callback called when a message is finished.",
-    },
-    {
-      name: "onError",
-      type: "(error: Error) => void",
-      description: "Optional callback called when an error occurs.",
-    },
-    {
-      name: "onCancel",
-      type: "() => void",
-      description: "Optional callback called when a request is cancelled.",
-    },
-    {
-      name: "credentials",
-      type: "RequestCredentials",
-      description: "Optional credentials mode for the fetch request.",
-    },
-    {
-      name: "headers",
-      type: "Record<string, string> | Headers | (() => Promise<Record<string, string> | Headers>)",
-      description: "Optional headers to include in the request.",
-    },
-    {
-      name: "body",
-      type: "object | (() => Promise<object | undefined>)",
-      description: "Optional additional body parameters to include in the request. Can be an object or an async function that returns one.",
-    },
-    {
-      name: "sendExtraMessageFields",
-      type: "boolean",
-      description: "Whether to include extra message fields like IDs in the request.",
-    },
-  ]}
-/>
-
-### `toLanguageModelMessages`
-
-Convert assistant-ui messages to AI SDK's `LanguageModelV2Message` format.
-
-<Callout type="info">
-For custom integrations, consider using `toGenericMessages` from `assistant-stream` instead.
-This function is specific to the AI SDK format.
-</Callout>
-
-```tsx
-import { toLanguageModelMessages } from "@assistant-ui/react-data-stream";
-
-const languageModelMessages = toLanguageModelMessages(messages, {
-  unstable_includeId: true,
-});
-```
-
-<ParametersTable
-  parameters={[
-    {
-      name: "messages",
-      type: "readonly ThreadMessage[]",
-      description: "The messages to convert.",
-    },
-    {
-      name: "options",
-      type: "{ unstable_includeId?: boolean }",
-      description: "Optional conversion options.",
-      children: [
-        {
-          type: "{ unstable_includeId?: boolean }",
-          parameters: [
-            {
-              name: "unstable_includeId",
-              type: "boolean",
-              description: "Whether to include message IDs in the converted messages.",
-            },
-          ],
-        },
-      ],
-    },
-  ]}
-/>
-
----
-
-## Framework-Agnostic Utilities
-
-For custom integrations that don't use the AI SDK, use these utilities from `assistant-stream`:
-
-### `toGenericMessages`
-
-Convert thread messages to a framework-agnostic format.
-
-```tsx
-import { toGenericMessages } from "assistant-stream";
-
-const genericMessages = toGenericMessages(messages);
-```
-
-Returns an array of `GenericMessage` which can be one of:
-- `{ role: "system"; content: string }`
-- `{ role: "user"; content: (GenericTextPart | GenericFilePart)[] }`
-- `{ role: "assistant"; content: (GenericTextPart | GenericToolCallPart)[] }`
-- `{ role: "tool"; content: GenericToolResultPart[] }`
-
-### `toToolsJSONSchema`
-
-Convert tool definitions to JSON Schema format.
-
-```tsx
-import { toToolsJSONSchema } from "assistant-stream";
-
-const toolSchemas = toToolsJSONSchema(tools);
-// Returns: Record<string, { description?: string; parameters: JSONSchema7 }>
-```
-
-By default, filters out disabled tools and backend-only tools. Use the `filter` option to customize:
-
-```tsx
-const allTools = toToolsJSONSchema(tools, {
-  filter: () => true, // Include all tools
-});
-```