@yushaw/sanqian-chat 0.1.1 → 0.2.1

package/dist/renderer/index.d.ts

@@ -1,8 +1,9 @@
 import { HitlInterruptPayload, HitlResponse, SanqianSDK } from '@yushaw/sanqian-sdk';
-export { ChatStreamEvent, HitlInterruptPayload, HitlInterruptType, HitlResponse, HitlRiskLevel, ChatMessage as SdkChatMessage, ConversationDetail as SdkConversationDetail, ConversationInfo as SdkConversationInfo, ToolCall as SdkToolCall } from '@yushaw/sanqian-sdk';
+export { HitlInterruptPayload, HitlInterruptType, HitlResponse, HitlRiskLevel, ChatMessage as SdkChatMessage, ConversationDetail as SdkConversationDetail, ConversationInfo as SdkConversationInfo, ToolCall as SdkToolCall } from '@yushaw/sanqian-sdk';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ReactNode } from 'react';
+import { ReactNode, RefObject, CSSProperties } from 'react';
+export { ChatMessage, ChatStreamEvent, SDKConfig, SanqianSDK, ToolDefinition } from '@yushaw/sanqian-sdk/browser';
 
 /**
  * @yushaw/sanqian-chat Core Types
@@ -10,16 +11,80 @@ import { ReactNode } from 'react';
  * Re-exports SDK types + chat-specific types
  */
 
-type MessageRole = 'user' | 'assistant' | 'system';
+type Locale = 'en' | 'zh';
+interface ChatUiStrings {
+    inputPlaceholder: string;
+    inputSend: string;
+    inputStop: string;
+    chat: string;
+    recentChats: string;
+    newChat: string;
+    selectConversation: string;
+    noHistory: string;
+    loadMore: string;
+    today: string;
+    yesterday: string;
+    delete: string;
+    dismiss: string;
+    close: string;
+    pin: string;
+    unpin: string;
+    conversationUntitled: string;
+    conversationDeleteConfirm: string;
+    messageThinking: string;
+    messageError: string;
+    messageLoading: string;
+    connectionConnecting: string;
+    connectionConnected: string;
+    connectionDisconnected: string;
+    connectionReconnecting: string;
+    connectionError: string;
+    steps: string;
+    executing: string;
+    thinking: string;
+    thinkingStreaming: string;
+    thinkingPaused: string;
+    hitlApprove: string;
+    hitlReject: string;
+    hitlSubmit: string;
+    hitlCancel: string;
+    hitlRememberChoice: string;
+    hitlRequiredField: string;
+    hitlTimeoutIn: string;
+    hitlSeconds: string;
+    hitlExecuteTool: string;
+    hitlToolLabel: string;
+    hitlArgsLabel: string;
+    hitlDefaultPrefix: string;
+    hitlEnterResponse: string;
+    hitlApprovalRequest: string;
+    hitlInputRequest: string;
+    hitlApprovalRequired: string;
+    hitlInputRequired: string;
+}
+type ChatThemeMode = 'light' | 'dark' | 'auto';
+type ChatFontSize = 'small' | 'normal' | 'large' | 'extra-large';
+interface ChatUiConfigSerializable {
+    logo?: string;
+    theme?: ChatThemeMode;
+    /** Font size scale: small (13px), normal (14px), large (16px), extra-large (18px) */
+    fontSize?: ChatFontSize;
+    accentColor?: string;
+    locale?: Locale;
+    strings?: Partial<ChatUiStrings>;
+    alwaysOnTop?: boolean;
+}
+type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
 type ToolCallStatus = 'pending' | 'running' | 'completed' | 'error' | 'cancelled';
 type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
 type ConnectionErrorCode = 'NOT_FOUND' | 'CONNECTION_FAILED' | 'WEBSOCKET_ERROR' | 'AUTH_ERROR' | 'TIMEOUT' | 'UNKNOWN';
 /** Tool call for UI rendering (extended from SDK) */
 interface ToolCall {
-    id: string;
+    id?: string;
     name: string;
-    arguments: Record<string, unknown>;
-    status: ToolCallStatus;
+    args?: Record<string, unknown>;
+    argsRaw?: string;
+    status?: ToolCallStatus;
     result?: unknown;
     error?: string;
 }
