@archon-claw/cli 0.0.2

package/dist/eval/execute.js

@@ -0,0 +1,260 @@
+import { createClient, toOpenAITools, streamChat } from "../llm.js";
+import { runAssertions } from "./assertions.js";
+const MAX_ITERATIONS = 20;
+/**
+ * Execute a single eval case, dispatching to the appropriate mode.
+ */
+export async function executeCase(opts) {
+    const start = Date.now();
+    switch (opts.evalCase.mode) {
+        case "single":
+            return executeSingle(opts, start);
+        case "injected":
+            return executeInjected(opts, start);
+        case "sequential":
+            return executeSequential(opts, start);
+        default:
+            return {
+                file: opts.fileName,
+                case: opts.evalCase.name,
+                mode: opts.evalCase.mode,
+                passed: false,
+                duration: Date.now() - start,
+                response: "",
+                toolCalls: [],
+                assertionResults: [
+                    {
+                        type: "contains",
+                        value: "",
+                        passed: false,
+                        message: `unknown mode: ${opts.evalCase.mode}`,
+                    },
+                ],
+            };
+    }
+}
+/**
+ * Collect text and tool calls from one LLM generation cycle (may include
+ * multiple tool-call loops).
+ */
+async function runGeneration(config, messages, toolSubset) {
+    const client = createClient(config.model);
+    // Filter tools if a subset is specified
+    let tools = config.tools;
+    if (toolSubset) {
+        tools = config.tools.filter((t) => toolSubset.includes(t.name));
+    }
+    const openAITools = toOpenAITools(tools);
+    let fullText = "";
+    const allToolCalls = [];
+    for (let i = 0; i < MAX_ITERATIONS; i++) {
+        const stream = streamChat(client, config.model, messages, openAITools);
+        let textContent = "";
+        const toolCallsMap = new Map();
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content) {
+                textContent += delta.content;
+            }
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    const existing = toolCallsMap.get(tc.index);
+                    if (existing) {
+                        if (tc.function?.arguments) {
+                            existing.args += tc.function.arguments;
+                        }
+                    }
+                    else {
+                        toolCallsMap.set(tc.index, {
+                            id: tc.id ?? "",
+                            name: tc.function?.name ?? "",
+                            args: tc.function?.arguments ?? "",
+                        });
+                    }
+                }
+            }
+        }
+        // Build assistant message
+        const assistantToolCalls = [...toolCallsMap.values()].map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: tc.args },
+        }));
+        const assistantMessage = assistantToolCalls.length > 0
+            ? { role: "assistant", content: textContent || null, tool_calls: assistantToolCalls }
+            : { role: "assistant", content: textContent };
+        messages.push(assistantMessage);
+        fullText += textContent;
+        // No tool calls — done
+        if (assistantToolCalls.length === 0)
+            break;
+        // Execute tool calls
+        for (const tc of assistantToolCalls) {
+            const args = JSON.parse(tc.function.arguments);
+            const impl = config.toolImpls.get(tc.function.name);
+            let result;
+            if (impl) {
+                try {
+                    result = await impl(args);
+                }
+                catch (err) {
+                    result = { error: err instanceof Error ? err.message : String(err) };
+                }
+            }
+            else {
+                result = { error: `Unknown tool: ${tc.function.name}` };
+            }
+            allToolCalls.push({ name: tc.function.name, args, result });
+            messages.push({
+                role: "tool",
+                tool_call_id: tc.id,
+                content: JSON.stringify(result),
+            });
+        }
+    }
+    return { text: fullText, toolCalls: allToolCalls, messages };
+}
+// ---- Mode 1: Single ----
+async function executeSingle(opts, start) {
+    const { config, evalCase, fileName, judgeRunner } = opts;
+    const userTurn = evalCase.turns[0];
+    const messages = [
+        { role: "system", content: config.systemPrompt },
+        { role: "user", content: userTurn.content },
+    ];
+    const { text, toolCalls } = await runGeneration(config, messages, evalCase.tools);
+    const assertionResults = runAssertions(evalCase.assertions ?? [], text, toolCalls);
+    const passed = assertionResults.every((a) => a.passed);
+    let judgeResult;
+    if (judgeRunner) {
+        judgeResult = await judgeRunner(userTurn.content, evalCase.expectedOutput, text, messages);
+    }
+    return {
+        file: fileName,
+        case: evalCase.name,
+        mode: "single",
+        passed,
+        duration: Date.now() - start,
+        response: text,
+        toolCalls,
+        assertionResults,
+        judgeResult,
+    };
+}
+// ---- Mode 2: Injected ----
+async function executeInjected(opts, start) {
+    const { config, evalCase, fileName, judgeRunner } = opts;
+    const messages = [
+        { role: "system", content: config.systemPrompt },
+    ];
+    // Inject all turns except the last user turn as history
+    for (const turn of evalCase.turns.slice(0, -1)) {
+        if (turn.role === "user") {
+            messages.push({ role: "user", content: turn.content });
+        }
+        else if (turn.role === "assistant") {
+            const msg = { role: "assistant", content: turn.content };
+            if (turn.toolCalls && turn.toolCalls.length > 0) {
+                const tcs = turn.toolCalls.map((tc, idx) => ({
+                    id: `injected_${idx}`,
+                    type: "function",
+                    function: { name: tc.name, arguments: JSON.stringify(tc.args) },
+                }));
+                msg.tool_calls = tcs;
+                // Add tool result messages
+                for (const tc of turn.toolCalls) {
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: `injected_${turn.toolCalls.indexOf(tc)}`,
+                        content: JSON.stringify(tc.result),
+                    });
+                }
+            }
+            messages.push(msg);
+        }
+    }
+    // Add the last user turn (triggers generation)
+    const lastTurn = evalCase.turns[evalCase.turns.length - 1];
+    messages.push({ role: "user", content: lastTurn.content });
+    const { text, toolCalls } = await runGeneration(config, messages, evalCase.tools);
+    const assertionResults = runAssertions(evalCase.assertions ?? [], text, toolCalls);
+    const passed = assertionResults.every((a) => a.passed);
+    let judgeResult;
+    if (judgeRunner) {
+        judgeResult = await judgeRunner(lastTurn.content, evalCase.expectedOutput, text, messages);
+    }
+    return {
+        file: fileName,
+        case: evalCase.name,
+        mode: "injected",
+        passed,
+        duration: Date.now() - start,
+        response: text,
+        toolCalls,
+        assertionResults,
+        judgeResult,
+    };
+}
+// ---- Mode 3: Sequential ----
+async function executeSequential(opts, start) {
+    const { config, evalCase, fileName, judgeRunner } = opts;
+    const messages = [
+        { role: "system", content: config.systemPrompt },
+    ];
+    const allToolCalls = [];
+    const turnResults = [];
+    let lastResponse = "";
+    let allPassed = true;
+    for (const turn of evalCase.turns) {
+        if (turn.role !== "user")
+            continue;
+        messages.push({ role: "user", content: turn.content });
+        const { text, toolCalls } = await runGeneration(config, messages, evalCase.tools);
+        lastResponse = text;
+        allToolCalls.push(...toolCalls);
+        // Per-turn assertions
+        let turnAssertionResults;
+        if (turn.assertions && turn.assertions.length > 0) {
+            turnAssertionResults = runAssertions(turn.assertions, text, toolCalls);
+            if (turnAssertionResults.some((a) => !a.passed)) {
+                allPassed = false;
+            }
+        }
+        // Per-turn judge
+        let turnJudgeResult;
+        if (judgeRunner && turn.judge) {
+            turnJudgeResult = await judgeRunner(turn.content, turn.expectedOutput, text, messages);
+        }
+        turnResults.push({
+            role: "assistant",
+            content: text,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            assertionResults: turnAssertionResults,
+            judgeResult: turnJudgeResult,
+        });
+    }
+    // Case-level assertions on the final response
+    const caseAssertionResults = runAssertions(evalCase.assertions ?? [], lastResponse, allToolCalls);
+    if (caseAssertionResults.some((a) => !a.passed)) {
+        allPassed = false;
+    }
+    // Case-level judge
+    let judgeResult;
+    if (judgeRunner) {
+        judgeResult = await judgeRunner(evalCase.turns.filter((t) => t.role === "user").map((t) => t.content).join("\n"), evalCase.expectedOutput, lastResponse, messages);
+    }
+    return {
+        file: fileName,
+        case: evalCase.name,
+        mode: "sequential",
+        passed: allPassed,
+        duration: Date.now() - start,
+        response: lastResponse,
+        turnResults,
+        toolCalls: allToolCalls,
+        assertionResults: caseAssertionResults,
+        judgeResult,
+    };
+}

