@axiom-lattice/local-stores 1.0.1

package/src/stores/LocalEvalStore.ts

@@ -0,0 +1,510 @@
+/**
+ * Local SQLite implementation of EvalStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import {
+  EvalStore,
+  EvalProject,
+  CreateEvalProjectRequest,
+  EvalSuite,
+  CreateEvalSuiteRequest,
+  EvalCase,
+  CreateEvalCaseRequest,
+  EvalRun,
+  CreateEvalRunRequest,
+  EvalRunResult,
+  EvalProjectReport,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+import { randomUUID } from "crypto";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_eval_projects (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  version TEXT,
+  judge_model_config TEXT NOT NULL DEFAULT '{}',
+  target_server_config TEXT NOT NULL DEFAULT '{}',
+  concurrency INTEGER NOT NULL DEFAULT 3,
+  report_config TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+
+CREATE TABLE IF NOT EXISTS lt_eval_suites (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_es_project ON lt_eval_suites(tenant_id, project_id);
+
+CREATE TABLE IF NOT EXISTS lt_eval_cases (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  suite_id TEXT NOT NULL,
+  input_message TEXT NOT NULL,
+  input_files TEXT,
+  steps TEXT NOT NULL DEFAULT '[]',
+  output_type TEXT NOT NULL DEFAULT 'message_content',
+  content_assertion TEXT NOT NULL DEFAULT '',
+  rubrics TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_ec_suite ON lt_eval_cases(tenant_id, suite_id);
+
+CREATE TABLE IF NOT EXISTS lt_eval_runs (
+  id TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'running',
+  concurrency INTEGER NOT NULL DEFAULT 3,
+  total_cases INTEGER NOT NULL DEFAULT 0,
+  passed_cases INTEGER NOT NULL DEFAULT 0,
+  failed_cases INTEGER NOT NULL DEFAULT 0,
+  avg_score REAL NOT NULL DEFAULT 0,
+  error TEXT,
+  created_at TEXT NOT NULL,
+  started_at TEXT,
+  completed_at TEXT,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_er_project ON lt_eval_runs(tenant_id, project_id);
+
+CREATE TABLE IF NOT EXISTS lt_eval_run_results (
+  id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  suite_name TEXT NOT NULL,
+  case_id TEXT,
+  pass INTEGER NOT NULL DEFAULT 0,
+  score REAL NOT NULL DEFAULT 0,
+  summary TEXT,
+  dimension_results TEXT DEFAULT '[]',
+  duration_ms INTEGER,
+  messages TEXT DEFAULT '[]',
+  logs TEXT DEFAULT '[]',
+  error TEXT,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (run_id, id)
+);
+`;
+
+function parseJson<T>(val: unknown, fallback: T): T {
+  if (val == null) return fallback;
+  if (typeof val === "string") {
+    try { return JSON.parse(val) as T; } catch { return fallback; }
+  }
+  return val as T;
+}
+
+function parseOptionalJson<T>(val: unknown): T | undefined {
+  if (val == null) return undefined;
+  if (typeof val === "string") {
+    try { return JSON.parse(val) as T; } catch { return undefined; }
+  }
+  return val as T;
+}
+
+export class LocalEvalStore implements EvalStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  // -------------------------------------------------------------------------
+  // Projects
+  // -------------------------------------------------------------------------
+
+  async getProjectsByTenant(tenantId: string): Promise<EvalProject[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_eval_projects WHERE tenant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId) as unknown as Record<string, unknown>[];
+    return rows.map(this.mapRowToProject);
+  }
+
+  async getProjectById(tenantId: string, id: string): Promise<EvalProject | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_eval_projects WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, id) as unknown as Record<string, unknown> | undefined;
+    return row ? this.mapRowToProject(row) : null;
+  }
+
+  async createProject(tenantId: string, id: string, data: CreateEvalProjectRequest): Promise<EvalProject> {
+    const actualId = id || randomUUID();
+    this.db.prepare(
+      `INSERT INTO lt_eval_projects (id, tenant_id, name, description, version, judge_model_config, target_server_config, concurrency, report_config, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(actualId, tenantId, data.name, data.description || null, data.version || null,
+      JSON.stringify(data.judgeModelConfig), JSON.stringify(data.targetServerConfig), data.concurrency ?? 3,
+      data.reportConfig === undefined ? null : JSON.stringify(data.reportConfig),
+      nowISO(), nowISO());
+    return (await this.getProjectById(tenantId, actualId))!;
+  }
+
+  async updateProject(tenantId: string, id: string, updates: Partial<CreateEvalProjectRequest>): Promise<EvalProject | null> {
+    const existing = await this.getProjectById(tenantId, id);
+    if (!existing) return null;
+
+    const set: string[] = [];
+    const vals: unknown[] = [];
+    if (updates.name !== undefined) { set.push("name = ?"); vals.push(updates.name); }
+    if (updates.description !== undefined) { set.push("description = ?"); vals.push(updates.description || null); }
+    if (updates.version !== undefined) { set.push("version = ?"); vals.push(updates.version || null); }
+    if (updates.judgeModelConfig !== undefined) { set.push("judge_model_config = ?"); vals.push(JSON.stringify(updates.judgeModelConfig)); }
+    if (updates.targetServerConfig !== undefined) { set.push("target_server_config = ?"); vals.push(JSON.stringify(updates.targetServerConfig)); }
+    if (updates.concurrency !== undefined) { set.push("concurrency = ?"); vals.push(updates.concurrency); }
+    if (updates.reportConfig !== undefined) { set.push("report_config = ?"); vals.push(JSON.stringify(updates.reportConfig)); }
+    set.push("updated_at = ?"); vals.push(nowISO());
+    vals.push(tenantId, id);
+
+    this.db.prepare(
+      `UPDATE lt_eval_projects SET ${set.join(", ")} WHERE tenant_id = ? AND id = ?`,
+    ).run(...vals);
+
+    return this.getProjectById(tenantId, id);
+  }
+
+  async deleteProject(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(`DELETE FROM lt_eval_projects WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
+    return result.changes > 0;
+  }
+
+  // -------------------------------------------------------------------------
+  // Suites
+  // -------------------------------------------------------------------------
+
+  async getSuitesByProject(tenantId: string, projectId: string): Promise<EvalSuite[]> {
+    const rows = this.db.prepare(
+      `SELECT s.*, (SELECT COUNT(*) FROM lt_eval_cases c WHERE c.suite_id = s.id AND c.tenant_id = s.tenant_id) as case_count
+       FROM lt_eval_suites s WHERE s.tenant_id = ? AND s.project_id = ? ORDER BY s.created_at DESC`,
+    ).all(tenantId, projectId) as unknown as Record<string, unknown>[];
+    return rows.map(this.mapRowToSuite);
+  }
+
+  async getSuiteById(tenantId: string, id: string): Promise<EvalSuite | null> {
+    const row = this.db.prepare(
+      `SELECT s.*, (SELECT COUNT(*) FROM lt_eval_cases c WHERE c.suite_id = s.id AND c.tenant_id = s.tenant_id) as case_count
+       FROM lt_eval_suites s WHERE s.tenant_id = ? AND s.id = ?`,
+    ).get(tenantId, id) as unknown as Record<string, unknown> | undefined;
+    return row ? this.mapRowToSuite(row) : null;
+  }
+
+  async createSuite(tenantId: string, projectId: string, id: string, data: CreateEvalSuiteRequest): Promise<EvalSuite> {
+    const actualId = id || randomUUID();
+    this.db.prepare(
+      `INSERT INTO lt_eval_suites (id, tenant_id, project_id, name, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`,
+    ).run(actualId, tenantId, projectId, data.name, nowISO(), nowISO());
+    return (await this.getSuiteById(tenantId, actualId))!;
+  }
+
+  async updateSuite(tenantId: string, id: string, updates: Partial<CreateEvalSuiteRequest>): Promise<EvalSuite | null> {
+    const existing = await this.getSuiteById(tenantId, id);
+    if (!existing) return null;
+    const set: string[] = [];
+    const vals: unknown[] = [];
+    if (updates.name !== undefined) { set.push("name = ?"); vals.push(updates.name); }
+    set.push("updated_at = ?"); vals.push(nowISO());
+    vals.push(tenantId, id);
+
+    this.db.prepare(
+      `UPDATE lt_eval_suites SET ${set.join(", ")} WHERE tenant_id = ? AND id = ?`,
+    ).run(...vals);
+    return this.getSuiteById(tenantId, id);
+  }
+
+  async deleteSuite(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(`DELETE FROM lt_eval_suites WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
+    return result.changes > 0;
+  }
+
+  // -------------------------------------------------------------------------
+  // Cases
+  // -------------------------------------------------------------------------
+
+  async getCasesBySuite(tenantId: string, suiteId: string): Promise<EvalCase[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_eval_cases WHERE tenant_id = ? AND suite_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId, suiteId) as unknown as Record<string, unknown>[];
+    return rows.map(this.mapRowToCase);
+  }
+
+  async getCaseById(tenantId: string, id: string): Promise<EvalCase | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_eval_cases WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, id) as unknown as Record<string, unknown> | undefined;
+    return row ? this.mapRowToCase(row) : null;
+  }
+
+  async createCase(tenantId: string, suiteId: string, id: string, data: CreateEvalCaseRequest): Promise<EvalCase> {
+    const actualId = id || randomUUID();
+    this.db.prepare(
+      `INSERT INTO lt_eval_cases (id, tenant_id, suite_id, input_message, input_files, steps, output_type, content_assertion, rubrics, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(actualId, tenantId, suiteId, data.inputMessage,
+      data.inputFiles ? JSON.stringify(data.inputFiles) : null,
+      JSON.stringify(data.steps), data.outputType || "message_content",
+      data.contentAssertion || "",
+      data.rubrics ? JSON.stringify(data.rubrics) : null,
+      nowISO(), nowISO());
+    return (await this.getCaseById(tenantId, actualId))!;
+  }
+
+  async updateCase(tenantId: string, id: string, updates: Partial<CreateEvalCaseRequest>): Promise<EvalCase | null> {
+    const existing = await this.getCaseById(tenantId, id);
+    if (!existing) return null;
+
+    const set: string[] = [];
+    const vals: unknown[] = [];
+    if (updates.inputMessage !== undefined) { set.push("input_message = ?"); vals.push(updates.inputMessage); }
+    if (updates.inputFiles !== undefined) { set.push("input_files = ?"); vals.push(JSON.stringify(updates.inputFiles)); }
+    if (updates.steps !== undefined) { set.push("steps = ?"); vals.push(JSON.stringify(updates.steps)); }
+    if (updates.outputType !== undefined) { set.push("output_type = ?"); vals.push(updates.outputType); }
+    if (updates.contentAssertion !== undefined) { set.push("content_assertion = ?"); vals.push(updates.contentAssertion); }
+    if (updates.rubrics !== undefined) { set.push("rubrics = ?"); vals.push(JSON.stringify(updates.rubrics)); }
+    set.push("updated_at = ?"); vals.push(nowISO());
+    vals.push(tenantId, id);
+
+    this.db.prepare(
+      `UPDATE lt_eval_cases SET ${set.join(", ")} WHERE tenant_id = ? AND id = ?`,
+    ).run(...vals);
+    return this.getCaseById(tenantId, id);
+  }
+
+  async deleteCase(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(`DELETE FROM lt_eval_cases WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
+    return result.changes > 0;
+  }
+
+  // -------------------------------------------------------------------------
+  // Runs
+  // -------------------------------------------------------------------------
+
+  async getRunsByTenant(tenantId: string, opts?: { projectId?: string; status?: string }): Promise<EvalRun[]> {
+    let query = `SELECT * FROM lt_eval_runs WHERE tenant_id = ?`;
+    const vals: unknown[] = [tenantId];
+    if (opts?.projectId) { query += ` AND project_id = ?`; vals.push(opts.projectId); }
+    if (opts?.status) { query += ` AND status = ?`; vals.push(opts.status); }
+    query += ` ORDER BY created_at DESC`;
+    const rows = this.db.prepare(query).all(...vals) as unknown as Record<string, unknown>[];
+    return rows.map(this.mapRowToRun);
+  }
+
+  async getRunById(tenantId: string, id: string): Promise<EvalRun | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_eval_runs WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, id) as unknown as Record<string, unknown> | undefined;
+    return row ? this.mapRowToRun(row) : null;
+  }
+
+  async createRun(tenantId: string, projectId: string, id: string, data: CreateEvalRunRequest): Promise<EvalRun> {
+    const actualId = id || randomUUID();
+    this.db.prepare(
+      `INSERT INTO lt_eval_runs (id, project_id, tenant_id, status, concurrency, total_cases, passed_cases, failed_cases, avg_score, created_at)
+       VALUES (?, ?, ?, 'running', ?, ?, 0, 0, 0, ?)`,
+    ).run(actualId, projectId, tenantId, data.concurrency, data.totalCases, nowISO());
+    return (await this.getRunById(tenantId, actualId))!;
+  }
+
+  async updateRunStatus(tenantId: string, id: string, updates: {
+    status?: EvalRun["status"]; passedCases?: number; failedCases?: number; avgScore?: number; error?: string; completedAt?: Date;
+  }): Promise<EvalRun | null> {
+    const existing = await this.getRunById(tenantId, id);
+    if (!existing) return null;
+
+    const set: string[] = [];
+    const vals: unknown[] = [];
+    if (updates.status !== undefined) { set.push("status = ?"); vals.push(updates.status); }
+    if (updates.passedCases !== undefined) { set.push("passed_cases = ?"); vals.push(updates.passedCases); }
+    if (updates.failedCases !== undefined) { set.push("failed_cases = ?"); vals.push(updates.failedCases); }
+    if (updates.avgScore !== undefined) { set.push("avg_score = ?"); vals.push(updates.avgScore); }
+    if (updates.error !== undefined) { set.push("error = ?"); vals.push(updates.error || null); }
+    if (updates.completedAt !== undefined) { set.push("completed_at = ?"); vals.push(updates.completedAt ? updates.completedAt.toISOString() : null); }
+    vals.push(tenantId, id);
+
+    this.db.prepare(
+      `UPDATE lt_eval_runs SET ${set.join(", ")} WHERE tenant_id = ? AND id = ?`,
+    ).run(...vals);
+    return this.getRunById(tenantId, id);
+  }
+
+  async deleteRun(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(`DELETE FROM lt_eval_runs WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
+    return result.changes > 0;
+  }
+
+  // -------------------------------------------------------------------------
+  // Run Results
+  // -------------------------------------------------------------------------
+
+  async getResultsByRun(tenantId: string, runId: string): Promise<EvalRunResult[]> {
+    const rows = this.db.prepare(
+      `SELECT rr.* FROM lt_eval_run_results rr
+       INNER JOIN lt_eval_runs r ON r.id = rr.run_id
+       WHERE r.tenant_id = ? AND rr.run_id = ? ORDER BY rr.created_at ASC`,
+    ).all(tenantId, runId) as unknown as Record<string, unknown>[];
+    return rows.map(this.mapRowToRunResult);
+  }
+
+  private async getRunResultById(tenantId: string, id: string): Promise<EvalRunResult | null> {
+    const row = this.db.prepare(
+      `SELECT rr.* FROM lt_eval_run_results rr
+       INNER JOIN lt_eval_runs r ON r.id = rr.run_id
+       WHERE r.tenant_id = ? AND rr.id = ?`,
+    ).get(tenantId, id) as unknown as Record<string, unknown> | undefined;
+    return row ? this.mapRowToRunResult(row) : null;
+  }
+
+  async createRunResult(tenantId: string, runId: string, id: string, data: Omit<EvalRunResult, "id" | "runId" | "createdAt">): Promise<EvalRunResult> {
+    const actualId = id || randomUUID();
+    this.db.prepare(
+      `INSERT INTO lt_eval_run_results (id, run_id, suite_name, case_id, pass, score, summary, dimension_results, duration_ms, messages, logs, error, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(actualId, runId, data.suiteName, data.caseId || null,
+      data.pass ? 1 : 0, data.score, data.summary || null,
+      JSON.stringify(data.dimensionResults || []), data.durationMs ?? null,
+      JSON.stringify(data.messages || []), JSON.stringify(data.logs || []),
+      data.error || null, nowISO());
+    return (await this.getRunResultById(tenantId, actualId))!;
+  }
+
+  async updateRunResult(tenantId: string, id: string, updates: Partial<EvalRunResult>): Promise<EvalRunResult | null> {
+    if (updates.runId !== undefined) throw new Error("runId cannot be updated on an existing result");
+
+    const set: string[] = [];
+    const vals: unknown[] = [];
+    if (updates.suiteName !== undefined) { set.push("suite_name = ?"); vals.push(updates.suiteName); }
+    if (updates.caseId !== undefined) { set.push("case_id = ?"); vals.push(updates.caseId); }
+    if (updates.pass !== undefined) { set.push("pass = ?"); vals.push(updates.pass ? 1 : 0); }
+    if (updates.score !== undefined) { set.push("score = ?"); vals.push(updates.score); }
+    if (updates.summary !== undefined) { set.push("summary = ?"); vals.push(updates.summary || null); }
+    if (updates.dimensionResults !== undefined) { set.push("dimension_results = ?"); vals.push(JSON.stringify(updates.dimensionResults)); }
+    if (updates.durationMs !== undefined) { set.push("duration_ms = ?"); vals.push(updates.durationMs ?? null); }
+    if (updates.messages !== undefined) { set.push("messages = ?"); vals.push(JSON.stringify(updates.messages)); }
+    if (updates.logs !== undefined) { set.push("logs = ?"); vals.push(JSON.stringify(updates.logs)); }
+    if (updates.error !== undefined) { set.push("error = ?"); vals.push(updates.error || null); }
+    if (set.length === 0) return this.getRunResultById(tenantId, id);
+
+    vals.push(id, tenantId);
+    this.db.prepare(
+      `UPDATE lt_eval_run_results SET ${set.join(", ")}
+       WHERE id = ? AND run_id IN (SELECT id FROM lt_eval_runs WHERE tenant_id = ?)`,
+    ).run(...vals);
+
+    return this.getRunResultById(tenantId, id);
+  }
+
+  // -------------------------------------------------------------------------
+  // Reports
+  // -------------------------------------------------------------------------
+
+  async getProjectReport(tenantId: string, projectId: string): Promise<EvalProjectReport | null> {
+    const project = await this.getProjectById(tenantId, projectId);
+    if (!project) return null;
+
+    const runs = await this.getRunsByTenant(tenantId, { projectId });
+    const totalRuns = runs.length;
+    const latestPassRate = runs.length > 0
+      ? (runs[0].totalCases > 0 ? runs[0].passedCases / runs[0].totalCases : 0)
+      : 0;
+    const avgScore = runs.length > 0
+      ? runs.reduce((sum, r) => sum + r.avgScore, 0) / runs.length
+      : 0;
+
+    return { projectId: project.id, projectName: project.name, totalRuns, latestPassRate, avgScore, runs };
+  }
+
+  // -------------------------------------------------------------------------
+  // Row mappers
+  // -------------------------------------------------------------------------
+
+  private mapRowToProject(row: Record<string, unknown>): EvalProject {
+    return {
+      id: row.id as string,
+      tenantId: row.tenant_id as string,
+      name: row.name as string,
+      description: row.description as string | undefined,
+      version: row.version as string | undefined,
+      judgeModelConfig: parseJson<Record<string, unknown>>(row.judge_model_config, {}),
+      targetServerConfig: parseJson<Record<string, unknown>>(row.target_server_config, {}),
+      concurrency: (row.concurrency as number) ?? 3,
+      reportConfig: parseOptionalJson<Record<string, unknown>>(row.report_config),
+      createdAt: parseISO(row.created_at as string),
+      updatedAt: parseISO(row.updated_at as string),
+    };
+  }
+
+  private mapRowToSuite(row: Record<string, unknown>): EvalSuite {
+    return {
+      id: row.id as string,
+      tenantId: row.tenant_id as string,
+      projectId: row.project_id as string,
+      name: row.name as string,
+      createdAt: parseISO(row.created_at as string),
+      updatedAt: parseISO(row.updated_at as string),
+      caseCount: row.case_count !== undefined ? (row.case_count as number) : undefined,
+    };
+  }
+
+  private mapRowToCase(row: Record<string, unknown>): EvalCase {
+    return {
+      id: row.id as string,
+      tenantId: row.tenant_id as string,
+      suiteId: row.suite_id as string,
+      inputMessage: row.input_message as string,
+      inputFiles: parseOptionalJson<Record<string, string>>(row.input_files),
+      steps: parseJson<Array<{ agent_id: string; override_message?: string }>>(row.steps, []),
+      outputType: (row.output_type as EvalCase["outputType"]) || "message_content",
+      contentAssertion: (row.content_assertion as string) || "",
+      rubrics: parseOptionalJson<Array<{ name: string; weight: number; description: string }>>(row.rubrics),
+      createdAt: parseISO(row.created_at as string),
+      updatedAt: parseISO(row.updated_at as string),
+    };
+  }
+
+  private mapRowToRun(row: Record<string, unknown>): EvalRun {
+    return {
+      id: row.id as string,
+      projectId: row.project_id as string,
+      tenantId: row.tenant_id as string,
+      status: row.status as EvalRun["status"],
+      concurrency: (row.concurrency as number) ?? 3,
+      totalCases: (row.total_cases as number) ?? 0,
+      passedCases: (row.passed_cases as number) ?? 0,
+      failedCases: (row.failed_cases as number) ?? 0,
+      avgScore: (row.avg_score as number) ?? 0,
+      error: row.error as string | undefined,
+      createdAt: parseISO(row.created_at as string),
+      startedAt: row.started_at ? parseISO(row.started_at as string) : undefined,
+      completedAt: row.completed_at ? parseISO(row.completed_at as string) : undefined,
+    };
+  }
+
+  private mapRowToRunResult(row: Record<string, unknown>): EvalRunResult {
+    return {
+      id: row.id as string,
+      runId: row.run_id as string,
+      suiteName: row.suite_name as string,
+      caseId: row.case_id as string | undefined,
+      pass: (row.pass as number) === 1,
+      score: (row.score as number) ?? 0,
+      summary: row.summary as string | undefined,
+      dimensionResults: parseOptionalJson<Array<{ name: string; score: number; reason: string }>>(row.dimension_results),
+      durationMs: row.duration_ms as number | undefined,
+      messages: parseOptionalJson<Array<{ role: string; content: string; id?: string }>>(row.messages),
+      logs: parseOptionalJson<Array<{ timestamp: string; level: string; message: string; data?: unknown }>>(row.logs),
+      error: row.error as string | undefined,
+      createdAt: parseISO(row.created_at as string),
+    };
+  }
+}