import type { EvalCase, EvalTurn, Score, Scorer } from './types.js';
/**
 * How closely the turn's tool sequence matched the expected one, as F1 over
 * the longest common subsequence.
 *
 * Trajectory, not final answer. Namzu's most load-bearing behavior is
 * tuned by constants nobody could measure — `search_tools` activates the
 * top 5 deferred tools, compaction fires at 0.7, six state lists cap at
 * 25 — and changing any of them, or a tool description, or the
 * deferred-tools prompt block, could silently make the agent take four
 * tool calls where it took one. Final-answer scoring cannot see that;
 * this can.
 *
 * Extra calls cut precision, missing calls cut recall, so a turn that does
 * the right thing wastefully and a turn that skips a step score
 * differently — which is the distinction a final-answer score collapses.
 */
export declare function trajectoryScorer(): Scorer;
/** The turn settled cleanly rather than erroring or being cut off. */
export declare function completionScorer(acceptable?: readonly string[]): Scorer;
/**
 * The turn stayed within a step budget.
 *
 * A regression that makes the agent take four turns where it took one is
 * invisible to correctness scoring and very visible on the bill.
 */
export declare function stepBudgetScorer(maxSteps: number): Scorer;
/** The final text contains every required substring. */
export declare function containsScorer(...required: string[]): Scorer;
/**
 * Judge the turn with a caller-supplied predicate.
 *
 * The escape hatch for anything the built-in scorers do not cover. For
 * a model-graded judge, reach for `judgeScorer` first: it handles the
 * parts that are easy to get wrong — a rubric it refuses to run without,
 * an ordinal scale rather than a float, disclosed truncation, and a
 * failed call that reports as unjudged rather than as a zero.
 */
export declare function customScorer(name: string, fn: (turn: EvalTurn, evalCase: EvalCase) => Score | Promise<Score>): Scorer;
//# sourceMappingURL=scorers.d.ts.map