@assistant-ui/mcp-docs-server 0.2.2 → 0.3.0

package/.docs/raw/docs/guides/electron.mdx

@@ -1,369 +0,0 @@
----
-title: Electron
-description: Run assistant-ui in an Electron renderer with a hosted backend or a secure, streaming preload and IPC bridge.
-platforms: ["react"]
----
-
-assistant-ui works in Electron through `@assistant-ui/react`. The renderer is a React DOM environment, so there is no separate `@assistant-ui/electron` package to install. The Electron-specific decision is where model requests run and how the renderer reaches them.
-
-<Callout type="warn">
-  Never put a provider API key in renderer code, a `VITE_*` variable, or a preload script. Bundled values are readable by anyone with the app. Keep remote credentials on your backend, or keep local credentials in the main process and provision them with an OS-backed secret store.
-</Callout>
-
-## Choose a connection pattern
-
-| Pattern | Use it when | Runtime |
-| --- | --- | --- |
-| Hosted backend | You already have an AI SDK endpoint, need server auth or persistence, or ship the app to other people | `useChatRuntime` with an absolute HTTPS URL |
-| Local main process | The desktop app owns the provider or agent process and must work without your web backend | `useLocalRuntime` with a narrow preload/IPC bridge |
-
-```mermaid
-flowchart LR
-  Renderer["Electron renderer<br/>assistant-ui React"] -->|"absolute HTTPS"| Backend["Hosted chat backend"]
-  Renderer -->|"window.assistantAI"| Preload["context-isolated preload"]
-  Preload -->|"transferred MessagePort"| Main["Electron main process"]
-  Backend --> Provider["Model or agent"]
-  Main --> Provider
-```
-
-Do not send an SDK client, assistant-ui runtime, callback, `AbortSignal`, or `File` through IPC. Electron IPC uses structured clone semantics; define a small data-only protocol instead.
-
-## Pattern 1: hosted backend
-
-This is the smallest integration. Keep your existing AI SDK chat route and point `AssistantChatTransport` at its public URL.
-
-```tsx title="renderer/assistant-runtime.tsx"
-import type { ReactNode } from "react";
-import { AssistantRuntimeProvider } from "@assistant-ui/react";
-import {
-  AssistantChatTransport,
-  useChatRuntime,
-} from "@assistant-ui/react-ai-sdk";
-
-const transport = new AssistantChatTransport({
-  api: "https://api.example.com/chat",
-});
-
-export function ElectronRuntimeProvider({ children }: { children: ReactNode }) {
-  const runtime = useChatRuntime({ transport });
-
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      {children}
-    </AssistantRuntimeProvider>
-  );
-}
-```
-
-The URL must be absolute in a packaged app. A relative value such as `/api/chat` targets the renderer's `file://` or custom-protocol origin, not your deployed backend. Configure the backend's CORS policy for the packaged origin, allow the endpoint in `connect-src`, and authenticate requests as you would from any desktop client.
-
-The endpoint must return the AI SDK UI message stream consumed by `AssistantChatTransport`. See the [AI SDK runtime guide](/docs/runtimes/ai-sdk/v7) for the backend route and tool-calling setup.
-
-## Pattern 2: local main process
-
-Use this pattern when the Electron main process calls the model or runs a local agent. Keep `contextIsolation: true`, `sandbox: true`, and `nodeIntegration: false` on the `BrowserWindow`. Register `registerAssistantIpc(mainWindow)` after creating the trusted window.
-
-The following example is intentionally text-only. It streams one request over a dedicated `MessagePort`; closing that port propagates assistant-ui's Stop action to an `AbortController` in the main process.
-
-### 1. Define a data-only protocol
-
-Place the shared types somewhere all three Electron bundles can import.
-
-```ts title="shared/assistant-ipc.ts"
-export const ASSISTANT_STREAM_CHANNEL = "assistant:stream";
-
-export type ChatMessage =
-  | { role: "user"; content: string }
-  | { role: "assistant"; content: string };
-
-export type ChatRequest = {
-  system?: string;
-  messages: ChatMessage[];
-};
-
-export type ChatEvent =
-  | { type: "delta"; text: string }
-  | { type: "done" }
-  | { type: "error"; message: string };
-
-export type AssistantAI = {
-  streamChat(
-    request: ChatRequest,
-    onEvent: (event: ChatEvent) => void,
-  ): () => void;
-};
-```
-
-### 2. Expose one preload capability
-
-Expose the smallest API the renderer needs, not `ipcRenderer` itself. The callback receives only validated event data, never Electron's privileged IPC event object.
-
-```ts title="preload/assistant.ts"
-import { contextBridge, ipcRenderer } from "electron";
-import {
-  ASSISTANT_STREAM_CHANNEL,
-  type AssistantAI,
-  type ChatEvent,
-} from "./shared";
-
-const assistantAI: AssistantAI = {
-  streamChat(request, onEvent) {
-    const { port1, port2 } = new MessageChannel();
-    const onMessage = (event: MessageEvent<ChatEvent>) => onEvent(event.data);
-
-    port1.addEventListener("message", onMessage);
-    port1.start();
-    ipcRenderer.postMessage(ASSISTANT_STREAM_CHANNEL, request, [port2]);
-
-    let stopped = false;
-    return () => {
-      if (stopped) return;
-      stopped = true;
-      port1.removeEventListener("message", onMessage);
-      port1.close();
-    };
-  },
-};
-
-contextBridge.exposeInMainWorld("assistantAI", assistantAI);
-```
-
-Declare the context-bridge API for renderer TypeScript:
-
-```ts title="renderer/electron.d.ts"
-import type { AssistantAI } from "./shared";
-
-declare global {
-  interface Window {
-    assistantAI: AssistantAI;
-  }
-}
-
-export {};
-```
-
-### 3. Stream from the main process
-
-Install the provider packages in the Electron main-process bundle:
-
-```sh
-pnpm add ai @ai-sdk/openai
-```
-
-The handler checks both the sending `WebContents` and its main frame, validates the untrusted payload and bounds its size before calling the model. Set `OPENAI_API_KEY` only in the main-process environment.
-
-```ts title="main/assistant-ipc.ts"
-import { openai } from "@ai-sdk/openai";
-import { streamText } from "ai";
-import { ipcMain, type BrowserWindow, type IpcMainEvent } from "electron";
-import {
-  ASSISTANT_STREAM_CHANNEL,
-  type ChatEvent,
-  type ChatRequest,
-} from "./shared";
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null;
-
-const isChatRequest = (value: unknown): value is ChatRequest => {
-  if (!isRecord(value) || !Array.isArray(value.messages)) return false;
-  if (value.system !== undefined && typeof value.system !== "string") {
-    return false;
-  }
-  if (value.messages.length > 200) return false;
-
-  let totalLength = typeof value.system === "string" ? value.system.length : 0;
-  for (const message of value.messages) {
-    if (!isRecord(message)) return false;
-    if (message.role !== "user" && message.role !== "assistant") return false;
-    if (typeof message.content !== "string") return false;
-    totalLength += message.content.length;
-    if (totalLength > 1_000_000) return false;
-  }
-
-  return true;
-};
-
-export function registerAssistantIpc(mainWindow: BrowserWindow) {
-  const handleStream = (event: IpcMainEvent, request: unknown) => {
-    const [port] = event.ports;
-    if (!port) return;
-
-    if (
-      event.sender !== mainWindow.webContents ||
-      event.senderFrame !== mainWindow.webContents.mainFrame
-    ) {
-      port.close();
-      return;
-    }
-
-    port.start();
-    if (!isChatRequest(request)) {
-      port.postMessage({
-        type: "error",
-        message: "Invalid chat request.",
-      } satisfies ChatEvent);
-      port.close();
-      return;
-    }
-
-    const abortController = new AbortController();
-    port.once("close", () => abortController.abort());
-    const send = (message: ChatEvent) => port.postMessage(message);
-
-    void (async () => {
-      try {
-        const result = streamText({
-          model: openai("gpt-5.6-luna"),
-          messages: request.messages,
-          ...(request.system ? { system: request.system } : {}),
-          abortSignal: abortController.signal,
-        });
-
-        for await (const text of result.textStream) {
-          send({ type: "delta", text });
-        }
-        send({ type: "done" });
-      } catch (error) {
-        if (abortController.signal.aborted) return;
-        console.error("Assistant stream failed", error);
-        send({ type: "error", message: "The model request failed." });
-      }
-    })();
-  };
-
-  ipcMain.on(ASSISTANT_STREAM_CHANNEL, handleStream);
-  mainWindow.once("closed", () => {
-    ipcMain.removeListener(ASSISTANT_STREAM_CHANNEL, handleStream);
-  });
-}
-```
-
-If your app can open more than one trusted assistant window, register a unique channel per window or route requests through one application-level registry. A global `ipcMain.on` listener should not be re-registered under the same channel for every window.
-
-### 4. Adapt IPC to assistant-ui
-
-`ChatModelAdapter` yields complete snapshots, so the renderer accumulates each IPC delta before yielding it. Its cleanup function closes the port on Stop, unmount, or completion.
-
-```tsx title="renderer/assistant-runtime.tsx"
-import type { ReactNode } from "react";
-import {
-  AssistantRuntimeProvider,
-  useLocalRuntime,
-  type ChatModelAdapter,
-} from "@assistant-ui/react";
-import type { ChatMessage } from "./shared";
-
-const ipcChatModel: ChatModelAdapter = {
-  async *run({ messages, context, abortSignal }) {
-    abortSignal.throwIfAborted();
-
-    const system = [context.system];
-    const serializedMessages: ChatMessage[] = [];
-
-    for (const message of messages) {
-      const text = message.content
-        .flatMap((part) => (part.type === "text" ? [part.text] : []))
-        .join("\n");
-      if (!text) continue;
-
-      if (message.role === "system") system.push(text);
-      if (message.role === "user") {
-        serializedMessages.push({ role: "user", content: text });
-      }
-      if (message.role === "assistant") {
-        serializedMessages.push({ role: "assistant", content: text });
-      }
-    }
-
-    const systemText = system.filter(Boolean).join("\n\n");
-    let stop: (() => void) | undefined;
-    let removeAbortListener: (() => void) | undefined;
-    const deltas = new ReadableStream<string>({
-      start(controller) {
-        let settled = false;
-        const close = () => {
-          if (settled) return;
-          settled = true;
-          controller.close();
-        };
-        const fail = (error: unknown) => {
-          if (settled) return;
-          settled = true;
-          controller.error(error);
-        };
-
-        stop = window.assistantAI.streamChat(
-          {
-            ...(systemText ? { system: systemText } : {}),
-            messages: serializedMessages,
-          },
-          (event) => {
-            if (event.type === "delta") controller.enqueue(event.text);
-            if (event.type === "done") close();
-            if (event.type === "error") fail(new Error(event.message));
-          },
-        );
-
-        const onAbort = () => {
-          stop?.();
-          fail(abortSignal.reason);
-        };
-        abortSignal.addEventListener("abort", onAbort, { once: true });
-        removeAbortListener = () =>
-          abortSignal.removeEventListener("abort", onAbort);
-        if (abortSignal.aborted) onAbort();
-      },
-      cancel() {
-        stop?.();
-      },
-    });
-
-    const reader = deltas.getReader();
-    let fullText = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) return;
-        fullText += value;
-        yield { content: [{ type: "text", text: fullText }] };
-      }
-    } finally {
-      removeAbortListener?.();
-      stop?.();
-      reader.releaseLock();
-    }
-  },
-};
-
-export function ElectronRuntimeProvider({ children }: { children: ReactNode }) {
-  const runtime = useLocalRuntime(ipcChatModel);
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      {children}
-    </AssistantRuntimeProvider>
-  );
-}
-```
-
-Wrap your existing assistant-ui thread with `ElectronRuntimeProvider`. Primitives and installed UI components work exactly as they do in a browser React app.
-
-## Extend the protocol deliberately
-
-The local example drops every non-text content part. Add explicit structured-clone-safe fields before claiming support for more features:
-
-- Attachments: pass bounded `ArrayBuffer` data or an app-owned file reference after validating type, size, and path in the main process. Do not pass browser `File` objects.
-- Tools: define serializable tool-call and tool-result events, and validate every tool invocation in the privileged process. Never expose a generic shell or filesystem IPC method.
-- Reasoning and metadata: add distinct event variants and map them to the corresponding assistant-ui content parts.
-- Thread persistence: store serializable thread data in the main process or use a remote thread-list adapter; do not try to transfer a runtime object.
-
-## Packaged-app checklist
-
-- Use an absolute HTTPS endpoint, a privileged custom protocol, or the preload bridge. Relative `/api/*` routes that worked against a development server will not follow your backend after packaging.
-- Serve local content through a custom protocol instead of `file://` when possible, and define a restrictive Content Security Policy. Do not disable `webSecurity` to work around origin errors.
-- Validate every IPC sender and every payload in the main process. Treat renderer data as untrusted even when the renderer is local.
-- Intercept new windows and external links with `webContents.setWindowOpenHandler`; do not let model-generated links create unrestricted Electron windows.
-- If you render remote HTML with `SafeContentFrame`, allow its documented host in `frame-src`. Ordinary text and Markdown rendering need no Electron-specific change.
-- Test the packaged build, not only the Vite or Webpack development server. The scheme, origin, preload path, CSP, and environment loading can all differ.
-
-For the underlying platform constraints, see Electron's official guides to [IPC and MessagePorts](https://www.electronjs.org/docs/latest/tutorial/message-ports), [context isolation](https://www.electronjs.org/docs/latest/tutorial/context-isolation), and the [security checklist](https://www.electronjs.org/docs/latest/tutorial/security).

