@axiom-lattice/pg-stores 1.0.53 → 1.0.55

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/index.ts
-import { Pool as Pool16 } from "pg";
+import { Pool as Pool17 } from "pg";
 
 // src/stores/PostgreSQLThreadStore.ts
 import { Pool } from "pg";
@@ -5141,13 +5141,935 @@ var PostgreSQLWorkflowTrackingStore = class {
     };
   }
 };
+
+// src/stores/PostgreSQLEvalStore.ts
+import { Pool as Pool16 } from "pg";
+
+// src/migrations/eval_migrations.ts
+var createEvalProjectsTable = {
+  version: 104,
+  name: "create_eval_projects_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_eval_projects (
+        id UUID PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT,
+        version TEXT,
+        judge_model_config JSONB NOT NULL DEFAULT '{}',
+        target_server_config JSONB NOT NULL DEFAULT '{}',
+        concurrency INTEGER NOT NULL DEFAULT 3,
+        report_config JSONB DEFAULT '{}',
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_projects_tenant_id
+      ON lattice_eval_projects(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_projects_created_at
+      ON lattice_eval_projects(created_at)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_projects_created_at");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_projects_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_eval_projects");
+  }
+};
+var createEvalSuitesTable = {
+  version: 105,
+  name: "create_eval_suites_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_eval_suites (
+        id UUID PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        project_id UUID NOT NULL REFERENCES lattice_eval_projects(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        UNIQUE(project_id, name)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_suites_tenant_id
+      ON lattice_eval_suites(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_suites_project_id
+      ON lattice_eval_suites(project_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_suites_project_id");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_suites_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_eval_suites");
+  }
+};
+var createEvalCasesTable = {
+  version: 106,
+  name: "create_eval_cases_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_eval_cases (
+        id UUID PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        suite_id UUID NOT NULL REFERENCES lattice_eval_suites(id) ON DELETE CASCADE,
+        template_id UUID,
+        input_message TEXT NOT NULL,
+        input_files JSONB DEFAULT '{}',
+        steps JSONB NOT NULL DEFAULT '[]',
+        output_type TEXT NOT NULL DEFAULT 'message_content',
+        content_assertion TEXT,
+        rubrics JSONB DEFAULT '[]',
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_cases_tenant_id
+      ON lattice_eval_cases(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_cases_suite_id
+      ON lattice_eval_cases(suite_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_cases_suite_id");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_cases_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_eval_cases");
+  }
+};
+var createEvalRunsTable = {
+  version: 107,
+  name: "create_eval_runs_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_eval_runs (
+        id UUID PRIMARY KEY,
+        project_id UUID NOT NULL REFERENCES lattice_eval_projects(id) ON DELETE CASCADE,
+        tenant_id VARCHAR(255) 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 FLOAT NOT NULL DEFAULT 0,
+        error TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        started_at TIMESTAMPTZ,
+        completed_at TIMESTAMPTZ
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_runs_tenant_id
+      ON lattice_eval_runs(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_runs_project_id
+      ON lattice_eval_runs(project_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_runs_status
+      ON lattice_eval_runs(status)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_runs_created_at
+      ON lattice_eval_runs(created_at)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_runs_created_at");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_runs_status");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_runs_project_id");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_runs_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_eval_runs");
+  }
+};
+var createEvalRunResultsTable = {
+  version: 108,
+  name: "create_eval_run_results_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_eval_run_results (
+        id UUID PRIMARY KEY,
+        run_id UUID NOT NULL REFERENCES lattice_eval_runs(id) ON DELETE CASCADE,
+        suite_name TEXT NOT NULL DEFAULT '',
+        case_id UUID,
+        pass BOOLEAN NOT NULL DEFAULT false,
+        score FLOAT NOT NULL DEFAULT 0,
+        summary TEXT,
+        dimension_results JSONB DEFAULT '[]',
+        duration_ms INTEGER DEFAULT 0,
+        messages JSONB DEFAULT '[]',
+        logs JSONB DEFAULT '[]',
+        error TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_run_results_run_id
+      ON lattice_eval_run_results(run_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_eval_run_results_case_id
+      ON lattice_eval_run_results(case_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_run_results_case_id");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_eval_run_results_run_id");
+    await client.query("DROP TABLE IF EXISTS lattice_eval_run_results");
+  }
+};
+var evalMigrations = [
+  createEvalProjectsTable,
+  createEvalSuitesTable,
+  createEvalCasesTable,
+  createEvalRunsTable,
+  createEvalRunResultsTable
+];
+
+// src/stores/PostgreSQLEvalStore.ts
+import { v4 as uuidv4 } from "uuid";
+var PostgreSQLEvalStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.ownsPool = true;
+    this.initPromise = null;
+    if (typeof options.poolConfig === "string") {
+      this.pool = new Pool16({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new Pool16(options.poolConfig);
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    for (const m of evalMigrations) {
+      this.migrationManager.register(m);
+    }
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLEvalStore:", error);
+        throw error;
+      });
+    }
+  }
+  /** Dispose resources and close the connection pool */
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+  /**
+   * Initialize the store and run migrations
+   * Uses a promise-based lock to prevent concurrent initialization
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+  /** Ensure store is initialized */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Row mappers
+  // ---------------------------------------------------------------------------
+  mapRowToProject(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      name: row.name,
+      description: row.description,
+      version: row.version,
+      judgeModelConfig: this.parseRequiredJson(row.judge_model_config, {}),
+      targetServerConfig: this.parseRequiredJson(row.target_server_config, {}),
+      concurrency: row.concurrency ?? 3,
+      reportConfig: this.parseOptionalJson(row.report_config),
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+  mapRowToSuite(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      projectId: row.project_id,
+      name: row.name,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at),
+      caseCount: row.case_count !== void 0 ? row.case_count : void 0
+    };
+  }
+  mapRowToCase(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      suiteId: row.suite_id,
+      inputMessage: row.input_message,
+      inputFiles: this.parseOptionalJson(row.input_files),
+      steps: this.parseRequiredJson(row.steps, []),
+      outputType: row.output_type || "message_content",
+      contentAssertion: row.content_assertion || "",
+      rubrics: this.parseOptionalJson(row.rubrics),
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+  mapRowToRun(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      tenantId: row.tenant_id,
+      status: row.status,
+      concurrency: row.concurrency ?? 3,
+      totalCases: row.total_cases ?? 0,
+      passedCases: row.passed_cases ?? 0,
+      failedCases: row.failed_cases ?? 0,
+      avgScore: row.avg_score ?? 0,
+      error: row.error,
+      createdAt: new Date(row.created_at),
+      startedAt: row.started_at ? new Date(row.started_at) : void 0,
+      completedAt: row.completed_at ? new Date(row.completed_at) : void 0
+    };
+  }
+  mapRowToRunResult(row) {
+    return {
+      id: row.id,
+      runId: row.run_id,
+      suiteName: row.suite_name,
+      caseId: row.case_id,
+      pass: row.pass ?? false,
+      score: row.score ?? 0,
+      summary: row.summary,
+      dimensionResults: this.parseOptionalJson(row.dimension_results),
+      durationMs: row.duration_ms,
+      messages: this.parseOptionalJson(row.messages),
+      logs: this.parseOptionalJson(row.logs),
+      error: row.error,
+      createdAt: new Date(row.created_at)
+    };
+  }
+  parseRequiredJson(val, fallback) {
+    if (val == null) return fallback;
+    if (typeof val === "string") {
+      try {
+        return JSON.parse(val);
+      } catch {
+        return fallback;
+      }
+    }
+    return val;
+  }
+  parseOptionalJson(val) {
+    if (val == null) return void 0;
+    if (typeof val === "string") {
+      try {
+        return JSON.parse(val);
+      } catch {
+        return void 0;
+      }
+    }
+    return val;
+  }
+  // ---------------------------------------------------------------------------
+  // Projects
+  // ---------------------------------------------------------------------------
+  /** Get all eval projects for a tenant */
+  async getProjectsByTenant(tenantId) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT id, tenant_id, name, description, version,
+              judge_model_config, target_server_config, concurrency,
+              report_config, created_at, updated_at
+       FROM lattice_eval_projects
+       WHERE tenant_id = $1
+       ORDER BY created_at DESC`,
+      [tenantId]
+    );
+    return rows.map((r) => this.mapRowToProject(r));
+  }
+  /** Get a single eval project by ID for a tenant */
+  async getProjectById(tenantId, id) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT id, tenant_id, name, description, version,
+              judge_model_config, target_server_config, concurrency,
+              report_config, created_at, updated_at
+       FROM lattice_eval_projects
+       WHERE id = $1 AND tenant_id = $2`,
+      [id, tenantId]
+    );
+    return rows.length ? this.mapRowToProject(rows[0]) : null;
+  }
+  /** Create a new eval project */
+  async createProject(tenantId, id, data) {
+    await this.ensureInitialized();
+    const actualId = id || uuidv4();
+    const { rows } = await this.pool.query(
+      `INSERT INTO lattice_eval_projects
+        (id, tenant_id, name, description, version, judge_model_config, target_server_config, concurrency, report_config)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+       RETURNING id, tenant_id, name, description, version,
+                 judge_model_config, target_server_config, concurrency,
+                 report_config, created_at, updated_at`,
+      [
+        actualId,
+        tenantId,
+        data.name,
+        data.description || null,
+        data.version || null,
+        JSON.stringify(data.judgeModelConfig),
+        JSON.stringify(data.targetServerConfig),
+        data.concurrency ?? 3,
+        data.reportConfig === void 0 ? null : JSON.stringify(data.reportConfig)
+      ]
+    );
+    return this.mapRowToProject(rows[0]);
+  }
+  /** Update an eval project */
+  async updateProject(tenantId, id, updates) {
+    await this.ensureInitialized();
+    const set = [];
+    const vals = [];
+    let i = 1;
+    if (updates.name !== void 0) {
+      set.push(`name = $${i++}`);
+      vals.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      set.push(`description = $${i++}`);
+      vals.push(updates.description);
+    }
+    if (updates.version !== void 0) {
+      set.push(`version = $${i++}`);
+      vals.push(updates.version);
+    }
+    if (updates.judgeModelConfig !== void 0) {
+      set.push(`judge_model_config = $${i++}`);
+      vals.push(JSON.stringify(updates.judgeModelConfig));
+    }
+    if (updates.targetServerConfig !== void 0) {
+      set.push(`target_server_config = $${i++}`);
+      vals.push(JSON.stringify(updates.targetServerConfig));
+    }
+    if (updates.concurrency !== void 0) {
+      set.push(`concurrency = $${i++}`);
+      vals.push(updates.concurrency);
+    }
+    if (updates.reportConfig !== void 0) {
+      set.push(`report_config = $${i++}`);
+      vals.push(JSON.stringify(updates.reportConfig));
+    }
+    if (set.length === 0) return this.getProjectById(tenantId, id);
+    set.push(`updated_at = NOW()`);
+    vals.push(id, tenantId);
+    const { rows } = await this.pool.query(
+      `UPDATE lattice_eval_projects SET ${set.join(", ")}
+       WHERE id = $${i} AND tenant_id = $${i + 1}
+       RETURNING id, tenant_id, name, description, version,
+                 judge_model_config, target_server_config, concurrency,
+                 report_config, created_at, updated_at`,
+      vals
+    );
+    return rows.length ? this.mapRowToProject(rows[0]) : null;
+  }
+  /** Delete an eval project */
+  async deleteProject(tenantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_eval_projects WHERE id = $1 AND tenant_id = $2`,
+      [id, tenantId]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Suites
+  // ---------------------------------------------------------------------------
+  /** Get all suites in a project with case counts */
+  async getSuitesByProject(tenantId, projectId) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT s.id, s.tenant_id, s.project_id, s.name, s.created_at, s.updated_at,
+              COUNT(c.id)::int AS case_count
+       FROM lattice_eval_suites s
+       LEFT JOIN lattice_eval_cases c ON c.suite_id = s.id
+       WHERE s.tenant_id = $1 AND s.project_id = $2
+       GROUP BY s.id
+       ORDER BY s.created_at DESC`,
+      [tenantId, projectId]
+    );
+    return rows.map((r) => this.mapRowToSuite(r));
+  }
+  /** Get a single suite by ID with case count */
+  async getSuiteById(tenantId, id) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT s.id, s.tenant_id, s.project_id, s.name, s.created_at, s.updated_at,
+              COUNT(c.id)::int AS case_count
+       FROM lattice_eval_suites s
+       LEFT JOIN lattice_eval_cases c ON c.suite_id = s.id
+       WHERE s.tenant_id = $1 AND s.id = $2
+       GROUP BY s.id`,
+      [tenantId, id]
+    );
+    return rows.length ? this.mapRowToSuite(rows[0]) : null;
+  }
+  /** Create a new eval suite */
+  async createSuite(tenantId, projectId, id, data) {
+    await this.ensureInitialized();
+    const actualId = id || uuidv4();
+    const { rows } = await this.pool.query(
+      `INSERT INTO lattice_eval_suites (id, tenant_id, project_id, name)
+       VALUES ($1, $2, $3, $4)
+       RETURNING id, tenant_id, project_id, name, created_at, updated_at`,
+      [actualId, tenantId, projectId, data.name]
+    );
+    return this.mapRowToSuite(rows[0]);
+  }
+  /** Update a suite's name */
+  async updateSuite(tenantId, id, updates) {
+    await this.ensureInitialized();
+    const set = [];
+    const vals = [];
+    let i = 1;
+    if (updates.name !== void 0) {
+      set.push(`name = $${i++}`);
+      vals.push(updates.name);
+    }
+    if (set.length === 0) return this.getSuiteById(tenantId, id);
+    set.push(`updated_at = NOW()`);
+    vals.push(id, tenantId);
+    const { rows } = await this.pool.query(
+      `UPDATE lattice_eval_suites SET ${set.join(", ")}
+       WHERE id = $${i} AND tenant_id = $${i + 1}
+       RETURNING id, tenant_id, project_id, name, created_at, updated_at`,
+      vals
+    );
+    return rows.length ? this.mapRowToSuite(rows[0]) : null;
+  }
+  /** Delete a suite */
+  async deleteSuite(tenantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_eval_suites WHERE id = $1 AND tenant_id = $2`,
+      [id, tenantId]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Cases
+  // ---------------------------------------------------------------------------
+  /** Get all test cases in a suite */
+  async getCasesBySuite(tenantId, suiteId) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT id, tenant_id, suite_id,
+              input_message, input_files, steps,
+              output_type, content_assertion, rubrics,
+              created_at, updated_at
+       FROM lattice_eval_cases
+       WHERE tenant_id = $1 AND suite_id = $2
+       ORDER BY created_at`,
+      [tenantId, suiteId]
+    );
+    return rows.map((r) => this.mapRowToCase(r));
+  }
+  /** Get a single test case by ID */
+  async getCaseById(tenantId, id) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT id, tenant_id, suite_id,
+              input_message, input_files, steps,
+              output_type, content_assertion, rubrics,
+              created_at, updated_at
+       FROM lattice_eval_cases
+       WHERE id = $1 AND tenant_id = $2`,
+      [id, tenantId]
+    );
+    return rows.length ? this.mapRowToCase(rows[0]) : null;
+  }
+  /** Create a new test case */
+  async createCase(tenantId, suiteId, id, data) {
+    await this.ensureInitialized();
+    const actualId = id || uuidv4();
+    const { rows } = await this.pool.query(
+      `INSERT INTO lattice_eval_cases
+        (id, tenant_id, suite_id, input_message, input_files, steps, output_type, content_assertion, rubrics)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+       RETURNING id, tenant_id, suite_id,
+                 input_message, input_files, steps,
+                 output_type, content_assertion, rubrics,
+                 created_at, updated_at`,
+      [
+        actualId,
+        tenantId,
+        suiteId,
+        data.inputMessage,
+        JSON.stringify(data.inputFiles || {}),
+        JSON.stringify(data.steps),
+        data.outputType,
+        data.contentAssertion || null,
+        JSON.stringify(data.rubrics || [])
+      ]
+    );
+    return this.mapRowToCase(rows[0]);
+  }
+  /** Update a test case */
+  async updateCase(tenantId, id, updates) {
+    await this.ensureInitialized();
+    const set = [];
+    const vals = [];
+    let i = 1;
+    if (updates.inputMessage !== void 0) {
+      set.push(`input_message = $${i++}`);
+      vals.push(updates.inputMessage);
+    }
+    if (updates.inputFiles !== void 0) {
+      set.push(`input_files = $${i++}`);
+      vals.push(JSON.stringify(updates.inputFiles));
+    }
+    if (updates.steps !== void 0) {
+      set.push(`steps = $${i++}`);
+      vals.push(JSON.stringify(updates.steps));
+    }
+    if (updates.outputType !== void 0) {
+      set.push(`output_type = $${i++}`);
+      vals.push(updates.outputType);
+    }
+    if (updates.contentAssertion !== void 0) {
+      set.push(`content_assertion = $${i++}`);
+      vals.push(updates.contentAssertion);
+    }
+    if (updates.rubrics !== void 0) {
+      set.push(`rubrics = $${i++}`);
+      vals.push(JSON.stringify(updates.rubrics));
+    }
+    if (set.length === 0) return this.getCaseById(tenantId, id);
+    set.push(`updated_at = NOW()`);
+    vals.push(id, tenantId);
+    const { rows } = await this.pool.query(
+      `UPDATE lattice_eval_cases SET ${set.join(", ")}
+       WHERE id = $${i} AND tenant_id = $${i + 1}
+       RETURNING id, tenant_id, suite_id,
+                 input_message, input_files, steps,
+                 output_type, content_assertion, rubrics,
+                 created_at, updated_at`,
+      vals
+    );
+    return rows.length ? this.mapRowToCase(rows[0]) : null;
+  }
+  /** Delete a test case */
+  async deleteCase(tenantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_eval_cases WHERE id = $1 AND tenant_id = $2`,
+      [id, tenantId]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Runs
+  // ---------------------------------------------------------------------------
+  /** Get all runs for a tenant, optionally filtered by project or status */
+  async getRunsByTenant(tenantId, opts) {
+    await this.ensureInitialized();
+    const conditions = ["tenant_id = $1"];
+    const vals = [tenantId];
+    let i = 2;
+    if (opts?.projectId) {
+      conditions.push(`project_id = $${i++}`);
+      vals.push(opts.projectId);
+    }
+    if (opts?.status) {
+      conditions.push(`status = $${i++}`);
+      vals.push(opts.status);
+    }
+    const { rows } = await this.pool.query(
+      `SELECT id, project_id, tenant_id,
+              status, concurrency, total_cases,
+              passed_cases, failed_cases, avg_score,
+              error, created_at, started_at, completed_at
+       FROM lattice_eval_runs
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY created_at DESC`,
+      vals
+    );
+    return rows.map((r) => this.mapRowToRun(r));
+  }
+  /** Get a single run by ID */
+  async getRunById(tenantId, id) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT id, project_id, tenant_id,
+              status, concurrency, total_cases,
+              passed_cases, failed_cases, avg_score,
+              error, created_at, started_at, completed_at
+       FROM lattice_eval_runs
+       WHERE id = $1 AND tenant_id = $2`,
+      [id, tenantId]
+    );
+    return rows.length ? this.mapRowToRun(rows[0]) : null;
+  }
+  /** Create a new eval run */
+  async createRun(tenantId, projectId, id, data) {
+    await this.ensureInitialized();
+    const actualId = id || uuidv4();
+    const { rows } = await this.pool.query(
+      `INSERT INTO lattice_eval_runs
+        (id, project_id, tenant_id, status, concurrency, total_cases, passed_cases, failed_cases, avg_score, started_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       RETURNING id, project_id, tenant_id,
+                 status, concurrency, total_cases,
+                 passed_cases, failed_cases, avg_score,
+                 error, created_at, started_at, completed_at`,
+      [
+        actualId,
+        projectId,
+        tenantId,
+        "running",
+        data.concurrency,
+        data.totalCases,
+        0,
+        0,
+        0,
+        /* @__PURE__ */ new Date()
+      ]
+    );
+    return this.mapRowToRun(rows[0]);
+  }
+  /** Update a run's status and aggregate fields */
+  async updateRunStatus(tenantId, id, updates) {
+    await this.ensureInitialized();
+    const set = [];
+    const vals = [];
+    let i = 1;
+    if (updates.status !== void 0) {
+      set.push(`status = $${i++}`);
+      vals.push(updates.status);
+    }
+    if (updates.passedCases !== void 0) {
+      set.push(`passed_cases = $${i++}`);
+      vals.push(updates.passedCases);
+    }
+    if (updates.failedCases !== void 0) {
+      set.push(`failed_cases = $${i++}`);
+      vals.push(updates.failedCases);
+    }
+    if (updates.avgScore !== void 0) {
+      set.push(`avg_score = $${i++}`);
+      vals.push(updates.avgScore);
+    }
+    if (updates.completedAt !== void 0) {
+      set.push(`completed_at = $${i++}`);
+      vals.push(updates.completedAt);
+    }
+    if (updates.error !== void 0) {
+      set.push(`error = $${i++}`);
+      vals.push(updates.error);
+    }
+    if (set.length === 0) return this.getRunById(tenantId, id);
+    vals.push(id, tenantId);
+    const { rows } = await this.pool.query(
+      `UPDATE lattice_eval_runs SET ${set.join(", ")}
+       WHERE id = $${i} AND tenant_id = $${i + 1}
+       RETURNING id, project_id, tenant_id,
+                 status, concurrency, total_cases,
+                 passed_cases, failed_cases, avg_score,
+                 error, created_at, started_at, completed_at`,
+      vals
+    );
+    return rows.length ? this.mapRowToRun(rows[0]) : null;
+  }
+  /** Delete a run and its results */
+  async deleteRun(tenantId, id) {
+    await this.ensureInitialized();
+    await this.pool.query(`DELETE FROM lattice_eval_run_results WHERE run_id = $1 AND tenant_id = $2`, [id, tenantId]);
+    const { rowCount } = await this.pool.query(
+      `DELETE FROM lattice_eval_runs WHERE id = $1 AND tenant_id = $2`,
+      [id, tenantId]
+    );
+    return (rowCount ?? 0) > 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Run Results
+  // ---------------------------------------------------------------------------
+  /** Get all results belonging to a run */
+  async getResultsByRun(tenantId, runId) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT rr.id, rr.run_id, rr.suite_name, rr.case_id,
+              rr.pass, rr.score, rr.summary, rr.dimension_results,
+              rr.duration_ms, rr.messages, rr.logs, rr.error, rr.created_at
+       FROM lattice_eval_run_results rr
+       INNER JOIN lattice_eval_runs r ON r.id = rr.run_id
+       WHERE r.tenant_id = $1 AND rr.run_id = $2
+       ORDER BY rr.created_at`,
+      [tenantId, runId]
+    );
+    return rows.map((r) => this.mapRowToRunResult(r));
+  }
+  /** Create a result for a case within a run */
+  async createRunResult(tenantId, runId, id, data) {
+    await this.ensureInitialized();
+    const actualId = id || uuidv4();
+    const { rows } = await this.pool.query(
+      `INSERT INTO lattice_eval_run_results
+        (id, run_id, suite_name, case_id, pass, score, summary, dimension_results, duration_ms, messages, logs, error)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+       RETURNING id, run_id, suite_name, case_id,
+                 pass, score, summary, dimension_results,
+                 duration_ms, messages, logs, error, created_at`,
+      [
+        actualId,
+        runId,
+        data.suiteName,
+        data.caseId || null,
+        data.pass,
+        data.score,
+        data.summary || null,
+        JSON.stringify(data.dimensionResults || []),
+        data.durationMs ?? null,
+        JSON.stringify(data.messages || []),
+        JSON.stringify(data.logs || []),
+        data.error || null
+      ]
+    );
+    return this.mapRowToRunResult(rows[0]);
+  }
+  /** Update a run result with tenant isolation via the parent run */
+  async updateRunResult(tenantId, id, updates) {
+    await this.ensureInitialized();
+    if (updates.runId !== void 0) {
+      throw new Error("runId cannot be updated on an existing result");
+    }
+    const set = [];
+    const vals = [];
+    let i = 1;
+    if (updates.suiteName !== void 0) {
+      set.push(`suite_name = $${i++}`);
+      vals.push(updates.suiteName);
+    }
+    if (updates.caseId !== void 0) {
+      set.push(`case_id = $${i++}`);
+      vals.push(updates.caseId);
+    }
+    if (updates.pass !== void 0) {
+      set.push(`pass = $${i++}`);
+      vals.push(updates.pass);
+    }
+    if (updates.score !== void 0) {
+      set.push(`score = $${i++}`);
+      vals.push(updates.score);
+    }
+    if (updates.summary !== void 0) {
+      set.push(`summary = $${i++}`);
+      vals.push(updates.summary);
+    }
+    if (updates.dimensionResults !== void 0) {
+      set.push(`dimension_results = $${i++}`);
+      vals.push(JSON.stringify(updates.dimensionResults));
+    }
+    if (updates.durationMs !== void 0) {
+      set.push(`duration_ms = $${i++}`);
+      vals.push(updates.durationMs);
+    }
+    if (updates.messages !== void 0) {
+      set.push(`messages = $${i++}`);
+      vals.push(JSON.stringify(updates.messages));
+    }
+    if (updates.logs !== void 0) {
+      set.push(`logs = $${i++}`);
+      vals.push(JSON.stringify(updates.logs));
+    }
+    if (updates.error !== void 0) {
+      set.push(`error = $${i++}`);
+      vals.push(updates.error);
+    }
+    if (set.length === 0) return this.getRunResultById(tenantId, id);
+    vals.push(id, tenantId);
+    const { rows } = await this.pool.query(
+      `UPDATE lattice_eval_run_results SET ${set.join(", ")}
+       WHERE id = $${i}
+         AND run_id IN (SELECT id FROM lattice_eval_runs WHERE tenant_id = $${i + 1})
+       RETURNING id, run_id, suite_name, case_id,
+                 pass, score, summary, dimension_results,
+                 duration_ms, messages, logs, error, created_at`,
+      vals
+    );
+    return rows.length ? this.mapRowToRunResult(rows[0]) : null;
+  }
+  /** Get a single run result by ID with tenant isolation */
+  async getRunResultById(tenantId, id) {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `SELECT rr.id, rr.run_id, rr.suite_name, rr.case_id,
+              rr.pass, rr.score, rr.summary, rr.dimension_results,
+              rr.duration_ms, rr.messages, rr.logs, rr.error, rr.created_at
+       FROM lattice_eval_run_results rr
+       INNER JOIN lattice_eval_runs r ON r.id = rr.run_id
+       WHERE rr.id = $1 AND r.tenant_id = $2`,
+      [id, tenantId]
+    );
+    return rows.length ? this.mapRowToRunResult(rows[0]) : null;
+  }
+  // ---------------------------------------------------------------------------
+  // Reports
+  // ---------------------------------------------------------------------------
+  /** Aggregate report for a project including all runs */
+  async getProjectReport(tenantId, projectId) {
+    await this.ensureInitialized();
+    const projectRows = await this.pool.query(
+      `SELECT id, tenant_id, name, description, version,
+              judge_model_config, target_server_config, concurrency,
+              report_config, created_at, updated_at
+       FROM lattice_eval_projects
+       WHERE id = $1 AND tenant_id = $2`,
+      [projectId, tenantId]
+    );
+    if (projectRows.rows.length === 0) return null;
+    const project = this.mapRowToProject(projectRows.rows[0]);
+    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
+    };
+  }
+};
 export {
   ChannelIdentityMappingStore,
   MigrationManager,
-  Pool16 as Pool,
+  Pool17 as Pool,
   PostgreSQLAssistantStore,
   PostgreSQLChannelInstallationStore,
   PostgreSQLDatabaseConfigStore,
+  PostgreSQLEvalStore,
   PostgreSQLMcpServerConfigStore,
   PostgreSQLMetricsServerConfigStore,
   PostgreSQLProjectStore,
@@ -5171,6 +6093,11 @@ export {
   createChannelIdentityMappingTables,
   createChannelInstallationsTable,
   createDatabaseConfigsTable,
+  createEvalCasesTable,
+  createEvalProjectsTable,
+  createEvalRunResultsTable,
+  createEvalRunsTable,
+  createEvalSuitesTable,
   createMcpServerConfigsTable,
   createMetricsConfigsTable,
   createProjectsTable,
@@ -5182,6 +6109,7 @@ export {
   createUsersTable,
   createWorkflowTrackingTables,
   createWorkspacesTable,
+  evalMigrations,
   getThreadMessageQueueStore
 };
 //# sourceMappingURL=index.mjs.map