package/dist/eval/formatter.d.ts

@@ -0,0 +1,10 @@
+import type { CaseResult, EvalFile } from "./types.js";
+interface LoadedEvalFile {
+    fileName: string;
+    data: EvalFile;
+}
+/**
+ * Format eval results for console output.
+ */
+export declare function formatEvalResults(evalFiles: LoadedEvalFile[], results: CaseResult[]): string;
+export {};

package/dist/eval/formatter.js

@@ -0,0 +1,62 @@
+/**
+ * Format eval results for console output.
+ */
+export function formatEvalResults(evalFiles, results) {
+    const lines = [];
+    for (const ef of evalFiles) {
+        lines.push(`\n  eval: ${ef.data.name} (${ef.fileName})\n`);
+        const fileResults = results.filter((r) => r.file === ef.fileName);
+        for (const r of fileResults) {
+            const icon = r.passed ? "\u2713" : "\u2717";
+            const durationStr = `${r.duration}ms`;
+            lines.push(`    ${icon} ${r.case} (${r.mode})${padRight(durationStr, 40, r.case.length + r.mode.length + 7)}`);
+            // Show assertion details for failed cases or when there are assertions
+            if (!r.passed || r.assertionResults.length > 0) {
+                for (const a of r.assertionResults) {
+                    const aIcon = a.passed ? "\u2713" : "\u2717";
+                    const detail = a.message ? ` (${a.message})` : "";
+                    lines.push(`      - ${a.type} "${a.value}"${padRight(aIcon + detail, 30, a.type.length + a.value.length + 5)}`);
+                }
+            }
+            // Show turn assertion details for sequential mode
+            if (r.turnResults) {
+                for (const tr of r.turnResults) {
+                    if (tr.assertionResults) {
+                        for (const a of tr.assertionResults) {
+                            if (!a.passed) {
+                                const detail = a.message ? ` (${a.message})` : "";
+                                lines.push(`      - ${a.type} "${a.value}"  \u2717${detail}`);
+                            }
+                        }
+                    }
+                }
+            }
+            // Show judge result if available
+            if (r.judgeResult) {
+                const scores = Object.entries(r.judgeResult.scores)
+                    .map(([key, s]) => `${key}=${s.score}`)
+                    .join(" ");
+                lines.push(`      - judge: ${scores}  avg=${r.judgeResult.overallScore}`);
+            }
+        }
+    }
+    // Summary
+    const totalCases = results.length;
+    const passed = results.filter((r) => r.passed).length;
+    const failed = totalCases - passed;
+    lines.push("");
+    lines.push(`  ${totalCases} cases, ${passed} passed, ${failed} failed`);
+    // Average judge score
+    const judgeScores = results
+        .filter((r) => r.judgeResult)
+        .map((r) => r.judgeResult.overallScore);
+    if (judgeScores.length > 0) {
+        const avg = Math.round((judgeScores.reduce((a, b) => a + b, 0) / judgeScores.length) * 10) / 10;
+        lines.push(`  Average judge score: ${avg} / 10`);
+    }
+    return lines.join("\n");
+}
+function padRight(suffix, targetGap, contentLength) {
+    const gap = Math.max(2, targetGap - contentLength);
+    return " ".repeat(gap) + suffix;
+}

