import type { AgentMessage } from '@earendil-works/pi-agent-core';
import { type Api, type Model } from '@earendil-works/pi-ai/compat';
import { type CompactionAudit, type CompactionHandover } from '../../session/compaction-types.js';
import type { TranscriptSourceEntry } from '../../storage/sqlite/transcript-repository.js';
import { type CompactionChunkCursorState } from './compaction-chunks.js';
export interface CompactionResult {
    summary: string;
    messages: AgentMessage[];
    firstKeptIndex: number;
    firstKeptEntryId?: string;
    tokensBefore: number;
    tokensAfter: number;
    compacted: boolean;
    plannerVersion?: 3;
    summaryModelRef?: string;
    qualityAudit?: 'passed' | 'disabled';
    handover?: CompactionHandover;
    audit?: CompactionAudit;
    compactedUsage?: {
        input: number;
        output: number;
        total: number;
        cost?: number;
    };
}
export interface CompactionConfig {
    enabled: boolean;
    triggerThreshold: number;
    minMessagesBeforeCompact: number;
    keepRecentTokens: number;
    recentTurnsPreserve: number;
    summaryMaxTokens: number;
    summaryChunkTokens: number;
    summaryTimeoutMs: number;
    summaryRetries: number;
    reasoningLevel: 'off' | 'low';
    qualityGuard: boolean;
    gapAudit: boolean;
    accumulateUsage: boolean;
}
export interface CompactionExecutionOptions {
    /** Between-turn recovery only: replace all raw history with a cited handover. */
    summarizeAll?: boolean;
    /** Retain the pending request verbatim when recovering an interrupted turn. */
    preserveLastUser?: boolean;
    conversationId?: string;
    fallbackModels?: Array<Model<Api>>;
    signal?: AbortSignal;
    checkpoint?: CompactionCheckpointStore;
    /**
     * Persist the failed attempt for audit, but replace it with a safe marker
     * while building the handover. This prevents a truncated response and
     * its synthetic tool results from becoming model-visible again later.
     */
    discardedAttempt?: CompactionDiscardedAttempt;
}
export interface CompactionDiscardedAttempt {
    assistantTimestamp: number;
    provider?: string;
    model?: string;
    toolCallIds?: string[];
}
export interface CompactionCheckpoint {
    version: 1;
    sourceFingerprint: string;
    cursor: CompactionChunkCursorState;
    chunkIndex: number;
    handover: CompactionHandover;
    modelRef: string;
    repaired: boolean;
    updatedAt: number;
}
export interface CompactionCheckpointStore {
    load(): unknown;
    save(checkpoint: CompactionCheckpoint): void;
    clear(): void;
}
export declare const DEFAULT_COMPACTION_CONFIG: CompactionConfig;
interface MessageUsage {
    input: number;
    output: number;
    total: number;
    cost?: number;
}
export declare function accumulateUsage(messages: AgentMessage[]): MessageUsage | undefined;
export declare class SessionCompactor {
    private readonly config;
    constructor(config?: Partial<CompactionConfig>);
    getConfig(): Readonly<CompactionConfig>;
    compact(entries: readonly TranscriptSourceEntry[], model: Model<Api>, instructions?: string, force?: boolean, options?: CompactionExecutionOptions): Promise<CompactionResult>;
    estimateTotalTokens(messages: AgentMessage[]): number;
    private generateHandover;
    private auditHandover;
    private sourceCursor;
    private promptFits;
    private callHandoverModels;
}
export {};