@iota-uz/sdk 0.1.1 → 0.3.0

package/dist/bichat/index.d.ts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ReactNode } from 'react';
+import react__default, { ReactNode, Component, ErrorInfo, HTMLAttributes, ReactElement, ImgHTMLAttributes, ButtonHTMLAttributes, RefObject } from 'react';
 
 /**
  * Type definitions for BI-Chat UI components
@@ -13,34 +13,75 @@ interface Session {
     createdAt: string;
     updatedAt: string;
 }
-declare enum MessageRole {
-    User = "user",
-    Assistant = "assistant",
-    System = "system",
-    Tool = "tool"
-}
-interface Message {
+/**
+ * A conversation turn groups a user message with its assistant response.
+ * This provides a cleaner mental model than flat message lists.
+ */
+interface ConversationTurn {
     id: string;
     sessionId: string;
-    role: MessageRole;
+    userTurn: UserTurn;
+    assistantTurn?: AssistantTurn;
+    createdAt: string;
+}
+/**
+ * Content of a user's message in a conversation turn
+ */
+interface UserTurn {
+    id: string;
     content: string;
+    attachments: Attachment[];
     createdAt: string;
-    toolCalls?: ToolCall[];
-    citations?: Citation[];
-    chartData?: ChartData;
-    artifacts?: Artifact[];
+}
+/**
+ * Content of an assistant's response in a conversation turn
+ */
+interface AssistantTurn {
+    id: string;
+    content: string;
     explanation?: string;
+    citations: Citation[];
+    chartData?: ChartData;
+    artifacts: Artifact[];
+    codeOutputs: CodeOutput[];
+    createdAt: string;
 }
+/**
+ * Role of a message in a conversation
+ */
+declare enum MessageRole {
+    User = "user",
+    Assistant = "assistant",
+    System = "system",
+    Tool = "tool"
+}
+/**
+ * A tool/function call made by the assistant
+ */
 interface ToolCall {
     id: string;
     name: string;
     arguments: string;
 }
