/**
 * Memory Manager
 *
 * Manages agent memory - both short-term (conversation context)
 * and long-term (persistent vector storage).
 *
 * Note: Long-term memory with vector stores requires a VectorDatabase service
 * which is not yet implemented. This module provides an interface and
 * in-memory fallback until vector database support is added.
 */
import { IAgentMemoryConfig, IConversationMessage, IMemoryResult } from './types';
/**
 * Vector store adapter interface
 * To be implemented when VectorDatabase service is available
 */
export interface IVectorStoreAdapter {
    /** Store embeddings with content and metadata */
    upsert(vectors: Array<{
        id: string;
        content: string;
        embedding: number[];
        metadata?: Record<string, unknown>;
    }>): Promise<void>;
    /** Query similar vectors */
    query(embedding: number[], topK: number, filter?: Record<string, unknown>): Promise<Array<{
        content: string;
        metadata?: Record<string, unknown>;
        score: number;
    }>>;
    /** Delete vectors by IDs */
    delete(ids: string[]): Promise<void>;
    /** Clear namespace */
    clear(namespace?: string): Promise<void>;
}
/**
 * Embedding provider interface
 * Used to generate embeddings for vector storage
 */
export interface IEmbeddingProvider {
    /** Generate embedding for text */
    embed(text: string): Promise<number[]>;
    /** Generate embeddings for multiple texts */
    embedBatch(texts: string[]): Promise<number[][]>;
}
/**
 * Stub embedding provider (returns random vectors until real implementation)
 */
export declare class StubEmbeddingProvider implements IEmbeddingProvider {
    private dimensions;
    constructor(dimensions?: number);
    embed(text: string): Promise<number[]>;
    embedBatch(texts: string[]): Promise<number[][]>;
    private hashString;
    private generateVector;
}
/**
 * In-memory vector store (fallback when real vector store not available)
 */
export declare class InMemoryVectorStore implements IVectorStoreAdapter {
    private vectors;
    upsert(vectors: Array<{
        id: string;
        content: string;
        embedding: number[];
        metadata?: Record<string, unknown>;
    }>): Promise<void>;
    query(embedding: number[], topK: number, filter?: Record<string, unknown>): Promise<Array<{
        content: string;
        metadata?: Record<string, unknown>;
        score: number;
    }>>;
    delete(ids: string[]): Promise<void>;
    clear(namespace?: string): Promise<void>;
    private cosineSimilarity;
}
/**
 * Conversation summarizer (for short-term memory management)
 */
export interface IConversationSummarizer {
    /** Summarize conversation messages */
    summarize(messages: IConversationMessage[]): Promise<string>;
}
/**
 * Simple conversation summarizer (extracts key points)
 */
export declare class SimpleConversationSummarizer implements IConversationSummarizer {
    summarize(messages: IConversationMessage[]): Promise<string>;
    private truncate;
}
/**
 * Memory Manager
 *
 * Handles both short-term (conversation) and long-term (vector) memory
 * for agent executions.
 */
export declare class MemoryManager {
    private config;
    private conversation;
    private conversationSummary;
    private vectorStore;
    private embeddingProvider;
    private summarizer;
    private executionId;
    private agentTag;
    private namespace?;
    constructor(config: IAgentMemoryConfig, executionId: string, agentTag: string, options?: {
        vectorStore?: IVectorStoreAdapter;
        embeddingProvider?: IEmbeddingProvider;
        summarizer?: IConversationSummarizer;
    });
    /**
     * Add a message to conversation history
     */
    addMessage(message: IConversationMessage): void;
    /**
     * Add multiple messages
     */
    addMessages(messages: IConversationMessage[]): void;
    /**
     * Get conversation messages for LLM context
     */
    getConversationForContext(): IConversationMessage[];
    /**
     * Get full conversation history
     */
    getFullConversation(): IConversationMessage[];
    /**
     * Clear conversation history
     */
    clearConversation(): void;
    /**
     * Compact conversation by summarizing older messages
     */
    private maybeCompactConversation;
    /**
     * Check if long-term memory is enabled
     */
    isLongTermEnabled(): boolean;
    /**
     * Store content in long-term memory
     */
    remember(content: string, metadata?: Record<string, unknown>): Promise<void>;
    /**
     * Retrieve relevant content from long-term memory
     */
    recall(query: string, topK?: number): Promise<IMemoryResult[]>;
    /**
     * Clear long-term memory for this agent/namespace
     */
    clearLongTermMemory(): Promise<void>;
    /**
     * Build context for LLM call including relevant memories
     */
    buildContext(currentQuery?: string): Promise<{
        conversation: IConversationMessage[];
        memories: IMemoryResult[];
    }>;
    /**
     * Format memories for inclusion in system prompt
     */
    formatMemoriesForPrompt(memories: IMemoryResult[]): string;
    /**
     * Get memory state snapshot
     */
    getState(): {
        conversationLength: number;
        hasSummary: boolean;
        longTermEnabled: boolean;
    };
    /**
     * Import conversation from another memory manager or serialized state
     */
    importConversation(messages: IConversationMessage[], summary?: string): void;
    /**
     * Export conversation for serialization
     */
    exportConversation(): {
        messages: IConversationMessage[];
        summary: string | null;
    };
}
export default MemoryManager;