@assistant-ui/mcp-docs-server 0.1.23 → 0.1.25

package/.docs/raw/docs/(reference)/api-reference/runtimes/thread-list-runtime.mdx

@@ -5,28 +5,48 @@ description: Runtime for accessing and managing the list of threads.
 
 import { ThreadListRuntime, ThreadListState } from "@/generated/typeDocs";
 
-### Access via `useAssistantRuntime`
+### `useAui` (Thread List Actions)
 
-You can access the thread list runtime via the assistant runtime:
+Access thread list actions via `useAui`:
 
 ```tsx
-import { useAssistantRuntime } from "@assistant-ui/react";
+import { useAui } from "@assistant-ui/react";
 
-const threadListRuntime = useAssistantRuntime().threadList;
+const aui = useAui();
+
+// Switch threads
+await aui.threads().switchToNewThread();
+await aui.threads().switchToThread(threadId);
+
+// Access the main thread runtime
+const mainThread = aui.threads().main;
+
+// Access a thread by ID
+const thread = aui.threads().getById(threadId);
+
+// Access thread list items
+const mainItem = aui.threads().mainItem;
+const itemByIndex = aui.threads().getItemByIndex(0);
+const itemById = aui.threads().getItemById(threadId);
+const archivedItem = aui.threads().getArchivedItemByIndex(0);
+
+// Get current state
+const state = aui.threads().getState();
+const threadIds = state.threadIds;
+const archivedThreadIds = state.archivedThreadIds;
 ```
 
 <ParametersTable {...ThreadListRuntime} />
 
-### `useThreadList`
+### `useAuiState` (Thread List State)
 
-This hook provides access to the thread list state:
+Access thread list state reactively:
 
 ```tsx
-import { useThreadList } from "@assistant-ui/react";
+import { useAuiState } from "@assistant-ui/react";
 
-const threadList = useThreadList();
-const threads = useThreadList((m) => m.threads);
-const isLoading = useThreadList((m) => m.isLoading);
+const threads = useAuiState((s) => s.threads.threadIds);
+const isLoading = useAuiState((s) => s.threads.isLoading);
 ```
 
 <ParametersTable {...ThreadListState} />

package/.docs/raw/docs/(reference)/api-reference/runtimes/thread-runtime.mdx

@@ -6,28 +6,30 @@ description: Runtime for thread state, messages, and viewport management.
 import { ThreadRuntime, ThreadState } from "@/generated/typeDocs";
 import { ThreadViewportState } from "@/components/docs/parameters-table.context";
 
-### `useThreadRuntime`
+### `useAui` (Thread Actions)
 
-Get the thread runtime object:
+Access thread actions via `useAui`:
 
 ```tsx
-import { useThreadRuntime } from "@assistant-ui/react";
+import { useAui } from "@assistant-ui/react";
 
-const thread = useThreadRuntime();
+const aui = useAui();
+aui.thread().cancelRun();
+aui.thread().append({ role: "user", content: [{ type: "text", text: "Hello" }] });
 ```
 
 <ParametersTable {...ThreadRuntime} />
 
-### `useThread`
+### `useAuiState` (Thread State)
 
-Access the thread state directly:
+Access the thread state reactively:
 
 ```tsx
-import { useThread } from "@assistant-ui/react";
+import { useAuiState } from "@assistant-ui/react";
 
-const thread = useThread();
-const isRunning = useThread((m) => m.isRunning);
-const isLoading = useThread((m) => m.isLoading);
+const isRunning = useAuiState((s) => s.thread.isRunning);
+const isLoading = useAuiState((s) => s.thread.isLoading);
+const messages = useAuiState((s) => s.thread.messages);
 ```
 
 <ParametersTable {...ThreadState} />

package/.docs/raw/docs/(reference)/migrations/deprecation-policy.mdx

@@ -24,7 +24,7 @@ These features may be removed at any time without notice.
 
 A deprecation of these features will undergo a short (<1) month deprecation notice period.
 
-- TailwindCSS Plugins (e.g. `@assistant-ui/react-ui/tailwindcss`)
+- TailwindCSS Plugins (e.g. `tw-shimmer`, `tw-glass`)
 - Context API
 - Runtime API
 - Message types