package/dist/eval/judge.d.ts

@@ -0,0 +1,7 @@
+import type { ChatMessage, ModelConfig } from "../types.js";
+import type { JudgeConfig, JudgeResult } from "./types.js";
+export type JudgeRunnerFn = (userInput: string, expectedOutput: string | undefined, actualResponse: string, conversation: ChatMessage[]) => Promise<JudgeResult>;
+/**
+ * Create a judge runner function from a JudgeConfig.
+ */
+export declare function createJudgeRunner(judgeConfig: JudgeConfig, fallbackModel: ModelConfig): JudgeRunnerFn;

package/dist/eval/judge.js

@@ -0,0 +1,116 @@
+import { Liquid } from "liquidjs";
+import { createClient } from "../llm.js";
+const DEFAULT_PROMPT_TEMPLATE = `请评估以下 AI 助手的回复质量。
+
+用户输入：{{ user_input }}
+{% if expected_output %}期望输出：{{ expected_output }}{% endif %}
+实际回复：{{ actual_response }}
+
+请对以下每个维度独立评估，并给出简短理由。
+{% for dim in dimensions %}
+{% if dim.type == "binary" %}- {{ dim.label }}（{{ dim.key }}）：通过 true / 不通过 false
+{% else %}- {{ dim.label }}（{{ dim.key }}）：{{ dim.min }} - {{ dim.max }} 分
+{% endif %}{% endfor %}
+
+请严格以下面的 JSON 格式回复，不要输出其他内容：
+{
+{% for dim in dimensions %}{% if dim.type == "binary" %}  "{{ dim.key }}": { "score": <true 或 false>, "reason": "<理由>" }{% else %}  "{{ dim.key }}": { "score": <分数>, "reason": "<理由>" }{% endif %}{% unless forloop.last %},{% endunless %}
+{% endfor %}}`;
+/**
+ * Create a judge runner function from a JudgeConfig.
+ */
+export function createJudgeRunner(judgeConfig, fallbackModel) {
+    const model = judgeConfig.model ?? fallbackModel;
+    const client = createClient(model);
+    const engine = new Liquid();
+    return async (userInput, expectedOutput, actualResponse, conversation) => {
+        const template = judgeConfig.promptTemplate ?? DEFAULT_PROMPT_TEMPLATE;
+        const prompt = await engine.parseAndRender(template, {
+            user_input: userInput,
+            expected_output: expectedOutput ?? "",
+            actual_response: actualResponse,
+            conversation: conversation.map((m) => `${m.role}: ${m.content}`).join("\n"),
+            dimensions: judgeConfig.dimensions.map((d) => ({
+                ...d,
+                type: d.type ?? "numeric",
+                min: d.min ?? 0,
+                max: d.max ?? 10,
+            })),
+        });
+        const response = await client.chat.completions.create({
+            model: model.model,
+            messages: [{ role: "user", content: prompt }],
+            max_tokens: model.maxTokens ?? 2048,
+            temperature: 0.1,
+        });
+        const content = response.choices[0]?.message?.content ?? "";
+        return parseJudgeResponse(content, judgeConfig);
+    };
+}
+/**
+ * Parse the judge LLM response into structured scores.
+ */
+function parseJudgeResponse(content, config) {
+    const scores = {};
+    try {
+        // Extract JSON from the response (may be wrapped in markdown code blocks)
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            throw new Error("No JSON found in judge response");
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        for (const dim of config.dimensions) {
+            const entry = parsed[dim.key];
+            if (!entry) {
+                scores[dim.key] = { score: 0, reason: "Failed to parse score" };
+                continue;
+            }
+            if ((dim.type ?? "numeric") === "binary") {
+                // Binary: convert boolean to 0/1
+                const val = typeof entry.score === "boolean" ? entry.score : !!entry.score;
+                scores[dim.key] = {
+                    score: val ? 1 : 0,
+                    reason: entry.reason ?? "",
+                };
+            }
+            else {
+                // Numeric
+                if (typeof entry.score === "number") {
+                    scores[dim.key] = {
+                        score: entry.score,
+                        reason: entry.reason ?? "",
+                    };
+                }
+                else {
+                    scores[dim.key] = { score: 0, reason: "Failed to parse score" };
+                }
+            }
+        }
+    }
+    catch {
+        for (const dim of config.dimensions) {
+            scores[dim.key] = { score: 0, reason: "Failed to parse judge response" };
+        }
+    }
+    // Calculate weighted overall score
+    let totalWeight = 0;
+    let weightedSum = 0;
+    for (const dim of config.dimensions) {
+        const s = scores[dim.key];
+        if (s) {
+            if ((dim.type ?? "numeric") === "binary") {
+                // Binary: 0 or 1 → normalize to 0-10
+                weightedSum += s.score * 10 * dim.weight;
+            }
+            else {
+                const max = dim.max ?? 10;
+                const min = dim.min ?? 0;
+                const normalized = max !== min ? ((s.score - min) / (max - min)) * 10 : 0;
+                weightedSum += normalized * dim.weight;
+            }
+            totalWeight += dim.weight;
+        }
+    }
+    const overallScore = totalWeight > 0 ? Math.round((weightedSum / totalWeight) * 10) / 10 : 0;
+    return { scores, overallScore };
+}

