@assistant-ui/mcp-docs-server 0.1.35 → 0.1.38

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

@@ -3,7 +3,7 @@ title: ThreadPrimitive
 description: Thread primitives for rendering chat transcripts, message lists, viewport state, suggestions, and composers in assistant-ui.
 ---
 
-import { ThreadPrimitiveIfProps, ThreadPrimitiveMessageByIndexProps, ThreadPrimitiveMessagesProps, ThreadPrimitiveRootProps, ThreadPrimitiveScrollToBottomProps, ThreadPrimitiveSuggestionByIndexProps, ThreadPrimitiveSuggestionProps, ThreadPrimitiveSuggestionsProps, ThreadPrimitiveViewportFooterProps, ThreadPrimitiveViewportProps, ThreadPrimitiveViewportProviderProps } from "@/generated/typeDocs";
+import { ThreadPrimitiveIfProps, ThreadPrimitiveMessageByIndexProps, ThreadPrimitiveMessagesProps, ThreadPrimitiveRootProps, ThreadPrimitiveScrollToBottomProps, ThreadPrimitiveSuggestionByIndexProps, ThreadPrimitiveSuggestionProps, ThreadPrimitiveSuggestionsProps, ThreadPrimitiveUnstable_MessageByIdProps, ThreadPrimitiveViewportFooterProps, ThreadPrimitiveViewportProps, ThreadPrimitiveViewportProviderProps } from "@/generated/typeDocs";
 import { ThreadPrimitive as ThreadPrimitiveDocs } from "@/generated/primitiveDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
@@ -51,6 +51,16 @@ const Thread = () => (
   <p>This primitive renders a <code>{`<${ThreadPrimitiveDocs.Root?.element}>`}</code> element unless <code>asChild</code> is set.</p>
 )}
 
+```tsx
+<ThreadPrimitive.Root>
+  <ThreadPrimitive.Viewport>
+    <ThreadPrimitive.Messages>
+      {() => <MyMessage />}
+    </ThreadPrimitive.Messages>
+  </ThreadPrimitive.Viewport>
+</ThreadPrimitive.Root>
+```
+
 <ParametersTable {...ThreadPrimitiveRootProps} />
 
 ### Empty
@@ -101,6 +111,14 @@ const Thread = () => (
   <p>This primitive renders a <code>{`<${ThreadPrimitiveDocs.Viewport?.element}>`}</code> element unless <code>asChild</code> is set.</p>
 )}
 
+```tsx
+<ThreadPrimitive.Viewport turnAnchor="top">
+  <ThreadPrimitive.Messages>
+    {() => <MyMessage />}
+  </ThreadPrimitive.Messages>
+</ThreadPrimitive.Viewport>
+```
+
 <ParametersTable {...ThreadPrimitiveViewportProps} />
 
 ### ViewportProvider
@@ -133,6 +151,17 @@ const Thread = () => (
   <p>This primitive renders a <code>{`<${ThreadPrimitiveDocs.ViewportFooter?.element}>`}</code> element unless <code>asChild</code> is set.</p>
 )}
 
+```tsx
+<ThreadPrimitive.Viewport>
+  <ThreadPrimitive.Messages>
+    {() => <MyMessage />}
+  </ThreadPrimitive.Messages>
+  <ThreadPrimitive.ViewportFooter className="sticky bottom-0">
+    <Composer />
+  </ThreadPrimitive.ViewportFooter>
+</ThreadPrimitive.Viewport>
+```
+
 <ParametersTable {...ThreadPrimitiveViewportFooterProps} />
 
 ### Messages
