/**
 * AutoMemory - Policy-based automatic memory capture
 * Integrates with Memory, KnowledgeBase, and Vector stores
 */
import { Memory, MemoryEntry, MemoryConfig } from './memory';
export interface AutoMemoryPolicy {
    name: string;
    condition: (content: string, role: string, context: AutoMemoryContext) => boolean;
    action: 'store' | 'summarize' | 'vectorize' | 'skip';
    priority?: number;
}
export interface AutoMemoryContext {
    messageCount: number;
    tokenCount: number;
    lastSummaryAt?: number;
    metadata: Record<string, any>;
}
export interface AutoMemoryConfig extends MemoryConfig {
    policies?: AutoMemoryPolicy[];
    summaryThreshold?: number;
    vectorizeThreshold?: number;
    summarizer?: (entries: MemoryEntry[]) => Promise<string>;
    vectorStore?: VectorStoreAdapter;
    knowledgeBase?: KnowledgeBaseAdapter;
}
export interface VectorStoreAdapter {
    add(id: string, embedding: number[], metadata?: Record<string, any>): Promise<void>;
    search(embedding: number[], limit?: number): Promise<Array<{
        id: string;
        score: number;
    }>>;
}
export interface KnowledgeBaseAdapter {
    add(content: string, metadata?: Record<string, any>): Promise<string>;
    search(query: string, limit?: number): Promise<Array<{
        content: string;
        score: number;
    }>>;
}
/**
 * Default policies for automatic memory management
 */
export declare const DEFAULT_POLICIES: AutoMemoryPolicy[];
/**
 * AutoMemory - Automatic memory management with policies
 */
export declare class AutoMemory {
    private memory;
    private policies;
    private summaryThreshold;
    private vectorizeThreshold;
    private summarizer?;
    private vectorStore?;
    private knowledgeBase?;
    private embeddingProvider?;
    private context;
    private pendingVectorization;
    constructor(config?: AutoMemoryConfig);
    /**
     * Process and add content with automatic policy application
     */
    add(content: string, role: 'user' | 'assistant' | 'system', metadata?: Record<string, any>): Promise<MemoryEntry | null>;
    /**
     * Get a memory entry by ID
     */
    get(id: string): MemoryEntry | undefined;
    /**
     * Get all entries
     */
    getAll(): MemoryEntry[];
    /**
     * Get recent entries
     */
    getRecent(count: number): MemoryEntry[];
    /**
     * Search memory
     */
    search(query: string, limit?: number): Promise<Array<{
        entry: MemoryEntry;
        score: number;
    }>>;
    /**
     * Build context with automatic retrieval
     */
    buildContext(query?: string, maxTokens?: number): Promise<string>;
    /**
     * Add a custom policy
     */
    addPolicy(policy: AutoMemoryPolicy): void;
    /**
     * Remove a policy by name
     */
    removePolicy(name: string): boolean;
    /**
     * Get current context stats
     */
    getStats(): AutoMemoryContext;
    /**
     * Clear all memory
     */
    clear(): void;
    /**
     * Export memory
     */
    toJSON(): MemoryEntry[];
    /**
     * Import memory
     */
    fromJSON(entries: MemoryEntry[]): void;
    /**
     * Get underlying memory instance
     */
    getMemory(): Memory;
    /**
     * Flush pending vectorization
     */
    private flushVectorization;
    /**
     * Summarize old entries to save space
     */
    private summarizeOldEntries;
    /**
     * Estimate token count (rough approximation)
     */
    private estimateTokens;
}
/**
 * Create an auto-memory instance
 */
export declare function createAutoMemory(config?: AutoMemoryConfig): AutoMemory;
/**
 * Create a simple summarizer using an LLM
 */
export declare function createLLMSummarizer(llm: {
    chat: (prompt: string) => Promise<string>;
}): (entries: MemoryEntry[]) => Promise<string>;