@iota-uz/sdk 0.3.0 → 0.3.2

package/dist/bichat/index.d.ts

@@ -1,11 +1,13 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import react__default, { ReactNode, Component, ErrorInfo, HTMLAttributes, ReactElement, ImgHTMLAttributes, ButtonHTMLAttributes, RefObject } 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-.js';
+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';
@@ -17,33 +19,36 @@ interface Session {
  * A conversation turn groups a user message with its assistant response.
  * This provides a cleaner mental model than flat message lists.
  */
-interface ConversationTurn {
+interface ConversationTurn$1 {
     id: string;
     sessionId: string;
-    userTurn: UserTurn;
-    assistantTurn?: AssistantTurn;
+    userTurn: UserTurn$1;
+    assistantTurn?: AssistantTurn$1;
     createdAt: string;
 }
 /**
  * Content of a user's message in a conversation turn
  */
-interface UserTurn {
+interface UserTurn$1 {
     id: string;
     content: string;
-    attachments: Attachment[];
+    attachments: Attachment$1[];
     createdAt: string;
 }
 /**
  * Content of an assistant's response in a conversation turn
  */
-interface AssistantTurn {
+interface AssistantTurn$1 {
     id: string;
+    role?: MessageRole;
     content: string;
     explanation?: string;
-    citations: Citation[];
+    citations: Citation$1[];
+    toolCalls?: ToolCall$1[];
     chartData?: ChartData;
-    artifacts: Artifact[];
-    codeOutputs: CodeOutput[];
+    artifacts: Artifact$1[];
+    codeOutputs: CodeOutput$1[];
+    debug?: DebugTrace$1;
     createdAt: string;
 }
 /**
@@ -58,15 +63,18 @@ declare enum MessageRole {
 /**
  * A tool/function call made by the assistant
  */
-interface ToolCall {
+interface ToolCall$1 {
     id: string;
     name: string;
     arguments: string;
+    result?: string;
+    error?: string;
+    durationMs?: number;
 }
 /**
  * Citation with position information for inline replacement
  */
-interface Citation {
+interface Citation$1 {
     id: string;
     /** Type of citation (e.g., "url_citation") */
     type: string;
@@ -83,24 +91,23 @@ interface Citation {
     /** 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;
-}
+};
 /**
  * Output from code interpreter tool
  */
-interface CodeOutput {
+interface CodeOutput$1 {
     type: 'image' | 'text' | 'error';
     content: string;
     /** File metadata for downloadable outputs */
@@ -113,7 +120,7 @@ interface CodeOutput {
  */
 interface QueuedMessage {
     content: string;
-    attachments: ImageAttachment[];
+    attachments: Attachment$1[];
 }
 /**
  * Chart visualization data for ApexCharts
@@ -141,7 +148,7 @@ interface ChartSeries {
     /** Numeric data values */
     data: number[];
 }
-interface Artifact {
+interface Artifact$1 {
     type: 'excel' | 'pdf';
     filename: string;
     url: string;
@@ -149,7 +156,20 @@ 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;
     questions: Question[];
@@ -184,68 +204,238 @@ 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;
-        turns: ConversationTurn[];
-        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;
-    turns: ConversationTurn[];
-    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;
+    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>;
-    handleRetry?: () => 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;
     /** Custom render function for user turns */
-    renderUserTurn?: (turn: ConversationTurn) => ReactNode;
+    renderUserTurn?: (turn: ConversationTurn$1) => ReactNode;
     /** Custom render function for assistant turns */
-    renderAssistantTurn?: (turn: ConversationTurn) => ReactNode;
+    renderAssistantTurn?: (turn: ConversationTurn$1) => ReactNode;
     className?: string;
     /** Custom content to display as header */
     headerSlot?: ReactNode;
@@ -257,26 +447,62 @@ 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;
+    /** When provided, used instead of useChatMessaging().artifactsInvalidationTrigger (allows use outside SDK ChatSessionProvider). */
+    artifactsInvalidationTrigger?: number;
+}
+declare function SessionArtifactsPanel({ dataSource, sessionId, isStreaming, allowDrop, className, artifactsInvalidationTrigger: artifactsInvalidationTriggerProp, }: 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 {
     /** Custom render function for user turns */
-    renderUserTurn?: (turn: ConversationTurn) => ReactNode;
+    renderUserTurn?: (turn: ConversationTurn$1) => ReactNode;
     /** Custom render function for assistant turns */
-    renderAssistantTurn?: (turn: ConversationTurn) => ReactNode;
+    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({ renderUserTurn, renderAssistantTurn }: MessageListProps): react_jsx_runtime.JSX.Element;
+declare function MessageList({ renderUserTurn, renderAssistantTurn, thinkingVerbs, readOnly }: MessageListProps): react_jsx_runtime.JSX.Element;
 
 interface UserMessageAvatarSlotProps {
     /** Default initials */
@@ -287,8 +513,8 @@ interface UserMessageContentSlotProps {
     content: string;
 }
 interface UserMessageAttachmentsSlotProps {
-    /** Image attachments */
-    attachments: ImageAttachment[];
+    /** Message attachments */
+    attachments: Attachment$1[];
     /** Handler to open image viewer */
     onView: (index: number) => void;
 }
@@ -336,7 +562,7 @@ interface UserMessageClassNames {
 }
 interface UserMessageProps {
     /** User turn data */
-    turn: UserTurn;
+    turn: UserTurn$1;
     /** Turn ID for edit operations */
     turnId?: string;
     /** User initials for avatar */
@@ -355,12 +581,14 @@ interface UserMessageProps {
     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, }: UserMessageProps): react_jsx_runtime.JSX.Element;
+declare function UserMessage({ turn, turnId, initials, slots, classNames: classNameOverrides, onCopy, onEdit, hideAvatar, hideActions, hideTimestamp, allowEdit, }: UserMessageProps): react_jsx_runtime.JSX.Element;
 
 interface UserTurnViewProps {
     /** The conversation turn containing the user message */
-    turn: ConversationTurn;
+    turn: ConversationTurn$1;
     /** Slot overrides for customization */
     slots?: UserMessageSlots;
     /** Class name overrides */
@@ -373,8 +601,10 @@ interface UserTurnViewProps {
     hideActions?: boolean;
     /** Hide timestamp */
     hideTimestamp?: boolean;
+    /** Whether edit action should be available */
+    allowEdit?: boolean;
 }
-declare function UserTurnView({ turn, slots, classNames, initials, hideAvatar, hideActions, hideTimestamp, }: UserTurnViewProps): react_jsx_runtime.JSX.Element;
+declare function UserTurnView({ turn, slots, classNames, initials, hideAvatar, hideActions, hideTimestamp, allowEdit, }: UserTurnViewProps): react_jsx_runtime.JSX.Element;
 
 interface AssistantMessageAvatarSlotProps {
     /** Default text */
@@ -384,13 +614,13 @@ interface AssistantMessageContentSlotProps {
     /** Message content (markdown) */
     content: string;
     /** Citations */
-    citations?: Citation[];
+    citations?: Citation$1[];
     /** Whether streaming is active */
     isStreaming: boolean;
 }
 interface AssistantMessageSourcesSlotProps {
     /** Citations to display */
-    citations: Citation[];
+    citations: Citation$1[];
 }
 interface AssistantMessageChartsSlotProps {
     /** Chart data */
@@ -398,11 +628,11 @@ interface AssistantMessageChartsSlotProps {
 }
 interface AssistantMessageCodeOutputsSlotProps {
     /** Code execution outputs */
-    outputs: CodeOutput[];
+    outputs: CodeOutput$1[];
 }
 interface AssistantMessageArtifactsSlotProps {
     /** Downloadable artifacts */
-    artifacts: Artifact[];
+    artifacts: Artifact$1[];
 }
 interface AssistantMessageActionsSlotProps {
     /** Copy content to clipboard */
@@ -470,13 +700,15 @@ interface AssistantMessageClassNames {
 }
 interface AssistantMessageProps {
     /** Assistant turn data */
-    turn: AssistantTurn;
+    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 | null;
+    pendingQuestion?: PendingQuestion$1 | null;
     /** Slot overrides */
     slots?: AssistantMessageSlots;
     /** Class name overrides */
@@ -495,12 +727,16 @@ interface AssistantMessageProps {
     hideActions?: boolean;
     /** Hide timestamp */
     hideTimestamp?: boolean;
+    /** Show debug panel */
+    showDebug?: boolean;
 }
-declare function AssistantMessage({ turn, turnId, isStreaming, pendingQuestion, slots, classNames: classNameOverrides, onCopy, onRegenerate, onSendMessage, sendDisabled, hideAvatar, hideActions, hideTimestamp, }: AssistantMessageProps): react_jsx_runtime.JSX.Element;
+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 {
     /** The conversation turn containing the assistant response */
-    turn: ConversationTurn;
+    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 */
@@ -514,7 +750,7 @@ interface AssistantTurnViewProps {
     /** Hide timestamp */
     hideTimestamp?: boolean;
 }
-declare function AssistantTurnView({ turn, isStreaming, slots, classNames, hideAvatar, hideActions, hideTimestamp, }: AssistantTurnViewProps): react_jsx_runtime.JSX.Element | null;
+declare function AssistantTurnView({ turn, isLastTurn, isStreaming, slots, classNames, hideAvatar, hideActions, hideTimestamp, }: AssistantTurnViewProps): react_jsx_runtime.JSX.Element | null;
 
 interface TurnBubbleClassNames {
     /** Root container */
@@ -526,11 +762,13 @@ interface TurnBubbleClassNames {
 }
 interface TurnBubbleProps {
     /** The conversation turn containing user and optional assistant content */
-    turn: ConversationTurn;
+    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) => ReactNode;
+    renderUserTurn?: (turn: ConversationTurn$1) => ReactNode;
     /** Custom render function for assistant turn (full control) */
-    renderAssistantTurn?: (turn: ConversationTurn) => ReactNode;
+    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) */
@@ -548,13 +786,13 @@ interface TurnBubbleProps {
     /** Whether assistant response is streaming */
     isStreaming?: boolean;
 }
-declare function TurnBubble({ turn, renderUserTurn, renderAssistantTurn, userTurnProps, assistantTurnProps, userMessageSlots, assistantMessageSlots, userMessageClassNames, assistantMessageClassNames, classNames, isStreaming, }: TurnBubbleProps): react_jsx_runtime.JSX.Element;
+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;
     /** Optional citations to process and display */
-    citations?: Citation[] | null;
+    citations?: Citation$1[] | null;
     /** Optional function to send messages (enables table export) */
     sendMessage?: (content: string) => void;
     /** Whether message sending is disabled */
@@ -574,30 +812,21 @@ interface ChartCardProps {
 }
 /**
  * ChartCard renders a single chart visualization with optional PNG export.
- *
- * Chart types:
- * - line: Line chart with multiple series
- * - bar: Bar chart with multiple series
- * - area: Area chart with multiple series (filled)
- * - pie: Pie chart (single series)
- * - donut: Donut chart (single series)
- *
- * @param chartData - Chart specification from GraphQL API
  */
 declare function ChartCard({ chartData }: ChartCardProps): react_jsx_runtime.JSX.Element;
 
 interface SourcesPanelProps {
-    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 | null;
 
@@ -610,82 +839,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 {
-    /** Array of image attachments to display */
-    attachments: ImageAttachment[];
-    /** Optional callback when remove button is clicked */
+    attachments: Attachment$1[];
     onRemove?: (index: number) => void;
-    /** Optional callback when thumbnail is clicked for preview */
     onView?: (index: number) => void;
-    /** Additional CSS class */
     className?: string;
-    /** If true, disable all interactions */
     readonly?: boolean;
-    /** Maximum number of attachments to display (default: all) */
     maxDisplay?: number;
-    /** Maximum total capacity (for warning display, default: 10) */
     maxCapacity?: number;
-    /** Empty state message */
     emptyMessage?: string;
-    /** Show count label above grid */
     showCount?: boolean;
+    /** Number of files currently being processed (shows shimmer placeholders) */
+    pendingCount?: number;
 }
-/**
- * Responsive grid component for displaying image attachments
- *
- * Layout:
- * - Mobile: 2 columns (grid-cols-2)
- * - Tablet: 3 columns (sm:grid-cols-3)
- * - Desktop: 4 columns (md:grid-cols-4)
- */
-declare function AttachmentGrid({ attachments, onRemove, onView, className, readonly, maxDisplay, maxCapacity, emptyMessage, showCount, }: AttachmentGridProps): react_jsx_runtime.JSX.Element | null;
+declare 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 {
-    /** Whether the modal is open */
     isOpen: boolean;
-    /** Callback to close the modal */
     onClose: () => void;
-    /** The current attachment to display */
     attachment: ImageAttachment;
-    /** Optional: all attachments for navigation */
     allAttachments?: ImageAttachment[];
-    /** Optional: current index for navigation state */
     currentIndex?: number;
-    /** Optional: callback for navigation (prev/next) */
     onNavigate?: (direction: 'prev' | 'next') => void;
 }
-/**
- * Full-screen image modal component for viewing attachments
- *
- * Features:
- * - Full-screen overlay with dark backdrop (90% opacity)
- * - Large image display centered on screen
- * - Close button (X) in top-right corner
- * - Image metadata: filename, file size, MIME type
- * - Navigation arrows (left/right) for image carousel
- * - Keyboard support: Escape to close, Arrow keys to navigate
- * - Click backdrop to close
- * - Focus trap within modal
- * - Body scroll locked when open
- * - Image loading state with spinner
- * - Navigation disabled at boundaries (not circular)
- */
-declare function ImageModal({ isOpen, onClose, attachment, allAttachments, currentIndex, onNavigate, }: ImageModalProps): react.ReactPortal | null;
+declare function ImageModal({ isOpen, onClose, attachment, allAttachments, currentIndex, onNavigate, }: ImageModalProps): react_jsx_runtime.JSX.Element;
 
 /**
  * WelcomeContent Component
@@ -701,7 +899,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;
 
@@ -719,8 +917,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 */
@@ -983,7 +1190,9 @@ declare function ToastContainer({ toasts, onDismiss, dismissLabel }: ToastContai
 
 /**
  * ConfirmModal Component
- * Generic confirmation dialog with customizable title, message, and actions
+ * 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 */
@@ -1003,7 +1212,7 @@ interface ConfirmModalProps {
     /** Whether this is a danger/destructive action (red confirm button) */
     isDanger?: boolean;
 }
-declare function ConfirmModalBase({ isOpen, title, message, onConfirm, onCancel, confirmText, cancelText, isDanger, }: ConfirmModalProps): react_jsx_runtime.JSX.Element | null;
+declare function ConfirmModalBase({ isOpen, title, message, onConfirm, onCancel, confirmText, cancelText, isDanger, }: ConfirmModalProps): react_jsx_runtime.JSX.Element;
 declare const ConfirmModal: react.MemoExoticComponent<typeof ConfirmModalBase>;
 
 /**
@@ -1073,24 +1282,291 @@ declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryS
 
 /**
  * TypingIndicator Component
- * Displays animated dots or rotating text to indicate AI is processing
+ * Displays rotating verbs with shimmer animation to show AI is thinking/processing.
+ * Verbs are configurable via props.
  */
-type TypingIndicatorVariant = 'dots' | 'text' | 'pulse';
 interface TypingIndicatorProps {
-    /** Display variant */
-    variant?: TypingIndicatorVariant;
-    /** Custom thinking messages (for text variant) */
-    messages?: string[];
-    /** Message rotation interval in ms (for text variant, defaults to 3000) */
+    /** Custom thinking verbs to rotate through */
+    verbs?: string[];
+    /** Verb rotation interval in ms (defaults to 3000) */
     rotationInterval?: number;
-    /** Size */
-    size?: 'sm' | 'md' | 'lg';
     /** Additional CSS classes */
     className?: string;
 }
-declare function TypingIndicator({ variant, messages, rotationInterval, size, className, }: TypingIndicatorProps): react_jsx_runtime.JSX.Element;
+declare 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;
 }
@@ -1501,22 +1977,22 @@ interface FileValidationError {
 interface UseAttachmentsOptions {
     /** Maximum number of files (default: 10) */
     maxFiles?: number;
-    /** Maximum file size in bytes (default: 10MB) */
+    /** Maximum file size in bytes (default: 20MB) */
     maxFileSize?: number;
-    /** Allowed MIME types (default: images only) */
+    /** Allowed MIME types (default: attachment allowlist) */
     allowedTypes?: string[];
     /** Custom validation function */
     validate?: (file: File) => string | null;
     /** Callback when files are added */
-    onAdd?: (files: Attachment[]) => void;
+    onAdd?: (files: Attachment$1[]) => void;
     /** Callback when a file is removed */
-    onRemove?: (file: Attachment) => void;
+    onRemove?: (file: Attachment$1) => void;
     /** Callback when validation fails */
     onError?: (errors: FileValidationError[]) => void;
 }
 interface UseAttachmentsReturn {
     /** Current attachments */
-    files: Attachment[];
+    files: Attachment$1[];
     /** Validation errors from last operation */
     errors: FileValidationError[];
     /** Whether files are being processed */
@@ -1528,13 +2004,13 @@ interface UseAttachmentsReturn {
     /** Add files (validates and processes) */
     add: (files: FileList | File[]) => Promise<void>;
     /** Remove a specific file */
-    remove: (fileOrId: Attachment | string) => void;
+    remove: (fileOrId: Attachment$1 | string) => void;
     /** Clear all files */
     clear: () => void;
     /** Clear errors */
     clearErrors: () => void;
     /** Set files directly (for controlled mode) */
-    setFiles: (files: Attachment[]) => void;
+    setFiles: (files: Attachment$1[]) => void;
 }
 /**
  * Hook for managing file attachments
@@ -1617,16 +2093,88 @@ interface UseMarkdownCopyReturn {
 declare function useMarkdownCopy(options?: UseMarkdownCopyOptions): UseMarkdownCopyReturn;
 
 /**
- * Framer Motion animation variants for BiChat UI
- * Subtle, professional animations for enterprise applications
- * Respects prefers-reduced-motion for accessibility
+ * 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;
+}
 /**
- * Fade in animation
+ * Hook for managing scroll-to-bottom behavior
+ * Automatically scrolls if user is near the bottom
+ * Shows button only when scrolled up significantly
  */
-declare const fadeInVariants: {
-    initial: {
-        opacity: number;
+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;
@@ -1808,6 +2356,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.)
  */
@@ -1877,35 +2450,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;
@@ -1914,30 +2514,26 @@ 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;
+/** Returns messaging context or null when outside ChatSessionProvider. Use when component can receive values via props (e.g. SessionArtifactsPanel with artifactsInvalidationTrigger prop). */
+declare function useOptionalChatMessaging(): ChatMessagingStateValue | null;
+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;
@@ -1972,14 +2568,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;
@@ -2014,7 +2619,7 @@ interface BiChatConfig {
         translations: Record<string, string>;
     };
     endpoints: {
-        graphQL: string;
+        rpc: string;
         stream: string;
     };
     csrfToken?: string;
@@ -2131,23 +2736,25 @@ 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;
+    /** Optional: called when a new session is created so the host app can navigate (e.g. SPA router) */
+    navigateToSession?: (sessionId: string) => void;
 }
 interface SessionState {
-    session: Session;
-    turns: ConversationTurn[];
-    pendingQuestion?: PendingQuestion | null;
+    session: Session$1;
+    turns: ConversationTurn$1[];
+    pendingQuestion?: PendingQuestion$1 | null;
 }
 interface Result<T> {
     success: boolean;
@@ -2157,6 +2764,7 @@ interface Result<T> {
 declare class HttpDataSource implements ChatDataSource {
     private config;
     private abortController;
+    private rpc;
     constructor(config: HttpDataSourceConfig);
     /**
      * Get CSRF token from config
@@ -2166,57 +2774,383 @@ 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 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: ArtifactIDParams;
+        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 ArtifactIDParams {
+    id: 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
  */
@@ -2231,6 +3165,25 @@ declare function formatFileSize(bytes: number): string;
  */
 declare function validateFileCount(currentCount: number, newCount: number, maxCount?: number): void;
 
+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
  *
@@ -2247,7 +3200,7 @@ interface ProcessedContent {
     /** Content with citation markers replaced by [1], [2], etc. */
     content: string;
     /** Citations array with their display indices */
-    citations: Array<Citation & {
+    citations: Array<Citation$1 & {
         displayIndex: number;
     }>;
 }
@@ -2268,6 +3221,77 @@ interface ProcessedContent {
  * // result.citations = [{ ..., displayIndex: 1 }]
  * ```
  */
-declare function processCitations(content: string, citations: Citation[] | null | undefined): ProcessedContent;
+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 { ActionButton, type ActionButtonIconProps, type ActionButtonLabelProps, type ActionButtonRootProps, type ActionButtonTooltipProps, type AppConfig, type Artifact, type AsChildProps, AssistantMessage, type AssistantMessageActionsSlotProps, type AssistantMessageArtifactsSlotProps, type AssistantMessageAvatarSlotProps, type AssistantMessageChartsSlotProps, type AssistantMessageClassNames, type AssistantMessageCodeOutputsSlotProps, type AssistantMessageContentSlotProps, type AssistantMessageExplanationSlotProps, type AssistantMessageProps, type AssistantMessageSlots, type AssistantMessageSourcesSlotProps, type AssistantTurn, AssistantTurnView, type AssistantTurnViewProps, type Attachment, MemoizedAttachmentGrid as AttachmentGrid, Avatar, type AvatarFallbackProps, type AvatarImageProps, type AvatarRootProps, type BiChatConfig, Bubble, type BubbleContentProps, type BubbleFooterProps, type BubbleHeaderProps, type BubbleMetadataProps, type BubbleRootProps, type BubbleVariant, ChartCard, type ChartData, type ChartSeries, type ChatDataSource, ChatHeader, ChatSession, type ChatSessionContextValue, ChatSessionProvider, type Citation, MemoizedCodeBlock as CodeBlock, type CodeOutput, CodeOutputsPanel, ConfigProvider, ConfirmModal, type ConfirmModalProps, type ConversationTurn, DefaultErrorContent, DownloadCard, MemoizedEditableText as EditableText, type EditableTextProps, type EditableTextRef, MemoizedEmptyState as EmptyState, type EmptyStateProps, ErrorBoundary, type FileValidationError, HttpDataSource, type HttpDataSourceConfig, type ImageAttachment, type ImageLoadingStatus, ImageModal, InlineQuestionForm, type IotaContext, IotaContextProvider, ListItemSkeleton, MemoizedLoadingSpinner as LoadingSpinner, type LocaleContext, MemoizedMarkdownRenderer as MarkdownRenderer, MessageInput, type MessageInputProps, type MessageInputRef, MessageList, MessageRole, type PendingQuestion, PermissionGuard, type PermissionGuardProps, type ProcessedContent, type Question, type QuestionAnswerData, type QuestionAnswers, type QuestionOption, type QueuedMessage, RateLimiter, type RateLimiterConfig, ScrollToBottomButton, MemoizedSearchInput as SearchInput, type SearchInputProps, type Session, MemoizedSkeleton as Skeleton, SkeletonAvatar, SkeletonCard, SkeletonGroup, type SkeletonGroupProps, type SkeletonProps, SkeletonText, Slot, type SlotProps, SourcesPanel, type StreamChunk, StreamingCursor, TableExportButton, TableWithExport, type TenantContext, type Theme, type ThemeBorderRadius, type ThemeColors, ThemeProvider, type ThemeSpacing, Toast, ToastContainer, type ToastItem, type ToastProps, type ToastType, type ToolCall, Turn, type TurnActionsProps, type TurnAssistantProps, TurnBubble, type TurnBubbleClassNames, type TurnBubbleProps, type TurnRootProps, type TurnTimestampProps, type TurnUserProps, MemoizedTypingIndicator as TypingIndicator, type TypingIndicatorProps, type TypingIndicatorVariant, type UseAttachmentsOptions, type UseAttachmentsReturn, type UseAutoScrollOptions, type UseAutoScrollReturn, type UseImageGalleryOptions, type UseImageGalleryReturn, type UseMarkdownCopyOptions, type UseMarkdownCopyReturn, type UseMessageActionsOptions, type UseMessageActionsReturn, type UseToastReturn, MemoizedUserAvatar as UserAvatar, type UserAvatarProps, type UserContext, UserMessage, type UserMessageActionsSlotProps, type UserMessageAttachmentsSlotProps, type UserMessageAvatarSlotProps, type UserMessageClassNames, type UserMessageContentSlotProps, type UserMessageProps, type UserMessageSlots, type UserTurn, UserTurnView, type UserTurnViewProps, WelcomeContent, addCSRFHeader, backdropVariants, buttonVariants, convertToBase64, createDataUrl, createHeadersWithCSRF, createHttpDataSource, darkTheme, dropdownVariants, fadeInUpVariants, fadeInVariants, floatingButtonVariants, formatFileSize, getCSRFToken, getValidChildren, hasPermission as hasConfigPermission, hasPermission$1 as hasPermission, lightTheme, listItemVariants, messageContainerVariants, messageVariants, processCitations, scaleFadeVariants, staggerContainerVariants, toastVariants, typingDotVariants, useActionButtonContext, useAttachments, useAutoScroll, useAvatarContext, useBubbleContext, useChat, useConfig, useFocusTrap, useImageGallery, useIotaContext, useMarkdownCopy, useMessageActions, useModalLock, useRequiredConfig, useStreaming, useTheme, useToast, useTranslation, useTurnContext, validateFileCount, validateImageFile };
+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, useOptionalChatMessaging, useRequiredConfig, useScrollToBottom, useStreaming, useTheme, useToast, useTranslation, useTurnContext, validateAnswers, validateAttachmentFile, validateFileCount, validateImageFile, verbTransitionVariants };