@@ -167,6 +196,33 @@ const Thread = () => (
 
 <ParametersTable {...ThreadPrimitiveMessageByIndexProps} />
 
+### Unstable_MessageById
+
+{ThreadPrimitiveDocs.Unstable_MessageById?.deprecated && (
+  <Callout type="tip">
+    <strong>Experimental.</strong> {ThreadPrimitiveDocs.Unstable_MessageById.deprecated}
+  </Callout>
+)}
+
+{ThreadPrimitiveDocs.Unstable_MessageById?.description}
+
+{ThreadPrimitiveDocs.Unstable_MessageById?.element && (
+  <p>This primitive renders a <code>{`<${ThreadPrimitiveDocs.Unstable_MessageById?.element}>`}</code> element unless <code>asChild</code> is set.</p>
+)}
+
+```tsx
+const messageIds = unstable_useThreadMessageIds();
+return messageIds.map((messageId) => (
+  <ThreadPrimitive.Unstable_MessageById
+    key={messageId}
+    messageId={messageId}
+    components={MESSAGE_COMPONENTS}
+  />
+));
+```
+
+<ParametersTable {...ThreadPrimitiveUnstable_MessageByIdProps} />
+
 ### ScrollToBottom
 
 {ThreadPrimitiveDocs.ScrollToBottom?.deprecated && (

package/.docs/raw/docs/(reference)/api-reference/tools/index.mdx

@@ -36,4 +36,10 @@ Toolkits are the current registration API. Tool **rendering** and **status** are
   <Card title={"Tool Status"} href={"/docs/api-reference/tools/status"}>
     {"Read tool arguments, execution status, and result state inside assistant-ui tool UI components."}
   </Card>
+  <Card title={"Interactables"} href={"/docs/api-reference/tools/interactables"}>
+    {"Unstable interactables APIs for model-editable app and message state, including hooks, resources, toolkit helpers, and snapshot utilities."}
+  </Card>
+  <Card title={"Interactables (legacy)"} href={"/docs/api-reference/tools/interactables-legacy"}>
+    {"Deprecated legacy interactables APIs for registering model-editable components with per-instance update tools."}
+  </Card>
 </Cards>

package/.docs/raw/docs/(reference)/api-reference/tools/interactables-legacy.mdx

@@ -0,0 +1,55 @@
+---
+title: Interactables (legacy)
+description: Deprecated legacy interactables APIs for registering model-editable components with per-instance update tools.
+---
+
+import { Interactables, useAssistantInteractable, useInteractableState } from "@/generated/typeDocs";
+
+{/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
+{/* Do not edit manually. */}
+
+{/* api-reference:start */}
+{/* AUTO-GENERATED by scripts/generate-api-reference.mts */}
+{/* Do not edit this block manually. */}
+
+## API Reference
+
+### Interactables
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Since 2026-06-14 — migrate to the Unstable / Experimental API.
+Scheduled for removal on/after 2026-09-14. See
+[Interactables migration guide](https://www.assistant-ui.com/docs/tools/interactables#migrating-from-the-previous-api).
+</Callout>
+
+<ParametersTable {...Interactables} />
+
+### useAssistantInteractable
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Since 2026-06-14 — migrate to the Unstable / Experimental API.
+Scheduled for removal on/after 2026-09-14. See
+[Interactables migration guide](https://www.assistant-ui.com/docs/tools/interactables#migrating-from-the-previous-api).
+</Callout>
+
+Registers an interactable with the AI assistant.
+
+This hook handles registration only. To read and write the interactable's
+state, use [useInteractableState](/docs/api-reference/tools/interactables-legacy#useinteractablestate) with the returned id.
+
+<ParametersTable {...useAssistantInteractable} />
+
+### useInteractableState
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Since 2026-06-14 — migrate to the Unstable / Experimental API.
+Scheduled for removal on/after 2026-09-14. See
+[Interactables migration guide](https://www.assistant-ui.com/docs/tools/interactables#migrating-from-the-previous-api).
+</Callout>
+
+Reads and writes the state of a registered interactable.
+
+Pair with [useAssistantInteractable](/docs/api-reference/tools/interactables-legacy#useassistantinteractable) which handles registration.
+
+<ParametersTable {...useInteractableState} />
+{/* api-reference:end */}

package/.docs/raw/docs/(reference)/api-reference/tools/interactables.mdx

@@ -0,0 +1,151 @@
+---
+title: Interactables
+description: Unstable interactables APIs for model-editable app and message state, including hooks, resources, toolkit helpers, and snapshot utilities.
+---
+
+import { unstable_formatInteractableSnapshot, unstable_getInteractableSnapshots, unstable_getInteractableVersions, unstable_useInteractable, unstable_useInteractableState, unstable_useInteractableVersions } from "@/generated/typeDocs";
+
+{/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
+{/* Do not edit manually. */}
+
+{/* api-reference:start */}
+{/* AUTO-GENERATED by scripts/generate-api-reference.mts */}
+{/* Do not edit this block manually. */}
+
+## API Reference
+
+### unstable_Interactables
+
+<Callout type="tip">
+<strong>Experimental.</strong> Unstable / Experimental (not actually removed).
+</Callout>
+
+Registers the unstable interactables store scope.
+
+```ts
+const unstable_Interactables: Resource<ClientOutput<"unstable_interactables">, [(Unstable_InteractablesConfig | undefined)?]>;
+```
+
+### unstable_useInteractable
+
+<Callout type="tip">
+<strong>Experimental.</strong> Unstable / Experimental (not actually removed).
+</Callout>
+
+Registers an interactable with the AI assistant and returns its live state,
+like `useState` that the model can also read and update.
+
+Call this once per place that shows the interactable. Other components can
+read and write the same instance by passing its `id` to
+`unstable_useInteractableState`.
+
+For tool-created interactables rendered inside tool-call message parts,
+`version` carries this message's version of the instance — its state as of
+that point in the conversation, whether it is the most recent tool-driven
+version, and a `restore()` back to it. Whether older messages render frozen history or stay
+live-editable is the component's choice. Inside an `update_{name}` part the
+instance `id` is inferred from the call, so the same component works at the
+creating call and at update calls.
+
+<ParametersTable {...unstable_useInteractable} />
+
+### unstable_useInteractableState
+
+<Callout type="tip">
+<strong>Experimental.</strong> Unstable / Experimental (not actually removed).
+</Callout>
+
+Reads and writes the state of an interactable registered elsewhere, by id.
+
+Use this from secondary readers (children, siblings); the owning component
+registers with `unstable_useInteractable`, which returns state directly. Returns
+`undefined` until the owning interactable is registered.
+
+<ParametersTable {...unstable_useInteractableState} />
+
+### unstable_useInteractableVersions
+
+<Callout type="tip">
+<strong>Experimental.</strong> Unstable / Experimental (not actually removed).
+</Callout>
+
+Every version of a tool-created interactable recorded in the current
+thread, oldest first: the creating tool call, each user edit, and each
+`update_*` call. Each entry carries the full state as of that version and a
+`restore()` that sets the live instance back to it — enough for a version
+picker like an artifact's history dropdown.
+
+<ParametersTable {...unstable_useInteractableVersions} />
+
+### unstable_interactableTool
+
+<Callout type="tip">
+<strong>Experimental.</strong> Unstable / Experimental (not actually removed).
+</Callout>
+
+Defines a tool that creates a thread-scoped interactable from its arguments,
+for assignment to a toolkit entry — the entry key is the interactable name:
+
+```tsx
+notepad: unstable_interactableTool({
+  description: "A notepad the user can read and edit.",
+  stateSchema: notepadSchema,
+  render: (props) => <Notepad {...props} />,
+}),
+```
+
+`render` shows at the creating call and — installed automatically — at every
+`update_{name}` call, with streaming previews, instance-id wiring, and
+registration handled. It receives the live `state`/`setState` plus this
+message's `version`; whether older messages render frozen history or stay
+live-editable is the render function's choice.
+
+```ts
+const unstable_interactableTool: <TSchema extends Unstable_InteractableStateSchema>(config: Unstable_InteractableToolConfig<TSchema>) => ToolDefinition<Record<string, unknown>, { success: true; }>;
+```
+
+### unstable_getInteractableSnapshots
+
+<Callout type="tip">
+<strong>Experimental.</strong> Unstable / Experimental (not actually removed).
+</Callout>
+
+Reads the interactable snapshots stamped on a message's
+`metadata.custom.interactables`, or `undefined` if none. This is the read
+half of the snapshot channel — integrations use it to surface interactable
+state to the model (see `unstable_injectInteractableContext` in
+`@assistant-ui/react-ai-sdk` for the AI SDK implementation).
+
+<ParametersTable {...unstable_getInteractableSnapshots} />
+
+### unstable_formatInteractableSnapshot
+
+<Callout type="tip">
+<strong>Experimental.</strong> Unstable / Experimental (not actually removed).
+</Callout>
+
+Canonical model-facing wording for one snapshot entry.
+
+<ParametersTable {...unstable_formatInteractableSnapshot} />
+
+### unstable_getInteractableVersions
+
+<Callout type="tip">
+<strong>Experimental.</strong> Unstable / Experimental (not actually removed).
+</Callout>
+
+Every version of interactable `id` recorded in the thread, oldest first,
+folded chronologically:
+
+- the tool call whose `toolCallId` equals `id` seeds the baseline with its
+  args (`origin: "create"`) — the `id: toolCallId` convention for
+  tool-created interactables,
+- a snapshot stamped on a user message is a `"user-edit"` version (a full
+  snapshot replaces the state; a partial one shallow-merges),
+- each accepted `update_*` call shallow-merges an `"update"` version.
+
+The last entry is the state the model knows. Partial snapshots and update
+calls with no baseline to merge into are skipped.
+
+<ParametersTable {...unstable_getInteractableVersions} />
+{/* api-reference:end */}

package/.docs/raw/docs/(reference)/api-reference/tools/rendering.mdx

@@ -44,6 +44,21 @@ type AssistantDataUIProps = {
 const makeAssistantDataUI: <T = any>(dataUI: AssistantDataUIProps<T>) => AssistantDataUI;
 ```
 
+### McpAppRenderer
+
+<ParametersTable {...McpAppRenderer} />
+
+### McpAppsRemoteHost
+
+<ParametersTable {...McpAppsRemoteHost} />
+
+### useAssistantDataUI
+
+Registers a renderer for named `data` message parts while the component is
+mounted.
+
+<ParametersTable {...useAssistantDataUI} />
+
 ### makeAssistantToolUI
 
 <Callout type="warn">
@@ -74,21 +89,6 @@ type AssistantToolUIProps = {
 const makeAssistantToolUI: <TArgs, TResult>(tool: AssistantToolUIProps<TArgs, TResult>) => AssistantToolUI;
 ```
 
-### McpAppRenderer
-
-<ParametersTable {...McpAppRenderer} />
-
-### McpAppsRemoteHost
-
-<ParametersTable {...McpAppsRemoteHost} />
-
-### useAssistantDataUI
-
-Registers a renderer for named `data` message parts while the component is
-mounted.
-
-<ParametersTable {...useAssistantDataUI} />
-
 ### useAssistantToolUI
 
 <Callout type="warn">

package/.docs/raw/docs/(reference)/api-reference/tools/toolkits.mdx

@@ -115,26 +115,6 @@ client build.
 function externalTool(): never;
 ```
 
-### hitl
-
-<Callout type="warn">
-<strong>Deprecated.</strong> Use [humanTool](/docs/api-reference/tools/toolkits#humantool).
-</Callout>
-
-```ts
-const hitl: typeof humanTool;
-```
-
-### hitlTool
-
-<Callout type="warn">
-<strong>Deprecated.</strong> Use [humanTool](/docs/api-reference/tools/toolkits#humantool).
-</Callout>
-
-```ts
-const hitlTool: typeof humanTool;
-```
-
 ### humanTool
 
 Marks a tool as **human-in-the-loop**: the agent pauses and the UI (`render`)
@@ -172,4 +152,24 @@ supplied by `useAuiToolOverrides(...)`.
 ```ts
 function stubTool(): never;
 ```
+
+### hitl
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Use [humanTool](/docs/api-reference/tools/toolkits#humantool).
+</Callout>
+
+```ts
+const hitl: typeof humanTool;
+```
+
+### hitlTool
+
+<Callout type="warn">
+<strong>Deprecated.</strong> Use [humanTool](/docs/api-reference/tools/toolkits#humantool).
+</Callout>
+
+```ts
+const hitlTool: typeof humanTool;
+```
 {/* api-reference:end */}

package/.docs/raw/docs/(reference)/api-reference/utilities/miscellaneous.mdx

@@ -3,7 +3,7 @@ title: Utilities
 description: Miscellaneous @assistant-ui/react utilities for custom rendering, composition, and advanced assistant UI behavior.
 ---
 
-import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, InMemoryThreadList, Interactables, SingleThreadList, Suggestions, useSmooth } from "@/generated/typeDocs";
+import { AssistantCloud, ChainOfThoughtClient, DevToolsHooks, InMemoryThreadList, SingleThreadList, Suggestions, useSmooth } from "@/generated/typeDocs";
 
 {/* AUTO-GENERATED PAGE by scripts/generate-api-reference.mts */}
 {/* Do not edit manually. */}
@@ -36,10 +36,6 @@ const createMessageQueue: (driver: MessageQueueDriver) => MessageQueueController
 
 <ParametersTable {...InMemoryThreadList} />
 
-### Interactables
-
-<ParametersTable {...Interactables} />
-
 ### SingleThreadList
 
 <ParametersTable {...SingleThreadList} />
@@ -48,6 +44,16 @@ const createMessageQueue: (driver: MessageQueueDriver) => MessageQueueController
 
 <ParametersTable {...Suggestions} />
 
+### unstable_defaultDirectiveFormatter
+
+Default directive formatter using the `:type[label]{name=id}` syntax.
+
+When `id` equals `label`, the `{name=…}` attribute is omitted for brevity.
+
+```ts
+const unstable_defaultDirectiveFormatter: Unstable_DirectiveFormatter;
+```
+
 ### useSmooth
 
 Animates streamed message part text with a typewriter-style reveal.
@@ -66,13 +72,23 @@ const { text, status } = useSmooth(useMessagePartText(), {
 
 <ParametersTable {...useSmooth} />
 
-### unstable_defaultDirectiveFormatter
+### fromThreadMessageLike
 
-Default directive formatter using the `:type[label]{name=id}` syntax.
+<Callout type="tip">
+<strong>Experimental.</strong> This API is experimental and may change without notice.
+</Callout>
 
-When `id` equals `label`, the `{name=…}` attribute is omitted for brevity.
+```ts
+const fromThreadMessageLike: (like: ThreadMessageLike, fallbackId: string, fallbackStatus: MessageStatus) => ThreadMessage;
+```
+
+### generateId
+
+<Callout type="tip">
+<strong>Experimental.</strong> This API is experimental and may change without notice.
+</Callout>
 
 ```ts
-const unstable_defaultDirectiveFormatter: Unstable_DirectiveFormatter;
+const generateId: (size?: number) => string;
 ```
 {/* api-reference:end */}

package/.docs/raw/docs/cloud/langgraph.mdx

@@ -547,6 +547,6 @@ For other authentication providers or custom implementations, see the [Cloud Aut
 
 ## Next Steps
 
-- Learn about [LangGraph runtime setup](/docs/runtimes/langgraph) for your application
+- Learn about [LangGraph runtime setup](/docs/runtimes/langgraph/overview) for your application
 - Explore [ThreadListRuntime](/docs/api-reference/runtimes/thread-list-runtime) for advanced thread management
 - Check out the [LangGraph example](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-langgraph) on GitHub

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

@@ -0,0 +1,113 @@
+---
+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/latex.mdx

@@ -106,47 +106,53 @@ By default, remark-math (react-markdown path) supports:
 
 ## Supporting Alternative LaTeX Delimiters
 
-Many language models generate LaTeX using different delimiter formats:
-- `\(...\)` for inline math
-- `\[...\]` for display math
-- Custom formats like `[/math]...[/math]`
+Many language models emit math in delimiters that remark-math does not recognize:
+- `\(...\)` for inline math and `\[...\]` for display math
+- custom tags like `[/math]...[/math]` and `[/inline]...[/inline]`
 
-You can use the `preprocess` prop on `MarkdownTextPrimitive` to normalize these formats before parsing:
+`@assistant-ui/react-markdown` exports `normalizeMathDelimiters`, which rewrites these to the `$...$` and `$$...$$` form remark-math parses. Pass it to the `preprocess` prop of `MarkdownTextPrimitive`:
 
 ```tsx title="/components/assistant-ui/markdown-text.tsx"
-import { MarkdownTextPrimitive } from "@assistant-ui/react-markdown";
+import {
+  MarkdownTextPrimitive,
+  normalizeMathDelimiters, // [!code ++]
+} from "@assistant-ui/react-markdown";
 
 const MarkdownTextImpl = () => {
   return (
     <MarkdownTextPrimitive
       remarkPlugins={[remarkGfm, remarkMath]}
       rehypePlugins={[rehypeKatex]}
-      preprocess={normalizeCustomMathTags} // [!code ++]
+      preprocess={normalizeMathDelimiters} // [!code ++]
       className="aui-md"
       components={defaultComponents}
     />
   );
 };
+```
 
-// Your LaTeX preprocessing function
-function normalizeCustomMathTags(input: string): string {
-  return (
-    input
-      // Convert [/math]...[/math] to $$...$$
-      .replace(/\[\/math\]([\s\S]*?)\[\/math\]/g, (_, content) => `$$${content.trim()}$$`)
+The individual transforms `rewriteLatexBracketDelimiters` and `rewriteCustomMathTags` are exported too, for finer control over which delimiters are normalized.
+
+<Callout type="info">
+  Using [Streamdown](/docs/ui/streamdown) as your renderer? The same helpers are exported from `@assistant-ui/react-streamdown` and accepted by the `preprocess` prop of `StreamdownTextPrimitive`.
+</Callout>
 
-      // Convert [/inline]...[/inline] to $...$
-      .replace(/\[\/inline\]([\s\S]*?)\[\/inline\]/g, (_, content) => `$${content.trim()}$`)
+### Currency amounts
 
-      // Convert \( ... \) to $...$ (inline math) - handles both single and double backslashes
-      .replace(/\\{1,2}\(([\s\S]*?)\\{1,2}\)/g, (_, content) => `$${content.trim()}$`)
+With single-dollar inline math enabled (the default on the react-markdown path), remark-math reads a lone `$` as a math delimiter, so prose such as `$5 ... $10` is parsed as math. `escapeCurrencyDollars` escapes a `$` immediately followed by a digit so currency survives, while leaving the `$$` of display math intact. Compose it with the delimiter normalization:
 
-      // Convert \[ ... \] to $$...$$ (block math) - handles both single and double backslashes
-      .replace(/\\{1,2}\[([\s\S]*?)\\{1,2}\]/g, (_, content) => `$$${content.trim()}$$`)
-  );
-}
+```tsx title="/components/assistant-ui/markdown-text.tsx"
+import {
+  normalizeMathDelimiters,
+  escapeCurrencyDollars, // [!code ++]
+} from "@assistant-ui/react-markdown";
+
+<MarkdownTextPrimitive
+  preprocess={(text) => escapeCurrencyDollars(normalizeMathDelimiters(text))} // [!code ++]
+  // ...
+/>;
 ```
 
 <Callout type="tip">
-Inside `MarkdownTextPrimitive`, the streamed text first passes through `preprocess` (delimiter normalization) and then through `useSmooth` (character-by-character accumulation), and only then reaches the markdown parser. Both run before remark-math sees the text, so delimiter replacement and the streaming smoothing are streaming-safe — partially-received delimiters are accumulated in the smoothing buffer rather than parsed mid-fragment.
+Inside `MarkdownTextPrimitive`, the streamed text first passes through `preprocess` (delimiter normalization) and then through `useSmooth` (character by character accumulation), and only then reaches the markdown parser. Both run before remark-math sees the text, so delimiter replacement and the streaming smoothing stay streaming safe; a partially received delimiter is accumulated in the smoothing buffer rather than parsed mid fragment.
 </Callout>