@miiflow/assistant-ui 0.5.2 → 0.9.0

package/dist/styled/index.d.ts

@@ -1,14 +1,15 @@
-export { A as AttachmentPreview, j as AttachmentPreviewProps, a as Avatar, k as AvatarProps, C as ChatContainer, l as ChatContainerProps, b as ChatLayout, m as ChatLayoutProps, M as MarkdownContent, n as MarkdownContentProps, c as Message, d as MessageActionBar, o as MessageActionBarProps, e as MessageComposer, p as MessageComposerProps, f as MessageList, q as MessageListProps, r as MessageProps, S as ScrollToBottomButton, s as ScrollToBottomButtonProps, g as StreamingText, t as StreamingTextProps, h as SuggestedActions, u as SuggestedActionsProps, v as ToolStatus, T as ToolStatusIndicator, w as ToolStatusIndicatorProps, i as TypingIndicator, x as TypingIndicatorProps, W as WelcomeScreen, y as WelcomeScreenProps } from '../WelcomeScreen-D32Tsu6G.js';
+export { A as AttachmentPreview, a as AttachmentPreviewProps, b as Avatar, c as AvatarProps, C as ChatContainer, d as ChatContainerProps, e as ChatLayout, f as ChatLayoutProps, M as MarkdownContent, g as MarkdownContentProps, h as Message, i as MessageActionBar, j as MessageActionBarProps, k as MessageComposer, l as MessageComposerProps, m as MessageList, n as MessageListProps, o as MessageProps, S as ScrollToBottomButton, p as ScrollToBottomButtonProps, q as StreamingText, r as StreamingTextProps, s as SuggestedActions, t as SuggestedActionsProps, T as ToolStatus, u as ToolStatusIndicator, v as ToolStatusIndicatorProps, w as TypingIndicator, x as TypingIndicatorProps, W as WelcomeScreen, y as WelcomeScreenProps } from '../WelcomeScreen-CVxniqqK.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import react__default, { ReactNode } from 'react';
-import { A as Attachment, S as SourceReference, a as MemoryFeedbackType } from '../message-D3D59U_Q.js';
-export { C as ChatMessage, M as MessageData, b as MessageError, c as Participant, P as ParticipantRole, d as SourceTypeConfig, e as SuggestedAction, f as SuggestedActionType } from '../message-D3D59U_Q.js';
-import { S as StreamingChunk, P as PlanData, C as ClarificationData, V as VisualizationChunkData, d as VisualizationActionEvent, e as ChartVisualizationData, f as VisualizationConfig, T as TableVisualizationData, g as CardVisualizationData, K as KpiVisualizationData, h as CodePreviewVisualizationData, F as FormVisualizationData, E as Event, i as EventStatus } from '../streaming-Q8hp5ev4.js';
-export { j as ChunkType, k as ClaudeToolChunkData, l as EventType, m as FileOperationChunkData, n as FollowupAction, M as MediaChunkData, O as ObservationEvent, o as ParallelSubtaskData, p as PlanningEvent, q as ProgressData, r as SearchResultsChunkData, s as StreamingMessage, t as SubTaskData, u as SubagentChunkData, v as SubagentInfo, w as SubtaskEvent, x as TerminalChunkData, y as ThinkingEvent, z as ToolEvent, A as VisualizationType, W as WaveData, B as WebOperationChunkData } from '../streaming-Q8hp5ev4.js';
+import react__default, { ReactNode, ComponentType } from 'react';
+import { A as Attachment, S as SourceReference } from '../message-D2ElX5k7.js';
+export { C as ChatMessage, M as MessageData, a as MessageError, P as Participant, b as ParticipantRole, c as SourceTypeConfig, d as SuggestedAction, e as SuggestedActionType } from '../message-D2ElX5k7.js';
+import { k as StreamingChunk, P as PlanData, d as ClarificationData, s as ToolApprovalData, u as VisualizationChunkData, V as VisualizationActionEvent, M as MediaChunkData, b as ChartVisualizationData, v as VisualizationConfig, T as TableVisualizationData, C as CardVisualizationData, K as KpiVisualizationData, e as CodePreviewVisualizationData, h as FormVisualizationData, A as ArtifactChunkData, E as Event, f as EventStatus } from '../streaming-B_u_jno6.js';
+export { a as ArtifactStatus, c as ChunkType, g as EventType, F as FollowupAction, O as ObservationEvent, i as PlanningEvent, j as ProgressData, l as StreamingMessage, o as SubTaskData, p as SubagentChunkData, q as SubtaskEvent, r as ThinkingEvent, t as ToolEvent, w as VisualizationType } from '../streaming-B_u_jno6.js';
 import { z, ZodSchema } from 'zod';
 export { ChatContextValue, ChatProvider, ChatProviderProps, useChatContext } from '../context/index.js';
