import { IContextManager, Message, ContextConfig, TruncationResult } from '../types';
export interface Tokenizer {
    encode(text: string, modelName?: string): Promise<number[]> | number[];
    decode(tokens: number[], modelName?: string): Promise<string> | string;
    count(text: string, modelName?: string): Promise<number> | number;
}
export interface ContextManagerOptions {
    /** Token cache size (default: 5000) */
    cacheSize?: number;
    /** Default buffer tokens */
    defaultBufferTokens?: number;
    /** Default completion tokens reserved */
    defaultCompletionTokens?: number;
}
/**
 * Context Manager
 *
 * Handles token counting, message truncation, and context window management.
 *
 * Features:
 * - Token caching (LRU) to avoid recalculation
 * - Session-based context windows for incremental message handling
 * - Multiple truncation strategies
 * - Model-specific overhead configuration
 */
export declare class ContextManager implements IContextManager {
    private readonly tokenizer;
    private readonly cache;
    private readonly sessions;
    private readonly modelConfigs;
    private readonly logger;
    private currentModel?;
    private readonly defaultBufferTokens;
    private readonly defaultCompletionTokens;
    private static readonly DEFAULT_MESSAGE_OVERHEAD;
    private static readonly DEFAULT_REQUEST_OVERHEAD;
    constructor(tokenizer: Tokenizer, options?: ContextManagerOptions);
    setModel(modelName: string): void;
    registerModelConfig(config: {
        modelName: string;
        messageOverhead?: number;
        requestOverhead?: number;
    }): void;
    getMessageOverhead(modelName?: string): number;
    getRequestOverhead(modelName?: string): number;
    countTokens(text: string, modelName?: string): Promise<number>;
    countMessageTokens(msg: Message, modelName?: string): Promise<number>;
    countMessagesTokens(messages: Message[], modelName?: string): Promise<number>;
    estimateTemplateTokens(template: string, variables: Record<string, unknown>, modelName?: string): Promise<number>;
    /**
     * Create a session for tracking context incrementally
     */
    createSession(sessionId: string, config: ContextConfig, modelName?: string): void;
    /**
     * Add messages to a session incrementally
     * Returns number of messages added and truncated
     */
    appendToSession(sessionId: string, messages: Message[]): Promise<{
        added: number;
        truncated: number;
    }>;
    /**
     * Get session messages
     */
    getSessionMessages(sessionId: string): Message[] | undefined;
    /**
     * Get session token count
     */
    getSessionTokens(sessionId: string): number | undefined;
    /**
     * Delete a session
     */
    deleteSession(sessionId: string): boolean;
    calculateAvailableTokens(config: ContextConfig): number;
    truncateMessages(messages: Message[], maxTokens: number): Promise<Message[]>;
    truncateMessagesWithMetadata(messages: Message[], config: ContextConfig): Promise<TruncationResult>;
    truncateMessagesWithTemplate(messages: Message[], config: ContextConfig, template?: string, templateVariables?: Record<string, unknown>): Promise<TruncationResult>;
    checkTokenLimit(messages: Message[], config: ContextConfig): Promise<{
        fits: boolean;
        currentTokens: number;
        availableTokens: number;
    }>;
    /**
     * Get cache statistics
     */
    getCacheStats(): {
        size: number;
        hits: number;
        misses: number;
        hitRate: number;
    };
    /**
     * Clear the token cache
     */
    clearCache(): void;
}
//# sourceMappingURL=manager.d.ts.map