/**
 * Routing ledger: local, append-only outcome measurements per model.
 *
 * Measured routing v2 — instead of ranking failover candidates purely on
 * static heuristics (cost band, reasoning, context window), Elyra records how
 * models actually perform on this machine (turn success, edit failures,
 * retries, failovers away from a model) and uses those measurements to demote
 * demonstrably unreliable candidates.
 *
 * Privacy: only model/provider ids, counters, timings, and cost numbers are
 * stored — never prompts, file paths, or code. The ledger is a single local
 * JSONL file under the agent dir and never leaves disk.
 */
/** Task classification. Reserved prefixes keep the schema stable when subagents/swarm gain per-role model choice. */
export type LedgerTaskClass = "main" | "review" | `subagent:${string}` | `swarm:${string}`;
export interface LedgerTurnEvent {
    type: "turn";
    ts: number;
    provider: string;
    modelId: string;
    taskClass: LedgerTaskClass;
    stopReason: string;
    aborted: boolean;
    error: boolean;
    latencyMs?: number;
    inputTokens: number;
    outputTokens: number;
    cost: number;
    editsAttempted: number;
    editsFailed: number;
    retries: number;
}
export interface LedgerFailoverEvent {
    type: "failover";
    ts: number;
    fromProvider: string;
    fromModelId: string;
    toProvider?: string;
    toModelId?: string;
}
export type LedgerEvent = LedgerTurnEvent | LedgerFailoverEvent;
/** Below this many turns a model is never demoted (insufficient evidence). */
export declare const MIN_RELIABILITY_SAMPLE = 5;
export declare function appendLedgerEvent(path: string, event: LedgerEvent): void;
export declare function readLedger(path: string): LedgerEvent[];
export interface ModelOutcomeStats {
    turns: number;
    /** Fraction of turns that ended without error and without being aborted. */
    successRate: number;
    /** Times a failover moved *away* from this model. */
    failoversFrom: number;
    editsAttempted: number;
    editsFailed: number;
    retries: number;
    totalCost: number;
    avgLatencyMs?: number;
}
export declare function computeStats(events: readonly LedgerEvent[], options?: {
    taskClass?: LedgerTaskClass;
    now?: number;
}): Map<string, ModelOutcomeStats>;
export declare function loadStats(path: string, taskClass?: LedgerTaskClass): Map<string, ModelOutcomeStats>;
/** Plain-text stats report shared by `elyra doctor routing` and `/routing-stats`. */
export declare function formatStatsReport(stats: ReadonlyMap<string, ModelOutcomeStats>): string;
/**
 * Consumes AgentSession events and appends one ledger turn event per
 * assistant message. Tool results that follow an assistant message are
 * attributed to it; the record is flushed when the next assistant message
 * starts or the run ends.
 */
export declare class TurnOutcomeRecorder {
    private readonly ledgerPath;
    private readonly taskClass;
    private turnStartTs;
    private pending;
    constructor(ledgerPath: string, taskClass?: LedgerTaskClass);
    /** Handle an AgentSession event. Never throws. */
    handleEvent(rawEvent: unknown): void;
    private process;
    /** Flush the pending turn record to disk, if any. */
    flush(): void;
}
//# sourceMappingURL=routing-ledger.d.ts.map