@@ -30,9 +95,11 @@ interface MessageBlock {
     timestamp: number;
     toolName?: string;
     toolArgs?: Record<string, unknown>;
+    toolArgsRaw?: string;
     toolCallId?: string;
     toolStatus?: ToolCallStatus;
     isIntermediate?: boolean;
+    fromSubagent?: boolean;
 }
 /** Chat message for UI rendering */
 interface ChatMessage {
@@ -45,8 +112,12 @@ interface ChatMessage {
     thinking?: string;
     currentThinking?: string;
     isThinkingStreaming?: boolean;
+    isThinkingPaused?: boolean;
+    isToolCallsStreaming?: boolean;
     blocks?: MessageBlock[];
+    finalContent?: string;
     isComplete?: boolean;
+    filePaths?: string[];
 }
 /** Conversation info for UI */
 interface ConversationInfo {
@@ -55,6 +126,7 @@ interface ConversationInfo {
     createdAt: string;
     updatedAt: string;
     messageCount: number;
+    agentId?: string | null;
 }
 interface ConversationDetail extends ConversationInfo {
     messages: ChatMessage[];
@@ -70,9 +142,21 @@ interface FloatingWindowConfig {
     position?: WindowPosition;
     width?: number;
     height?: number;
+    /** Minimum window width (default: 320) */
+    minWidth?: number;
+    /** Minimum window height (default: 420) */
+    minHeight?: number;
     alwaysOnTop?: boolean;
     showInTaskbar?: boolean;
     theme?: 'light' | 'dark' | 'system';
+    /** Optional UI config for renderer (serializable) */
+    uiConfig?: ChatUiConfigSerializable;
+    /** Persist size/position across sessions (stored under ~/.sanqian-chat) */
+    rememberWindowState?: boolean;
+    /** Optional storage key to avoid conflicts between apps */
+    windowStateKey?: string;
+    /** Optional full path for window state file */
+    windowStatePath?: string;
 }
 
 /**
@@ -84,6 +168,10 @@ interface FloatingWindowConfig {
 
 /** Stream event callback */
 type StreamEvent = {
+    type: 'start';
+    run_id: string;
+    conversationId?: string;
+} | {
     type: 'text';
     content: string;
 } | {
@@ -98,6 +186,16 @@ type StreamEvent = {
             arguments: string;
         };
     };
+} | {
+    type: 'tool_args_chunk';
+    tool_call_id: string;
+    tool_name?: string;
+    chunk: string;
+} | {
+    type: 'tool_args';
+    tool_call_id: string;
+    tool_name?: string;
+    args: Record<string, unknown>;
 } | {
     type: 'tool_result';
     tool_call_id: string;
@@ -114,6 +212,9 @@ type StreamEvent = {
     interrupt_type: string;
     interrupt_payload: HitlInterruptData;
     run_id?: string;
+} | {
+    type: 'cancelled';
+    run_id?: string;
 };
 /** Message to send */
 interface SendMessage {
@@ -138,7 +239,9 @@ interface ChatAdapter {
         messageLimit?: number;
     }): Promise<ConversationDetail>;
     deleteConversation(id: string): Promise<void>;
-    chatStream(messages: SendMessage[], conversationId: string | undefined, onEvent: (event: StreamEvent) => void): Promise<{
+    chatStream(messages: SendMessage[], conversationId: string | undefined, onEvent: (event: StreamEvent) => void, options?: {
+        agentId?: string | null;
+    }): Promise<{
         cancel: () => void;
     }>;
     sendHitlResponse?(response: HitlResponse, runId?: string): void;
@@ -151,8 +254,47 @@ interface SdkAdapterConfig {
     /** Agent ID getter */
     getAgentId: () => string | null;
 }
+/** Simple chat adapter config (no SDK knowledge required) */
+interface ChatAdapterConfig {
+    /** App name for registration */
+    appName: string;
+    /** App version */
+    appVersion: string;
+    /** Agent ID to chat with */
+    agentId: string;
+    /** Whether to persist conversation history (default: false) */
+    persistHistory?: boolean;
+    /** Tools to expose to the agent */
+    tools?: Array<{
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+        handler?: (args: Record<string, unknown>) => Promise<unknown>;
+    }>;
+}
+/**
+ * Create a chat adapter with simple config (recommended for most use cases)
+ *
+ * This is the easiest way to integrate with Sanqian. Just provide your app info
+ * and agent ID, and the adapter handles SDK lifecycle automatically.
+ *
+ * @example
+ * ```typescript
+ * const adapter = createChatAdapter({
+ *   appName: 'my-app',
+ *   appVersion: '1.0.0',
+ *   agentId: 'assistant',
+ * });
+ *
+ * <CompactChat adapter={adapter} />
+ * ```
+ */
+declare function createChatAdapter(config: ChatAdapterConfig): ChatAdapter;
 /**
  * Create adapter that wraps @yushaw/sanqian-sdk
+ *
+ * Use this when you need more control over the SDK instance.
+ * For simpler usage, prefer `createChatAdapter()`.
  */
 declare function createSdkAdapter(config: SdkAdapterConfig): ChatAdapter;
 
@@ -209,7 +351,12 @@ declare function useTheme(): ThemeContextValue;
  */
 declare function useStandaloneTheme(defaultTheme?: ThemeMode): ThemeContextValue;
 
-type Locale = 'en' | 'zh';
+interface ChatUiConfig extends Omit<ChatUiConfigSerializable, 'logo'> {
+    logo?: string | ReactNode;
+    onClose?: () => void;
+    onPin?: (pinned: boolean) => void;
+}
+
 interface Translations {
     hitl: {
         approvalRequired: string;
@@ -268,6 +415,107 @@ declare function useStandaloneI18n(defaultLocale?: Locale): I18nContextValue;
  */
 declare function getTranslations(locale: Locale): Translations;
 
+/**
+ * useConnection Hook
+ *
+ * Manages connection state with the backend.
+ */
+
+interface UseConnectionOptions {
+    /** Chat adapter */
+    adapter: ChatAdapter;
+    /** Auto-connect on mount */
+    autoConnect?: boolean;
+    /** Called when connection status changes */
+    onStatusChange?: (status: ConnectionStatus, error?: string, errorCode?: ConnectionErrorCode) => void;
+}
+interface UseConnectionReturn {
+    /** Current connection status */
+    status: ConnectionStatus;
+    /** Connection error message (if any) */
+    error: string | undefined;
+    /** Connection error code (if any) */
+    errorCode: ConnectionErrorCode | undefined;
+    /** Whether currently connected */
+    isConnected: boolean;
+    /** Whether currently connecting/reconnecting */
+    isConnecting: boolean;
+    /** Connect to the backend */
+    connect: () => Promise<void>;
+    /** Disconnect from the backend */
+    disconnect: () => Promise<void>;
+}
+declare function useConnection(options: UseConnectionOptions): UseConnectionReturn;
+
+/**
+ * useConversations Hook
+ *
+ * Manages conversation history list with loading and delete operations.
+ */
+
+interface UseConversationsOptions {
+    /** Chat adapter for backend communication */
+    adapter: ChatAdapter;
+    /** Number of conversations per page */
+    pageSize?: number;
+    /** Called when an error occurs */
+    onError?: (error: Error) => void;
+}
+interface UseConversationsReturn {
+    conversations: ConversationInfo[];
+    isLoading: boolean;
+    hasMore: boolean;
+    total: number;
+    error: string | null;
+    /** Whether last loadMore failed (for retry button) */
+    loadError: boolean;
+    loadConversations: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    deleteConversation: (id: string) => Promise<void>;
+    refresh: () => Promise<void>;
+}
+declare function useConversations(options: UseConversationsOptions): UseConversationsReturn;
+
+declare function useChatStyles(): void;
+
+/**
+ * useFocusPersistence Hook
+ *
+ * Restores focus to input when clicking empty areas in the chat container.
+ * Inspired by Slack's forceFocus pattern - always keep input ready for typing.
+ */
+
+interface UseFocusPersistenceOptions {
+    /** Container element ref */
+    containerRef: RefObject<HTMLElement | null>;
+    /** Input element ref (must have focus method) */
+    inputRef: RefObject<{
+        focus: () => void;
+    } | null>;
+    /** Skip focus restoration when this is true (e.g., HITL dialog open, history view) */
+    disabled?: boolean;
+}
+/**
+ * Hook that restores focus to input when clicking empty areas.
+ *
+ * @example
+ * ```tsx
+ * const containerRef = useRef<HTMLDivElement>(null);
+ * const inputRef = useRef<ChatInputHandle>(null);
+ *
+ * useFocusPersistence({
+ *   containerRef,
+ *   inputRef,
+ *   disabled: !!pendingInterrupt || showHistory,
+ * });
+ * ```
+ */
+declare function useFocusPersistence({ containerRef, inputRef, disabled, }: UseFocusPersistenceOptions): void;
+
+declare function useIpcUiConfig(): ChatUiConfigSerializable | null;
+
+declare function useResolvedUiConfig(config?: ChatUiConfig): ChatUiConfig | undefined;
+
 /**
  * IPC Adapter
  *
@@ -296,6 +544,41 @@ interface MessageBubbleProps {
 }
 declare const MessageBubble: react.NamedExoticComponent<MessageBubbleProps>;
 
+interface SanqianChatProps {
+    adapter: ChatAdapter;
+    placeholder?: string;
+    autoConnect?: boolean;
+    className?: string;
+    emptyState?: ReactNode;
+    onError?: (error: Error) => void;
+    onConversationChange?: (conversationId: string, title?: string) => void;
+    onStateChange?: (state: {
+        messages: ChatMessage[];
+        conversationId: string | null;
+    }) => void;
+    config?: ChatUiConfig;
+    logo?: string | ReactNode;
+}
+declare const SanqianChat: react.NamedExoticComponent<SanqianChatProps>;
+
+interface SanqianMessageListProps {
+    messages: ChatMessage[];
+    isLoading: boolean;
+    className?: string;
+    emptyState?: ReactNode;
+    onClickEmpty?: () => void;
+    onAtBottomChange?: (atBottom: boolean) => void;
+}
+interface SanqianMessageListHandle {
+    scrollToBottom: (behavior?: 'smooth' | 'auto', source?: string) => void;
+}
+declare const SanqianMessageList: react.ForwardRefExoticComponent<SanqianMessageListProps & react.RefAttributes<SanqianMessageListHandle>>;
+
+interface SanqianChatMessageProps {
+    message: ChatMessage;
+}
+declare const SanqianChatMessage: react.NamedExoticComponent<SanqianChatMessageProps>;
+
 interface ChatInputProps {
     onSend: (content: string) => void;
     onStop?: () => void;
@@ -303,17 +586,22 @@ interface ChatInputProps {
     disabled?: boolean;
     isStreaming?: boolean;
     isLoading?: boolean;
-    className?: string;
-    textareaClassName?: string;
-    sendButtonClassName?: string;
-    stopButtonClassName?: string;
-    sendButtonContent?: ReactNode;
-    stopButtonContent?: ReactNode;
+    sendLabel?: string;
+    stopLabel?: string;
     maxRows?: number;
     autoFocus?: boolean;
-    focusRef?: React.MutableRefObject<(() => void) | null>;
+    leftSlot?: ReactNode;
+    rightSlot?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+interface ChatInputHandle {
+    focus: () => void;
+    setValue: (text: string) => void;
+    getValue: () => string;
+    clear: () => void;
 }
-declare const ChatInput: react.NamedExoticComponent<ChatInputProps>;
+declare const ChatInput: react.MemoExoticComponent<react.ForwardRefExoticComponent<ChatInputProps & react.RefAttributes<ChatInputHandle>>>;
 
 interface FloatingChatProps {
     messages: ChatMessage[];
@@ -325,10 +613,11 @@ interface FloatingChatProps {
     onStopStreaming: () => void;
     onApproveHitl?: (remember?: boolean) => void;
     onRejectHitl?: (remember?: boolean) => void;
-    onHide?: () => void;
     className?: string;
     placeholder?: string;
     locale?: Locale;
+    config?: ChatUiConfig;
+    logo?: string | ReactNode;
     renderMessage?: (message: ChatMessage, index: number) => ReactNode;
     renderContent?: (content: string, isStreaming: boolean) => ReactNode;
     renderHitl?: (interrupt: HitlInterruptData, onApprove: () => void, onReject: () => void) => ReactNode;
@@ -337,4 +626,306 @@ interface FloatingChatProps {
 }
 declare const FloatingChat: react.NamedExoticComponent<FloatingChatProps>;
 
-export { type ChatAdapter, ChatInput, type ChatInputProps, type ChatMessage, type ConnectionErrorCode, type ConnectionStatus, type ConversationDetail, type ConversationInfo, FloatingChat, type FloatingChatProps, type FloatingWindowConfig, type HitlInterruptData, I18nProvider, type I18nProviderProps, type Locale, type MessageBlock, MessageBubble, type MessageBubbleProps, MessageList, type MessageListProps, type MessageRole, type ResolvedTheme, type SdkAdapterConfig, type SendMessage, type StreamEvent, type ThemeMode, ThemeProvider, type ThemeProviderProps, type ToolCall, type ToolCallStatus, type Translations, type UseChatOptions, type UseChatReturn, type WindowPosition, createIpcAdapter, createSdkAdapter, getTranslations, useChat, useI18n, useStandaloneI18n, useStandaloneTheme, useTheme };
+interface IntermediateStepsProps {
+    /** Message blocks to display */
+    blocks: MessageBlock[];
+    /** Additional CSS classes */
+    className?: string;
+    /** Default expanded state (default: false) */
+    defaultExpanded?: boolean;
+    /** Localized strings */
+    strings?: {
+        steps?: string;
+    };
+}
+interface StreamingTimelineProps {
+    blocks: MessageBlock[];
+    currentThinking?: string;
+    isThinkingStreaming?: boolean;
+    isToolCallsStreaming?: boolean;
+    isComplete?: boolean;
+    className?: string;
+    strings?: {
+        steps?: string;
+        executing?: string;
+    };
+}
+interface ThinkingSectionProps {
+    thinking: string;
+    currentThinking?: string;
+    isStreaming?: boolean;
+    isPaused?: boolean;
+    isComplete?: boolean;
+    className?: string;
+    strings?: {
+        thinkingStreaming?: string;
+        thinkingPaused?: string;
+        thinking?: string;
+    };
+}
+/**
+ * Thinking section component with streaming support
+ * Three states:
+ * 1. Streaming: show currentThinking, auto-expand, animated loading symbol
+ * 2. Paused: show currentThinking, stay expanded, "已思考" (waiting for next round)
+ * 3. Finished: show full thinking, collapsed by default, "思考过程"
+ */
+declare const ThinkingSection: react.NamedExoticComponent<ThinkingSectionProps>;
+declare const IntermediateSteps: react.NamedExoticComponent<IntermediateStepsProps>;
+declare const StreamingTimeline: react.NamedExoticComponent<StreamingTimelineProps>;
+
+interface HitlCardProps {
+    /** Interrupt data from backend */
+    interrupt: HitlInterruptData;
+    /** Called when user approves (for approval_request) */
+    onApprove?: (remember?: boolean) => void;
+    /** Called when user rejects (for approval_request) */
+    onReject?: (remember?: boolean) => void;
+    /** Called when user submits input (for user_input_request) */
+    onSubmit?: (response: HitlResponse) => void;
+    /** Called when user cancels */
+    onCancel?: () => void;
+    /** Whether in dark mode */
+    isDarkMode?: boolean;
+    /** Custom strings for i18n */
+    strings?: {
+        approve?: string;
+        reject?: string;
+        submit?: string;
+        cancel?: string;
+        rememberChoice?: string;
+        requiredField?: string;
+        timeoutIn?: string;
+        seconds?: string;
+        executeTool?: string;
+        toolLabel?: string;
+        argsLabel?: string;
+        defaultPrefix?: string;
+        enterResponse?: string;
+        approvalRequest?: string;
+        inputRequest?: string;
+    };
+}
+declare const HitlCard: react.NamedExoticComponent<HitlCardProps>;
+
+interface HistoryListProps {
+    /** List of conversations */
+    conversations: ConversationInfo[];
+    /** Currently selected conversation ID */
+    selectedId?: string | null;
+    /** Whether loading */
+    isLoading?: boolean;
+    /** Whether there are more items to load */
+    hasMore?: boolean;
+    /** Whether last load failed */
+    loadError?: boolean;
+    /** Called when a conversation is selected */
+    onSelect: (id: string) => void;
+    /** Called when a conversation should be deleted */
+    onDelete: (id: string) => void;
+    /** Called when load more is triggered */
+    onLoadMore?: () => void;
+    /** Dark mode */
+    isDarkMode?: boolean;
+    /** Localized strings */
+    strings?: {
+        noHistory?: string;
+        loadMore?: string;
+        today?: string;
+        yesterday?: string;
+        delete?: string;
+    };
+}
+declare const HistoryList: react.NamedExoticComponent<HistoryListProps>;
+
+declare function resolveChatStrings(locale?: Locale, overrides?: Partial<ChatUiStrings>): ChatUiStrings;
+
+type AlertType = 'warning' | 'error';
+interface AlertAction {
+    /** Action label */
+    label: string;
+    /** Action handler */
+    onClick: () => void;
+}
+interface AlertBannerProps {
+    /** Alert type - determines styling */
+    type: AlertType;
+    /** Alert message content */
+    message: string | ReactNode;
+    /** Optional action button */
+    action?: AlertAction;
+    /** Optional dismiss handler - shows dismiss button when provided */
+    onDismiss?: () => void;
+    /** Additional class names */
+    className?: string;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Max lines before truncating (default: 3) */
+    maxLines?: number;
+    /** Localized strings */
+    strings?: {
+        collapse?: string;
+        expand?: string;
+    };
+}
+declare const AlertBanner: react.NamedExoticComponent<AlertBannerProps>;
+
+/** Alert configuration for displaying warnings/errors above input */
+interface AlertConfig {
+    type: AlertType;
+    message: string;
+    action?: AlertAction;
+    dismissible?: boolean;
+}
+interface CompactChatProps {
+    /** Chat adapter for backend communication */
+    adapter: ChatAdapter;
+    /** UI configuration */
+    config?: ChatUiConfig;
+    /** Logo override (takes precedence over config.logo) */
+    logo?: string | ReactNode;
+    /** Input placeholder */
+    placeholder?: string;
+    /** Whether to auto-connect on mount */
+    autoConnect?: boolean;
+    /** Called when an error occurs */
+    onError?: (error: Error) => void;
+    /** Called when a message is received (for session tracking) */
+    onMessageReceived?: (message: ChatMessage) => void;
+    /** Called when loading state changes */
+    onLoadingChange?: (isLoading: boolean) => void;
+    /** Called when chat state changes (messages, conversationId) */
+    onStateChange?: (state: {
+        messages: ChatMessage[];
+        conversationId: string | null;
+    }) => void;
+    /** Header content (left side) */
+    headerLeft?: ReactNode;
+    /** Header content (right side) */
+    headerRight?: ReactNode;
+    /** Whether to hide header */
+    hideHeader?: boolean;
+    /** Whether to hide input area (for custom external input) */
+    hideInput?: boolean;
+    /** Container element for rendering input via Portal */
+    inputPortalContainer?: HTMLElement | null;
+    /** Ref to expose sendMessage function for external input */
+    sendMessageRef?: React.MutableRefObject<((message: string) => void) | null>;
+    /** Ref to expose newConversation function */
+    newConversationRef?: React.MutableRefObject<(() => void) | null>;
+    /** Ref to expose focusInput function */
+    focusInputRef?: React.MutableRefObject<(() => void) | null>;
+    /** Ref to expose setText function (for filling input externally) */
+    setTextRef?: React.MutableRefObject<((text: string) => void) | null>;
+    /** Custom message renderer */
+    renderMessage?: (message: ChatMessage) => ReactNode;
+    /** Empty state content (when no messages) */
+    emptyState?: ReactNode;
+    /** Additional class name */
+    className?: string;
+    /**
+     * Dark mode.
+     * @deprecated Use config.theme instead.
+     */
+    isDarkMode?: boolean;
+    /** Localized strings */
+    strings?: Partial<ChatUiStrings>;
+    /** Custom alert to display above input (overrides default connection/error alerts) */
+    alert?: AlertConfig | null;
+    /** Callback when alert is dismissed */
+    onAlertDismiss?: () => void;
+    /** Function to get error message from error code (for i18n) */
+    getErrorMessage?: (errorCode: string) => string;
+    /** Use floating window container style (for transparent Electron windows) */
+    floating?: boolean;
+}
+declare const CompactChat: react.NamedExoticComponent<CompactChatProps>;
+
+/**
+ * Tool Arguments Display Component
+ *
+ * Displays tool call arguments in a compact, Python kwargs-like format.
+ * No JSON braces, uses indentation and bullet points for nested structures.
+ *
+ * Features:
+ * - Python kwargs-style display (key=value)
+ * - Recursive nested object/array rendering
+ * - Smart inline vs multi-line formatting
+ * - Theme-aware using CSS variables
+ */
+interface ToolArgumentsDisplayProps {
+    /** Arguments object to display */
+    args: Record<string, unknown>;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * Displays tool arguments in Python kwargs style.
+ *
+ * @example
+ * <ToolArgumentsDisplay
+ *   args={{ file_path: "/path/to/file", content: "Hello" }}
+ * />
+ * // Renders:
+ * // file_path = "/path/to/file"
+ * // content = "Hello"
+ */
+declare const ToolArgumentsDisplay: react.NamedExoticComponent<ToolArgumentsDisplayProps>;
+
+interface MarkdownRendererProps {
+    /** Markdown content to render */
+    content: string;
+    /** Whether content is still streaming */
+    isStreaming?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Custom component overrides */
+    components?: {
+        /** Custom link renderer */
+        a?: React.ComponentType<{
+            href?: string;
+            children?: ReactNode;
+        }>;
+        /** Custom code block renderer */
+        code?: React.ComponentType<{
+            className?: string;
+            children?: ReactNode;
+        }>;
+        /** Custom paragraph renderer */
+        p?: React.ComponentType<{
+            children?: ReactNode;
+        }>;
+    };
+    /** Callback when a link is clicked */
+    onLinkClick?: (href: string, event: React.MouseEvent) => void;
+}
+declare const MarkdownRenderer: react.NamedExoticComponent<MarkdownRendererProps>;
+
+/**
+ * Inject chat styles into the document.
+ *
+ * Style modes:
+ * - 'safe' (default): CSS variables + component styles + Tailwind utilities.
+ *   No global resets (preflight). Safe for third-party integration.
+ * - 'full': Complete styles including Tailwind CSS preflight.
+ *   Use this for standalone windows where you control the entire page.
+ * - false: Disable all style injection.
+ *
+ * Configure via:
+ * - window.__SANQIAN_CHAT_STYLE_MODE__ = 'full' | 'safe' | false
+ * - window.__SANQIAN_CHAT_DISABLE_STYLES__ = true (legacy, same as 'false')
+ *
+ * Or import CSS directly:
+ * - '@yushaw/sanqian-chat/renderer/styles/safe.css' (no preflight)
+ * - '@yushaw/sanqian-chat/renderer/styles/chat.css' (full with preflight)
+ */
+declare function ensureChatBaseStyles(): void;
+/**
+ * Inject full chat styles including Tailwind preflight.
+ * Use this for standalone windows where you control the entire page.
+ *
+ * @deprecated Use window.__SANQIAN_CHAT_STYLE_MODE__ = 'full' instead
+ */
+declare function ensureFullChatStyles(): void;
+
+export { type AlertAction, AlertBanner, type AlertBannerProps, type AlertConfig, type AlertType, type ChatAdapter, type ChatAdapterConfig, type ChatFontSize, ChatInput, type ChatInputHandle, type ChatInputProps, type ChatThemeMode, type ChatUiConfig, type ChatUiConfigSerializable, type ChatUiStrings, CompactChat, type CompactChatProps, type ConnectionErrorCode, type ConnectionStatus, type ConversationDetail, type ConversationInfo, FloatingChat, type FloatingChatProps, type FloatingWindowConfig, HistoryList, type HistoryListProps, HitlCard, type HitlCardProps, type HitlInterruptData, I18nProvider, type I18nProviderProps, IntermediateSteps, type IntermediateStepsProps, type Locale, MarkdownRenderer, type MarkdownRendererProps, type MessageBlock, MessageBubble, type MessageBubbleProps, MessageList, type MessageListProps, type MessageRole, type ResolvedTheme, SanqianChat, SanqianChatMessage, type SanqianChatMessageProps, type SanqianChatProps, SanqianMessageList, type SanqianMessageListHandle, type SanqianMessageListProps, type SdkAdapterConfig, type SendMessage, type StreamEvent, StreamingTimeline, type StreamingTimelineProps, type ThemeMode, ThemeProvider, type ThemeProviderProps, ThinkingSection, type ThinkingSectionProps, ToolArgumentsDisplay, type ToolArgumentsDisplayProps, type ToolCall, type ToolCallStatus, type Translations, type UseChatOptions, type UseChatReturn, type UseConnectionOptions, type UseConnectionReturn, type UseConversationsOptions, type UseConversationsReturn, type UseFocusPersistenceOptions, type WindowPosition, createChatAdapter, createIpcAdapter, createSdkAdapter, ensureChatBaseStyles, ensureFullChatStyles, getTranslations, resolveChatStrings, useChat, useChatStyles, useConnection, useConversations, useFocusPersistence, useI18n, useIpcUiConfig, useResolvedUiConfig, useStandaloneI18n, useStandaloneTheme, useTheme };