agent-regression-lab 0.1.0

package/dist/storage.js

@@ -0,0 +1,394 @@
+import { DatabaseSync } from "node:sqlite";
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { ensureParentDir } from "./lib/fs.js";
+const DB_PATH = resolve("artifacts", "agentlab.db");
+const SCHEMA_VERSION = "2";
+export class Storage {
+    db;
+    constructor() {
+        ensureParentDir(DB_PATH);
+        this.db = new DatabaseSync(DB_PATH);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS scenarios (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        suite TEXT NOT NULL,
+        description TEXT,
+        tags_json TEXT,
+        difficulty TEXT,
+        file_path TEXT NOT NULL,
+        file_hash TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS agent_versions (
+        id TEXT PRIMARY KEY,
+        label TEXT NOT NULL,
+        model_id TEXT,
+        provider TEXT,
+        command TEXT,
+        args_json TEXT,
+        config_json TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        scenario_id TEXT NOT NULL,
+        scenario_file_hash TEXT NOT NULL,
+        agent_version_id TEXT NOT NULL,
+        status TEXT NOT NULL,
+        termination_reason TEXT NOT NULL,
+        final_output TEXT NOT NULL,
+        total_steps INTEGER NOT NULL,
+        total_tool_calls INTEGER NOT NULL,
+        duration_ms INTEGER NOT NULL,
+        total_tokens INTEGER,
+        total_cost_usd REAL,
+        score INTEGER NOT NULL,
+        started_at TEXT NOT NULL,
+        finished_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS run_steps (
+        id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        step_index INTEGER NOT NULL,
+        timestamp TEXT NOT NULL,
+        source TEXT NOT NULL,
+        type TEXT NOT NULL,
+        payload_json TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS tool_calls (
+        id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        step_index INTEGER NOT NULL,
+        tool_name TEXT NOT NULL,
+        input_json TEXT NOT NULL,
+        output_json TEXT,
+        status TEXT NOT NULL,
+        duration_ms INTEGER,
+        error_message TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS evaluator_results (
+        id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        evaluator_id TEXT NOT NULL,
+        evaluator_type TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        status TEXT NOT NULL,
+        raw_score REAL,
+        normalized_score REAL,
+        weight REAL,
+        message TEXT NOT NULL,
+        details_json TEXT
+      );
+    `);
+        this.ensureSchemaVersion();
+        this.ensureAgentVersionColumns();
+    }
+    upsertScenario(summary, definition, filePath, fileHash) {
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT INTO scenarios (id, name, suite, description, tags_json, difficulty, file_path, file_hash, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name,
+           suite = excluded.suite,
+           description = excluded.description,
+           tags_json = excluded.tags_json,
+           difficulty = excluded.difficulty,
+           file_path = excluded.file_path,
+           file_hash = excluded.file_hash,
+           updated_at = excluded.updated_at`)
+            .run(summary.id, summary.name, summary.suite, summary.description ?? null, JSON.stringify(definition.tags ?? []), summary.difficulty ?? null, filePath, fileHash, now, now);
+    }
+    upsertAgentVersion(agentVersion) {
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT INTO agent_versions (id, label, model_id, provider, command, args_json, config_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           label = excluded.label,
+           model_id = excluded.model_id,
+           provider = excluded.provider,
+           command = excluded.command,
+           args_json = excluded.args_json,
+           config_json = excluded.config_json`)
+            .run(agentVersion.id, agentVersion.label, agentVersion.modelId ?? null, agentVersion.provider ?? null, agentVersion.command ?? null, JSON.stringify(agentVersion.args ?? []), JSON.stringify(agentVersion.config), now);
+    }
+    saveRun(bundle) {
+        const run = bundle.run;
+        this.db
+            .prepare(`INSERT INTO runs (
+          id, scenario_id, scenario_file_hash, agent_version_id, status, termination_reason, final_output,
+          total_steps, total_tool_calls, duration_ms, total_tokens, total_cost_usd, score, started_at, finished_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(run.id, run.scenarioId, run.scenarioFileHash, run.agentVersionId, run.status, run.terminationReason, run.finalOutput, run.totalSteps, run.totalToolCalls, run.durationMs, run.totalTokens ?? null, run.totalCostUsd ?? null, run.score, run.startedAt, run.finishedAt);
+        const insertStep = this.db.prepare(`INSERT INTO run_steps (id, run_id, step_index, timestamp, source, type, payload_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        const insertTool = this.db.prepare(`INSERT INTO tool_calls (id, run_id, step_index, tool_name, input_json, output_json, status, duration_ms, error_message)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const insertEval = this.db.prepare(`INSERT INTO evaluator_results (id, run_id, evaluator_id, evaluator_type, mode, status, raw_score, normalized_score, weight, message, details_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        this.db.exec("BEGIN");
+        try {
+            for (const event of bundle.traceEvents) {
+                insertStep.run(event.eventId, bundle.run.id, event.stepIndex, event.timestamp, event.source, event.type, JSON.stringify(event.payload));
+            }
+            for (const toolCall of bundle.toolCalls) {
+                insertTool.run(toolCall.id, bundle.run.id, toolCall.stepIndex, toolCall.toolName, JSON.stringify(toolCall.input), toolCall.output === undefined ? null : JSON.stringify(toolCall.output), toolCall.status, toolCall.durationMs ?? null, toolCall.errorMessage ?? null);
+            }
+            for (const result of bundle.evaluatorResults) {
+                insertEval.run(`${bundle.run.id}:${result.evaluatorId}`, bundle.run.id, result.evaluatorId, result.evaluatorType, result.mode, result.status, result.rawScore ?? null, result.normalizedScore ?? null, result.weight ?? null, result.message, result.details ? JSON.stringify(result.details) : null);
+            }
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+        this.writeTraceArtifact(bundle.run.id, bundle.traceEvents);
+    }
+    listRuns(filters = {}) {
+        const clauses = [];
+        const values = [];
+        if (filters.suite) {
+            clauses.push("s.suite = ?");
+            values.push(filters.suite);
+        }
+        if (filters.status) {
+            clauses.push("r.status = ?");
+            values.push(filters.status);
+        }
+        if (filters.provider) {
+            clauses.push("av.provider = ?");
+            values.push(filters.provider);
+        }
+        const whereClause = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+        return this.db
+            .prepare(`SELECT r.id, r.scenario_id as scenarioId, s.suite, r.agent_version_id as agentVersionId,
+                av.label as agentLabel, av.provider, av.model_id as modelId,
+                r.status, r.score, r.duration_ms as durationMs, r.total_steps as totalSteps,
+                r.started_at as startedAt
+         FROM runs r
+         JOIN scenarios s ON s.id = r.scenario_id
+         JOIN agent_versions av ON av.id = r.agent_version_id
+         ${whereClause}
+         ORDER BY r.started_at DESC`)
+            .all(...values);
+    }
+    getRun(runId) {
+        const run = this.getRunRecord(runId);
+        if (!run) {
+            return null;
+        }
+        const traceEvents = this.db
+            .prepare(`SELECT id as eventId, run_id as runId, step_index as stepIndex, timestamp, source, type, payload_json
+         FROM run_steps WHERE run_id = ? ORDER BY step_index ASC`)
+            .all(runId)
+            .map((row) => ({
+            eventId: row.eventId,
+            runId: row.runId,
+            scenarioId: run.scenarioId,
+            stepIndex: row.stepIndex,
+            timestamp: row.timestamp,
+            source: row.source,
+            type: row.type,
+            payload: JSON.parse(row.payload_json),
+        }));
+        const toolCalls = this.db
+            .prepare(`SELECT id, step_index as stepIndex, tool_name as toolName, input_json, output_json, status, duration_ms as durationMs, error_message as errorMessage
+         FROM tool_calls WHERE run_id = ? ORDER BY step_index ASC`)
+            .all(runId)
+            .map((row) => ({
+            id: row.id,
+            stepIndex: row.stepIndex,
+            toolName: row.toolName,
+            input: JSON.parse(row.input_json),
+            output: row.output_json ? JSON.parse(row.output_json) : undefined,
+            status: row.status,
+            durationMs: row.durationMs ?? undefined,
+            errorMessage: row.errorMessage ?? undefined,
+        }));
+        const evaluatorResults = this.db
+            .prepare(`SELECT evaluator_id as evaluatorId, evaluator_type as evaluatorType, mode, status, raw_score as rawScore,
+                normalized_score as normalizedScore, weight, message, details_json
+         FROM evaluator_results WHERE run_id = ? ORDER BY evaluator_id ASC`)
+            .all(runId)
+            .map((row) => ({
+            evaluatorId: row.evaluatorId,
+            evaluatorType: row.evaluatorType,
+            mode: row.mode,
+            status: row.status,
+            rawScore: row.rawScore ?? undefined,
+            normalizedScore: row.normalizedScore ?? undefined,
+            weight: row.weight ?? undefined,
+            message: row.message,
+            details: row.details_json ? JSON.parse(row.details_json) : undefined,
+        }));
+        const agentVersion = this.db
+            .prepare(`SELECT id, label, model_id as modelId, provider, command, args_json, config_json
+         FROM agent_versions WHERE id = ?`)
+            .get(run.agentVersionId);
+        return {
+            run,
+            traceEvents,
+            toolCalls,
+            evaluatorResults,
+            agentVersion: agentVersion
+                ? {
+                    id: agentVersion.id,
+                    label: agentVersion.label,
+                    modelId: agentVersion.modelId ?? undefined,
+                    provider: agentVersion.provider ?? undefined,
+                    command: agentVersion.command ?? undefined,
+                    args: agentVersion.args_json ? JSON.parse(agentVersion.args_json) : undefined,
+                    config: JSON.parse(agentVersion.config_json),
+                }
+                : undefined,
+        };
+    }
+    compareRuns(baselineRunId, candidateRunId) {
+        const baseline = this.getRun(baselineRunId);
+        const candidate = this.getRun(candidateRunId);
+        if (!baseline) {
+            throw new Error(`Run '${baselineRunId}' not found.`);
+        }
+        if (!candidate) {
+            throw new Error(`Run '${candidateRunId}' not found.`);
+        }
+        if (baseline.run.scenarioId !== candidate.run.scenarioId) {
+            throw new Error("Runs can only be compared when they share the same scenario id.");
+        }
+        if (baseline.run.scenarioFileHash !== candidate.run.scenarioFileHash) {
+            throw new Error("Runs can only be compared when they share the same scenario file hash.");
+        }
+        const notes = [];
+        if (baseline.run.status !== candidate.run.status) {
+            notes.push(`Verdict changed: ${baseline.run.status} -> ${candidate.run.status}`);
+        }
+        if (baseline.run.score !== candidate.run.score) {
+            notes.push(`Score changed: ${baseline.run.score} -> ${candidate.run.score}`);
+        }
+        if (baseline.run.totalSteps !== candidate.run.totalSteps) {
+            notes.push(`Steps changed: ${baseline.run.totalSteps} -> ${candidate.run.totalSteps}`);
+        }
+        if (baseline.run.durationMs !== candidate.run.durationMs) {
+            notes.push(`Runtime changed: ${baseline.run.durationMs}ms -> ${candidate.run.durationMs}ms`);
+        }
+        if (baseline.run.terminationReason !== candidate.run.terminationReason) {
+            notes.push(`Termination changed: ${baseline.run.terminationReason} -> ${candidate.run.terminationReason}`);
+        }
+        const evaluatorDiffs = buildEvaluatorDiffs(baseline, candidate);
+        const toolDiffs = buildToolDiffs(baseline, candidate);
+        return {
+            baseline,
+            candidate,
+            notes,
+            deltas: {
+                score: candidate.run.score - baseline.run.score,
+                runtimeMs: candidate.run.durationMs - baseline.run.durationMs,
+                steps: candidate.run.totalSteps - baseline.run.totalSteps,
+            },
+            evaluatorDiffs,
+            toolDiffs,
+        };
+    }
+    getRunRecord(runId) {
+        return (this.db
+            .prepare(`SELECT id, scenario_id as scenarioId, scenario_file_hash as scenarioFileHash, agent_version_id as agentVersionId,
+                  status, termination_reason as terminationReason, final_output as finalOutput, total_steps as totalSteps,
+                  total_tool_calls as totalToolCalls, duration_ms as durationMs, total_tokens as totalTokens,
+                  total_cost_usd as totalCostUsd, score, started_at as startedAt, finished_at as finishedAt
+           FROM runs WHERE id = ?`)
+            .get(runId) ?? null);
+    }
+    getRunRecordOrThrow(runId) {
+        const run = this.getRunRecord(runId);
+        if (!run) {
+            throw new Error(`Run '${runId}' not found.`);
+        }
+        return run;
+    }
+    writeTraceArtifact(runId, events) {
+        const path = resolve("artifacts", runId, "trace.json");
+        ensureParentDir(path);
+        writeFileSync(path, JSON.stringify(events, null, 2));
+    }
+    ensureSchemaVersion() {
+        const existing = this.db
+            .prepare(`SELECT value FROM metadata WHERE key = 'schema_version'`)
+            .get();
+        if (!existing) {
+            this.db.prepare(`INSERT INTO metadata (key, value) VALUES ('schema_version', ?)`).run(SCHEMA_VERSION);
+            return;
+        }
+        if (existing.value !== SCHEMA_VERSION) {
+            throw new Error(`Unsupported database schema version '${existing.value}'. Expected '${SCHEMA_VERSION}'. Remove artifacts/agentlab.db or add a migration.`);
+        }
+    }
+    ensureAgentVersionColumns() {
+        const columns = this.db.prepare(`PRAGMA table_info(agent_versions)`).all();
+        const names = new Set(columns.map((column) => column.name));
+        if (!names.has("command")) {
+            this.db.exec(`ALTER TABLE agent_versions ADD COLUMN command TEXT`);
+        }
+        if (!names.has("args_json")) {
+            this.db.exec(`ALTER TABLE agent_versions ADD COLUMN args_json TEXT`);
+        }
+    }
+}
+function buildEvaluatorDiffs(baseline, candidate) {
+    const ids = new Set([
+        ...baseline.evaluatorResults.map((result) => result.evaluatorId),
+        ...candidate.evaluatorResults.map((result) => result.evaluatorId),
+    ]);
+    return [...ids]
+        .sort()
+        .map((evaluatorId) => {
+        const baselineResult = baseline.evaluatorResults.find((result) => result.evaluatorId === evaluatorId);
+        const candidateResult = candidate.evaluatorResults.find((result) => result.evaluatorId === evaluatorId);
+        if (baselineResult?.status === candidateResult?.status) {
+            return null;
+        }
+        return {
+            evaluatorId,
+            baselineStatus: baselineResult?.status,
+            candidateStatus: candidateResult?.status,
+            note: `Evaluator '${evaluatorId}' changed: ${baselineResult?.status ?? "missing"} -> ${candidateResult?.status ?? "missing"}`,
+        };
+    })
+        .filter((diff) => diff !== null);
+}
+function buildToolDiffs(baseline, candidate) {
+    const toolNames = new Set([
+        ...baseline.toolCalls.map((call) => call.toolName),
+        ...candidate.toolCalls.map((call) => call.toolName),
+    ]);
+    return [...toolNames]
+        .sort()
+        .map((toolName) => {
+        const baselineCount = baseline.toolCalls.filter((call) => call.toolName === toolName).length;
+        const candidateCount = candidate.toolCalls.filter((call) => call.toolName === toolName).length;
+        if (baselineCount === candidateCount) {
+            return null;
+        }
+        return {
+            toolName,
+            baselineCount,
+            candidateCount,
+            note: `Tool '${toolName}' usage changed: ${baselineCount} -> ${candidateCount}`,
+        };
+    })
+        .filter((diff) => diff !== null);
+}

package/dist/tools.js

@@ -0,0 +1,128 @@
+import { readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+import { loadAgentLabConfig } from "./config.js";
+function loadFixture(path) {
+    const raw = readFileSync(resolve(path), "utf8");
+    return JSON.parse(raw);
+}
+const BUILTIN_TOOLS = [
+    {
+        spec: {
+            name: "crm.search_customer",
+            description: "Find a customer by email.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    email: { type: "string", description: "Customer email address." },
+                },
+                required: ["email"],
+            },
+        },
+        handler: async (input) => {
+            assertObject(input);
+            const email = String(input.email ?? "");
+            const customers = loadFixture("fixtures/support/customers.json");
+            const customer = customers.find((candidate) => candidate.email === email);
+            if (!customer) {
+                throw new Error(`Customer with email '${email}' not found.`);
+            }
+            return customer;
+        },
+    },
+    {
+        spec: {
+            name: "orders.list",
+            description: "List orders for a given customer id.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    customer_id: { type: "string", description: "Customer id returned from CRM." },
+                },
+                required: ["customer_id"],
+            },
+        },
+        handler: async (input) => {
+            assertObject(input);
+            const customerId = String(input.customer_id ?? "");
+            const orders = loadFixture("fixtures/support/orders.json");
+            return orders.filter((order) => order.customer_id === customerId);
+        },
+    },
+    {
+        spec: {
+            name: "orders.refund",
+            description: "Refund a single order by id.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    order_id: { type: "string", description: "Order id to refund." },
+                },
+                required: ["order_id"],
+            },
+        },
+        handler: async (input) => {
+            assertObject(input);
+            const orderId = String(input.order_id ?? "");
+            const orders = loadFixture("fixtures/support/orders.json");
+            const order = orders.find((candidate) => candidate.id === orderId);
+            if (!order) {
+                throw new Error(`Order '${orderId}' not found.`);
+            }
+            return {
+                refunded: true,
+                order_id: order.id,
+                amount: order.amount,
+                currency: order.currency,
+            };
+        },
+    },
+];
+export async function loadToolRegistry() {
+    const tools = await loadTools();
+    return Object.fromEntries(tools.map((tool) => [tool.spec.name, tool.handler]));
+}
+export async function loadToolSpecs() {
+    const tools = await loadTools();
+    return tools.map((tool) => tool.spec);
+}
+export function getBuiltinToolSpecs() {
+    return BUILTIN_TOOLS.map((tool) => tool.spec);
+}
+async function loadTools() {
+    const config = loadAgentLabConfig();
+    const configuredTools = await Promise.all((config.tools ?? []).map((tool) => loadConfiguredTool(tool)));
+    const merged = [...BUILTIN_TOOLS, ...configuredTools];
+    const seen = new Set();
+    for (const tool of merged) {
+        if (seen.has(tool.spec.name)) {
+            throw new Error(`Duplicate tool registration for '${tool.spec.name}'.`);
+        }
+        seen.add(tool.spec.name);
+    }
+    return merged;
+}
+async function loadConfiguredTool(tool) {
+    const moduleUrl = pathToFileURL(resolve(tool.modulePath)).href;
+    const module = await import(moduleUrl);
+    const candidate = module[tool.exportName];
+    if (typeof candidate !== "function") {
+        throw new Error(`Tool '${tool.name}' export '${tool.exportName}' is not a function.`);
+    }
+    return {
+        spec: {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        },
+        handler: candidate,
+    };
+}
+function assertObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("Tool input must be an object.");
+    }
+}

package/dist/trace.js

@@ -0,0 +1,30 @@
+import { createEventId } from "./lib/id.js";
+export class TraceRecorder {
+    runId;
+    scenarioId;
+    events = [];
+    stepIndex = 0;
+    constructor(runId, scenarioId) {
+        this.runId = runId;
+        this.scenarioId = scenarioId;
+    }
+    record(source, type, payload) {
+        this.stepIndex += 1;
+        this.events.push({
+            eventId: createEventId(),
+            runId: this.runId,
+            scenarioId: this.scenarioId,
+            stepIndex: this.stepIndex,
+            timestamp: new Date().toISOString(),
+            source,
+            type,
+            payload,
+        });
+    }
+    getEvents() {
+        return [...this.events];
+    }
+    getStepCount() {
+        return this.stepIndex;
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/App.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+export function App() {
+    const route = getRoute();
+    return (_jsxs("div", { className: "shell", children: [_jsx("header", { className: "topbar", children: _jsx("a", { className: "brand", href: "/", children: "Agent Regression Lab Alpha" }) }), _jsxs("main", { className: "page", children: [route.type === "list" ? _jsx(RunListPage, {}) : null, route.type === "detail" ? _jsx(RunDetailPage, { runId: route.runId }) : null, route.type === "compare" ? _jsx(ComparePage, { baseline: route.baseline, candidate: route.candidate }) : null] })] }));
+}
+function RunListPage() {
+    const [runs, setRuns] = useState([]);
+    const [suite, setSuite] = useState("");
+    const [status, setStatus] = useState("");
+    const [provider, setProvider] = useState("");
+    useEffect(() => {
+        const url = new URL("/api/runs", window.location.origin);
+        if (suite)
+            url.searchParams.set("suite", suite);
+        if (status)
+            url.searchParams.set("status", status);
+        if (provider)
+            url.searchParams.set("provider", provider);
+        void fetch(url)
+            .then((response) => response.json())
+            .then((data) => setRuns(Array.isArray(data.runs) ? data.runs : []));
+    }, [suite, status, provider]);
+    return (_jsxs("section", { children: [_jsxs("div", { className: "hero", children: [_jsx("h1", { children: "Runs" }), _jsx("p", { children: "Inspect local alpha runs, filter failures, and compare behavior changes." })] }), _jsxs("div", { className: "filters", children: [_jsx("input", { value: suite, onChange: (event) => setSuite(event.target.value), placeholder: "Suite" }), _jsxs("select", { value: status, onChange: (event) => setStatus(event.target.value), children: [_jsx("option", { value: "", children: "All statuses" }), _jsx("option", { value: "pass", children: "Pass" }), _jsx("option", { value: "fail", children: "Fail" }), _jsx("option", { value: "error", children: "Error" })] }), _jsxs("select", { value: provider, onChange: (event) => setProvider(event.target.value), children: [_jsx("option", { value: "", children: "All providers" }), _jsx("option", { value: "mock", children: "Mock" }), _jsx("option", { value: "openai", children: "OpenAI" }), _jsx("option", { value: "external_process", children: "External process" })] })] }), runs.length === 0 ? _jsx(EmptyState, { title: "No runs yet", description: "Run a scenario from the CLI to populate the lab." }) : null, runs.length > 0 ? (_jsxs("table", { className: "table", children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { children: "Run" }), _jsx("th", { children: "Scenario" }), _jsx("th", { children: "Provider" }), _jsx("th", { children: "Status" }), _jsx("th", { children: "Score" }), _jsx("th", { children: "Runtime" }), _jsx("th", { children: "Steps" }), _jsx("th", { children: "Started" })] }) }), _jsx("tbody", { children: runs.map((run, index) => (_jsxs("tr", { children: [_jsx("td", { children: _jsx("a", { href: `/runs/${run.id}`, children: run.id }) }), _jsx("td", { children: run.scenarioId }), _jsxs("td", { children: [run.provider ?? "-", _jsx("div", { className: "muted", children: run.modelId ?? run.agentLabel ?? "" })] }), _jsx("td", { children: _jsx("span", { className: `pill ${run.status}`, children: run.status }) }), _jsx("td", { children: run.score }), _jsxs("td", { children: [run.durationMs, "ms"] }), _jsx("td", { children: run.totalSteps }), _jsxs("td", { children: [new Date(run.startedAt).toLocaleString(), index > 0 && runs[index - 1].scenarioId === run.scenarioId ? (_jsx("div", { className: "muted", children: _jsx("a", { href: `/compare?baseline=${runs[index - 1].id}&candidate=${run.id}`, children: "compare previous" }) })) : null] })] }, run.id))) })] })) : null] }));
+}
+function RunDetailPage(props) {
+    const [detail, setDetail] = useState(null);
+    useEffect(() => {
+        void fetch(`/api/runs/${props.runId}`)
+            .then((response) => response.json())
+            .then((data) => setDetail(data));
+    }, [props.runId]);
+    if (!detail) {
+        return _jsx(EmptyState, { title: "Loading run", description: "Fetching run detail from the local lab." });
+    }
+    return (_jsxs("section", { children: [_jsxs("div", { className: "hero", children: [_jsx("h1", { children: detail.run.id }), _jsx("p", { children: detail.run.scenarioId })] }), _jsxs("div", { className: "stats", children: [_jsx(Stat, { label: "Status", value: _jsx("span", { className: `pill ${detail.run.status}`, children: detail.run.status }) }), _jsx(Stat, { label: "Score", value: detail.run.score }), _jsx(Stat, { label: "Runtime", value: `${detail.run.durationMs}ms` }), _jsx(Stat, { label: "Steps", value: detail.run.totalSteps })] }), _jsxs("div", { className: "panel-grid", children: [_jsxs("section", { className: "panel", children: [_jsx("h2", { children: "Summary" }), _jsxs("p", { children: [_jsx("strong", { children: "Provider:" }), " ", detail.agentVersion?.provider ?? "-"] }), _jsxs("p", { children: [_jsx("strong", { children: "Model:" }), " ", detail.agentVersion?.modelId ?? "-"] }), detail.agentVersion?.command ? (_jsxs("p", { children: [_jsx("strong", { children: "Command:" }), " ", detail.agentVersion.command, " ", (detail.agentVersion.args ?? []).join(" ")] })) : null, _jsxs("p", { children: [_jsx("strong", { children: "Termination:" }), " ", detail.run.terminationReason] }), detail.errorDetail ? _jsxs("p", { children: [_jsx("strong", { children: "Error:" }), " ", detail.errorDetail] }) : null, _jsx("p", { children: _jsx("strong", { children: "Final output:" }) }), _jsx("pre", { children: detail.run.finalOutput || "(none)" })] }), _jsxs("section", { className: "panel", children: [_jsx("h2", { children: "Evaluators" }), _jsx("ul", { className: "stack", children: detail.evaluatorResults.map((result) => (_jsxs("li", { children: [_jsx("span", { className: `pill ${result.status}`, children: result.status }), " ", result.evaluatorId, _jsx("div", { className: "muted", children: result.message })] }, result.evaluatorId))) })] })] }), _jsxs("section", { className: "panel", children: [_jsx("h2", { children: "Tool Calls" }), detail.toolCalls.length === 0 ? _jsx("p", { className: "muted", children: "No tool calls recorded." }) : null, _jsx("ul", { className: "stack", children: detail.toolCalls.map((call) => (_jsxs("li", { children: [_jsx("strong", { children: call.toolName }), " ", _jsx("span", { className: `pill ${call.status}`, children: call.status }), _jsx("pre", { children: JSON.stringify({ input: call.input, output: call.output }, null, 2) })] }, call.id))) })] }), _jsxs("section", { className: "panel", children: [_jsx("h2", { children: "Trace" }), _jsx("ol", { className: "timeline", children: detail.traceEvents.map((event) => (_jsxs("li", { children: [_jsxs("div", { children: [_jsxs("strong", { children: [event.stepIndex, ". ", event.type] }), " ", _jsx("span", { className: "muted", children: event.source })] }), _jsx("pre", { children: JSON.stringify(event.payload, null, 2) })] }, event.eventId))) })] })] }));
+}
+function ComparePage(props) {
+    const [data, setData] = useState(null);
+    useEffect(() => {
+        if (!props.baseline || !props.candidate) {
+            setData(null);
+            return;
+        }
+        const url = new URL("/api/compare", window.location.origin);
+        url.searchParams.set("baseline", props.baseline);
+        url.searchParams.set("candidate", props.candidate);
+        void fetch(url)
+            .then((response) => response.json())
+            .then((payload) => setData(payload));
+    }, [props.baseline, props.candidate]);
+    if (!props.baseline || !props.candidate) {
+        return _jsx(EmptyState, { title: "No comparison selected", description: "Open the compare page with baseline and candidate run ids." });
+    }
+    if (!data) {
+        return _jsx(EmptyState, { title: "Loading comparison", description: "Fetching both runs and computing deltas." });
+    }
+    return (_jsxs("section", { children: [_jsxs("div", { className: "hero", children: [_jsx("h1", { children: "Compare" }), _jsx("p", { children: data.baseline.run.scenarioId })] }), _jsxs("div", { className: "stats", children: [_jsx(Stat, { label: "Score delta", value: signed(data.deltas.score) }), _jsx(Stat, { label: "Runtime delta", value: `${signed(data.deltas.runtimeMs)}ms` }), _jsx(Stat, { label: "Step delta", value: signed(data.deltas.steps) })] }), _jsxs("section", { className: "panel", children: [_jsx("h2", { children: "Notes" }), data.notes.length === 0 ? _jsx("p", { className: "muted", children: "No material differences recorded." }) : null, _jsx("ul", { className: "stack", children: data.notes.map((note) => (_jsx("li", { children: note }, note))) })] }), _jsxs("div", { className: "panel-grid", children: [_jsxs("section", { className: "panel", children: [_jsx("h2", { children: "Evaluator diffs" }), data.evaluatorDiffs.length === 0 ? _jsx("p", { className: "muted", children: "No evaluator changes." }) : null, _jsx("ul", { className: "stack", children: data.evaluatorDiffs.map((diff) => (_jsx("li", { children: diff.note }, diff.evaluatorId))) })] }), _jsxs("section", { className: "panel", children: [_jsx("h2", { children: "Tool diffs" }), data.toolDiffs.length === 0 ? _jsx("p", { className: "muted", children: "No tool usage changes." }) : null, _jsx("ul", { className: "stack", children: data.toolDiffs.map((diff) => (_jsx("li", { children: diff.note }, diff.toolName))) })] })] }), _jsxs("div", { className: "compare-grid", children: [_jsx(RunSide, { title: "Baseline", detail: data.baseline }), _jsx(RunSide, { title: "Candidate", detail: data.candidate })] })] }));
+}
+function RunSide(props) {
+    return (_jsxs("section", { className: "panel", children: [_jsx("h2", { children: props.title }), _jsxs("p", { children: [_jsx("strong", { children: "Run:" }), " ", _jsx("a", { href: `/runs/${props.detail.run.id}`, children: props.detail.run.id })] }), _jsxs("p", { children: [_jsx("strong", { children: "Status:" }), " ", _jsx("span", { className: `pill ${props.detail.run.status}`, children: props.detail.run.status })] }), _jsxs("p", { children: [_jsx("strong", { children: "Score:" }), " ", props.detail.run.score] }), _jsxs("p", { children: [_jsx("strong", { children: "Runtime:" }), " ", props.detail.run.durationMs, "ms"] }), _jsxs("p", { children: [_jsx("strong", { children: "Termination:" }), " ", props.detail.run.terminationReason] }), _jsxs("p", { children: [_jsx("strong", { children: "Agent:" }), " ", props.detail.agentVersion?.label ?? "-"] }), _jsxs("p", { children: [_jsx("strong", { children: "Provider:" }), " ", props.detail.agentVersion?.provider ?? "-"] }), props.detail.agentVersion?.modelId ? _jsxs("p", { children: [_jsx("strong", { children: "Model:" }), " ", props.detail.agentVersion.modelId] }) : null, props.detail.agentVersion?.command ? (_jsxs("p", { children: [_jsx("strong", { children: "Command:" }), " ", props.detail.agentVersion.command, " ", (props.detail.agentVersion.args ?? []).join(" ")] })) : null, props.detail.errorDetail ? _jsxs("p", { children: [_jsx("strong", { children: "Error:" }), " ", props.detail.errorDetail] }) : null, _jsx("p", { children: _jsx("strong", { children: "Final output:" }) }), _jsx("pre", { children: props.detail.run.finalOutput || "(none)" }), _jsx("h3", { children: "Trace" }), _jsx("ol", { className: "timeline compact", children: props.detail.traceEvents.map((event) => (_jsx("li", { children: _jsxs("strong", { children: [event.stepIndex, ". ", event.type] }) }, event.eventId))) })] }));
+}
+function Stat(props) {
+    return (_jsxs("div", { className: "stat", children: [_jsx("div", { className: "muted", children: props.label }), _jsx("div", { className: "stat-value", children: props.value })] }));
+}
+function EmptyState(props) {
+    return (_jsxs("section", { className: "empty", children: [_jsx("h1", { children: props.title }), _jsx("p", { children: props.description })] }));
+}
+function signed(value) {
+    return value > 0 ? `+${value}` : `${value}`;
+}
+function getRoute() {
+    const url = new URL(window.location.href);
+    if (url.pathname.startsWith("/runs/")) {
+        return { type: "detail", runId: decodeURIComponent(url.pathname.slice("/runs/".length)) };
+    }
+    if (url.pathname === "/compare") {
+        return {
+            type: "compare",
+            baseline: url.searchParams.get("baseline") ?? undefined,
+            candidate: url.searchParams.get("candidate") ?? undefined,
+        };
+    }
+    return { type: "list" };
+}

package/dist/ui/client.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { App } from "./App.js";
+import "./styles.css";
+const container = document.getElementById("root");
+if (!container) {
+    throw new Error("Missing root element.");
+}
+createRoot(container).render(_jsx(React.StrictMode, { children: _jsx(App, {}) }));