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

package/.docs/raw/docs/react-native/adapters.mdx

@@ -1,118 +1,94 @@
 ---
 title: Adapters
-description: Storage and title generation adapters for React Native.
+description: Persistence and title generation adapters for React Native.
 ---
 
-Adapters customize how the local runtime persists threads and generates titles. Pass them to `useLocalRuntime` via options.
+Adapters customize runtime behavior. They can be passed as options to `useLocalRuntime` or `useRemoteThreadListRuntime`.
 
-```tsx
-import AsyncStorage from "@react-native-async-storage/async-storage";
-import {
-  useLocalRuntime,
-  createSimpleTitleAdapter,
-} from "@assistant-ui/react-native";
-
-const runtime = useLocalRuntime(chatModel, {
-  storage: AsyncStorage,
-  titleGenerator: createSimpleTitleAdapter(),
-});
-```
+## Persistence
 
-## Storage
-
-The `storage` option accepts any object with `getItem`, `setItem`, and `removeItem` methods (matching the `AsyncStorage` interface). When provided, threads and messages are persisted across app restarts.
-
-```tsx
-type AsyncStorageLike = {
-  getItem(key: string): Promise<string | null>;
-  setItem(key: string, value: string): Promise<void>;
-  removeItem(key: string): Promise<void>;
-};
-```
+By default, `useLocalRuntime` stores threads and messages in memory only -- they are lost when the app restarts. To persist data, use one of these approaches:
 
-### AsyncStorage
+### Assistant Cloud
 
-The most common choice for React Native:
+The simplest way to add persistence. Pass a `cloud` option to `useLocalRuntime`:
 
 ```tsx
-import AsyncStorage from "@react-native-async-storage/async-storage";
+import { useLocalRuntime } from "@assistant-ui/react-native";
+import { AssistantCloud } from "@assistant-ui/cloud";
 
-const runtime = useLocalRuntime(chatModel, {
-  storage: AsyncStorage,
+const cloud = new AssistantCloud({
+  baseUrl: "https://backend.assistant-ui.com",
+  authToken: () => fetchTokenFromYourBackend(),
 });
-```
-
-An optional `storagePrefix` parameter namespaces the keys:
 
-```tsx
-const runtime = useLocalRuntime(chatModel, {
-  storage: AsyncStorage,
-  storagePrefix: "chat:",
-  // Keys: "chat:threads", "chat:messages:<threadId>", ...
-});
+const runtime = useLocalRuntime(chatModel, { cloud });
 ```
 
-### No storage (default)
-
-When `storage` is omitted, threads live in memory only — lost on app restart.
-
-```tsx
-const runtime = useLocalRuntime(chatModel);
-```
+This gives you multi-thread support with server-side persistence, cross-device sync, and automatic title generation.
 
-### Advanced: createLocalStorageAdapter
+### History adapter
 
-For more control, use `createLocalStorageAdapter` directly to create a `RemoteThreadListAdapter`:
+For custom persistence (e.g. saving message history to your own backend), pass a `ThreadHistoryAdapter` via `adapters.history`:
 
 ```tsx
-import AsyncStorage from "@react-native-async-storage/async-storage";
-import {
-  createLocalStorageAdapter,
-  createSimpleTitleAdapter,
-} from "@assistant-ui/react-native";
-
-const adapter = createLocalStorageAdapter({
-  storage: AsyncStorage,
-  prefix: "chat:",
-  titleGenerator: createSimpleTitleAdapter(),
-});
-```
-
-## TitleGenerationAdapter
-
-Generates a title for a thread based on its messages.
+import { useLocalRuntime } from "@assistant-ui/react-native";
+import type { ThreadHistoryAdapter } from "@assistant-ui/react-native";
+
+const myHistoryAdapter: ThreadHistoryAdapter = {
+  async load() {
+    // Load saved messages from your storage
+    const data = await fetchMessagesFromBackend();
+    return data; // { headId, messages }
+  },
+  async append(item) {
+    // Persist a new message
+    await saveMessageToBackend(item);
+  },
+};
 
-```tsx
-interface TitleGenerationAdapter {
-  generateTitle(messages: ThreadMessage[]): Promise<string>;
-}
+const runtime = useLocalRuntime(chatModel, {
+  adapters: {
+    history: myHistoryAdapter,
+  },
+});
 ```
 
-### Built-in implementations
+### RemoteThreadListAdapter
 
-#### Simple title adapter
+For full backend thread management (thread list, archiving, cross-device sync), use `useRemoteThreadListRuntime`. See the [Custom Backend](/docs/react-native/custom-backend) page for a full example.
 
-Returns the first 50 characters of the first user message.
+## RemoteThreadListAdapter
 