package/.docs/raw/docs/guides/headless-composer-input.mdx

@@ -1,113 +0,0 @@
----
-title: Headless Composer Input
-description: Build a custom composer input while keeping assistant-ui composer state and send gating.
-platforms: ["react"]
----
-
-`ComposerPrimitive.Input` is still the recommended composer input for most apps. It owns autosize, keyboard shortcuts, IME handling, paste-to-attachment, focus behavior, and trigger-popover keyboard integration.
-
-Use `unstable_useComposerInput` when you already own the input surface, such as a custom editor, a `contentEditable` surface, or a textarea wrapper whose behavior cannot be expressed through `ComposerPrimitive.Input`'s props, `asChild`, or `render` APIs.
-
-<Callout type="warn">
-  This API is marked unstable and may change without notice. It is a thin bridge
-  to composer text and send state, not a replacement implementation of
-  `ComposerPrimitive.Input`.
-</Callout>
-
-## Usage
-
-Render the custom input inside a composer and mirror text changes into the assistant-ui composer state:
-
-```tsx
-"use client";
-
-import {
-  ComposerPrimitive,
-  unstable_useComposerInput,
-  unstable_useTriggerPopoverAriaProps,
-} from "@assistant-ui/react";
-
-function HeadlessComposer() {
-  const composer = unstable_useComposerInput();
-  const popoverAria = unstable_useTriggerPopoverAriaProps();
-
-  return (
-    <ComposerPrimitive.Root>
-      <textarea
-        aria-label="Message"
-        value={composer.value}
-        disabled={composer.isDisabled}
-        onChange={(event) => {
-          composer.setText(event.currentTarget.value);
-        }}
-        onKeyDown={(event) => {
-          if (event.nativeEvent.isComposing) return;
-
-          if (event.key === "Enter" && !event.shiftKey) {
-            event.preventDefault();
-
-            if (composer.canSend) {
-              composer.send();
-            }
-          }
-        }}
-        {...popoverAria}
-      />
-      <ComposerPrimitive.Send />
-    </ComposerPrimitive.Root>
-  );
-}
-```
-
-`composer.send()` exposes the same send action used by `ComposerPrimitive.Send`, including send options such as `composer.send({ steer: true })`. It is a no-op unless `composer.canSend` is `true`; check `canSend` in custom keyboard handlers to keep your event handling explicit.
-
-## Hook Result
-
-| Field | Description |
-| --- | --- |
-| `value` | Current composer text. Returns `""` when the composer is not editing. |
-| `setText(text)` | Writes text into the composer while it is editing. |
-| `send(options?)` | Sends the current composer message when `canSend` is `true`; otherwise a no-op. |
-| `isDisabled` | Combines the hook's `disabled` option with assistant-ui disabled sources, such as thread disabled state and active dictation input lock. |
-| `canSend` | Matches `ComposerPrimitive.Send` gating, then also respects `isDisabled`. |
-
-Pass `disabled` when your editor has an additional read-only state:
-
-```tsx
-const composer = unstable_useComposerInput({
-  disabled: editorReadOnly,
-});
-```
-
-## What You Still Own
-
-The hook does not recreate the behavior of `ComposerPrimitive.Input`. Your input or editor remains responsible for:
-
-- Enter/newline shortcuts, steer shortcuts, escape/cancel behavior, and any other keyboard behavior.
-- IME and composition handling.
-- Cursor and selection tracking.
-- Autosize and focus management.
-- Paste/drop attachment behavior.
-- Rich text state, serialization, and DOM synchronization for `contentEditable` or editor-library integrations.
-
-For styled textareas, prefer `ComposerPrimitive.Input`. Reach for the headless hook when the editor has its own model or DOM lifecycle and assistant-ui should only supply composer state and send gating.
-
-## Trigger Popovers
-
-`unstable_useTriggerPopoverAriaProps` returns the combobox ARIA attributes for the currently open trigger popover:
-
-```tsx
-const popoverAria = unstable_useTriggerPopoverAriaProps();
-
-<textarea {...popoverAria} />;
-```
-
-Spread these props last so they can mirror `ComposerPrimitive.Input` when a popover is open.
-
-This helper only describes the open popover to assistive technology. It does not wire a custom editor into mention or slash-command keyboard handling, cursor tracking, or item insertion. For the full built-in trigger-popover experience, use `ComposerPrimitive.Input`; for richer editors, integrate the trigger UI with the editor's own selection and keyboard model.
-
-## Related
-
-- [Composer primitives](/docs/primitives/composer)
-- [Composer Trigger Popover](/docs/ui/composer-trigger-popover)
-- [Input History](/docs/guides/input-history)

