@mastra/pg 0.12.3 → 0.12.4

package/src/storage/index.ts

@@ -1,32 +1,33 @@
-import { MessageList } from '@mastra/core/agent';
 import type { MastraMessageContentV2, MastraMessageV2 } from '@mastra/core/agent';
 import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
-import type { MetricResult } from '@mastra/core/eval';
 import type { MastraMessageV1, StorageThreadType } from '@mastra/core/memory';
-import {
-  MastraStorage,
-  TABLE_MESSAGES,
-  TABLE_THREADS,
-  TABLE_TRACES,
-  TABLE_RESOURCES,
-  TABLE_WORKFLOW_SNAPSHOT,
-  TABLE_EVALS,
-} from '@mastra/core/storage';
+import type { ScoreRowData } from '@mastra/core/scores';
+import { MastraStorage } from '@mastra/core/storage';
 import type {
   EvalRow,
   PaginationInfo,
   StorageColumn,
   StorageGetMessagesArg,
+  StorageGetTracesArg,
+  StorageGetTracesPaginatedArg,
   StorageResourceType,
   TABLE_NAMES,
   WorkflowRun,
   WorkflowRuns,
   PaginationArgs,
+  StoragePagination,
+  StorageDomains,
 } from '@mastra/core/storage';
-import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
+import type { Trace } from '@mastra/core/telemetry';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 import pgPromise from 'pg-promise';
 import type { ISSLConfig } from 'pg-promise/typescript/pg-subset';
+import { LegacyEvalsPG } from './domains/legacy-evals';
+import { MemoryPG } from './domains/memory';
+import { StoreOperationsPG } from './domains/operations';
+import { ScoresPG } from './domains/scores';
+import { TracesPG } from './domains/traces';
+import { WorkflowsPG } from './domains/workflows';
 
 export type PostgresConfig = {
   schemaName?: string;
@@ -47,9 +48,10 @@ export type PostgresConfig = {
 export class PostgresStore extends MastraStorage {
   public db: pgPromise.IDatabase<{}>;
   public pgp: pgPromise.IMain;
+  private client: pgPromise.IDatabase<{}>;
   private schema?: string;
-  private setupSchemaPromise: Promise<void> | null = null;
-  private schemaSetupComplete: boolean | undefined = undefined;
+
+  stores: StorageDomains;
 
   constructor(config: PostgresConfig) {
     // Validation: connectionString or host/database/user/password must not be empty
@@ -76,7 +78,7 @@ export class PostgresStore extends MastraStorage {
       }
       super({ name: 'PostgresStore' });
       this.pgp = pgPromise();
-      this.schema = config.schemaName;
+      this.schema = config.schemaName || 'public';
       this.db = this.pgp(
         `connectionString` in config
           ? { connectionString: config.connectionString }
@@ -89,6 +91,24 @@ export class PostgresStore extends MastraStorage {
               ssl: config.ssl,
             },
       );
+
+      this.client = this.db;
+
+      const operations = new StoreOperationsPG({ client: this.client, schemaName: this.schema });
+      const scores = new ScoresPG({ client: this.client, operations });
+      const traces = new TracesPG({ client: this.client, operations, schema: this.schema });
+      const workflows = new WorkflowsPG({ client: this.client, operations, schema: this.schema });
+      const legacyEvals = new LegacyEvalsPG({ client: this.client, schema: this.schema });
+      const memory = new MemoryPG({ client: this.client, schema: this.schema, operations });
+
+      this.stores = {
+        operations,
+        scores,
+        traces,
+        workflows,
+        legacyEvals,
+        memory,
+      };
     } catch (e) {
       throw new MastraError(
         {
@@ -101,304 +121,42 @@ export class PostgresStore extends MastraStorage {
     }
   }
 
-  public get supports(): {
-    selectByIncludeResourceScope: boolean;
-    resourceWorkingMemory: boolean;
-  } {
+  public get supports() {
     return {
       selectByIncludeResourceScope: true,
       resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true,
     };
   }
 
-  private getTableName(indexName: string) {
-    const parsedIndexName = parseSqlIdentifier(indexName, 'index name');
-    const quotedIndexName = `"${parsedIndexName}"`;
-    const quotedSchemaName = this.getSchemaName();
-    return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
-  }
-
-  private getSchemaName() {
-    return this.schema ? `"${parseSqlIdentifier(this.schema, 'schema name')}"` : undefined;
-  }
-
   /** @deprecated use getEvals instead */
   async getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
-    try {
-      const baseQuery = `SELECT * FROM ${this.getTableName(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`;
-
-      const rows = await this.db.manyOrNone(query, [agentName]);
-      return rows?.map(row => this.transformEvalRow(row)) ?? [];
-    } catch (error) {
-      // Handle case where table doesn't exist yet
-      if (error instanceof Error && error.message.includes('relation') && error.message.includes('does not exist')) {
-        return [];
-      }
-      console.error('Failed to get evals for the specified agent: ' + (error as any)?.message);
-      throw error;
-    }
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
   }
 
-  private transformEvalRow(row: Record<string, any>): EvalRow {
-    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 as string,
-      input: row.input as string,
-      output: row.output as string,
-      result: row.result as MetricResult,
-      metricName: row.metric_name as string,
-      instructions: row.instructions as string,
-      testInfo: testInfoValue,
-      globalRunId: row.global_run_id as string,
-      runId: row.run_id as string,
-      createdAt: row.created_at as string,
-    };
-  }
-
-  async batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
-    try {
-      await this.db.query('BEGIN');
-      for (const record of records) {
-        await this.insert({ tableName, record });
-      }
-      await this.db.query('COMMIT');
-    } catch (error) {
-      await this.db.query('ROLLBACK');
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_BATCH_INSERT_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-            numberOfRecords: records.length,
-          },
-        },
-        error,
-      );
-    }
+  async getEvals(
+    options: {
+      agentName?: string;
+      type?: 'test' | 'live';
+    } & PaginationArgs = {},
+  ): Promise<PaginationInfo & { evals: EvalRow[] }> {
+    return this.stores.legacyEvals.getEvals(options);
   }
 
   /**
    * @deprecated use getTracesPaginated instead
    */
-  public async getTraces(args: {
-    name?: string;
-    scope?: string;
-    attributes?: Record<string, string>;
-    filters?: Record<string, any>;
-    page: number;
-    perPage?: number;
-    fromDate?: Date;
-    toDate?: Date;
-  }): Promise<any[]> {
-    if (args.fromDate || args.toDate) {
-      (args as any).dateRange = {
-        start: args.fromDate,
-        end: args.toDate,
-      };
-    }
-    const result = await this.getTracesPaginated(args);
-    return result.traces;
+  public async getTraces(args: StorageGetTracesArg): Promise<Trace[]> {
+    return this.stores.traces.getTraces(args);
   }
 
-  public async getTracesPaginated(
-    args: {
-      name?: string;
-      scope?: string;
-      attributes?: Record<string, string>;
-      filters?: Record<string, any>;
-    } & PaginationArgs,
-  ): Promise<
-    PaginationInfo & {
-      traces: any[];
-    }
-  > {
-    const { name, scope, page = 0, perPage: perPageInput, attributes, filters, dateRange } = args;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-
-    const perPage = perPageInput !== undefined ? perPageInput : 100; // Default perPage
-    const currentOffset = page * perPage;
-
-    const queryParams: any[] = [];
-    const conditions: string[] = [];
-    let paramIndex = 1;
-
-    if (name) {
-      conditions.push(`name LIKE $${paramIndex++}`);
-      queryParams.push(`${name}%`); // Add wildcard for LIKE
-    }
-    if (scope) {
-      conditions.push(`scope = $${paramIndex++}`);
-      queryParams.push(scope);
-    }
-    if (attributes) {
-      Object.entries(attributes).forEach(([key, value]) => {
-        const parsedKey = parseFieldKey(key);
-        conditions.push(`attributes->>'${parsedKey}' = $${paramIndex++}`);
-        queryParams.push(value);
-      });
-    }
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        const parsedKey = parseFieldKey(key);
-        conditions.push(`"${parsedKey}" = $${paramIndex++}`); // Ensure filter keys are quoted if they are column names
-        queryParams.push(value);
-      });
-    }
-    if (fromDate) {
-      conditions.push(`"createdAt" >= $${paramIndex++}`);
-      queryParams.push(fromDate);
-    }
-    if (toDate) {
-      conditions.push(`"createdAt" <= $${paramIndex++}`);
-      queryParams.push(toDate);
-    }
-
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-
-    // Get total count
-    const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(TABLE_TRACES)} ${whereClause}`;
-    let total = 0;
-    try {
-      const countResult = await this.db.one(countQuery, queryParams);
-      total = parseInt(countResult.count, 10);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TOTAL_COUNT',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            name: args.name ?? '',
-            scope: args.scope ?? '',
-          },
-        },
-        error,
-      );
-    }
-
-    if (total === 0) {
-      return {
-        traces: [],
-        total: 0,
-        page,
-        perPage,
-        hasMore: false,
-      };
-    }
-
-    const dataQuery = `SELECT * FROM ${this.getTableName(
-      TABLE_TRACES,
-    )} ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-    const finalQueryParams = [...queryParams, perPage, currentOffset];
-
-    try {
-      const rows = await this.db.manyOrNone<any>(dataQuery, finalQueryParams);
-      const traces = rows.map(row => ({
-        id: row.id,
-        parentSpanId: row.parentSpanId,
-        traceId: row.traceId,
-        name: row.name,
-        scope: row.scope,
-        kind: row.kind,
-        status: row.status,
-        events: row.events,
-        links: row.links,
-        attributes: row.attributes,
-        startTime: row.startTime,
-        endTime: row.endTime,
-        other: row.other,
-        createdAt: row.createdAt,
-      }));
-
-      return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + traces.length < total,
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TRACES',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            name: args.name ?? '',
-            scope: args.scope ?? '',
-          },
-        },
-        error,
-      );
-    }
+  public async getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & { traces: Trace[] }> {
+    return this.stores.traces.getTracesPaginated(args);
   }
 
