@iota-uz/sdk 0.1.2 → 0.3.1

package/dist/bichat/index.d.cts

@@ -1,11 +1,13 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ReactNode } from 'react';
+import react__default, { ReactNode, Component, ErrorInfo, FC, HTMLAttributes, ReactElement, ImgHTMLAttributes, ButtonHTMLAttributes, RefObject } from 'react';
+import { I as InitialContext, A as AppConfig$1, L as LocaleContext$1, c as TenantContext$1, U as UserContext$1 } from '../index-B73-BCi-.cjs';
+import { File as File$1 } from '@phosphor-icons/react';
 
 /**
  * Type definitions for BI-Chat UI components
  */
-interface Session {
+interface Session$1 {
     id: string;
     title: string;
     status: 'active' | 'archived';
@@ -13,65 +15,140 @@ 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$1 {
     id: string;
     sessionId: string;
-    role: MessageRole;
+    userTurn: UserTurn$1;
+    assistantTurn?: AssistantTurn$1;
+    createdAt: string;
+}
+/**
+ * Content of a user's message in a conversation turn
+ */
+interface UserTurn$1 {
+    id: string;
     content: string;
+    attachments: Attachment$1[];
     createdAt: string;
-    toolCalls?: ToolCall[];
-    citations?: Citation[];
-    chartData?: ChartData;
-    artifacts?: Artifact[];
+}
+/**
+ * Content of an assistant's response in a conversation turn
+ */
+interface AssistantTurn$1 {
+    id: string;
+    role?: MessageRole;
+    content: string;
     explanation?: string;
+    citations: Citation$1[];
+    toolCalls?: ToolCall$1[];
+    chartData?: ChartData;
+    artifacts: Artifact$1[];
+    codeOutputs: CodeOutput$1[];
+    debug?: DebugTrace$1;
+    createdAt: string;
 }
-interface ToolCall {
+/**
+ * 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$1 {
     id: string;
     name: string;
     arguments: string;
+    result?: string;
+    error?: string;
+    durationMs?: number;
 }
-interface Citation {
+/**
+ * Citation with position information for inline replacement
+ */
+interface Citation$1 {
     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;
+interface Attachment$1 {
+    id?: string;
     filename: string;
     mimeType: string;
     sizeBytes: number;
     base64Data?: string;
+    url?: string;
+    preview?: string;
 }
-interface ImageAttachment {
-    filename: string;
-    mimeType: string;
-    sizeBytes: number;
+type ImageAttachment = Attachment$1 & {
     base64Data: string;
     preview: string;
-}
-interface CodeOutput {
+};
+/**
+ * Output from code interpreter tool
+ */
+interface CodeOutput$1 {
     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[];
+    attachments: Attachment$1[];
 }
+/**
+ * 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;
 }
-interface Artifact {
+/**
+ * A single data series in a chart
+ */
+interface ChartSeries {
+    /** Display name for this series */
+    name: string;
+    /** Numeric data values */
+    data: number[];
+}
+interface Artifact$1 {
     type: 'excel' | 'pdf';
     filename: string;
     url: string;
@@ -79,75 +156,286 @@ interface Artifact {
     rowCount?: number;
     description?: string;
 }
-interface PendingQuestion {
+interface SessionArtifact {
+    id: string;
+    sessionId: string;
+    messageId?: string;
+    type: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    url?: string;
+    sizeBytes: number;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+}
+interface PendingQuestion$1 {
     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';
+    type: 'chunk' | 'content' | 'tool_start' | 'tool_end' | 'usage' | 'done' | 'error' | 'user_message' | 'interrupt';
     content?: string;
     error?: string;
     sessionId?: string;
+    usage?: DebugUsage$1;
+    tool?: StreamToolPayload;
+    interrupt?: StreamInterruptPayload;
+    generationMs?: number;
+    timestamp?: number;
+}
+interface StreamInterruptPayload {
+    checkpointId: string;
+    agentName?: string;
+    questions: StreamInterruptQuestion[];
+}
+interface StreamInterruptQuestion {
+    id: string;
+    text: string;
+    type: string;
+    options: Array<{
+        id: string;
+        label: string;
+    }>;
+}
+interface DebugUsage$1 {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cachedTokens?: number;
+    cost?: number;
+}
+interface StreamToolPayload {
+    callId?: string;
+    name: string;
+    arguments?: string;
+    result?: string;
+    error?: string;
+    durationMs?: number;
+}
+interface DebugTrace$1 {
+    generationMs?: number;
+    usage?: DebugUsage$1;
+    tools: StreamToolPayload[];
+}
+interface DebugLimits {
+    policyMaxTokens: number;
+    modelMaxTokens: number;
+    effectiveMaxTokens: number;
+    completionReserveTokens: number;
+}
+interface SessionDebugUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    turnsWithUsage: number;
+    latestPromptTokens: number;
+    latestCompletionTokens: number;
+    latestTotalTokens: number;
+}
+interface SendMessageOptions {
+    debugMode?: boolean;
+    replaceFromMessageID?: string;
+}
+interface SessionListResult$1 {
+    sessions: Session$1[];
+    total: number;
+    hasMore: boolean;
+}
+interface SessionUser {
+    id: string;
+    firstName: string;
+    lastName: string;
+    initials: string;
+}
+interface SessionGroup {
+    name: string;
+    sessions: Session$1[];
 }
 interface ChatDataSource {
-    createSession(): Promise<Session>;
+    createSession(): Promise<Session$1>;
     fetchSession(id: string): Promise<{
-        session: Session;
-        messages: Message[];
-        pendingQuestion?: PendingQuestion | null;
+        session: Session$1;
+        turns: ConversationTurn$1[];
+        pendingQuestion?: PendingQuestion$1 | null;
     } | null>;
-    sendMessage(sessionId: string, content: string, attachments?: Attachment[], signal?: AbortSignal): AsyncGenerator<StreamChunk>;
+    fetchSessionArtifacts?(sessionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        artifacts: SessionArtifact[];
+        hasMore?: boolean;
+        nextOffset?: number;
+    }>;
+    uploadSessionArtifacts?(sessionId: string, files: File[]): Promise<{
+        artifacts: SessionArtifact[];
+    }>;
+    renameSessionArtifact?(artifactId: string, name: string, description?: string): Promise<SessionArtifact>;
+    deleteSessionArtifact?(artifactId: string): Promise<void>;
+    sendMessage(sessionId: string, content: string, attachments?: Attachment$1[], signal?: AbortSignal, options?: SendMessageOptions): AsyncGenerator<StreamChunk>;
+    clearSessionHistory(sessionId: string): Promise<{
+        success: boolean;
+        deletedMessages: number;
+        deletedArtifacts: number;
+    }>;
+    compactSessionHistory(sessionId: string): Promise<{
+        success: boolean;
+        summary: string;
+        deletedMessages: number;
+        deletedArtifacts: number;
+    }>;
     submitQuestionAnswers(sessionId: string, questionId: string, answers: QuestionAnswers): Promise<{
         success: boolean;
         error?: string;
     }>;
-    cancelPendingQuestion(questionId: string): Promise<{
+    rejectPendingQuestion(sessionId: string): Promise<{
         success: boolean;
         error?: string;
     }>;
     navigateToSession?(sessionId: string): void;
+    listSessions(options?: {
+        limit?: number;
+        offset?: number;
+        includeArchived?: boolean;
+    }): Promise<SessionListResult$1>;
+    archiveSession(sessionId: string): Promise<Session$1>;
+    unarchiveSession(sessionId: string): Promise<Session$1>;
+    pinSession(sessionId: string): Promise<Session$1>;
+    unpinSession(sessionId: string): Promise<Session$1>;
+    deleteSession(sessionId: string): Promise<void>;
+    renameSession(sessionId: string, title: string): Promise<Session$1>;
+    regenerateSessionTitle(sessionId: string): Promise<Session$1>;
+    listUsers?(): Promise<SessionUser[]>;
+    listAllSessions?(options?: {
+        limit?: number;
+        offset?: number;
+        includeArchived?: boolean;
+        userId?: string | null;
+    }): Promise<{
+        sessions: Array<Session$1 & {
+            owner: SessionUser;
+        }>;
+        total: number;
+        hasMore: boolean;
+    }>;
 }
-interface ChatSessionContextValue {
-    message: string;
-    messages: Message[];
-    loading: boolean;
-    error: string | null;
+interface ChatSessionStateValue {
+    session: Session$1 | null;
     currentSessionId?: string;
-    pendingQuestion: PendingQuestion | null;
-    session: Session | null;
     fetching: boolean;
+    error: string | null;
+    debugMode: boolean;
+    sessionDebugUsage: SessionDebugUsage;
+    debugLimits: DebugLimits | null;
+    setError: (error: string | null) => void;
+}
+interface ChatMessagingStateValue {
+    turns: ConversationTurn$1[];
     streamingContent: string;
     isStreaming: boolean;
-    messageQueue: QueuedMessage[];
-    codeOutputs: CodeOutput[];
-    setMessage: (message: string) => void;
-    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>;
+    loading: boolean;
+    pendingQuestion: PendingQuestion$1 | null;
+    codeOutputs: CodeOutput$1[];
+    isCompacting: boolean;
+    compactionSummary: string | null;
+    /** Bumped when artifacts should be refetched (e.g. tool_end for artifact-producing tools). */
+    artifactsInvalidationTrigger: number;
+    sendMessage: (content: string, attachments?: Attachment$1[]) => 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>;
+    handleRejectPendingQuestion: () => Promise<void>;
+    cancel: () => void;
+    setCodeOutputs: (outputs: CodeOutput$1[]) => void;
+}
+interface ChatInputStateValue {
+    message: string;
+    inputError: string | null;
+    messageQueue: QueuedMessage[];
+    setMessage: (message: string) => void;
+    setInputError: (error: string | null) => void;
+    handleSubmit: (e: React.FormEvent, attachments?: Attachment$1[]) => void;
     handleUnqueue: () => {
         content: string;
-        attachments: ImageAttachment[];
+        attachments: Attachment$1[];
     } | null;
-    sendMessage: (content: string, attachments?: Attachment[]) => Promise<void>;
-    cancel: () => void;
+}
+interface ChatSessionContextValue extends ChatSessionStateValue, ChatMessagingStateValue, ChatInputStateValue {
+    handleRetry?: () => Promise<void>;
+}
+
+/**
+ * Per-session rate limiter
+ * Prevents excessive requests within a time window
+ */
+interface RateLimiterConfig {
+    maxRequests: number;
+    windowMs: number;
+}
+declare class RateLimiter {
+    private timestamps;
+    private maxRequests;
+    private windowMs;
+    constructor(config: RateLimiterConfig);
+    /**
+     * Check if a request can be made
+     * Updates internal state if request is allowed
+     */
+    canMakeRequest(): boolean;
+    /**
+     * Get milliseconds until next request is allowed
+     * Returns 0 if request can be made immediately
+     */
+    getTimeUntilNextRequest(): number;
+    /**
+     * Reset the rate limiter state
+     */
+    reset(): void;
 }
 
 interface ChatSessionProps {
     dataSource: ChatDataSource;
     sessionId?: string;
+    /** Optional rate limiter to throttle sendMessage */
+    rateLimiter?: RateLimiter;
+    /** Alias for isReadOnly (preferred) */
+    readOnly?: boolean;
     isReadOnly?: boolean;
-    renderUserMessage?: (message: Message) => ReactNode;
-    renderAssistantMessage?: (message: Message) => ReactNode;
+    /** Custom render function for user turns */
+    renderUserTurn?: (turn: ConversationTurn$1) => ReactNode;
+    /** Custom render function for assistant turns */
+    renderAssistantTurn?: (turn: ConversationTurn$1) => ReactNode;
     className?: string;
     /** Custom content to display as header */
     headerSlot?: ReactNode;
@@ -159,72 +447,386 @@ interface ChatSessionProps {
     actionsSlot?: ReactNode;
     /** Callback when user navigates back */
     onBack?: () => void;
+    /** Custom verbs for the typing indicator (e.g. ['Thinking', 'Analyzing', ...]) */
+    thinkingVerbs?: string[];
+    /** Enables the built-in right-side artifacts panel for persisted session artifacts */
+    showArtifactsPanel?: boolean;
+    /** Initial expanded state for artifacts panel when no persisted preference exists */
+    artifactsPanelDefaultExpanded?: boolean;
+    /** localStorage key for artifacts panel expanded/collapsed state */
+    artifactsPanelStorageKey?: string;
 }
 declare function ChatSession(props: ChatSessionProps): react_jsx_runtime.JSX.Element;
 
+interface SessionArtifactsPanelProps {
+    dataSource: ChatDataSource;
+    sessionId: string;
+    isStreaming: boolean;
+    allowDrop?: boolean;
+    className?: string;
+}
+declare function SessionArtifactsPanel({ dataSource, sessionId, isStreaming, allowDrop, className, }: SessionArtifactsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface SessionArtifactListProps {
+    artifacts: SessionArtifact[];
+    selectedArtifactId?: string;
+    onSelect: (artifact: SessionArtifact) => void;
+}
+declare function SessionArtifactList({ artifacts, selectedArtifactId, onSelect, }: SessionArtifactListProps): react_jsx_runtime.JSX.Element;
+
+interface SessionArtifactPreviewProps {
+    artifact: SessionArtifact;
+}
+declare function SessionArtifactPreview({ artifact }: SessionArtifactPreviewProps): react_jsx_runtime.JSX.Element;
+
 interface ChatHeaderProps {
-    session: Session | null;
+    session: Session$1 | null;
     onBack?: () => void;
+    readOnly?: boolean;
     /** Custom logo component to display */
     logoSlot?: ReactNode;
     /** Custom action buttons */
     actionsSlot?: ReactNode;
 }
-declare function ChatHeader({ session, onBack, logoSlot, actionsSlot }: ChatHeaderProps): react_jsx_runtime.JSX.Element;
+declare function ChatHeader({ session, onBack, readOnly, 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$1) => ReactNode;
+    /** Custom render function for assistant turns */
+    renderAssistantTurn?: (turn: ConversationTurn$1) => ReactNode;
+    /** Custom verbs for the typing indicator (e.g. ['Thinking', 'Analyzing', ...]) */
+    thinkingVerbs?: string[];
+    /** When true, hides edit/regenerate actions */
+    readOnly?: boolean;
 }
-declare function MessageList({ renderUserMessage, renderAssistantMessage }: MessageListProps): react_jsx_runtime.JSX.Element;
+declare function MessageList({ renderUserTurn, renderAssistantTurn, thinkingVerbs, readOnly }: 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 {
+    /** Message attachments */
+    attachments: Attachment$1[];
+    /** Handler to open image viewer */
+    onView: (index: number) => void;
 }
-declare function TurnBubble({ message, renderUserMessage, renderAssistantMessage, }: TurnBubbleProps): react_jsx_runtime.JSX.Element | null;
+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$1;
+    /** 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;
+    /** Whether edit action should be available */
+    allowEdit?: boolean;
+}
+declare function UserMessage({ turn, turnId, initials, slots, classNames: classNameOverrides, onCopy, onEdit, hideAvatar, hideActions, hideTimestamp, allowEdit, }: UserMessageProps): react_jsx_runtime.JSX.Element;
 
 interface UserTurnViewProps {
-    message: Message & {
-        attachments?: ImageAttachment[];
-    };
+    /** The conversation turn containing the user message */
+    turn: ConversationTurn$1;
+    /** 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;
+    /** Whether edit action should be available */
+    allowEdit?: boolean;
+}
+declare function UserTurnView({ turn, slots, classNames, initials, hideAvatar, hideActions, hideTimestamp, allowEdit, }: UserTurnViewProps): react_jsx_runtime.JSX.Element;
+
+interface AssistantMessageAvatarSlotProps {
+    /** Default text */
+    text: string;
+}
+interface AssistantMessageContentSlotProps {
+    /** Message content (markdown) */
+    content: string;
+    /** Citations */
+    citations?: Citation$1[];
+    /** Whether streaming is active */
+    isStreaming: boolean;
+}
+interface AssistantMessageSourcesSlotProps {
+    /** Citations to display */
+    citations: Citation$1[];
+}
+interface AssistantMessageChartsSlotProps {
+    /** Chart data */
+    chartData: ChartData;
+}
+interface AssistantMessageCodeOutputsSlotProps {
+    /** Code execution outputs */
+    outputs: CodeOutput$1[];
 }
-declare function UserTurnView({ message }: UserTurnViewProps): react_jsx_runtime.JSX.Element;
+interface AssistantMessageArtifactsSlotProps {
+    /** Downloadable artifacts */
+    artifacts: Artifact$1[];
+}
+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$1;
+    /** Turn ID for regenerate operations */
+    turnId?: string;
+    /** When true, this is the last turn (Regenerate button shown only on last assistant message) */
+    isLastTurn?: boolean;
+    /** Whether response is being streamed */
+    isStreaming?: boolean;
+    /** Pending question for HITL */
+    pendingQuestion?: PendingQuestion$1 | 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;
+    /** Show debug panel */
+    showDebug?: boolean;
+}
+declare function AssistantMessage({ turn, turnId, isLastTurn, isStreaming, pendingQuestion, slots, classNames: classNameOverrides, onCopy, onRegenerate, onSendMessage, sendDisabled, hideAvatar, hideActions, hideTimestamp, showDebug, }: AssistantMessageProps): react_jsx_runtime.JSX.Element;
 
 interface AssistantTurnViewProps {
-    message: Message & {
-        codeOutputs?: CodeOutput[];
-        isStreaming?: boolean;
-    };
+    /** The conversation turn containing the assistant response */
+    turn: ConversationTurn$1;
+    /** When true, this is the last turn in the list (Regenerate button shown only on last assistant message) */
+    isLastTurn?: boolean;
+    /** 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({ message }: AssistantTurnViewProps): react_jsx_runtime.JSX.Element;
+declare function AssistantTurnView({ turn, isLastTurn, 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$1;
+    /** When true, this turn is the last in the list (e.g. Regenerate shows only on last assistant message) */
+    isLastTurn?: boolean;
+    /** Custom render function for user turn (full control) */
+    renderUserTurn?: (turn: ConversationTurn$1) => ReactNode;
+    /** Custom render function for assistant turn (full control) */
+    renderAssistantTurn?: (turn: ConversationTurn$1) => 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 TurnBubble({ turn, isLastTurn, renderUserTurn, renderAssistantTurn, userTurnProps, assistantTurnProps, userMessageSlots, assistantMessageSlots, userMessageClassNames, assistantMessageClassNames, classNames, isStreaming, }: TurnBubbleProps): react_jsx_runtime.JSX.Element;
 
 interface MarkdownRendererProps {
+    /** Markdown content to render */
     content: string;
-    citations?: Citation[] | null;
+    /** Optional citations to process and display */
+    citations?: Citation$1[] | 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.
+ */
 declare function ChartCard({ chartData }: ChartCardProps): react_jsx_runtime.JSX.Element;
 
 interface SourcesPanelProps {
-    citations: Citation[];
+    citations: Citation$1[];
 }
 declare function SourcesPanel({ citations }: SourcesPanelProps): react_jsx_runtime.JSX.Element | null;
 
 interface DownloadCardProps {
-    artifact: Artifact;
+    artifact: Artifact$1;
 }
 declare function DownloadCard({ artifact }: DownloadCardProps): react_jsx_runtime.JSX.Element;
 
 interface InlineQuestionFormProps {
-    pendingQuestion: PendingQuestion;
+    pendingQuestion: PendingQuestion$1;
 }
-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;
@@ -235,34 +837,51 @@ interface MessageInputProps {
     loading: boolean;
     fetching?: boolean;
     disabled?: boolean;
+    commandError?: string | null;
+    debugMode?: boolean;
+    debugSessionUsage?: SessionDebugUsage;
+    debugLimits?: DebugLimits | null;
     messageQueue?: QueuedMessage[];
+    onClearCommandError?: () => void;
     onMessageChange: (value: string) => void;
-    onSubmit: (e: React.FormEvent, attachments: ImageAttachment[]) => void;
+    onSubmit: (e: React.FormEvent, attachments: Attachment$1[]) => void;
     onUnqueue?: () => {
         content: string;
-        attachments: ImageAttachment[];
+        attachments: Attachment$1[];
     } | null;
     placeholder?: string;
     maxFiles?: number;
     maxFileSize?: number;
     containerClassName?: string;
+    formClassName?: string;
 }
 declare const MessageInput: react.ForwardRefExoticComponent<MessageInputProps & react.RefAttributes<MessageInputRef>>;
 
 interface AttachmentGridProps {
-    attachments: ImageAttachment[];
+    attachments: Attachment$1[];
     onRemove?: (index: number) => void;
     onView?: (index: number) => void;
     className?: string;
+    readonly?: boolean;
+    maxDisplay?: number;
+    maxCapacity?: number;
+    emptyMessage?: string;
+    showCount?: boolean;
+    /** Number of files currently being processed (shows shimmer placeholders) */
+    pendingCount?: number;
 }
-declare function AttachmentGrid({ attachments, onRemove, onView, className }: AttachmentGridProps): react_jsx_runtime.JSX.Element | null;
+declare function AttachmentGrid({ attachments, onRemove, onView, className, readonly, maxDisplay, maxCapacity, emptyMessage, showCount, pendingCount, }: AttachmentGridProps): react_jsx_runtime.JSX.Element | null;
+declare const MemoizedAttachmentGrid: react__default.MemoExoticComponent<typeof AttachmentGrid>;
 
 interface ImageModalProps {
-    images: ImageAttachment[];
-    initialIndex: number;
+    isOpen: boolean;
     onClose: () => void;
+    attachment: ImageAttachment;
+    allAttachments?: ImageAttachment[];
+    currentIndex?: number;
+    onNavigate?: (direction: 'prev' | 'next') => void;
 }
-declare function ImageModal({ images, initialIndex, onClose }: ImageModalProps): react_jsx_runtime.JSX.Element;
+declare function ImageModal({ isOpen, onClose, attachment, allAttachments, currentIndex, onNavigate, }: ImageModalProps): react_jsx_runtime.JSX.Element;
 
 /**
  * WelcomeContent Component
@@ -278,7 +897,7 @@ interface WelcomeContentProps {
 declare function WelcomeContent({ onPromptSelect, title, description, disabled }: WelcomeContentProps): react_jsx_runtime.JSX.Element;
 
 interface CodeOutputsPanelProps {
-    outputs: CodeOutput[];
+    outputs: CodeOutput$1[];
 }
 declare function CodeOutputsPanel({ outputs }: CodeOutputsPanelProps): react_jsx_runtime.JSX.Element | null;
 
@@ -296,8 +915,17 @@ interface ScrollToBottomButtonProps {
     show: boolean;
     onClick: () => void;
     unreadCount?: number;
+    disabled?: boolean;
+    /** When set, renders a pill-style button with this label (e.g. "New messages") */
+    label?: string;
+}
+declare function ScrollToBottomButton({ show, onClick, unreadCount, disabled, label, }: ScrollToBottomButtonProps): react_jsx_runtime.JSX.Element;
+
+interface CompactionDoodleProps {
+    title: string;
+    subtitle: string;
 }
-declare function ScrollToBottomButton({ show, onClick, unreadCount }: ScrollToBottomButtonProps): react_jsx_runtime.JSX.Element;
+declare function CompactionDoodle({ title, subtitle }: CompactionDoodleProps): react_jsx_runtime.JSX.Element;
 
 interface EmptyStateProps {
     /** Optional icon to display */
@@ -314,7 +942,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 +974,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 +1003,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,50 +1064,1146 @@ 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>;
 
 /**
- * Framer Motion animation variants for BiChat UI
- * Subtle, professional animations for enterprise applications
- * Respects prefers-reduced-motion for accessibility
+ * 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>;
+
 /**
- * Fade in animation
+ * LoadingSpinner Component
+ * Displays animated loading indicators
  */
-declare const fadeInVariants: {
-    initial: {
-        opacity: number;
-    };
-    animate: {
-        opacity: number;
-        transition: {
-            duration: number;
-        };
-    };
-    exit: {
-        opacity: number;
-        transition: {
-            duration: number;
-        };
-    };
-};
+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>;
+
 /**
- * Fade in with subtle slide up
+ * TableExportButton Component
+ * Small inline button for exporting markdown tables to Excel
  */
-declare const fadeInUpVariants: {
-    initial: {
-        opacity: number;
-        y: number;
-    };
-    animate: {
-        opacity: number;
-        y: number;
-        transition: {
-            duration: number;
-            ease: number[];
-        };
-    };
-    exit: {
+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
+ * Polished confirmation dialog with contextual icon, refined typography,
+ * and smooth micro-interactions.
+ * Uses @headlessui/react Dialog for accessible modal behavior.
+ */
+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;
+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 rotating verbs with shimmer animation to show AI is thinking/processing.
+ * Verbs are configurable via props.
+ */
+interface TypingIndicatorProps {
+    /** Custom thinking verbs to rotate through */
+    verbs?: string[];
+    /** Verb rotation interval in ms (defaults to 3000) */
+    rotationInterval?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare function TypingIndicator({ verbs, rotationInterval, className, }: TypingIndicatorProps): react_jsx_runtime.JSX.Element;
+declare const MemoizedTypingIndicator: react.MemoExoticComponent<typeof TypingIndicator>;
+
+interface SidebarProps {
+    dataSource: ChatDataSource;
+    onSessionSelect: (sessionId: string) => void;
+    onNewChat: () => void;
+    onArchivedView?: () => void;
+    activeSessionId?: string;
+    creating?: boolean;
+    showAllChatsTab?: boolean;
+    isOpen?: boolean;
+    onClose?: () => void;
+    headerSlot?: react__default.ReactNode;
+    footerSlot?: react__default.ReactNode;
+    className?: string;
+}
+declare function Sidebar({ dataSource, onSessionSelect, onNewChat, onArchivedView, activeSessionId, creating, showAllChatsTab, isOpen: _isOpen, onClose, headerSlot, footerSlot, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * SessionItem Component
+ * Individual chat session item in the sidebar with actions menu
+ * Router-agnostic: uses onSelect callback instead of Link
+ */
+
+interface SessionItemProps {
+    session: Session$1;
+    isActive: boolean;
+    mode?: 'active' | 'archived';
+    onSelect: (sessionId: string) => void;
+    onArchive?: () => void;
+    onRestore?: () => void;
+    onPin?: () => void;
+    onRename?: (newTitle: string) => void;
+    onRegenerateTitle?: () => void;
+    onDelete?: () => void;
+    testIdPrefix?: string;
+    className?: string;
+}
+declare const SessionItem: react__default.NamedExoticComponent<SessionItemProps>;
+
+interface ArchivedChatListProps {
+    dataSource: ChatDataSource;
+    onBack: () => void;
+    onSessionSelect: (sessionId: string) => void;
+    activeSessionId?: string;
+    className?: string;
+    toast?: UseToastReturn;
+}
+declare function ArchivedChatList({ dataSource, onBack, onSessionSelect, activeSessionId, className, toast: toastFromProps, }: ArchivedChatListProps): react_jsx_runtime.JSX.Element;
+
+interface AllChatsListProps {
+    dataSource: ChatDataSource;
+    onSessionSelect: (sessionId: string) => void;
+    activeSessionId?: string;
+}
+declare function AllChatsList({ dataSource, onSessionSelect, activeSessionId }: AllChatsListProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * TabBar Component
+ * Horizontal tabs with animated indicator for switching between views
+ * Generic: accepts any set of tabs via props
+ */
+interface TabBarProps {
+    tabs: Array<{
+        id: string;
+        label: string;
+    }>;
+    activeTab: string;
+    onTabChange: (tabId: string) => void;
+}
+declare function TabBar({ tabs, activeTab, onTabChange }: TabBarProps): react_jsx_runtime.JSX.Element | null;
+declare const MemoizedTabBar: react.MemoExoticComponent<typeof TabBar>;
+
+interface UserFilterProps {
+    users: SessionUser[];
+    selectedUser: SessionUser | null;
+    onUserChange: (user: SessionUser | null) => void;
+    loading?: boolean;
+}
+declare function UserFilter({ users, selectedUser, onUserChange, loading }: UserFilterProps): react_jsx_runtime.JSX.Element;
+declare const MemoizedUserFilter: react.MemoExoticComponent<typeof UserFilter>;
+
+interface DateGroupHeaderProps {
+    groupName: string;
+    count: number;
+}
+/**
+ * Sticky header for date-based session groups
+ * Displays group name and session count
+ */
+declare function DateGroupHeader({ groupName, count }: DateGroupHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface SessionSkeletonProps {
+    count?: number;
+}
+declare function SessionSkeleton({ count }: SessionSkeletonProps): react_jsx_runtime.JSX.Element;
+
+interface SystemMessageProps {
+    content: string;
+    createdAt: string;
+    onCopy?: (content: string) => Promise<void> | void;
+    hideActions?: boolean;
+    hideTimestamp?: boolean;
+}
+declare function SystemMessage({ content, createdAt, onCopy, hideActions, hideTimestamp, }: SystemMessageProps): react_jsx_runtime.JSX.Element;
+
+interface DebugPanelProps {
+    trace?: DebugTrace$1;
+}
+declare function DebugPanel({ trace }: DebugPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Alert Component
+ * Standardized error/success/warning/info messages with retry capability
+ */
+type AlertVariant = 'error' | 'success' | 'warning' | 'info';
+interface AlertProps {
+    variant?: AlertVariant;
+    message: string;
+    title?: string;
+    onDismiss?: () => void;
+    onRetry?: () => void;
+    show?: boolean;
+    dismissible?: boolean;
+}
+declare function Alert({ variant, message, title, onDismiss, onRetry, show, dismissible, }: AlertProps): react_jsx_runtime.JSX.Element;
+declare const _default$1: react.MemoExoticComponent<typeof Alert>;
+
+/**
+ * Archive Banner Component
+ * Displays when a chat session is archived and provides a restore button
+ */
+interface ArchiveBannerProps {
+    show?: boolean;
+    onRestore?: () => Promise<void>;
+    restoring?: boolean;
+    onRestoreComplete?: () => void;
+}
+declare function ArchiveBanner({ show, onRestore, restoring, onRestoreComplete, }: ArchiveBannerProps): react_jsx_runtime.JSX.Element;
+declare const _default: react.MemoExoticComponent<typeof ArchiveBanner>;
+
+/**
+ * RetryActionArea Component
+ * Displays a retry action area inline where the assistant message would appear
+ * (typically after an interrupted request or connection loss)
+ *
+ * Styled to match assistant message positioning (left-aligned) so users see
+ * the retry button contextually in the conversation flow.
+ */
+interface RetryActionAreaProps {
+    /** Callback when retry button is clicked */
+    onRetry: () => void;
+}
+declare const RetryActionArea: react.NamedExoticComponent<RetryActionAreaProps>;
+
+/**
+ * StreamError Component
+ * Error recovery UI for streaming failures
+ */
+interface StreamErrorProps {
+    /** Error message to display */
+    error: string;
+    /** Callback to retry the failed operation */
+    onRetry?: () => void;
+    /** Callback to regenerate the message */
+    onRegenerate?: () => void;
+    /** Whether to show compact mode (less padding) */
+    compact?: boolean;
+}
+declare function StreamError({ error, onRetry, onRegenerate, compact, }: StreamErrorProps): react_jsx_runtime.JSX.Element;
+
+interface ActionableMessage {
+    id: string;
+    role: MessageRole;
+    content: string;
+}
+interface MessageActionsProps {
+    message: ActionableMessage;
+    onCopy: (text: string) => Promise<void>;
+    onRegenerate?: (messageId: string) => Promise<void>;
+    onEdit?: (message: ActionableMessage) => void;
+}
+declare function MessageActions({ message, onCopy, onRegenerate, onEdit, }: MessageActionsProps): react_jsx_runtime.JSX.Element;
+
+interface AttachmentPreviewProps {
+    /** The attachment to display */
+    attachment: ImageAttachment;
+    /** Optional callback when remove button is clicked */
+    onRemove?: () => void;
+    /** Optional callback when thumbnail is clicked (for enlargement) */
+    onClick?: () => void;
+    /** If true, hide remove button and disable click interactions */
+    readonly?: boolean;
+}
+declare const AttachmentPreview: react.NamedExoticComponent<AttachmentPreviewProps>;
+
+interface AttachmentUploadProps {
+    /** Callback fired when files are successfully converted and validated */
+    onAttachmentsSelected: (attachments: Attachment$1[]) => void;
+    /** Maximum number of attachments allowed (default: 10) */
+    maxAttachments?: number;
+    /** Maximum file size in bytes (default: 20 MB) */
+    maxSizeBytes?: number;
+    /** Whether the component is disabled */
+    disabled?: boolean;
+}
+declare const AttachmentUpload: react.NamedExoticComponent<AttachmentUploadProps>;
+
+interface ScreenReaderAnnouncerProps {
+    message: string;
+    politeness?: 'polite' | 'assertive';
+    clearAfter?: number;
+}
+/**
+ * Screen reader announcer component for live region updates
+ * Uses ARIA live regions to announce dynamic content changes
+ *
+ * @param message - The message to announce
+ * @param politeness - 'polite' (wait for pause) or 'assertive' (immediate)
+ * @param clearAfter - Optional milliseconds to clear message after announcement
+ *
+ * @example
+ * <ScreenReaderAnnouncer
+ *   message="New message received"
+ *   politeness="polite"
+ * />
+ */
+declare function ScreenReaderAnnouncer({ message, politeness, clearAfter, }: ScreenReaderAnnouncerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Skip to main content link for keyboard navigation
+ * Hidden by default, visible on keyboard focus
+ * Allows users to skip navigation and go directly to main content
+ */
+declare function SkipLink(): react_jsx_runtime.JSX.Element;
+
+interface ContextMenuItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    onClick: () => void;
+    variant?: 'default' | 'danger';
+    disabled?: boolean;
+}
+interface TouchContextMenuProps {
+    items: ContextMenuItem[];
+    isOpen: boolean;
+    onClose: () => void;
+    anchorRect: DOMRect | null;
+}
+declare const TouchContextMenu: FC<TouchContextMenuProps>;
+
+interface QuestionFormProps {
+    pendingQuestion: PendingQuestion$1;
+    sessionId: string;
+    onSubmit: (answers: QuestionAnswers) => Promise<void>;
+    onCancel: () => void;
+}
+declare function QuestionForm({ pendingQuestion, onSubmit, onCancel, }: QuestionFormProps): react_jsx_runtime.JSX.Element;
+
+interface QuestionStepProps {
+    question: Question;
+    selectedAnswers: QuestionAnswers;
+    onAnswer: (answerData: QuestionAnswerData) => void;
+}
+declare function QuestionStep({ question, selectedAnswers, onAnswer, }: QuestionStepProps): react_jsx_runtime.JSX.Element;
+
+interface ConfirmationStepProps {
+    questions: Question[];
+    answers: QuestionAnswers;
+}
+declare function ConfirmationStep({ questions, answers, }: ConfirmationStepProps): react_jsx_runtime.JSX.Element;
+
+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: 20MB) */
+    maxFileSize?: number;
+    /** Allowed MIME types (default: attachment allowlist) */
+    allowedTypes?: string[];
+    /** Custom validation function */
+    validate?: (file: File) => string | null;
+    /** Callback when files are added */
+    onAdd?: (files: Attachment$1[]) => void;
+    /** Callback when a file is removed */
+    onRemove?: (file: Attachment$1) => void;
+    /** Callback when validation fails */
+    onError?: (errors: FileValidationError[]) => void;
+}
+interface UseAttachmentsReturn {
+    /** Current attachments */
+    files: Attachment$1[];
+    /** 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$1 | string) => void;
+    /** Clear all files */
+    clear: () => void;
+    /** Clear errors */
+    clearErrors: () => void;
+    /** Set files directly (for controlled mode) */
+    setFiles: (files: Attachment$1[]) => 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;
+
+/**
+ * useScrollToBottom Hook
+ * Manages scroll-to-bottom functionality with smart auto-scroll
+ * Only scrolls if user is near the bottom (within threshold)
+ */
+interface UseScrollToBottomReturn {
+    /**
+     * Ref to attach to the messages container
+     */
+    containerRef: React.RefObject<HTMLDivElement>;
+    /**
+     * Whether to show the scroll-to-bottom button
+     */
+    showScrollButton: boolean;
+    /**
+     * Function to scroll to bottom
+     */
+    scrollToBottom: () => void;
+}
+/**
+ * Hook for managing scroll-to-bottom behavior
+ * Automatically scrolls if user is near the bottom
+ * Shows button only when scrolled up significantly
+ */
+declare function useScrollToBottom(items: unknown[]): UseScrollToBottomReturn;
+
+interface ShortcutConfig {
+    key: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    callback: () => void;
+    preventDefault?: boolean;
+    description?: string;
+}
+/**
+ * Hook for managing global keyboard shortcuts
+ * Automatically handles modifier keys and input field exclusion
+ *
+ * @param shortcuts - Array of keyboard shortcut configurations
+ *
+ * @example
+ * useKeyboardShortcuts([
+ *   { key: 'k', ctrl: true, callback: () => focusSearch(), description: 'Focus search' },
+ *   { key: '?', callback: () => setShowHelp(true), description: 'Show keyboard shortcuts' },
+ * ])
+ */
+declare function useKeyboardShortcuts(shortcuts: ShortcutConfig[]): void;
+
+interface LongPressOptions {
+    delay?: number;
+    onLongPress: (e: React.TouchEvent | React.MouseEvent) => void;
+    onPressStart?: () => void;
+    onPressCancel?: () => void;
+    moveThreshold?: number;
+    hapticFeedback?: boolean;
+}
+interface LongPressEventHandlers {
+    onTouchStart: (e: React.TouchEvent) => void;
+    onTouchEnd: (e: React.TouchEvent) => void;
+    onTouchMove: (e: React.TouchEvent) => void;
+    onMouseDown?: (e: React.MouseEvent) => void;
+    onMouseUp?: (e: React.MouseEvent) => void;
+    onMouseLeave?: (e: React.MouseEvent) => void;
+}
+interface LongPressResult {
+    handlers: LongPressEventHandlers;
+    isPressed: boolean;
+}
+declare function useLongPress(options: LongPressOptions): LongPressResult;
+
+/**
+ * Framer Motion animation variants for BiChat UI
+ * Subtle, professional animations for enterprise applications
+ * Respects prefers-reduced-motion for accessibility
+ */
+/**
+ * Fade in animation
+ */
+declare const fadeInVariants: {
+    initial: {
+        opacity: number;
+    };
+    animate: {
+        opacity: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Fade in with subtle slide up
+ */
+declare const fadeInUpVariants: {
+    initial: {
+        opacity: number;
+        y: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+    exit: {
         opacity: number;
         y: number;
         transition: {
@@ -630,6 +2354,31 @@ declare const typingDotVariants: {
         };
     };
 };
+/**
+ * Verb transition for typing indicator
+ * Smooth slide-up animation for rotating text
+ */
+declare const verbTransitionVariants: {
+    initial: {
+        y: number;
+        opacity: number;
+    };
+    animate: {
+        y: number;
+        opacity: number;
+        transition: {
+            duration: number;
+            ease: string;
+        };
+    };
+    exit: {
+        y: number;
+        opacity: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
 /**
  * Floating button (scroll to bottom, etc.)
  */
@@ -699,35 +2448,62 @@ declare const toastVariants: {
         };
     };
 };
-
 /**
- * Per-session rate limiter
- * Prevents excessive requests within a time window
+ * Session item with subtle slide-right on hover
  */
-interface RateLimiterConfig {
-    maxRequests: number;
-    windowMs: number;
-}
-declare class RateLimiter {
-    private timestamps;
-    private maxRequests;
-    private windowMs;
-    constructor(config: RateLimiterConfig);
-    /**
-     * Check if a request can be made
-     * Updates internal state if request is allowed
-     */
-    canMakeRequest(): boolean;
-    /**
-     * Get milliseconds until next request is allowed
-     * Returns 0 if request can be made immediately
-     */
-    getTimeUntilNextRequest(): number;
-    /**
-     * Reset the rate limiter state
-     */
-    reset(): void;
-}
+declare const sessionItemVariants: {
+    initial: {
+        opacity: number;
+        x: number;
+    };
+    animate: {
+        opacity: number;
+        x: number;
+        transition: {
+            duration: number;
+        };
+    };
+    hover: {
+        x: number;
+        transition: {
+            duration: number;
+        };
+    };
+    exit: {
+        opacity: number;
+        x: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
+/**
+ * Error/alert message slide-in
+ */
+declare const errorMessageVariants: {
+    initial: {
+        opacity: number;
+        y: number;
+        height: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        height: string;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+    exit: {
+        opacity: number;
+        y: number;
+        height: number;
+        transition: {
+            duration: number;
+        };
+    };
+};
 
 interface ChatSessionProviderProps {
     dataSource: ChatDataSource;
@@ -736,30 +2512,24 @@ interface ChatSessionProviderProps {
     children: ReactNode;
 }
 declare function ChatSessionProvider({ dataSource, sessionId, rateLimiter: externalRateLimiter, children }: ChatSessionProviderProps): react_jsx_runtime.JSX.Element;
+declare function useChatSession(): ChatSessionStateValue;
+declare function useChatMessaging(): ChatMessagingStateValue;
+declare function useChatInput(): ChatInputStateValue;
 declare function useChat(): ChatSessionContextValue;
 
 /**
- * Type definitions matching Go structs for server-side context
+ * BiChat context types layered on top of canonical applet-core context contracts.
  */
-interface UserContext {
-    id: number;
-    email: string;
-    firstName: string;
-    lastName: string;
-    permissions: string[];
-}
-interface TenantContext {
-    id: string;
-    name: string;
-}
-interface LocaleContext {
-    language: string;
-    translations: Record<string, string>;
-}
-interface AppConfig {
-    graphQLEndpoint: string;
+
+type UserContext = UserContext$1;
+type TenantContext = TenantContext$1;
+type LocaleContext = LocaleContext$1;
+type AppConfig = AppConfig$1 & {
     streamEndpoint: string;
-}
+    basePath: string;
+    assetsBasePath: string;
+    rpcUIEndpoint: string;
+};
 interface Extensions {
     branding?: {
         appName?: string;
@@ -794,14 +2564,23 @@ interface Extensions {
         codeInterpreter?: boolean;
         multiAgent?: boolean;
     };
+    llm?: {
+        provider?: string;
+        apiKeyConfigured?: boolean;
+    };
+    debug?: {
+        limits?: {
+            policyMaxTokens: number;
+            modelMaxTokens: number;
+            effectiveMaxTokens: number;
+            completionReserveTokens: number;
+        };
+    };
 }
-interface IotaContext {
-    user: UserContext;
-    tenant: TenantContext;
-    locale: LocaleContext;
+type IotaContext = Omit<InitialContext, 'config' | 'extensions'> & {
     config: AppConfig;
     extensions?: Extensions;
-}
+};
 declare global {
     interface Window {
         __BICHAT_CONTEXT__: IotaContext;
@@ -836,7 +2615,7 @@ interface BiChatConfig {
         translations: Record<string, string>;
     };
     endpoints: {
-        graphQL: string;
+        rpc: string;
         stream: string;
     };
     csrfToken?: string;
@@ -870,33 +2649,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
  */
@@ -980,21 +2732,23 @@ declare function createHeadersWithCSRF(init?: HeadersInit): Headers;
 
 /**
  * Built-in HTTP data source with SSE streaming and AbortController
- * Implements ChatDataSource interface with real HTTP/GraphQL calls
+ * Implements ChatDataSource interface with real HTTP/RPC calls
+ *
+ * Uses turn-based architecture - fetches ConversationTurns instead of flat messages.
  */
 
 interface HttpDataSourceConfig {
     baseUrl: string;
-    graphQLEndpoint?: string;
+    rpcEndpoint: string;
     streamEndpoint?: string;
     csrfToken?: string | (() => string);
     headers?: Record<string, string>;
     timeout?: number;
 }
 interface SessionState {
-    session: Session;
-    messages: Message[];
-    pendingQuestion?: PendingQuestion | null;
+    session: Session$1;
+    turns: ConversationTurn$1[];
+    pendingQuestion?: PendingQuestion$1 | null;
 }
 interface Result<T> {
     success: boolean;
@@ -1004,6 +2758,7 @@ interface Result<T> {
 declare class HttpDataSource implements ChatDataSource {
     private config;
     private abortController;
+    private rpc;
     constructor(config: HttpDataSourceConfig);
     /**
      * Get CSRF token from config
@@ -1013,57 +2768,380 @@ declare class HttpDataSource implements ChatDataSource {
      * Create headers for HTTP requests
      */
     private createHeaders;
-    /**
-     * Execute GraphQL query
-     */
-    private graphql;
+    private callRPC;
     /**
      * Create a new chat session
      */
-    createSession(): Promise<Session>;
+    createSession(): Promise<Session$1>;
     /**
-     * Fetch an existing session with messages
+     * Fetch an existing session with turns (turn-based architecture)
      */
     fetchSession(id: string): Promise<SessionState | null>;
+    fetchSessionArtifacts(sessionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        artifacts: SessionArtifact[];
+        hasMore?: boolean;
+        nextOffset?: number;
+    }>;
+    uploadSessionArtifacts(sessionId: string, files: File[]): Promise<{
+        artifacts: SessionArtifact[];
+    }>;
+    renameSessionArtifact(artifactId: string, name: string, description?: string): Promise<SessionArtifact>;
+    deleteSessionArtifact(artifactId: string): Promise<void>;
     /**
      * Send a message and stream the response using SSE
      */
-    sendMessage(sessionId: string, content: string, attachments?: Attachment[], signal?: AbortSignal): AsyncGenerator<StreamChunk>;
+    sendMessage(sessionId: string, content: string, attachments?: Attachment$1[], signal?: AbortSignal, options?: SendMessageOptions): AsyncGenerator<StreamChunk>;
     /**
      * Cancel ongoing stream
      */
     cancelStream(): void;
+    /**
+     * Clear session history in-place.
+     */
+    clearSessionHistory(sessionId: string): Promise<{
+        success: boolean;
+        deletedMessages: number;
+        deletedArtifacts: number;
+    }>;
+    /**
+     * Compact session history into summarized turn.
+     */
+    compactSessionHistory(sessionId: string): Promise<{
+        success: boolean;
+        summary: string;
+        deletedMessages: number;
+        deletedArtifacts: number;
+    }>;
     /**
      * Submit answers to a pending question
      */
     submitQuestionAnswers(sessionId: string, questionId: string, answers: QuestionAnswers): Promise<Result<void>>;
     /**
-     * Cancel a pending question
+     * Reject a pending question
      */
-    cancelPendingQuestion(questionId: string): Promise<Result<void>>;
+    rejectPendingQuestion(sessionId: string): Promise<Result<void>>;
     /**
      * Navigate to a session (optional, for SPA routing)
      */
     navigateToSession?(sessionId: string): void;
+    listSessions(options?: {
+        limit?: number;
+        offset?: number;
+        includeArchived?: boolean;
+    }): Promise<SessionListResult$1>;
+    archiveSession(sessionId: string): Promise<Session$1>;
+    unarchiveSession(sessionId: string): Promise<Session$1>;
+    pinSession(sessionId: string): Promise<Session$1>;
+    unpinSession(sessionId: string): Promise<Session$1>;
+    deleteSession(sessionId: string): Promise<void>;
+    renameSession(sessionId: string, title: string): Promise<Session$1>;
+    regenerateSessionTitle(sessionId: string): Promise<Session$1>;
 }
 /**
  * Factory function to create HttpDataSource
  */
 declare function createHttpDataSource(config: HttpDataSourceConfig): ChatDataSource;
 
+type BichatRPC = {
+    "bichat.artifact.delete": {
+        params: SessionIDParams;
+        result: OkResult;
+    };
+    "bichat.artifact.update": {
+        params: ArtifactUpdateParams;
+        result: ArtifactResult;
+    };
+    "bichat.ping": {
+        params: PingParams;
+        result: PingResult;
+    };
+    "bichat.question.reject": {
+        params: QuestionCancelParams;
+        result: SessionGetResult;
+    };
+    "bichat.question.submit": {
+        params: QuestionSubmitParams;
+        result: SessionGetResult;
+    };
+    "bichat.session.archive": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.artifacts": {
+        params: SessionArtifactsParams;
+        result: SessionArtifactsResult;
+    };
+    "bichat.session.clear": {
+        params: SessionIDParams;
+        result: SessionClearResult;
+    };
+    "bichat.session.compact": {
+        params: SessionIDParams;
+        result: SessionCompactResult;
+    };
+    "bichat.session.create": {
+        params: SessionCreateParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.delete": {
+        params: SessionIDParams;
+        result: OkResult;
+    };
+    "bichat.session.get": {
+        params: SessionGetParams;
+        result: SessionGetResult;
+    };
+    "bichat.session.list": {
+        params: SessionListParams;
+        result: SessionListResult;
+    };
+    "bichat.session.pin": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.regenerateTitle": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.unarchive": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.unpin": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.updateTitle": {
+        params: SessionUpdateTitleParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.uploadArtifacts": {
+        params: SessionUploadArtifactsParams;
+        result: SessionUploadArtifactsResult;
+    };
+};
+interface Artifact {
+    id: string;
+    sessionId: string;
+    messageId?: string;
+    type: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    url?: string;
+    sizeBytes: number;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+}
+interface ArtifactResult {
+    artifact: Artifact;
+}
+interface ArtifactUpdateParams {
+    id: string;
+    name: string;
+    description?: string;
+}
+interface AssistantTurn {
+    id: string;
+    role?: string;
+    content: string;
+    explanation?: string;
+    citations: Citation[];
+    toolCalls?: ToolCall[];
+    debug?: DebugTrace | null;
+    artifacts: unknown[];
+    codeOutputs: CodeOutput[];
+    createdAt: string;
+}
+interface Attachment {
+    id: string;
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    base64Data?: string;
+    url?: string;
+}
+interface Citation {
+    id: string;
+    type: string;
+    title: string;
+    url: string;
+    startIndex: number;
+    endIndex: number;
+    excerpt?: string;
+    source?: string;
+}
+interface CodeOutput {
+    type: string;
+    content: string;
+    filename?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+}
+interface ConversationTurn {
+    id: string;
+    sessionId: string;
+    userTurn: UserTurn;
+    assistantTurn?: AssistantTurn | null;
+    createdAt: string;
+}
+interface DebugToolCall {
+    callId?: string;
+    name?: string;
+    arguments?: string;
+    result?: string;
+    error?: string;
+    durationMs?: number;
+}
+interface DebugTrace {
+    usage?: DebugUsage | null;
+    generationMs?: number;
+    tools?: DebugToolCall[];
+}
+interface DebugUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cachedTokens: number;
+    cost: number;
+}
+interface OkResult {
+    ok: boolean;
+}
+interface PendingQuestion {
+    checkpointId: string;
+    agentName?: string;
+    turnId: string;
+    questions: PendingQuestionItem[];
+}
+interface PendingQuestionItem {
+    id: string;
+    text: string;
+    type: string;
+    options: PendingQuestionOption[];
+}
+interface PendingQuestionOption {
+    id: string;
+    label: string;
+}
+type PingParams = Record<string, never>;
+interface PingResult {
+    ok: boolean;
+    tenantId: string;
+}
+interface QuestionCancelParams {
+    sessionId: string;
+}
+interface QuestionSubmitParams {
+    sessionId: string;
+    checkpointId: string;
+    answers: Record<string, string>;
+}
+interface Session {
+    id: string;
+    title: string;
+    status: string;
+    pinned: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SessionArtifactsParams {
+    sessionId: string;
+    limit: number;
+    offset: number;
+}
+interface SessionArtifactsResult {
+    artifacts: Artifact[];
+    hasMore: boolean;
+    nextOffset: number;
+}
+interface SessionClearResult {
+    success: boolean;
+    deletedMessages: number;
+    deletedArtifacts: number;
+}
+interface SessionCompactResult {
+    success: boolean;
+    summary: string;
+    deletedMessages: number;
+    deletedArtifacts: number;
+}
+interface SessionCreateParams {
+    title: string;
+}
+interface SessionCreateResult {
+    session: Session;
+}
+interface SessionGetParams {
+    id: string;
+}
+interface SessionGetResult {
+    session: Session;
+    turns: ConversationTurn[];
+    pendingQuestion?: PendingQuestion | null;
+}
+interface SessionIDParams {
+    id: string;
+}
+interface SessionListParams {
+    limit: number;
+    offset: number;
+    includeArchived: boolean;
+}
+interface SessionListResult {
+    sessions: Session[];
+    total?: number;
+    hasMore: boolean;
+}
+interface SessionUpdateTitleParams {
+    id: string;
+    title: string;
+}
+interface SessionUploadArtifactsParams {
+    sessionId: string;
+    attachments: Attachment[];
+}
+interface SessionUploadArtifactsResult {
+    artifacts: Artifact[];
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+    result?: string;
+    error?: string;
+    durationMs?: number;
+}
+interface UserTurn {
+    id: string;
+    content: string;
+    attachments: Attachment[];
+    createdAt: string;
+}
+
 /**
  * File Utilities
  * Validation, conversion, and formatting for file attachments
  */
+declare const ATTACHMENT_ACCEPT_ATTRIBUTE: string;
+declare function isImageMimeType(mimeType: string): boolean;
 /**
- * Validates an image file against size and type constraints
+ * Validates a file against size and type constraints
  * @throws Error if validation fails
  */
-declare function validateImageFile(file: File, maxSizeBytes?: number): void;
+declare function validateAttachmentFile(file: File$1, maxSizeBytes?: number): void;
+/**
+ * Backward-compatible image validator used by older components/stories.
+ */
+declare function validateImageFile(file: File$1, maxSizeBytes?: number): void;
 /**
- * Converts a file to base64 string (without data URL prefix)
+ * Converts a file to base64 string (without data URL prefix).
+ * Prefers FileReader data URLs, then falls back to buffer-based encoding.
  */
-declare function convertToBase64(file: File): Promise<string>;
+declare function convertToBase64(file: File$1): Promise<string>;
 /**
  * Creates a data URL from base64 string and MIME type
  */
@@ -1078,4 +3156,133 @@ 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 };
+interface FileVisual {
+    /** Phosphor icon component */
+    icon: typeof File$1;
+    /** Tailwind text-color classes for the icon (light + dark) */
+    iconColor: string;
+    /** Tailwind background classes for the icon container (light + dark) */
+    bgColor: string;
+    /** Short label (PDF, CSV, XLS, etc.) */
+    label: string;
+}
+/**
+ * Resolves visual metadata (icon, colors, label) for a file based on
+ * its MIME type and/or filename. Single source of truth used by
+ * AttachmentGrid, SessionArtifactList, DownloadCard, etc.
+ */
+declare function getFileVisual(mimeType?: string, filename?: string): FileVisual;
+/** Chart-specific visual (not mime-based, used for artifact type = 'chart') */
+declare const CHART_VISUAL: FileVisual;
+
+/**
+ * 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$1 & {
+        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$1[] | null | undefined): ProcessedContent;
+
+/**
+ * Normalizes partially-streamed markdown so that react-markdown
+ * can render it without layout artifacts (e.g. an unclosed code fence
+ * turning the rest of the message into a code block).
+ *
+ * Called on every streaming content update — kept intentionally cheap (O(lines)).
+ */
+declare function normalizeStreamingMarkdown(text: string): string;
+
+/**
+ * SSE stream parser for consuming Server-Sent Events.
+ */
+interface SSEEvent {
+    type: string;
+    content?: string;
+    error?: string;
+    sessionId?: string;
+    toolName?: string;
+    toolCallId?: string;
+    durationMs?: number;
+    success?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Parses an SSE stream and yields parsed JSON events.
+ */
+declare function parseSSEStream(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncGenerator<SSEEvent, void, unknown>;
+
+/**
+ * Groups chat sessions by date relative to today
+ * Categories: Today, Yesterday, Last 7 Days, Last 30 Days, Older
+ * Sessions within each group are sorted by updatedAt (most recent first)
+ */
+declare function groupSessionsByDate(sessions: Session$1[], t?: (key: string) => string): SessionGroup[];
+
+/**
+ * Date formatting utilities using date-fns
+ */
+/**
+ * Format a date as relative time (e.g., "5m ago", "2h ago")
+ * Falls back to HH:mm format for dates older than 24 hours
+ *
+ * Accepts an optional `t` function for i18n. Translation keys used:
+ * - relativeTime.justNow
+ * - relativeTime.minutesAgo (receives `{count}`)
+ * - relativeTime.hoursAgo   (receives `{count}`)
+ * - relativeTime.daysAgo    (receives `{count}`)
+ *
+ * If no `t` function is provided, falls back to English defaults.
+ */
+declare function formatRelativeTime(date: string | Date, t?: (key: string, params?: Record<string, string | number>) => string): string;
+
+/**
+ * Shared validation utilities for QuestionForm components
+ */
+
+/**
+ * Checks if a question has been answered.
+ * A question is answered if it has at least one selected option OR custom text.
+ */
+declare function isQuestionAnswered(data: QuestionAnswerData | undefined): boolean;
+/**
+ * Validates that all questions are answered and custom text is valid.
+ * Returns null if valid, or an error message string if invalid.
+ *
+ * @param questions - Array of questions to validate
+ * @param answers - Map of question IDs to answer data
+ * @param t - Optional translation function for error messages
+ */
+declare function validateAnswers(questions: Question[], answers: QuestionAnswers, t?: (key: string, params?: Record<string, any>) => string): string | null;
+
+export { ATTACHMENT_ACCEPT_ATTRIBUTE, ActionButton, type ActionButtonIconProps, type ActionButtonLabelProps, type ActionButtonRootProps, type ActionButtonTooltipProps, _default$1 as Alert, AllChatsList, type AppConfig, _default as ArchiveBanner, ArchivedChatList, type Artifact$1 as 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$1 as AssistantTurn, AssistantTurnView, type AssistantTurnViewProps, type Attachment$1 as Attachment, MemoizedAttachmentGrid as AttachmentGrid, AttachmentPreview, AttachmentUpload, Avatar, type AvatarFallbackProps, type AvatarImageProps, type AvatarRootProps, type BiChatConfig, type BichatRPC, Bubble, type BubbleContentProps, type BubbleFooterProps, type BubbleHeaderProps, type BubbleMetadataProps, type BubbleRootProps, type BubbleVariant, CHART_VISUAL, ChartCard, type ChartData, type ChartSeries, type ChatDataSource, ChatHeader, type ChatInputStateValue, type ChatMessagingStateValue, ChatSession, type ChatSessionContextValue, ChatSessionProvider, type ChatSessionStateValue, type Citation$1 as Citation, MemoizedCodeBlock as CodeBlock, type CodeOutput$1 as CodeOutput, CodeOutputsPanel, CompactionDoodle, ConfigProvider, ConfirmModal, type ConfirmModalProps, ConfirmationStep, type ConversationTurn$1 as ConversationTurn, DateGroupHeader, DebugPanel, type DebugPanelProps, DefaultErrorContent, DownloadCard, MemoizedEditableText as EditableText, type EditableTextProps, type EditableTextRef, MemoizedEmptyState as EmptyState, type EmptyStateProps, ErrorBoundary, type FileValidationError, type FileVisual, HttpDataSource, type HttpDataSourceConfig, type ImageAttachment, type ImageLoadingStatus, ImageModal, InlineQuestionForm, type IotaContext, IotaContextProvider, ListItemSkeleton, MemoizedLoadingSpinner as LoadingSpinner, type LocaleContext, MemoizedMarkdownRenderer as MarkdownRenderer, MessageActions, MessageInput, type MessageInputProps, type MessageInputRef, MessageList, MessageRole, type PendingQuestion$1 as PendingQuestion, PermissionGuard, type PermissionGuardProps, type ProcessedContent, type Question, type QuestionAnswerData, type QuestionAnswers, QuestionForm, type QuestionOption, QuestionStep, type QueuedMessage, RateLimiter, type RateLimiterConfig, RetryActionArea, type SSEEvent, ScreenReaderAnnouncer, ScrollToBottomButton, MemoizedSearchInput as SearchInput, type SearchInputProps, type Session$1 as Session, type SessionArtifact, SessionArtifactList, SessionArtifactPreview, SessionArtifactsPanel, type SessionGroup, SessionItem, type SessionListResult$1 as SessionListResult, SessionSkeleton, type SessionUser, type ShortcutConfig, Sidebar, MemoizedSkeleton as Skeleton, SkeletonAvatar, SkeletonCard, SkeletonGroup, type SkeletonGroupProps, type SkeletonProps, SkeletonText, SkipLink, Slot, type SlotProps, SourcesPanel, type StreamChunk, StreamError, StreamingCursor, SystemMessage, MemoizedTabBar as TabBar, TableExportButton, TableWithExport, type TenantContext, type Theme, type ThemeBorderRadius, type ThemeColors, ThemeProvider, type ThemeSpacing, Toast, ToastContainer, type ToastItem, type ToastProps, type ToastType, type ToolCall$1 as ToolCall, TouchContextMenu, Turn, type TurnActionsProps, type TurnAssistantProps, TurnBubble, type TurnBubbleClassNames, type TurnBubbleProps, type TurnRootProps, type TurnTimestampProps, type TurnUserProps, MemoizedTypingIndicator as TypingIndicator, type TypingIndicatorProps, 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, MemoizedUserFilter as UserFilter, UserMessage, type UserMessageActionsSlotProps, type UserMessageAttachmentsSlotProps, type UserMessageAvatarSlotProps, type UserMessageClassNames, type UserMessageContentSlotProps, type UserMessageProps, type UserMessageSlots, type UserTurn$1 as UserTurn, UserTurnView, type UserTurnViewProps, WelcomeContent, addCSRFHeader, backdropVariants, buttonVariants, convertToBase64, createDataUrl, createHeadersWithCSRF, createHttpDataSource, darkTheme, dropdownVariants, errorMessageVariants, fadeInUpVariants, fadeInVariants, floatingButtonVariants, formatFileSize, formatRelativeTime, getCSRFToken, getFileVisual, getValidChildren, groupSessionsByDate, hasPermission as hasConfigPermission, hasPermission$1 as hasPermission, isImageMimeType, isQuestionAnswered, lightTheme, listItemVariants, messageContainerVariants, messageVariants, normalizeStreamingMarkdown, parseSSEStream, processCitations, scaleFadeVariants, sessionItemVariants, staggerContainerVariants, toastVariants, typingDotVariants, useActionButtonContext, useAttachments, useAutoScroll, useAvatarContext, useBubbleContext, useChat, useChatInput, useChatMessaging, useChatSession, useConfig, useFocusTrap, useImageGallery, useIotaContext, useKeyboardShortcuts, useLongPress, useMarkdownCopy, useMessageActions, useModalLock, useRequiredConfig, useScrollToBottom, useStreaming, useTheme, useToast, useTranslation, useTurnContext, validateAnswers, validateAttachmentFile, validateFileCount, validateImageFile, verbTransitionVariants };