@mastra/pg 0.2.7-alpha.1 → 0.2.7-alpha.3

package/dist/index.js

@@ -2,7 +2,7 @@ import { createHash } from 'crypto';
 import { MastraVector } from '@mastra/core/vector';
 import pg from 'pg';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import { MastraStorage } from '@mastra/core/storage';
+import { MastraStorage, TABLE_EVALS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, TABLE_THREADS, TABLE_MESSAGES } from '@mastra/core/storage';
 import pgPromise from 'pg-promise';
 
 // src/vector/index.ts
@@ -701,12 +701,46 @@ var PostgresStore = class extends MastraStorage {
         port: config.port,
         database: config.database,
         user: config.user,
-        password: config.password
+        password: config.password,
+        ssl: config.ssl
       }
     );
   }
-  getEvalsByAgentName(_agentName, _type) {
-    throw new Error("Method not implemented.");
+  getEvalsByAgentName(agentName, type) {
+    try {
+      const baseQuery = `SELECT * FROM ${TABLE_EVALS} WHERE agent_name = $1`;
+      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
+      const query = `${baseQuery}${typeCondition} ORDER BY created_at DESC`;
+      return this.db.manyOrNone(query, [agentName]).then((rows) => rows?.map((row) => this.transformEvalRow(row)) ?? []);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("relation") && error.message.includes("does not exist")) {
+        return Promise.resolve([]);
+      }
+      console.error("Failed to get evals for the specified agent: " + error?.message);
+      throw error;
+    }
+  }
+  transformEvalRow(row) {
+    let testInfoValue = null;
+    if (row.test_info) {
+      try {
+        testInfoValue = typeof row.test_info === "string" ? JSON.parse(row.test_info) : row.test_info;
+      } catch (e) {
+        console.warn("Failed to parse test_info:", e);
+      }
+    }
+    return {
+      agentName: row.agent_name,
+      input: row.input,
+      output: row.output,
+      result: row.result,
+      metricName: row.metric_name,
+      instructions: row.instructions,
+      testInfo: testInfoValue,
+      globalRunId: row.global_run_id,
+      runId: row.run_id,
+      createdAt: row.created_at
+    };
   }
   async batchInsert({ tableName, records }) {
     try {
@@ -726,7 +760,8 @@ var PostgresStore = class extends MastraStorage {
     scope,
     page,
     perPage,
-    attributes
+    attributes,
+    filters
   }) {
     let idx = 1;
     const limit = perPage;
@@ -744,6 +779,11 @@ var PostgresStore = class extends MastraStorage {
         conditions.push(`attributes->>'${key}' = $${idx++}`);
       });
     }
+    if (filters) {
+      Object.entries(filters).forEach(([key, value]) => {
+        conditions.push(`${key} = $${idx++}`);
+      });
+    }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     if (name) {
       args.push(name);
@@ -756,15 +796,17 @@ var PostgresStore = class extends MastraStorage {
         args.push(value);
       }
     }