+/**
+ * Citation with position information for inline replacement
+ */
 interface Citation {
     id: string;
-    source: string;
-    url?: string;
+    /** Type of citation (e.g., "url_citation") */
+    type: string;
+    /** Title of the cited source */
+    title: string;
+    /** URL of the cited source */
+    url: string;
+    /** Starting character index in the message content where this citation is referenced */
+    startIndex: number;
+    /** Ending character index in the message content where this citation is referenced */
+    endIndex: number;
+    /** Optional excerpt from the source */
     excerpt?: string;
+    /** Legacy: source name (for backward compatibility) */
+    source?: string;
 }
 interface Attachment {
     id: string;
@@ -56,20 +97,49 @@ interface ImageAttachment {
     base64Data: string;
     preview: string;
 }
+/**
+ * Output from code interpreter tool
+ */
 interface CodeOutput {
     type: 'image' | 'text' | 'error';
-    content: string | ImageAttachment;
+    content: string;
+    /** File metadata for downloadable outputs */
+    filename?: string;
+    mimeType?: string;
+    sizeBytes?: number;
 }
+/**
+ * Queued message for offline/loading state
+ */
 interface QueuedMessage {
     content: string;
     attachments: ImageAttachment[];
 }
+/**
+ * Chart visualization data for ApexCharts
+ */
 interface ChartData {
-    type: 'bar' | 'line' | 'pie' | 'area';
-    title?: string;
-    data: any[];
-    xAxisKey?: string;
-    yAxisKey?: string;
+    /** Type of chart: line, bar, pie, area, or donut */
+    chartType: 'line' | 'bar' | 'area' | 'pie' | 'donut';
+    /** Chart title displayed above the chart */
+    title: string;
+    /** Data series (multiple allowed for line/bar/area, single for pie/donut) */
+    series: ChartSeries[];
+    /** X-axis category labels or segment labels for pie/donut */
+    labels?: string[];
+    /** Hex color codes for series (e.g., '#4CAF50') */
+    colors?: string[];
+    /** Chart height in pixels */
+    height?: number;
+}
+/**
+ * A single data series in a chart
+ */
+interface ChartSeries {
+    /** Display name for this series */
+    name: string;
+    /** Numeric data values */
+    data: number[];
 }
 interface Artifact {
     type: 'excel' | 'pdf';
@@ -82,12 +152,37 @@ interface Artifact {
 interface PendingQuestion {
     id: string;
     turnId: string;
-    question: string;
-    type: 'MULTIPLE_CHOICE' | 'FREE_TEXT';
-    options?: string[];
+    questions: Question[];
     status: 'PENDING' | 'ANSWERED' | 'CANCELLED';
 }
-type QuestionAnswers = Record<string, string>;
+interface Question {
+    id: string;
+    text: string;
+    type: 'SINGLE_CHOICE' | 'MULTIPLE_CHOICE';
+    options?: QuestionOption[];
+    required?: boolean;
+}
+interface QuestionOption {
+    id: string;
+    label: string;
+    value: string;
+}
+/**
+ * Answer data for a single question, including predefined options and custom "Other" text.
+ */
+interface QuestionAnswerData {
+    /** Selected predefined options (labels) */
+    options: string[];
+    /** Custom text entered when user selects "Other" option */
+    customText?: string;
+}
+/**
+ * Map of question IDs to answer data.
+ * Supports both multi-select options and custom "Other" text input.
+ */
+interface QuestionAnswers {
+    [questionId: string]: QuestionAnswerData;
+}
 interface StreamChunk {
     type: 'chunk' | 'error' | 'done' | 'user_message';
     content?: string;
@@ -98,7 +193,7 @@ interface ChatDataSource {
     createSession(): Promise<Session>;
     fetchSession(id: string): Promise<{
         session: Session;
-        messages: Message[];
+        turns: ConversationTurn[];
         pendingQuestion?: PendingQuestion | null;
     } | null>;
     sendMessage(sessionId: string, content: string, attachments?: Attachment[], signal?: AbortSignal): AsyncGenerator<StreamChunk>;
@@ -114,7 +209,7 @@ interface ChatDataSource {
 }
 interface ChatSessionContextValue {
     message: string;
-    messages: Message[];
+    turns: ConversationTurn[];
     loading: boolean;
     error: string | null;
     currentSessionId?: string;
@@ -129,11 +224,12 @@ interface ChatSessionContextValue {
     setError: (error: string | null) => void;
     setCodeOutputs: (outputs: CodeOutput[]) => void;
     handleSubmit: (e: React.FormEvent, attachments?: ImageAttachment[]) => void;
-    handleRegenerate?: (messageId: string) => Promise<void>;
-    handleEdit?: (messageId: string, newContent: string) => Promise<void>;
+    handleRegenerate?: (turnId: string) => Promise<void>;
+    handleEdit?: (turnId: string, newContent: string) => Promise<void>;
     handleCopy: (text: string) => Promise<void>;
     handleSubmitQuestionAnswers: (answers: QuestionAnswers) => void;
     handleCancelPendingQuestion: () => Promise<void>;
+    handleRetry?: () => Promise<void>;
     handleUnqueue: () => {
         content: string;
         attachments: ImageAttachment[];
@@ -146,8 +242,10 @@ interface ChatSessionProps {
     dataSource: ChatDataSource;
     sessionId?: string;
     isReadOnly?: boolean;
-    renderUserMessage?: (message: Message) => ReactNode;
-    renderAssistantMessage?: (message: Message) => ReactNode;
+    /** Custom render function for user turns */
+    renderUserTurn?: (turn: ConversationTurn) => ReactNode;
+    /** Custom render function for assistant turns */
+    renderAssistantTurn?: (turn: ConversationTurn) => ReactNode;
     className?: string;
     /** Custom content to display as header */
     headerSlot?: ReactNode;
@@ -173,42 +271,319 @@ interface ChatHeaderProps {
 declare function ChatHeader({ session, onBack, logoSlot, actionsSlot }: ChatHeaderProps): react_jsx_runtime.JSX.Element;
 
 interface MessageListProps {
-    renderUserMessage?: (message: Message) => ReactNode;
-    renderAssistantMessage?: (message: Message) => ReactNode;
+    /** Custom render function for user turns */
+    renderUserTurn?: (turn: ConversationTurn) => ReactNode;
+    /** Custom render function for assistant turns */
+    renderAssistantTurn?: (turn: ConversationTurn) => ReactNode;
 }
-declare function MessageList({ renderUserMessage, renderAssistantMessage }: MessageListProps): react_jsx_runtime.JSX.Element;
+declare function MessageList({ renderUserTurn, renderAssistantTurn }: MessageListProps): react_jsx_runtime.JSX.Element;
 
-interface TurnBubbleProps {
-    message: Message;
-    renderUserMessage?: (message: Message) => ReactNode;
-    renderAssistantMessage?: (message: Message) => ReactNode;
+interface UserMessageAvatarSlotProps {
+    /** Default initials */
+    initials: string;
+}
+interface UserMessageContentSlotProps {
+    /** Message content text */
+    content: string;
+}
+interface UserMessageAttachmentsSlotProps {
+    /** Image attachments */
+    attachments: ImageAttachment[];
+    /** Handler to open image viewer */
+    onView: (index: number) => void;
+}
+interface UserMessageActionsSlotProps {
+    /** Copy content to clipboard */
+    onCopy: () => void;
+    /** Edit message (if available) */
+    onEdit?: () => void;
+    /** Formatted timestamp */
+    timestamp: string;
+    /** Whether copy action is available */
+    canCopy: boolean;
+    /** Whether edit action is available */
+    canEdit: boolean;
+}
+interface UserMessageSlots {
+    /** Custom avatar renderer */
+    avatar?: ReactNode | ((props: UserMessageAvatarSlotProps) => ReactNode);
+    /** Custom content renderer */
+    content?: ReactNode | ((props: UserMessageContentSlotProps) => ReactNode);
+    /** Custom attachments renderer */
+    attachments?: ReactNode | ((props: UserMessageAttachmentsSlotProps) => ReactNode);
+    /** Custom actions renderer */
+    actions?: ReactNode | ((props: UserMessageActionsSlotProps) => ReactNode);
+}
+interface UserMessageClassNames {
+    /** Root container */
+    root?: string;
+    /** Inner content wrapper */
+    wrapper?: string;
+    /** Avatar container */
+    avatar?: string;
+    /** Message bubble */
+    bubble?: string;
+    /** Content text */
+    content?: string;
+    /** Attachments container */
+    attachments?: string;
+    /** Actions container */
+    actions?: string;
+    /** Action button */
+    actionButton?: string;
+    /** Timestamp */
+    timestamp?: string;
+}
+interface UserMessageProps {
+    /** User turn data */
+    turn: UserTurn;
+    /** Turn ID for edit operations */
+    turnId?: string;
+    /** User initials for avatar */
+    initials?: string;
+    /** Slot overrides */
+    slots?: UserMessageSlots;
+    /** Class name overrides */
+    classNames?: UserMessageClassNames;
+    /** Copy handler */
+    onCopy?: (content: string) => Promise<void> | void;
+    /** Edit handler */
+    onEdit?: (turnId: string, newContent: string) => void;
+    /** Hide avatar */
+    hideAvatar?: boolean;
+    /** Hide actions */
+    hideActions?: boolean;
+    /** Hide timestamp */
+    hideTimestamp?: boolean;
 }
-declare function TurnBubble({ message, renderUserMessage, renderAssistantMessage, }: TurnBubbleProps): react_jsx_runtime.JSX.Element | null;
+declare function UserMessage({ turn, turnId, initials, slots, classNames: classNameOverrides, onCopy, onEdit, hideAvatar, hideActions, hideTimestamp, }: UserMessageProps): react_jsx_runtime.JSX.Element;
 
 interface UserTurnViewProps {
-    message: Message & {
-        attachments?: ImageAttachment[];
-    };
+    /** The conversation turn containing the user message */
+    turn: ConversationTurn;
+    /** Slot overrides for customization */
+    slots?: UserMessageSlots;
+    /** Class name overrides */
+    classNames?: UserMessageClassNames;
+    /** User initials for avatar */
+    initials?: string;
+    /** Hide avatar */
+    hideAvatar?: boolean;
+    /** Hide actions */
+    hideActions?: boolean;
+    /** Hide timestamp */
+    hideTimestamp?: boolean;
 }
-declare function UserTurnView({ message }: UserTurnViewProps): react_jsx_runtime.JSX.Element;
+declare function UserTurnView({ turn, slots, classNames, initials, hideAvatar, hideActions, hideTimestamp, }: UserTurnViewProps): react_jsx_runtime.JSX.Element;
+
+interface AssistantMessageAvatarSlotProps {
+    /** Default text */
+    text: string;
+}
+interface AssistantMessageContentSlotProps {
+    /** Message content (markdown) */
+    content: string;
+    /** Citations */
+    citations?: Citation[];
+    /** Whether streaming is active */
+    isStreaming: boolean;
+}
+interface AssistantMessageSourcesSlotProps {
+    /** Citations to display */
+    citations: Citation[];
+}
+interface AssistantMessageChartsSlotProps {
+    /** Chart data */
+    chartData: ChartData;
+}
+interface AssistantMessageCodeOutputsSlotProps {
+    /** Code execution outputs */
+    outputs: CodeOutput[];
+}
+interface AssistantMessageArtifactsSlotProps {
+    /** Downloadable artifacts */
+    artifacts: Artifact[];
+}
+interface AssistantMessageActionsSlotProps {
+    /** Copy content to clipboard */
+    onCopy: () => void;
+    /** Regenerate response */
+    onRegenerate?: () => void;
+    /** Formatted timestamp */
+    timestamp: string;
+    /** Whether copy action is available */
+    canCopy: boolean;
+    /** Whether regenerate action is available */
+    canRegenerate: boolean;
+}
+interface AssistantMessageExplanationSlotProps {
+    /** Explanation content (markdown) */
+    explanation: string;
+    /** Whether expanded */
+    isExpanded: boolean;
+    /** Toggle expansion */
+    onToggle: () => void;
+}
+interface AssistantMessageSlots {
+    /** Custom avatar renderer */
+    avatar?: ReactNode | ((props: AssistantMessageAvatarSlotProps) => ReactNode);
+    /** Custom content renderer */
+    content?: ReactNode | ((props: AssistantMessageContentSlotProps) => ReactNode);
+    /** Custom sources renderer */
+    sources?: ReactNode | ((props: AssistantMessageSourcesSlotProps) => ReactNode);
+    /** Custom charts renderer */
+    charts?: ReactNode | ((props: AssistantMessageChartsSlotProps) => ReactNode);
+    /** Custom code outputs renderer */
+    codeOutputs?: ReactNode | ((props: AssistantMessageCodeOutputsSlotProps) => ReactNode);
+    /** Custom artifacts renderer */
+    artifacts?: ReactNode | ((props: AssistantMessageArtifactsSlotProps) => ReactNode);
+    /** Custom actions renderer */
+    actions?: ReactNode | ((props: AssistantMessageActionsSlotProps) => ReactNode);
+    /** Custom explanation renderer */
+    explanation?: ReactNode | ((props: AssistantMessageExplanationSlotProps) => ReactNode);
+}
+interface AssistantMessageClassNames {
+    /** Root container */
+    root?: string;
+    /** Inner content wrapper */
+    wrapper?: string;
+    /** Avatar container */
+    avatar?: string;
+    /** Message bubble */
+    bubble?: string;
+    /** Code outputs container */
+    codeOutputs?: string;
+    /** Charts container */
+    charts?: string;
+    /** Artifacts container */
+    artifacts?: string;
+    /** Sources container */
+    sources?: string;
+    /** Explanation container */
+    explanation?: string;
+    /** Actions container */
+    actions?: string;
+    /** Action button */
+    actionButton?: string;
+    /** Timestamp */
+    timestamp?: string;
+}
+interface AssistantMessageProps {
+    /** Assistant turn data */
+    turn: AssistantTurn;
+    /** Turn ID for regenerate operations */
+    turnId?: string;
+    /** Whether response is being streamed */
+    isStreaming?: boolean;
+    /** Pending question for HITL */
+    pendingQuestion?: PendingQuestion | null;
+    /** Slot overrides */
+    slots?: AssistantMessageSlots;
+    /** Class name overrides */
+    classNames?: AssistantMessageClassNames;
+    /** Copy handler */
+    onCopy?: (content: string) => Promise<void> | void;
+    /** Regenerate handler */
+    onRegenerate?: (turnId: string) => Promise<void> | void;
+    /** Send message handler (for markdown links) */
+    onSendMessage?: (content: string) => void;
+    /** Whether sending is disabled */
+    sendDisabled?: boolean;
+    /** Hide avatar */
+    hideAvatar?: boolean;
+    /** Hide actions */
+    hideActions?: boolean;
+    /** Hide timestamp */
+    hideTimestamp?: boolean;
+}
+declare function AssistantMessage({ turn, turnId, isStreaming, pendingQuestion, slots, classNames: classNameOverrides, onCopy, onRegenerate, onSendMessage, sendDisabled, hideAvatar, hideActions, hideTimestamp, }: AssistantMessageProps): react_jsx_runtime.JSX.Element;
 
 interface AssistantTurnViewProps {
-    message: Message & {
-        codeOutputs?: CodeOutput[];
-        isStreaming?: boolean;
-    };
+    /** The conversation turn containing the assistant response */
+    turn: ConversationTurn;
+    /** Whether the response is currently being streamed */
+    isStreaming?: boolean;
+    /** Slot overrides for customization */
+    slots?: AssistantMessageSlots;
+    /** Class name overrides */
+    classNames?: AssistantMessageClassNames;
+    /** Hide avatar */
+    hideAvatar?: boolean;
+    /** Hide actions */
+    hideActions?: boolean;
+    /** Hide timestamp */
+    hideTimestamp?: boolean;
+}
+declare function AssistantTurnView({ turn, isStreaming, slots, classNames, hideAvatar, hideActions, hideTimestamp, }: AssistantTurnViewProps): react_jsx_runtime.JSX.Element | null;
+
+interface TurnBubbleClassNames {
+    /** Root container */
+    root?: string;
+    /** User turn wrapper */
+    userTurn?: string;
+    /** Assistant turn wrapper */
+    assistantTurn?: string;
+}
+interface TurnBubbleProps {
+    /** The conversation turn containing user and optional assistant content */
+    turn: ConversationTurn;
+    /** Custom render function for user turn (full control) */
+    renderUserTurn?: (turn: ConversationTurn) => ReactNode;
+    /** Custom render function for assistant turn (full control) */
+    renderAssistantTurn?: (turn: ConversationTurn) => ReactNode;
+    /** Props passed to UserTurnView (when not using custom renderer) */
+    userTurnProps?: Omit<UserTurnViewProps, 'turn'>;
+    /** Props passed to AssistantTurnView (when not using custom renderer) */
+    assistantTurnProps?: Omit<AssistantTurnViewProps, 'turn'>;
+    /** Slots for user message customization */
+    userMessageSlots?: UserMessageSlots;
+    /** Slots for assistant message customization */
+    assistantMessageSlots?: AssistantMessageSlots;
+    /** Class names for user message */
+    userMessageClassNames?: UserMessageClassNames;
+    /** Class names for assistant message */
+    assistantMessageClassNames?: AssistantMessageClassNames;
+    /** Class names for turn bubble container */
+    classNames?: TurnBubbleClassNames;
+    /** Whether assistant response is streaming */
+    isStreaming?: boolean;
 }
-declare function AssistantTurnView({ message }: AssistantTurnViewProps): react_jsx_runtime.JSX.Element;
+declare function TurnBubble({ turn, renderUserTurn, renderAssistantTurn, userTurnProps, assistantTurnProps, userMessageSlots, assistantMessageSlots, userMessageClassNames, assistantMessageClassNames, classNames, isStreaming, }: TurnBubbleProps): react_jsx_runtime.JSX.Element;
 
 interface MarkdownRendererProps {
+    /** Markdown content to render */
     content: string;
+    /** Optional citations to process and display */
     citations?: Citation[] | null;
+    /** Optional function to send messages (enables table export) */
+    sendMessage?: (content: string) => void;
+    /** Whether message sending is disabled */
+    sendDisabled?: boolean;
+    /** Copy button label for code blocks */
+    copyLabel?: string;
+    /** Copied confirmation label for code blocks */
+    copiedLabel?: string;
+    /** Export button label for tables */
+    exportLabel?: string;
 }
-declare function MarkdownRenderer({ content }: MarkdownRendererProps): react_jsx_runtime.JSX.Element;
+declare function MarkdownRenderer({ content, citations, sendMessage, sendDisabled, copyLabel, copiedLabel, exportLabel, }: MarkdownRendererProps): react_jsx_runtime.JSX.Element;
+declare const MemoizedMarkdownRenderer: react.MemoExoticComponent<typeof MarkdownRenderer>;
 
 interface ChartCardProps {
     chartData: ChartData;
 }
+/**
+ * ChartCard renders a single chart visualization with optional PNG export.
+ *
+ * Chart types:
+ * - line: Line chart with multiple series
+ * - bar: Bar chart with multiple series
+ * - area: Area chart with multiple series (filled)
+ * - pie: Pie chart (single series)
+ * - donut: Donut chart (single series)
+ *
+ * @param chartData - Chart specification from GraphQL API
+ */
 declare function ChartCard({ chartData }: ChartCardProps): react_jsx_runtime.JSX.Element;
 
 interface SourcesPanelProps {
@@ -224,7 +599,7 @@ declare function DownloadCard({ artifact }: DownloadCardProps): react_jsx_runtim
 interface InlineQuestionFormProps {
     pendingQuestion: PendingQuestion;
 }
-declare function InlineQuestionForm({ pendingQuestion }: InlineQuestionFormProps): react_jsx_runtime.JSX.Element;
+declare function InlineQuestionForm({ pendingQuestion }: InlineQuestionFormProps): react_jsx_runtime.JSX.Element | null;
 
 interface MessageInputRef {
     focus: () => void;
@@ -250,19 +625,67 @@ interface MessageInputProps {
 declare const MessageInput: react.ForwardRefExoticComponent<MessageInputProps & react.RefAttributes<MessageInputRef>>;
 
 interface AttachmentGridProps {
+    /** Array of image attachments to display */
     attachments: ImageAttachment[];
+    /** Optional callback when remove button is clicked */
     onRemove?: (index: number) => void;
+    /** Optional callback when thumbnail is clicked for preview */
     onView?: (index: number) => void;
+    /** Additional CSS class */
     className?: string;
+    /** If true, disable all interactions */
+    readonly?: boolean;
+    /** Maximum number of attachments to display (default: all) */
+    maxDisplay?: number;
+    /** Maximum total capacity (for warning display, default: 10) */
+    maxCapacity?: number;
+    /** Empty state message */
+    emptyMessage?: string;
+    /** Show count label above grid */
+    showCount?: boolean;
 }
-declare function AttachmentGrid({ attachments, onRemove, onView, className }: AttachmentGridProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * Responsive grid component for displaying image attachments
+ *
+ * Layout:
+ * - Mobile: 2 columns (grid-cols-2)
+ * - Tablet: 3 columns (sm:grid-cols-3)
+ * - Desktop: 4 columns (md:grid-cols-4)
+ */
+declare function AttachmentGrid({ attachments, onRemove, onView, className, readonly, maxDisplay, maxCapacity, emptyMessage, showCount, }: AttachmentGridProps): react_jsx_runtime.JSX.Element | null;
+declare const MemoizedAttachmentGrid: react__default.MemoExoticComponent<typeof AttachmentGrid>;
 
 interface ImageModalProps {
-    images: ImageAttachment[];
-    initialIndex: number;
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Callback to close the modal */
     onClose: () => void;
+    /** The current attachment to display */
+    attachment: ImageAttachment;
+    /** Optional: all attachments for navigation */
+    allAttachments?: ImageAttachment[];
+    /** Optional: current index for navigation state */
+    currentIndex?: number;
+    /** Optional: callback for navigation (prev/next) */
+    onNavigate?: (direction: 'prev' | 'next') => void;
 }
-declare function ImageModal({ images, initialIndex, onClose }: ImageModalProps): react_jsx_runtime.JSX.Element;
+/**
+ * Full-screen image modal component for viewing attachments
+ *
+ * Features:
+ * - Full-screen overlay with dark backdrop (90% opacity)
+ * - Large image display centered on screen
+ * - Close button (X) in top-right corner
+ * - Image metadata: filename, file size, MIME type
+ * - Navigation arrows (left/right) for image carousel
+ * - Keyboard support: Escape to close, Arrow keys to navigate
+ * - Click backdrop to close
+ * - Focus trap within modal
+ * - Body scroll locked when open
+ * - Image loading state with spinner
+ * - Navigation disabled at boundaries (not circular)
+ */
+declare function ImageModal({ isOpen, onClose, attachment, allAttachments, currentIndex, onNavigate, }: ImageModalProps): react.ReactPortal | null;
 
 /**
  * WelcomeContent Component
@@ -314,7 +737,7 @@ interface EmptyStateProps {
     size?: 'sm' | 'md' | 'lg';
 }
 declare function EmptyState({ icon, title, description, action, className, size, }: EmptyStateProps): react_jsx_runtime.JSX.Element;
-declare const _default$3: react.MemoExoticComponent<typeof EmptyState>;
+declare const MemoizedEmptyState: react.MemoExoticComponent<typeof EmptyState>;
 
 /**
  * EditableText Component
@@ -346,7 +769,7 @@ interface EditableTextRef {
     /** Programmatically cancel editing */
     cancelEditing: () => void;
 }
-declare const _default$2: react.MemoExoticComponent<react.ForwardRefExoticComponent<EditableTextProps & react.RefAttributes<EditableTextRef>>>;
+declare const MemoizedEditableText: react.MemoExoticComponent<react.ForwardRefExoticComponent<EditableTextProps & react.RefAttributes<EditableTextRef>>>;
 
 /**
  * SearchInput Component
@@ -375,7 +798,7 @@ interface SearchInputProps {
     ariaLabel?: string;
 }
 declare function SearchInput({ value, onChange, placeholder, autoFocus, onSubmit, onEscape, className, size, disabled, ariaLabel, }: SearchInputProps): react_jsx_runtime.JSX.Element;
-declare const _default$1: react.MemoExoticComponent<typeof SearchInput>;
+declare const MemoizedSearchInput: react.MemoExoticComponent<typeof SearchInput>;
 
 /**
  * Skeleton Component
@@ -436,7 +859,762 @@ declare function SkeletonCard({ width, height, className, }: {
 declare function ListItemSkeleton({ className }: {
     className?: string;
 }): react_jsx_runtime.JSX.Element;
-declare const _default: react.MemoExoticComponent<typeof Skeleton>;
+declare const MemoizedSkeleton: react.MemoExoticComponent<typeof Skeleton>;
+
+/**
+ * CodeBlock Component
+ * Syntax highlighted code blocks with copy functionality and dark mode support
+ */
+interface CodeBlockProps {
+    /** Programming language for syntax highlighting */
+    language: string;
+    /** Code content to display */
+    value: string;
+    /** Whether to render as inline code */
+    inline?: boolean;
+    /** Copy button label (defaults to "Copy") */
+    copyLabel?: string;
+    /** Copied confirmation label (defaults to "Copied!") */
+    copiedLabel?: string;
+}
+declare function CodeBlock({ language, value, inline, copyLabel, copiedLabel, }: CodeBlockProps): react_jsx_runtime.JSX.Element;
+declare const MemoizedCodeBlock: react.MemoExoticComponent<typeof CodeBlock>;
+
+/**
+ * LoadingSpinner Component
+ * Displays animated loading indicators
+ */
+type SpinnerVariant = 'spinner' | 'dots' | 'pulse';
+interface LoadingSpinnerProps {
+    variant?: SpinnerVariant;
+    size?: 'sm' | 'md' | 'lg';
+    message?: string;
+}
+declare function LoadingSpinner({ variant, size, message }: LoadingSpinnerProps): react_jsx_runtime.JSX.Element;
+declare const MemoizedLoadingSpinner: react.MemoExoticComponent<typeof LoadingSpinner>;
+
+/**
+ * TableExportButton Component
+ * Small inline button for exporting markdown tables to Excel
+ */
+interface TableExportButtonProps {
+    /** Click handler for export action */
+    onClick: () => void;
+    /** Whether the button should be disabled */
+    disabled?: boolean;
+    /** Export button label (defaults to "Export") */
+    label?: string;
+    /** Disabled tooltip text */
+    disabledTooltip?: string;
+}
+declare const TableExportButton: react.NamedExoticComponent<TableExportButtonProps>;
+
+interface TableWithExportProps {
+    /** The table content to render */
+    children: ReactNode;
+    /** Function to send a message (from chat context) */
+    sendMessage?: (content: string) => void;
+    /** Whether sending is disabled (loading or streaming) */
+    disabled?: boolean;
+    /** Custom export message to send */
+    exportMessage?: string;
+    /** Export button label */
+    exportLabel?: string;
+}
+declare const TableWithExport: react.NamedExoticComponent<TableWithExportProps>;
+
+/**
+ * useToast Hook
+ * Manages toast notification state
+ */
+type ToastType = 'success' | 'error' | 'info' | 'warning';
+interface ToastItem {
+    id: string;
+    type: ToastType;
+    message: string;
+    duration?: number;
+}
+interface UseToastReturn {
+    toasts: ToastItem[];
+    success: (msg: string, duration?: number) => void;
+    error: (msg: string, duration?: number) => void;
+    info: (msg: string, duration?: number) => void;
+    warning: (msg: string, duration?: number) => void;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+}
+/**
+ * Hook for managing toast notifications
+ *
+ * @example
+ * ```tsx
+ * const { toasts, success, error, dismiss } = useToast()
+ *
+ * // Show a success toast
+ * success('Operation completed!')
+ *
+ * // Show an error toast with custom duration
+ * error('Something went wrong', 10000)
+ *
+ * // Render toasts
+ * <ToastContainer toasts={toasts} onDismiss={dismiss} />
+ * ```
+ */
+declare function useToast(): UseToastReturn;
+
+interface ToastProps {
+    id: string;
+    type: ToastType;
+    message: string;
+    duration?: number;
+    onDismiss: (id: string) => void;
+    /** Label for dismiss button (defaults to "Dismiss") */
+    dismissLabel?: string;
+}
+declare function Toast({ id, type, message, duration, onDismiss, dismissLabel, }: ToastProps): react_jsx_runtime.JSX.Element;
+
+interface ToastContainerProps {
+    toasts: ToastItem[];
+    onDismiss: (id: string) => void;
+    /** Label for dismiss buttons */
+    dismissLabel?: string;
+}
+declare function ToastContainer({ toasts, onDismiss, dismissLabel }: ToastContainerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ConfirmModal Component
+ * Generic confirmation dialog with customizable title, message, and actions
+ */
+interface ConfirmModalProps {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Modal title */
+    title: string;
+    /** Modal message/description */
+    message: string;
+    /** Callback when user confirms */
+    onConfirm: () => void;
+    /** Callback when user cancels */
+    onCancel: () => void;
+    /** Confirm button text (defaults to "Confirm") */
+    confirmText?: string;
+    /** Cancel button text (defaults to "Cancel") */
+    cancelText?: string;
+    /** Whether this is a danger/destructive action (red confirm button) */
+    isDanger?: boolean;
+}
+declare function ConfirmModalBase({ isOpen, title, message, onConfirm, onCancel, confirmText, cancelText, isDanger, }: ConfirmModalProps): react_jsx_runtime.JSX.Element | null;
+declare const ConfirmModal: react.MemoExoticComponent<typeof ConfirmModalBase>;
+
+/**
+ * UserAvatar Component
+ * Displays user initials with deterministic color from a color palette
+ */
+interface UserAvatarProps {
+    /** User's first name */
+    firstName: string;
+    /** User's last name */
+    lastName: string;
+    /** Override initials (defaults to first letters of first and last name) */
+    initials?: string;
+    /** Avatar size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function UserAvatar({ firstName, lastName, initials: providedInitials, size, className, }: UserAvatarProps): react_jsx_runtime.JSX.Element;
+declare const MemoizedUserAvatar: react.MemoExoticComponent<typeof UserAvatar>;
+
+interface PermissionGuardProps {
+    /** Permission names to check */
+    permissions: string[];
+    /** Check mode: 'all' requires all permissions (AND), 'any' requires at least one (OR) */
+    mode?: 'all' | 'any';
+    /** Function to check if user has a specific permission */
+    hasPermission: (permission: string) => boolean;
+    /** Fallback to render when permissions are not satisfied */
+    fallback?: ReactNode;
+    /** Children to render when permissions are satisfied */
+    children: ReactNode;
+}
+/**
+ * Permission guard component.
+ * Conditionally renders children based on permission checks.
+ */
+declare function PermissionGuard({ permissions, mode, hasPermission, fallback, children, }: PermissionGuardProps): react_jsx_runtime.JSX.Element;
+
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    /** Optional custom error UI */
+    fallback?: ReactNode | ((error: Error | null, reset: () => void) => ReactNode);
+    /** Callback when an error is caught */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+/**
+ * Default error UI component
+ */
+declare function DefaultErrorContent({ error, onReset, resetLabel, errorTitle, }: {
+    error: Error | null;
+    onReset?: () => void;
+    resetLabel?: string;
+    errorTitle?: string;
+}): react_jsx_runtime.JSX.Element;
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    handleReset: () => void;
+    render(): string | number | boolean | Iterable<ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+}
+
+/**
+ * TypingIndicator Component
+ * Displays animated dots or rotating text to indicate AI is processing
+ */
+type TypingIndicatorVariant = 'dots' | 'text' | 'pulse';
+interface TypingIndicatorProps {
+    /** Display variant */
+    variant?: TypingIndicatorVariant;
+    /** Custom thinking messages (for text variant) */
+    messages?: string[];
+    /** Message rotation interval in ms (for text variant, defaults to 3000) */
+    rotationInterval?: number;
+    /** Size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function TypingIndicator({ variant, messages, rotationInterval, size, className, }: TypingIndicatorProps): react_jsx_runtime.JSX.Element;
+declare const MemoizedTypingIndicator: react.MemoExoticComponent<typeof TypingIndicator>;
+
+interface SlotProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+}
+/**
+ * Slot component that merges its props with its child element's props
+ * Used for the asChild pattern to allow consumers to customize the rendered element
+ */
+declare const Slot: react.ForwardRefExoticComponent<SlotProps & react.RefAttributes<HTMLElement>>;
+/**
+ * Helper type for components that support asChild
+ * Extends the HTML attributes while adding asChild option
+ */
+type AsChildProps<T extends HTMLAttributes<HTMLElement> = HTMLAttributes<HTMLElement>> = T & {
+    /** Merge props with child element instead of rendering wrapper */
+    asChild?: boolean;
+};
+/**
+ * Get children count (flattens fragments)
+ */
+declare function getValidChildren(children: ReactNode): ReactElement[];
+
+interface TurnContextValue {
+    /** Turn identifier */
+    turnId?: string;
+}
+declare function useTurnContext(): TurnContextValue;
+type TurnRootProps = AsChildProps<HTMLAttributes<HTMLDivElement>> & {
+    /** Turn identifier for tracking */
+    turnId?: string;
+};
+type TurnUserProps = AsChildProps<HTMLAttributes<HTMLDivElement>>;
+type TurnAssistantProps = AsChildProps<HTMLAttributes<HTMLDivElement>>;
+type TurnTimestampProps = AsChildProps<HTMLAttributes<HTMLTimeElement>> & {
+    /** ISO date string or Date object */
+    date?: string | Date;
+    /** Custom formatter */
+    formatter?: (date: Date) => string;
+};
+type TurnActionsProps = AsChildProps<HTMLAttributes<HTMLDivElement>>;
+declare const Turn: {
+    Root: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & {
+        /** Turn identifier for tracking */
+        turnId?: string;
+    } & react.RefAttributes<HTMLDivElement>>;
+    User: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLDivElement>>;
+    Assistant: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLDivElement>>;
+    Timestamp: react.ForwardRefExoticComponent<HTMLAttributes<HTMLTimeElement> & {
+        asChild?: boolean;
+    } & {
+        /** ISO date string or Date object */
+        date?: string | Date;
+        /** Custom formatter */
+        formatter?: (date: Date) => string;
+    } & react.RefAttributes<HTMLTimeElement>>;
+    Actions: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLDivElement>>;
+};
+
+type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
+interface AvatarContextValue {
+    imageLoadingStatus: ImageLoadingStatus;
+    setImageLoadingStatus: (status: ImageLoadingStatus) => void;
+}
+declare function useAvatarContext(): AvatarContextValue;
+type AvatarRootProps = AsChildProps<HTMLAttributes<HTMLSpanElement>>;
+type AvatarImageProps = AsChildProps<ImgHTMLAttributes<HTMLImageElement>> & {
+    /** Called when loading status changes */
+    onLoadingStatusChange?: (status: ImageLoadingStatus) => void;
+};
+type AvatarFallbackProps = AsChildProps<HTMLAttributes<HTMLSpanElement>> & {
+    /** Delay before showing fallback (in ms) */
+    delayMs?: number;
+};
+declare const Avatar: {
+    Root: react.ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLSpanElement>>;
+    Image: react.ForwardRefExoticComponent<ImgHTMLAttributes<HTMLImageElement> & {
+        asChild?: boolean;
+    } & {
+        /** Called when loading status changes */
+        onLoadingStatusChange?: (status: ImageLoadingStatus) => void;
+    } & react.RefAttributes<HTMLImageElement>>;
+    Fallback: react.ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & {
+        asChild?: boolean;
+    } & {
+        /** Delay before showing fallback (in ms) */
+        delayMs?: number;
+    } & react.RefAttributes<HTMLSpanElement>>;
+};
+
+type BubbleVariant = 'user' | 'assistant' | 'system';
+interface BubbleContextValue {
+    variant?: BubbleVariant;
+}
+declare function useBubbleContext(): BubbleContextValue;
+type BubbleRootProps = AsChildProps<HTMLAttributes<HTMLDivElement>> & {
+    /** Bubble variant (affects data attribute for styling) */
+    variant?: BubbleVariant;
+};
+type BubbleContentProps = AsChildProps<HTMLAttributes<HTMLDivElement>>;
+type BubbleHeaderProps = AsChildProps<HTMLAttributes<HTMLDivElement>>;
+type BubbleFooterProps = AsChildProps<HTMLAttributes<HTMLDivElement>>;
+type BubbleMetadataProps = AsChildProps<HTMLAttributes<HTMLDivElement>>;
+declare const Bubble: {
+    Root: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & {
+        /** Bubble variant (affects data attribute for styling) */
+        variant?: BubbleVariant;
+    } & react.RefAttributes<HTMLDivElement>>;
+    Content: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLDivElement>>;
+    Header: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLDivElement>>;
+    Footer: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLDivElement>>;
+    Metadata: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLDivElement>>;
+};
+
+interface ActionButtonContextValue {
+    isHovered: boolean;
+    isFocused: boolean;
+    isPressed: boolean;
+    isDisabled: boolean;
+}
+declare function useActionButtonContext(): ActionButtonContextValue;
+type ActionButtonRootProps = AsChildProps<ButtonHTMLAttributes<HTMLButtonElement>>;
+type ActionButtonIconProps = AsChildProps<HTMLAttributes<HTMLSpanElement>>;
+type ActionButtonLabelProps = AsChildProps<HTMLAttributes<HTMLSpanElement>> & {
+    /** Visually hidden but accessible to screen readers */
+    srOnly?: boolean;
+};
+type ActionButtonTooltipProps = AsChildProps<HTMLAttributes<HTMLSpanElement>> & {
+    /** Position relative to button */
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    /** Only show when hovered */
+    showOnHover?: boolean;
+};
+declare const ActionButton: {
+    Root: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLButtonElement>>;
+    Icon: react.ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & {
+        asChild?: boolean;
+    } & react.RefAttributes<HTMLSpanElement>>;
+    Label: react.ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & {
+        asChild?: boolean;
+    } & {
+        /** Visually hidden but accessible to screen readers */
+        srOnly?: boolean;
+    } & react.RefAttributes<HTMLSpanElement>>;
+    Tooltip: react.ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & {
+        asChild?: boolean;
+    } & {
+        /** Position relative to button */
+        position?: "top" | "bottom" | "left" | "right";
+        /** Only show when hovered */
+        showOnHover?: boolean;
+    } & react.RefAttributes<HTMLSpanElement>>;
+};
+
+/**
+ * useStreaming hook
+ * Handles AsyncGenerator streaming responses with cancellation support
+ */
+
+interface UseStreamingOptions {
+    onChunk?: (content: string) => void;
+    onError?: (error: string) => void;
+    onDone?: () => void;
+}
+declare function useStreaming(options?: UseStreamingOptions): {
+    content: string;
+    isStreaming: boolean;
+    error: Error | null;
+    processStream: (stream: AsyncGenerator<StreamChunk>, signal?: AbortSignal) => Promise<void>;
+    cancel: () => void;
+    reset: () => void;
+};
+
+/**
+ * Translation hook using locale from IotaContext
+ */
+declare function useTranslation(): {
+    t: (key: string, params?: Record<string, any>) => string;
+    locale: string;
+};
+
+/**
+ * Hook to prevent body scroll when modal is open
+ * Restores scroll on cleanup or when modal closes
+ *
+ * @param isOpen - Whether the modal is currently open
+ *
+ * @example
+ * const [isModalOpen, setIsModalOpen] = useState(false)
+ * useModalLock(isModalOpen)
+ */
+declare function useModalLock(isOpen: boolean): void;
+
+/**
+ * Hook to trap focus within a container (for modals, sidebars)
+ * Ensures Tab and Shift+Tab cycle through focusable elements only
+ *
+ * @param containerRef - React ref to the container element
+ * @param isActive - Whether the focus trap is currently active
+ * @param restoreFocusOnDeactivate - Element to restore focus to when deactivated
+ *
+ * @example
+ * const modalRef = useRef<HTMLDivElement>(null)
+ * useFocusTrap(modalRef, isOpen)
+ */
+declare function useFocusTrap(containerRef: RefObject<HTMLElement | null>, isActive: boolean, restoreFocusOnDeactivate?: HTMLElement | null): void;
+
+/**
+ * useImageGallery Hook
+ * Manages image modal/gallery state and navigation
+ */
+
+interface UseImageGalleryOptions {
+    /** Initial images to display */
+    images?: ImageAttachment[];
+    /** Wrap navigation at boundaries (default: false) */
+    wrap?: boolean;
+    /** Callback when modal opens */
+    onOpen?: (index: number) => void;
+    /** Callback when modal closes */
+    onClose?: () => void;
+    /** Callback when navigation occurs */
+    onNavigate?: (index: number, direction: 'prev' | 'next') => void;
+}
+interface UseImageGalleryReturn {
+    /** Whether the gallery modal is open */
+    isOpen: boolean;
+    /** Current image index */
+    currentIndex: number;
+    /** Current image (or undefined if none) */
+    currentImage: ImageAttachment | undefined;
+    /** All images in the gallery */
+    images: ImageAttachment[];
+    /** Whether there's a previous image */
+    hasPrev: boolean;
+    /** Whether there's a next image */
+    hasNext: boolean;
+    /** Open gallery at specific index */
+    open: (index: number, newImages?: ImageAttachment[]) => void;
+    /** Close the gallery */
+    close: () => void;
+    /** Navigate to previous image */
+    prev: () => void;
+    /** Navigate to next image */
+    next: () => void;
+    /** Navigate to specific index */
+    goTo: (index: number) => void;
+    /** Set images without opening */
+    setImages: (images: ImageAttachment[]) => void;
+}
+/**
+ * Hook for managing image gallery/modal state
+ *
+ * @example
+ * ```tsx
+ * const gallery = useImageGallery({ images: attachments })
+ *
+ * // Open gallery
+ * <button onClick={() => gallery.open(0)}>View Images</button>
+ *
+ * // Render gallery
+ * {gallery.isOpen && (
+ *   <ImageModal
+ *     image={gallery.currentImage}
+ *     onClose={gallery.close}
+ *     onPrev={gallery.prev}
+ *     onNext={gallery.next}
+ *     hasPrev={gallery.hasPrev}
+ *     hasNext={gallery.hasNext}
+ *   />
+ * )}
+ * ```
+ */
+declare function useImageGallery(options?: UseImageGalleryOptions): UseImageGalleryReturn;
+
+/**
+ * useAutoScroll Hook
+ * Manages auto-scroll behavior for chat containers
+ */
+interface UseAutoScrollOptions {
+    /** Threshold in pixels from bottom to consider "at bottom" (default: 100) */
+    threshold?: number;
+    /** Smooth scroll behavior (default: true) */
+    smooth?: boolean;
+    /** Callback when scroll position changes */
+    onScroll?: (isAtBottom: boolean) => void;
+}
+interface UseAutoScrollReturn {
+    /** Ref to attach to the scrollable container */
+    containerRef: React.RefObject<HTMLDivElement>;
+    /** Whether the container is scrolled to the bottom */
+    isAtBottom: boolean;
+    /** Whether auto-scroll should be active */
+    shouldAutoScroll: boolean;
+    /** Manually scroll to bottom */
+    scrollToBottom: (smooth?: boolean) => void;
+    /** Enable/disable auto-scroll */
+    setAutoScroll: (enabled: boolean) => void;
+    /** Handle scroll event (attach to container if not using ref) */
+    handleScroll: (e: React.UIEvent<HTMLDivElement>) => void;
+}
+/**
+ * Hook for managing auto-scroll behavior in chat containers
+ *
+ * @example
+ * ```tsx
+ * const scroll = useAutoScroll({ threshold: 50 })
+ *
+ * // Attach to container
+ * <div ref={scroll.containerRef} onScroll={scroll.handleScroll}>
+ *   {messages.map(msg => <Message key={msg.id} />)}
+ * </div>
+ *
+ * // Scroll button
+ * {!scroll.isAtBottom && (
+ *   <button onClick={() => scroll.scrollToBottom()}>
+ *     Scroll to bottom
+ *   </button>
+ * )}
+ * ```
+ */
+declare function useAutoScroll(options?: UseAutoScrollOptions): UseAutoScrollReturn;
+
+/**
+ * useMessageActions Hook
+ * Provides copy, regenerate, and edit functionality for messages
+ */
+interface UseMessageActionsOptions {
+    /** Callback when copy succeeds */
+    onCopy?: (content: string) => void;
+    /** Callback when copy fails */
+    onCopyError?: (error: Error) => void;
+    /** Callback when regenerate is triggered */
+    onRegenerate?: () => void | Promise<void>;
+    /** Callback when edit is triggered */
+    onEdit?: (content: string) => void | Promise<void>;
+    /** Duration to show "copied" state in ms (default: 2000) */
+    copiedDuration?: number;
+}
+interface UseMessageActionsReturn {
+    /** Whether content was recently copied */
+    isCopied: boolean;
+    /** Whether regenerate is in progress */
+    isRegenerating: boolean;
+    /** Whether edit is in progress */
+    isEditing: boolean;
+    /** Copy content to clipboard */
+    copy: (content: string) => Promise<void>;
+    /** Trigger regenerate action */
+    regenerate: () => Promise<void>;
+    /** Trigger edit action */
+    edit: (content: string) => Promise<void>;
+    /** Reset all states */
+    reset: () => void;
+}
+/**
+ * Hook for managing message actions (copy, regenerate, edit)
+ *
+ * @example
+ * ```tsx
+ * const actions = useMessageActions({
+ *   onRegenerate: () => chatContext.regenerateMessage(messageId),
+ *   onEdit: (content) => chatContext.editMessage(messageId, content),
+ *   onCopy: () => toast.success('Copied!'),
+ * })
+ *
+ * <button onClick={() => actions.copy(message.content)}>
+ *   {actions.isCopied ? 'Copied!' : 'Copy'}
+ * </button>
+ *
+ * <button onClick={actions.regenerate} disabled={actions.isRegenerating}>
+ *   {actions.isRegenerating ? 'Regenerating...' : 'Regenerate'}
+ * </button>
+ * ```
+ */
+declare function useMessageActions(options?: UseMessageActionsOptions): UseMessageActionsReturn;
+
+/**
+ * useAttachments Hook
+ * Manages file upload state, validation, and preview
+ */
+
+interface FileValidationError {
+    file: File;
+    reason: 'size' | 'type' | 'count' | 'custom';
+    message: string;
+}
+interface UseAttachmentsOptions {
+    /** Maximum number of files (default: 10) */
+    maxFiles?: number;
+    /** Maximum file size in bytes (default: 10MB) */
+    maxFileSize?: number;
+    /** Allowed MIME types (default: images only) */
+    allowedTypes?: string[];
+    /** Custom validation function */
+    validate?: (file: File) => string | null;
+    /** Callback when files are added */
+    onAdd?: (files: Attachment[]) => void;
+    /** Callback when a file is removed */
+    onRemove?: (file: Attachment) => void;
+    /** Callback when validation fails */
+    onError?: (errors: FileValidationError[]) => void;
+}
+interface UseAttachmentsReturn {
+    /** Current attachments */
+    files: Attachment[];
+    /** Validation errors from last operation */
+    errors: FileValidationError[];
+    /** Whether files are being processed */
+    isProcessing: boolean;
+    /** Whether max file limit is reached */
+    isMaxReached: boolean;
+    /** Number of remaining slots */
+    remainingSlots: number;
+    /** Add files (validates and processes) */
+    add: (files: FileList | File[]) => Promise<void>;
+    /** Remove a specific file */
+    remove: (fileOrId: Attachment | string) => void;
+    /** Clear all files */
+    clear: () => void;
+    /** Clear errors */
+    clearErrors: () => void;
+    /** Set files directly (for controlled mode) */
+    setFiles: (files: Attachment[]) => void;
+}
+/**
+ * Hook for managing file attachments
+ *
+ * @example
+ * ```tsx
+ * const attachments = useAttachments({
+ *   maxFiles: 5,
+ *   maxFileSize: 5 * 1024 * 1024, // 5MB
+ *   onError: (errors) => errors.forEach(e => toast.error(e.message)),
+ * })
+ *
+ * <input
+ *   type="file"
+ *   multiple
+ *   accept="image/*"
+ *   onChange={(e) => attachments.add(e.target.files)}
+ * />
+ *
+ * {attachments.files.map(file => (
+ *   <AttachmentPreview
+ *     key={file.id}
+ *     attachment={file}
+ *     onRemove={() => attachments.remove(file)}
+ *   />
+ * ))}
+ *
+ * {attachments.errors.length > 0 && (
+ *   <ErrorList errors={attachments.errors} />
+ * )}
+ * ```
+ */
+declare function useAttachments(options?: UseAttachmentsOptions): UseAttachmentsReturn;
+
+/**
+ * useMarkdownCopy Hook
+ * Manages copy-to-clipboard state for code blocks in markdown
+ */
+interface UseMarkdownCopyOptions {
+    /** Duration to show "copied" state in ms (default: 2000) */
+    copiedDuration?: number;
+    /** Callback when copy succeeds */
+    onCopy?: (content: string, language?: string) => void;
+    /** Callback when copy fails */
+    onError?: (error: Error) => void;
+}
+interface UseMarkdownCopyReturn {
+    /** Map of copied states by block ID */
+    copiedStates: Map<string, boolean>;
+    /** Check if a specific block is in copied state */
+    isCopied: (blockId: string) => boolean;
+    /** Copy content with block ID tracking */
+    copy: (blockId: string, content: string, language?: string) => Promise<void>;
+    /** Reset copied state for a specific block */
+    reset: (blockId: string) => void;
+    /** Reset all copied states */
+    resetAll: () => void;
+}
+/**
+ * Hook for managing copy states for multiple code blocks
+ *
+ * @example
+ * ```tsx
+ * const markdownCopy = useMarkdownCopy({
+ *   onCopy: (content, lang) => console.log(`Copied ${lang} code`),
+ * })
+ *
+ * function CodeBlock({ id, code, language }) {
+ *   return (
+ *     <div>
+ *       <pre>{code}</pre>
+ *       <button onClick={() => markdownCopy.copy(id, code, language)}>
+ *         {markdownCopy.isCopied(id) ? 'Copied!' : 'Copy'}
+ *       </button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useMarkdownCopy(options?: UseMarkdownCopyOptions): UseMarkdownCopyReturn;
 
 /**
  * Framer Motion animation variants for BiChat UI
@@ -870,33 +2048,6 @@ declare function useRequiredConfig(): BiChatConfig;
  */
 declare function hasPermission(config: BiChatConfig | null, permission: string): boolean;
 
-/**
- * useStreaming hook
- * Handles AsyncGenerator streaming responses with cancellation support
- */
-
-interface UseStreamingOptions {
-    onChunk?: (content: string) => void;
-    onError?: (error: string) => void;
-    onDone?: () => void;
-}
-declare function useStreaming(options?: UseStreamingOptions): {
-    content: string;
-    isStreaming: boolean;
-    error: Error | null;
-    processStream: (stream: AsyncGenerator<StreamChunk>, signal?: AbortSignal) => Promise<void>;
-    cancel: () => void;
-    reset: () => void;
-};
-
-/**
- * Translation hook using locale from IotaContext
- */
-declare function useTranslation(): {
-    t: (key: string, params?: Record<string, any>) => string;
-    locale: string;
-};
-
 /**
  * Theme system type definitions
  */
@@ -981,6 +2132,8 @@ declare function createHeadersWithCSRF(init?: HeadersInit): Headers;
 /**
  * Built-in HTTP data source with SSE streaming and AbortController
  * Implements ChatDataSource interface with real HTTP/GraphQL calls
+ *
+ * Uses turn-based architecture - fetches ConversationTurns instead of flat messages.
  */
 
 interface HttpDataSourceConfig {
@@ -993,7 +2146,7 @@ interface HttpDataSourceConfig {
 }
 interface SessionState {
     session: Session;
-    messages: Message[];
+    turns: ConversationTurn[];
     pendingQuestion?: PendingQuestion | null;
 }
 interface Result<T> {
@@ -1022,7 +2175,7 @@ declare class HttpDataSource implements ChatDataSource {
      */
     createSession(): Promise<Session>;
     /**
-     * Fetch an existing session with messages
+     * Fetch an existing session with turns (turn-based architecture)
      */
     fetchSession(id: string): Promise<SessionState | null>;
     /**
@@ -1078,4 +2231,43 @@ declare function formatFileSize(bytes: number): string;
  */
 declare function validateFileCount(currentCount: number, newCount: number, maxCount?: number): void;
 
-export { type AppConfig, type Artifact, AssistantTurnView, type Attachment, AttachmentGrid, type BiChatConfig, ChartCard, type ChartData, type ChatDataSource, ChatHeader, ChatSession, type ChatSessionContextValue, ChatSessionProvider, type Citation, type CodeOutput, CodeOutputsPanel, ConfigProvider, DownloadCard, _default$2 as EditableText, type EditableTextProps, type EditableTextRef, _default$3 as EmptyState, type EmptyStateProps, HttpDataSource, type HttpDataSourceConfig, type ImageAttachment, ImageModal, InlineQuestionForm, type IotaContext, IotaContextProvider, ListItemSkeleton, type LocaleContext, MarkdownRenderer, type Message, MessageInput, type MessageInputProps, type MessageInputRef, MessageList, MessageRole, type PendingQuestion, type QuestionAnswers, type QueuedMessage, RateLimiter, type RateLimiterConfig, ScrollToBottomButton, _default$1 as SearchInput, type SearchInputProps, type Session, _default as Skeleton, SkeletonAvatar, SkeletonCard, SkeletonGroup, type SkeletonGroupProps, type SkeletonProps, SkeletonText, SourcesPanel, type StreamChunk, StreamingCursor, type TenantContext, type Theme, type ThemeBorderRadius, type ThemeColors, ThemeProvider, type ThemeSpacing, type ToolCall, TurnBubble, type UserContext, UserTurnView, WelcomeContent, addCSRFHeader, backdropVariants, buttonVariants, convertToBase64, createDataUrl, createHeadersWithCSRF, createHttpDataSource, darkTheme, dropdownVariants, fadeInUpVariants, fadeInVariants, floatingButtonVariants, formatFileSize, getCSRFToken, hasPermission as hasConfigPermission, hasPermission$1 as hasPermission, lightTheme, listItemVariants, messageContainerVariants, messageVariants, scaleFadeVariants, staggerContainerVariants, toastVariants, typingDotVariants, useChat, useConfig, useIotaContext, useRequiredConfig, useStreaming, useTheme, useTranslation, validateFileCount, validateImageFile };
+/**
+ * Citation Processing Utility
+ *
+ * Transforms OpenAI citations from raw markers (e.g., ≡cite≡turn0search2≡)
+ * to formatted inline citation markers (e.g., [1], [2]).
+ *
+ * Process:
+ * 1. Sort citations by startIndex (descending) to process from end to start
+ * 2. Replace character ranges [startIndex, endIndex] with numbered markers
+ * 3. Return processed content with clean inline citation references
+ */
+
+interface ProcessedContent {
+    /** Content with citation markers replaced by [1], [2], etc. */
+    content: string;
+    /** Citations array with their display indices */
+    citations: Array<Citation & {
+        displayIndex: number;
+    }>;
+}
+/**
+ * Process message content to replace raw citation markers with formatted inline citations
+ *
+ * @param content - Raw message content with potential citation markers
+ * @param citations - Array of citations with startIndex/endIndex positions
+ * @returns Processed content with clean citation markers and indexed citations
+ *
+ * @example
+ * ```ts
+ * const result = processCitations(
+ *   "Tesla reported $28B ≡cite≡turn0search2≡ revenue",
+ *   [{ startIndex: 20, endIndex: 42, title: "...", url: "...", type: "url_citation" }]
+ * )
+ * // result.content = "Tesla reported $28B [1] revenue"
+ * // result.citations = [{ ..., displayIndex: 1 }]
+ * ```
+ */
+declare function processCitations(content: string, citations: Citation[] | null | undefined): ProcessedContent;
+
+export { ActionButton, type ActionButtonIconProps, type ActionButtonLabelProps, type ActionButtonRootProps, type ActionButtonTooltipProps, type AppConfig, type Artifact, type AsChildProps, AssistantMessage, type AssistantMessageActionsSlotProps, type AssistantMessageArtifactsSlotProps, type AssistantMessageAvatarSlotProps, type AssistantMessageChartsSlotProps, type AssistantMessageClassNames, type AssistantMessageCodeOutputsSlotProps, type AssistantMessageContentSlotProps, type AssistantMessageExplanationSlotProps, type AssistantMessageProps, type AssistantMessageSlots, type AssistantMessageSourcesSlotProps, type AssistantTurn, AssistantTurnView, type AssistantTurnViewProps, type Attachment, MemoizedAttachmentGrid as AttachmentGrid, Avatar, type AvatarFallbackProps, type AvatarImageProps, type AvatarRootProps, type BiChatConfig, Bubble, type BubbleContentProps, type BubbleFooterProps, type BubbleHeaderProps, type BubbleMetadataProps, type BubbleRootProps, type BubbleVariant, ChartCard, type ChartData, type ChartSeries, type ChatDataSource, ChatHeader, ChatSession, type ChatSessionContextValue, ChatSessionProvider, type Citation, MemoizedCodeBlock as CodeBlock, type CodeOutput, CodeOutputsPanel, ConfigProvider, ConfirmModal, type ConfirmModalProps, type ConversationTurn, DefaultErrorContent, DownloadCard, MemoizedEditableText as EditableText, type EditableTextProps, type EditableTextRef, MemoizedEmptyState as EmptyState, type EmptyStateProps, ErrorBoundary, type FileValidationError, HttpDataSource, type HttpDataSourceConfig, type ImageAttachment, type ImageLoadingStatus, ImageModal, InlineQuestionForm, type IotaContext, IotaContextProvider, ListItemSkeleton, MemoizedLoadingSpinner as LoadingSpinner, type LocaleContext, MemoizedMarkdownRenderer as MarkdownRenderer, MessageInput, type MessageInputProps, type MessageInputRef, MessageList, MessageRole, type PendingQuestion, PermissionGuard, type PermissionGuardProps, type ProcessedContent, type Question, type QuestionAnswerData, type QuestionAnswers, type QuestionOption, type QueuedMessage, RateLimiter, type RateLimiterConfig, ScrollToBottomButton, MemoizedSearchInput as SearchInput, type SearchInputProps, type Session, MemoizedSkeleton as Skeleton, SkeletonAvatar, SkeletonCard, SkeletonGroup, type SkeletonGroupProps, type SkeletonProps, SkeletonText, Slot, type SlotProps, SourcesPanel, type StreamChunk, StreamingCursor, TableExportButton, TableWithExport, type TenantContext, type Theme, type ThemeBorderRadius, type ThemeColors, ThemeProvider, type ThemeSpacing, Toast, ToastContainer, type ToastItem, type ToastProps, type ToastType, type ToolCall, Turn, type TurnActionsProps, type TurnAssistantProps, TurnBubble, type TurnBubbleClassNames, type TurnBubbleProps, type TurnRootProps, type TurnTimestampProps, type TurnUserProps, MemoizedTypingIndicator as TypingIndicator, type TypingIndicatorProps, type TypingIndicatorVariant, type UseAttachmentsOptions, type UseAttachmentsReturn, type UseAutoScrollOptions, type UseAutoScrollReturn, type UseImageGalleryOptions, type UseImageGalleryReturn, type UseMarkdownCopyOptions, type UseMarkdownCopyReturn, type UseMessageActionsOptions, type UseMessageActionsReturn, type UseToastReturn, MemoizedUserAvatar as UserAvatar, type UserAvatarProps, type UserContext, UserMessage, type UserMessageActionsSlotProps, type UserMessageAttachmentsSlotProps, type UserMessageAvatarSlotProps, type UserMessageClassNames, type UserMessageContentSlotProps, type UserMessageProps, type UserMessageSlots, type UserTurn, UserTurnView, type UserTurnViewProps, WelcomeContent, addCSRFHeader, backdropVariants, buttonVariants, convertToBase64, createDataUrl, createHeadersWithCSRF, createHttpDataSource, darkTheme, dropdownVariants, fadeInUpVariants, fadeInVariants, floatingButtonVariants, formatFileSize, getCSRFToken, getValidChildren, hasPermission as hasConfigPermission, hasPermission$1 as hasPermission, lightTheme, listItemVariants, messageContainerVariants, messageVariants, processCitations, scaleFadeVariants, staggerContainerVariants, toastVariants, typingDotVariants, useActionButtonContext, useAttachments, useAutoScroll, useAvatarContext, useBubbleContext, useChat, useConfig, useFocusTrap, useImageGallery, useIotaContext, useMarkdownCopy, useMessageActions, useModalLock, useRequiredConfig, useStreaming, useTheme, useToast, useTranslation, useTurnContext, validateFileCount, validateImageFile };