-```tsx
-import { createSimpleTitleAdapter } from "@assistant-ui/react-native";
-
-const titleGenerator = createSimpleTitleAdapter();
-```
-
-### Custom implementation
+Title generation is configured via the `generateTitle` method on `RemoteThreadListAdapter`. See the [Custom Backend](/docs/react-native/custom-backend) page for a full example.
 
 ```tsx
-import type { TitleGenerationAdapter } from "@assistant-ui/react-native";
-
-const aiTitleGenerator: TitleGenerationAdapter = {
-  async generateTitle(messages) {
-    const response = await fetch("/api/generate-title", {
-      method: "POST",
-      body: JSON.stringify({ messages }),
+import type { RemoteThreadListAdapter } from "@assistant-ui/react-native";
+import { createAssistantStream } from "assistant-stream";
+
+const myAdapter: RemoteThreadListAdapter = {
+  // ... other methods ...
+
+  async generateTitle(remoteId, unstable_messages) {
+    return createAssistantStream(async (controller) => {
+      const res = await fetch(`/api/threads/${remoteId}/title`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ messages: unstable_messages }),
+      });
+      const { title } = await res.json();
+      controller.appendText(title);
     });
-    const { title } = await response.json();
-    return title;
   },
 };
 ```
+
+## Which option to choose?
+
+| | ChatModelAdapter + `useLocalRuntime` | RemoteThreadListAdapter + `useRemoteThreadListRuntime` |
+|---|---|---|
+| **Thread storage** | In-memory (or cloud) | Your backend |
+| **Message storage** | In-memory (can add history adapter) | In-memory (can add history adapter for server-side) |
+| **Cross-device sync** | Only with cloud | Yes |
+| **Setup complexity** | Minimal | Moderate |
+| **Best for** | Single-device apps, prototypes | Production apps with user accounts |

package/.docs/raw/docs/react-native/custom-backend.mdx

@@ -40,22 +40,19 @@ export const myChatAdapter: ChatModelAdapter = {
 ```
 
 ```tsx title="hooks/use-app-runtime.ts"
-import AsyncStorage from "@react-native-async-storage/async-storage";
 import { useLocalRuntime } from "@assistant-ui/react-native";
 import { myChatAdapter } from "@/adapters/my-chat-adapter";
 
 export function useAppRuntime() {
-  return useLocalRuntime(myChatAdapter, {
-    storage: AsyncStorage, // threads + messages persisted locally
-  });
+  return useLocalRuntime(myChatAdapter);
 }
 ```
 
 This gives you:
 
 - Streaming chat responses from your API
-- Local thread list with persistence (AsyncStorage)
-- Message history saved across app restarts
+- In-memory thread and message management
+- Automatic features like message editing, reloading, and branch switching
 
 ## Option 2: Full backend thread management
 
@@ -129,12 +126,12 @@ export const myThreadListAdapter: RemoteThreadListAdapter = {
     };
   },
 
-  async generateTitle(remoteId, messages) {
+  async generateTitle(remoteId, unstable_messages) {
     return createAssistantStream(async (controller) => {
       const res = await fetch(`${API_BASE}/threads/${remoteId}/title`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ messages }),
+        body: JSON.stringify({ messages: unstable_messages }),
       });
       const { title } = await res.json();
       controller.appendText(title);
@@ -170,15 +167,15 @@ export function useAppRuntime() {
 ### Use in your app
 
 ```tsx title="app/index.tsx"
-import { AssistantProvider } from "@assistant-ui/react-native";
+import { AssistantRuntimeProvider } from "@assistant-ui/react-native";
 import { useAppRuntime } from "@/hooks/use-app-runtime";
 
 export default function App() {
   const runtime = useAppRuntime();
   return (
-    <AssistantProvider runtime={runtime}>
+    <AssistantRuntimeProvider runtime={runtime}>
       {/* your chat UI */}
-    </AssistantProvider>
+    </AssistantRuntimeProvider>
   );
 }
 ```
@@ -197,14 +194,14 @@ export default function App() {
 | `unarchive(remoteId)` | Restore archived thread |
 | `delete(remoteId)` | Permanently remove thread |
 | `fetch(remoteId)` | Fetch single thread metadata |
-| `generateTitle(remoteId, messages)` | Return an `AssistantStream` with the generated title |
+| `generateTitle(remoteId, unstable_messages)` | Return an `AssistantStream` with the generated title |
 
 ## Which option to choose?
 
 | | Option 1: ChatModelAdapter | Option 2: RemoteThreadListAdapter |
 |---|---|---|
-| **Thread storage** | On-device (AsyncStorage) | Your backend |
-| **Message storage** | On-device (AsyncStorage) | On-device (can add history adapter for server-side) |
+| **Thread storage** | In-memory | Your backend |
+| **Message storage** | In-memory | In-memory (can add history adapter for server-side) |
 | **Cross-device sync** | No | Yes |
 | **Setup complexity** | Minimal | Moderate |
 | **Best for** | Single-device apps, prototypes | Production apps with user accounts |