package/.docs/raw/docs/guides/image-generation.mdx

@@ -1,74 +0,0 @@
----
-title: Image Generation
-description: Generate images in your backend and render them inline in an assistant-ui thread.
----
-
-Image generation needs no dedicated primitive. Generate the image wherever you already run model calls (a route handler or a tool), store the result as an `ImageMessagePart`, and render it with the `@assistant-ui/ui` `Image` component.
-
-<Callout type="info">
-  This covers non-streaming generation, rendering, and actions. Streaming partial images and multi-image galleries are out of scope.
-</Callout>
-
-## Generate in your backend
-
-Call your provider from a server route. With the AI SDK that is `generateImage`; return the image as a data URI (or an object-store URL) plus any provider metadata you want to keep.
-
-```ts
-// app/api/image/route.ts
-import { generateImage } from "ai";
-import { openai } from "@ai-sdk/openai";
-
-export async function POST(req: Request) {
-  const { prompt } = await req.json();
-  const result = await generateImage({
-    model: openai.image("gpt-image-1"),
-    prompt,
-  });
-  const revisedPrompt = (
-    result.providerMetadata as
-      | Record<string, Record<string, unknown>>
-      | undefined
-  )?.openai?.revisedPrompt;
-  return Response.json({
-    image: `data:${result.image.mediaType};base64,${result.image.base64}`,
-    mimeType: result.image.mediaType,
-    ...(typeof revisedPrompt === "string" && { revisedPrompt }),
-  });
-}
-```
-
-The model provider is irrelevant to rendering; swap `openai.image(...)` for any AI SDK image model.
-
-## Store it as an `ImageMessagePart`
-
-An `ImageMessagePart` only needs `image` (a `data:` URI, an `https://` URL, or a `blob:` URL) plus an optional `filename`. Keep any provenance you want to display, the prompt, a revised prompt, a model id, in your own component state or in message metadata; the part itself stays minimal.
-
-```ts
-const part: ImageMessagePart = {
-  type: "image",
-  image: result.image, // data:, https://, or blob: URL
-};
-```
-
-## Render with the `Image` component
-
-The `Image` component in `@assistant-ui/ui` handles the render states for you:
-
-1. **Running** (`status.type === "running"`) renders a spinner.
-2. **Content filter** (`status.type === "incomplete"` with `reason: "content-filter"`) renders an error card with no `<img src>`.
-3. **Complete** renders a zoomable `<img>` with optional `Image.Actions`.
-
-`Image.Actions` provides download and copy buttons, plus a regenerate button when you pass an `onRegenerate` callback. Wire it to the same generation flow you used above; debounce, rate limiting, and confirmation are your call.
-
-```tsx
-import { Image } from "@assistant-ui/ui";
-
-<>
-  <Image {...imagePart} />
-  <Image.Actions part={imagePart} onRegenerate={() => regenerate(prompt)} />
-</>;
-```
-
-## Example
-
-A complete Next.js example (with a mock fallback when `OPENAI_API_KEY` is unset) lives in [`examples/with-image-generation`](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-image-generation).