-  private async setupSchema() {
-    if (!this.schema || this.schemaSetupComplete) {
-      return;
-    }
-
-    if (!this.setupSchemaPromise) {
-      this.setupSchemaPromise = (async () => {
-        try {
-          // First check if schema exists and we have usage permission
-          const schemaExists = await this.db.oneOrNone(
-            `
-            SELECT EXISTS (
-              SELECT 1 FROM information_schema.schemata 
-              WHERE schema_name = $1
-            )
-          `,
-            [this.schema],
-          );
-
-          if (!schemaExists?.exists) {
-            try {
-              await this.db.none(`CREATE SCHEMA IF NOT EXISTS ${this.getSchemaName()}`);
-              this.logger.info(`Schema "${this.schema}" created successfully`);
-            } catch (error) {
-              this.logger.error(`Failed to create schema "${this.schema}"`, { error });
-              throw new Error(
-                `Unable to create schema "${this.schema}". This requires CREATE privilege on the database. ` +
-                  `Either create the schema manually or grant CREATE privilege to the user.`,
-              );
-            }
-          }
-
-          // If we got here, schema exists and we can use it
-          this.schemaSetupComplete = true;
-          this.logger.debug(`Schema "${this.schema}" is ready for use`);
-        } catch (error) {
-          // Reset flags so we can retry
-          this.schemaSetupComplete = undefined;
-          this.setupSchemaPromise = null;
-          throw error;
-        } finally {
-          this.setupSchemaPromise = null;
-        }
-      })();
-    }
-
-    await this.setupSchemaPromise;
+  async batchTraceInsert({ records }: { records: Record<string, any>[] }): Promise<void> {
+    return this.stores.traces.batchTraceInsert({ records });
   }
 
   async createTable({
@@ -408,76 +166,9 @@ export class PostgresStore extends MastraStorage {
     tableName: TABLE_NAMES;
     schema: Record<string, StorageColumn>;
   }): Promise<void> {
-    try {
-      const columns = Object.entries(schema)
-        .map(([name, def]) => {
-          const parsedName = parseSqlIdentifier(name, 'column name');
-          const constraints = [];
-          if (def.primaryKey) constraints.push('PRIMARY KEY');
-          if (!def.nullable) constraints.push('NOT NULL');
-          return `"${parsedName}" ${def.type.toUpperCase()} ${constraints.join(' ')}`;
-        })
-        .join(',\n');
-
-      // Create schema if it doesn't exist
-      if (this.schema) {
-        await this.setupSchema();
-      }
-
-      const sql = `
-        CREATE TABLE IF NOT EXISTS ${this.getTableName(tableName)} (
-          ${columns}
-        );
-        ${
-          tableName === TABLE_WORKFLOW_SNAPSHOT
-            ? `
-        DO $$ BEGIN
-          IF NOT EXISTS (
-            SELECT 1 FROM pg_constraint WHERE conname = 'mastra_workflow_snapshot_workflow_name_run_id_key'
-          ) THEN
-            ALTER TABLE ${this.getTableName(tableName)}
-            ADD CONSTRAINT mastra_workflow_snapshot_workflow_name_run_id_key
-            UNIQUE (workflow_name, run_id);
-          END IF;
-        END $$;
-        `
-            : ''
-        }
-      `;
-
-      await this.db.none(sql);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_CREATE_TABLE_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.operations.createTable({ tableName, schema });
   }
 
-  protected getDefaultValue(type: StorageColumn['type']): string {
-    switch (type) {
-      case 'timestamp':
-        return 'DEFAULT NOW()';
-      case 'jsonb':
-        return "DEFAULT '{}'::jsonb";
-      default:
-        return super.getDefaultValue(type);
-    }
-  }
-
-  /**
-   * Alters table schema to add columns if they don't exist
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
   async alterTable({
     tableName,
     schema,
@@ -487,288 +178,54 @@ export class PostgresStore extends MastraStorage {
     schema: Record<string, StorageColumn>;
     ifNotExists: string[];
   }): Promise<void> {
-    const fullTableName = this.getTableName(tableName);
-
-    try {
-      for (const columnName of ifNotExists) {
-        if (schema[columnName]) {
-          const columnDef = schema[columnName];
-          const sqlType = this.getSqlType(columnDef.type);
-          const nullable = columnDef.nullable === false ? 'NOT NULL' : '';
-          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : '';
-          const parsedColumnName = parseSqlIdentifier(columnName, 'column name');
-          const alterSql =
-            `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
-
-          await this.db.none(alterSql);
-          this.logger?.debug?.(`Ensured column ${parsedColumnName} exists in table ${fullTableName}`);
-        }
-      }
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_ALTER_TABLE_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
   }
 
   async clearTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
-    try {
-      await this.db.none(`TRUNCATE TABLE ${this.getTableName(tableName)} CASCADE`);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_CLEAR_TABLE_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.operations.clearTable({ tableName });
+  }
+
+  async dropTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
+    return this.stores.operations.dropTable({ tableName });
   }
 
   async insert({ tableName, record }: { tableName: TABLE_NAMES; record: Record<string, any> }): Promise<void> {
-    try {
-      const columns = Object.keys(record).map(col => parseSqlIdentifier(col, 'column name'));
-      const values = Object.values(record);
-      const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
+    return this.stores.operations.insert({ tableName, record });
+  }
 
-      await this.db.none(
-        `INSERT INTO ${this.getTableName(tableName)} (${columns.map(c => `"${c}"`).join(', ')}) VALUES (${placeholders})`,
-        values,
-      );
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_INSERT_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-          },
-        },
-        error,
-      );
-    }
+  async batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
+    return this.stores.operations.batchInsert({ tableName, records });
   }
 
   async load<R>({ tableName, keys }: { tableName: TABLE_NAMES; keys: Record<string, string> }): Promise<R | null> {
-    try {
-      const keyEntries = Object.entries(keys).map(([key, value]) => [parseSqlIdentifier(key, 'column name'), value]);
-      const conditions = keyEntries.map(([key], index) => `"${key}" = $${index + 1}`).join(' AND ');
-      const values = keyEntries.map(([_, value]) => value);
-
-      const result = await this.db.oneOrNone<R>(
-        `SELECT * FROM ${this.getTableName(tableName)} WHERE ${conditions}`,
-        values,
-      );
-
-      if (!result) {
-        return null;
-      }
-
-      // If this is a workflow snapshot, parse the snapshot field
-      if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
-        const snapshot = result as any;
-        if (typeof snapshot.snapshot === 'string') {
-          snapshot.snapshot = JSON.parse(snapshot.snapshot);
-        }
-        return snapshot;
-      }
-
-      return result;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_LOAD_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.operations.load({ tableName, keys });
   }
 
-  async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
-    try {
-      const thread = await this.db.oneOrNone<StorageThreadType>(
-        `SELECT 
-          id,
-          "resourceId",
-          title,
-          metadata,
-          "createdAt",
-          "updatedAt"
-        FROM ${this.getTableName(TABLE_THREADS)}
-        WHERE id = $1`,
-        [threadId],
-      );
-
-      if (!thread) {
-        return null;
-      }
+  /**
+   * Memory
+   */
 
-      return {
-        ...thread,
-        metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt,
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_THREAD_BY_ID_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-          },
-        },
-        error,
-      );
-    }
+  async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
+    return this.stores.memory.getThreadById({ threadId });
   }
 
   /**
    * @deprecated use getThreadsByResourceIdPaginated instead
    */
   public async getThreadsByResourceId(args: { resourceId: string }): Promise<StorageThreadType[]> {
-    const { resourceId } = args;
-
-    try {
-      const baseQuery = `FROM ${this.getTableName(TABLE_THREADS)} WHERE "resourceId" = $1`;
-      const queryParams: any[] = [resourceId];
-
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC`;
-      const rows = await this.db.manyOrNone(dataQuery, queryParams);
-      return (rows || []).map(thread => ({
-        ...thread,
-        metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt,
-      }));
-    } catch (error) {
-      this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
-      return [];
-    }
+    return this.stores.memory.getThreadsByResourceId(args);
   }
 
-  public async getThreadsByResourceIdPaginated(
-    args: {
-      resourceId: string;
-    } & PaginationArgs,
-  ): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
-    const { resourceId, page = 0, perPage: perPageInput } = args;
-    try {
-      const baseQuery = `FROM ${this.getTableName(TABLE_THREADS)} WHERE "resourceId" = $1`;
-      const queryParams: any[] = [resourceId];
-      const perPage = perPageInput !== undefined ? perPageInput : 100;
-      const currentOffset = page * perPage;
-
-      const countQuery = `SELECT COUNT(*) ${baseQuery}`;
-      const countResult = await this.db.one(countQuery, queryParams);
-      const total = parseInt(countResult.count, 10);
-
-      if (total === 0) {
-        return {
-          threads: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false,
-        };
-      }
-
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC LIMIT $2 OFFSET $3`;
-      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
-
-      const threads = (rows || []).map(thread => ({
-        ...thread,
-        metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt, // Assuming already Date objects or ISO strings
-        updatedAt: thread.updatedAt,
-      }));
-
-      return {
-        threads,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + threads.length < total,
-      };
-    } catch (error) {
-      const mastraError = new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            resourceId,
-            page,
-          },
-        },
-        error,
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
-    }
+  public async getThreadsByResourceIdPaginated(args: {
+    resourceId: string;
+    page: number;
+    perPage: number;
+  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
   }
 
   async saveThread({ thread }: { thread: StorageThreadType }): Promise<StorageThreadType> {
-    try {
-      await this.db.none(
-        `INSERT INTO ${this.getTableName(TABLE_THREADS)} (
-          id,
-          "resourceId",
-          title,
-          metadata,
-          "createdAt",
-          "updatedAt"
-        ) VALUES ($1, $2, $3, $4, $5, $6)
-        ON CONFLICT (id) DO UPDATE SET
-          "resourceId" = EXCLUDED."resourceId",
-          title = EXCLUDED.title,
-          metadata = EXCLUDED.metadata,
-          "createdAt" = EXCLUDED."createdAt",
-          "updatedAt" = EXCLUDED."updatedAt"`,
-        [
-          thread.id,
-          thread.resourceId,
-          thread.title,
-          thread.metadata ? JSON.stringify(thread.metadata) : null,
-          thread.createdAt,
-          thread.updatedAt,
-        ],
-      );
-
-      return thread;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_SAVE_THREAD_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId: thread.id,
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.memory.saveThread({ thread });
   }
 
   async updateThread({
@@ -780,150 +237,11 @@ export class PostgresStore extends MastraStorage {
     title: string;
     metadata: Record<string, unknown>;
   }): Promise<StorageThreadType> {
-    // First get the existing thread to merge metadata
-    const existingThread = await this.getThreadById({ threadId: id });
-    if (!existingThread) {
-      throw new MastraError({
-        id: 'MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED',
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        text: `Thread ${id} not found`,
-        details: {
-          threadId: id,
-          title,
-        },
-      });
-    }
-
-    // Merge the existing metadata with the new metadata
-    const mergedMetadata = {
-      ...existingThread.metadata,
-      ...metadata,
-    };
-
-    try {
-      const thread = await this.db.one<StorageThreadType>(
-        `UPDATE ${this.getTableName(TABLE_THREADS)}
-        SET title = $1,
-        metadata = $2,
-        "updatedAt" = $3
-        WHERE id = $4
-        RETURNING *`,
-        [title, mergedMetadata, new Date().toISOString(), id],
-      );
-
-      return {
-        ...thread,
-        metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt,
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId: id,
-            title,
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.memory.updateThread({ id, title, metadata });
   }
 
   async deleteThread({ threadId }: { threadId: string }): Promise<void> {
-    try {
-      await this.db.tx(async t => {
-        // First delete all messages associated with this thread
-        await t.none(`DELETE FROM ${this.getTableName(TABLE_MESSAGES)} WHERE thread_id = $1`, [threadId]);
-
-        // Then delete the thread
-        await t.none(`DELETE FROM ${this.getTableName(TABLE_THREADS)} WHERE id = $1`, [threadId]);
-      });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_DELETE_THREAD_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-          },
-        },
-        error,
-      );
-    }
-  }
-
-  private async _getIncludedMessages({
-    threadId,
-    selectBy,
-    orderByStatement,
-  }: {
-    threadId: string;
-    selectBy: StorageGetMessagesArg['selectBy'];
-    orderByStatement: string;
-  }) {
-    const include = selectBy?.include;
-    if (!include) return null;
-
-    const unionQueries: string[] = [];
-    const params: any[] = [];
-    let paramIdx = 1;
-
-    for (const inc of include) {
-      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      // if threadId is provided, use it, otherwise use threadId from args
-      const searchId = inc.threadId || threadId;
-      unionQueries.push(
-        `
-            SELECT * FROM (
-              WITH ordered_messages AS (
-                SELECT 
-                  *,
-                  ROW_NUMBER() OVER (${orderByStatement}) as row_num
-                FROM ${this.getTableName(TABLE_MESSAGES)}
-                WHERE thread_id = $${paramIdx}
-              )
-              SELECT
-                m.id, 
-                m.content, 
-                m.role, 
-                m.type,
-                m."createdAt", 
-                m.thread_id AS "threadId",
-                m."resourceId"
-              FROM ordered_messages m
-              WHERE m.id = $${paramIdx + 1}
-              OR EXISTS (
-                SELECT 1 FROM ordered_messages target
-                WHERE target.id = $${paramIdx + 1}
-                AND (
-                  -- Get previous messages based on the max withPreviousMessages
-                  (m.row_num <= target.row_num + $${paramIdx + 2} AND m.row_num > target.row_num)
-                  OR
-                  -- Get next messages based on the max withNextMessages
-                  (m.row_num >= target.row_num - $${paramIdx + 3} AND m.row_num < target.row_num)
-                )
-              )
-            ) AS query_${paramIdx}
-            `, // Keep ASC for final sorting after fetching context
-      );
-      params.push(searchId, id, withPreviousMessages, withNextMessages);
-      paramIdx += 4;
-    }
-    const finalQuery = unionQueries.join(' UNION ALL ') + ' ORDER BY "createdAt" ASC';
-    const includedRows = await this.db.manyOrNone(finalQuery, params);
-    const seen = new Set<string>();
-    const dedupedRows = includedRows.filter(row => {
-      if (seen.has(row.id)) return false;
-      seen.add(row.id);
-      return true;
-    });
-    return dedupedRows;
+    return this.stores.memory.deleteThread({ threadId });
   }
 
   /**
@@ -936,73 +254,7 @@ export class PostgresStore extends MastraStorage {
       format?: 'v1' | 'v2';
     },
   ): Promise<MastraMessageV1[] | MastraMessageV2[]> {
-    const { threadId, format, selectBy } = args;
-
-    const selectStatement = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId"`;
-    const orderByStatement = `ORDER BY "createdAt" DESC`;
-    const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-
-    try {
-      let rows: any[] = [];
-      const include = selectBy?.include || [];
-
-      if (include?.length) {
-        const includeMessages = await this._getIncludedMessages({ threadId, selectBy, orderByStatement });
-        if (includeMessages) {
-          rows.push(...includeMessages);
-        }
-      }
-
-      const excludeIds = rows.map(m => m.id);
-      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + 2}`).join(', ');
-      let query = `${selectStatement} FROM ${this.getTableName(TABLE_MESSAGES)} WHERE thread_id = $1 
-        ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ''}
-        ${orderByStatement}
-        LIMIT $${excludeIds.length + 2}
-        `;
-      const queryParams: any[] = [threadId, ...excludeIds, limit];
-      const remainingRows = await this.db.manyOrNone(query, queryParams);
-      rows.push(...remainingRows);
-
-      const fetchedMessages = (rows || []).map(message => {
-        if (typeof message.content === 'string') {
-          try {
-            message.content = JSON.parse(message.content);
-          } catch {
-            /* ignore */
-          }
-        }
-        if (message.type === 'v2') delete message.type;
-        return message as MastraMessageV1;
-      });
-
-      // Sort all messages by creation date
-      const sortedMessages = fetchedMessages.sort(
-        (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime(),
-      );
-
-      return format === 'v2'
-        ? sortedMessages.map(
-            m =>
-              ({ ...m, content: m.content || { format: 2, parts: [{ type: 'text', text: '' }] } }) as MastraMessageV2,
-          )
-        : sortedMessages;
-    } catch (error) {
-      const mastraError = new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_MESSAGES_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-          },
-        },
-        error,
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return [];
-    }
+    return this.stores.memory.getMessages(args);
   }
 
   public async getMessagesPaginated(
@@ -1010,220 +262,54 @@ export class PostgresStore extends MastraStorage {
       format?: 'v1' | 'v2';
     },
   ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
-    const { threadId, format, selectBy } = args;
-    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-
-    const selectStatement = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId"`;
-    const orderByStatement = `ORDER BY "createdAt" DESC`;
-
-    const messages: MastraMessageV2[] = [];
-
-    if (selectBy?.include?.length) {
-      const includeMessages = await this._getIncludedMessages({ threadId, selectBy, orderByStatement });
-      if (includeMessages) {
-        messages.push(...includeMessages);
-      }
-    }
-
-    try {
-      const perPage =
-        perPageInput !== undefined
-          ? perPageInput
-          : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-      const currentOffset = page * perPage;
-
-      const conditions: string[] = [`thread_id = $1`];
-      const queryParams: any[] = [threadId];
-      let paramIndex = 2;
-
-      if (fromDate) {
-        conditions.push(`"createdAt" >= $${paramIndex++}`);
-        queryParams.push(fromDate);
-      }
-      if (toDate) {
-        conditions.push(`"createdAt" <= $${paramIndex++}`);
-        queryParams.push(toDate);
-      }
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-
-      const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(TABLE_MESSAGES)} ${whereClause}`;
-      const countResult = await this.db.one(countQuery, queryParams);
-      const total = parseInt(countResult.count, 10);
-
-      if (total === 0 && messages.length === 0) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false,
-        };
-      }
-
-      const excludeIds = messages.map(m => m.id);
-      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + paramIndex}`).join(', ');
-      paramIndex += excludeIds.length;
-
-      const dataQuery = `${selectStatement} FROM ${this.getTableName(
-        TABLE_MESSAGES,
-      )} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ''}${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, ...excludeIds, perPage, currentOffset]);
-      messages.push(...(rows || []));
-
-      // Parse content back to objects if they were stringified during storage
-      const messagesWithParsedContent = messages.map(message => {
-        if (typeof message.content === 'string') {
-          try {
-            return { ...message, content: JSON.parse(message.content) };
-          } catch {
-            // If parsing fails, leave as string (V1 message)
-            return message;
-          }
-        }
-        return message;
-      });
-
-      const list = new MessageList().add(messagesWithParsedContent, 'memory');
-      const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
-
-      return {
-        messages: messagesToReturn,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + rows.length < total,
-      };
-    } catch (error) {
-      const mastraError = new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_MESSAGES_PAGINATED_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-            page,
-          },
-        },
-        error,
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
-    }
+    return this.stores.memory.getMessagesPaginated(args);
   }
 
   async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
   async saveMessages(args: { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[]>;
-  async saveMessages({
-    messages,
-    format,
-  }:
-    | { messages: MastraMessageV1[]; format?: undefined | 'v1' }
-    | { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[] | MastraMessageV1[]> {
-    if (messages.length === 0) return messages;
-
-    const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      throw new MastraError({
-        id: 'MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED',
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.THIRD_PARTY,
-        text: `Thread ID is required`,
-      });
-    }
-
-    // Check if thread exists
-    const thread = await this.getThreadById({ threadId });
-    if (!thread) {
-      throw new MastraError({
-        id: 'MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED',
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.THIRD_PARTY,
-        text: `Thread ${threadId} not found`,
-        details: {
-          threadId,
-        },
-      });
-    }
-
-    try {
-      await this.db.tx(async t => {
-        // Execute message inserts and thread update in parallel for better performance
-        const messageInserts = messages.map(message => {
-          if (!message.threadId) {
-            throw new Error(
-              `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`,
-            );
-          }
-          if (!message.resourceId) {
-            throw new Error(
-              `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`,
-            );
-          }
-          return t.none(
-            `INSERT INTO ${this.getTableName(TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type, "resourceId") 
-             VALUES ($1, $2, $3, $4, $5, $6, $7)
-             ON CONFLICT (id) DO UPDATE SET
-              thread_id = EXCLUDED.thread_id,
-              content = EXCLUDED.content,
-              role = EXCLUDED.role,
-              type = EXCLUDED.type,
-              "resourceId" = EXCLUDED."resourceId"`,
-            [
-              message.id,
-              message.threadId,
-              typeof message.content === 'string' ? message.content : JSON.stringify(message.content),
-              message.createdAt || new Date().toISOString(),
-              message.role,
-              message.type || 'v2',
-              message.resourceId,
-            ],
-          );
-        });
+  async saveMessages(
+    args: { messages: MastraMessageV1[]; format?: undefined | 'v1' } | { messages: MastraMessageV2[]; format: 'v2' },
+  ): Promise<MastraMessageV2[] | MastraMessageV1[]> {
+    return this.stores.memory.saveMessages(args);
+  }
 
-        const threadUpdate = t.none(
-          `UPDATE ${this.getTableName(TABLE_THREADS)} 
-           SET "updatedAt" = $1 
-           WHERE id = $2`,
-          [new Date().toISOString(), threadId],
-        );
+  async updateMessages({
+    messages,
+  }: {
+    messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+      id: string;
+      content?: {
+        metadata?: MastraMessageContentV2['metadata'];
+        content?: MastraMessageContentV2['content'];
+      };
+    })[];
+  }): Promise<MastraMessageV2[]> {
+    return this.stores.memory.updateMessages({ messages });
+  }
 
-        await Promise.all([...messageInserts, threadUpdate]);
-      });
+  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
 
-      // Parse content back to objects if they were stringified during storage
-      const messagesWithParsedContent = messages.map(message => {
-        if (typeof message.content === 'string') {
-          try {
-            return { ...message, content: JSON.parse(message.content) };
-          } catch {
-            // If parsing fails, leave as string (V1 message)
-            return message;
-          }
-        }
-        return message;
-      });
+  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
+    return this.stores.memory.saveResource({ resource });
+  }
 
-      const list = new MessageList().add(messagesWithParsedContent, 'memory');
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-          },
-        },
-        error,
-      );
-    }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata,
+  }: {
+    resourceId: string;
+    workingMemory?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<StorageResourceType> {
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
   }
 
+  /**
+   * Workflows
+   */
   async persistWorkflowSnapshot({
     workflowName,
     runId,
@@ -1233,35 +319,7 @@ export class PostgresStore extends MastraStorage {
     runId: string;
     snapshot: WorkflowRunState;
   }): Promise<void> {
-    try {
-      const now = new Date().toISOString();
-      await this.db.none(
-        `INSERT INTO ${this.getTableName(TABLE_WORKFLOW_SNAPSHOT)} (
-          workflow_name,
-          run_id,
-          snapshot,
-          "createdAt",
-          "updatedAt"
-        ) VALUES ($1, $2, $3, $4, $5)
-        ON CONFLICT (workflow_name, run_id) DO UPDATE
-        SET snapshot = EXCLUDED.snapshot,
-            "updatedAt" = EXCLUDED."updatedAt"`,
-        [workflowName, runId, JSON.stringify(snapshot), now, now],
-      );
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName,
-            runId,
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
   }
 
   async loadWorkflowSnapshot({
@@ -1271,65 +329,7 @@ export class PostgresStore extends MastraStorage {
     workflowName: string;
     runId: string;
   }): Promise<WorkflowRunState | null> {
-    try {
-      const result = await this.load({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId,
-        },
-      });
-
-      if (!result) {
-        return null;
-      }
-
-      return (result as any).snapshot;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName,
-            runId,
-          },
-        },
-        error,
-      );
-    }
-  }
-
-  private async hasColumn(table: string, column: string): Promise<boolean> {
-    // Use this.schema to scope the check
-    const schema = this.schema || 'public';
-    const result = await this.db.oneOrNone(
-      `SELECT 1 FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 AND (column_name = $3 OR column_name = $4)`,
-      [schema, table, column, column.toLowerCase()],
-    );
-    return !!result;
-  }
-
-  private parseWorkflowRun(row: any): WorkflowRun {
-    let parsedSnapshot: WorkflowRunState | string = row.snapshot as string;
-    if (typeof parsedSnapshot === 'string') {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot as string) as WorkflowRunState;
-      } catch (e) {
-        // If parsing fails, return the raw snapshot string
-        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,
-      resourceId: row.resourceId,
-    };
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
   }
 
   async getWorkflowRuns({
@@ -1347,82 +347,7 @@ export class PostgresStore extends MastraStorage {
     offset?: number;
     resourceId?: string;
   } = {}): Promise<WorkflowRuns> {
-    try {
-      const conditions: string[] = [];
-      const values: any[] = [];
-      let paramIndex = 1;
-
-      if (workflowName) {
-        conditions.push(`workflow_name = $${paramIndex}`);
-        values.push(workflowName);
-        paramIndex++;
-      }
-
-      if (resourceId) {
-        const hasResourceId = await this.hasColumn(TABLE_WORKFLOW_SNAPSHOT, 'resourceId');
-        if (hasResourceId) {
-          conditions.push(`"resourceId" = $${paramIndex}`);
-          values.push(resourceId);
-          paramIndex++;
-        } else {
-          console.warn(`[${TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
-        }
-      }
-
-      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;
-      // Only get total count when using pagination
-      if (limit !== undefined && offset !== undefined) {
-        const countResult = await this.db.one(
-          `SELECT COUNT(*) as count FROM ${this.getTableName(TABLE_WORKFLOW_SNAPSHOT)} ${whereClause}`,
-          values,
-        );
-        total = Number(countResult.count);
-      }
-
-      // Get results
-      const query = `
-      SELECT * FROM ${this.getTableName(TABLE_WORKFLOW_SNAPSHOT)} 
-      ${whereClause} 
-      ORDER BY "createdAt" DESC
-      ${limit !== undefined && offset !== undefined ? ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ''}
-    `;
-
-      const queryValues = limit !== undefined && offset !== undefined ? [...values, limit, offset] : values;
-
-      const result = await this.db.manyOrNone(query, queryValues);
-
-      const runs = (result || []).map(row => {
-        return this.parseWorkflowRun(row);
-      });
-
-      // Use runs.length as total when not paginating
-      return { runs, total: total || runs.length };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUNS_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName: workflowName || 'all',
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
   }
 
   async getWorkflowRunById({
@@ -1432,370 +357,57 @@ export class PostgresStore extends MastraStorage {
     runId: string;
     workflowName?: string;
   }): Promise<WorkflowRun | null> {
-    try {
-      const conditions: string[] = [];
-      const values: any[] = [];
-      let paramIndex = 1;
-
-      if (runId) {
-        conditions.push(`run_id = $${paramIndex}`);
-        values.push(runId);
-        paramIndex++;
-      }
-
-      if (workflowName) {
-        conditions.push(`workflow_name = $${paramIndex}`);
-        values.push(workflowName);
-        paramIndex++;
-      }
-
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-
-      // Get results
-      const query = `
-      SELECT * FROM ${this.getTableName(TABLE_WORKFLOW_SNAPSHOT)} 
-      ${whereClause} 
-    `;
-
-      const queryValues = values;
-
-      const result = await this.db.oneOrNone(query, queryValues);
-
-      if (!result) {
-        return null;
-      }
-
-      return this.parseWorkflowRun(result);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            runId,
-            workflowName: workflowName || '',
-          },
-        },
-        error,
-      );
-    }
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
   }
 
   async close(): Promise<void> {
     this.pgp.end();
   }
 
