@gendive/chatllm 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1099 @@
+/**
+ * Core types for devdive-chatLLM
+ */
+type ProviderType = 'openai' | 'anthropic' | 'google' | 'naver' | 'ollama';
+interface ProviderConfigs {
+    openai?: OpenAIConfig;
+    anthropic?: AnthropicConfig;
+    google?: GoogleConfig;
+    naver?: NaverConfig;
+    ollama?: OllamaConfig;
+}
+interface OpenAIConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface AnthropicConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface GoogleConfig {
+    apiKey: string;
+}
+interface NaverConfig {
+    apiKey: string;
+    apiGatewayKey: string;
+    baseUrl?: string;
+}
+interface OllamaConfig {
+    baseUrl?: string;
+}
+type Role = 'system' | 'user' | 'assistant' | 'tool';
+interface Message {
+    id: string;
+    role: Role;
+    content: string;
+    provider?: ProviderType;
+    model?: string;
+    toolCalls?: ToolCall[];
+    toolCallId?: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+interface ToolResult {
+    toolCallId: string;
+    result: unknown;
+    error?: string;
+}
+interface ParameterSchema {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    enum?: string[];
+    items?: ParameterSchema;
+    properties?: Record<string, ParameterSchema>;
+    required?: string[];
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, ParameterSchema>;
+        required?: string[];
+    };
+    handler: (params: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+interface ChatConfig {
+    id?: string;
+    providers: ProviderConfigs;
+    defaultProvider: ProviderType;
+    defaultModel?: string;
+    storagePath?: string;
+    systemPrompt?: string;
+    /** 개인화 설정 */
+    personalization?: Partial<PersonalizationConfig>;
+}
+interface Chat {
+    id: string;
+    config: ChatConfig;
+    messages: Message[];
+    tools: Map<string, ToolDefinition>;
+    memory: Map<string, MemoryEntry>;
+    createdAt: number;
+    updatedAt: number;
+}
+interface SendOptions {
+    provider?: ProviderType;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: ToolDefinition[];
+    systemPrompt?: string;
+}
+type StreamEventType = 'text' | 'tool_call' | 'tool_result' | 'done' | 'error';
+interface StreamEvent {
+    type: StreamEventType;
+    content?: string;
+    toolCall?: ToolCall;
+    toolResult?: ToolResult;
+    error?: Error;
+    message?: Message;
+}
+interface MemoryEntry {
+    key: string;
+    value: unknown;
+    createdAt: number;
+    updatedAt: number;
+}
+interface GlobalMemoryStore$1 {
+    entries: Map<string, MemoryEntry>;
+    storagePath: string;
+}
+type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+interface ObservedTask {
+    id: string;
+    description: string;
+    status: TaskStatus;
+    progress: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface UserPreference {
+    key: string;
+    value: unknown;
+    confidence: number;
+    source: string;
+}
+interface LearnedSkill {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    steps: SkillStep[];
+    successRate: number;
+    usageCount: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface SkillStep {
+    order: number;
+    action: string;
+    expectedInput?: string;
+    expectedOutput?: string;
+}
+interface ObserverConfig {
+    extractTasks: boolean;
+    extractPreferences: boolean;
+    autoLearn: boolean;
+}
+interface ObserverState {
+    enabled: boolean;
+    config: ObserverConfig;
+    tasks: ObservedTask[];
+    preferences: UserPreference[];
+}
+type StyleLevel = 'low' | 'medium' | 'high';
+type FormattingStyle = 'minimal' | 'default' | 'rich';
+/**
+ * 응답 스타일 설정
+ */
+interface ResponseStyle {
+    /** 따뜻함 수준 */
+    warmth: StyleLevel;
+    /** 열정/에너지 수준 */
+    enthusiasm: StyleLevel;
+    /** 이모지 사용 수준 */
+    emojiUsage: StyleLevel;
+    /** 포맷팅 스타일 (헤더, 목록 등) */
+    formatting: FormattingStyle;
+    /** 응답 길이 선호 */
+    verbosity: 'concise' | 'balanced' | 'detailed';
+}
+/**
+ * 사용자 프로필 정보
+ */
+interface UserProfile {
+    /** 사용자 닉네임/호칭 */
+    nickname?: string;
+    /** 직업/역할 */
+    occupation?: string;
+    /** 추가 정보 (관심사, 가치, 선호 사항) */
+    additionalInfo?: string;
+    /** 선호 언어 */
+    preferredLanguage?: string;
+    /** 전문 분야 */
+    expertise?: string[];
+    /** 커스텀 지시사항 */
+    customInstructions?: string;
+}
+/**
+ * 개인화 설정 전체
+ */
+interface PersonalizationConfig {
+    /** 응답 스타일 */
+    responseStyle: ResponseStyle;
+    /** 사용자 프로필 */
+    userProfile: UserProfile;
+    /** 메모리 참조 활성화 */
+    useMemory: boolean;
+    /** 언어 설정 ('auto' | 'ko' | 'en' | etc.) */
+    language: string;
+}
+/**
+ * 개인화 설정 기본값
+ */
+declare const DEFAULT_PERSONALIZATION: PersonalizationConfig;
+/**
+ * @description Hook 결과 타입 (React Query UseMutationResult 호환)
+ */
+interface MutationResult<TData = unknown, TError = Error, TVariables = unknown> {
+    mutate: (variables: TVariables) => void;
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    isPending: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    data?: TData;
+    error?: TError;
+    reset: () => void;
+}
+/**
+ * @description Tool/Action Hook 타입
+ */
+type ToolHook<TRequest = unknown, TResponse = unknown> = () => MutationResult<TResponse, Error, TRequest>;
+/**
+ * @description AI가 자동으로 호출하는 Tool 설정
+ * AI가 사용자 메시지를 분석해서 필요시 자동 호출
+ */
+interface LLMToolConfig<TRequest = unknown, TResponse = unknown> {
+    /** Tool hook */
+    hook: ToolHook<TRequest, TResponse>;
+    /** AI가 판단할 때 사용하는 설명 */
+    description: string;
+    /** JSON Schema 형태의 파라미터 정의 (선택) */
+    parameters?: {
+        type: 'object';
+        properties: Record<string, {
+            type: string;
+            description?: string;
+            enum?: string[];
+        }>;
+        required?: string[];
+    };
+}
+/**
+ * @description 사용자가 UI에서 직접 선택하는 Action 설정
+ */
+interface LLMActionConfig<TRequest = unknown, TResponse = unknown> {
+    /** Action hook */
+    hook: ToolHook<TRequest, TResponse>;
+    /** UI에 표시할 레이블 */
+    label: string;
+    /** 아이콘 이름 또는 컴포넌트 */
+    icon?: string;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+}
+/**
+ * @description 기본 채팅(텍스트 생성) 설정
+ */
+interface LLMChatHookConfig<TRequest = unknown, TResponse = unknown> {
+    /** 텍스트 생성 hook */
+    hook: ToolHook<TRequest, TResponse>;
+    /** 기본 시스템 프롬프트 */
+    systemPrompt?: string;
+}
+/**
+ * @description LLM Chat 컴포넌트 Props
+ */
+interface LLMChatComponentProps {
+    /** AI가 자동 호출하는 Tools */
+    tools?: Record<string, LLMToolConfig>;
+    /** 사용자가 직접 선택하는 Actions */
+    actions?: Record<string, LLMActionConfig>;
+    /** 기본 채팅 설정 */
+    chat: LLMChatHookConfig;
+    /** 스타일 클래스 */
+    className?: string;
+    /** 개인화 설정 */
+    personalization?: Partial<PersonalizationConfig>;
+}
+
+/**
+ * Session represents a conversation context that can span multiple providers
+ * This is inspired by Acontext's Session concept
+ */
+interface Session {
+    id: string;
+    messages: Message[];
+    systemPrompt?: string;
+    createdAt: number;
+    updatedAt: number;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Create a new session
+ */
+declare function createSession(options?: {
+    id?: string;
+    systemPrompt?: string;
+    metadata?: Record<string, unknown>;
+}): Session;
+/**
+ * Add a message to the session
+ */
+declare function addMessage(session: Session, message: Message): Session;
+/**
+ * Add multiple messages to the session
+ */
+declare function addMessages(session: Session, messages: Message[]): Session;
+/**
+ * Get messages prepared for a specific provider
+ * Includes system prompt as the first message if defined
+ */
+declare function getMessagesForProvider(session: Session, _provider: ProviderType): Message[];
+/**
+ * Update session system prompt
+ */
+declare function setSystemPrompt$1(session: Session, prompt: string): Session;
+/**
+ * Clear session messages but keep system prompt
+ */
+declare function clearMessages$1(session: Session): Session;
+/**
+ * Get the last N messages from session
+ */
+declare function getLastMessages(session: Session, count: number): Message[];
+/**
+ * Get messages after a specific timestamp
+ */
+declare function getMessagesAfter(session: Session, timestamp: number): Message[];
+/**
+ * Get a summary of the session
+ */
+declare function getSessionSummary(session: Session): {
+    id: string;
+    messageCount: number;
+    providers: ProviderType[];
+    firstMessageAt: number | null;
+    lastMessageAt: number | null;
+};
+/**
+ * Update session metadata
+ */
+declare function setSessionMetadata(session: Session, key: string, value: unknown): Session;
+/**
+ * Serialize session to JSON-compatible object
+ */
+declare function serializeSession(session: Session): Record<string, unknown>;
+/**
+ * Deserialize session from JSON-compatible object
+ */
+declare function deserializeSession(data: Record<string, unknown>): Session;
+
+/**
+ * Create a new chat instance
+ */
+declare function createChat(config: ChatConfig): Chat;
+/**
+ * Send a message and get a response
+ */
+declare function sendMessage(chat: Chat, content: string, options?: SendOptions): Promise<Message>;
+/**
+ * Send a message and stream the response
+ */
+declare function sendMessageStream(chat: Chat, content: string, options?: SendOptions): AsyncGenerator<StreamEvent>;
+/**
+ * Register a tool for the chat
+ */
+declare function registerTool(chat: Chat, tool: ToolDefinition): void;
+/**
+ * Unregister a tool from the chat
+ */
+declare function unregisterTool(chat: Chat, toolName: string): boolean;
+/**
+ * Get all registered tools
+ */
+declare function getTools(chat: Chat): ToolDefinition[];
+/**
+ * Set system prompt for the chat
+ */
+declare function setSystemPrompt(chat: Chat, prompt: string): void;
+/**
+ * Get chat messages
+ */
+declare function getMessages(chat: Chat): Message[];
+/**
+ * Clear chat messages only
+ */
+declare function clearMessages(chat: Chat): void;
+/**
+ * Reset chat completely (messages, tools, memory)
+ */
+declare function resetChat(chat: Chat): void;
+/**
+ * Get chat session
+ */
+declare function getSession(chat: Chat): Session;
+/**
+ * Destroy a chat and clean up resources
+ */
+declare function destroyChat(chat: Chat): void;
+
+/**
+ * Create a new message
+ */
+declare function createMessage(role: Role, content: string, options?: {
+    provider?: ProviderType;
+    model?: string;
+    toolCalls?: ToolCall[];
+    toolCallId?: string;
+    metadata?: Record<string, unknown>;
+}): Message;
+/**
+ * Create a user message
+ */
+declare function createUserMessage(content: string): Message;
+/**
+ * Create an assistant message
+ */
+declare function createAssistantMessage(content: string, provider?: ProviderType, model?: string, toolCalls?: ToolCall[]): Message;
+/**
+ * Create a system message
+ */
+declare function createSystemMessage(content: string): Message;
+/**
+ * Create a tool result message
+ */
+declare function createToolMessage(content: string, toolCallId: string): Message;
+/**
+ * Clone a message with optional overrides
+ */
+declare function cloneMessage(message: Message, overrides?: Partial<Message>): Message;
+/**
+ * Filter messages by role
+ */
+declare function filterByRole(messages: Message[], role: Role): Message[];
+/**
+ * Filter messages by provider
+ */
+declare function filterByProvider(messages: Message[], provider: ProviderType): Message[];
+/**
+ * Get the last message of a specific role
+ */
+declare function getLastMessageByRole(messages: Message[], role: Role): Message | undefined;
+/**
+ * Calculate total content length of messages
+ */
+declare function getTotalContentLength(messages: Message[]): number;
+/**
+ * Truncate messages to fit within a token limit (approximate)
+ * Uses a simple character-based estimation (1 token ≈ 4 characters)
+ */
+declare function truncateMessages(messages: Message[], maxTokens: number, preserveSystem?: boolean): Message[];
+/**
+ * Format messages for display/logging
+ */
+declare function formatMessagesForDisplay(messages: Message[]): string;
+
+/**
+ * Abstract base class for LLM providers
+ * Each provider (OpenAI, Anthropic, etc.) must implement this interface
+ */
+declare abstract class BaseProvider {
+    protected config: ChatConfig;
+    abstract readonly name: ProviderType;
+    constructor(config: ChatConfig);
+    /**
+     * Send a message and get a complete response
+     */
+    abstract sendMessage(messages: Message[], options: SendOptions): Promise<Message>;
+    /**
+     * Send a message and stream the response
+     */
+    abstract sendMessageStream(messages: Message[], options: SendOptions): AsyncGenerator<StreamEvent>;
+    /**
+     * Convert internal message format to provider-specific format
+     */
+    protected abstract formatMessages(messages: Message[]): unknown[];
+    /**
+     * Convert tool definitions to provider-specific format
+     */
+    protected abstract formatTools(tools: ToolDefinition[]): unknown[];
+    /**
+     * Parse provider response into internal message format
+     */
+    protected abstract parseResponse(response: unknown): Message;
+    /**
+     * Get the API endpoint URL
+     */
+    protected abstract getEndpoint(model: string): string;
+    /**
+     * Get headers for API requests
+     */
+    protected abstract getHeaders(): Record<string, string>;
+    /**
+     * Generate a unique message ID
+     */
+    protected generateMessageId(): string;
+    /**
+     * Build the request body for API calls
+     */
+    protected abstract buildRequestBody(messages: unknown[], options: SendOptions, tools?: unknown[]): unknown;
+}
+/**
+ * Provider registry for managing available providers
+ */
+declare class ProviderRegistry {
+    private providers;
+    register(provider: BaseProvider): void;
+    get(name: ProviderType): BaseProvider | undefined;
+    has(name: ProviderType): boolean;
+    getAll(): Map<ProviderType, BaseProvider>;
+}
+
+/**
+ * Ollama message format
+ */
+interface OllamaMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    tool_calls?: OllamaToolCall[];
+}
+interface OllamaToolCall {
+    function: {
+        name: string;
+        arguments: Record<string, unknown>;
+    };
+}
+interface OllamaTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required?: string[];
+        };
+    };
+}
+interface OllamaChatRequest {
+    model: string;
+    messages: OllamaMessage[];
+    stream?: boolean;
+    options?: {
+        temperature?: number;
+        num_predict?: number;
+    };
+    tools?: OllamaTool[];
+}
+interface OllamaChatResponse {
+    model: string;
+    message: OllamaMessage;
+    done: boolean;
+    done_reason?: string;
+}
+/**
+ * Ollama Provider implementation
+ * Connects to local Ollama server for running open-source models
+ */
+declare class OllamaProvider extends BaseProvider {
+    readonly name: ProviderType;
+    private baseUrl;
+    constructor(config: ChatConfig);
+    /**
+     * Send a message and get a complete response
+     */
+    sendMessage(messages: Message[], options: SendOptions): Promise<Message>;
+    /**
+     * Send a message and stream the response
+     */
+    sendMessageStream(messages: Message[], options: SendOptions): AsyncGenerator<StreamEvent>;
+    /**
+     * Convert internal message format to Ollama format
+     */
+    protected formatMessages(messages: Message[]): OllamaMessage[];
+    /**
+     * Convert tool definitions to Ollama format
+     */
+    protected formatTools(tools: ToolDefinition[]): OllamaTool[];
+    /**
+     * Parse Ollama response into internal message format
+     */
+    protected parseResponse(response: OllamaChatResponse): Message;
+    /**
+     * Get the Ollama API endpoint
+     */
+    protected getEndpoint(_model: string): string;
+    /**
+     * Get headers for Ollama API requests
+     */
+    protected getHeaders(): Record<string, string>;
+    /**
+     * Build request body for Ollama API
+     */
+    protected buildRequestBody(messages: unknown[], options: SendOptions, tools?: unknown[]): OllamaChatRequest;
+    /**
+     * List available models from Ollama
+     */
+    listModels(): Promise<string[]>;
+    /**
+     * Check if Ollama server is available
+     */
+    isAvailable(): Promise<boolean>;
+}
+
+/**
+ * Custom error classes for devdive-chatLLM
+ */
+declare class ChatLLMError extends Error {
+    constructor(message: string);
+}
+declare class ProviderError extends ChatLLMError {
+    provider: string;
+    statusCode?: number | undefined;
+    originalError?: Error | undefined;
+    constructor(provider: string, message: string, statusCode?: number | undefined, originalError?: Error | undefined);
+}
+declare class ConfigurationError extends ChatLLMError {
+    constructor(message: string);
+}
+declare class ToolExecutionError extends ChatLLMError {
+    toolName: string;
+    originalError?: Error | undefined;
+    constructor(toolName: string, message: string, originalError?: Error | undefined);
+}
+declare class StorageError extends ChatLLMError {
+    operation: 'read' | 'write' | 'delete';
+    originalError?: Error | undefined;
+    constructor(operation: 'read' | 'write' | 'delete', message: string, originalError?: Error | undefined);
+}
+declare class StreamError extends ChatLLMError {
+    originalError?: Error | undefined;
+    constructor(message: string, originalError?: Error | undefined);
+}
+declare class ValidationError extends ChatLLMError {
+    field: string;
+    constructor(field: string, message: string);
+}
+/**
+ * Wraps an error with provider context
+ */
+declare function wrapProviderError(provider: string, error: unknown, statusCode?: number): ProviderError;
+/**
+ * Checks if an error is a specific type
+ */
+declare function isProviderError(error: unknown): error is ProviderError;
+declare function isToolExecutionError(error: unknown): error is ToolExecutionError;
+declare function isStorageError(error: unknown): error is StorageError;
+
+/**
+ * Parse Server-Sent Events (SSE) stream
+ */
+declare function parseSSEStream(response: Response): AsyncGenerator<string>;
+/**
+ * Parse NDJSON (Newline Delimited JSON) stream - used by Ollama
+ */
+declare function parseNDJSONStream(response: Response): AsyncGenerator<unknown>;
+/**
+ * Create a stream event helper
+ */
+declare function createStreamEvent(type: StreamEvent['type'], data?: Partial<Omit<StreamEvent, 'type'>>): StreamEvent;
+/**
+ * Collect all stream events into a single message content
+ */
+declare function collectStreamContent(stream: AsyncGenerator<StreamEvent>): Promise<string>;
+
+/**
+ * Default configuration values
+ */
+declare const DEFAULT_STORAGE_PATH: string;
+declare const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+declare const DEFAULT_MODELS: Record<ProviderType, string>;
+/**
+ * Validates provider configuration
+ */
+declare function validateProviderConfig(provider: ProviderType, config: ChatConfig): void;
+/**
+ * Gets the base URL for a provider
+ */
+declare function getProviderBaseUrl(provider: ProviderType, config: ChatConfig): string;
+/**
+ * Gets the default model for a provider
+ */
+declare function getDefaultModel(provider: ProviderType, config: ChatConfig): string;
+/**
+ * Merges user config with defaults
+ */
+declare function mergeConfig(userConfig: ChatConfig): ChatConfig;
+
+/**
+ * File-based storage for persisting data
+ */
+declare class FileStorage {
+    private basePath;
+    constructor(basePath: string);
+    /**
+     * Ensure a directory exists
+     */
+    private ensureDirectory;
+    /**
+     * Get the full path for a key
+     */
+    private getFilePath;
+    /**
+     * Read data from storage
+     */
+    read<T>(key: string): T | null;
+    /**
+     * Write data to storage
+     */
+    write<T>(key: string, data: T): void;
+    /**
+     * Delete data from storage
+     */
+    delete(key: string): boolean;
+    /**
+     * Check if a key exists
+     */
+    exists(key: string): boolean;
+    /**
+     * Get the base path
+     */
+    getBasePath(): string;
+}
+/**
+ * In-memory storage (for testing or temporary use)
+ */
+declare class MemoryStorage {
+    private data;
+    read<T>(key: string): T | null;
+    write<T>(key: string, data: T): void;
+    delete(key: string): boolean;
+    exists(key: string): boolean;
+    clear(): void;
+    getAll(): Map<string, unknown>;
+}
+/**
+ * Storage interface for polymorphism
+ */
+interface Storage {
+    read<T>(key: string): T | null;
+    write<T>(key: string, data: T): void;
+    delete(key: string): boolean;
+    exists(key: string): boolean;
+}
+
+/**
+ * Global memory store - shared across all chats
+ */
+declare class GlobalMemoryStore {
+    private entries;
+    private storage;
+    private storageKey;
+    private autoSave;
+    constructor(storagePath?: string, autoSave?: boolean);
+    /**
+     * Load entries from storage
+     */
+    private load;
+    /**
+     * Save entries to storage
+     */
+    private save;
+    /**
+     * Set a memory entry
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Get a memory entry value
+     */
+    get<T = unknown>(key: string): T | undefined;
+    /**
+     * Get a memory entry with metadata
+     */
+    getEntry(key: string): MemoryEntry | undefined;
+    /**
+     * Check if a key exists
+     */
+    has(key: string): boolean;
+    /**
+     * Delete a memory entry
+     */
+    delete(key: string): boolean;
+    /**
+     * Get all memory entries
+     */
+    getAll(): Map<string, MemoryEntry>;
+    /**
+     * Get all keys
+     */
+    keys(): string[];
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Get entries count
+     */
+    size(): number;
+    /**
+     * Force save to storage
+     */
+    forceSave(): void;
+    /**
+     * Convert entries to a format suitable for system prompt injection
+     */
+    toPromptContext(): string;
+}
+/**
+ * Initialize global memory with storage path
+ */
+declare function initGlobalMemory(storagePath?: string, autoSave?: boolean): void;
+/**
+ * Get global memory instance
+ */
+declare function getGlobalMemoryStore(): GlobalMemoryStore;
+/**
+ * Set a global memory value
+ */
+declare function setGlobalMemory(key: string, value: unknown): void;
+/**
+ * Get a global memory value
+ */
+declare function getGlobalMemory<T = unknown>(key: string): T | undefined;
+/**
+ * Delete a global memory entry
+ */
+declare function deleteGlobalMemory(key: string): boolean;
+/**
+ * Check if a global memory key exists
+ */
+declare function hasGlobalMemory(key: string): boolean;
+/**
+ * Get all global memory keys
+ */
+declare function getGlobalMemoryKeys(): string[];
+/**
+ * Clear all global memory
+ */
+declare function clearGlobalMemory(): void;
+/**
+ * Get global memory as prompt context
+ */
+declare function getGlobalMemoryContext(): string;
+
+/**
+ * Initialize chat memory with storage path
+ */
+declare function initChatMemory(storagePath?: string, autoSave?: boolean): void;
+/**
+ * Set a chat memory value
+ */
+declare function setChatMemory(chat: Chat, key: string, value: unknown): void;
+/**
+ * Get a chat memory value
+ */
+declare function getChatMemory<T = unknown>(chat: Chat, key: string): T | undefined;
+/**
+ * Delete a chat memory entry
+ */
+declare function deleteChatMemory(chat: Chat, key: string): boolean;
+/**
+ * Check if a chat memory key exists
+ */
+declare function hasChatMemory(chat: Chat, key: string): boolean;
+/**
+ * Get all chat memory keys
+ */
+declare function getChatMemoryKeys(chat: Chat): string[];
+/**
+ * Clear all chat memory
+ */
+declare function clearChatMemory(chat: Chat): void;
+/**
+ * Get chat memory as prompt context
+ */
+declare function getChatMemoryContext(chat: Chat): string;
+/**
+ * Sync chat's internal memory to persistent storage
+ */
+declare function syncChatMemory(chat: Chat): void;
+
+/**
+ * Memory manager configuration
+ */
+interface MemoryManagerConfig {
+    storagePath?: string;
+    autoSave?: boolean;
+}
+/**
+ * Initialize memory system
+ */
+declare function initMemory(config?: MemoryManagerConfig): void;
+/**
+ * Get combined memory context for prompt injection
+ * Combines global memory and chat-specific memory
+ */
+declare function getMemoryContext(chat: Chat): string;
+/**
+ * Build a system prompt with memory context injected
+ */
+declare function buildSystemPromptWithMemory(basePrompt: string, chat: Chat): string;
+
+/**
+ * Task extraction result from LLM
+ */
+interface TaskExtractionResult {
+    tasks: ExtractedTask[];
+    preferences: ExtractedPreference[];
+}
+interface ExtractedTask {
+    description: string;
+    status: TaskStatus;
+    progress: number;
+}
+interface ExtractedPreference {
+    key: string;
+    value: unknown;
+    confidence: number;
+}
+/**
+ * Learning input for SOP generation
+ */
+interface LearningInput {
+    taskDescription: string;
+    conversationSummary: string;
+    outcome: 'success' | 'failure' | 'partial';
+    steps: LearningStep[];
+}
+interface LearningStep {
+    userInput: string;
+    assistantOutput: string;
+    toolsUsed?: string[];
+}
+/**
+ * Skill search options
+ */
+interface SkillSearchOptions {
+    category?: string;
+    minSuccessRate?: number;
+    limit?: number;
+}
+/**
+ * Skill application result
+ */
+interface SkillApplicationResult {
+    applied: boolean;
+    skillId: string;
+    suggestedPrompt?: string;
+    error?: string;
+}
+/**
+ * Observer event types
+ */
+type ObserverEventType = 'task_detected' | 'task_updated' | 'preference_detected' | 'learning_triggered';
+interface ObserverEvent {
+    type: ObserverEventType;
+    timestamp: number;
+    data: ObservedTask | UserPreference | LearnedSkill;
+}
+/**
+ * Observer callback function
+ */
+type ObserverCallback = (event: ObserverEvent) => void;
+
+/**
+ * Enable observer for a chat
+ */
+declare function enableObserver(chat: Chat, config?: Partial<ObserverConfig>): void;
+/**
+ * Disable observer for a chat
+ */
+declare function disableObserver(chat: Chat): void;
+/**
+ * Check if observer is enabled
+ */
+declare function isObserverEnabled(chat: Chat): boolean;
+/**
+ * Get observer configuration
+ */
+declare function getObserverConfig(chat: Chat): ObserverConfig;
+/**
+ * Register an observer callback
+ */
+declare function onObserverEvent(chat: Chat, callback: ObserverCallback): () => void;
+/**
+ * Analyze messages and extract tasks/preferences
+ * This is a simplified local extraction - in production, you might use LLM for this
+ */
+declare function analyzeMessages(chat: Chat, messages?: Message[]): TaskExtractionResult;
+/**
+ * Process new messages and update observer state
+ */
+declare function processMessages(chat: Chat, newMessages: Message[]): void;
+/**
+ * Get observed tasks for a chat
+ */
+declare function getObservedTasks(chat: Chat): ObservedTask[];
+/**
+ * Get observed preferences for a chat
+ */
+declare function getObservedPreferences(chat: Chat): UserPreference[];
+/**
+ * Update a task's status
+ */
+declare function updateTaskStatus(chat: Chat, taskId: string, status: ObservedTask['status'], progress?: number): boolean;
+/**
+ * Clear observer state for a chat
+ */
+declare function clearObserverState(chat: Chat): void;
+/**
+ * Get full observer state (for debugging/export)
+ */
+declare function getObserverState(chat: Chat): ObserverState;
+
+/**
+ * Initialize the learner
+ */
+declare function initLearner(storagePath?: string): void;
+/**
+ * Learn from a completed conversation
+ */
+declare function learnFromConversation(chat: Chat, taskDescription: string, outcome?: 'success' | 'failure' | 'partial'): LearnedSkill;
+/**
+ * Get all learned skills
+ */
+declare function getLearnedSkills(category?: string): LearnedSkill[];
+/**
+ * Search learned skills
+ */
+declare function searchLearnedSkills(keyword: string): LearnedSkill[];
+/**
+ * Get a specific skill
+ */
+declare function getLearnedSkill(skillId: string): LearnedSkill | undefined;
+/**
+ * Record skill usage result
+ */
+declare function recordSkillUsage(skillId: string, success: boolean): void;
+/**
+ * Delete a learned skill
+ */
+declare function deleteLearnedSkill(skillId: string): boolean;
+/**
+ * Clear all learned skills
+ */
+declare function clearLearnedSkills(): void;
+
+/**
+ * Search for relevant skills based on user input
+ */
+declare function findRelevantSkills(query: string, options?: SkillSearchOptions): LearnedSkill[];
+/**
+ * Apply a skill to a chat by generating a suggested prompt
+ */
+declare function applySkill(_chat: Chat, skill: LearnedSkill): SkillApplicationResult;
+/**
+ * Apply a skill and inject it into system prompt
+ */
+declare function applySkillToSystemPrompt(chat: Chat, skill: LearnedSkill, baseSystemPrompt: string): string;
+/**
+ * Get best matching skill for a query
+ */
+declare function getBestSkill(query: string, options?: SkillSearchOptions): LearnedSkill | undefined;
+/**
+ * Suggest skills based on conversation context
+ */
+declare function suggestSkills(chat: Chat, limit?: number): LearnedSkill[];
+/**
+ * Record that a skill was used and whether it was successful
+ */
+declare function recordSkillApplication(skillId: string, success: boolean): void;
+/**
+ * Track skill application
+ */
+declare function trackSkillApplication(chatId: string, skillId: string): void;
+/**
+ * Update skill application success
+ */
+declare function updateSkillApplicationSuccess(chatId: string, skillId: string, success: boolean): void;
+/**
+ * Get skill application history for a chat
+ */
+declare function getSkillApplicationHistory(chatId: string): Array<{
+    skillId: string;
+    appliedAt: number;
+    success?: boolean;
+}>;
+/**
+ * Clear skill application history for a chat
+ */
+declare function clearSkillApplicationHistory(chatId: string): void;
+
+export { type AnthropicConfig, BaseProvider, type Chat, type ChatConfig, ChatLLMError, ConfigurationError, DEFAULT_MODELS, DEFAULT_OLLAMA_BASE_URL, DEFAULT_PERSONALIZATION, DEFAULT_STORAGE_PATH, type ExtractedPreference, type ExtractedTask, FileStorage, type FormattingStyle, type GlobalMemoryStore$1 as GlobalMemoryStore, type GoogleConfig, type LLMActionConfig, type LLMChatComponentProps, type LLMChatHookConfig, type LLMToolConfig, type LearnedSkill, type LearningInput, type LearningStep, type MemoryEntry, type MemoryManagerConfig, MemoryStorage, type Message, type MutationResult, type NaverConfig, type ObservedTask, type ObserverCallback, type ObserverConfig, type ObserverEvent, type ObserverEventType, type ObserverState, type OllamaConfig, OllamaProvider, type OpenAIConfig, type ParameterSchema, type PersonalizationConfig, type ProviderConfigs, ProviderError, ProviderRegistry, type ProviderType, type ResponseStyle, type Role, type SendOptions, type Session, type SkillApplicationResult, type SkillSearchOptions, type SkillStep, type Storage, StorageError, StreamError, type StreamEvent, type StreamEventType, type StyleLevel, type TaskExtractionResult, type TaskStatus, type ToolCall, type ToolDefinition, ToolExecutionError, type ToolHook, type ToolResult, type UserPreference, type UserProfile, ValidationError, addMessage as addSessionMessage, addMessages as addSessionMessages, analyzeMessages, applySkill, applySkillToSystemPrompt, buildSystemPromptWithMemory, clearChatMemory, clearGlobalMemory, clearLearnedSkills, clearMessages, clearObserverState, clearMessages$1 as clearSessionMessages, clearSkillApplicationHistory, cloneMessage, collectStreamContent, createAssistantMessage, createChat, createMessage, createSession, createStreamEvent, createSystemMessage, createToolMessage, createUserMessage, deleteChatMemory, deleteGlobalMemory, deleteLearnedSkill, deserializeSession, destroyChat, disableObserver, enableObserver, filterByProvider, filterByRole, findRelevantSkills, formatMessagesForDisplay, getBestSkill, getChatMemory, getChatMemoryContext, getChatMemoryKeys, getDefaultModel, getGlobalMemory, getGlobalMemoryContext, getGlobalMemoryKeys, getGlobalMemoryStore, getLastMessageByRole, getLastMessages, getLearnedSkill, getLearnedSkills, getMemoryContext, getMessages, getMessagesAfter, getMessagesForProvider, getObservedPreferences, getObservedTasks, getObserverConfig, getObserverState, getProviderBaseUrl, getSession, getSessionSummary, getSkillApplicationHistory, getTools, getTotalContentLength, hasChatMemory, hasGlobalMemory, initChatMemory, initGlobalMemory, initLearner, initMemory, isObserverEnabled, isProviderError, isStorageError, isToolExecutionError, learnFromConversation, mergeConfig, onObserverEvent, parseNDJSONStream, parseSSEStream, processMessages, recordSkillApplication, recordSkillUsage, registerTool, resetChat, searchLearnedSkills, sendMessage, sendMessageStream, serializeSession, setChatMemory, setGlobalMemory, setSessionMetadata, setSystemPrompt$1 as setSessionSystemPrompt, setSystemPrompt, suggestSkills, syncChatMemory, trackSkillApplication, truncateMessages, unregisterTool, updateSkillApplicationSuccess, updateTaskStatus, validateProviderConfig, wrapProviderError };