package/.docs/raw/docs/guides/index.mdx

@@ -1,117 +0,0 @@
----
-title: Guides
-description: Practical recipes for building AI chat features in React with assistant-ui — attachments, branching, multi-agent, voice, slash commands, generative UI, and more.
-platforms: ["react"]
----
-
-Guides are task-oriented walkthroughs for building specific features on top of assistant-ui. They sit between the [Primitives](/docs/primitives) (low-level building blocks) and [Components](/docs/ui/thread) (pre-styled installs) — pick a guide when you know what you want to build and need the recommended pattern.
-
-## Composer
-
-Extend the message input with file attachments, mentions, slash commands, voice, and quoting.
-
-<Cards>
-  <Card title="Attachments" href="/docs/guides/attachments">
-    Let users attach files, images, and documents to messages. Covers upload adapters, validation, and the typed `attachmentAddError` event.
-  </Card>
-  <Card title="Mentions" href="/docs/guides/mentions">
-    `@`-style triggers that insert directives into the composer. Sync and async search patterns.
-  </Card>
-  <Card title="Slash Commands" href="/docs/guides/slash-commands">
-    `/`-style commands with arguments, async loading, and combining with mentions.
-  </Card>
-  <Card title="Quoting" href="/docs/guides/quoting">
-    Selection toolbar, programmatic `setQuote`, and forwarding quote context to the LLM.
-  </Card>
-  <Card title="Dictation" href="/docs/guides/dictation">
-    Speech-to-text into the composer using `DictationAdapter` and `ComposerPrimitive.Dictate`.
-  </Card>
-</Cards>
-
-## Messages
-
-Customize how messages render, are edited, branched, and suggested.
-
-<Cards>
-  <Card title="Suggestions" href="/docs/guides/suggestions">
-    Welcome-screen prompts, dynamic suggestions, and the `AuiIf` empty-thread pattern.
-  </Card>
-  <Card title="Editing" href="/docs/guides/editing">
-    Edit user messages with `UserEditComposer`, `beginEdit()`, and edit-during-streaming behavior.
-  </Card>
-  <Card title="Branching" href="/docs/guides/branching">
-    Navigate alternative message versions with `BranchPickerPrimitive`, reload, and direct branch-id navigation.
-  </Card>
-  <Card title="Message Timing" href="/docs/guides/message-timing">
-    Display response duration and stream timing with `useMessageTiming` (experimental).
-  </Card>
-</Cards>
-
-## Tools & Generative UI
-
-Tool calling and generative UI have their own [Tools](/docs/tools) section — defining toolkits, rendering tool calls, interactables, MCP, and multi-agent UIs.
-
-<Cards>
-  <Card title="Tools" href="/docs/tools">
-    Define toolkits, render tool calls, connect MCP servers, and build generative UI.
-  </Card>
-</Cards>
-
-## Display
-
-Render specialized message content.
-
-<Cards>
-  <Card title="Chain of Thought" href="/docs/guides/chain-of-thought">
-    Display the assistant's reasoning steps in a collapsible accordion.
-  </Card>
-  <Card title="LaTeX" href="/docs/guides/latex">
-    Render math via React Markdown or Streamdown, with streaming-safe escape rules.
-  </Card>
-  <Card title="Thread Virtualization" href="/docs/guides/virtualization">
-    Render very long threads with @tanstack/react-virtual and per-index message rendering.
-  </Card>
-</Cards>
-
-## Audio
-
-Voice input and output.
-
-<Cards>
-  <Card title="Voice" href="/docs/guides/voice">
-    Realtime bidirectional audio with `RealtimeVoiceAdapter` and `createVoiceSession`.
-  </Card>
-  <Card title="Speech" href="/docs/guides/speech">
-    Text-to-speech for assistant messages via `SpeechSynthesisAdapter`.
-  </Card>
-</Cards>
-
-## Programmatic
-
-Read and drive runtime state from your own code.
-
-<Cards>
-  <Card title="Context API" href="/docs/guides/context-api">
-    Access threads, messages, composer, and tool state via `useAui` and the runtime scope tree.
-  </Card>
-</Cards>
-
-## Providers
-
-Alternative ways to connect a model.
-
-<Cards>
-  <Card title="ChatGPT Subscription" href="/docs/guides/chatgpt-subscription">
-    Run your app locally on a ChatGPT Plus or Pro plan via Codex OAuth, no API key required.
-  </Card>
-</Cards>
-
-## Environments
-
-Run assistant-ui outside a conventional browser deployment.
-
-<Cards>
-  <Card title="Electron" href="/docs/guides/electron">
-    Connect an Electron renderer to a hosted backend or a secure, streaming preload/IPC bridge.
-  </Card>
-</Cards>