@comma-agents/tui 2.0.0-rc.0

package/dist/components/Frame/Frame.d.ts

@@ -0,0 +1,48 @@
+import type React from "react";
+import type { FrameTheme } from "./Frame.theme";
+/** Definition of a single tab in the Frame header. */
+export interface TabDefinition {
+    /** Route path this tab navigates to (e.g. "/chat"). */
+    readonly path: string;
+    /** Display label for the tab. */
+    readonly label: string;
+    /** Alt+number shortcut hint (e.g. "Alt+1"). */
+    readonly shortcut: string;
+}
+export interface FrameProps {
+    /**
+     * The route path of the currently active tab. Should match one of the
+     * `path` values in `tabs`. Used to highlight the correct tab header.
+     */
+    readonly activeTabPath: string;
+    /** Tab definitions to render in the header. */
+    readonly tabs: readonly TabDefinition[];
+    /** Called when the user selects a tab (by keyboard or click). */
+    readonly onTabSelect: (path: string) => void;
+    /** Content to render in the body area (the active page). */
+    readonly children: React.ReactNode;
+    /** Content rendered at the bottom of the frame (pinned). */
+    readonly footer?: React.ReactNode;
+}
+export declare function Frame({ activeTabPath, tabs, onTabSelect, children, footer, }: FrameProps): React.ReactElement;
+export interface FrameRenderProps {
+    /** Resolved theme style objects. */
+    readonly theme: FrameTheme;
+    /** Route path of the currently active tab. */
+    readonly activeTabPath: string;
+    /** Tab definitions to render in the header. */
+    readonly tabs: readonly TabDefinition[];
+    /** Terminal height in rows, used to size the root container. */
+    readonly terminalHeight: number;
+    /** Terminal width in columns, used to size the root container. */
+    readonly terminalWidth: number;
+    /** Called when a tab is selected. */
+    readonly onTabSelect: (path: string) => void;
+    /** Content to render in the body area. */
+    readonly children: React.ReactNode;
+    /** Content rendered at the bottom of the frame (pinned). */
+    readonly footer?: React.ReactNode;
+    /** Debug render ref to attach to root Box. */
+    readonly debugRef?: React.Ref<import("ink").DOMElement>;
+}
+export declare function FrameRender({ theme, activeTabPath, tabs, terminalHeight, terminalWidth, onTabSelect, children, footer, debugRef, }: FrameRenderProps): React.ReactElement;

package/dist/components/Frame/Frame.theme.d.ts

@@ -0,0 +1,52 @@
+/** Spread-ready style objects for the Frame component. */
+export interface FrameTheme {
+    /** Root container (column layout). Height is set dynamically by the container. */
+    readonly root: {
+        readonly flexDirection: "column";
+        readonly backgroundColor: string;
+    };
+    /** Tab bar container. */
+    readonly tabBar: {
+        readonly flexDirection: "row";
+        readonly gap: number;
+        readonly paddingX: number;
+        readonly marginBottom: number;
+    };
+    /** Style for an active tab label. */
+    readonly activeTab: {
+        readonly bold: boolean;
+        readonly color: string;
+        readonly underline: boolean;
+    };
+    /** Style for an inactive tab label. */
+    readonly inactiveTab: {
+        readonly dimColor: boolean;
+    };
+    /**
+     * Style applied (merged on top of the active/inactive style) when the
+     * pointer is hovering over a tab. Only sets the visual highlight —
+     * underline / bold come from the base style.
+     */
+    readonly hoveredTab: {
+        readonly color: string;
+        readonly bold: boolean;
+    };
+    /** Style for the tab shortcut hint (e.g. "Alt+1"). */
+    readonly tabHint: {
+        readonly dimColor: boolean;
+    };
+    /** Content area below the tab bar (grows to fill available space). */
+    readonly content: {
+        readonly flexDirection: "column";
+        readonly flexGrow: number;
+    };
+    /** Footer area pinned to the bottom of the frame. */
+    readonly footer: {
+        readonly flexDirection: "column";
+    };
+}
+/**
+ * Returns themed style objects for the Frame component.
+ * Consumes global tokens via `useTheme()`.
+ */
+export declare function useFrameTheme(): FrameTheme;

package/dist/components/Frame/index.d.ts

@@ -0,0 +1,4 @@
+export type { FrameProps, FrameRenderProps, TabDefinition } from "./Frame";
+export { Frame, FrameRender } from "./Frame";
+export type { FrameTheme } from "./Frame.theme";
+export { useFrameTheme } from "./Frame.theme";

package/dist/components/Hide/Hide.d.ts

@@ -0,0 +1,20 @@
+import type React from "react";
+import type { HideProps } from "./Hide.types";
+/**
+ * Conditionally hide children based on terminal width.
+ *
+ * Accepts either a named breakpoint (`"sm"`, `"md"`, etc.) or a raw
+ * column count for both `below` and `above` props.
+ *
+ * @param props - Visibility conditions and children.
+ * @example
+ * ```tsx
+ * <Hide below="md">
+ *   <DetailedSidebar />
+ * </Hide>
+ * <Hide below={128}>
+ *   <TitleLogo />
+ * </Hide>
+ * ```
+ */
+export declare function Hide({ below, above, children }: HideProps): React.ReactNode;

package/dist/components/Hide/Hide.types.d.ts

@@ -0,0 +1,12 @@
+import type { BreakpointName } from "../../Theme";
+/** A breakpoint name or a specific column width. */
+export type BreakpointOrColumns = BreakpointName | number;
+/** Props for the `Hide` component. */
+export interface HideProps {
+    /** Hide children when terminal width is below this breakpoint or column count. */
+    readonly below?: BreakpointOrColumns;
+    /** Hide children when terminal width is at or above this breakpoint or column count. */
+    readonly above?: BreakpointOrColumns;
+    /** Child content to conditionally render. */
+    readonly children: React.ReactNode;
+}

package/dist/components/Hide/index.d.ts

@@ -0,0 +1,2 @@
+export { Hide } from "./Hide";
+export type { BreakpointOrColumns, HideProps } from "./Hide.types";

package/dist/components/MessageList/AgentMessage/AgentMessage.d.ts

@@ -0,0 +1,71 @@
+import type React from "react";
+import type { ChatMessage, MessageSegment } from "../../../hooks/useChat/useChat.types";
+import { useMessageListTheme } from "../MessageList.theme";
+import type { GroupedChatMessage } from "../MessageList.types";
+/**
+ * Truncate long tool-call argument blobs so they fit a single visual line.
+ */
+export declare const MAX_TOOL_ARGS_PREVIEW_LENGTH = 200;
+export interface AgentMessageProps {
+    /** Display name of the agent (e.g. "planner", "builder"). */
+    readonly sender: string;
+    /**
+     * Ordered body segments. When omitted, `fallbackText` is rendered as a
+     * single text segment so the component still works for legacy/simple
+     * messages that don't yet emit segmented events.
+     */
+    readonly segments?: readonly MessageSegment[];
+    /** Plain text body used when `segments` is empty or undefined. */
+    readonly fallbackText: string;
+    /** Whether the message is still receiving streaming events. */
+    readonly streaming: boolean;
+    /** Provider/model identifier used for this call. */
+    readonly model?: string;
+    /** Maximum model context tokens, when known. */
+    readonly contextWindow?: number;
+    /** Final model-step context usage. */
+    readonly contextUsage?: ChatMessage["contextUsage"];
+    /** Call start timestamp in milliseconds. */
+    readonly startedAt: number;
+    /** Call completion timestamp in milliseconds. */
+    readonly completedAt?: number;
+    /** Messages emitted by `launch_strategy` calls inside this agent message. */
+    readonly subMessages?: readonly GroupedChatMessage[];
+    /** Opens a spawned strategy transcript in its dedicated page. */
+    readonly onOpenSubStrategy?: (toolCallId: string) => void;
+}
+/**
+ * Renders a single agent message with rich, ordered body segments.
+ *
+ * Each segment kind (text, tool-call, tool-result, thinking)
+ * gets its own visual treatment so that the user can distinguish the
+ * agent's prose from its tool invocations and reasoning at a glance.
+ */
+export declare function AgentMessage({ sender, segments, fallbackText, streaming, model, contextWindow, contextUsage, startedAt, completedAt, subMessages, onOpenSubStrategy, }: AgentMessageProps): React.ReactElement;
+export interface AgentMessageRenderProps {
+    /** Resolved MessageList theme styles. */
+    readonly theme: ReturnType<typeof useMessageListTheme>;
+    /** Display name of the agent. */
+    readonly sender: string;
+    /** Ordered body segments. */
+    readonly segments: readonly MessageSegment[];
+    /** Whether the message is still receiving streaming events. */
+    readonly streaming: boolean;
+    readonly model?: string;
+    readonly contextWindow?: number;
+    readonly contextUsage?: ChatMessage["contextUsage"];
+    readonly startedAt: number;
+    readonly completedAt?: number;
+    /** Messages emitted by `launch_strategy` calls inside this agent message. */
+    readonly subMessages: readonly GroupedChatMessage[];
+    /** Opens a spawned strategy transcript in its dedicated page. */
+    readonly onOpenSubStrategy?: (toolCallId: string) => void;
+}
+export declare function AgentMessageRender({ theme, sender, segments, streaming, model, contextWindow, contextUsage, startedAt, completedAt, subMessages, onOpenSubStrategy, }: AgentMessageRenderProps): React.ReactElement;
+/**
+ * Trim long argument blobs to a single-line preview suffixed with ellipsis.
+ *
+ * Exported so the row-height estimator can compute heights against the
+ * exact same string the renderer will draw.
+ */
+export declare function truncatePreview(value: string): string;

package/dist/components/MessageList/AgentMessage/index.d.ts

@@ -0,0 +1,2 @@
+export type { AgentMessageProps, AgentMessageRenderProps, } from "./AgentMessage";
+export { AgentMessage, AgentMessageRender } from "./AgentMessage";

package/dist/components/MessageList/ContextUsageModal/ContextUsageModal.constants.d.ts

@@ -0,0 +1,2 @@
+/** Single shared modal id for context-usage details. */
+export declare const CONTEXT_USAGE_MODAL_ID = "context-usage";

package/dist/components/MessageList/ContextUsageModal/ContextUsageModal.d.ts

@@ -0,0 +1,9 @@
+import type React from "react";
+import type { ContextUsageModalPayload } from "./ContextUsageModal.types";
+/** Modal showing the detailed token breakdown behind the context meter. */
+export declare function ContextUsageModal(): React.ReactElement | null;
+export interface ContextUsageModalRenderProps {
+    /** Context usage details to render. */
+    readonly payload: ContextUsageModalPayload;
+}
+export declare function ContextUsageModalRender({ payload, }: ContextUsageModalRenderProps): React.ReactElement;

package/dist/components/MessageList/ContextUsageModal/ContextUsageModal.types.d.ts

@@ -0,0 +1,12 @@
+import type { ContextUsageWire } from "@comma-agents/daemon";
+/** Payload carried when opening the context usage details modal. */
+export interface ContextUsageModalPayload {
+    /** Agent name shown in the modal title. */
+    readonly agentName: string;
+    /** Provider/model identifier used for the agent call. */
+    readonly model?: string;
+    /** Maximum context window for the model, when known. */
+    readonly contextWindow?: number;
+    /** Final model-step context usage to display. */
+    readonly contextUsage: ContextUsageWire;
+}

package/dist/components/MessageList/ContextUsageModal/index.d.ts

@@ -0,0 +1,4 @@
+export type { ContextUsageModalRenderProps } from "./ContextUsageModal";
+export { ContextUsageModal, ContextUsageModalRender, } from "./ContextUsageModal";
+export { CONTEXT_USAGE_MODAL_ID } from "./ContextUsageModal.constants";
+export type { ContextUsageModalPayload } from "./ContextUsageModal.types";

package/dist/components/MessageList/MarkdownView/MarkdownView.constants.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Heading prefix glyph rendered before the heading text. Mirrors how
+ * shells display headings (e.g. `# h1`) so users recognise the level
+ * without relying on font weight alone.
+ *
+ * The `#` count matches the heading depth (1..6).
+ */
+export declare const HEADING_PREFIX_CHAR = "#";
+/**
+ * Bullet glyph for unordered lists. Single cell wide for predictable
+ * column alignment when the row estimator counts wrapped widths.
+ */
+export declare const UNORDERED_LIST_BULLET = "\u2022";
+/**
+ * Indent applied per nesting level for nested lists. Two spaces matches
+ * the source-text indent used by `marked`'s loose tokenizer and keeps
+ * arithmetic with the row estimator simple.
+ */
+export declare const LIST_INDENT_PER_LEVEL = 2;
+/**
+ * Glyph drawn at the head of every blockquote line. Vertical bar is
+ * the most readable terminal-safe blockquote marker.
+ */
+export declare const BLOCKQUOTE_PREFIX = "\u2502 ";
+/**
+ * Glyph used to render `<hr>` markdown. Repeated to a sensible width;
+ * the renderer picks the actual repetition count based on the viewport.
+ */
+export declare const HORIZONTAL_RULE_CHAR = "\u2500";
+/**
+ * Default character width for the horizontal rule when the renderer is
+ * not provided a viewport width. Matches the global
+ * {@link Theme.separator.width} fallback in `theme.ts`.
+ */
+export declare const HORIZONTAL_RULE_DEFAULT_WIDTH = 60;
+/**
+ * Number of trailing rendered lines to keep when summarising a
+ * `thinking` segment in the agent message. Anything earlier is
+ * truncated and replaced with a `\u2026` ellipsis line.
+ *
+ * Five lines is a compromise between giving the user a sense of the
+ * agent's reasoning shape and keeping long deliberations from
+ * dominating the viewport.
+ */
+export declare const THINKING_TRUNCATION_LINE_COUNT = 5;
+/**
+ * Single-character ellipsis appended to truncated thinking output.
+ * Matches the rest of the codebase (`AgentMessage.tsx`,
+ * `ToolCallView.constants.ts`).
+ */
+export declare const THINKING_ELLIPSIS_LINE = "\u2026";

package/dist/components/MessageList/MarkdownView/MarkdownView.d.ts

@@ -0,0 +1,34 @@
+import type React from "react";
+import type { MarkdownViewProps, MarkdownViewRenderProps } from "./MarkdownView.types";
+import { inlineSpansToPlainText } from "./MarkdownView.utils";
+/**
+ * Render a Markdown source string as themed Ink elements.
+ *
+ * Lex-and-render: the source is re-tokenised on every render so
+ * streaming agent output (which appends to the same string between
+ * frames) renders as soon as new tokens close. `marked` auto-finalises
+ * unfinished fences/lists, so partial output never visually corrupts —
+ * the worst case is a paragraph that flips into a code-block once the
+ * trailing fence arrives.
+ *
+ * Component is intentionally render-pure beyond the lex step so it
+ * can be measured by `ScrollableView` via Ink's headless `measureLayout`
+ * without producing different output than the live render.
+ */
+export declare function MarkdownView({ markdown, width, }: MarkdownViewProps): React.ReactElement;
+/**
+ * Pure render half of {@link MarkdownView}.
+ *
+ * Split out so unit tests can drive the renderer with a hand-crafted
+ * block tree and a stub theme without having to round-trip through the
+ * `marked` lexer. Same pattern as
+ * {@link import("../../CodeView").CodeViewRender} and
+ * {@link import("../ToolCallView").ToolCallViewRender}.
+ */
+export declare function MarkdownViewRender({ blocks, theme, width, }: MarkdownViewRenderProps): React.ReactElement;
+/**
+ * Convenience re-export so `AgentMessage`'s row estimator can pick up
+ * the same plain-text projection the renderer uses for tables and
+ * tests without depending on the utils file directly.
+ */
+export { inlineSpansToPlainText };

package/dist/components/MessageList/MarkdownView/MarkdownView.theme.d.ts

@@ -0,0 +1,89 @@
+import { type ThemeOf } from "../../../Theme";
+/** Memoized themed style objects for the {@link MarkdownView} component. */
+export declare const useMarkdownViewTheme: () => {
+    /** Outer container wrapping the entire rendered document. */
+    root: {
+        flexDirection: "column";
+    };
+    /** Container for a paragraph block. */
+    paragraph: {
+        flexDirection: "column";
+    };
+    /** Container row for a single list item. */
+    listItemRow: {
+        flexDirection: "row";
+    };
+    /** Bullet / ordinal column at the start of a list-item row. */
+    listMarker: {
+        color: string;
+        bold: boolean;
+    };
+    /** Inner column used to stack the item's content + nested blocks. */
+    listItemContent: {
+        flexDirection: "column";
+    };
+    /** Container for a blockquote (vertical-bar prefix is part of every line). */
+    blockquote: {
+        flexDirection: "column";
+    };
+    /** Style of the leading vertical-bar marker on each blockquote line. */
+    blockquoteMarker: {
+        color: string;
+        dimColor: boolean;
+    };
+    /** Heading text style; depth is applied by the renderer via the depth prefix. */
+    heading: {
+        bold: boolean;
+        color: string;
+    };
+    /** Faint heading prefix (e.g. `## `) so the depth is unambiguous. */
+    headingPrefix: {
+        dimColor: boolean;
+        color: string;
+    };
+    /** Inline `code` span style. */
+    inlineCode: {
+        color: string;
+    };
+    /** Inline `[text](url)` link text style. */
+    linkText: {
+        color: string;
+        underline: true;
+    };
+    /** Inline link's `(url)` companion style — dimmer than the text. */
+    linkUrl: {
+        color: string;
+        dimColor: boolean;
+    };
+    /** Strong / bold inline style. */
+    strong: {
+        bold: true;
+    };
+    /** Emphasised / italic inline style. */
+    em: {
+        italic: true;
+    };
+    /** Container around a horizontal rule. */
+    horizontalRule: {
+        flexDirection: "row";
+    };
+    /** Style of the horizontal rule glyph. */
+    horizontalRuleText: {
+        dimColor: boolean;
+        color: string;
+    };
+    /** Container around a rendered cli-table block. */
+    table: {
+        flexDirection: "column";
+    };
+    /** Style of the cli-table text payload. */
+    tableText: {
+        color: string;
+    };
+    /** Wrapper for plain paragraph text. */
+    paragraphText: {
+        wrap: "wrap";
+    };
+};
+/** Resolved style object shape returned by {@link useMarkdownViewTheme}. */
+export type MarkdownViewTheme = ThemeOf<typeof useMarkdownViewTheme>;

package/dist/components/MessageList/MarkdownView/MarkdownView.types.d.ts

@@ -0,0 +1,96 @@
+import type { BundledLanguage } from "shiki/langs";
+import type { MarkdownViewTheme } from "./MarkdownView.theme";
+/**
+ * Inline span — a leaf or one level of nested formatting that lives
+ * inside a single line of flowing text (paragraph, heading, list item,
+ * blockquote, table cell).
+ *
+ * The renderer flattens these into a single Ink `<Text>` element with
+ * nested `<Text>` style fragments, which is the only nesting Ink
+ * supports for inline styling.
+ */
+export type MdInline = {
+    readonly kind: "text";
+    readonly value: string;
+} | {
+    readonly kind: "strong";
+    readonly children: readonly MdInline[];
+} | {
+    readonly kind: "em";
+    readonly children: readonly MdInline[];
+} | {
+    readonly kind: "code";
+    readonly value: string;
+} | {
+    readonly kind: "link";
+    readonly text: string;
+    readonly href: string;
+};
+/**
+ * Block-level node — top-level entity in the rendered Markdown
+ * document. Each block becomes one or more Ink `<Box>`/`<Text>`
+ * elements, separated by a single blank row from its neighbour.
+ */
+export type MdBlock = {
+    readonly kind: "paragraph";
+    readonly children: readonly MdInline[];
+} | {
+    readonly kind: "heading";
+    /** Heading depth, clamped to `1..6` to match Markdown spec. */
+    readonly depth: 1 | 2 | 3 | 4 | 5 | 6;
+    readonly children: readonly MdInline[];
+} | {
+    readonly kind: "list";
+    readonly ordered: boolean;
+    /** 1-based starting index for ordered lists; ignored when `!ordered`. */
+    readonly start: number;
+    readonly items: readonly MdListItem[];
+} | {
+    readonly kind: "blockquote";
+    readonly children: readonly MdBlock[];
+} | {
+    readonly kind: "code";
+    /** Raw source text of the fenced block (no surrounding fences). */
+    readonly value: string;
+    /** Language identifier as written after the opening fence; may be empty. */
+    readonly language: string;
+} | {
+    readonly kind: "table";
+    readonly header: readonly (readonly MdInline[])[];
+    readonly rows: readonly (readonly (readonly MdInline[])[])[];
+} | {
+    readonly kind: "hr";
+};
+/** A single list item (may itself contain nested blocks). */
+export interface MdListItem {
+    /** Inline content of the item's first line. */
+    readonly children: readonly MdInline[];
+    /** Nested blocks (e.g. a sub-list) rendered indented under the item. */
+    readonly nested: readonly MdBlock[];
+}
+/** Props for the {@link MarkdownView} container. */
+export interface MarkdownViewProps {
+    /** Raw Markdown source. */
+    readonly markdown: string;
+    /**
+     * Optional override for the column width used to size the horizontal
+     * rule and the table layout. Defaults to
+     * {@link HORIZONTAL_RULE_DEFAULT_WIDTH}.
+     */
+    readonly width?: number;
+}
+/** Props for the pure {@link MarkdownViewRender} function. */
+export interface MarkdownViewRenderProps {
+    /** Block tree to render. */
+    readonly blocks: readonly MdBlock[];
+    /** Resolved theme styles. */
+    readonly theme: MarkdownViewTheme;
+    /** Effective column width for layout-sensitive blocks (hr, table). */
+    readonly width: number;
+}
+/**
+ * Re-export of shiki's bundled language union so the table-renderer's
+ * fenced-code dispatch can advertise its accepted set without each
+ * call site importing shiki directly.
+ */
+export type FencedLanguage = BundledLanguage;

package/dist/components/MessageList/MarkdownView/MarkdownView.utils.d.ts

@@ -0,0 +1,58 @@
+import type { MdBlock, MdInline } from "./MarkdownView.types";
+/**
+ * Convert raw Markdown source into our normalized
+ * {@link MdBlock} tree.
+ *
+ * `marked` is invoked in lexer-only mode — we never call `marked.parse`
+ * because we don't want HTML output, we want a renderable AST. Unknown
+ * or unsupported token types collapse into a paragraph containing
+ * their `raw` text so nothing is silently dropped from the rendered
+ * message.
+ *
+ * The function is pure and synchronous — same input always produces
+ * the same output. It's safe to invoke on every render even while a
+ * segment is streaming because `marked.lexer` is fast (microseconds
+ * for typical chat messages) and auto-closes incomplete fenced blocks
+ * by emitting them as code tokens.
+ */
+export declare function tokenizeMarkdown(source: string): readonly MdBlock[];
+/**
+ * Flatten an inline span tree into its plain-text content.
+ *
+ * Used for:
+ * - table cells, where `cli-table3` measures column widths against the
+ *   plain content (style escapes break its width math);
+ * - the row-height estimator, which counts wrapped widths against the
+ *   same characters the renderer will draw.
+ *
+ * Links are rendered as `text (url)` to match the inline renderer's
+ * decision (see {@link MarkdownViewProps}).
+ */
+export declare function inlineSpansToPlainText(spans: readonly MdInline[]): string;
+/**
+ * Render a parsed Markdown table to a single ASCII string suitable for
+ * a single Ink `<Text>` element. Column widths and borders are
+ * delegated to `cli-table3` which sizes each column to its widest
+ * cell. The output is plain (no shell colours) so Ink's line-wrap
+ * stays accurate.
+ */
+export declare function renderTableToText(header: readonly (readonly MdInline[])[], rows: readonly (readonly (readonly MdInline[])[])[]): string;
+/**
+ * Truncate `text` to its last {@link THINKING_TRUNCATION_LINE_COUNT}
+ * lines, prepending an ellipsis line to indicate truncation occurred.
+ *
+ * Operates on already-rendered lines (i.e. post-Markdown layout). When
+ * the input has fewer lines than the cap the original string is
+ * returned unchanged so short reasoning passes don't grow an extra
+ * marker line.
+ *
+ * Pure — no allocation when the input fits.
+ */
+export declare function truncateToLastNLines(text: string, lineCount: number): string;
+/**
+ * Convenience wrapper around {@link truncateToLastNLines} bound to the
+ * Phase-2 default cap. Exists so call sites read declaratively
+ * (`truncateThinking(text)`) and the constant stays a single source
+ * of truth.
+ */
+export declare function truncateThinking(text: string): string;

package/dist/components/MessageList/MarkdownView/index.d.ts

@@ -0,0 +1,6 @@
+export { MarkdownView, MarkdownViewRender } from "./MarkdownView";
+export { HEADING_PREFIX_CHAR, HORIZONTAL_RULE_CHAR, HORIZONTAL_RULE_DEFAULT_WIDTH, LIST_INDENT_PER_LEVEL, THINKING_ELLIPSIS_LINE, THINKING_TRUNCATION_LINE_COUNT, UNORDERED_LIST_BULLET, } from "./MarkdownView.constants";
+export type { MarkdownViewTheme } from "./MarkdownView.theme";
+export { useMarkdownViewTheme } from "./MarkdownView.theme";
+export type { MarkdownViewProps, MarkdownViewRenderProps, MdBlock, MdInline, MdListItem, } from "./MarkdownView.types";
+export { inlineSpansToPlainText, renderTableToText, tokenizeMarkdown, truncateThinking, truncateToLastNLines, } from "./MarkdownView.utils";

package/dist/components/MessageList/MessageList.d.ts

@@ -0,0 +1,20 @@
+import type React from "react";
+import type { ChatMessage } from "../../hooks/useChat/useChat.types";
+import type { GroupedChatMessage, MessageListProps, MessageListRenderProps } from "./MessageList.types";
+/**
+ * Scrollable, role-dispatching message list.
+ *
+ * Wraps `ScrollableView` so the user can scroll back through history with
+ * the mouse wheel. The list auto-pins to the latest message until the user
+ * scrolls up; once they scroll back down to the bottom, auto-pin re-engages
+ * — standard chat behavior. There is no concept of a "selected" message,
+ * so keyboard arrow-key navigation is intentionally absent.
+ */
+export declare function MessageList({ messages, onOpenSubStrategy, }: MessageListProps): React.ReactElement;
+export declare function MessageListRender({ messages, debugRef, containerProps, emptyStateProps, emptyStateTextProps, onOpenSubStrategy, }: MessageListRenderProps): React.ReactElement;
+/** Build a nested message tree from `parentToolCallId` lineage metadata. */
+export declare function groupSubStrategyMessages(messages: readonly ChatMessage[]): readonly GroupedChatMessage[];
+/** Return only messages emitted by a launch call and its nested launches. */
+export declare function selectSubStrategyMessages(messages: readonly ChatMessage[], toolCallId: string): readonly ChatMessage[];
+/** Resolve the strategy name advertised by a launch tool call. */
+export declare function findSubStrategyName(messages: readonly ChatMessage[], toolCallId: string): string;