import type { AgentMessage } from "@mariozechner/pi-agent-core";
export type AssembleResult = {
    /** Ordered messages to use as model context */
    messages: AgentMessage[];
    /** Estimated total tokens in assembled context */
    estimatedTokens: number;
    /** Optional context-engine-provided instructions prepended to the runtime system prompt */
    systemPromptAddition?: string;
};
export type CompactResult = {
    ok: boolean;
    compacted: boolean;
    reason?: string;
    result?: {
        summary?: string;
        firstKeptEntryId?: string;
        tokensBefore: number;
        tokensAfter?: number;
        details?: unknown;
    };
};
export type IngestResult = {
    /** Whether the message was ingested (false if duplicate or no-op) */
    ingested: boolean;
};
export type IngestBatchResult = {
    /** Number of messages ingested from the supplied batch */
    ingestedCount: number;
};
export type BootstrapResult = {
    /** Whether bootstrap ran and initialized the engine's store */
    bootstrapped: boolean;
    /** Number of historical messages imported (if applicable) */
    importedMessages?: number;
    /** Optional reason when bootstrap was skipped */
    reason?: string;
};
export type ContextEngineInfo = {
    id: string;
    name: string;
    version?: string;
    /** True when the engine manages its own compaction lifecycle. */
    ownsCompaction?: boolean;
};
export type SubagentSpawnPreparation = {
    /** Roll back pre-spawn setup when subagent launch fails. */
    rollback: () => void | Promise<void>;
};
export type SubagentEndReason = "deleted" | "completed" | "swept" | "released";
/**
 * ContextEngine defines the pluggable contract for context management.
 *
 * Required methods define a generic lifecycle; optional methods allow engines
 * to provide additional capabilities (retrieval, lineage, etc.).
 */
export interface ContextEngine {
    /** Engine identifier and metadata */
    readonly info: ContextEngineInfo;
    /**
     * Initialize engine state for a session, optionally importing historical context.
     */
    bootstrap?(params: {
        sessionId: string;
        sessionFile: string;
    }): Promise<BootstrapResult>;
    /**
     * Ingest a single message into the engine's store.
     */
    ingest(params: {
        sessionId: string;
        message: AgentMessage;
        /** True when the message belongs to a heartbeat run. */
        isHeartbeat?: boolean;
    }): Promise<IngestResult>;
    /**
     * Ingest a completed turn batch as a single unit.
     */
    ingestBatch?(params: {
        sessionId: string;
        messages: AgentMessage[];
        /** True when the batch belongs to a heartbeat run. */
        isHeartbeat?: boolean;
    }): Promise<IngestBatchResult>;
    /**
     * Execute optional post-turn lifecycle work after a run attempt completes.
     * Engines can use this to persist canonical context and trigger background
     * compaction decisions.
     */
    afterTurn?(params: {
        sessionId: string;
        sessionFile: string;
        messages: AgentMessage[];
        /** Number of messages that existed before the prompt was sent. */
        prePromptMessageCount: number;
        /** Optional auto-compaction summary emitted by the runtime. */
        autoCompactionSummary?: string;
        /** True when this turn belongs to a heartbeat run. */
        isHeartbeat?: boolean;
        /** Optional model context token budget for proactive compaction. */
        tokenBudget?: number;
        /** Backward-compat only: legacy compaction bridge runtime params. */
        legacyCompactionParams?: Record<string, unknown>;
    }): Promise<void>;
    /**
     * Assemble model context under a token budget.
     * Returns an ordered set of messages ready for the model.
     */
    assemble(params: {
        sessionId: string;
        messages: AgentMessage[];
        tokenBudget?: number;
    }): Promise<AssembleResult>;
    /**
     * Compact context to reduce token usage.
     * May create summaries, prune old turns, etc.
     */
    compact(params: {
        sessionId: string;
        sessionFile: string;
        tokenBudget?: number;
        /** Backward-compat only: force legacy compaction behavior even below threshold. */
        force?: boolean;
        /** Optional live token estimate from the caller's active context. */
        currentTokenCount?: number;
        /** Controls convergence target; defaults to budget for compatibility. */
        compactionTarget?: "budget" | "threshold";
        customInstructions?: string;
        /** Backward-compat only: full params bag for legacy compaction bridge. */
        legacyParams?: Record<string, unknown>;
    }): Promise<CompactResult>;
    /**
     * Prepare context-engine-managed subagent state before the child run starts.
     *
     * Implementations can return a rollback handle that is invoked when spawn
     * fails after preparation succeeds.
     */
    prepareSubagentSpawn?(params: {
        parentSessionKey: string;
        childSessionKey: string;
        ttlMs?: number;
    }): Promise<SubagentSpawnPreparation | undefined>;
    /**
     * Notify the context engine that a subagent lifecycle ended.
     */
    onSubagentEnded?(params: {
        childSessionKey: string;
        reason: SubagentEndReason;
    }): Promise<void>;
    /**
     * Dispose of any resources held by the engine.
     */
    dispose?(): Promise<void>;
}