package/.docs/raw/docs/(reference)/migrations/react-langgraph-v0-7.mdx

@@ -136,6 +136,7 @@ export function MyRuntimeProvider({ children }) {
   const cloud = useMemo(
     () => new AssistantCloud({
       baseUrl: process.env.NEXT_PUBLIC_ASSISTANT_BASE_URL,
+      anonymous: true,
     }),
     []
   );
@@ -198,16 +199,20 @@ type NewLangGraphRuntimeOptions = {
   cloud?: AssistantCloud;
   stream: (
     messages: Message[],
-    context: {
+    config: {
+      abortSignal: AbortSignal;
       initialize: () => Promise<{
         remoteId: string;
         externalId: string | undefined;
-      }>
+      }>;
+      command?: { resume: string };
+      runConfig?: unknown;
+      checkpointId?: string;
     }
   ) => AsyncGenerator;
   create?: () => Promise<{ externalId: string }>;
-  load?: (externalId: string) => Promise<ThreadState>;
-  delete?: (externalId: string) => Promise<void>;
+  load?: (threadId: string) => Promise<ThreadState>;
+  delete?: (threadId: string) => Promise<void>;
 };
 ```
 

package/.docs/raw/docs/(reference)/migrations/v0-11.mdx

@@ -42,7 +42,7 @@ The following types and components have been renamed:
 - `useContentPartSource` → `useMessagePartSource`
 - `useContentPartFile` → `useMessagePartFile`
 - `useContentPartImage` → `useMessagePartImage`
-- `useTextContentPart` → `useTextMessagePart`
+- `useTextContentPart` → `useMessagePartText`
 
 #### Component Types
 
@@ -87,7 +87,9 @@ The `MessagePrimitive.Content` component has been renamed to `MessagePrimitive.P
 
 ```diff
 -<MessagePrimitive.Content components={{ Text: MyText }} />
-+<MessagePrimitive.Parts components={{ Text: MyText }} />
++<MessagePrimitive.Parts>
++  {({ part }) => part.type === "text" ? <MyText {...part} /> : null}
++</MessagePrimitive.Parts>
 ```
 
 ### Migration
@@ -96,13 +98,13 @@ To migrate your codebase automatically, use the migration codemod:
 
 ```sh
 # IMPORTANT: make sure to commit all changes to git / create a backup before running the codemod
-npx @assistant-ui/cli upgrade
+npx assistant-ui@latest upgrade
 ```
 
 Or run the specific migration:
 
 ```sh
-npx @assistant-ui/cli codemod v0-11/content-part-to-message-part .
+npx assistant-ui@latest codemod v0-11/content-part-to-message-part .
 ```
 
 #### Manual Migration Examples
@@ -167,4 +169,4 @@ If you prefer to migrate manually, here are some examples:
 
 The ContentPart naming was inconsistent with the rest of the codebase, where "message parts" are used throughout. This change improves semantic clarity and makes the API more intuitive by aligning terminology across the entire library.
 
-The old ContentPart APIs continue to work but are now deprecated and will be removed in a future major version.
+The old ContentPart APIs have been completely removed. You must update all references to use the new MessagePart names.

package/.docs/raw/docs/(reference)/migrations/v0-12.mdx

@@ -26,6 +26,7 @@ The core hooks have been renamed for consistency and clarity:
 - `useAssistantApi` → `useAui`
 - `useAssistantState` → `useAuiState`
 - `useAssistantEvent` → `useAuiEvent`
+- `AssistantIf` → `AuiIf`
 
 The variable naming convention has also changed from `api` to `aui`.
 
@@ -44,8 +45,8 @@ function MyComponent() {
   const api = useAssistantApi();
   const isRunning = useAssistantState(({ thread }) => thread.isRunning);
 
-  useAssistantEvent("thread.started", () => {
-    console.log("Thread started");
+  useAssistantEvent("thread.run-start", () => {
+    console.log("Thread started running");
   });
 
   const handleSend = () => {
@@ -65,8 +66,8 @@ function MyComponent() {
   const aui = useAui();
   const isRunning = useAuiState((s) => s.thread.isRunning);
 
-  useAuiEvent("thread.started", () => {
-    console.log("Thread started");
+  useAuiEvent("thread.runStart", () => {
+    console.log("Run started");
   });
 
   const handleSend = () => {
@@ -118,8 +119,8 @@ The following hooks have been removed:
 
 - `useMessageUtils` → Use `useAuiState((s) => s.message.isHovering)` / `useAuiState((s) => s.message.isCopied)`
 - `useMessageUtilsStore` → Use `useAui()` with `aui.message().setIsHovering()` / `aui.message().setIsCopied()`
-- `useToolUIs` → Use `useAuiState((s) => s.tools)` and `useAui()` with `aui.tools()`
-- `useToolUIsStore` → Use `useAui()` with `aui.tools()`
+- `useToolUIs` → Removed with no direct equivalent. Use `useAssistantTool` / `makeAssistantToolUI` to register tool UIs instead.
+- `useToolUIsStore` → Removed with no direct equivalent.
 
 **Deprecated Hooks:**
 
@@ -137,7 +138,8 @@ The following hooks have been removed:
 - `useMessagePartRuntime` → Use `useAui()` with `aui.part()`
 - `useAttachment` → Use `useAuiState((s) => s.attachment)`
 - `useAttachmentRuntime` → Use `useAui()` with `aui.attachment()`
-- `useThreadModelContext` / `useThreadModelConfig` → Use `useAuiState((s) => s.thread.modelContext)`
+- `useThreadModelContext` → Use `useAuiState((s) => s.thread.modelContext)`
+- `useThreadModelConfig` → Removed. Use `useAui().thread().getModelContext()` instead.
 - `useThreadComposer` → Use `useAuiState((s) => s.thread.composer)`
 - `useThreadList` → Use `useAuiState((s) => s.threads)`
 

package/.docs/raw/docs/(reference)/migrations/v0-14.mdx

@@ -0,0 +1,159 @@
+---
+title: Migration to v0.14
+description: Primitives migrate from components prop to children render functions.
+---
+
+## Children API for Primitives
+
+Version 0.14 replaces the `components` prop on primitives with a children render function pattern. This gives you full control over rendering with simple inline logic.
+
+### ThreadPrimitive.Messages
+
+**Before:**
+
+```tsx
+<ThreadPrimitive.Messages
+  components={{
+    UserMessage,
+    EditComposer,
+    AssistantMessage,
+  }}
+/>
+```
+
+**After:**
+
+```tsx
+<ThreadPrimitive.Messages>
+  {({ message }) => {
+    if (message.composer.isEditing) return <EditComposer />;
+    if (message.role === "user") return <UserMessage />;
+    return <AssistantMessage />;
+  }}
+</ThreadPrimitive.Messages>
+```
+
+### MessagePrimitive.Parts
+
+**Before:**
+
+```tsx
+<MessagePrimitive.Parts
+  components={{
+    Text: MarkdownText,
+    Reasoning,
+    tools: { Fallback: ToolFallback },
+  }}
+/>
+```
+
+**After:**
+
+```tsx
+<MessagePrimitive.Parts>
+  {({ part }) => {
+    if (part.type === "text") return <MarkdownText />;
+    if (part.type === "reasoning") return <Reasoning {...part} />;
+    if (part.type === "tool-call")
+      return part.toolUI ?? <ToolFallback {...part} />;
+    return null;
+  }}
+</MessagePrimitive.Parts>
+```
+
+### `part.toolUI` and `part.dataRendererUI`
+
+Tool-call parts now expose a `toolUI` property that resolves to the registered tool UI (via `useAssistantToolUI` / `makeAssistantToolUI`) or `null` if none is registered. Data parts similarly expose `dataRendererUI`.
+
+```tsx
+// Renders the registered tool UI if available, otherwise ToolFallback
+if (part.type === "tool-call")
+  return part.toolUI ?? <ToolFallback {...part} />;
+
+// Renders the registered data renderer if available
+if (part.type === "data")
+  return part.dataRendererUI ?? null;
+```
+
+### Returning `null`
+
+Returning `null` from the children function renders registered tool UIs and data renderer UIs automatically via the registry. To explicitly render nothing (suppressing registered UIs), return `<></>`.
+
+```tsx
+<MessagePrimitive.Parts>
+  {({ part }) => {
+    if (part.type === "text") return <MarkdownText />;
+    return null; // registered tool/data UIs still render
+  }}
+</MessagePrimitive.Parts>
+```
+
+### ThreadPrimitive.Suggestions
+
+**Before:**
+
+```tsx
+<ThreadPrimitive.Suggestions
+  components={{ Suggestion: SuggestionItem }}
+/>
+```
+
+**After:**
+
+```tsx
+<ThreadPrimitive.Suggestions>
+  {() => <SuggestionItem />}
+</ThreadPrimitive.Suggestions>
+```
+
+### ThreadListPrimitive.Items
+
+**Before:**
+
+```tsx
+<ThreadListPrimitive.Items
+  components={{ ThreadListItem: MyThreadListItem }}
+/>
+```
+
+**After:**
+
+```tsx
+<ThreadListPrimitive.Items>
+  {() => <MyThreadListItem />}
+</ThreadListPrimitive.Items>
+```
+
+### Attachments
+
+**Before:**
+
+```tsx
+<ComposerPrimitive.Attachments
+  components={{ Attachment: MyAttachment }}
+/>
+```
+
+**After:**
+
+```tsx
+<ComposerPrimitive.Attachments>
+  {() => <MyAttachment />}
+</ComposerPrimitive.Attachments>
+```
+
+### `addResult` / `resume` on enriched part state
+
+When using the children API, tool-call parts include `addResult` and `resume` methods directly on the part object. This means `<ToolFallback {...part} />` works without needing a wrapper component to provide these methods.
+
+### Backwards Compatibility
+
+The `components` prop is still supported on all primitives but is deprecated and will be removed in a future version.
+
+## Getting Help
+
+If you encounter issues during migration:
+
+1. Check the updated API documentation for detailed examples
+2. Review the example applications in the repository
+3. Report issues at https://github.com/assistant-ui/assistant-ui/issues

package/.docs/raw/docs/(reference)/react-compatibility.mdx

@@ -1,16 +1,16 @@
 ---
 title: Using old React versions
-description: Compatibility notes for React 18, 17, and 16.
+description: Compatibility notes for React 18 and 19.
 ---
 
 
-<Callout type="warning" title="Older React Versions">
-  Older React versions are not continuously tested. If you encounter any issues
-  with integration, please contact us for help by joining our
+<Callout type="warning" title="React 18 Required">
+  assistant-ui requires React 18 or React 19. React 17 and React 16 are not
+  supported. If you need help with an upgrade, join our
   [Discord](https://discord.gg/S9dwgCNEFs).
 </Callout>
 
-This guide provides instructions for configuring assistant-ui to work with React 18 or older versions.
+This guide provides instructions for configuring assistant-ui to work with React 18.
 
 ## React 18
 
@@ -65,135 +65,6 @@ const Button = React.forwardRef<
 Button.displayName = "Button";
 ```
 
-**Note:** If you're using a lower React version (17 or 16), you'll also need to follow the instructions for that version.
-
-## React 17
-
-For React 17 compatibility, in addition to the modifications outlined for React 18, you must also include a polyfill for the `useSyncExternalStore` hook (utilized by zustand).
-
-### Patching Zustand with patch-package
-
-Since the assistant-ui uses zustand internally, which depends on `useSyncExternalStore`, you'll need to patch the zustand package directly:
-
-1. Install the required packages:
-
-<InstallCommand npm={["use-sync-external-store", "patch-package"]} />
-
-2. Add a postinstall script to your package.json:
-
-```json
-{
-  "scripts": {
-    "postinstall": "patch-package"
-  }
-}
-```
-
-3. You'll want to follow the instructions in [patch-package](https://github.com/ds300/patch-package), by first making changes to the files of a particular package in your node_modules folder, then running either `yarn patch-package package-name` or `npx patch-package package-name`. You'll need a patch for zustand - within `node_modules/zustand`, open `zustand/react.js` and make the following code changes:
-
-```diff
-diff --git a/node_modules/zustand/react.js b/node_modules/zustand/react.js
-index 7599cfb..64530a8 100644
---- a/node_modules/zustand/react.js
-+++ b/node_modules/zustand/react.js
-@@ -1,6 +1,6 @@
- 'use strict';
-
--var React = require('react');
-+var React = require('use-sync-external-store/shim');
- var vanilla = require('zustand/vanilla');
-
- const identity = (arg) => arg;
-@@ -10,7 +10,7 @@ function useStore(api, selector = identity) {
-     () => selector(api.getState()),
-     () => selector(api.getInitialState())
-   );
--  React.useDebugValue(slice);
-+  //React.useDebugValue(slice);
-   return slice;
- }
- const createImpl = (createState) => {
-
-This patch replaces the React import in zustand with the polyfill from `use-sync-external-store/shim` and comments out the `useDebugValue` call which isn't needed.
-
-You should then run the patch-package command `yarn patch-package zustand` or `npx patch-package zustand` which should create a `patches` folder with a zustand patch file similar looking to this:
-
-```diff
-diff --git a/node_modules/zustand/react.js b/node_modules/zustand/react.js
-index 7599cfb..64530a8 100644
---- a/node_modules/zustand/react.js
-+++ b/node_modules/zustand/react.js
-@@ -1,6 +1,6 @@
- 'use strict';
-
--var React = require('react');
-+var React = require('use-sync-external-store/shim');
- var vanilla = require('zustand/vanilla');
-
- const identity = (arg) => arg;
-@@ -10,7 +10,7 @@ function useStore(api, selector = identity) {
-     () => selector(api.getState()),
-     () => selector(api.getInitialState())
-   );
--  React.useDebugValue(slice);
-+  //React.useDebugValue(slice);
-   return slice;
- }
- const createImpl = (createState) => {
-```
-
-4. You may also need to apply the same patches within `node_modules/@assistant-ui/react/` and possibly a nested dependency patch for `node_modules/@assistant-ui/react/node_modules/zustand`. Look for instances of `React.useSyncExternalStore` and replace with `{ useSyncExternalStore } from "use-sync-external-store/shim";` and comment out any `useDebugValue` calls. Finally, you may need to patch `useId` from React, so within `node_modules/@assistant-ui/react/dist/runtimes/remote-thread-list/RemoteThreadListThreadListRuntimeCore.js`, change the following:
-
-```diff
--import { Fragment, useEffect, useId } from "react";
-+import { Fragment, useEffect, useRef } from "react";
- import { create } from "zustand";
- import { AssistantMessageStream } from "assistant-stream";
- import { RuntimeAdapterProvider } from "../adapters/RuntimeAdapterProvider.js";
- import { jsx } from "react/jsx-runtime";
-+
-+// PATCH-PACKAGE: Polyfill for useId if not available in React 16
-+let useId;
-+try {
-+  // Try to use React's useId if available
-+  useId = require("react").useId;
-+} catch (e) {}
-+if (!useId) {
-+  // Fallback polyfill
-+  let globalId = 0;
-+  useId = function() {
-+    const idRef = useRef();
-+    if (!idRef.current) {
-+      globalId++;
-+      idRef.current = `uid-${globalId}`;
-+    }
-+    return idRef.current;
-+  };
-+}
-```
-
-5. Run the postinstall script to apply the patches:
-
-```bash
-npm run postinstall
-# or
-yarn postinstall
-```
-
-This patch replaces the React import in zustand with the polyfill from `use-sync-external-store/shim` and comments out the `useDebugValue` call which isn't needed.
-
-**Note:** If you're using React 16, you'll also need to follow the instructions for that version.
-
-## React 16
-
-<Callout type="info" title="Incomplete Section">
-  This section is incomplete and contributions are welcome. If you're using
-  React 16 and have successfully integrated assistant-ui, please consider
-  contributing to this documentation.
-</Callout>
-
-For React 16 compatibility, you need to apply all the steps for **React 18** and **React 17** above.
-
 ## Additional Resources
 
 If you encounter any issues with React compatibility, please: