@arbidocs/blocks 0.3.185 → 0.4.1

package/dist/chat/ContextPanel.d.ts

@@ -0,0 +1,108 @@
+import { type MouseEventHandler, type ReactNode } from 'react';
+import { type ButtonProps } from '@arbidocs/react/ui';
+/**
+ * Parts of the composer's "in this chat" panels (files, facts): a card that opens upward from the
+ * composer, a grouped pick list, and below it the labels, search and bulk actions.
+ */
+/** The card itself: width follows the chat input (`--chat-input-width`), bounded on small screens. */
+export declare const ContextPanelContent: import("react").ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-hover-card").HoverCardContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export interface ContextPickerGroup {
+    key: string;
+    heading: string;
+    /** Id of the heading element. */
+    testId?: string;
+    /** Shown after the heading as `(n)`. */
+    count: number;
+    children: ReactNode;
+}
+export interface ContextPickerListProps {
+    groups: ContextPickerGroup[];
+    /** Shown instead of the groups when every group is empty. */
+    emptyText: string;
+    testId: string;
+    className?: string;
+}
+/**
+ * Two (or more) headed groups, e.g. "In this conversation" then "In this workspace". Each heading
+ * pins to the top of the scroller and is pushed out by the next one; the second parks below the
+ * first (32px = a heading's own height), so both stay visible however far down you scroll.
+ */
+export declare function ContextPickerList({ groups, emptyText, testId, className, }: ContextPickerListProps): import("react").JSX.Element;
+export interface ContextPickerRowProps {
+    isSelected: boolean;
+    onToggle: () => void;
+    testId?: string;
+    children: ReactNode;
+}
+/** A whole-row toggle (e.g. a fact): check glyph then clamped text. */
+export declare function ContextPickerRow({ isSelected, onToggle, testId, children, }: ContextPickerRowProps): import("react").JSX.Element;
+export interface ContextCheckRowProps {
+    isSelected: boolean;
+    /** The check toggle: accessible name (e.g. "Add to conversation"), handler and test id. */
+    toggle: {
+        label: string;
+        onToggle: () => void;
+        testId?: string;
+    };
+    /** Status glyph between the toggle and the content. */
+    status?: ReactNode;
+    testId?: string;
+    /** The row's content (e.g. a document pill that opens the document). */
+    children: ReactNode;
+}
+/** A row with its own check toggle plus a content slot (e.g. a document, which opens on click). */
+export declare function ContextCheckRow({ isSelected, toggle, status, testId, children, }: ContextCheckRowProps): import("react").JSX.Element;
+export interface ContextSelectListProps {
+    children: ReactNode;
+}
+/** Compact single-select list (e.g. choose the document to pin). */
+export declare function ContextSelectList({ children }: ContextSelectListProps): import("react").JSX.Element;
+export interface ContextSelectRowProps {
+    isSelected: boolean;
+    onSelect: MouseEventHandler<HTMLButtonElement>;
+    status?: ReactNode;
+    title: string;
+    testId?: string;
+}
+export declare function ContextSelectRow({ isSelected, onSelect, status, title, testId, }: ContextSelectRowProps): import("react").JSX.Element;
+export interface ContextPanelFooterProps {
+    /** Label shortcut chips (host-supplied row). */
+    labels?: ReactNode;
+    /** The search box. */
+    search: ReactNode;
+    /** Icon + title of the panel; omit when tabs already name it. */
+    title?: ReactNode;
+    /** The action buttons, right aligned. */
+    actions: ReactNode;
+}
+/** Everything below the list: the panel opens upward, so its controls sit nearest the button. */
+export declare function ContextPanelFooter({ labels, search, title, actions }: ContextPanelFooterProps): import("react").JSX.Element;
+export declare const ContextSearchInput: import("react").ForwardRefExoticComponent<Omit<Omit<import("@arbidocs/react").InputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export interface ContextActionButtonProps extends Omit<ButtonProps, 'size'> {
+    icon?: ReactNode;
+    /** Badge after the label; hidden at 0 / undefined. */
+    count?: number;
+    /** Put the icon after the label (bulk Add / Remove) rather than before it. */
+    isIconTrailing?: boolean;
+}
+/** Compact action of the panel footer (stops click propagation so the card stays open). */
+export declare const ContextActionButton: import("react").ForwardRefExoticComponent<ContextActionButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface ContextTab {
+    value: string;
+    /** Visible tab name, e.g. "Documents". */
+    label: string;
+    /** Count shown in the tab label. */
+    count: number;
+    testId?: string;
+    content: ReactNode;
+}
+export interface ContextPanelTabsProps {
+    tabs: ContextTab[];
+    value: string;
+    onValueChange: (value: string) => void;
+    testId?: string;
+    /** Extra classes for the tab strip (e.g. leave room for a sheet's close button). */
+    listClassName?: string;
+}
+/** The panel's tab strip (Radix tabs: roving tabindex, arrow keys) and the active tab's content. */
+export declare function ContextPanelTabs({ tabs, value, onValueChange, testId, listClassName, }: ContextPanelTabsProps): import("react").JSX.Element;

package/dist/chat/ConversationEmpty.d.ts

@@ -0,0 +1,53 @@
+import type { ReactNode } from 'react';
+export interface ConversationShortcut {
+    /** Short button label. */
+    label: string;
+    /** Full prompt the host drops into the composer. */
+    prompt: string;
+}
+/** Every fixed string of the empty state. Pass a partial `labels` to translate or reword. */
+export interface ConversationEmptyLabels {
+    title: string;
+    description: string;
+    dropDocuments: string;
+}
+export declare const DEFAULT_CONVERSATION_EMPTY_LABELS: ConversationEmptyLabels;
+export interface ConversationEmptyProps {
+    /** Does the workspace have documents to ask about? Picks the layout. */
+    hasDocuments: boolean;
+    /** Starter questions (has-documents state). */
+    prompts: ReadonlyArray<string>;
+    /** Featured action-shaped shortcut that leads the row. */
+    shortcut?: ConversationShortcut;
+    /** Drop a prompt into the composer. */
+    onUsePrompt: (text: string) => void;
+    /** Add documents: dropped files, or no argument to open the picker. */
+    onAddDocuments: (files?: File[]) => void;
+    /** Rendered instead of the starters when there are no documents (upload box, alt sources). */
+    noDocuments: ReactNode;
+    /**
+     * Extra content under the starters (the host's list of things to start). It lives INSIDE the
+     * empty state's own scroll area, never in the composer dock: the composer stays anchored at the
+     * bottom whatever the length, and a long list scrolls here, above it.
+     */
+    below?: ReactNode;
+    /** Heading; wins over `labels.title`. */
+    title?: string;
+    /** Sub-heading; wins over `labels.description`. */
+    description?: string;
+    className?: string;
+    labels?: Partial<ConversationEmptyLabels>;
+    /** Per-part test ids; defaults are the current ids. */
+    testIds?: Partial<{
+        root: string;
+        upload: string;
+        shortcut: string;
+        prompt: string;
+    }>;
+}
+/**
+ * Empty state of a brand-new conversation. With no documents the first job is adding one, so
+ * the host's upload box leads. With documents it is a one-line framing, a few clickable starter
+ * prompts that prefill the composer, and a quiet "add more" row.
+ */
+export declare function ConversationEmpty({ hasDocuments, prompts, shortcut, onUsePrompt, onAddDocuments, noDocuments, below, title, description, className, labels, testIds, }: ConversationEmptyProps): import("react").JSX.Element;

package/dist/chat/ConversationLayout.d.ts

@@ -0,0 +1,40 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+/** Every fixed string of the conversation layout. Pass a partial `labels` to reword. */
+export interface ConversationLayoutLabels {
+    loadingMessages: string;
+}
+export declare const DEFAULT_CONVERSATION_LAYOUT_LABELS: ConversationLayoutLabels;
+/**
+ * Page frame of a conversation. The chat scroll surface belongs to the HOST (the outer
+ * `[data-scroll-container]`), so this column must GROW with its content, not stay
+ * viewport-capped: the sticky header and the sticky composer dock need a containing block that
+ * spans the whole thread, otherwise `position: sticky` is clamped to one screen and both unpin.
+ *
+ * Do NOT put `overflow: clip/hidden`, `transform`, `filter`, `will-change` or `contain` on
+ * {@link ConversationBody}: `overflow: clip` collapses the scrollHeight so the thread cannot
+ * scroll, and a transform creates a containing block that breaks the dock's `bottom: 0`.
+ */
+export declare function ConversationRoot({ className, children, testId, ...rest }: HTMLAttributes<HTMLDivElement> & {
+    testId?: string;
+}): import("react").JSX.Element;
+/** Sticky strip at the top (tabs and their actions). */
+export declare function ConversationHeader({ className, children, ...rest }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+/** Grows (never shrinks) to the thread's full height so the sticky dock spans the scroll range. */
+export declare function ConversationBody({ className, children, ...rest }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+/** The thread (or its empty / loading state). `relative` so absolutely-filled states fit. */
+export declare function ConversationMain({ className, children, ...rest }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+/** Centered status while the thread loads. */
+export declare function ConversationLoading({ children, labels, className, testId, }: {
+    /** Text; wins over `labels.loadingMessages`. */
+    children?: ReactNode;
+    labels?: Partial<ConversationLayoutLabels>;
+    className?: string;
+    testId?: string;
+}): import("react").JSX.Element;
+export declare const Conversation: {
+    Root: typeof ConversationRoot;
+    Header: typeof ConversationHeader;
+    Body: typeof ConversationBody;
+    Main: typeof ConversationMain;
+    Loading: typeof ConversationLoading;
+};

package/dist/chat/ConversationParts.d.ts

@@ -0,0 +1,62 @@
+import type { ReactNode } from 'react';
+/** Right side of the conversation tab strip. */
+export declare function ConversationHeaderActions({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/** Every fixed string of the conversation parts. Pass a partial `labels` to a part to reword. */
+export interface ConversationPartsLabels {
+    /** "New Chat": `entityLabel` is the host's noun. */
+    newEntity: (entityLabel: string) => string;
+    newPaChatTitle: string;
+    newPaChat: string;
+    paModeTitle: string;
+    pa: string;
+}
+export declare const DEFAULT_CONVERSATION_PARTS_LABELS: ConversationPartsLabels;
+export interface NewChatButtonProps {
+    /** Entity label, e.g. "Chat": names the button ("New Chat"). */
+    entityLabel: string;
+    /** Narrow header: icon only. */
+    isCompact: boolean;
+    onClick: () => void;
+    labels?: Partial<ConversationPartsLabels>;
+    testId?: string;
+}
+/** "+ New Chat". */
+export declare function NewChatButton({ entityLabel, isCompact, onClick, labels, testId, }: NewChatButtonProps): import("react").JSX.Element;
+/** Starts a Personal Assistant conversation (experimental). */
+export declare function NewPaChatButton({ isCompact, onClick, labels, testId, }: {
+    isCompact: boolean;
+    onClick: () => void;
+    labels?: Partial<ConversationPartsLabels>;
+    testId?: string;
+}): import("react").JSX.Element;
+/** Left of the composer toolbar: borderless, muted buttons (files, facts). */
+export declare function ComposerAccessories({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/** Right of the composer toolbar: tools (settings, mic) around the send button. */
+export declare function ComposerTools({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/** Personal Assistant mode marker in place of the accessories. */
+export declare function PaModeBadge({ icon, labels, testId, }: {
+    icon: ReactNode;
+    labels?: Partial<ConversationPartsLabels>;
+    testId?: string;
+}): import("react").JSX.Element;
+/** Icon-only gear for the conversation's settings (developers). */
+export declare function ConversationSettingsButton({ label, onClick, testId, }: {
+    /** e.g. "Chat Settings". */
+    label: string;
+    onClick: () => void;
+    testId?: string;
+}): import("react").JSX.Element;
+/** The history (list) view area when no chat tab is active. */
+export declare function ConversationHistoryPane({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/chat/ConversationSearchView.d.ts

@@ -0,0 +1,57 @@
+import { type ComponentType, type ReactNode } from 'react';
+/** One matching message of a conversation. */
+export interface ConversationSearchMatch {
+    id: string;
+    role: string;
+    score: number;
+    snippet: string;
+}
+/** A conversation with the messages that matched the query. */
+export interface ConversationSearchGroup {
+    id: string;
+    title?: string | null;
+    matches: ConversationSearchMatch[];
+}
+/** Every fixed string of the conversation search. */
+export interface ConversationSearchLabels {
+    placeholder: string;
+    search: string;
+    searching: string;
+    matched: (count: number, query: string) => string;
+    matchCount: (count: number) => string;
+    untitled: string;
+    you: string;
+    assistant: string;
+    clear: string;
+    noResults: (query: string) => string;
+    reindexHint: ReactNode;
+    backToList: string;
+}
+export declare const DEFAULT_CONVERSATION_SEARCH_LABELS: ConversationSearchLabels;
+export interface ConversationSearchViewProps {
+    query: string;
+    onQueryChange: (query: string) => void;
+    /** Enter (without Shift) or the submit button. */
+    onSubmit: () => void;
+    canSubmit: boolean;
+    isSearching: boolean;
+    /** The query the shown results answer; empty while no search has run. */
+    submittedQuery: string;
+    /** Results of `submittedQuery`. */
+    groups: ConversationSearchGroup[];
+    onOpenConversation: (conversationId: string, messageId?: string) => void;
+    /** Back to the idle body. */
+    onClear: () => void;
+    /** Shown beneath the bar until a search is run (e.g. the history list). */
+    children?: ReactNode;
+    /** Wraps the results area (e.g. an error boundary). */
+    ResultsBoundary?: ComponentType<{
+        children: ReactNode;
+    }>;
+    labels?: Partial<ConversationSearchLabels>;
+}
+/**
+ * Search across past conversations: a search bar, then either the idle body (history list) or
+ * the matches grouped by conversation. Opening a group or a hit is the host's navigation.
+ */
+export declare function ConversationSearchView({ query, onQueryChange, onSubmit, canSubmit, isSearching, submittedQuery, groups, onOpenConversation, onClear, children, ResultsBoundary, labels, }: ConversationSearchViewProps): import("react").JSX.Element;

package/dist/chat/LabelPinRow.d.ts

@@ -0,0 +1,30 @@
+export interface PinnableLabel {
+    id: string;
+    name: string;
+    /** The label's own colour (any CSS colour): the same hue everywhere the label appears. */
+    color: string;
+    /** Ids of the items carrying this label. */
+    itemIds: string[];
+}
+export interface LabelPinRowLabels {
+    remove: (count: number, name: string) => string;
+    add: (count: number, name: string) => string;
+}
+export declare const DEFAULT_LABEL_PIN_ROW_LABELS: LabelPinRowLabels;
+export interface LabelPinRowProps {
+    labels: PinnableLabel[];
+    /** Ids currently in the conversation. */
+    selectedIds: string[];
+    /** Add every id (already de-duplicated against the chat). */
+    onAdd: (ids: string[]) => void;
+    /** Remove every id. */
+    onRemove: (ids: string[]) => void;
+    testId?: string;
+    copy?: Partial<LabelPinRowLabels>;
+}
+/**
+ * Label shortcuts inside the in-chat panels: one chip per label in use; clicking it pins
+ * everything carrying that label. A chip whose items are ALL in the chat reads as active and
+ * clicking it takes them back out, so a label is a toggle rather than a one-way add.
+ */
+export declare function LabelPinRow({ labels, selectedIds, onAdd, onRemove, testId, copy, }: LabelPinRowProps): import("react").JSX.Element | null;

package/dist/chat/Message.d.ts

@@ -0,0 +1,189 @@
+import { type ButtonHTMLAttributes, type HTMLAttributes, type ReactNode } from 'react';
+export type MessageRole = 'user' | 'assistant';
+export type MessageTone = 'default' | 'error' | 'subagent';
+/** Every fixed string of the message parts. Pass a partial `labels` to a part to translate or reword. */
+export interface MessageLabels {
+    subagentBadge: string;
+    hideSteps: string;
+    showSteps: string;
+    /** "3 steps" / "1 step". */
+    stepCount: (count: number) => string;
+    /** Tooltip of a source chip. */
+    openSource: (num: string, title: string) => string;
+    /** Accessible name of a source chip. */
+    openSourceAria: (num: string, title: string, page?: number | null) => string;
+    page: (page: number) => string;
+    /** Several cited pages of one file: "pp. 1, 3". */
+    pages: (pages: ReadonlyArray<number>) => string;
+    moreActionsTitle: string;
+    moreActionsAria: string;
+}
+export declare const DEFAULT_MESSAGE_LABELS: MessageLabels;
+export interface MessageRootProps extends HTMLAttributes<HTMLDivElement> {
+    role: MessageRole;
+    /** Drives the default `data-testid` (`message-<id>`). */
+    messageId: string;
+    /** `error` = red wash (failed / orphaned), `subagent` = muted wash (ARBI's own delegate task). */
+    tone?: MessageTone;
+    /** Overrides the default test id. A `data-testid` in the rest props still wins over both. */
+    testId?: string;
+}
+/** One message row: centred column, role + id as data attributes for scroll/deep-link lookups. */
+export declare function MessageRoot({ role, messageId, tone, testId, className, children, ...rest }: MessageRootProps): import("react").JSX.Element;
+export interface MessageContentProps extends HTMLAttributes<HTMLDivElement> {
+    role: MessageRole;
+    messageId: string;
+    /** Overrides the default test id. A `data-testid` in the rest props still wins over both. */
+    testId?: string;
+}
+/** Column that holds the bubble and (for the user) the footer under it, right-aligned. */
+export declare function MessageContent({ role, messageId, testId, className, children, ...rest }: MessageContentProps): import("react").JSX.Element;
+export interface MessageBubbleProps extends HTMLAttributes<HTMLDivElement> {
+    role: MessageRole;
+    messageId: string;
+    /** The message is open in the composer for editing / branching. */
+    isEditing?: boolean;
+    /** The user prompt is accepted by the backend but not yet running. */
+    isQueued?: boolean;
+    /** Overrides the default test id. A `data-testid` in the rest props still wins over both. */
+    testId?: string;
+}
+/**
+ * The message surface. The user's prompt is a tonal (`bg-muted`) rounded block that shrinks to
+ * its text; the assistant answer is full-width ink on the canvas, indented under its byline.
+ */
+export declare const MessageBubble: import("react").ForwardRefExoticComponent<MessageBubbleProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface MessageBylineProps {
+    messageId: string;
+    /** Who answered: the host's model pill / entity chip. */
+    identity?: ReactNode;
+    /** Already-formatted time. */
+    timeLabel: string;
+    /** False while the answer is still streaming: the status cell is hidden. */
+    isSettled: boolean;
+    isFailed?: boolean;
+    /** "Answered in 3.2s" / "Complete" / "Response failed". */
+    statusLabel: string;
+    className?: string;
+    /** Test id of the byline row. */
+    testId?: string;
+    /** Test id of the status cell. */
+    statusTestId?: string;
+}
+/** AI avatar disc, identity, time and settled status above an assistant answer. */
+export declare function MessageByline({ messageId, identity, timeLabel, isSettled, isFailed, statusLabel, className, testId, statusTestId, }: MessageBylineProps): import("react").JSX.Element;
+/** Marks a `role: user` message that ARBI wrote itself to hand a task to a delegate. */
+export declare function MessageSubagentBadge({ messageId, children, labels, className, testId, }: {
+    messageId: string;
+    /** Badge text; wins over `labels.subagentBadge`. */
+    children?: ReactNode;
+    labels?: Partial<MessageLabels>;
+    className?: string;
+    testId?: string;
+}): import("react").JSX.Element;
+/** The rendered text (markdown) of a message. */
+export declare function MessageBody({ messageId, className, children, testId, }: {
+    messageId: string;
+    className?: string;
+    children: ReactNode;
+    testId?: string;
+}): import("react").JSX.Element;
+/** Prose the model has moved on from while the turn streams: dimmed, never the live answer. */
+export declare function MessageNarration({ messageId, children, className, testId, }: {
+    messageId: string;
+    children: ReactNode;
+    className?: string;
+    testId?: string;
+}): import("react").JSX.Element;
+export interface SourceChipProps {
+    /** Citation number as the answer shows it. */
+    num: string;
+    title: string;
+    page?: number | null;
+    /** Several pages of the same file (merged chip); wins over `page`. */
+    pages?: ReadonlyArray<number>;
+    onOpen: () => void;
+    className?: string;
+    labels?: Partial<MessageLabels>;
+    /** Overrides the default `source-chip-<num>` test id. */
+    testId?: string;
+}
+/** One cited source: AI-tinted number, file name, page. A tap opens the passage. */
+export declare function SourceChip({ num, title, page, pages, onOpen, className, labels, testId, }: SourceChipProps): import("react").JSX.Element;
+export interface SourceView {
+    num: string;
+    title: string;
+    page?: number | null;
+}
+export interface MessageSourcesProps {
+    messageId: string;
+    sources: ReadonlyArray<SourceView>;
+    onOpenSource: (num: string) => void;
+    className?: string;
+    labels?: Partial<MessageLabels>;
+    testId?: string;
+}
+/** Row of {@link SourceChip}s under an answer; renders nothing when there are none. */
+export declare function MessageSources({ messageId, sources, onOpenSource, className, labels, testId, }: MessageSourcesProps): import("react").JSX.Element | null;
+export interface MessageStepsView {
+    count: number;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The steps trace, rendered in a popover that opens upward from the footer. */
+    panel: ReactNode;
+}
+export interface MessageFooterProps {
+    role: MessageRole;
+    /** Left side: author pill + time for the user. The assistant's steps toggle is added for you. */
+    leading?: ReactNode;
+    /** Right side: branch control and action buttons. */
+    actions?: ReactNode;
+    /** Assistant only: the "N steps" disclosure. */
+    steps?: MessageStepsView;
+    className?: string;
+    labels?: Partial<MessageLabels>;
+    /** Test id of the steps toggle. */
+    stepsToggleTestId?: string;
+}
+/**
+ * Footer row of a settled message. The whole row anchors the steps popover so the trace is as
+ * wide as the card.
+ */
+export declare function MessageFooter({ role, leading, actions, steps, className, labels, stepsToggleTestId, }: MessageFooterProps): import("react").JSX.Element;
+export interface MessageActionButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Success tint (copied, saved). */
+    isDone?: boolean;
+}
+/** 32px (44px on touch) icon button used in the message footer. */
+export declare const MessageActionButton: import("react").ForwardRefExoticComponent<MessageActionButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface MessageActionMenuItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    onSelect: () => void;
+    testId?: string;
+    tone?: 'default' | 'danger';
+}
+export interface MessageActionMenuProps {
+    items: ReadonlyArray<MessageActionMenuItem>;
+    testId?: string;
+    /** Trigger `aria-label`; wins over `labels.moreActionsAria`. */
+    label?: string;
+    labels?: Partial<MessageLabels>;
+    className?: string;
+}
+/** Overflow ("...") menu: tap-friendly, every secondary action is reachable here. */
+export declare function MessageActionMenu({ items, testId, label, labels, className, }: MessageActionMenuProps): import("react").JSX.Element;
+export declare const Message: {
+    Root: typeof MessageRoot;
+    Content: typeof MessageContent;
+    Bubble: import("react").ForwardRefExoticComponent<MessageBubbleProps & import("react").RefAttributes<HTMLDivElement>>;
+    Byline: typeof MessageByline;
+    SubagentBadge: typeof MessageSubagentBadge;
+    Body: typeof MessageBody;
+    Narration: typeof MessageNarration;
+    Sources: typeof MessageSources;
+    Footer: typeof MessageFooter;
+    ActionButton: import("react").ForwardRefExoticComponent<MessageActionButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+    ActionMenu: typeof MessageActionMenu;
+};

package/dist/chat/MessageAlert.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the alert. Pass a partial `labels` to translate or reword. */
+export interface MessageAlertLabels {
+    retrying: string;
+    /** Name of the retry button rendered for `onActivate`. */
+    retry: string;
+}
+export declare const DEFAULT_MESSAGE_ALERT_LABELS: MessageAlertLabels;
+export interface MessageAlertProps {
+    title: string;
+    description: string;
+    /** A retry is in flight: shows a spinner and the busy title. */
+    isBusy?: boolean;
+    /** Title while busy; wins over `labels.retrying`. */
+    busyTitle?: string;
+    labels?: Partial<MessageAlertLabels>;
+    /** Adds a Retry button (a real, keyboard-operable one) that runs this. */
+    onActivate?: () => void;
+    /** Explicit buttons under the text (e.g. a Retry button). */
+    actions?: ReactNode;
+    className?: string;
+    testId?: string;
+}
+/** Tinted alert above the composer: a send that failed, or an answer that never arrived. */
+export declare function MessageAlert({ title, description, isBusy, busyTitle, labels, onActivate, actions, className, testId, }: MessageAlertProps): import("react").JSX.Element;

package/dist/chat/MessageList.d.ts

@@ -0,0 +1,102 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+/**
+ * Presentational shell of a (virtualised) message thread. The host owns the virtualiser and the
+ * scroll element; these parts only lay the rows out, so any list engine can drive them:
+ *
+ *   <MessageList.Root>
+ *     <MessageList.Banner onBack=... />
+ *     <MessageList.Rows totalSize={virtualizer.getTotalSize()}>
+ *       <MessageList.Row index start messageId measureRef> ... </MessageList.Row>
+ *     </MessageList.Rows>
+ *     <MessageList.Tail />
+ *   </MessageList.Root>
+ */
+/** Every fixed string of the message list. Pass a partial `labels` to translate or reword. */
+export interface MessageListLabels {
+    messageList: string;
+    startConversation: string;
+    backToConversation: string;
+    conversationMessages: string;
+    /** Spoken once when a reply starts. */
+    responding: string;
+    /** Spoken when a reply is complete; receives the (truncated) plain text of the answer. */
+    responseComplete: (text: string) => string;
+}
+export declare const DEFAULT_MESSAGE_LIST_LABELS: MessageListLabels;
+export interface MessageListRootProps extends HTMLAttributes<HTMLDivElement> {
+    /** A reply is streaming: `aria-busy` tells assistive tech to hold back until it settles. */
+    isBusy?: boolean;
+    labels?: Partial<MessageListLabels>;
+    /** Test id of the list. A `data-testid` in the rest props still wins. */
+    testId?: string;
+}
+/**
+ * A `log` landmark (the conversation transcript). Its own live announcements are switched off on
+ * purpose: tokens streaming into a live region would be read out one fragment at a time. Pair it
+ * with {@link MessageListStatus}, which announces "responding" once and the finished answer once.
+ * An `aria-label` in the rest props wins over `labels.messageList`.
+ */
+export declare function MessageListRoot({ className, children, isBusy, labels, testId, ...rest }: MessageListRootProps): import("react").JSX.Element;
+export interface MessageListStatusProps {
+    /** What to announce; change it to announce again. Build it with `useStreamAnnouncement`. */
+    message: string;
+    testId?: string;
+}
+/** Visually hidden polite live region. Mount it before the first announcement. */
+export declare function MessageListStatus({ message, testId, }: MessageListStatusProps): import("react").JSX.Element;
+/** Shown while the list has nothing to render. */
+export declare function MessageListEmpty({ children, labels, className, testId, }: {
+    /** Text; wins over `labels.startConversation`. */
+    children?: ReactNode;
+    labels?: Partial<MessageListLabels>;
+    className?: string;
+    testId?: string;
+}): import("react").JSX.Element;
+export interface MessageListBannerProps {
+    onBack: () => void;
+    /** Text; wins over `labels.backToConversation`. */
+    children?: ReactNode;
+    labels?: Partial<MessageListLabels>;
+    className?: string;
+    testId?: string;
+}
+/**
+ * Sticky way back out of a delegated (sub-agent) thread: pinned so the only sign you are not in
+ * the real conversation does not scroll away.
+ */
+export declare function MessageListBanner({ onBack, children, labels, className, testId, }: MessageListBannerProps): import("react").JSX.Element;
+export interface MessageListRowsProps extends HTMLAttributes<HTMLDivElement> {
+    /** Total scroll height reported by the virtualiser. */
+    totalSize: number;
+    labels?: Partial<MessageListLabels>;
+}
+/** Height spacer the virtualised rows are absolutely positioned inside. */
+export declare function MessageListRows({ totalSize, className, children, labels, ...rest }: MessageListRowsProps): import("react").JSX.Element;
+export interface MessageListRowProps extends Omit<HTMLAttributes<HTMLDivElement>, 'style'> {
+    index: number;
+    /** Offset of the row from the top, in px. */
+    start: number;
+    /** Exposed as `data-message-id` for scroll-to-message and deep links. */
+    messageId?: string;
+    /**
+     * Total messages in the thread. A virtualised list mounts only a window of rows, so without it
+     * a screen reader counts the mounted rows; with it each row says "n of N".
+     */
+    setSize?: number;
+}
+/** One absolutely positioned row. Pass the virtualiser's `measureElement` as `ref`. */
+export declare const MessageListRow: import("react").ForwardRefExoticComponent<MessageListRowProps & import("react").RefAttributes<HTMLDivElement>>;
+/**
+ * Breathing room so the last message clears the sticky composer. Fixed (not
+ * viewport-proportional) so it never balloons into dead space on tall screens; smaller on phones.
+ */
+export declare function MessageListTail(): import("react").JSX.Element;
+export declare const MessageList: {
+    Root: typeof MessageListRoot;
+    Empty: typeof MessageListEmpty;
+    Banner: typeof MessageListBanner;
+    Status: typeof MessageListStatus;
+    Rows: typeof MessageListRows;
+    Row: import("react").ForwardRefExoticComponent<MessageListRowProps & import("react").RefAttributes<HTMLDivElement>>;
+    Tail: typeof MessageListTail;
+};