/**
 * Token Benchmark: runtime antigo vs runtime novo, na dimensão CUSTO.
 *
 * O que ele mede, exatamente: o PLANO. Para cada objetivo representativo,
 * compara o que o caminho legado (Planner por categoria, um modelo para o run
 * inteiro) reservaria contra o que o Commander reserva (modo proporcional +
 * roteamento por papel). As grandezas comparadas são tetos declarados e preços
 * de catálogo, então o resultado é 100% determinístico e reproduzível.
 *
 * O que ele NÃO mede: qualidade da saída do modelo nem tokens realmente
 * consumidos numa execução real (isso depende do provider e aparece na
 * telemetria de cada run, via `izanagi budget <run-id>`). Confundir as duas
 * coisas seria exatamente o tipo de número inflado que este framework proíbe.
 */
import { ModelRouter } from '../model/router.js';
import { type AgentRole } from '../contracts/task-contract.js';
import type { ModelProvider } from '../types.js';
export interface TokenBenchmarkCase {
    id: string;
    objective: string;
    /** O que este caso existe para provar. */
    hypothesis: string;
}
export declare const TOKEN_BENCHMARK_CASES: TokenBenchmarkCase[];
export interface PlanMetrics {
    mode: string;
    /** Tarefas do grafo. */
    nodes: number;
    /** Tarefas que de fato chamam um modelo (gate/validator não chamam). */
    modelCalls: number;
    /** Soma dos tetos de token declarados. */
    maxTokens: number;
    /** Custo do teto em USD, com o roteamento daquele caminho. */
    maxCostUsd: number;
    byRole?: Record<AgentRole, number>;
}
export interface TokenBenchmarkRow {
    id: string;
    objective: string;
    hypothesis: string;
    legacy: PlanMetrics;
    commander: PlanMetrics;
    /** Redução de custo em [0,1]. Negativo = o novo caminho custa mais. */
    costReduction: number;
    /** Redução de chamadas de modelo em [0,1]. */
    callReduction: number;
    /** Redução do teto de tokens em [0,1]. */
    tokenReduction: number;
}
export interface TokenBenchmarkReport {
    createdAt: string;
    catalog: string[];
    rows: TokenBenchmarkRow[];
    totals: {
        legacyTokens: number;
        commanderTokens: number;
        legacyCostUsd: number;
        commanderCostUsd: number;
        legacyModelCalls: number;
        commanderModelCalls: number;
        costReduction: number;
        callReduction: number;
        tokenReduction: number;
    };
}
/**
 * Métricas do caminho legado: template por categoria e UM modelo escolhido
 * para o run inteiro (era exatamente assim que o Orchestrator roteava antes).
 */
export declare function legacyMetrics(objective: string, router: ModelRouter): PlanMetrics;
/** Métricas do caminho novo: modo proporcional + custo por papel. */
export declare function commanderMetrics(objective: string, router: ModelRouter): PlanMetrics;
/**
 * Roda o benchmark contra o catálogo informado. Sem catálogo, usa o default
 * do ModelRouter (providers pagos + locais).
 */
export declare const PAID_CATALOG: ModelProvider[];
export declare function runTokenBenchmark(opts?: {
    providers?: ModelProvider[];
    cases?: TokenBenchmarkCase[];
}): TokenBenchmarkReport;
/** Tabela legível para a CLI. */
export declare function formatTokenBenchmark(report: TokenBenchmarkReport): string;
//# sourceMappingURL=token-benchmark.d.ts.map