@uix-ai/agent 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1649 @@
+import * as React from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { VirtualElement, Placement, UseFloatingReturn } from '@floating-ui/react';
+export { VirtualElement } from '@floating-ui/react';
+import { ToolStatus, SourceBlockContent, LucidConversation, LucidBlock } from '@uix-ai/core';
+import { ClassValue } from 'clsx';
+
+/**
+ * Shared types for @uix-ai/agent components
+ *
+ * This file is the single source of truth for shared types.
+ * Import from here instead of individual component files.
+ */
+/**
+ * Message role types following AgentX convention
+ * - user: Human user messages
+ * - assistant: AI assistant responses
+ * - system: System messages
+ * - tool: Tool execution results
+ * - error: Error messages
+ */
+type MessageRole = 'user' | 'assistant' | 'system' | 'tool' | 'error';
+/**
+ * Message lifecycle status
+ */
+type MessageStatus = 'idle' | 'thinking' | 'streaming' | 'complete' | 'error';
+/**
+ * Avatar size options
+ */
+type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Avatar color variants
+ */
+type AvatarVariant$1 = 'primary' | 'secondary' | 'neutral' | 'success' | 'warning' | 'error';
+/**
+ * AI-specific dynamic status for avatar animations
+ */
+type AvatarAnimationStatus = 'idle' | 'thinking' | 'planning' | 'responding' | 'tool-calling';
+/**
+ * Online/presence status
+ */
+type PresenceStatus = 'online' | 'offline' | 'busy';
+/**
+ * Image loading status
+ */
+type ImageLoadingStatus$1 = 'idle' | 'loading' | 'loaded' | 'error';
+/**
+ * Agent data for @mention
+ */
+interface MentionAgent {
+    id: string;
+    name: string;
+    avatar?: string;
+    description?: string;
+    status?: PresenceStatus;
+}
+/**
+ * Stream source type
+ */
+type StreamSource = AsyncIterable<string> | ReadableStream<string> | string;
+/**
+ * Thinking animation variant
+ */
+type ThinkingVariant = 'dots' | 'pulse' | 'bounce' | 'wave' | 'spinner';
+/**
+ * Agent associated with a conversation
+ */
+interface ConversationAgent {
+    id: string;
+    name: string;
+    avatar?: string;
+}
+/**
+ * Conversation item data structure
+ */
+interface Conversation {
+    /** Unique identifier */
+    id: string;
+    /** Conversation title */
+    title: string;
+    /** Last message preview */
+    lastMessage?: string;
+    /** Last active time */
+    lastActiveAt?: Date | string;
+    /** Unread message count */
+    unreadCount?: number;
+    /** Is pinned */
+    pinned?: boolean;
+    /** Associated agent */
+    agent?: ConversationAgent;
+    /** Tags */
+    tags?: string[];
+}
+/**
+ * Agent info for ChatWindowHeader
+ */
+interface ChatWindowAgent {
+    id: string;
+    name: string;
+    avatar?: string;
+    status?: PresenceStatus;
+    description?: string;
+}
+/**
+ * ChatWindow status
+ */
+type ChatWindowStatus = 'idle' | 'loading' | 'streaming' | 'error';
+
+/**
+ * Avatar - Composable avatar components for AI agents
+ *
+ * Follows shadcn/Radix composition pattern.
+ * Components can be freely composed to create custom avatar layouts.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <Avatar>
+ *   <AvatarImage src="/claude.png" />
+ *   <AvatarFallback>CL</AvatarFallback>
+ * </Avatar>
+ * ```
+ *
+ * @example With AI status animation
+ * ```tsx
+ * <Avatar status="thinking">
+ *   <AvatarImage src="/claude.png" />
+ *   <AvatarFallback variant="primary">A</AvatarFallback>
+ * </Avatar>
+ * ```
+ *
+ * @example With online status indicator
+ * ```tsx
+ * <Avatar size="lg">
+ *   <AvatarImage src="/claude.png" />
+ *   <AvatarFallback>CL</AvatarFallback>
+ *   <AvatarStatusIndicator status="online" />
+ * </Avatar>
+ * ```
+ *
+ * @example Role-based (shorthand for message scenarios)
+ * ```tsx
+ * <Avatar role="assistant" status="responding">
+ *   <AvatarFallback />
+ * </Avatar>
+ * ```
+ */
+
+/**
+ * Message role for automatic color/symbol mapping
+ */
+type AvatarRole = 'user' | 'assistant' | 'system' | 'tool' | 'error';
+declare const sizeClasses: Record<AvatarSize, string>;
+declare const variantClasses: Record<AvatarVariant$1, string>;
+declare const roleToVariant: Record<AvatarRole, AvatarVariant$1>;
+declare const roleSymbols: Record<AvatarRole, string>;
+declare const presenceColors: Record<PresenceStatus, string>;
+interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Avatar size
+     * @default "md"
+     */
+    size?: AvatarSize;
+    /**
+     * AI animation status
+     * @default "idle"
+     */
+    status?: AvatarAnimationStatus;
+    /**
+     * Message role (provides default variant and symbol to children)
+     */
+    role?: AvatarRole;
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface AvatarImageProps extends React.ImgHTMLAttributes<HTMLImageElement> {
+    /**
+     * Callback when loading status changes
+     */
+    onLoadingStatusChange?: (status: ImageLoadingStatus$1) => void;
+}
+declare const AvatarImage: React.ForwardRefExoticComponent<AvatarImageProps & React.RefAttributes<HTMLImageElement>>;
+interface AvatarFallbackProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Color variant
+     * @default "neutral" (or derived from role)
+     */
+    variant?: AvatarVariant$1;
+    /**
+     * Delay before showing fallback (ms)
+     * @default 0
+     */
+    delayMs?: number;
+}
+declare const AvatarFallback: React.ForwardRefExoticComponent<AvatarFallbackProps & React.RefAttributes<HTMLDivElement>>;
+interface AvatarStatusIndicatorProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Presence status
+     */
+    status: PresenceStatus;
+}
+declare const AvatarStatusIndicator: React.ForwardRefExoticComponent<AvatarStatusIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+
+/**
+ * AvatarGroup - Multi-avatar stack component
+ *
+ * Displays multiple avatars in a stacked layout with overflow handling.
+ * Uses the composable Avatar system.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <AvatarGroup>
+ *   <Avatar><AvatarImage src="/a.png" /><AvatarFallback>A</AvatarFallback></Avatar>
+ *   <Avatar><AvatarImage src="/b.png" /><AvatarFallback>B</AvatarFallback></Avatar>
+ * </AvatarGroup>
+ * ```
+ *
+ * @example With max and overflow
+ * ```tsx
+ * <AvatarGroup max={3}>
+ *   {agents.map(agent => (
+ *     <Avatar key={agent.id}>
+ *       <AvatarImage src={agent.avatar} />
+ *       <AvatarFallback>{agent.initials}</AvatarFallback>
+ *     </Avatar>
+ *   ))}
+ * </AvatarGroup>
+ * ```
+ */
+
+interface AvatarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Maximum number of avatars to show before overflow
+     * @default 4
+     */
+    max?: number;
+    /**
+     * Avatar size (applied to all children)
+     * @default "sm"
+     */
+    size?: AvatarSize;
+    /**
+     * Stack direction
+     * @default "left"
+     */
+    direction?: 'left' | 'right';
+}
+/**
+ * AvatarGroup Component
+ *
+ * Displays a stack of avatars with:
+ * - Overlap effect (later avatars partially cover earlier ones)
+ * - Overflow indicator (+N) when exceeding max
+ * - Hover effect to show full avatar
+ */
+declare const AvatarGroup: React.ForwardRefExoticComponent<AvatarGroupProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * AgentAvatar - Flexible avatar for agents and users
+ *
+ * General-purpose avatar component supporting images, icons, and initials
+ * with multiple color variants and status indicators.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <AgentAvatar name="Claude" />
+ * <AgentAvatar src="/avatar.png" name="Claude" status="online" />
+ * ```
+ *
+ * @example With variants
+ * ```tsx
+ * <AgentAvatar name="AI" variant="primary" />
+ * <AgentAvatar name="User" variant="secondary" />
+ * ```
+ *
+ * @example With loading status callback (Radix-style)
+ * ```tsx
+ * <AgentAvatar
+ *   src="/avatar.png"
+ *   name="Claude"
+ *   onLoadingStatusChange={(status) => console.log(status)}
+ *   fallbackDelayMs={600}
+ * />
+ * ```
+ */
+
+/**
+ * Color variants for avatar backgrounds
+ * @deprecated Use AvatarVariant from './Avatar' instead
+ */
+type AvatarVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info' | 'neutral';
+/**
+ * Image loading status (Radix-style)
+ * @deprecated Use ImageLoadingStatus from './Avatar' instead
+ */
+type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
+interface AgentAvatarProps {
+    /**
+     * Avatar image URL
+     */
+    src?: string;
+    /**
+     * Agent name (used for fallback initials)
+     */
+    name: string;
+    /**
+     * Custom icon component (displayed instead of initials when no src)
+     */
+    icon?: React.ReactNode;
+    /**
+     * Color variant
+     * @default "neutral"
+     */
+    variant?: AvatarVariant;
+    /**
+     * Online status indicator
+     */
+    status?: 'online' | 'offline' | 'busy';
+    /**
+     * Avatar size
+     * @default "md"
+     */
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Callback when image loading status changes (Radix-style)
+     */
+    onLoadingStatusChange?: (status: ImageLoadingStatus) => void;
+    /**
+     * Delay in ms before showing fallback (gives image time to load)
+     * @default 0
+     */
+    fallbackDelayMs?: number;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+/**
+ * Hook to track image loading status (Radix-style)
+ */
+declare function useImageLoadingStatus(src: string | undefined, onStatusChange?: (status: ImageLoadingStatus) => void): ImageLoadingStatus;
+/**
+ * AgentAvatar Component
+ *
+ * Flexible avatar component for displaying agents and users.
+ * Supports images, custom icons, and fallback initials with
+ * multiple color variants and status indicators.
+ *
+ * Features:
+ * - Image loading status tracking (Radix-style)
+ * - Automatic fallback with optional delay
+ * - Multiple color variants
+ * - Online/offline/busy status indicators
+ */
+declare const AgentAvatar: React.ForwardRefExoticComponent<AgentAvatarProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * MessageAvatar - Role-driven avatar for chat messages
+ *
+ * Automatically maps message role to color and symbol.
+ * Based on AgentX u/a/s/t convention.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <MessageAvatar role="user" />
+ * <MessageAvatar role="assistant" />
+ * <MessageAvatar role="tool" />
+ * ```
+ *
+ * @example With AI status animation
+ * ```tsx
+ * <MessageAvatar role="assistant" status="thinking" />
+ * <MessageAvatar role="assistant" status="responding" />
+ * <MessageAvatar role="tool" status="tool-calling" />
+ * ```
+ *
+ * @example With custom image
+ * ```tsx
+ * <MessageAvatar role="assistant" src="/claude.png" name="Claude" />
+ * ```
+ */
+
+/**
+ * AI-specific dynamic status for avatar animations
+ * - idle: No animation (default)
+ * - thinking: Pulsing animation - AI is processing
+ * - responding: Breathing effect - AI is streaming response
+ * - tool-calling: Spinning indicator - AI is calling tools
+ */
+type AvatarStatus = 'idle' | 'thinking' | 'responding' | 'tool-calling';
+interface MessageAvatarProps {
+    /**
+     * Message role - determines color and default symbol
+     */
+    role: MessageRole;
+    /**
+     * AI dynamic status - triggers animations
+     * @default "idle"
+     */
+    status?: AvatarStatus;
+    /**
+     * Custom avatar image URL (overrides default symbol)
+     */
+    src?: string;
+    /**
+     * Agent/user name (used for alt text and custom initials)
+     */
+    name?: string;
+    /**
+     * Custom icon component (overrides default symbol)
+     */
+    icon?: React.ReactNode;
+    /**
+     * Avatar size
+     * @default "md"
+     */
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+/**
+ * Role to color mapping using semantic design tokens
+ * - user: primary (blue) - precise commands
+ * - assistant: secondary (amber/gold) - generative thinking
+ * - system: muted (gray) - neutral system info
+ * - tool: accent (orange) - action/execution
+ * - error: destructive (red) - errors
+ */
+declare const roleColors: Record<MessageRole, string>;
+/**
+ * AI status animation classes
+ * - thinking: pulse animation (scale + opacity)
+ * - responding: breathing glow effect
+ * - tool-calling: spinning ring indicator
+ */
+declare const statusAnimations: Record<AvatarStatus, string>;
+/**
+ * MessageAvatar Component
+ *
+ * Role-driven avatar that automatically applies appropriate colors and symbols
+ * based on the message role (user/assistant/system/tool/error).
+ *
+ * Design philosophy:
+ * - User messages use primary color (rational blue) - precise commands
+ * - Assistant messages use secondary color (sentient gold) - generative thinking
+ * - System/tool messages use neutral colors
+ * - Error messages use destructive red
+ *
+ * AI Status animations:
+ * - thinking: Pulsing effect indicating AI is processing
+ * - responding: Breathing glow effect during streaming
+ * - tool-calling: Spinning ring indicator for tool execution
+ */
+declare const MessageAvatar: React.ForwardRefExoticComponent<MessageAvatarProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatBubbleProps {
+    /**
+     * Message role
+     */
+    role: 'user' | 'assistant' | 'system';
+    /**
+     * Avatar image URL (for assistant)
+     */
+    avatar?: string;
+    /**
+     * Agent/user name
+     */
+    name?: string;
+    /**
+     * Message content
+     */
+    children: React.ReactNode;
+    /**
+     * Timestamp
+     */
+    timestamp?: string | Date;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+/**
+ * ChatBubble Component
+ *
+ * @deprecated Use `ChatMessageSimple` instead. ChatBubble will be removed in a future version.
+ *
+ * ChatMessageSimple provides the same functionality but is built on the composable
+ * ChatMessage primitives, ensuring consistent styling and behavior.
+ *
+ * @example Migration
+ * ```tsx
+ * // Before (deprecated)
+ * <ChatBubble role="assistant" avatar="/claude.png" name="Claude">
+ *   Hello!
+ * </ChatBubble>
+ *
+ * // After (recommended)
+ * <ChatMessageSimple
+ *   role="assistant"
+ *   avatar="/claude.png"
+ *   name="Claude"
+ *   content="Hello!"
+ * />
+ * ```
+ */
+declare function ChatBubble({ role, avatar, name, children, timestamp, className, }: ChatBubbleProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ChatInput - Composable input components for AI chat
+ *
+ * Follows the "composition over configuration" pattern from shadcn/ui and Vercel.
+ * Components can be freely composed to create custom input layouts.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <ChatInput onSubmit={handleSubmit}>
+ *   <ChatInputTextarea placeholder="Ask anything..." />
+ *   <ChatInputToolbar>
+ *     <ChatInputTools>
+ *       <ChatInputButton onClick={handleAttach}>
+ *         <PaperclipIcon />
+ *       </ChatInputButton>
+ *     </ChatInputTools>
+ *     <ChatInputSubmit status={status} />
+ *   </ChatInputToolbar>
+ * </ChatInput>
+ * ```
+ *
+ * @example With mentions
+ * ```tsx
+ * <ChatInput onSubmit={handleSubmit}>
+ *   <ChatInputTextarea
+ *     onMentionQuery={searchAgents}
+ *     mentionTrigger="@"
+ *   />
+ *   <ChatInputToolbar>
+ *     <ChatInputSubmit />
+ *   </ChatInputToolbar>
+ * </ChatInput>
+ * ```
+ */
+
+type ChatStatus = 'idle' | 'submitted' | 'streaming' | 'error';
+/**
+ * @deprecated Use MentionAgent from MentionPopover instead
+ */
+interface ChatInputMentionItem {
+    id: string;
+    name: string;
+    avatar?: string;
+    description?: string;
+}
+type MentionItem$1 = ChatInputMentionItem;
+interface ChatInputProps extends React.FormHTMLAttributes<HTMLFormElement> {
+    /**
+     * Callback when form is submitted
+     */
+    onSubmit?: (e: React.FormEvent<HTMLFormElement>) => void;
+}
+/**
+ * Container component for chat input.
+ * Renders as a form element.
+ */
+declare const ChatInput: React.ForwardRefExoticComponent<ChatInputProps & React.RefAttributes<HTMLFormElement>>;
+interface ChatInputTextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange'> {
+    /**
+     * Controlled value
+     */
+    value?: string;
+    /**
+     * Value change callback
+     */
+    onChange?: (value: string) => void;
+    /**
+     * Minimum height in pixels
+     * @default 48
+     */
+    minHeight?: number;
+    /**
+     * Maximum height in pixels
+     * @default 200
+     */
+    maxHeight?: number;
+    /**
+     * Trigger character for mentions
+     * @default "@"
+     */
+    mentionTrigger?: string;
+    /**
+     * Callback to query mention candidates
+     */
+    onMentionQuery?: (query: string) => MentionItem$1[];
+    /**
+     * Available mention items (used if onMentionQuery not provided)
+     */
+    mentionItems?: MentionItem$1[];
+    /**
+     * Callback when a mention is selected
+     */
+    onMentionSelect?: (item: MentionItem$1) => void;
+}
+/**
+ * Auto-resizing textarea with optional @mention support.
+ */
+declare const ChatInputTextarea: React.ForwardRefExoticComponent<ChatInputTextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+interface ChatInputToolbarProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+/**
+ * Toolbar container for input actions.
+ * Typically placed below the textarea.
+ */
+declare const ChatInputToolbar: React.ForwardRefExoticComponent<ChatInputToolbarProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatInputToolsProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+/**
+ * Container for tool buttons (left side of toolbar).
+ */
+declare const ChatInputTools: React.ForwardRefExoticComponent<ChatInputToolsProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatInputButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Visual variant
+     */
+    variant?: 'ghost' | 'default';
+}
+/**
+ * Button for toolbar actions (attach, emoji, etc.)
+ */
+declare const ChatInputButton: React.ForwardRefExoticComponent<ChatInputButtonProps & React.RefAttributes<HTMLButtonElement>>;
+interface ChatInputSubmitProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Current chat status
+     */
+    status?: ChatStatus;
+    /**
+     * Callback when stop is clicked (during streaming)
+     */
+    onStop?: () => void;
+}
+/**
+ * Submit button with status-aware icons.
+ */
+declare const ChatInputSubmit: React.ForwardRefExoticComponent<ChatInputSubmitProps & React.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * StreamText - Streaming text display with cursor effect
+ *
+ * Core component for AI streaming responses. Supports real async streams
+ * and simulated typing animation.
+ *
+ * @example Real streaming
+ * ```tsx
+ * <StreamText stream={asyncIterator} onComplete={() => setDone(true)} />
+ * ```
+ *
+ * @example With cursor
+ * ```tsx
+ * <StreamText stream={stream} cursor cursorChar="▋" />
+ * ```
+ *
+ * @example Simulated typing (for non-streaming APIs)
+ * ```tsx
+ * <StreamText text="Hello, I am Claude." speed={30} />
+ * ```
+ *
+ * @example Composed with custom renderer
+ * ```tsx
+ * <StreamText stream={stream}>
+ *   {(text, isStreaming) => (
+ *     <Markdown className={isStreaming ? 'opacity-90' : ''}>{text}</Markdown>
+ *   )}
+ * </StreamText>
+ * ```
+ *
+ * @example With abort controller
+ * ```tsx
+ * const abortRef = useRef<AbortController>()
+ * <StreamText stream={stream} abortController={abortRef.current} />
+ * <button onClick={() => abortRef.current?.abort()}>Stop</button>
+ * ```
+ */
+
+interface StreamTextProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children' | 'onError'> {
+    /**
+     * Stream source: AsyncIterable, ReadableStream, or plain string
+     */
+    stream?: AsyncIterable<string> | ReadableStream<string>;
+    /**
+     * Static text for simulated typing (mutually exclusive with stream)
+     */
+    text?: string;
+    /**
+     * Show blinking cursor during streaming
+     * @default true
+     */
+    cursor?: boolean;
+    /**
+     * Cursor character
+     * @default "▋"
+     */
+    cursorChar?: string;
+    /**
+     * Typing speed in ms per character (only for text prop)
+     * @default 30
+     */
+    speed?: number;
+    /**
+     * Called when streaming/typing completes
+     */
+    onComplete?: () => void;
+    /**
+     * Called on streaming error
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called on each text update with current text
+     */
+    onUpdate?: (text: string) => void;
+    /**
+     * AbortController for external cancellation
+     */
+    abortController?: AbortController;
+    /**
+     * Custom render function for advanced use (e.g., markdown rendering)
+     */
+    children?: (text: string, isStreaming: boolean) => React.ReactNode;
+}
+interface UseAsyncStreamOptions {
+    onComplete?: () => void;
+    onError?: (error: Error) => void;
+    onUpdate?: (text: string) => void;
+    abortController?: AbortController;
+}
+interface UseAsyncStreamResult {
+    text: string;
+    isStreaming: boolean;
+    error: Error | null;
+    abort: () => void;
+}
+/**
+ * Hook to consume an async iterable stream
+ *
+ * Uses ref pattern for callbacks to prevent dependency issues.
+ * Supports external abort via AbortController.
+ */
+declare function useAsyncStream(stream: AsyncIterable<string> | ReadableStream<string> | undefined, options?: UseAsyncStreamOptions): UseAsyncStreamResult;
+interface UseTypingAnimationOptions {
+    speed?: number;
+    onComplete?: () => void;
+    onUpdate?: (text: string) => void;
+}
+interface UseTypingAnimationResult {
+    displayText: string;
+    isTyping: boolean;
+}
+/**
+ * Hook for simulated typing animation
+ *
+ * Uses ref pattern for callbacks to prevent dependency issues.
+ */
+declare function useTypingAnimation(text: string | undefined, options?: UseTypingAnimationOptions): UseTypingAnimationResult;
+/**
+ * Blinking cursor component
+ */
+declare const StreamCursor: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & {
+    char?: string;
+} & React.RefAttributes<HTMLSpanElement>>;
+/**
+ * StreamText Component
+ *
+ * Renders streaming text from async sources with optional cursor effect.
+ * Supports both real streaming (AsyncIterable/ReadableStream) and
+ * simulated typing animation for static text.
+ *
+ * Design notes:
+ * - Uses useCallbackRef pattern to avoid useEffect dependency issues
+ * - Supports external abort via AbortController
+ * - Accumulated text pattern prevents state closure issues
+ */
+declare const StreamText: React.ForwardRefExoticComponent<StreamTextProps & React.RefAttributes<HTMLSpanElement>>;
+
+/**
+ * ChatMessage - Composable message component system
+ *
+ * Provides composable primitives for building chat messages.
+ * Each part can be used independently or composed together.
+ *
+ * @example Full composition
+ * ```tsx
+ * <ChatMessage role="assistant" status="streaming">
+ *   <ChatMessageAvatar src="/claude.png" name="Claude" />
+ *   <ChatMessageContent>
+ *     <StreamText stream={stream} />
+ *   </ChatMessageContent>
+ *   <ChatMessageTimestamp time={new Date()} />
+ * </ChatMessage>
+ * ```
+ *
+ * @example Minimal composition
+ * ```tsx
+ * <ChatMessage role="user">
+ *   <ChatMessageContent>Hello!</ChatMessageContent>
+ * </ChatMessage>
+ * ```
+ *
+ * @example With thinking state
+ * ```tsx
+ * <ChatMessage role="assistant" status="thinking">
+ *   <ChatMessageAvatar />
+ *   <ChatMessageContent>
+ *     <ChatMessageThinking label="Analyzing..." />
+ *   </ChatMessageContent>
+ * </ChatMessage>
+ * ```
+ *
+ * @example Pre-composed simple version
+ * ```tsx
+ * <ChatMessageSimple
+ *   role="assistant"
+ *   status="streaming"
+ *   stream={stream}
+ *   avatar="/claude.png"
+ *   name="Claude"
+ * />
+ * ```
+ */
+
+interface ChatMessageContextValue {
+    role: MessageRole;
+    status: MessageStatus;
+    isUser: boolean;
+}
+declare function useChatMessageContext(): ChatMessageContextValue;
+
+interface ChatMessageProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Message role - determines layout direction and default styling
+     */
+    role: MessageRole;
+    /**
+     * Message status - provides context to children
+     * @default "complete"
+     */
+    status?: MessageStatus;
+}
+/**
+ * ChatMessage Container
+ *
+ * Provides context for child components and handles layout.
+ * User messages align right, others align left.
+ */
+declare const ChatMessage: React.ForwardRefExoticComponent<ChatMessageProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatMessageAvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Avatar image URL
+     */
+    src?: string;
+    /**
+     * Name for fallback initials
+     */
+    name?: string;
+    /**
+     * Override animation status (defaults to message status)
+     */
+    animationStatus?: AvatarAnimationStatus;
+}
+/**
+ * ChatMessageAvatar
+ *
+ * Avatar with automatic animation based on message status.
+ * Uses role from context for default styling.
+ */
+declare const ChatMessageAvatar: React.ForwardRefExoticComponent<ChatMessageAvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatMessageContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Name to display above content (typically for assistant)
+     */
+    name?: string;
+}
+/**
+ * ChatMessageContent
+ *
+ * Content container with role-based styling.
+ * Renders children as message content.
+ */
+declare const ChatMessageContent: React.ForwardRefExoticComponent<ChatMessageContentProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatMessageTimestampProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Time to display
+     */
+    time: Date | string;
+    /**
+     * Custom format function
+     */
+    format?: (time: Date) => string;
+}
+/**
+ * ChatMessageTimestamp
+ *
+ * Renders formatted timestamp below message content.
+ */
+declare const ChatMessageTimestamp: React.ForwardRefExoticComponent<ChatMessageTimestampProps & React.RefAttributes<HTMLSpanElement>>;
+interface ChatMessageThinkingProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Custom thinking label
+     */
+    label?: string;
+}
+/**
+ * ChatMessageThinking
+ *
+ * Animated thinking indicator for use inside ChatMessageContent.
+ */
+declare const ChatMessageThinking: React.ForwardRefExoticComponent<ChatMessageThinkingProps & React.RefAttributes<HTMLSpanElement>>;
+interface ChatMessageErrorProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Error message
+     */
+    message?: string;
+    /**
+     * Retry callback
+     */
+    onRetry?: () => void;
+}
+/**
+ * ChatMessageError
+ *
+ * Error display with optional retry button.
+ */
+declare const ChatMessageError: React.ForwardRefExoticComponent<ChatMessageErrorProps & React.RefAttributes<HTMLSpanElement>>;
+interface ChatMessageSimpleProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onError'> {
+    /**
+     * Message role
+     */
+    role: MessageRole;
+    /**
+     * Message status
+     * @default "complete"
+     */
+    status?: MessageStatus;
+    /**
+     * Static content (for complete status)
+     */
+    content?: string;
+    /**
+     * Stream source (for streaming status)
+     */
+    stream?: StreamTextProps['stream'];
+    /**
+     * Avatar image URL
+     */
+    avatar?: string;
+    /**
+     * Agent/user name
+     */
+    name?: string;
+    /**
+     * Timestamp
+     */
+    timestamp?: Date | string;
+    /**
+     * Thinking label
+     */
+    thinkingLabel?: string;
+    /**
+     * Error message
+     */
+    errorMessage?: string;
+    /**
+     * Stream callbacks
+     */
+    onComplete?: () => void;
+    onError?: (error: Error) => void;
+    onRetry?: () => void;
+}
+/**
+ * ChatMessageSimple
+ *
+ * Pre-composed ChatMessage for common use cases.
+ * Automatically handles thinking/streaming/complete/error states.
+ *
+ * For full customization, use the composable primitives instead.
+ */
+declare const ChatMessageSimple: React.ForwardRefExoticComponent<ChatMessageSimpleProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * MentionPopover - @mention agent selector with auto-positioning
+ *
+ * Popover component for selecting agents when typing @mention.
+ * Uses floating-ui for automatic positioning relative to anchor element.
+ *
+ * @example Basic usage with anchor ref
+ * ```tsx
+ * const anchorRef = useRef<HTMLTextAreaElement>(null)
+ *
+ * <textarea ref={anchorRef} />
+ *
+ * <MentionPopover
+ *   open={open}
+ *   anchorRef={anchorRef}
+ *   query={query}
+ *   agents={agents}
+ *   onSelect={(agent) => { insertMention(agent); setOpen(false) }}
+ *   onClose={() => setOpen(false)}
+ * />
+ * ```
+ *
+ * @example With virtual anchor (cursor position)
+ * ```tsx
+ * const [virtualAnchor, setVirtualAnchor] = useState<VirtualElement | null>(null)
+ *
+ * // On @ trigger, create virtual anchor at cursor
+ * setVirtualAnchor({
+ *   getBoundingClientRect: () => getCursorRect()
+ * })
+ *
+ * <MentionPopover
+ *   open={open}
+ *   virtualAnchor={virtualAnchor}
+ *   agents={agents}
+ *   onSelect={handleSelect}
+ * />
+ * ```
+ *
+ * @example Composable with custom item renderer
+ * ```tsx
+ * <MentionPopover open={open} anchorRef={ref} agents={agents} onSelect={handleSelect}>
+ *   {(filteredAgents) => filteredAgents.map(agent => (
+ *     <MentionItem key={agent.id} agent={agent}>
+ *       <CustomAgentCard agent={agent} />
+ *     </MentionItem>
+ *   ))}
+ * </MentionPopover>
+ * ```
+ */
+
+interface MentionPopoverProps {
+    /**
+     * Whether the popover is open
+     */
+    open: boolean;
+    /**
+     * Reference element for positioning
+     */
+    anchorRef?: React.RefObject<HTMLElement>;
+    /**
+     * Virtual anchor for custom positioning (e.g., cursor position)
+     */
+    virtualAnchor?: VirtualElement | null;
+    /**
+     * Search query (text after @)
+     */
+    query?: string;
+    /**
+     * Available agents to mention
+     */
+    agents: MentionAgent[];
+    /**
+     * Called when an agent is selected
+     */
+    onSelect?: (agent: MentionAgent) => void;
+    /**
+     * Called when popover should close
+     */
+    onClose?: () => void;
+    /**
+     * Maximum items to show
+     * @default 5
+     */
+    maxItems?: number;
+    /**
+     * Placement preference
+     * @default "bottom-start"
+     */
+    placement?: Placement;
+    /**
+     * Custom filter function
+     */
+    filter?: (agent: MentionAgent, query: string) => boolean;
+    /**
+     * Empty state message
+     * @default "No agents found"
+     */
+    emptyMessage?: string;
+    /**
+     * Custom render function for items
+     */
+    children?: (filteredAgents: MentionAgent[]) => React.ReactNode;
+    /**
+     * Additional className for popover
+     */
+    className?: string;
+}
+interface MentionItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /**
+     * Agent data
+     */
+    agent: MentionAgent;
+    /**
+     * Whether this item is highlighted/focused
+     */
+    highlighted?: boolean;
+    /**
+     * Called when item is selected
+     */
+    onSelect?: (agent: MentionAgent) => void;
+}
+interface MentionContextValue {
+    query: string;
+    highlightedIndex: number;
+    setHighlightedIndex: (index: number) => void;
+    onSelect: (agent: MentionAgent) => void;
+}
+declare function useMentionContext(): MentionContextValue;
+interface UseMentionPopoverOptions {
+    placement?: Placement;
+    offset?: number;
+}
+interface UseMentionPopoverReturn {
+    floating: UseFloatingReturn;
+    isPositioned: boolean;
+}
+/**
+ * Hook for manual floating control
+ * Use this when you need more control over positioning
+ */
+declare function useMentionPopover(anchorRef: React.RefObject<HTMLElement> | undefined, virtualAnchor: VirtualElement | null | undefined, options?: UseMentionPopoverOptions): UseMentionPopoverReturn;
+/**
+ * Individual mention item
+ */
+declare const MentionItem: React.ForwardRefExoticComponent<MentionItemProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * MentionPopover Component
+ *
+ * Floating popover for @mention agent selection.
+ * Features:
+ * - Auto-positioning with floating-ui
+ * - Keyboard navigation (↑/↓/Enter/Esc)
+ * - Composable item rendering
+ * - Virtual anchor support for cursor positioning
+ */
+declare const MentionPopover: React.ForwardRefExoticComponent<MentionPopoverProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ThinkingIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Custom label text
+     */
+    label?: string;
+    /**
+     * Multiple agents thinking in parallel
+     */
+    agents?: string[];
+    /**
+     * Animation variant
+     * @default "bounce"
+     */
+    variant?: ThinkingVariant;
+    /**
+     * Size of the indicator
+     * @default "md"
+     */
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Render inline (no wrapper div)
+     * @default false
+     */
+    inline?: boolean;
+    /**
+     * Color scheme
+     * @default "secondary" (gold/amber)
+     */
+    color?: 'primary' | 'secondary' | 'neutral';
+}
+/**
+ * Animated dots (default)
+ */
+declare function DotsAnimation({ size, color, }: {
+    size: 'sm' | 'md' | 'lg';
+    color: 'primary' | 'secondary' | 'neutral';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Bouncing dots
+ */
+declare function BounceAnimation({ size, color, }: {
+    size: 'sm' | 'md' | 'lg';
+    color: 'primary' | 'secondary' | 'neutral';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Wave animation (sequential height change)
+ * Uses animate-wave from Tailwind config (defined in @uix-ai/lucid-tokens)
+ */
+declare function WaveAnimation({ size, color, }: {
+    size: 'sm' | 'md' | 'lg';
+    color: 'primary' | 'secondary' | 'neutral';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Pulse ring
+ */
+declare function PulseAnimation({ size, color, }: {
+    size: 'sm' | 'md' | 'lg';
+    color: 'primary' | 'secondary' | 'neutral';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Spinner
+ */
+declare function SpinnerAnimation({ size, color, }: {
+    size: 'sm' | 'md' | 'lg';
+    color: 'primary' | 'secondary' | 'neutral';
+}): react_jsx_runtime.JSX.Element;
+/**
+ * ThinkingIndicator Component
+ *
+ * Flexible AI thinking state indicator with multiple animation variants.
+ * Uses sentient gold (secondary-500) color by default to represent
+ * AI's generative thinking process.
+ */
+declare const ThinkingIndicator: React.ForwardRefExoticComponent<ThinkingIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ToolResultProps {
+    /**
+     * Tool name
+     */
+    tool: string;
+    /**
+     * Execution status (extended to support approval workflow)
+     */
+    status: ToolStatus;
+    /**
+     * Tool output content
+     */
+    children?: React.ReactNode;
+    /**
+     * Whether the result is collapsed
+     */
+    collapsed?: boolean;
+    /**
+     * Callback when collapse state changes
+     */
+    onToggle?: () => void;
+    /**
+     * Error message (when status is 'error')
+     */
+    error?: string;
+    /**
+     * Callback when user approves tool execution
+     */
+    onApprove?: () => void;
+    /**
+     * Callback when user denies tool execution
+     */
+    onDeny?: (reason?: string) => void;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+/**
+ * ToolResult Component
+ *
+ * Displays the result of a tool/function call with support for
+ * approval workflows and extended status states.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <ToolResult tool="search" status="success">
+ *   Found 10 results...
+ * </ToolResult>
+ *
+ * // With error
+ * <ToolResult tool="code_execution" status="error" error="Timeout">
+ *   Execution failed
+ * </ToolResult>
+ *
+ * // With approval workflow
+ * <ToolResult
+ *   tool="delete_file"
+ *   status="approval-required"
+ *   onApprove={() => handleApprove()}
+ *   onDeny={(reason) => handleDeny(reason)}
+ * >
+ *   This will delete important_file.txt
+ * </ToolResult>
+ * ```
+ */
+declare function ToolResult({ tool, status, children, collapsed, onToggle, error, onApprove, onDeny, className, }: ToolResultProps): react_jsx_runtime.JSX.Element;
+
+interface Message {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: React.ReactNode;
+    avatar?: string;
+    name?: string;
+    timestamp?: string | Date;
+}
+interface MessageListProps {
+    /**
+     * List of messages to display
+     */
+    messages: Message[];
+    /**
+     * Custom message renderer
+     */
+    renderMessage?: (message: Message) => React.ReactNode;
+    /**
+     * Whether to auto-scroll to bottom on new messages
+     */
+    autoScroll?: boolean;
+    /**
+     * Throttle interval in milliseconds for scroll updates during streaming.
+     * Reduces re-renders when messages update frequently.
+     * Set to 0 or undefined to disable throttling.
+     * @default undefined (no throttling)
+     */
+    throttleMs?: number;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+/**
+ * MessageList Component
+ *
+ * Container for displaying a list of chat messages.
+ * Supports throttled scroll updates for better performance during streaming.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <MessageList
+ *   messages={messages}
+ *   autoScroll
+ * />
+ *
+ * // With throttle for streaming (recommended: 50-100ms)
+ * <MessageList
+ *   messages={messages}
+ *   autoScroll
+ *   throttleMs={50}
+ * />
+ * ```
+ */
+declare function MessageList({ messages, renderMessage, autoScroll, throttleMs, className, }: MessageListProps): react_jsx_runtime.JSX.Element;
+
+interface SourceBlockProps {
+    /**
+     * Source content from LucidBlock
+     */
+    source: SourceBlockContent;
+    /**
+     * Whether to show the excerpt/snippet
+     */
+    showExcerpt?: boolean;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+/**
+ * SourceBlock Component
+ *
+ * Displays a source/citation reference, commonly used in RAG applications
+ * to show where information was retrieved from.
+ *
+ * @example
+ * ```tsx
+ * // URL source
+ * <SourceBlock
+ *   source={{
+ *     sourceId: 'src-1',
+ *     sourceType: 'url',
+ *     title: 'React Documentation',
+ *     url: 'https://react.dev/learn'
+ *   }}
+ * />
+ *
+ * // Document source with excerpt
+ * <SourceBlock
+ *   source={{
+ *     sourceId: 'src-2',
+ *     sourceType: 'document',
+ *     title: 'Company Policy',
+ *     filename: 'policy.pdf',
+ *     mediaType: 'application/pdf',
+ *     excerpt: 'All employees must...'
+ *   }}
+ *   showExcerpt
+ * />
+ * ```
+ */
+declare function SourceBlock({ source, showExcerpt, className, }: SourceBlockProps): react_jsx_runtime.JSX.Element;
+/**
+ * Compact inline source citation
+ */
+declare function SourceCitation({ source, index, className, }: {
+    source: SourceBlockContent;
+    index?: number;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * List of sources, typically shown at the end of a response
+ */
+declare function SourceList({ sources, title, className, }: {
+    sources: SourceBlockContent[];
+    title?: string;
+    className?: string;
+}): react_jsx_runtime.JSX.Element | null;
+
+interface ChatWindowContextValue {
+    status: ChatWindowStatus;
+    agent: ChatWindowAgent | null;
+}
+declare function useChatWindowContext(): ChatWindowContextValue;
+
+interface ChatWindowProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Current agent */
+    agent?: ChatWindowAgent | null;
+    /** Window status */
+    status?: ChatWindowStatus;
+}
+declare const ChatWindow: React.ForwardRefExoticComponent<ChatWindowProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatWindowHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Override agent from context */
+    agent?: ChatWindowAgent;
+}
+declare const ChatWindowHeader: React.ForwardRefExoticComponent<ChatWindowHeaderProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatWindowHeaderAvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    agent: ChatWindowAgent;
+}
+declare const ChatWindowHeaderAvatar: React.ForwardRefExoticComponent<ChatWindowHeaderAvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatWindowHeaderInfoProps extends React.HTMLAttributes<HTMLDivElement> {
+    agent: ChatWindowAgent;
+}
+declare const ChatWindowHeaderInfo: React.ForwardRefExoticComponent<ChatWindowHeaderInfoProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatWindowHeaderActionsProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const ChatWindowHeaderActions: React.ForwardRefExoticComponent<ChatWindowHeaderActionsProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatWindowMessagesProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Auto scroll to bottom */
+    autoScroll?: boolean;
+    /** Throttle scroll in ms */
+    throttleMs?: number;
+}
+declare const ChatWindowMessages: React.ForwardRefExoticComponent<ChatWindowMessagesProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatWindowInputProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Submit callback */
+    onSend?: (message: string) => void;
+    /** Input value (controlled) */
+    value?: string;
+    /** Value change callback */
+    onValueChange?: (value: string) => void;
+    /** Is disabled */
+    disabled?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+}
+declare const ChatWindowInput: React.ForwardRefExoticComponent<ChatWindowInputProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatWindowEmptyProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** Title text */
+    title?: string;
+    /** Description text */
+    description?: string;
+}
+declare const ChatWindowEmpty: React.ForwardRefExoticComponent<ChatWindowEmptyProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatListContextValue {
+    activeId: string | null;
+    onSelect: (id: string) => void;
+}
+declare function useChatListContext(): ChatListContextValue;
+
+interface ChatListProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** Current active conversation ID */
+    activeId?: string | null;
+    /** Conversation select callback */
+    onSelect?: (id: string) => void;
+}
+declare const ChatList: React.ForwardRefExoticComponent<ChatListProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatListHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Title text */
+    title?: string;
+}
+declare const ChatListHeader: React.ForwardRefExoticComponent<ChatListHeaderProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatListSearchProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    /** Value change callback */
+    onChange?: (value: string) => void;
+}
+declare const ChatListSearch: React.ForwardRefExoticComponent<ChatListSearchProps & React.RefAttributes<HTMLInputElement>>;
+interface ChatListGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Group label */
+    label?: string;
+}
+declare const ChatListGroup: React.ForwardRefExoticComponent<ChatListGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatListItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Conversation data */
+    conversation: Conversation;
+}
+declare const ChatListItem: React.ForwardRefExoticComponent<ChatListItemProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatListItemAvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Agent data */
+    agent?: ConversationAgent;
+}
+declare const ChatListItemAvatar: React.ForwardRefExoticComponent<ChatListItemAvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatListItemContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Conversation data */
+    conversation: Conversation;
+}
+declare const ChatListItemContent: React.ForwardRefExoticComponent<ChatListItemContentProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatListItemBadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** Unread count */
+    count: number;
+}
+declare const ChatListItemBadge: React.ForwardRefExoticComponent<ChatListItemBadgeProps & React.RefAttributes<HTMLSpanElement>>;
+interface ChatListEmptyProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** Title text */
+    title?: string;
+    /** Description text */
+    description?: string;
+}
+declare const ChatListEmpty: React.ForwardRefExoticComponent<ChatListEmptyProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * AgentChat - One-component AI chat interface
+ *
+ * The fastest way to add an AI conversation UI to your app.
+ * Combines ChatWindow, MessageList, and ChatInput into a single
+ * pre-composed component that works out of the box.
+ *
+ * @example Minimal usage (3 lines)
+ * ```tsx
+ * import { AgentChat } from '@uix-ai/agent'
+ *
+ * <AgentChat
+ *   conversations={conversations}
+ *   onSend={(text) => sendToAgent(text)}
+ * />
+ * ```
+ *
+ * @example With agent info
+ * ```tsx
+ * <AgentChat
+ *   conversations={conversations}
+ *   agent={{ id: '1', name: 'Claude', status: 'online' }}
+ *   onSend={(text) => sendToAgent(text)}
+ *   onStop={() => abortController.abort()}
+ * />
+ * ```
+ *
+ * @example Full integration with AG-UI
+ * ```tsx
+ * import { AgentChat } from '@uix-ai/agent'
+ * import { useAGUI } from '@uix-ai/adapter-agui/react'
+ *
+ * function App() {
+ *   const { conversations, status, send } = useAGUI({ url: '/api/agent' })
+ *   return <AgentChat conversations={conversations} status={status} onSend={send} />
+ * }
+ * ```
+ *
+ * @example Full integration with Vercel AI SDK
+ * ```tsx
+ * import { AgentChat } from '@uix-ai/agent'
+ * import { useVercelChat } from '@uix-ai/adapter-vercel/react'
+ *
+ * function App() {
+ *   const chat = useVercelChat()
+ *   return <AgentChat conversations={chat.conversations} status={chat.status} onSend={chat.send} />
+ * }
+ * ```
+ */
+
+interface AgentChatProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onError'> {
+    /**
+     * UIX LucidConversation array - the universal format from any adapter.
+     * Can come from @uix-ai/adapter-vercel, @uix-ai/adapter-agui, or any custom source.
+     */
+    conversations: LucidConversation[];
+    /**
+     * Agent information displayed in the header.
+     * Omit to hide the header.
+     */
+    agent?: ChatWindowAgent | null;
+    /**
+     * Chat status - controls input state and submit button behavior.
+     * @default 'idle'
+     */
+    status?: ChatWindowStatus;
+    /**
+     * Called when the user sends a message.
+     */
+    onSend?: (message: string) => void;
+    /**
+     * Called when the user clicks stop during streaming.
+     */
+    onStop?: () => void;
+    /**
+     * Called when the user clicks retry on an error message.
+     */
+    onRetry?: () => void;
+    /**
+     * Called when the user approves a tool execution.
+     */
+    onToolApprove?: (toolCallId: string) => void;
+    /**
+     * Called when the user denies a tool execution.
+     */
+    onToolDeny?: (toolCallId: string, reason?: string) => void;
+    /**
+     * Input placeholder text.
+     * @default '输入消息...'
+     */
+    placeholder?: string;
+    /**
+     * Empty state configuration.
+     */
+    emptyState?: {
+        icon?: React.ReactNode;
+        title?: string;
+        description?: string;
+    };
+    /**
+     * Custom block renderer. Return null to use default rendering.
+     */
+    renderBlock?: (block: LucidBlock, conversation: LucidConversation) => React.ReactNode | null;
+    /**
+     * Whether to show the header.
+     * @default true if agent is provided
+     */
+    showHeader?: boolean;
+    /**
+     * Auto scroll to bottom on new messages.
+     * @default true
+     */
+    autoScroll?: boolean;
+}
+declare const AgentChat: React.ForwardRefExoticComponent<AgentChatProps & React.RefAttributes<HTMLDivElement>>;
+
+declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Format a date as relative time string
+ * @param date - Date object or ISO string
+ * @returns Relative time string (e.g., "刚刚", "5分钟前", "2小时前")
+ */
+declare function formatRelativeTime(date: Date | string): string;
+
+export { AgentAvatar, type AgentAvatarProps, AgentChat, type AgentChatProps, Avatar, type AvatarAnimationStatus, AvatarFallback, type AvatarFallbackProps, AvatarGroup, type AvatarGroupProps, AvatarImage, type AvatarImageProps, type AvatarProps, type AvatarRole, type AvatarSize, type AvatarStatus, AvatarStatusIndicator, type AvatarStatusIndicatorProps, type AvatarVariant$1 as AvatarVariant, BounceAnimation, ChatBubble, type ChatBubbleProps, ChatInput, ChatInputButton, type ChatInputButtonProps, type ChatInputMentionItem, type ChatInputProps, ChatInputSubmit, type ChatInputSubmitProps, ChatInputTextarea, type ChatInputTextareaProps, ChatInputToolbar, type ChatInputToolbarProps, ChatInputTools, type ChatInputToolsProps, ChatList, ChatListEmpty, type ChatListEmptyProps, ChatListGroup, type ChatListGroupProps, ChatListHeader, type ChatListHeaderProps, ChatListItem, ChatListItemAvatar, type ChatListItemAvatarProps, ChatListItemBadge, type ChatListItemBadgeProps, ChatListItemContent, type ChatListItemContentProps, type ChatListItemProps, type ChatListProps, ChatListSearch, type ChatListSearchProps, ChatMessage, ChatMessageAvatar, type ChatMessageAvatarProps, ChatMessageContent, type ChatMessageContentProps, ChatMessageError, type ChatMessageErrorProps, type ChatMessageProps, ChatMessageSimple, type ChatMessageSimpleProps, ChatMessageThinking, type ChatMessageThinkingProps, ChatMessageTimestamp, type ChatMessageTimestampProps, type ChatStatus, ChatWindow, type ChatWindowAgent, ChatWindowEmpty, type ChatWindowEmptyProps, ChatWindowHeader, ChatWindowHeaderActions, type ChatWindowHeaderActionsProps, ChatWindowHeaderAvatar, type ChatWindowHeaderAvatarProps, ChatWindowHeaderInfo, type ChatWindowHeaderInfoProps, type ChatWindowHeaderProps, ChatWindowInput, type ChatWindowInputProps, ChatWindowMessages, type ChatWindowMessagesProps, type ChatWindowProps, type ChatWindowStatus, type Conversation, type ConversationAgent, DotsAnimation, type ImageLoadingStatus$1 as ImageLoadingStatus, type MentionAgent, MentionItem, type MentionItemProps, MentionPopover, type MentionPopoverProps, type Message, MessageAvatar, type MessageAvatarProps, MessageList, type MessageListProps, type MessageRole, type MessageStatus, type PresenceStatus, PulseAnimation, SourceBlock, type SourceBlockProps, SourceCitation, SourceList, SpinnerAnimation, StreamCursor, type StreamSource, StreamText, type StreamTextProps, ThinkingIndicator, type ThinkingIndicatorProps, type ThinkingVariant, ToolResult, type ToolResultProps, type UseAsyncStreamOptions, type UseAsyncStreamResult, type UseMentionPopoverOptions, type UseMentionPopoverReturn, type UseTypingAnimationOptions, type UseTypingAnimationResult, WaveAnimation, sizeClasses as avatarSizeClasses, variantClasses as avatarVariantClasses, cn, formatRelativeTime, presenceColors, roleColors, roleSymbols, roleToVariant, statusAnimations, useAsyncStream, useChatListContext, useChatMessageContext, useChatWindowContext, useImageLoadingStatus, useMentionContext, useMentionPopover, useTypingAnimation };