package/dist/eval/runner.d.ts

@@ -0,0 +1,9 @@
+import type { EvalSummary, EvalDetails, EvalOptions } from "./types.js";
+/**
+ * Run all eval files for an agent directory.
+ */
+export declare function runEvals(agentDir: string, options?: EvalOptions): Promise<{
+    summary: EvalSummary;
+    details: EvalDetails;
+    formatted: string;
+}>;

package/dist/eval/runner.js

@@ -0,0 +1,156 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadAgentConfig } from "../config.js";
+import { executeCase } from "./execute.js";
+import { createJudgeRunner } from "./judge.js";
+import { formatEvalResults } from "./formatter.js";
+/**
+ * Run all eval files for an agent directory.
+ */
+export async function runEvals(agentDir, options = {}) {
+    const absDir = path.resolve(agentDir);
+    const casesDir = path.join(absDir, "eval-cases");
+    const judgesDir = path.join(absDir, "eval-judges");
+    // Load agent config
+    const config = await loadAgentConfig(agentDir);
+    // Load eval files from eval-cases/
+    let evalFiles = await loadEvalFiles(casesDir);
+    // Filter by file
+    if (options.file) {
+        evalFiles = evalFiles.filter((f) => f.fileName === options.file);
+        if (evalFiles.length === 0) {
+            throw new Error(`Eval file not found: ${options.file}`);
+        }
+    }
+    // Filter cases by tag
+    if (options.tag) {
+        for (const ef of evalFiles) {
+            ef.data.cases = ef.data.cases.filter((c) => c.tags && c.tags.includes(options.tag));
+        }
+        evalFiles = evalFiles.filter((ef) => ef.data.cases.length > 0);
+    }
+    if (evalFiles.length === 0) {
+        throw new Error("No eval cases found");
+    }
+    // Load judge configs from eval-judges/ (optional)
+    let judgeRunners;
+    if (!options.noJudge) {
+        const judgeConfigs = await loadJudgeConfigs(judgesDir);
+        if (judgeConfigs.size > 0) {
+            judgeRunners = new Map();
+            for (const [name, judgeConfig] of judgeConfigs) {
+                judgeRunners.set(name, createJudgeRunner(judgeConfig, config.model));
+            }
+        }
+    }
+    // Run all cases
+    const results = [];
+    const startTime = Date.now();
+    for (const ef of evalFiles) {
+        for (const evalCase of ef.data.cases) {
+            // Resolve judge runner for this case
+            let judgeRunner;
+            if (judgeRunners) {
+                const judgeName = evalCase.judge ?? "default";
+                judgeRunner = judgeRunners.get(judgeName);
+            }
+            const result = await executeCase({
+                config,
+                evalCase,
+                fileName: ef.fileName,
+                judgeRunner,
+            });
+            results.push(result);
+        }
+    }
+    const totalDuration = Date.now() - startTime;
+    // Build summary
+    const summary = buildSummary(results, absDir, config, totalDuration, evalFiles);
+    const details = { results };
+    // Save results if requested
+    if (options.save) {
+        await saveResults(absDir, summary, details);
+    }
+    const formatted = formatEvalResults(evalFiles, results);
+    return { summary, details, formatted };
+}
+async function loadEvalFiles(casesDir) {
+    let files;
+    try {
+        files = await fs.readdir(casesDir);
+    }
+    catch {
+        throw new Error(`No eval-cases/ directory found`);
+    }
+    const evalFiles = files.filter((f) => f.endsWith(".eval.json"));
+    if (evalFiles.length === 0) {
+        throw new Error("No .eval.json files found in eval-cases/");
+    }
+    const loaded = [];
+    for (const file of evalFiles) {
+        const content = await fs.readFile(path.join(casesDir, file), "utf-8");
+        const parsed = JSON.parse(content);
+        loaded.push({ fileName: file, data: parsed });
+    }
+    return loaded;
+}
+async function loadJudgeConfigs(judgesDir) {
+    const configs = new Map();
+    let files;
+    try {
+        files = await fs.readdir(judgesDir);
+    }
+    catch {
+        return configs; // eval-judges/ is optional
+    }
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    for (const file of jsonFiles) {
+        const name = file.replace(/\.json$/, "");
+        const content = await fs.readFile(path.join(judgesDir, file), "utf-8");
+        const parsed = JSON.parse(content);
+        configs.set(name, parsed);
+    }
+    return configs;
+}
+function buildSummary(results, absDir, config, totalDuration, evalFiles) {
+    const passed = results.filter((r) => r.passed).length;
+    const failed = results.length - passed;
+    // Average judge score
+    const judgeScores = results
+        .filter((r) => r.judgeResult)
+        .map((r) => r.judgeResult.overallScore);
+    const averageScore = judgeScores.length > 0
+        ? Math.round((judgeScores.reduce((a, b) => a + b, 0) / judgeScores.length) * 10) / 10
+        : null;
+    // Per-file stats
+    const fileResults = evalFiles.map((ef) => {
+        const fileResults = results.filter((r) => r.file === ef.fileName);
+        const filePassed = fileResults.filter((r) => r.passed).length;
+        return {
+            file: ef.fileName,
+            name: ef.data.name,
+            cases: fileResults.length,
+            passed: filePassed,
+            failed: fileResults.length - filePassed,
+        };
+    });
+    return {
+        timestamp: new Date().toISOString(),
+        agent: path.basename(absDir),
+        model: `${config.model.provider}/${config.model.model}`,
+        totalCases: results.length,
+        passed,
+        failed,
+        averageScore,
+        duration: totalDuration,
+        files: fileResults,
+    };
+}
+async function saveResults(absDir, summary, details) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const resultsDir = path.join(absDir, "eval-results", timestamp);
+    await fs.mkdir(resultsDir, { recursive: true });
+    await fs.writeFile(path.join(resultsDir, "summary.json"), JSON.stringify(summary, null, 2));
+    await fs.writeFile(path.join(resultsDir, "details.json"), JSON.stringify(details, null, 2));
+    return resultsDir;
+}