-export { B as BrandingData } from '../branding-SzYU4ncD.js';
-export { u as useComposer, g as useMessage } from '../avatar-CAmTN1L7.js';
+export { B as BrandingData } from '../branding-NieTEGQf.js';
+export { u as useComposer, n as useMessage } from '../avatar-DnLePg72.js';
+import '../types-DeHbndy0.js';
 
 interface LoadingDotsProps {
     /** Size variant */
@@ -82,7 +83,8 @@ interface ReasoningPanelProps {
     isStreaming?: boolean;
     /** Streaming chunks */
     chunks?: StreamingChunk[];
-    /** Execution plan for Plan & Execute mode */
+    /** Execution plan persisted on completed messages (historical messages only —
+     *  new streams persist the plan as plain text without subtasks). */
     plan?: PlanData;
     /** Execution timeline (completed messages) */
     executionTimeline?: any[];
@@ -103,38 +105,91 @@ declare function ReasoningPanel({ isStreaming, chunks, plan, executionTimeline,
 
 interface ClarificationPanelProps {
     clarification: ClarificationData;
-    onSubmit: (response: string) => void;
+    onSubmit?: (response: string) => void;
     onOptionSelect?: (option: string) => void;
     disabled?: boolean;
     loading?: boolean;
     className?: string;
+    /**
+     * When set, renders a read-only "answered" state showing the user's response
+     * inline with the question. Used in scrolled-back chat history so a past
+     * clarification still shows what was asked and answered.
+     */
+    answer?: string;
 }
 /**
  * Stateless clarification panel - displays when the AI agent needs user input.
  * Orange left-border panel with question, radio options, and free-text input.
+ *
+ * If `answer` is provided, switches to a read-only "answered" view.
  */
-declare function ClarificationPanel({ clarification, onSubmit, onOptionSelect, disabled, loading, className, }: ClarificationPanelProps): react_jsx_runtime.JSX.Element;
+declare function ClarificationPanel({ clarification, onSubmit, onOptionSelect, disabled, loading, className, answer, }: ClarificationPanelProps): react_jsx_runtime.JSX.Element;
+
+interface ApprovalButtonSlotProps {
+    onClick: () => void;
+    disabled?: boolean;
+    children: ReactNode;
+}
+interface ApprovalChatInputSlotProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: () => void;
+    onCancel: () => void;
+    placeholder: string;
+    disabled?: boolean;
+    autoFocus?: boolean;
+}
+interface ToolApprovalSlots {
+    AllowButton?: ComponentType<ApprovalButtonSlotProps>;
+    RejectButton?: ComponentType<ApprovalButtonSlotProps>;
+    ChatButton?: ComponentType<ApprovalButtonSlotProps>;
+    SendButton?: ComponentType<ApprovalButtonSlotProps>;
+    CancelButton?: ComponentType<ApprovalButtonSlotProps>;
+    ChatInput?: ComponentType<ApprovalChatInputSlotProps>;
+}
+interface ToolApprovalPanelProps {
+    approval: ToolApprovalData;
+    onApprove: (modifiedInputs: Record<string, unknown>) => void;
+    onReject: (reason?: string) => void;
+    disabled?: boolean;
+    className?: string;
+    /**
+     * Per-action component overrides. Pass any subset; unspecified slots fall
+     * back to the library's default Tailwind-styled renderings. Use this to
+     * align buttons and input with a host app's brand system.
+     */
+    slots?: ToolApprovalSlots;
+}
+/**
+ * Tool approval — rendered as a raised CTA above the composer to communicate
+ * that the agent is paused on a decision. Anatomy:
+ *
+ *   ┌─ Approve action ─ <tool identity> ─────────────────────┐
+ *   │  <agent's prompt sentence>                              │
+ *   │  [param: value]  [param: value]                         │
+ *   │  [ Approve ]  [ Decline ]    ⏎ approve · Esc decline    │
+ *   │  Show all details                                       │
+ *   └─────────────────────────────────────────────────────────┘
+ *
+ * Buttons and the chat input are slottable via the `slots` prop so host apps
+ * can swap in their own brand-aligned components.
+ */
+declare function ToolApprovalPanel({ approval, onApprove, onReject, disabled, className, slots, }: ToolApprovalPanelProps): react_jsx_runtime.JSX.Element;
 
 interface CitationSourcesProps {
     sources: SourceReference[];
     className?: string;
-    onMemoryFeedback?: (semanticAtomId: string, feedback: MemoryFeedbackType) => void;
-    memoryFeedbackState?: Record<string, MemoryFeedbackType>;
 }
 /**
  * Renders citation sources as a horizontal row of clickable chips.
  * Clicking a chip opens a modal showing full source content.
- * Memory citations include feedback buttons (thumbs up/down).
  */
-declare function CitationSources({ sources, className, onMemoryFeedback, memoryFeedbackState, }: CitationSourcesProps): react_jsx_runtime.JSX.Element | null;
+declare function CitationSources({ sources, className, }: CitationSourcesProps): react_jsx_runtime.JSX.Element | null;
 interface SourceDetailModalProps {
     source: SourceReference | null;
     onClose: () => void;
-    onMemoryFeedback?: (semanticAtomId: string, feedback: MemoryFeedbackType) => void;
-    feedbackState?: Record<string, MemoryFeedbackType>;
-    onFeedbackChange?: (source: SourceReference, feedback: MemoryFeedbackType) => void;
 }
-declare function SourceDetailModal({ source, onClose, onMemoryFeedback, feedbackState, onFeedbackChange, }: SourceDetailModalProps): react_jsx_runtime.JSX.Element | null;
+declare function SourceDetailModal({ source, onClose, }: SourceDetailModalProps): react_jsx_runtime.JSX.Element | null;
 /**
  * Inline citation badge - renders a small numbered badge like [1]
  * with optional tooltip on hover and click-to-open URL.
@@ -145,34 +200,15 @@ interface InlineCitationProps {
 }
 declare function InlineCitation({ index, source }: InlineCitationProps): react_jsx_runtime.JSX.Element;
 
-interface ClaudeToolPreviewProps {
-    chunk: StreamingChunk;
-}
-declare function ClaudeToolPreview({ chunk }: ClaudeToolPreviewProps): react_jsx_runtime.JSX.Element | null;
-
-interface TerminalOutputProps {
-    chunk: StreamingChunk;
-}
-declare function TerminalOutput({ chunk }: TerminalOutputProps): react_jsx_runtime.JSX.Element | null;
-
-interface FileOperationPreviewProps {
-    chunk: StreamingChunk;
-}
-declare function FileOperationPreview({ chunk }: FileOperationPreviewProps): react_jsx_runtime.JSX.Element | null;
-
-interface SearchResultsViewProps {
-    chunk: StreamingChunk;
-}
-declare function SearchResultsView({ chunk }: SearchResultsViewProps): react_jsx_runtime.JSX.Element | null;
-
-interface WebOperationPreviewProps {
-    chunk: StreamingChunk;
-}
-declare function WebOperationPreview({ chunk }: WebOperationPreviewProps): react_jsx_runtime.JSX.Element | null;
-
 interface SubagentPanelProps {
     chunk: StreamingChunk;
 }
+/**
+ * Renders a single sub-assistant dispatch as one row in a `Timeline` —
+ * label + description + duration + chevron — matching plan subtasks and
+ * multi-agent rows. Nested chunks (thinking/tool/observation/sub-assistant)
+ * render as an indented `EventTimeline` underneath.
+ */
 declare function SubagentPanel({ chunk }: SubagentPanelProps): react_jsx_runtime.JSX.Element | null;
 
 declare const chartVisualizationSchema: z.ZodObject<{
@@ -225,6 +261,7 @@ declare const tableVisualizationSchema: z.ZodObject<{
             number: "number";
             boolean: "boolean";
             progress: "progress";
+            media: "media";
             currency: "currency";
             date: "date";
             badge: "badge";
@@ -270,7 +307,7 @@ declare const kpiVisualizationSchema: z.ZodObject<{
             down: "down";
             neutral: "neutral";
         }>>>;
-        change: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        change: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         changeLabel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         sparkline: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
         color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -278,6 +315,7 @@ declare const kpiVisualizationSchema: z.ZodObject<{
     layout: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         row: "row";
         grid: "grid";
+        bento: "bento";
     }>>>;
 }, z.core.$strip>;
 declare const codePreviewVisualizationSchema: z.ZodObject<{
@@ -324,8 +362,10 @@ interface VisualizationRendererProps {
     data: VisualizationChunkData;
     isStreaming?: boolean;
     onAction?: (event: VisualizationActionEvent) => void;
+    /** Message-level media bag used to resolve `media_ref:<id>` cell values. */
+    medias?: MediaChunkData[];
 }
-declare function VisualizationRenderer({ data, isStreaming, onAction, }: VisualizationRendererProps): react_jsx_runtime.JSX.Element;
+declare function VisualizationRenderer({ data, isStreaming, onAction, medias, }: VisualizationRendererProps): react_jsx_runtime.JSX.Element;
 
 interface ChartVisualizationProps {
     data: ChartVisualizationData;
@@ -338,8 +378,10 @@ interface TableVisualizationProps {
     data: TableVisualizationData;
     config?: VisualizationConfig;
     isStreaming?: boolean;
+    /** Message-level media bag used to resolve `media_ref:<id>` cell values. */
+    medias?: MediaChunkData[];
 }
-declare function TableVisualization({ data, config }: TableVisualizationProps): react_jsx_runtime.JSX.Element;
+declare function TableVisualization({ data, config, medias }: TableVisualizationProps): react_jsx_runtime.JSX.Element;
 
 interface CardVisualizationProps {
     data: CardVisualizationData;
@@ -377,6 +419,7 @@ interface VisualizationEntry {
         config?: VisualizationConfig;
         isStreaming?: boolean;
         onAction?: (event: VisualizationActionEvent) => void;
+        medias?: MediaChunkData[];
     }>;
     schema?: ZodSchema;
 }
@@ -394,27 +437,97 @@ declare function getVisualization(type: string): VisualizationEntry | undefined;
  */
 declare function getRegisteredTypes(): string[];
 
+interface ArtifactInlineCardProps {
+    artifact: ArtifactChunkData;
+    isStreaming?: boolean;
+    onOpen?: (artifact: ArtifactChunkData) => void;
+}
+/**
+ * Unstyled primitive inline card. The app layer (`web/`) registers a
+ * MUI-skinned version via `registerArtifact`; this primitive is the fallback
+ * shipped with the chat-ui package so headless / embedded consumers still
+ * render something when a tool emits an artifact.
+ */
+declare function ArtifactInlineCard({ artifact, isStreaming, onOpen, }: ArtifactInlineCardProps): react_jsx_runtime.JSX.Element;
+
+interface ArtifactListProps {
+    artifacts: ArtifactChunkData[];
+    isStreaming?: boolean;
+    onOpen?: (artifact: ArtifactChunkData) => void;
+}
+/**
+ * Renders one inline card per artifact using the registered renderer when
+ * available; falls back to the unstyled `ArtifactInlineCard` otherwise.
+ */
+declare function ArtifactList({ artifacts, isStreaming, onOpen, }: ArtifactListProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Shape of a registered artifact type.
+ *
+ * Artifacts have a dual UI:
+ *  - `InlineCard` is rendered inside the message body (compact, clickable).
+ *  - `Viewer` is rendered inside the side-panel drawer (full preview).
+ *
+ * The app layer (`web/`) supplies MUI-skinned implementations; the unstyled
+ * primitive `ArtifactInlineCard` is used as a fallback for headless consumers
+ * (e.g. the embedded widget) that do not register MUI artifacts.
+ */
+interface ArtifactEntry {
+    type: string;
+    label: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    InlineCard: ComponentType<{
+        artifact: ArtifactChunkData;
+        isStreaming?: boolean;
+        onOpen?: (artifact: ArtifactChunkData) => void;
+    }>;
+    Viewer?: ComponentType<{
+        artifact: ArtifactChunkData;
+    }>;
+    /** Optional description shown when no entry is registered for this type. */
+    fallback?: ReactNode;
+}
+declare function registerArtifact(type: string, entry: ArtifactEntry): void;
+declare function getArtifact(type: string): ArtifactEntry | undefined;
+declare function getRegisteredArtifactTypes(): string[];
+
 interface EventContentProps {
     event: Event;
     className?: string;
-    /** When true, shows beamer scanning effect on tool items */
+    /** Active state — drives the trailing caret on tool calls. */
     isRunning?: boolean;
+    /**
+     * Slowest duration in the surrounding timeline. Used to scale this row's
+     * trailing micro-bar so the panel reads as a proportional trace.
+     */
+    maxDurationSeconds?: number;
 }
 /**
- * Renders content for different event types
- * - Thinking: Markdown content with subtle styling
- * - Planning: Markdown content with planning context
- * - Tool: Inline icon + text display with beamer effect when running
- * - Observation: Colored result panel
+ * Refreshed event content.
+ *
+ * - Thinking / planning render as prose at 78% ink with relaxed leading;
+ *   active rows bump to weight 500 so the eye lands on live content.
+ * - Tool calls render as an inline monospace tag. The redundant inner dot
+ *   is gone (the rail badge already conveys state at the same y); a soft
+ *   caret blinks at the trailing edge while running.
+ * - Completed rows get a right-aligned duration with a proportional micro-
+ *   bar — the panel reads as a tiny trace.
+ * - Observations use a quiet tinted background, no side-stripe.
  */
-declare function EventContent({ event, className, isRunning }: EventContentProps): react_jsx_runtime.JSX.Element | null;
+declare function EventContent({ event, className, isRunning, maxDurationSeconds, }: EventContentProps): react_jsx_runtime.JSX.Element | null;
 
 /**
  * Convert StreamingChunk to Event format
  */
 declare function convertChunkToEvent(chunk: StreamingChunk, index: number): Event | null;
 /**
- * Convert timeline items (from metadata) to Events
+ * Convert timeline items (from metadata) to Events.
+ *
+ * Computes pairwise `durationSeconds` from `item.timestamp` so completed
+ * timelines can show per-step trace bars. Falls back to undefined when
+ * timestamps are missing (e.g. tail events without a successor).
  */
 declare function convertTimelineToEvents(timeline: Array<Record<string, unknown>>): Event[];
 interface EventTimelineProps {
@@ -439,24 +552,24 @@ interface PlanTimelineProps {
  */
 declare function PlanTimeline({ plan, streamingChunks, className, }: PlanTimelineProps): react_jsx_runtime.JSX.Element;
 
-interface StatusBadgeProps {
-    status: EventStatus;
-    size?: number;
-    className?: string;
-}
-/**
- * Circular status badge with magical animations
- * - Pending: Dashed circle (muted)
- * - Running: Glowing orb with pulse effect
- * - Completed: Green check with pop + flash animation
- * - Failed: Red X
- */
-declare function StatusBadge({ status, size, className }: StatusBadgeProps): react_jsx_runtime.JSX.Element;
-
+type TimelineItemKind = "thinking" | "planning" | "tool" | "observation" | "subagent";
 interface TimelineItemData {
     id: string;
     status: EventStatus;
     content: ReactNode;
+    /**
+     * When true, the parent Timeline does not apply the running-state
+     * gradient wash to this row's content cell. Use for rows that own a
+     * nested timeline (e.g. subagents) — the wash bleeds behind the entire
+     * expanded body and reads as a card around the group.
+     */
+    bare?: boolean;
+    /**
+     * Semantic kind of this row. Drives adjacency-aware vertical spacing
+     * (consecutive thoughts pack tighter; tool/subagent boundaries breathe
+     * wider) and the StatusBadge marker variant (subagent gets a ring).
+     */
+    kind?: TimelineItemKind;
 }
 interface TimelineProps {
     items: TimelineItemData[];
@@ -464,8 +577,13 @@ interface TimelineProps {
     className?: string;
 }
 /**
- * Vertical timeline component
- * Displays items with status badges and connecting lines
+ * Vertical timeline — refreshed look.
+ *
+ * One unbroken hairline rail down the badge column with rail-anchored ink
+ * markers. The active segment carries a soft downward-flowing gradient
+ * slice; running rows get a left-anchored gradient wash on the content
+ * side. Spacing varies by adjacency so the panel reads like prose, not a
+ * uniform list.
  */
 declare function Timeline({ items, badgeSize, className }: TimelineProps): react_jsx_runtime.JSX.Element | null;
 interface TimelineItemProps {
@@ -476,8 +594,63 @@ interface TimelineItemProps {
     className?: string;
 }
 /**
- * Single timeline item (alternative API)
+ * Single timeline item (alternative API). Matches the refreshed look of
+ * the parent `Timeline`: hairline rail, ink-dot markers, no card chrome.
  */
 declare function TimelineItem({ status, isLast, badgeSize, children, className, }: TimelineItemProps): react_jsx_runtime.JSX.Element;
 
-export { Attachment, CardVisualization, type CardVisualizationProps, ChartVisualization, type ChartVisualizationProps, ChatHeader, type ChatHeaderAction, type ChatHeaderProps, CitationSources, type CitationSourcesProps, ClarificationData, ClarificationPanel, type ClarificationPanelProps, ClaudeToolPreview, type ClaudeToolPreviewProps, CodePreviewVisualization, type CodePreviewVisualizationProps, Event, EventContent, EventStatus, EventTimeline, type EventTimelineProps, FileOperationPreview, type FileOperationPreviewProps, FormVisualization, type FormVisualizationProps, InlineCitation, type InlineCitationProps, KpiVisualization, type KpiVisualizationProps, LoadingDots, type LoadingDotsProps, MessageAttachments, type MessageAttachmentsProps, PlanData, PlanTimeline, type PlanTimelineProps, ReasoningPanel, type ReasoningPanelProps, SearchResultsView, type SearchResultsViewProps, SourceDetailModal, type SourceDetailModalProps, SourceReference, StatusBadge, StreamingChunk, SubagentPanel, type SubagentPanelProps, TableVisualization, type TableVisualizationProps, TerminalOutput, type TerminalOutputProps, TimeMarker, type TimeMarkerProps, Timeline, TimelineItem, type TimelineItemData, type TimelineItemProps, type TimelineProps, VisualizationActionEvent, VisualizationChunkData, VisualizationConfig, type VisualizationEntry, VisualizationRenderer, type VisualizationRendererProps, WebOperationPreview, type WebOperationPreviewProps, cardVisualizationSchema, chartVisualizationSchema, codePreviewVisualizationSchema, convertChunkToEvent, convertTimelineToEvents, formVisualizationSchema, getRegisteredTypes, getVisualization, kpiVisualizationSchema, registerVisualization, tableVisualizationSchema };
+interface StatusBadgeProps {
+    status: EventStatus;
+    size?: number;
+    className?: string;
+    /**
+     * Semantic kind of the row this badge marks. Each kind has a distinct
+     * marker geometry so the rail itself encodes event type at a glance —
+     * dot for thoughts (soft/prose), diamond for tool calls (geometric/
+     * action), ring for subagents (a dispatched thread). Shape, not just
+     * color, carries the categorical distinction.
+     */
+    kind?: TimelineItemKind;
+}
+/**
+ * Rail-anchored state marker.
+ *
+ * Shape carries state alongside color: running markers are visibly larger
+ * with a strong breathing halo, so a neutral activity color still reads
+ * as "in progress." Color comes from `--chat-activity` with a fallback to
+ * `--chat-primary`; callers whose primary is neutral can override the
+ * activity accent independently via `BrandingData.activityAccentColor`.
+ */
+declare function StatusBadge({ status, size, className, kind }: StatusBadgeProps): react_jsx_runtime.JSX.Element;
+
+interface TimelineRowProps {
+    /** Primary label — subtask description, agent name, or humanized handle. */
+    label: string;
+    /** Secondary text — task summary, self-description, or error message. */
+    description?: string;
+    /** Duration in seconds. Rendered right-aligned with tabular numerals. */
+    durationSeconds?: number;
+    /** Apply failed-state coloring to label/description. */
+    isFailed?: boolean;
+    /** Auto-expand the row when first rendered (e.g. when running). */
+    defaultExpanded?: boolean;
+    /** Nested events rendered in an indented body when expanded. */
+    nestedEvents?: Event[];
+    /** When true, the chevron is suppressed (used for non-expandable rows). */
+    hideChevron?: boolean;
+}
+/**
+ * Shared row content used by every reasoning-panel timeline:
+ * plan subtasks, multi-agent subagents, and sub-assistant dispatches.
+ *
+ * The leading status marker and rail are provided by the parent
+ * `Timeline`; this component only owns the label/description/duration row
+ * and the nested timeline that expands beneath it.
+ *
+ * Refreshed look: the lucide chevron is replaced by a typographic caret
+ * that rotates on expand; the duration is rendered as a tabular-num pill
+ * with quiet weight so it reads as data, not chrome.
+ */
+declare function TimelineRow({ label, description, durationSeconds, isFailed, defaultExpanded, nestedEvents, hideChevron, }: TimelineRowProps): react_jsx_runtime.JSX.Element;
+
+export { type ApprovalButtonSlotProps, type ApprovalChatInputSlotProps, ArtifactChunkData, type ArtifactEntry, ArtifactInlineCard, type ArtifactInlineCardProps, ArtifactList, type ArtifactListProps, Attachment, CardVisualization, type CardVisualizationProps, ChartVisualization, type ChartVisualizationProps, ChatHeader, type ChatHeaderAction, type ChatHeaderProps, CitationSources, type CitationSourcesProps, ClarificationData, ClarificationPanel, type ClarificationPanelProps, CodePreviewVisualization, type CodePreviewVisualizationProps, Event, EventContent, EventStatus, EventTimeline, type EventTimelineProps, FormVisualization, type FormVisualizationProps, InlineCitation, type InlineCitationProps, KpiVisualization, type KpiVisualizationProps, LoadingDots, type LoadingDotsProps, MediaChunkData, MessageAttachments, type MessageAttachmentsProps, PlanData, PlanTimeline, type PlanTimelineProps, ReasoningPanel, type ReasoningPanelProps, SourceDetailModal, type SourceDetailModalProps, SourceReference, StatusBadge, StreamingChunk, SubagentPanel, type SubagentPanelProps, TableVisualization, type TableVisualizationProps, TimeMarker, type TimeMarkerProps, Timeline, TimelineItem, type TimelineItemData, type TimelineItemProps, type TimelineProps, TimelineRow, type TimelineRowProps, ToolApprovalPanel, type ToolApprovalPanelProps, type ToolApprovalSlots, VisualizationActionEvent, VisualizationChunkData, VisualizationConfig, type VisualizationEntry, VisualizationRenderer, type VisualizationRendererProps, cardVisualizationSchema, chartVisualizationSchema, codePreviewVisualizationSchema, convertChunkToEvent, convertTimelineToEvents, formVisualizationSchema, getArtifact, getRegisteredArtifactTypes, getRegisteredTypes, getVisualization, kpiVisualizationSchema, registerArtifact, registerVisualization, tableVisualizationSchema };

package/dist/styled/index.js

@@ -1,2 +1,2 @@
-export{c as AttachmentPreview,d as Avatar,G as CardVisualization,E as ChartVisualization,e as ChatContainer,$ as ChatHeader,ba as ChatLayout,h as CitationSources,k as ClarificationPanel,v as ClaudeToolPreview,I as CodePreviewVisualization,q as EventContent,t as EventTimeline,x as FileOperationPreview,J as FormVisualization,j as InlineCitation,H as KpiVisualization,f as LoadingDots,g as MarkdownContent,V as Message,l as MessageActionBar,m as MessageAttachments,W as MessageComposer,Y as MessageList,u as PlanTimeline,B as ReasoningPanel,X as ScrollToBottomButton,y as SearchResultsView,i as SourceDetailModal,n as StatusBadge,C as StreamingText,A as SubagentPanel,D as SuggestedActions,F as TableVisualization,w as TerminalOutput,Z as TimeMarker,o as Timeline,p as TimelineItem,aa as ToolStatusIndicator,_ as TypingIndicator,T as VisualizationRenderer,z as WebOperationPreview,ca as WelcomeScreen,P as cardVisualizationSchema,N as chartVisualizationSchema,R as codePreviewVisualizationSchema,r as convertChunkToEvent,s as convertTimelineToEvents,S as formVisualizationSchema,M as getRegisteredTypes,L as getVisualization,Q as kpiVisualizationSchema,K as registerVisualization,O as tableVisualizationSchema}from'../chunk-VDFIXLNO.js';export{h as useComposer,b as useMessage}from'../chunk-6RN7SUWT.js';import'../chunk-D2PFIJNZ.js';import'../chunk-4WWJTYYA.js';export{b as ChatProvider,c as useChatContext}from'../chunk-OCKHJ4WO.js';//# sourceMappingURL=index.js.map
+export{O as ArtifactInlineCard,S as ArtifactList,a as AttachmentPreview,b as Avatar,A as CardVisualization,y as ChartVisualization,c as ChatContainer,_ as ChatHeader,aa as ChatLayout,f as CitationSources,i as ClarificationPanel,C as CodePreviewVisualization,p as EventContent,s as EventTimeline,D as FormVisualization,h as InlineCitation,B as KpiVisualization,d as LoadingDots,e as MarkdownContent,U as Message,k as MessageActionBar,l as MessageAttachments,V as MessageComposer,X as MessageList,u as PlanTimeline,v as ReasoningPanel,W as ScrollToBottomButton,g as SourceDetailModal,m as StatusBadge,w as StreamingText,ca as SubagentPanel,x as SuggestedActions,z as TableVisualization,Y as TimeMarker,n as Timeline,o as TimelineItem,t as TimelineRow,j as ToolApprovalPanel,$ as ToolStatusIndicator,Z as TypingIndicator,N as VisualizationRenderer,ba as WelcomeScreen,J as cardVisualizationSchema,H as chartVisualizationSchema,L as codePreviewVisualizationSchema,q as convertChunkToEvent,r as convertTimelineToEvents,M as formVisualizationSchema,Q as getArtifact,R as getRegisteredArtifactTypes,G as getRegisteredTypes,F as getVisualization,K as kpiVisualizationSchema,P as registerArtifact,E as registerVisualization,I as tableVisualizationSchema}from'../chunk-ERJKVQQT.js';export{h as useComposer,b as useMessage}from'../chunk-6RN7SUWT.js';import'../chunk-D2PFIJNZ.js';import'../chunk-4WWJTYYA.js';export{b as ChatProvider,c as useChatContext}from'../chunk-NKLA5PPB.js';import'../chunk-NG4HKXYB.js';import'../chunk-IUCKTDTZ.js';//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map