+    if (filters) {
+      for (const [key, value] of Object.entries(filters)) {
+        args.push(value);
+      }
+    }
     console.log(
       "QUERY",
-      `SELECT * FROM ${MastraStorage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
-      args
-    );
-    const result = await this.db.manyOrNone(
-      `SELECT * FROM ${MastraStorage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+      `SELECT * FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
       args
     );
+    const result = await this.db.manyOrNone(`SELECT * FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`, args);
     if (!result) {
       return [];
     }
@@ -800,7 +842,7 @@ var PostgresStore = class extends MastraStorage {
         CREATE TABLE IF NOT EXISTS ${tableName} (
           ${columns}
         );
-        ${tableName === MastraStorage.TABLE_WORKFLOW_SNAPSHOT ? `
+        ${tableName === TABLE_WORKFLOW_SNAPSHOT ? `
         DO $$ BEGIN
           IF NOT EXISTS (
             SELECT 1 FROM pg_constraint WHERE conname = 'mastra_workflow_snapshot_workflow_name_run_id_key'
@@ -849,7 +891,7 @@ var PostgresStore = class extends MastraStorage {
       if (!result) {
         return null;
       }
-      if (tableName === MastraStorage.TABLE_WORKFLOW_SNAPSHOT) {
+      if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
         const snapshot = result;
         if (typeof snapshot.snapshot === "string") {
           snapshot.snapshot = JSON.parse(snapshot.snapshot);
@@ -872,7 +914,7 @@ var PostgresStore = class extends MastraStorage {
           metadata,
           "createdAt",
           "updatedAt"
-        FROM "${MastraStorage.TABLE_THREADS}"
+        FROM "${TABLE_THREADS}"
         WHERE id = $1`,
         [threadId]
       );
@@ -900,7 +942,7 @@ var PostgresStore = class extends MastraStorage {
           metadata,
           "createdAt",
           "updatedAt"
-        FROM "${MastraStorage.TABLE_THREADS}"
+        FROM "${TABLE_THREADS}"
         WHERE "resourceId" = $1`,
         [resourceId]
       );
@@ -918,7 +960,7 @@ var PostgresStore = class extends MastraStorage {
   async saveThread({ thread }) {
     try {
       await this.db.none(
-        `INSERT INTO "${MastraStorage.TABLE_THREADS}" (
+        `INSERT INTO "${TABLE_THREADS}" (
           id,
           "resourceId",
           title,
@@ -962,7 +1004,7 @@ var PostgresStore = class extends MastraStorage {
         ...metadata
       };
       const thread = await this.db.one(
-        `UPDATE "${MastraStorage.TABLE_THREADS}"
+        `UPDATE "${TABLE_THREADS}"
         SET title = $1,
             metadata = $2,
             "updatedAt" = $3
@@ -984,8 +1026,8 @@ var PostgresStore = class extends MastraStorage {
   async deleteThread({ threadId }) {
     try {
       await this.db.tx(async (t) => {
-        await t.none(`DELETE FROM "${MastraStorage.TABLE_MESSAGES}" WHERE thread_id = $1`, [threadId]);
-        await t.none(`DELETE FROM "${MastraStorage.TABLE_THREADS}" WHERE id = $1`, [threadId]);
+        await t.none(`DELETE FROM "${TABLE_MESSAGES}" WHERE thread_id = $1`, [threadId]);
+        await t.none(`DELETE FROM "${TABLE_THREADS}" WHERE id = $1`, [threadId]);
       });
     } catch (error) {
       console.error("Error deleting thread:", error);
@@ -1004,7 +1046,7 @@ var PostgresStore = class extends MastraStorage {
             SELECT 
               *,
               ROW_NUMBER() OVER (ORDER BY "createdAt" DESC) as row_num
-            FROM "${MastraStorage.TABLE_MESSAGES}"
+            FROM "${TABLE_MESSAGES}"
             WHERE thread_id = $1
           )
           SELECT
@@ -1047,7 +1089,7 @@ var PostgresStore = class extends MastraStorage {
             type,
             "createdAt", 
             thread_id AS "threadId"
-        FROM "${MastraStorage.TABLE_MESSAGES}"
+        FROM "${TABLE_MESSAGES}"
         WHERE thread_id = $1
         AND id != ALL($2)
         ORDER BY "createdAt" DESC
@@ -1085,7 +1127,7 @@ var PostgresStore = class extends MastraStorage {
       await this.db.tx(async (t) => {
         for (const message of messages) {
           await t.none(
-            `INSERT INTO "${MastraStorage.TABLE_MESSAGES}" (id, thread_id, content, "createdAt", role, type) 
+            `INSERT INTO "${TABLE_MESSAGES}" (id, thread_id, content, "createdAt", role, type) 
              VALUES ($1, $2, $3, $4, $5, $6)`,
             [
               message.id,
@@ -1112,7 +1154,7 @@ var PostgresStore = class extends MastraStorage {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       await this.db.none(
-        `INSERT INTO "${MastraStorage.TABLE_WORKFLOW_SNAPSHOT}" (
+        `INSERT INTO "${TABLE_WORKFLOW_SNAPSHOT}" (
           workflow_name,
           run_id,
           snapshot,
@@ -1135,7 +1177,7 @@ var PostgresStore = class extends MastraStorage {
   }) {
     try {
       const result = await this.load({
-        tableName: MastraStorage.TABLE_WORKFLOW_SNAPSHOT,
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
         keys: {
           workflow_name: workflowName,
           run_id: runId
@@ -1150,6 +1192,67 @@ var PostgresStore = class extends MastraStorage {
       throw error;
     }
   }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset
+  } = {}) {
+    const conditions = [];
+    const values = [];
+    let paramIndex = 1;
+    if (workflowName) {
+      conditions.push(`workflow_name = $${paramIndex}`);
+      values.push(workflowName);
+      paramIndex++;
+    }
+    if (fromDate) {
+      conditions.push(`"createdAt" >= $${paramIndex}`);
+      values.push(fromDate);
+      paramIndex++;
+    }
+    if (toDate) {
+      conditions.push(`"createdAt" <= $${paramIndex}`);
+      values.push(toDate);
+      paramIndex++;
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    let total = 0;
+    if (limit !== void 0 && offset !== void 0) {
+      const countResult = await this.db.one(
+        `SELECT COUNT(*) as count FROM ${TABLE_WORKFLOW_SNAPSHOT} ${whereClause}`,
+        values
+      );
+      total = Number(countResult.count);
+    }
+    const query = `
+      SELECT * FROM ${TABLE_WORKFLOW_SNAPSHOT} 
+      ${whereClause} 
+      ORDER BY "createdAt" DESC
+      ${limit !== void 0 && offset !== void 0 ? ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ""}
+    `;
+    const queryValues = limit !== void 0 && offset !== void 0 ? [...values, limit, offset] : values;
+    const result = await this.db.manyOrNone(query, queryValues);
+    const runs = (result || []).map((row) => {
+      let parsedSnapshot = row.snapshot;
+      if (typeof parsedSnapshot === "string") {
+        try {
+          parsedSnapshot = JSON.parse(row.snapshot);
+        } catch (e) {
+          console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+        }
+      }
+      return {
+        workflowName: row.workflow_name,
+        runId: row.run_id,
+        snapshot: parsedSnapshot,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+      };
+    });
+    return { runs, total: total || runs.length };
+  }
   async close() {
     this.pgp.end();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.2.7-alpha.1",
+  "version": "0.2.7-alpha.3",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,7 @@
   "dependencies": {
     "pg": "^8.13.3",
     "pg-promise": "^11.11.0",
-    "@mastra/core": "^0.8.0-alpha.1"
+    "@mastra/core": "^0.8.0-alpha.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/storage/index.test.ts

@@ -1,4 +1,6 @@
 import { randomUUID } from 'crypto';
+import type { MetricResult } from '@mastra/core/eval';
+import { TABLE_WORKFLOW_SNAPSHOT, TABLE_MESSAGES, TABLE_THREADS, TABLE_EVALS } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
 
@@ -33,6 +35,49 @@ const createSampleMessage = (threadId: string) =>
     createdAt: new Date(),
   }) as any;
 
+const createSampleWorkflowSnapshot = (status: string, createdAt?: Date) => {
+  const runId = `run-${randomUUID()}`;
+  const stepId = `step-${randomUUID()}`;
+  const timestamp = createdAt || new Date();
+  const snapshot = {
+    result: { success: true },
+    value: {},
+    context: {
+      steps: {
+        [stepId]: {
+          status,
+          payload: {},
+          error: undefined,
+        },
+      },
+      triggerData: {},
+      attempts: {},
+    },
+    activePaths: [],
+    runId,
+    timestamp: timestamp.getTime(),
+  } as WorkflowRunState;
+  return { snapshot, runId, stepId };
+};
+
+const createSampleEval = (agentName: string, isTest = false) => {
+  const testInfo = isTest ? { testPath: 'test/path.ts', testName: 'Test Name' } : undefined;
+
+  return {
+    id: randomUUID(),
+    agentName,
+    input: 'Sample input',
+    output: 'Sample output',
+    result: { score: 0.8 } as MetricResult,
+    metricName: 'sample-metric',
+    instructions: 'Sample instructions',
+    testInfo,
+    globalRunId: `global-${randomUUID()}`,
+    runId: `run-${randomUUID()}`,
+    createdAt: new Date().toISOString(),
+  };
+};
+
 describe('PostgresStore', () => {
   let store: PostgresStore;
 
@@ -43,15 +88,15 @@ describe('PostgresStore', () => {
 
   beforeEach(async () => {
     // Clear tables before each test
-    await store.clearTable({ tableName: 'mastra_workflow_snapshot' });
-    await store.clearTable({ tableName: 'mastra_messages' });
-    await store.clearTable({ tableName: 'mastra_threads' });
+    await store.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
+    await store.clearTable({ tableName: TABLE_MESSAGES });
+    await store.clearTable({ tableName: TABLE_THREADS });
+    await store.clearTable({ tableName: TABLE_EVALS });
   });
 
   describe('Thread Operations', () => {
     it('should create and retrieve a thread', async () => {
       const thread = createSampleThread();
-      console.log('Saving thread:', thread);
 
       // Save thread
       const savedThread = await store.__saveThread({ thread });
@@ -81,7 +126,6 @@ describe('PostgresStore', () => {
 
     it('should update thread title and metadata', async () => {
       const thread = createSampleThread();
-      console.log('Saving thread:', thread);
       await store.__saveThread({ thread });
 
       const newMetadata = { newKey: 'newValue' };
@@ -362,7 +406,7 @@ describe('PostgresStore', () => {
       await store.persistWorkflowSnapshot({
         workflowName,
         runId,
-        snapshot: complexSnapshot as WorkflowRunState,
+        snapshot: complexSnapshot as unknown as WorkflowRunState,
       });
 
       const loadedSnapshot = await store.loadWorkflowSnapshot({
@@ -374,6 +418,233 @@ describe('PostgresStore', () => {
     });
   });
 
+  describe('getWorkflowRuns', () => {
+    beforeEach(async () => {
+      await store.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
+    });
+    it('returns empty array when no workflows exist', async () => {
+      const { runs, total } = await store.__getWorkflowRuns();
+      expect(runs).toEqual([]);
+      expect(total).toBe(0);
+    });
+
+    it('returns all workflows by default', async () => {
+      const workflowName1 = 'default_test_1';
+      const workflowName2 = 'default_test_2';
+
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
+
+      await store.persistWorkflowSnapshot({ workflowName: workflowName1, runId: runId1, snapshot: workflow1 });
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
+      await store.persistWorkflowSnapshot({ workflowName: workflowName2, runId: runId2, snapshot: workflow2 });
+
+      const { runs, total } = await store.__getWorkflowRuns();
+      expect(runs).toHaveLength(2);
+      expect(total).toBe(2);
+      expect(runs[0]!.workflowName).toBe(workflowName2); // Most recent first
+      expect(runs[1]!.workflowName).toBe(workflowName1);
+      const firstSnapshot = runs[0]!.snapshot as WorkflowRunState;
+      const secondSnapshot = runs[1]!.snapshot as WorkflowRunState;
+      expect(firstSnapshot.context?.steps[stepId2]?.status).toBe('running');
+      expect(secondSnapshot.context?.steps[stepId1]?.status).toBe('completed');
+    });
+
+    it('filters by workflow name', async () => {
+      const workflowName1 = 'filter_test_1';
+      const workflowName2 = 'filter_test_2';
+
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow2, runId: runId2 } = createSampleWorkflowSnapshot('failed');
+
+      await store.persistWorkflowSnapshot({ workflowName: workflowName1, runId: runId1, snapshot: workflow1 });
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
+      await store.persistWorkflowSnapshot({ workflowName: workflowName2, runId: runId2, snapshot: workflow2 });
+
+      const { runs, total } = await store.__getWorkflowRuns({ workflowName: workflowName1 });
+      expect(runs).toHaveLength(1);
+      expect(total).toBe(1);
+      expect(runs[0]!.workflowName).toBe(workflowName1);
+      const snapshot = runs[0]!.snapshot as WorkflowRunState;
+      expect(snapshot.context?.steps[stepId1]?.status).toBe('completed');
+    });
+
+    it('filters by date range', async () => {
+      const now = new Date();
+      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+      const twoDaysAgo = new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000);
+      const workflowName1 = 'date_test_1';
+      const workflowName2 = 'date_test_2';
+      const workflowName3 = 'date_test_3';
+
+      const { snapshot: workflow1, runId: runId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
+      const { snapshot: workflow3, runId: runId3, stepId: stepId3 } = createSampleWorkflowSnapshot('waiting');
+
+      await store.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          workflow_name: workflowName1,
+          run_id: runId1,
+          snapshot: workflow1,
+          createdAt: twoDaysAgo,
+          updatedAt: twoDaysAgo,
+        },
+      });
+      await store.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          workflow_name: workflowName2,
+          run_id: runId2,
+          snapshot: workflow2,
+          createdAt: yesterday,
+          updatedAt: yesterday,
+        },
+      });
+      await store.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          workflow_name: workflowName3,
+          run_id: runId3,
+          snapshot: workflow3,
+          createdAt: now,
+          updatedAt: now,
+        },
+      });
+
+      const { runs } = await store.__getWorkflowRuns({
+        fromDate: yesterday,
+        toDate: now,
+      });
+
+      expect(runs).toHaveLength(2);
+      expect(runs[0]!.workflowName).toBe(workflowName3);
+      expect(runs[1]!.workflowName).toBe(workflowName2);
+      const firstSnapshot = runs[0]!.snapshot as WorkflowRunState;
+      const secondSnapshot = runs[1]!.snapshot as WorkflowRunState;
+      expect(firstSnapshot.context?.steps[stepId3]?.status).toBe('waiting');
+      expect(secondSnapshot.context?.steps[stepId2]?.status).toBe('running');
+    });
+
+    it('handles pagination', async () => {
+      const workflowName1 = 'page_test_1';
+      const workflowName2 = 'page_test_2';
+      const workflowName3 = 'page_test_3';
+
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
+      const { snapshot: workflow3, runId: runId3, stepId: stepId3 } = createSampleWorkflowSnapshot('waiting');
+
+      await store.persistWorkflowSnapshot({ workflowName: workflowName1, runId: runId1, snapshot: workflow1 });
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
+      await store.persistWorkflowSnapshot({ workflowName: workflowName2, runId: runId2, snapshot: workflow2 });
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
+      await store.persistWorkflowSnapshot({ workflowName: workflowName3, runId: runId3, snapshot: workflow3 });
+
+      // Get first page
+      const page1 = await store.__getWorkflowRuns({ limit: 2, offset: 0 });
+      expect(page1.runs).toHaveLength(2);
+      expect(page1.total).toBe(3); // Total count of all records
+      expect(page1.runs[0]!.workflowName).toBe(workflowName3);
+      expect(page1.runs[1]!.workflowName).toBe(workflowName2);
+      const firstSnapshot = page1.runs[0]!.snapshot as WorkflowRunState;
+      const secondSnapshot = page1.runs[1]!.snapshot as WorkflowRunState;
+      expect(firstSnapshot.context?.steps[stepId3]?.status).toBe('waiting');
+      expect(secondSnapshot.context?.steps[stepId2]?.status).toBe('running');
+
+      // Get second page
+      const page2 = await store.__getWorkflowRuns({ limit: 2, offset: 2 });
+      expect(page2.runs).toHaveLength(1);
+      expect(page2.total).toBe(3);
+      expect(page2.runs[0]!.workflowName).toBe(workflowName1);
+      const snapshot = page2.runs[0]!.snapshot as WorkflowRunState;
+      expect(snapshot.context?.steps[stepId1]?.status).toBe('completed');
+    });
+  });
+
+  describe('Eval Operations', () => {
+    it('should retrieve evals by agent name', async () => {
+      const agentName = `test-agent-${randomUUID()}`;
+
+      // Create sample evals
+      const liveEval = createSampleEval(agentName, false);
+      const testEval = createSampleEval(agentName, true);
+      const otherAgentEval = createSampleEval(`other-agent-${randomUUID()}`, false);
+
+      // Insert evals
+      await store.insert({
+        tableName: TABLE_EVALS,
+        record: {
+          agent_name: liveEval.agentName,
+          input: liveEval.input,
+          output: liveEval.output,
+          result: liveEval.result,
+          metric_name: liveEval.metricName,
+          instructions: liveEval.instructions,
+          test_info: null,
+          global_run_id: liveEval.globalRunId,
+          run_id: liveEval.runId,
+          created_at: liveEval.createdAt,
+          createdAt: new Date(liveEval.createdAt),
+        },
+      });
+
+      await store.insert({
+        tableName: TABLE_EVALS,
+        record: {
+          agent_name: testEval.agentName,
+          input: testEval.input,
+          output: testEval.output,
+          result: testEval.result,
+          metric_name: testEval.metricName,
+          instructions: testEval.instructions,
+          test_info: JSON.stringify(testEval.testInfo),
+          global_run_id: testEval.globalRunId,
+          run_id: testEval.runId,
+          created_at: testEval.createdAt,
+          createdAt: new Date(testEval.createdAt),
+        },
+      });
+
+      await store.insert({
+        tableName: TABLE_EVALS,
+        record: {
+          agent_name: otherAgentEval.agentName,
+          input: otherAgentEval.input,
+          output: otherAgentEval.output,
+          result: otherAgentEval.result,
+          metric_name: otherAgentEval.metricName,
+          instructions: otherAgentEval.instructions,
+          test_info: null,
+          global_run_id: otherAgentEval.globalRunId,
+          run_id: otherAgentEval.runId,
+          created_at: otherAgentEval.createdAt,
+          createdAt: new Date(otherAgentEval.createdAt),
+        },
+      });
+
+      // Test getting all evals for the agent
+      const allEvals = await store.getEvalsByAgentName(agentName);
+      expect(allEvals).toHaveLength(2);
+      expect(allEvals.map(e => e.runId)).toEqual(expect.arrayContaining([liveEval.runId, testEval.runId]));
+
+      // Test getting only live evals
+      const liveEvals = await store.getEvalsByAgentName(agentName, 'live');
+      expect(liveEvals).toHaveLength(1);
+      expect(liveEvals[0].runId).toBe(liveEval.runId);
+
+      // Test getting only test evals
+      const testEvals = await store.getEvalsByAgentName(agentName, 'test');
+      expect(testEvals).toHaveLength(1);
+      expect(testEvals[0].runId).toBe(testEval.runId);
+      expect(testEvals[0].testInfo).toEqual(testEval.testInfo);
+
+      // Test getting evals for non-existent agent
+      const nonExistentEvals = await store.getEvalsByAgentName('non-existent-agent');
+      expect(nonExistentEvals).toHaveLength(0);
+    });
+  });
+
   afterAll(async () => {
     await store.close();
   });