package/dist/eval/types.d.ts

@@ -0,0 +1,67 @@
+export type { AssertionType, Assertion, EvalTurnToolCall, EvalTurn, EvalMode, EvalCase, EvalFile, JudgeDimension, JudgeConfig, } from "../schemas.js";
+import type { AssertionType, EvalMode } from "../schemas.js";
+export interface AssertionResult {
+    type: AssertionType;
+    value: string;
+    passed: boolean;
+    message?: string;
+}
+export interface JudgeScore {
+    score: number;
+    reason: string;
+}
+export interface JudgeResult {
+    scores: Record<string, JudgeScore>;
+    overallScore: number;
+}
+export interface ToolCallRecord {
+    name: string;
+    args: Record<string, unknown>;
+    result: unknown;
+}
+export interface TurnResult {
+    role: "user" | "assistant";
+    content: string;
+    toolCalls?: ToolCallRecord[];
+    assertionResults?: AssertionResult[];
+    judgeResult?: JudgeResult;
+}
+export interface CaseResult {
+    file: string;
+    case: string;
+    mode: EvalMode;
+    passed: boolean;
+    duration: number;
+    response: string;
+    turnResults?: TurnResult[];
+    toolCalls: ToolCallRecord[];
+    assertionResults: AssertionResult[];
+    judgeResult?: JudgeResult;
+}
+export interface FileResult {
+    file: string;
+    name: string;
+    cases: number;
+    passed: number;
+    failed: number;
+}
+export interface EvalSummary {
+    timestamp: string;
+    agent: string;
+    model: string;
+    totalCases: number;
+    passed: number;
+    failed: number;
+    averageScore: number | null;
+    duration: number;
+    files: FileResult[];
+}
+export interface EvalDetails {
+    results: CaseResult[];
+}
+export interface EvalOptions {
+    file?: string;
+    tag?: string;
+    save?: boolean;
+    noJudge?: boolean;
+}