stageflow 0.40.0 → 0.44.0

package/dist/evals/read/datasets.js

@@ -0,0 +1,318 @@
+import path from "node:path";
+import { isInsideProjectRoot } from "../../config/catalogRelativePath.js";
+import { parseCsv, CsvParseError } from "../../config/csv.js";
+import { checkDatasetAgainstAgent } from "../../config/datasetAgentCheck.js";
+import { checkDatasetAgainstStage } from "../../config/datasetStageCheck.js";
+import { applyUploadMapping, formatId, nextIdNumber, } from "../../config/datasetImport.js";
+import { DATASET_LIMITS } from "../../config/loadDataset.js";
+import { resolveEvalTarget } from "../../config/resolveEvalTarget.js";
+import { AGENT_ID_PATTERN, isReservedAgentId } from "../../agents/agentId.js";
+import { isAgentError } from "../../agents/errors.js";
+export function agentInputFields(mode) {
+    const simulated = mode === "simulated";
+    return [
+        { name: "mode", required: false },
+        { name: "opening", required: simulated },
+        { name: "persona", required: simulated },
+        { name: "goal", required: simulated },
+        { name: "facts", required: false },
+        { name: "script", required: !simulated },
+        { name: "tool_mocks", required: false },
+    ];
+}
+/** The upload mapping targets an agent dataset cannot take from a column: scripts and tool mocks are JSON or JSONL only. */
+export const AGENT_UNSUPPORTED_MAPPING_TARGETS = ["input.script", "input.tool_mocks"];
+export function inputFieldsOf(schema) {
+    if (typeof schema !== "object" || schema === null)
+        return [];
+    const { properties, required } = schema;
+    if (typeof properties !== "object" || properties === null)
+        return [];
+    const requiredSet = new Set(Array.isArray(required) ? required.filter((r) => typeof r === "string") : []);
+    return Object.entries(properties).map(([name, prop]) => {
+        const type = typeof prop === "object" && prop !== null ? prop.type : undefined;
+        return { name, required: requiredSet.has(name), ...(typeof type === "string" ? { type } : {}) };
+    });
+}
+export async function resolveDatasetTarget(projectRoot, target, agents) {
+    if (target.agent_id !== undefined) {
+        if (target.file !== undefined || target.pipeline_path !== undefined || target.stage_id !== undefined) {
+            return { ok: false, message: "target needs either agent_id, file, or pipeline_path with stage_id" };
+        }
+        const agentId = target.agent_id;
+        if (!AGENT_ID_PATTERN.test(agentId) || isReservedAgentId(agentId)) {
+            return { ok: false, message: `"${agentId}" is not a valid agent id` };
+        }
+        if (agents) {
+            try {
+                await agents.get(projectRoot, agentId);
+            }
+            catch (err) {
+                if (isAgentError(err))
+                    return { ok: false, message: `Agent "${agentId}" was not found` };
+                throw err;
+            }
+        }
+        return { ok: true, value: { inputSchema: undefined, stageId: undefined, pipelineAbsPath: undefined, agentId } };
+    }
+    const kindFile = target.file !== undefined;
+    const kindPipeline = target.pipeline_path !== undefined && target.stage_id !== undefined;
+    if (kindFile === kindPipeline) {
+        return { ok: false, message: "target needs either file or pipeline_path with stage_id" };
+    }
+    const given = (kindFile ? target.file : target.pipeline_path);
+    if (path.isAbsolute(given) || !isInsideProjectRoot(projectRoot, path.resolve(projectRoot, given))) {
+        return { ok: false, message: "target path must be relative and inside the project" };
+    }
+    const evalAbs = path.join(projectRoot, "target-lookup.eval.yaml");
+    const file = {
+        version: 1,
+        id: "target-lookup",
+        target: kindFile
+            ? { kind: "stage", file: target.file }
+            : { kind: "stage", pipeline: target.pipeline_path, stage: target.stage_id },
+        dataset: "target-lookup.dataset.jsonl",
+        graders: [],
+    };
+    const outcome = await resolveEvalTarget(file, evalAbs, projectRoot);
+    if (!outcome.ok)
+        return { ok: false, message: outcome.issues[0]?.message ?? "target does not resolve" };
+    const { inputSchema, stageId, pipelinePath } = outcome.value;
+    return { ok: true, value: { inputSchema, stageId, pipelineAbsPath: pipelinePath } };
+}
+export function buildDatasetDetail(input) {
+    const { loaded, query } = input;
+    const checks = input.hasEval
+        ? new Map((input.agent
+            ? checkDatasetAgainstAgent(loaded.cases, { mode: input.agent.mode })
+            : checkDatasetAgainstStage(loaded.cases, input.inputSchema)).map((c) => [c.caseId, c]))
+        : undefined;
+    const tags = {};
+    let tagged = 0;
+    let invalid = 0;
+    for (const c of loaded.cases) {
+        if ((c.tags ?? []).length > 0)
+            tagged += 1;
+        for (const tag of c.tags ?? [])
+            tags[tag] = (tags[tag] ?? 0) + 1;
+        if (checks?.get(c.id)?.valid === false)
+            invalid += 1;
+    }
+    const q = query.q?.trim().toLowerCase();
+    const matched = loaded.cases.filter((c) => {
+        const check = checks?.get(c.id);
+        if (query.filter === "invalid" && check?.valid !== false)
+            return false;
+        if (query.filter === "tagged" && (c.tags ?? []).length === 0)
+            return false;
+        if (query.tag !== undefined && !(c.tags ?? []).includes(query.tag))
+            return false;
+        if (q === undefined || q === "")
+            return true;
+        return `${c.id}\n${c.title ?? ""}\n${JSON.stringify(c.input)}`.toLowerCase().includes(q);
+    });
+    const page = matched.slice(query.offset, query.offset + query.limit);
+    return {
+        id: input.id,
+        path: loaded.relPath,
+        format: loaded.format ?? null,
+        hash: loaded.contentHash,
+        editable: loaded.format === "jsonl",
+        cases_total: loaded.cases.length,
+        invalid_total: invalid,
+        tagged_total: tagged,
+        matched_total: matched.length,
+        tags,
+        input_fields: input.agent ? agentInputFields(input.agent.mode) : inputFieldsOf(input.inputSchema),
+        cases: page.map((c) => {
+            const check = checks?.get(c.id);
+            return {
+                ...c,
+                input_check: check === undefined ? null : { valid: check.valid, ...(check.message !== undefined ? { message: check.message } : {}) },
+            };
+        }),
+        findings: input.agent && input.hasEval ? [...loaded.findings, ...scenarioNotes(loaded.relPath, checks)] : loaded.findings,
+        used_by: input.usedBy,
+    };
+}
+function scenarioNotes(relPath, checks) {
+    const out = [];
+    for (const check of checks?.values() ?? []) {
+        for (const note of check.notes ?? []) {
+            out.push({ severity: "warning", code: note.code, path: relPath, message: note.message, category: "dataset" });
+        }
+    }
+    return out;
+}
+const CASE_KEYS = new Set(["id", "input", "title", "expected", "tags", "goal", "metadata"]);
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function uploadFinding(code, message, line) {
+    return {
+        severity: "error",
+        code,
+        path: "",
+        message,
+        category: "dataset",
+        ...(line !== undefined ? { line } : {}),
+    };
+}
+function isPlain(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseObjectRows(format, content, findings) {
+    if (format === "jsonl") {
+        const rows = [];
+        content.split(/\r?\n/).forEach((line, idx) => {
+            if (line.trim() === "")
+                return;
+            try {
+                const value = JSON.parse(line);
+                if (isPlain(value))
+                    rows.push(value);
+                else
+                    findings.push(uploadFinding("dataset.not_object", `line ${idx + 1}: not a JSON object`, idx + 1));
+            }
+            catch {
+                findings.push(uploadFinding("dataset.load_error", `line ${idx + 1}: invalid JSON`, idx + 1));
+            }
+        });
+        return rows;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        const list = Array.isArray(parsed) ? parsed : isPlain(parsed) && Array.isArray(parsed.cases) ? parsed.cases : undefined;
+        if (list === undefined) {
+            findings.push(uploadFinding("dataset.invalid_shape", "JSON must be an array of cases or { cases: [...] }"));
+            return [];
+        }
+        return list.filter(isPlain);
+    }
+    catch {
+        findings.push(uploadFinding("dataset.load_error", "content is not valid JSON"));
+        return [];
+    }
+}
+function stringCell(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function defaultMapping(columns, inputSchema, agent) {
+    const mapping = {};
+    if (agent) {
+        for (const field of agentInputFields(agent.mode)) {
+            if (field.name === "script" || field.name === "tool_mocks")
+                continue;
+            const column = columns.find((c) => c === field.name || c === `input.${field.name}`);
+            mapping[`input.${field.name}`] =
+                column === undefined ? null : field.name === "facts" ? { column, split: "|" } : { column };
+        }
+        return mapping;
+    }
+    const fields = inputFieldsOf(inputSchema);
+    if (fields.length === 0) {
+        for (const column of columns)
+            mapping[`input.${column}`] = { column };
+        return mapping;
+    }
+    for (const field of fields) {
+        const column = columns.find((c) => c === field.name || c === `input.${field.name}`);
+        mapping[`input.${field.name}`] = column === undefined ? null : { column };
+    }
+    return mapping;
+}
+function scenarioReason(draft, mode) {
+    const [result] = checkDatasetAgainstAgent([draft], { mode });
+    return result !== undefined && !result.valid ? result.message : undefined;
+}
+function directRows(objects, inputSchema, existingIds, agent) {
+    const shaped = objects.map((raw) => (isPlain(raw.input) ? raw : { input: raw }));
+    let next = nextIdNumber([...existingIds, ...shaped.flatMap((o) => (typeof o.id === "string" ? [o.id] : []))]);
+    const cases = shaped.map((o, i) => ({ id: String(i), input: o.input }));
+    const checks = agent
+        ? checkDatasetAgainstAgent(cases, { mode: agent.mode })
+        : checkDatasetAgainstStage(cases, inputSchema);
+    return shaped.map((row, index) => {
+        const draft = { ...row, id: typeof row.id === "string" ? row.id : "" };
+        const unknownKey = Object.keys(row).find((k) => !CASE_KEYS.has(k));
+        let reason;
+        if (unknownKey !== undefined)
+            reason = `unknown key "${unknownKey}"`;
+        else if (draft.id !== "" && !ID_RE.test(draft.id))
+            reason = `id "${draft.id}" is not valid`;
+        else if (!checks[index]?.valid)
+            reason = checks[index]?.message?.replace(/\s+/g, " ").slice(0, 160);
+        if (reason !== undefined)
+            return { index, case: draft, status: "skipped", reason };
+        if (draft.id === "") {
+            draft.id = formatId(next);
+            next += 1;
+        }
+        return { index, case: draft, status: "ready" };
+    });
+}
+export function previewUpload(input) {
+    const findings = [];
+    const existingIds = input.existingIds ?? [];
+    const { agent } = input;
+    const mapOptions = agent
+        ? { caseMeta: true, check: (draft) => scenarioReason(draft, agent.mode) }
+        : {};
+    if (agent && input.mapping !== undefined) {
+        for (const target of AGENT_UNSUPPORTED_MAPPING_TARGETS) {
+            if (input.mapping[target] != null) {
+                findings.push(uploadFinding("dataset.mapping_unsupported_field", `${target} cannot be mapped from a file column; scripts and tool mocks need a JSON or JSONL file`));
+            }
+        }
+        if (findings.length > 0)
+            return { rows: [], findings, counts: { ready: 0, skipped: 0 } };
+    }
+    if (Buffer.byteLength(input.content, "utf8") > DATASET_LIMITS.maxFileBytes) {
+        findings.push(uploadFinding("dataset.file_too_large", `file is larger than ${DATASET_LIMITS.maxFileBytes} bytes`));
+        return { rows: [], findings, counts: { ready: 0, skipped: 0 } };
+    }
+    let columns;
+    let rows = [];
+    if (input.format === "csv") {
+        let records = [];
+        try {
+            records = parseCsv(input.content, input.delimiter !== undefined ? { delimiter: input.delimiter } : {});
+        }
+        catch (err) {
+            findings.push(uploadFinding("dataset.load_error", err instanceof CsvParseError ? err.message : "invalid CSV", err instanceof CsvParseError ? err.record : undefined));
+        }
+        const headerIdx = records.findIndex((r) => !(r.length === 1 && r[0] === ""));
+        if (headerIdx !== -1) {
+            const headers = records[headerIdx].map((h) => h.trim());
+            columns = headers;
+            const body = records
+                .slice(headerIdx + 1)
+                .filter((r) => !(r.length === 1 && r[0] === ""))
+                .map((cells) => Object.fromEntries(headers.map((h, i) => [h, cells[i] ?? ""])));
+            rows = applyUploadMapping(body, input.mapping ?? defaultMapping(headers, input.inputSchema, agent), input.inputSchema, existingIds, mapOptions);
+        }
+    }
+    else {
+        const objects = parseObjectRows(input.format, input.content, findings);
+        if (input.mapping !== undefined) {
+            const keys = [...new Set(objects.flatMap((o) => Object.keys(o)))];
+            columns = keys;
+            const flat = objects.map((o) => Object.fromEntries(keys.filter((k) => k in o).map((k) => [k, stringCell(o[k])])));
+            rows = applyUploadMapping(flat, input.mapping, input.inputSchema, existingIds, mapOptions);
+        }
+        else {
+            rows = directRows(objects, input.inputSchema, existingIds, agent);
+        }
+    }
+    if (rows.length === 0 && !findings.some((f) => f.severity === "error")) {
+        findings.push(uploadFinding("dataset.empty", "no rows found"));
+    }
+    if (rows.length > DATASET_LIMITS.maxCases) {
+        findings.push(uploadFinding("dataset.too_many_cases", `more than ${DATASET_LIMITS.maxCases} rows`));
+    }
+    const ready = rows.filter((r) => r.status === "ready").length;
+    return {
+        ...(columns !== undefined ? { columns } : {}),
+        rows,
+        findings,
+        counts: { ready, skipped: rows.length - ready },
+    };
+}

package/dist/evals/read/list.d.ts

@@ -0,0 +1,66 @@
+import type { EvalCatalogEntry } from "../../config/evalCatalog.js";
+import type { AgentCatalogPort } from "../../config/resolveAgentTarget.js";
+import { type BannerEvalInput, type ListStatus, type RegressionBanner } from "../listStatus.js";
+import { type ActiveRun, type ReadStore, type RunHeadline } from "./runs.js";
+export type EvalListTarget = {
+    kind: "stage";
+    pipeline_path?: string;
+    stage_id?: string;
+    file?: string;
+    label: string;
+} | {
+    kind: "agent";
+    agent_id: string;
+    agent_name: string;
+    model: string | null;
+    revision: number | null;
+    label: string;
+};
+export type EvalListItem = {
+    project_root?: string;
+    id: string;
+    name: string;
+    description: string | null;
+    type: string;
+    path: string;
+    target: EvalListTarget;
+    conversation?: {
+        mode: string;
+        max_turns: number;
+        tools: string;
+        approvals: string;
+    };
+    dataset_path: string;
+    dataset_cases: number;
+    repeats: number;
+    grader_count: number;
+    rubric_count: number;
+    valid: boolean;
+    finding_count: number;
+    status: ListStatus | "running";
+    active_run: ActiveRun | null;
+    last_run: RunHeadline | null;
+    last_run_delta_pts: number | null;
+    trend: Array<{
+        run_number: number;
+        passed: boolean;
+        pass_rate: number | null;
+        pass_threshold: number;
+    }>;
+};
+export declare function filterEvalListItems(items: readonly EvalListItem[], filter: {
+    target_kind?: string | null;
+    agent?: string | null;
+}): EvalListItem[];
+export declare function buildEvalListItems(input: {
+    store: ReadStore;
+    projectRoot: string;
+    entries: readonly EvalCatalogEntry[];
+    datasetCases: (absPath: string) => number;
+    agents?: AgentCatalogPort;
+}): Promise<{
+    items: EvalListItem[];
+    banner: RegressionBanner | null;
+    bannerInputs: BannerEvalInput[];
+}>;
+export declare function costLastSevenDays(store: Pick<ReadStore, "listEvalRuns">, projectRoot: string, now: Date): Promise<number>;

package/dist/evals/read/list.js

@@ -0,0 +1,182 @@
+import path from "node:path";
+import { EVAL_DEFAULT_REPEATS, resolveConversation, resolveEvalPaths } from "../../config/loadEval.js";
+import { evalStem } from "../../config/evalWriteRoots.js";
+import { listStatus, regressionBanner, } from "../listStatus.js";
+import { activeRunOf, completedRunsNewestFirst, runHeadline, statsOfRun, } from "./runs.js";
+const TREND_RUNS = 7;
+function posix(projectRoot, abs) {
+    return path.relative(projectRoot, abs).split(path.sep).join("/");
+}
+function pipelineStem(pipelinePath) {
+    return path.basename(pipelinePath).replace(/\.pipeline\.ya?ml$/, "");
+}
+function str(value) {
+    return typeof value === "string" && value !== "" ? value : null;
+}
+async function agentListTarget(agentId, last, agents, projectRoot) {
+    const snap = last && last.targetKind === "agent" ? last.config.target : undefined;
+    let name = null;
+    let model = null;
+    let revision = null;
+    if (snap) {
+        const def = (snap.definition ?? {});
+        name = str(def.name);
+        model = str(snap.model);
+        revision = typeof snap.revision === "number" ? snap.revision : null;
+    }
+    else if (agents) {
+        try {
+            const detail = await agents.get(projectRoot, agentId);
+            name = str(detail.agent.name);
+            model = str(detail.agent.model?.id);
+            revision = detail.agent.revision;
+        }
+        catch {
+            // the agent may be deleted or unreadable: fall back to the id
+        }
+    }
+    const agentName = name ?? agentId;
+    return { kind: "agent", agent_id: agentId, agent_name: agentName, model, revision, label: agentName };
+}
+export function filterEvalListItems(items, filter) {
+    return items.filter((item) => {
+        if (filter.target_kind && item.target.kind !== filter.target_kind)
+            return false;
+        if (filter.agent && !(item.target.kind === "agent" && item.target.agent_id === filter.agent))
+            return false;
+        return true;
+    });
+}
+async function listRunSummary(store, row) {
+    const stats = statsOfRun(row, await store.listEvalResults(row.evalRunId));
+    return {
+        runNumber: row.runNumber,
+        passed: row.passed === true,
+        passRate: stats.pass_rate,
+        finishedAt: row.finishedAt,
+        graders: stats.by_grader.map((g) => ({ graderId: g.grader_id, hash: g.hash, passRate: g.pass_rate })),
+    };
+}
+export async function buildEvalListItems(input) {
+    const { store, projectRoot } = input;
+    const items = [];
+    const bannerInputs = [];
+    for (const entry of input.entries) {
+        const findingCount = entry.findings.length;
+        const valid = !entry.findings.some((f) => f.severity === "error");
+        if (!entry.outcome.ok) {
+            const id = evalStem(path.basename(entry.absPath));
+            items.push({
+                id,
+                name: id,
+                description: null,
+                type: "capability",
+                path: entry.relPath,
+                target: { kind: "stage", label: "Unknown target" },
+                dataset_path: "",
+                dataset_cases: 0,
+                repeats: EVAL_DEFAULT_REPEATS,
+                grader_count: 0,
+                rubric_count: 0,
+                valid: false,
+                finding_count: findingCount,
+                status: "never_run",
+                active_run: null,
+                last_run: null,
+                last_run_delta_pts: null,
+                trend: [],
+            });
+            continue;
+        }
+        const loaded = entry.outcome.value;
+        const { file } = loaded;
+        const paths = resolveEvalPaths(file, loaded.path);
+        const type = file.type ?? "capability";
+        const stageId = file.target.kind === "stage" ? file.target.stage : undefined;
+        const completed = await completedRunsNewestFirst(store, projectRoot, loaded.id);
+        const last = completed[0];
+        const previous = completed[1];
+        const lastSummary = last ? await listRunSummary(store, last) : null;
+        const previousSummary = previous ? await listRunSummary(store, previous) : null;
+        const status = listStatus([lastSummary, previousSummary].filter((s) => s !== null), type);
+        const activeRun = await activeRunOf(store, projectRoot, loaded.id);
+        bannerInputs.push({ evalId: loaded.id, status, last: lastSummary, previous: previousSummary });
+        const agentTarget = file.target.kind === "agent"
+            ? await agentListTarget(file.target.agent, last, input.agents, projectRoot)
+            : file.target.kind === "internal_agent"
+                ? {
+                    kind: "agent",
+                    agent_id: file.target.profile,
+                    agent_name: file.target.profile,
+                    model: file.defaults?.model ?? null,
+                    revision: null,
+                    label: `${file.target.profile} (internal)`,
+                }
+                : undefined;
+        const conv = agentTarget ? resolveConversation(file.conversation) : undefined;
+        const pipelinePath = paths.pipelinePath !== undefined ? posix(projectRoot, paths.pipelinePath) : undefined;
+        const stageFile = paths.stageFile !== undefined ? posix(projectRoot, paths.stageFile) : undefined;
+        const label = pipelinePath !== undefined
+            ? `${pipelineStem(pipelinePath)} · ${stageId ?? ""}`
+            : path.basename(stageFile ?? "").replace(/\.(stage\.)?ya?ml$/, "");
+        const delta = lastSummary?.passRate != null && previousSummary?.passRate != null
+            ? (lastSummary.passRate - previousSummary.passRate) * 100
+            : null;
+        items.push({
+            id: loaded.id,
+            name: file.name ?? loaded.id,
+            description: file.description ?? null,
+            type,
+            path: entry.relPath,
+            target: agentTarget ?? {
+                kind: "stage",
+                ...(pipelinePath !== undefined ? { pipeline_path: pipelinePath } : {}),
+                ...(stageId !== undefined ? { stage_id: stageId } : {}),
+                ...(stageFile !== undefined ? { file: stageFile } : {}),
+                label,
+            },
+            ...(conv
+                ? { conversation: { mode: conv.mode, max_turns: conv.maxTurns, tools: conv.tools, approvals: conv.approvals } }
+                : {}),
+            dataset_path: posix(projectRoot, paths.datasetPath),
+            dataset_cases: input.datasetCases(paths.datasetPath),
+            repeats: file.defaults?.repeats ?? EVAL_DEFAULT_REPEATS,
+            grader_count: loaded.graders.length,
+            rubric_count: loaded.graders.filter((g) => g.type === "rubric").length,
+            valid,
+            finding_count: findingCount,
+            status: activeRun ? "running" : status,
+            active_run: activeRun,
+            last_run: last ? runHeadline(last) : null,
+            last_run_delta_pts: delta,
+            trend: completed
+                .slice(0, TREND_RUNS)
+                .reverse()
+                .map((r) => ({
+                run_number: r.runNumber,
+                passed: r.passed === true,
+                pass_rate: (r.summary ?? {}).pass_rate ?? null,
+                pass_threshold: r.passThreshold,
+            })),
+        });
+    }
+    return { items, banner: regressionBanner(bannerInputs), bannerInputs };
+}
+export async function costLastSevenDays(store, projectRoot, now) {
+    const cutoff = now.getTime() - 7 * 24 * 3600 * 1000;
+    const createdFloor = cutoff - 24 * 3600 * 1000;
+    let total = 0;
+    let cursor;
+    for (let pages = 0; pages < 50; pages += 1) {
+        const page = await store.listEvalRuns({ projectRoot, limit: 200, ...(cursor ? { cursor } : {}) });
+        for (const run of page.items) {
+            if (run.finishedAt !== null && Date.parse(run.finishedAt) >= cutoff)
+                total += run.costUsd;
+        }
+        const oldest = page.items[page.items.length - 1];
+        if (page.nextCursor === null || !oldest || Date.parse(oldest.createdAt) < createdFloor)
+            break;
+        cursor = page.nextCursor;
+    }
+    return total;
+}

package/dist/evals/read/results.d.ts

@@ -0,0 +1,46 @@
+import type { EvalCaseRow, EvalResultWithGrades, EvalReviewRow } from "../storeTypes.js";
+export declare const RESULT_ROW_STATUSES: readonly ["passed", "failed", "errored", "flaky"];
+export type ResultRowStatus = (typeof RESULT_ROW_STATUSES)[number];
+export type ResultRow = {
+    case_id: string;
+    position: number;
+    title: string | null;
+    tags: string[];
+    repeats: Array<{
+        repeat_index: number;
+        status: string;
+        passed: boolean;
+        score: number | null;
+    }>;
+    pass_fraction: number | null;
+    mean_score: number | null;
+    failed_graders: string[];
+    latency_ms_p50: number | null;
+    cost_usd: number;
+    failure_tags: string[];
+    turns?: number | null;
+    tool_calls?: number | null;
+};
+export type ResultRowFilter = {
+    status?: ResultRowStatus;
+    grader?: string;
+    q?: string;
+    tag?: string;
+};
+export type ResultRowCounts = {
+    all: number;
+    passed: number;
+    failed: number;
+    errored: number;
+    flaky: number;
+};
+export declare function buildResultRows(input: {
+    cases: readonly EvalCaseRow[];
+    results: readonly EvalResultWithGrades[];
+    reviews: readonly EvalReviewRow[];
+    filter?: ResultRowFilter;
+    targetKind?: string;
+}): {
+    rows: ResultRow[];
+    counts: ResultRowCounts;
+};