-  async getEvals(
-    options: {
-      agentName?: string;
-      type?: 'test' | 'live';
-    } & PaginationArgs = {},
-  ): Promise<PaginationInfo & { evals: EvalRow[] }> {
-    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-
-    const conditions: string[] = [];
-    const queryParams: any[] = [];
-    let paramIndex = 1;
-
-    if (agentName) {
-      conditions.push(`agent_name = $${paramIndex++}`);
-      queryParams.push(agentName);
-    }
-
-    if (type === 'test') {
-      conditions.push(`(test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL)`);
-    } else if (type === 'live') {
-      conditions.push(`(test_info IS NULL OR test_info->>'testPath' IS NULL)`);
-    }
-
-    if (fromDate) {
-      conditions.push(`created_at >= $${paramIndex++}`);
-      queryParams.push(fromDate);
-    }
-
-    if (toDate) {
-      conditions.push(`created_at <= $${paramIndex++}`);
-      queryParams.push(toDate);
-    }
-
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-
-    const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(TABLE_EVALS)} ${whereClause}`;
-    try {
-      const countResult = await this.db.one(countQuery, queryParams);
-      const total = parseInt(countResult.count, 10);
-      const currentOffset = page * perPage;
-
-      if (total === 0) {
-        return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false,
-        };
-      }
-
-      const dataQuery = `SELECT * FROM ${this.getTableName(
-        TABLE_EVALS,
-      )} ${whereClause} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
-
-      return {
-        evals: rows?.map(row => this.transformEvalRow(row)) ?? [],
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + (rows?.length ?? 0) < total,
-      };
-    } catch (error) {
-      const mastraError = new MastraError(
-        {
-          id: 'MASTRA_STORAGE_PG_STORE_GET_EVALS_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            agentName: agentName || 'all',
-            type: type || 'all',
-            page,
-            perPage,
-          },
-        },
-        error,
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      throw mastraError;
-    }
+  /**
+   * Scorers
+   */
+  async getScoreById({ id: _id }: { id: string }): Promise<ScoreRowData | null> {
+    return this.stores.scores.getScoreById({ id: _id });
   }
 
