import type { MemoryStorePort } from "./memory-store.js";
import type { TokenUsage, ModelInfo, ContextStats, CompactionStrategy, CompactionResult, DirectMessage, GroupMessage } from "./types.js";

export interface SessionContextRecord {
    
    sessionId: string;
    
    tokens: {
        totalInput: number;
        totalOutput: number;
        totalReasoning: number;
    };
    
    modelInfo?: ModelInfo;
    
    lastActivity: string;
    
    compactions: {
        timestamp: string;
        strategy: CompactionStrategy;
        freedTokens: number;
        messageCount: number;
    }[];
    
    overflowWarned: boolean;
    
    messageCount: number;
}
export declare class ContextManager {
    
    private sessions;
    private memoryStore;
    constructor(memoryStore: MemoryStorePort);
    
    lookupModelLimits(modelName: string): {
        contextLimit: number;
        maxOutput: number;
    };
    
    estimateTokens(text: string): number;
    
    estimateTotalUsage(tokens: TokenUsage): number;
    
    private getOrCreateSession;
    
    recordUsage(sessionId: string, tokens: TokenUsage, modelInfo?: ModelInfo): Promise<void>;
    
    isOverflow(sessionId: string, modelInfo?: ModelInfo): Promise<boolean>;
    
    getStats(sessionId: string, modelInfo?: ModelInfo): Promise<ContextStats>;
    
    prune(messages: (DirectMessage | GroupMessage)[], keepLastTurns?: number): CompactionResult;
    
    private isUserMessage;
    
    getCompactionSummary(sessionId: string): Promise<string | null>;
    
    saveToMemory(session: SessionContextRecord): Promise<void>;
    
    loadFromMemory(sessionId: string): Promise<SessionContextRecord | null>;
    
    saveCompactionResult(sessionId: string, result: CompactionResult): Promise<void>;
    
    resetOverflowWarning(sessionId: string): Promise<void>;
    
    clearSession(sessionId?: string): void;
}