@mast-ai/react-ui 0.1.0

package/LICENSE

@@ -0,0 +1,193 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of discussing and
+      improving the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by the combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any patent
+      claim embodied in the Work constitutes direct or contributory patent
+      infringement, then any patent licenses granted to You under this
+      License for that Work shall terminate as of the date such litigation
+      is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or in addition to the
+          NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Contribution, and to permit persons to whom the Contribution is
+      furnished to do so.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any conditions of
+      TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      workstop, computer failure or malfunction, or all other commercial
+      damages or losses), even if such Contributor has been advised of the
+      possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the programming language used. Source files
+      may also indicate a copyright notice separately from the text below.
+
+   Copyright 2026 Andre Cipriani Bandarra
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,57 @@
+# @mast-ai/react-ui
+
+React 19 components and hooks for [MAST](https://github.com/andreban/mast-ai). Turns an `AgentRunner` into a streaming chat UI: a default theme, a complete `<ConversationPanel>` widget, and headless primitives (`useAgent`, `useAgentStream`) for fully custom layouts.
+
+## Install
+
+```bash
+npm install @mast-ai/core @mast-ai/react-ui @tanstack/react-virtual react react-dom
+```
+
+`@tanstack/react-virtual` is a required peer dependency — `<MessageList>` virtualises long conversations. React must be 19.0 or newer.
+
+Optional peer dependencies (auto-detected at runtime if installed):
+
+| Package                                           | Adds                                 |
+| ------------------------------------------------- | ------------------------------------ |
+| `react-markdown`, `remark-gfm`, `rehype-sanitize` | Markdown rendering with sanitisation |
+
+## Quick start
+
+```tsx
+import { AgentRunner, ToolRegistry, createAgent } from '@mast-ai/core';
+import { GoogleGenAIAdapter } from '@mast-ai/google-genai';
+import { GoogleGenAI } from '@google/genai';
+import { AgentProvider, ConversationPanel } from '@mast-ai/react-ui';
+import '@mast-ai/react-ui/styles.css';
+
+const client = new GoogleGenAI({ apiKey: import.meta.env.VITE_GEMINI_API_KEY });
+const adapter = new GoogleGenAIAdapter(client, { model: 'gemini-2.5-flash' });
+const runner = new AgentRunner(adapter, new ToolRegistry());
+const agent = createAgent({ name: 'Assistant', instructions: 'Be helpful.', tools: [] });
+
+export function App() {
+  return (
+    <AgentProvider runner={runner} agent={agent}>
+      <ConversationPanel />
+    </AgentProvider>
+  );
+}
+```
+
+## What's exported
+
+- **`<AgentProvider>` / `useAgent()`** — context that exposes the runner, conversation, and `sendMessage`.
+- **`<ConversationPanel>`** — full chat UI: message list, input, approval prompts, tool call blocks.
+- **Primitives** — `<MessageList>`, `<MessageItem>`, `<UserMessage>`, `<AssistantMessage>`, `<ChatInput>`, `<ToolCallBlock>`, `<ThinkingBlock>`, `<InlineApproval>` for custom layouts.
+- **`useAgentStream()`** — fully headless variant; you own all rendering.
+- **Mentions** — `useMentions()` and helpers for `@`-mention pickers in `<ChatInput>`.
+
+## Documentation
+
+- [Usage guide](https://github.com/andreban/mast-ai/blob/main/docs/react-ui/USAGE.md) — comprehensive walkthrough of every prop and pattern.
+- [API spec](https://github.com/andreban/mast-ai/blob/main/docs/react-ui/SPEC.md) — type reference.
+
+## License
+
+Apache-2.0. Copyright 2026 Andre Cipriani Bandarra.

package/dist/approval.d.ts

@@ -0,0 +1,82 @@
+import type { ToolDefinition, ToolProvider } from '@mast-ai/core';
+import type { ToolCallStatus, ToolEventEntry } from './types';
+/**
+ * Sentinel value returned from {@link OnApprovalRequired} to defer the
+ * decision to the inline approval queue. The proxy enqueues a
+ * {@link PendingApproval} handle on `useAgent().pendingApprovals` and waits
+ * for the consumer (or the built-in `<InlineApproval>` slot) to call
+ * `approve()`, `reject()`, or `respondWith(...)`.
+ *
+ * @example
+ * ```tsx
+ * onApprovalRequired={async (toolCall) => {
+ *   if (toolCall.name === 'set_page_title') return INLINE_APPROVAL;
+ *   return window.confirm(`Allow ${toolCall.name}?`);
+ * }}
+ * ```
+ */
+export declare const INLINE_APPROVAL: unique symbol;
+/**
+ * Callback invoked by {@link AgentProvider} before executing a tool whose
+ * effective approval policy is `true`. Apps render their own confirmation UI
+ * inside this callback and resolve with one of:
+ *
+ * - `true` — proceed with the tool call as normal
+ * - `false` — cancel; the runner receives a synthetic "user cancelled" result
+ * - `string` — skip execution and inject the string directly as the tool result
+ * - {@link INLINE_APPROVAL} — defer to the inline approval queue
+ */
+export type OnApprovalRequired = (toolCall: ToolEventEntry) => Promise<boolean | string | typeof INLINE_APPROVAL>;
+/** Synthetic tool result returned when an approval resolves to `false`. */
+export declare const APPROVAL_CANCELLED_RESULT = "User cancelled the tool call.";
+/**
+ * A live handle for a tool call that is waiting on the inline approval queue.
+ * The library exposes the current set via `useAgent().pendingApprovals` and
+ * passes the matching handle into the `renderApproval` slot.
+ */
+export interface PendingApproval {
+    /** Name of the tool awaiting approval. */
+    toolName: string;
+    /** Arguments the model passed to the tool. */
+    args: unknown;
+    /** Approve the call — proceed with normal tool execution. */
+    approve: () => void;
+    /** Reject the call — runner receives the synthetic cancelled result. */
+    reject: () => void;
+    /** Skip execution and inject `result` as the tool result. */
+    respondWith: (result: string) => void;
+}
+/**
+ * Computes the effective approval requirement for a tool given a list of
+ * runtime overrides. Implements the rule from SPEC §9.3:
+ *
+ * ```
+ * needsApproval = (def.requiresApproval || overrideSet.has(name)) && !suppressSet.has(name)
+ * ```
+ *
+ * Names prefixed with `!` in `approvalOverride` suppress approval; unprefixed
+ * names add it.
+ */
+export declare function computeNeedsApproval(def: ToolDefinition, approvalOverride: readonly string[] | undefined): boolean;
+/** Hooks the proxy uses to drive React state during an approval. */
+export interface ApprovalProxyHooks {
+    /** Called with `true` when waiting starts and `false` when a decision is reached. */
+    notifyAwaiting?: (name: string, awaiting: boolean) => void;
+    /** Called when a decision sets the final tool-call status (e.g. cancelled). */
+    setStatus?: (name: string, status: ToolCallStatus) => void;
+    /**
+     * Pushes a pending approval onto the queue and returns a promise that
+     * resolves once the consumer calls `approve`, `reject`, or `respondWith`.
+     */
+    enqueueInline?: (toolName: string, args: unknown) => Promise<boolean | string>;
+}
+/**
+ * Wraps a {@link ToolProvider} so that tools whose effective approval flag is
+ * `true` are intercepted: the wrapper invokes {@link OnApprovalRequired} before
+ * delegating to the underlying tool. Tools that do not require approval are
+ * returned unchanged.
+ *
+ * The two `get*` parameters are read on every `getTool` call so that React
+ * prop changes are picked up without rebuilding the wrapper.
+ */
+export declare function withApprovalProxy(provider: ToolProvider, getCallback: () => OnApprovalRequired | undefined, getApprovalOverride: () => readonly string[] | undefined, hooks?: ApprovalProxyHooks): ToolProvider;

package/dist/components/AssistantMessage.d.ts

@@ -0,0 +1,44 @@
+import type { ReactNode } from 'react';
+import type { PendingApproval } from '../approval';
+import type { ConversationEntry, ToolEventEntry } from '../types';
+/**
+ * Props accepted by {@link AssistantMessage}.
+ */
+export interface AssistantMessageProps {
+    /** The conversation entry to render. Must have `role === 'assistant'`. */
+    entry: ConversationEntry;
+    /** Optional class added to the root element. */
+    className?: string;
+    /**
+     * Replaces the default text renderer. When provided, takes precedence over
+     * the optional `react-markdown` integration and is invoked for every
+     * non-empty `entry.text`.
+     */
+    renderMessage?: (text: string) => ReactNode;
+    /**
+     * Replaces the default tool-call renderer. Called once per element of
+     * `entry.toolEvents`.
+     *
+     * Receives the tool event and, when the call is awaiting an inline
+     * approval decision, a {@link PendingApproval} handle exposing
+     * `approve()`, `reject()`, and `respondWith()`. Consumers can dispatch on
+     * tool name, and use the bundled `<InlineApproval>` or `<ToolCallBlock>`
+     * components as building blocks.
+     *
+     * When this prop is omitted, the library defaults to rendering
+     * `<InlineApproval>` for tool events with a pending approval handle and
+     * `<ToolCallBlock>` otherwise.
+     */
+    renderToolCall?: (entry: ToolEventEntry, approval?: PendingApproval) => ReactNode;
+}
+/**
+ * Renders an assistant turn: an optional {@link ThinkingBlock}, zero or more
+ * {@link ToolCallBlock}s, then the final text.
+ *
+ * Final text is rendered with `react-markdown` (sanitised via
+ * `rehype-sanitize`) when the optional peer dependencies are installed; it
+ * falls back to a plain `<p>` otherwise. Apps may override either layer via
+ * `renderMessage` (the entire text region) or `renderToolCall` (each tool
+ * invocation) without losing the surrounding wiring.
+ */
+export declare function AssistantMessage({ entry, className, renderMessage, renderToolCall, }: AssistantMessageProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ChatInput.d.ts

@@ -0,0 +1,41 @@
+import type { ReactNode } from 'react';
+import type { MentionsConfig } from '../mentions/types';
+/**
+ * Props accepted by {@link ChatInput}.
+ */
+export interface ChatInputProps {
+    /** Optional class added to the root element. */
+    className?: string;
+    /** Placeholder text shown in the empty textarea. */
+    placeholder?: string;
+    /** Overrides the default send button content (the `send` icon). */
+    sendLabel?: ReactNode;
+    /** Overrides the default cancel button content (the `stop` icon). */
+    cancelLabel?: ReactNode;
+    /**
+     * Opt-in `@`-mention picker. When supplied, the textarea is wrapped in a
+     * compound input that renders inline chips for committed selections and
+     * shows a keyboard-navigable picker while the user types `@<query>`. On
+     * submit, the input calls `sendMessage(prompt, displayText)` so the user
+     * bubble shows the chip form while the LLM receives the augmented prompt
+     * (from `mentions.buildPrompt` if provided, otherwise the inline text).
+     *
+     * Omit to keep the plain textarea behaviour unchanged.
+     */
+    mentions?: MentionsConfig;
+}
+/**
+ * Text input wired to {@link useAgent}.
+ *
+ * - Pressing Enter submits the message; Shift+Enter inserts a newline.
+ * - The textarea grows vertically with content (via the `rows` attribute).
+ * - While a run is in progress the send button is replaced by a cancel button
+ *   that calls `cancel()`. The textarea itself is disabled during the run so
+ *   the user cannot edit while the agent streams.
+ * - Send and cancel slot their content from `useIcons().send` / `.stop` by
+ *   default; consumers can override either via the `sendLabel` / `cancelLabel`
+ *   props without giving up the surrounding accessibility wiring.
+ * - Pass `mentions` to enable the optional `@`-mention picker; see the
+ *   `mentions` package directory for the full API.
+ */
+export declare function ChatInput({ className, placeholder, sendLabel, cancelLabel, mentions, }: ChatInputProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ConversationPanel.d.ts

@@ -0,0 +1,43 @@
+import type { ReactNode } from 'react';
+import type { PendingApproval } from '../approval';
+import type { MentionsConfig } from '../mentions/types';
+import type { ToolEventEntry } from '../types';
+/**
+ * Props accepted by {@link ConversationPanel}.
+ */
+export interface ConversationPanelProps {
+    /**
+     * Forces a theme regardless of the user's `prefers-color-scheme` setting.
+     * When omitted, the panel follows the OS preference via the default
+     * stylesheet's media query.
+     */
+    theme?: 'light' | 'dark';
+    /** Optional class added to the root `[data-mast-root]` element. */
+    className?: string;
+    /**
+     * Replaces the default tool-call renderer for the entire list. Receives a
+     * {@link PendingApproval} handle as the second argument when the call is
+     * awaiting an inline approval decision.
+     */
+    renderToolCall?: (entry: ToolEventEntry, approval?: PendingApproval) => ReactNode;
+    /** Replaces the default assistant text renderer for the entire list. */
+    renderMessage?: (text: string) => ReactNode;
+    /** Placeholder text for the {@link ChatInput} field. */
+    inputPlaceholder?: string;
+    /**
+     * Forwarded to the internal {@link ChatInput} when the optional `@`-mention
+     * picker should be enabled. Omit to keep the plain textarea behaviour.
+     */
+    mentions?: MentionsConfig;
+}
+/**
+ * Renders a complete chat UI as a single composable unit.
+ *
+ * Internally renders {@link MessageList} and {@link ChatInput} inside a
+ * `[data-mast-root]` div so the default stylesheet's CSS custom properties
+ * resolve. Sets `data-mast-theme` from the optional `theme` prop, which the
+ * default stylesheet uses to override the OS-driven dark mode preference.
+ *
+ * Must be rendered inside an `<AgentProvider>`.
+ */
+export declare function ConversationPanel({ theme, className, renderToolCall, renderMessage, inputPlaceholder, mentions, }: ConversationPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/InlineApproval.d.ts

@@ -0,0 +1,26 @@
+import type { ToolEventEntry } from '../types';
+/**
+ * Props passed to a custom `renderApproval` slot and accepted by the
+ * built-in {@link InlineApproval} component.
+ */
+export interface InlineApprovalProps {
+    /** The tool call awaiting approval. */
+    entry: ToolEventEntry;
+    /** Approve the call; the underlying tool will execute. */
+    approve: () => void;
+    /** Reject the call; the runner receives the synthetic cancelled result. */
+    reject: () => void;
+    /** Skip execution and inject `result` as the tool result. */
+    respondWith: (result: string) => void;
+    /** Optional class added to the root element. */
+    className?: string;
+}
+/**
+ * Default UI rendered for tool calls awaiting an inline approval decision.
+ *
+ * Displays the tool name, formatted args, and Approve/Reject buttons. Used by
+ * {@link AssistantMessage} when neither `renderApproval` nor `renderToolCall`
+ * is provided; consumers can also import it directly to compose alongside a
+ * custom `renderApproval` slot.
+ */
+export declare function InlineApproval({ entry, approve, reject, className }: InlineApprovalProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/MessageItem.d.ts

@@ -0,0 +1,29 @@
+import type { ReactNode } from 'react';
+import type { PendingApproval } from '../approval';
+import type { ConversationEntry, ToolEventEntry } from '../types';
+/**
+ * Props accepted by {@link MessageItem}.
+ */
+export interface MessageItemProps {
+    /** The conversation entry to render. */
+    entry: ConversationEntry;
+    /** Optional class added to the inner message component. */
+    className?: string;
+    /**
+     * Forwarded to {@link AssistantMessage}. Has no effect when `entry.role` is
+     * `'user'`.
+     */
+    renderToolCall?: (entry: ToolEventEntry, approval?: PendingApproval) => ReactNode;
+    /**
+     * Forwarded to {@link AssistantMessage}. Has no effect when `entry.role` is
+     * `'user'`.
+     */
+    renderMessage?: (text: string) => ReactNode;
+}
+/**
+ * Renders a single {@link ConversationEntry} by dispatching to
+ * {@link UserMessage} or {@link AssistantMessage} based on `entry.role`.
+ *
+ * Used by {@link MessageList} to render each virtualised row.
+ */
+export declare function MessageItem({ entry, className, renderToolCall, renderMessage }: MessageItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/MessageList.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react';
+import type { PendingApproval } from '../approval';
+import type { ToolEventEntry } from '../types';
+/**
+ * Props accepted by {@link MessageList}.
+ */
+export interface MessageListProps {
+    /** Optional class added to the scrollable root element. */
+    className?: string;
+    /**
+     * Forwarded to each {@link MessageItem} so consumers can replace the default
+     * tool call renderer for the entire list. Receives a {@link PendingApproval}
+     * handle as the second argument when the call is awaiting an inline approval
+     * decision.
+     */
+    renderToolCall?: (entry: ToolEventEntry, approval?: PendingApproval) => ReactNode;
+    /**
+     * Forwarded to each {@link MessageItem} so consumers can replace the default
+     * assistant text renderer for the entire list.
+     */
+    renderMessage?: (text: string) => ReactNode;
+}
+/**
+ * Scrollable list of {@link ConversationEntry} items rendered with
+ * `@tanstack/react-virtual`.
+ *
+ * Only the visible window of messages is mounted, so long-running conversations
+ * stay performant. Item heights are dynamic: each rendered row is observed via
+ * `virtualizer.measureElement`, so messages with long tool call results or
+ * large markdown blocks expand the viewport correctly.
+ *
+ * Auto-scrolls to the bottom whenever a new entry is appended or the last
+ * entry's `text` grows during streaming.
+ *
+ * Reads `messages` from `useAgent()`, so this component must be rendered
+ * inside an `<AgentProvider>`.
+ */
+export declare function MessageList({ className, renderToolCall, renderMessage }: MessageListProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ThinkingBlock.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Props accepted by {@link ThinkingBlock}.
+ */
+export interface ThinkingBlockProps {
+    /** The accumulated thinking/reasoning text to display when expanded. */
+    content: string;
+    /**
+     * `true` while the assistant is still streaming thinking deltas.
+     * Drives a pulsing indicator next to the label.
+     */
+    isStreaming?: boolean;
+    /** Optional class added to the root `<details>` element. */
+    className?: string;
+    /** Header label. Default: `'Thinking Process'`. */
+    label?: string;
+    /**
+     * When provided, controls the `open` attribute on the root `<details>`
+     * element. Useful for auto-expanding the block while streaming and letting
+     * it collapse afterwards (e.g. inside `<ToolCallBlock>`). When omitted, the
+     * block defaults to collapsed and is toggled by the user.
+     */
+    open?: boolean;
+}
+/**
+ * Collapsible section for the agent's thinking/reasoning trace.
+ *
+ * Rendered as a native `<details>/<summary>` element so it is keyboard
+ * accessible and works without JavaScript. Collapsed by default; consumers
+ * can override the appearance via the default stylesheet's `mast-thinking-*`
+ * classes or by passing a custom `className`.
+ */
+export declare function ThinkingBlock({ content, isStreaming, className, label, open, }: ThinkingBlockProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ToolCallBlock.d.ts

@@ -0,0 +1,11 @@
+import type { ToolEventEntry } from '../types';
+/**
+ * Props accepted by {@link ToolCallBlock}.
+ */
+export interface ToolCallBlockProps {
+    /** The tool invocation to render. */
+    entry: ToolEventEntry;
+    /** Optional class added to the root element. */
+    className?: string;
+}
+export declare function ToolCallBlock({ entry, className }: ToolCallBlockProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/UserMessage.d.ts

@@ -0,0 +1,19 @@
+import type { ConversationEntry } from '../types';
+/**
+ * Props accepted by {@link UserMessage}.
+ */
+export interface UserMessageProps {
+    /** The conversation entry to render. Must have `role === 'user'`. */
+    entry: ConversationEntry;
+    /** Optional class added to the root element. */
+    className?: string;
+}
+/**
+ * Renders a user turn as a simple text bubble.
+ *
+ * Outputs the raw `entry.text` inside a `[data-mast-user-message]` wrapper so
+ * the default stylesheet's `mast-user-*` classes can theme it as a chat
+ * bubble. User input is intentionally rendered as plain text with no
+ * markdown processing.
+ */
+export declare function UserMessage({ entry, className }: UserMessageProps): import("react/jsx-runtime").JSX.Element;