-  async updateMessages({
-    messages,
+  async getScoresByScorerId({
+    scorerId: _scorerId,
+    pagination: _pagination,
   }: {
-    messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
-      id: string;
-      content?: {
-        metadata?: MastraMessageContentV2['metadata'];
-        content?: MastraMessageContentV2['content'];
-      };
-    })[];
-  }): Promise<MastraMessageV2[]> {
-    if (messages.length === 0) {
-      return [];
-    }
-
-    const messageIds = messages.map(m => m.id);
-
-    const selectQuery = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${this.getTableName(
-      TABLE_MESSAGES,
-    )} WHERE id IN ($1:list)`;
-
-    const existingMessagesDb = await this.db.manyOrNone(selectQuery, [messageIds]);
-
-    if (existingMessagesDb.length === 0) {
-      return [];
-    }
-
-    // Parse content from string to object for merging
-    const existingMessages: MastraMessageV2[] = existingMessagesDb.map(msg => {
-      if (typeof msg.content === 'string') {
-        try {
-          msg.content = JSON.parse(msg.content);
-        } catch {
-          // ignore if not valid json
-        }
-      }
-      return msg as MastraMessageV2;
-    });
-
-    const threadIdsToUpdate = new Set<string>();
-
-    await this.db.tx(async t => {
-      const queries = [];
-      const columnMapping: Record<string, string> = {
-        threadId: 'thread_id',
-      };
-
-      for (const existingMessage of existingMessages) {
-        const updatePayload = messages.find(m => m.id === existingMessage.id);
-        if (!updatePayload) continue;
-
-        const { id, ...fieldsToUpdate } = updatePayload;
-        if (Object.keys(fieldsToUpdate).length === 0) continue;
-
-        threadIdsToUpdate.add(existingMessage.threadId!);
-        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
-          threadIdsToUpdate.add(updatePayload.threadId);
-        }
-
-        const setClauses: string[] = [];
-        const values: any[] = [];
-        let paramIndex = 1;
-
-        const updatableFields = { ...fieldsToUpdate };
-
-        // Special handling for content: merge in code, then update the whole field
-        if (updatableFields.content) {
-          const newContent = {
-            ...existingMessage.content,
-            ...updatableFields.content,
-            // Deep merge metadata if it exists on both
-            ...(existingMessage.content?.metadata && updatableFields.content.metadata
-              ? {
-                  metadata: {
-                    ...existingMessage.content.metadata,
-                    ...updatableFields.content.metadata,
-                  },
-                }
-              : {}),
-          };
-          setClauses.push(`content = $${paramIndex++}`);
-          values.push(newContent);
-          delete updatableFields.content;
-        }
-
-        for (const key in updatableFields) {
-          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
-            const dbColumn = columnMapping[key] || key;
-            setClauses.push(`"${dbColumn}" = $${paramIndex++}`);
-            values.push(updatableFields[key as keyof typeof updatableFields]);
-          }
-        }
-
-        if (setClauses.length > 0) {
-          values.push(id);
-          const sql = `UPDATE ${this.getTableName(
-            TABLE_MESSAGES,
-          )} SET ${setClauses.join(', ')} WHERE id = $${paramIndex}`;
-          queries.push(t.none(sql, values));
-        }
-      }
-
-      if (threadIdsToUpdate.size > 0) {
-        queries.push(
-          t.none(`UPDATE ${this.getTableName(TABLE_THREADS)} SET "updatedAt" = NOW() WHERE id IN ($1:list)`, [
-            Array.from(threadIdsToUpdate),
-          ]),
-        );
-      }
-
-      if (queries.length > 0) {
-        await t.batch(queries);
-      }
-    });
-
-    // Re-fetch to return the fully updated messages
-    const updatedMessages = await this.db.manyOrNone<MastraMessageV2>(selectQuery, [messageIds]);
-
-    return (updatedMessages || []).map(message => {
-      if (typeof message.content === 'string') {
-        try {
-          message.content = JSON.parse(message.content);
-        } catch {
-          /* ignore */
-        }
-      }
-      return message;
-    });
+    scorerId: string;
+    pagination: StoragePagination;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination });
   }
 
-  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
-    const tableName = this.getTableName(TABLE_RESOURCES);
-    const result = await this.db.oneOrNone<StorageResourceType>(`SELECT * FROM ${tableName} WHERE id = $1`, [
-      resourceId,
-    ]);
-
-    if (!result) {
-      return null;
-    }
-
-    return {
-      ...result,
-      // Ensure workingMemory is always returned as a string, regardless of automatic parsing
-      workingMemory:
-        typeof result.workingMemory === 'object' ? JSON.stringify(result.workingMemory) : result.workingMemory,
-      metadata: typeof result.metadata === 'string' ? JSON.parse(result.metadata) : result.metadata,
-    };
+  async saveScore(_score: ScoreRowData): Promise<{ score: ScoreRowData }> {
+    return this.stores.scores.saveScore(_score);
   }
 
-  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
-    const tableName = this.getTableName(TABLE_RESOURCES);
-    await this.db.none(
-      `INSERT INTO ${tableName} (id, "workingMemory", metadata, "createdAt", "updatedAt") 
-       VALUES ($1, $2, $3, $4, $5)`,
-      [
-        resource.id,
-        resource.workingMemory,
-        JSON.stringify(resource.metadata),
-        resource.createdAt.toISOString(),
-        resource.updatedAt.toISOString(),
-      ],
-    );
-
-    return resource;
+  async getScoresByRunId({
+    runId: _runId,
+    pagination: _pagination,
+  }: {
+    runId: string;
+    pagination: StoragePagination;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByRunId({ runId: _runId, pagination: _pagination });
   }
 
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata,
+  async getScoresByEntityId({
+    entityId: _entityId,
+    entityType: _entityType,
+    pagination: _pagination,
   }: {
-    resourceId: string;
-    workingMemory?: string;
-    metadata?: Record<string, unknown>;
-  }): Promise<StorageResourceType> {
-    const existingResource = await this.getResourceById({ resourceId });
-
-    if (!existingResource) {
-      // Create new resource if it doesn't exist
-      const newResource: StorageResourceType = {
-        id: resourceId,
-        workingMemory,
-        metadata: metadata || {},
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-      return this.saveResource({ resource: newResource });
-    }
-
-    const updatedResource = {
-      ...existingResource,
-      workingMemory: workingMemory !== undefined ? workingMemory : existingResource.workingMemory,
-      metadata: {
-        ...existingResource.metadata,
-        ...metadata,
-      },
-      updatedAt: new Date(),
-    };
-
-    const tableName = this.getTableName(TABLE_RESOURCES);
-    const updates: string[] = [];
-    const values: any[] = [];
-    let paramIndex = 1;
-
-    if (workingMemory !== undefined) {
-      updates.push(`"workingMemory" = $${paramIndex}`);
-      values.push(workingMemory);
-      paramIndex++;
-    }
-
-    if (metadata) {
-      updates.push(`metadata = $${paramIndex}`);
-      values.push(JSON.stringify(updatedResource.metadata));
-      paramIndex++;
-    }
-
-    updates.push(`"updatedAt" = $${paramIndex}`);
-    values.push(updatedResource.updatedAt.toISOString());
-    paramIndex++;
-
-    values.push(resourceId);
-
-    await this.db.none(`UPDATE ${tableName} SET ${updates.join(', ')} WHERE id = $${paramIndex}`, values);
-
-    return updatedResource;
+    pagination: StoragePagination;
+    entityId: string;
+    entityType: string;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByEntityId({
+      entityId: _entityId,
+      entityType: _entityType,
+      pagination: _pagination,
+    });
   }
 }