import type { NormalizedTranscript } from "../transcript/types.js";
import type { RunResult } from "../types/output.js";
import type { AgentConfig, ScoringWeights } from "../types/config.js";
import type { CategoryEvalResult, DeepEvalResult, Interaction, InteractionCategory, SparseIndex } from "../types/scoring.js";
/** Options for the deep evaluation pass. */
export interface DeepEvalOptions {
    /** Scoring weights — categories with weight 0 are skipped. */
    weights?: ScoringWeights;
    /** Report directory containing raw data files for judges. */
    reportDir?: string;
    /**
     * Judge agents in precedence order. The runner picks the first whose adapter
     * name differs from the run's own agent (or falls back to the first entry).
     */
    judging?: AgentConfig[];
}
/**
 * Run the deep evaluation as parallel per-category judge calls.
 *
 * Each category (environment, service, agent) gets its own focused LLM judge.
 * Categories with no interactions or zero weight are skipped (default scores used).
 * Speed is always computed heuristically from interaction timing data (no LLM needed).
 */
export declare function runDeepEval(result: RunResult, sparseIndex: SparseIndex, normalized: NormalizedTranscript, options?: DeepEvalOptions): Promise<DeepEvalResult>;
/**
 * Compute a heuristic speed score (0-1) for an interaction based on
 * duration and category. Deterministic — no LLM needed.
 *
 * Thresholds are generous to account for system overhead
 * (SDK roundtrips, sandbox setup, process spawning).
 */
export declare function computeHeuristicSpeed(interaction: Interaction): number;
export declare function parseCategoryEvalResponse(responseText: string, category: InteractionCategory, sparseIndex: SparseIndex): CategoryEvalResult;
/**
 * Parse the legacy deep eval LLM response (all categories in one call).
 * Kept for backward compatibility with existing tests and any code that uses it.
 */
export declare function parseDeepEvalResponse(responseText: string, sparseIndex: SparseIndex): DeepEvalResult;
/**
 * Merge per-category results into a single DeepEvalResult.
 *
 * Audits are kept per-judge — an interaction can have multiple audits (e.g. env
 * judge scored execution success, agent judge scored decision quality). Each
 * audit carries its judging category in `audit.categories`, so downstream
 * filters in `computeCategoryScore` route them correctly.
 *
 * Interactions never audited by any judge get a synthetic default tagged to
 * whichever category they belong to (or "agent" if uncategorized).
 */
export declare function mergeCategoryResults(categoryResults: CategoryEvalResult[], sparseIndex: SparseIndex): DeepEvalResult;
export declare function buildDefaultCategoryResult(category: InteractionCategory, interactions?: Interaction[]): CategoryEvalResult;
//# sourceMappingURL=deep-eval.d.ts.map