@mastra/pg 0.12.3 → 0.12.4-alpha.0

package/dist/index.cjs

@@ -7,9 +7,9 @@ var asyncMutex = require('async-mutex');
 var pg = require('pg');
 var xxhash = require('xxhash-wasm');
 var filter = require('@mastra/core/vector/filter');
-var agent = require('@mastra/core/agent');
 var storage = require('@mastra/core/storage');
 var pgPromise = require('pg-promise');
+var agent = require('@mastra/core/agent');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -490,6 +490,7 @@ var PgVector = class extends vector.MastraVector {
     }
     const client = await this.pool.connect();
     try {
+      await client.query("BEGIN");
       const vectorStr = `[${queryVector.join(",")}]`;
       const translatedFilter = this.transformFilter(filter);
       const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter, minScore, topK);
@@ -519,6 +520,7 @@ var PgVector = class extends vector.MastraVector {
         ORDER BY score DESC
         LIMIT $2`;
       const result = await client.query(query, filterValues);
+      await client.query("COMMIT");
       return result.rows.map(({ id, score, metadata, embedding }) => ({
         id,
         score,
@@ -526,6 +528,7 @@ var PgVector = class extends vector.MastraVector {
         ...includeVector && embedding && { vector: JSON.parse(embedding) }
       }));
     } catch (error$1) {
+      await client.query("ROLLBACK");
       const mastraError = new error.MastraError(
         {
           id: "MASTRA_STORAGE_PG_VECTOR_QUERY_FAILED",
@@ -1104,77 +1107,55 @@ var PgVector = class extends vector.MastraVector {
     }
   }
 };
-var PostgresStore = class extends storage.MastraStorage {
-  db;
-  pgp;
-  schema;
-  setupSchemaPromise = null;
-  schemaSetupComplete = void 0;
-  constructor(config) {
+function getSchemaName(schema) {
+  return schema ? `"${utils.parseSqlIdentifier(schema, "schema name")}"` : void 0;
+}
+function getTableName({ indexName, schemaName }) {
+  const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+  const quotedIndexName = `"${parsedIndexName}"`;
+  const quotedSchemaName = schemaName;
+  return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
+}
+
+// src/storage/domains/legacy-evals/index.ts
+function transformEvalRow(row) {
+  let testInfoValue = null;
+  if (row.test_info) {
     try {
-      if ("connectionString" in config) {
-        if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
-          throw new Error(
-            "PostgresStore: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults."
-          );
-        }
-      } else {
-        const required = ["host", "database", "user", "password"];
-        for (const key of required) {
-          if (!(key in config) || typeof config[key] !== "string" || config[key].trim() === "") {
-            throw new Error(
-              `PostgresStore: ${key} must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults.`
-            );
-          }
-        }
-      }
-      super({ name: "PostgresStore" });
-      this.pgp = pgPromise__default.default();
-      this.schema = config.schemaName;
-      this.db = this.pgp(
-        `connectionString` in config ? { connectionString: config.connectionString } : {
-          host: config.host,
-          port: config.port,
-          database: config.database,
-          user: config.user,
-          password: config.password,
-          ssl: config.ssl
-        }
-      );
+      testInfoValue = typeof row.test_info === "string" ? JSON.parse(row.test_info) : row.test_info;
     } catch (e) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_PG_STORE_INITIALIZATION_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
-        },
-        e
-      );
+      console.warn("Failed to parse test_info:", e);
     }
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true
-    };
-  }
-  getTableName(indexName) {
-    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
-    const quotedIndexName = `"${parsedIndexName}"`;
-    const quotedSchemaName = this.getSchemaName();
-    return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
-  }
-  getSchemaName() {
-    return this.schema ? `"${utils.parseSqlIdentifier(this.schema, "schema name")}"` : void 0;
+  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_atZ || row.created_at
+  };
+}
+var LegacyEvalsPG = class extends storage.LegacyEvalsStorage {
+  client;
+  schema;
+  constructor({ client, schema }) {
+    super();
+    this.client = client;
+    this.schema = schema;
   }
   /** @deprecated use getEvals instead */
   async getEvalsByAgentName(agentName, type) {
     try {
-      const baseQuery = `SELECT * FROM ${this.getTableName(storage.TABLE_EVALS)} WHERE agent_name = $1`;
+      const baseQuery = `SELECT * FROM ${getTableName({ indexName: storage.TABLE_EVALS, schemaName: getSchemaName(this.schema) })} 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)) ?? [];
+      const rows = await this.client.manyOrNone(query, [agentName]);
+      return rows?.map((row) => transformEvalRow(row)) ?? [];
     } catch (error) {
       if (error instanceof Error && error.message.includes("relation") && error.message.includes("does not exist")) {
         return [];
@@ -1183,486 +1164,522 @@ var PostgresStore = class extends storage.MastraStorage {
       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);
-      }
+  async getEvals(options = {}) {
+    const tableName = getTableName({ indexName: storage.TABLE_EVALS, schemaName: getSchemaName(this.schema) });
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const conditions = [];
+    const queryParams = [];
+    let paramIndex = 1;
+    if (agentName) {
+      conditions.push(`agent_name = $${paramIndex++}`);
+      queryParams.push(agentName);
     }
-    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 }) {
+    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 ${tableName} ${whereClause}`;
     try {
-      await this.db.query("BEGIN");
-      for (const record of records) {
-        await this.insert({ tableName, record });
+      const countResult = await this.client.one(countQuery, queryParams);
+      const total = parseInt(countResult.count, 10);
+      const currentOffset = page * perPage;
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
       }
-      await this.db.query("COMMIT");
+      const dataQuery = `SELECT * FROM ${tableName} ${whereClause} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.client.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
+      return {
+        evals: rows?.map((row) => transformEvalRow(row)) ?? [],
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + (rows?.length ?? 0) < total
+      };
     } catch (error$1) {
-      await this.db.query("ROLLBACK");
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_BATCH_INSERT_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_GET_EVALS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName,
-            numberOfRecords: records.length
+            agentName: agentName || "all",
+            type: type || "all",
+            page,
+            perPage
           }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
   }
-  /**
-   * @deprecated use getTracesPaginated instead
-   */
-  async getTraces(args) {
-    if (args.fromDate || args.toDate) {
-      args.dateRange = {
-        start: args.fromDate,
-        end: args.toDate
-      };
-    }
-    const result = await this.getTracesPaginated(args);
-    return result.traces;
+};
+var MemoryPG = class extends storage.MemoryStorage {
+  client;
+  schema;
+  operations;
+  constructor({
+    client,
+    schema,
+    operations
+  }) {
+    super();
+    this.client = client;
+    this.schema = schema;
+    this.operations = operations;
   }
-  async getTracesPaginated(args) {
-    const { name, scope, page = 0, perPage: perPageInput, attributes, filters, dateRange } = args;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const perPage = perPageInput !== void 0 ? perPageInput : 100;
-    const currentOffset = page * perPage;
-    const queryParams = [];
-    const conditions = [];
-    let paramIndex = 1;
-    if (name) {
-      conditions.push(`name LIKE $${paramIndex++}`);
-      queryParams.push(`${name}%`);
-    }
-    if (scope) {
-      conditions.push(`scope = $${paramIndex++}`);
-      queryParams.push(scope);
-    }
-    if (attributes) {
-      Object.entries(attributes).forEach(([key, value]) => {
-        const parsedKey = utils.parseFieldKey(key);
-        conditions.push(`attributes->>'${parsedKey}' = $${paramIndex++}`);
-        queryParams.push(value);
-      });
-    }
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        const parsedKey = utils.parseFieldKey(key);
-        conditions.push(`"${parsedKey}" = $${paramIndex++}`);
-        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 ")}` : "";
-    const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(storage.TABLE_TRACES)} ${whereClause}`;
-    let total = 0;
+  async getThreadById({ threadId }) {
     try {
-      const countResult = await this.db.one(countQuery, queryParams);
-      total = parseInt(countResult.count, 10);
+      const tableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+      const thread = await this.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE id = $1`,
+        [threadId]
+      );
+      if (!thread) {
+        return null;
+      }
+      return {
+        id: thread.id,
+        resourceId: thread.resourceId,
+        title: thread.title,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAtZ || thread.createdAt,
+        updatedAt: thread.updatedAtZ || thread.updatedAt
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TOTAL_COUNT",
+          id: "MASTRA_STORAGE_PG_STORE_GET_THREAD_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            name: args.name ?? "",
-            scope: args.scope ?? ""
+            threadId
           }
         },
         error$1
       );
     }
-    if (total === 0) {
-      return {
-        traces: [],
-        total: 0,
-        page,
-        perPage,
-        hasMore: false
-      };
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  async getThreadsByResourceId(args) {
+    const { resourceId } = args;
+    try {
+      const tableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+      const baseQuery = `FROM ${tableName} WHERE "resourceId" = $1`;
+      const queryParams = [resourceId];
+      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC`;
+      const rows = await this.client.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 [];
     }
-    const dataQuery = `SELECT * FROM ${this.getTableName(
-      storage.TABLE_TRACES
-    )} ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-    const finalQueryParams = [...queryParams, perPage, currentOffset];
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page = 0, perPage: perPageInput } = args;
     try {
-      const rows = await this.db.manyOrNone(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
+      const tableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+      const baseQuery = `FROM ${tableName} WHERE "resourceId" = $1`;
+      const queryParams = [resourceId];
+      const perPage = perPageInput !== void 0 ? perPageInput : 100;
+      const currentOffset = page * perPage;
+      const countQuery = `SELECT COUNT(*) ${baseQuery}`;
+      const countResult = await this.client.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.client.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 {
-        traces,
+        threads,
         total,
         page,
         perPage,
-        hasMore: currentOffset + traces.length < total
+        hasMore: currentOffset + threads.length < total
       };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TRACES",
+          id: "MASTRA_STORAGE_PG_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            name: args.name ?? "",
-            scope: args.scope ?? ""
+            resourceId,
+            page
           }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
     }
   }
-  async setupSchema() {
-    if (!this.schema || this.schemaSetupComplete) {
-      return;
-    }
-    if (!this.setupSchemaPromise) {
-      this.setupSchemaPromise = (async () => {
-        try {
-          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.`
-              );
-            }
-          }
-          this.schemaSetupComplete = true;
-          this.logger.debug(`Schema "${this.schema}" is ready for use`);
-        } catch (error) {
-          this.schemaSetupComplete = void 0;
-          this.setupSchemaPromise = null;
-          throw error;
-        } finally {
-          this.setupSchemaPromise = null;
-        }
-      })();
-    }
-    await this.setupSchemaPromise;
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
+  async saveThread({ thread }) {
     try {
-      const columns = Object.entries(schema).map(([name, def]) => {
-        const parsedName = utils.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");
-      if (this.schema) {
-        await this.setupSchema();
-      }
-      const sql = `
-        CREATE TABLE IF NOT EXISTS ${this.getTableName(tableName)} (
-          ${columns}
-        );
-        ${tableName === storage.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);
+      const tableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+      await this.client.none(
+        `INSERT INTO ${tableName} (
+          id,
+          "resourceId",
+          title,
+          metadata,
+          "createdAt",
+          "createdAtZ",
+          "updatedAt",
+          "updatedAtZ"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+        ON CONFLICT (id) DO UPDATE SET
+          "resourceId" = EXCLUDED."resourceId",
+          title = EXCLUDED.title,
+          metadata = EXCLUDED.metadata,
+          "createdAt" = EXCLUDED."createdAt",
+          "createdAtZ" = EXCLUDED."createdAtZ",
+          "updatedAt" = EXCLUDED."updatedAt",
+          "updatedAtZ" = EXCLUDED."updatedAtZ"`,
+        [
+          thread.id,
+          thread.resourceId,
+          thread.title,
+          thread.metadata ? JSON.stringify(thread.metadata) : null,
+          thread.createdAt,
+          thread.createdAt,
+          thread.updatedAt,
+          thread.updatedAt
+        ]
+      );
+      return thread;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_CREATE_TABLE_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_SAVE_THREAD_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId: thread.id
           }
         },
         error$1
       );
     }
   }
-  getDefaultValue(type) {
-    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,
-    ifNotExists
+  async updateThread({
+    id,
+    title,
+    metadata
   }) {
-    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 = utils.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}`);
+    const threadTableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+    const existingThread = await this.getThreadById({ threadId: id });
+    if (!existingThread) {
+      throw new error.MastraError({
+        id: "MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread ${id} not found`,
+        details: {
+          threadId: id,
+          title
         }
-      }
+      });
+    }
+    const mergedMetadata = {
+      ...existingThread.metadata,
+      ...metadata
+    };
+    try {
+      const thread = await this.client.one(
+        `UPDATE ${threadTableName}
+                    SET 
+                        title = $1,
+                        metadata = $2,
+                        "updatedAt" = $3,
+                        "updatedAtZ" = $3
+                    WHERE id = $4
+                    RETURNING *
+                `,
+        [title, mergedMetadata, (/* @__PURE__ */ new Date()).toISOString(), id]
+      );
+      return {
+        id: thread.id,
+        resourceId: thread.resourceId,
+        title: thread.title,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAtZ || thread.createdAt,
+        updatedAt: thread.updatedAtZ || thread.updatedAt
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_ALTER_TABLE_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId: id,
+            title
           }
         },
         error$1
       );
     }
   }
-  async clearTable({ tableName }) {
+  async deleteThread({ threadId }) {
     try {
-      await this.db.none(`TRUNCATE TABLE ${this.getTableName(tableName)} CASCADE`);
+      const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
+      const threadTableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+      await this.client.tx(async (t) => {
+        await t.none(`DELETE FROM ${tableName} WHERE thread_id = $1`, [threadId]);
+        await t.none(`DELETE FROM ${threadTableName} WHERE id = $1`, [threadId]);
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_CLEAR_TABLE_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_DELETE_THREAD_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId
           }
         },
         error$1
       );
     }
   }
-  async insert({ tableName, record }) {
+  async _getIncludedMessages({
+    threadId,
+    selectBy,
+    orderByStatement
+  }) {
+    const include = selectBy?.include;
+    if (!include) return null;
+    const unionQueries = [];
+    const params = [];
+    let paramIdx = 1;
+    const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      const searchId = inc.threadId || threadId;
+      unionQueries.push(
+        `
+            SELECT * FROM (
+              WITH ordered_messages AS (
+                SELECT 
+                  *,
+                  ROW_NUMBER() OVER (${orderByStatement}) as row_num
+                FROM ${tableName}
+                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.client.manyOrNone(finalQuery, params);
+    const seen = /* @__PURE__ */ new Set();
+    const dedupedRows = includedRows.filter((row) => {
+      if (seen.has(row.id)) return false;
+      seen.add(row.id);
+      return true;
+    });
+    return dedupedRows;
+  }
+  async getMessages(args) {
+    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 = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
     try {
-      const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
-      const values = Object.values(record);
-      const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
-      await this.db.none(
-        `INSERT INTO ${this.getTableName(tableName)} (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
-        values
+      let rows = [];
+      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 tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + 2}`).join(", ");
+      let query = `${selectStatement} FROM ${tableName} WHERE thread_id = $1 
+        ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""}
+        ${orderByStatement}
+        LIMIT $${excludeIds.length + 2}
+        `;
+      const queryParams = [threadId, ...excludeIds, limit];
+      const remainingRows = await this.client.manyOrNone(query, queryParams);
+      rows.push(...remainingRows);
+      const fetchedMessages = (rows || []).map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            message.content = JSON.parse(message.content);
+          } catch {
+          }
+        }
+        if (message.type === "v2") delete message.type;
+        return message;
+      });
+      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: "" }] } })
+      ) : sortedMessages;
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_INSERT_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async load({ tableName, keys }) {
-    try {
-      const keyEntries = Object.entries(keys).map(([key, value]) => [utils.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(
-        `SELECT * FROM ${this.getTableName(tableName)} WHERE ${conditions}`,
-        values
-      );
-      if (!result) {
-        return null;
-      }
-      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-        const snapshot = result;
-        if (typeof snapshot.snapshot === "string") {
-          snapshot.snapshot = JSON.parse(snapshot.snapshot);
-        }
-        return snapshot;
-      }
-      return result;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_PG_STORE_LOAD_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
+            threadId
           }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return [];
     }
   }
-  async getThreadById({ threadId }) {
-    try {
-      const thread = await this.db.oneOrNone(
-        `SELECT 
-          id,
-          "resourceId",
-          title,
-          metadata,
-          "createdAt",
-          "updatedAt"
-        FROM ${this.getTableName(storage.TABLE_THREADS)}
-        WHERE id = $1`,
-        [threadId]
-      );
-      if (!thread) {
-        return null;
+  async getMessagesPaginated(args) {
+    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 = [];
+    if (selectBy?.include?.length) {
+      const includeMessages = await this._getIncludedMessages({ threadId, selectBy, orderByStatement });
+      if (includeMessages) {
+        messages.push(...includeMessages);
       }
-      return {
-        ...thread,
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_PG_STORE_GET_THREAD_BY_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId
-          }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead
-   */
-  async getThreadsByResourceId(args) {
-    const { resourceId } = args;
-    try {
-      const baseQuery = `FROM ${this.getTableName(storage.TABLE_THREADS)} WHERE "resourceId" = $1`;
-      const queryParams = [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 [];
     }
-  }
-  async getThreadsByResourceIdPaginated(args) {
-    const { resourceId, page = 0, perPage: perPageInput } = args;
     try {
-      const baseQuery = `FROM ${this.getTableName(storage.TABLE_THREADS)} WHERE "resourceId" = $1`;
-      const queryParams = [resourceId];
-      const perPage = perPageInput !== void 0 ? perPageInput : 100;
+      const perPage = perPageInput !== void 0 ? perPageInput : storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
       const currentOffset = page * perPage;
-      const countQuery = `SELECT COUNT(*) ${baseQuery}`;
-      const countResult = await this.db.one(countQuery, queryParams);
+      const conditions = [`thread_id = $1`];
+      const queryParams = [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 tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
+      const countQuery = `SELECT COUNT(*) FROM ${tableName} ${whereClause}`;
+      const countResult = await this.client.one(countQuery, queryParams);
       const total = parseInt(countResult.count, 10);
-      if (total === 0) {
+      if (total === 0 && messages.length === 0) {
         return {
-          threads: [],
+          messages: [],
           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
-      }));
+      const excludeIds = messages.map((m) => m.id);
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + paramIndex}`).join(", ");
+      paramIndex += excludeIds.length;
+      const dataQuery = `${selectStatement} FROM ${tableName} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""}${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.client.manyOrNone(dataQuery, [...queryParams, ...excludeIds, perPage, currentOffset]);
+      messages.push(...rows || []);
+      const messagesWithParsedContent = messages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            return message;
+          }
+        }
+        return message;
+      });
+      const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
+      const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
       return {
-        threads,
+        messages: messagesToReturn,
         total,
         page,
         perPage,
-        hasMore: currentOffset + threads.length < total
+        hasMore: currentOffset + rows.length < total
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            resourceId,
+            threadId,
             page
           }
         },
@@ -1670,872 +1687,1348 @@ var PostgresStore = class extends storage.MastraStorage {
       );
       this.logger?.error?.(mastraError.toString());
       this.logger?.trackException(mastraError);
-      return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
+      return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
     }
   }
-  async saveThread({ thread }) {
+  async saveMessages({
+    messages,
+    format
+  }) {
+    if (messages.length === 0) return messages;
+    const threadId = messages[0]?.threadId;
+    if (!threadId) {
+      throw new error.MastraError({
+        id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY,
+        text: `Thread ID is required`
+      });
+    }
+    const thread = await this.getThreadById({ threadId });
+    if (!thread) {
+      throw new error.MastraError({
+        id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY,
+        text: `Thread ${threadId} not found`,
+        details: {
+          threadId
+        }
+      });
+    }
     try {
-      await this.db.none(
-        `INSERT INTO ${this.getTableName(storage.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;
+      const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
+      await this.client.tx(async (t) => {
+        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 ${tableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId") 
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+             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 || (/* @__PURE__ */ new Date()).toISOString(),
+              message.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+              message.role,
+              message.type || "v2",
+              message.resourceId
+            ]
+          );
+        });
+        const threadTableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+        const threadUpdate = t.none(
+          `UPDATE ${threadTableName} 
+                        SET 
+                            "updatedAt" = $1,
+                            "updatedAtZ" = $1
+                        WHERE id = $2
+                    `,
+          [(/* @__PURE__ */ new Date()).toISOString(), threadId]
+        );
+        await Promise.all([...messageInserts, threadUpdate]);
+      });
+      const messagesWithParsedContent = messages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            return message;
+          }
+        }
+        return message;
+      });
+      const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_SAVE_THREAD_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId: thread.id
+            threadId
           }
         },
         error$1
       );
     }
   }
-  async updateThread({
-    id,
-    title,
-    metadata
+  async updateMessages({
+    messages
   }) {
-    const existingThread = await this.getThreadById({ threadId: id });
-    if (!existingThread) {
-      throw new error.MastraError({
-        id: "MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: `Thread ${id} not found`,
-        details: {
-          threadId: id,
-          title
+    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 ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} WHERE id IN ($1:list)`;
+    const existingMessagesDb = await this.client.manyOrNone(selectQuery, [messageIds]);
+    if (existingMessagesDb.length === 0) {
+      return [];
+    }
+    const existingMessages = existingMessagesDb.map((msg) => {
+      if (typeof msg.content === "string") {
+        try {
+          msg.content = JSON.parse(msg.content);
+        } catch {
         }
-      });
+      }
+      return msg;
+    });
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    await this.client.tx(async (t) => {
+      const queries = [];
+      const columnMapping = {
+        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 = [];
+        const values = [];
+        let paramIndex = 1;
+        const updatableFields = { ...fieldsToUpdate };
+        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]);
+          }
+        }
+        if (setClauses.length > 0) {
+          values.push(id);
+          const sql = `UPDATE ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
+          queries.push(t.none(sql, values));
+        }
+      }
+      if (threadIdsToUpdate.size > 0) {
+        queries.push(
+          t.none(
+            `UPDATE ${getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) })} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id IN ($1:list)`,
+            [Array.from(threadIdsToUpdate)]
+          )
+        );
+      }
+      if (queries.length > 0) {
+        await t.batch(queries);
+      }
+    });
+    const updatedMessages = await this.client.manyOrNone(selectQuery, [messageIds]);
+    return (updatedMessages || []).map((message) => {
+      if (typeof message.content === "string") {
+        try {
+          message.content = JSON.parse(message.content);
+        } catch {
+        }
+      }
+      return message;
+    });
+  }
+  async getResourceById({ resourceId }) {
+    const tableName = getTableName({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
+    const result = await this.client.oneOrNone(
+      `SELECT * FROM ${tableName} WHERE id = $1`,
+      [resourceId]
+    );
+    if (!result) {
+      return null;
     }
-    const mergedMetadata = {
-      ...existingThread.metadata,
-      ...metadata
+    return {
+      id: result.id,
+      createdAt: result.createdAtZ || result.createdAt,
+      updatedAt: result.updatedAtZ || result.updatedAt,
+      workingMemory: result.workingMemory,
+      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
+    };
+  }
+  async saveResource({ resource }) {
+    await this.operations.insert({
+      tableName: storage.TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata)
+      }
+    });
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const existingResource = await this.getResourceById({ resourceId });
+    if (!existingResource) {
+      const newResource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      return this.saveResource({ resource: newResource });
+    }
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata
+      },
+      updatedAt: /* @__PURE__ */ new Date()
     };
+    const tableName = getTableName({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
+    const updates = [];
+    const values = [];
+    let paramIndex = 1;
+    if (workingMemory !== void 0) {
+      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());
+    updates.push(`"updatedAtZ" = $${paramIndex++}`);
+    values.push(updatedResource.updatedAt.toISOString());
+    paramIndex++;
+    values.push(resourceId);
+    await this.client.none(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = $${paramIndex}`, values);
+    return updatedResource;
+  }
+};
+var StoreOperationsPG = class extends storage.StoreOperations {
+  client;
+  schemaName;
+  setupSchemaPromise = null;
+  schemaSetupComplete = void 0;
+  constructor({ client, schemaName }) {
+    super();
+    this.client = client;
+    this.schemaName = schemaName;
+  }
+  async hasColumn(table, column) {
+    const schema = this.schemaName || "public";
+    const result = await this.client.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;
+  }
+  async setupSchema() {
+    if (!this.schemaName || this.schemaSetupComplete) {
+      return;
+    }
+    const schemaName = getSchemaName(this.schemaName);
+    if (!this.setupSchemaPromise) {
+      this.setupSchemaPromise = (async () => {
+        try {
+          const schemaExists = await this.client.oneOrNone(
+            `
+                SELECT EXISTS (
+                  SELECT 1 FROM information_schema.schemata 
+                  WHERE schema_name = $1
+                )
+              `,
+            [this.schemaName]
+          );
+          if (!schemaExists?.exists) {
+            try {
+              await this.client.none(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
+              this.logger.info(`Schema "${this.schemaName}" created successfully`);
+            } catch (error) {
+              this.logger.error(`Failed to create schema "${this.schemaName}"`, { error });
+              throw new Error(
+                `Unable to create schema "${this.schemaName}". This requires CREATE privilege on the database. Either create the schema manually or grant CREATE privilege to the user.`
+              );
+            }
+          }
+          this.schemaSetupComplete = true;
+          this.logger.debug(`Schema "${schemaName}" is ready for use`);
+        } catch (error) {
+          this.schemaSetupComplete = void 0;
+          this.setupSchemaPromise = null;
+          throw error;
+        } finally {
+          this.setupSchemaPromise = null;
+        }
+      })();
+    }
+    await this.setupSchemaPromise;
+  }
+  async insert({ tableName, record }) {
     try {
-      const thread = await this.db.one(
-        `UPDATE ${this.getTableName(storage.TABLE_THREADS)}
-        SET title = $1,
-        metadata = $2,
-        "updatedAt" = $3
-        WHERE id = $4
-        RETURNING *`,
-        [title, mergedMetadata, (/* @__PURE__ */ new Date()).toISOString(), id]
+      if (record.createdAt) {
+        record.createdAtZ = record.createdAt;
+      }
+      if (record.created_at) {
+        record.created_atZ = record.created_at;
+      }
+      if (record.updatedAt) {
+        record.updatedAtZ = record.updatedAt;
+      }
+      const schemaName = getSchemaName(this.schemaName);
+      const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
+      const values = Object.values(record);
+      const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+      await this.client.none(
+        `INSERT INTO ${getTableName({ indexName: tableName, schemaName })} (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
+        values
       );
-      return {
-        ...thread,
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
-      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_INSERT_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId: id,
-            title
+            tableName
           }
         },
         error$1
       );
     }
   }
-  async deleteThread({ threadId }) {
+  async clearTable({ tableName }) {
     try {
-      await this.db.tx(async (t) => {
-        await t.none(`DELETE FROM ${this.getTableName(storage.TABLE_MESSAGES)} WHERE thread_id = $1`, [threadId]);
-        await t.none(`DELETE FROM ${this.getTableName(storage.TABLE_THREADS)} WHERE id = $1`, [threadId]);
-      });
+      const schemaName = getSchemaName(this.schemaName);
+      const tableNameWithSchema = getTableName({ indexName: tableName, schemaName });
+      await this.client.none(`TRUNCATE TABLE ${tableNameWithSchema} CASCADE`);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_DELETE_THREAD_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_CLEAR_TABLE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId
+            tableName
           }
         },
         error$1
       );
     }
   }
-  async _getIncludedMessages({
-    threadId,
-    selectBy,
-    orderByStatement
+  getDefaultValue(type) {
+    switch (type) {
+      case "timestamp":
+        return "DEFAULT NOW()";
+      case "jsonb":
+        return "DEFAULT '{}'::jsonb";
+      default:
+        return super.getDefaultValue(type);
+    }
+  }
+  async createTable({
+    tableName,
+    schema
   }) {
-    const include = selectBy?.include;
-    if (!include) return null;
-    const unionQueries = [];
-    const params = [];
-    let paramIdx = 1;
-    for (const inc of include) {
-      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const searchId = inc.threadId || threadId;
-      unionQueries.push(
-        `
-            SELECT * FROM (
-              WITH ordered_messages AS (
-                SELECT 
-                  *,
-                  ROW_NUMBER() OVER (${orderByStatement}) as row_num
-                FROM ${this.getTableName(storage.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
+    try {
+      const timeZColumnNames = Object.entries(schema).filter(([_, def]) => def.type === "timestamp").map(([name]) => name);
+      const timeZColumns = Object.entries(schema).filter(([_, def]) => def.type === "timestamp").map(([name]) => {
+        const parsedName = utils.parseSqlIdentifier(name, "column name");
+        return `"${parsedName}Z" TIMESTAMPTZ DEFAULT NOW()`;
+      });
+      const columns = Object.entries(schema).map(([name, def]) => {
+        const parsedName = utils.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(" ")}`;
+      });
+      if (this.schemaName) {
+        await this.setupSchema();
+      }
+      const finalColumns = [...columns, ...timeZColumns].join(",\n");
+      const sql = `
+            CREATE TABLE IF NOT EXISTS ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} (
+              ${finalColumns}
+            );
+            ${tableName === storage.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 ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })}
+                ADD CONSTRAINT mastra_workflow_snapshot_workflow_name_run_id_key
+                UNIQUE (workflow_name, run_id);
+              END IF;
+            END $$;
+            ` : ""}
+          `;
+      await this.client.none(sql);
+      console.log("Alter Table SQL", tableName);
+      console.log("timeZColumnNames", timeZColumnNames);
+      await this.alterTable({
+        tableName,
+        schema,
+        ifNotExists: timeZColumnNames
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_CREATE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
       );
-      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 = /* @__PURE__ */ new Set();
-    const dedupedRows = includedRows.filter((row) => {
-      if (seen.has(row.id)) return false;
-      seen.add(row.id);
-      return true;
-    });
-    return dedupedRows;
   }
-  async getMessages(args) {
-    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 });
+  /**
+   * 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,
+    ifNotExists
+  }) {
+    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
     try {
-      let rows = [];
-      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(storage.TABLE_MESSAGES)} WHERE thread_id = $1 
-        ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""}
-        ${orderByStatement}
-        LIMIT $${excludeIds.length + 2}
-        `;
-      const queryParams = [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 {
+      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 = utils.parseSqlIdentifier(columnName, "column name");
+          const alterSql = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.client.none(alterSql);
+          if (sqlType === "TIMESTAMP") {
+            const alterSql2 = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}Z" TIMESTAMPTZ DEFAULT NOW()`.trim();
+            await this.client.none(alterSql2);
           }
+          this.logger?.debug?.(`Ensured column ${parsedColumnName} exists in table ${fullTableName}`);
         }
-        if (message.type === "v2") delete message.type;
-        return message;
-      });
-      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: "" }] } })
-      ) : sortedMessages;
+      }
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_ALTER_TABLE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId
+            tableName
           }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return [];
     }
   }
-  async getMessagesPaginated(args) {
-    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 = [];
-    if (selectBy?.include?.length) {
-      const includeMessages = await this._getIncludedMessages({ threadId, selectBy, orderByStatement });
-      if (includeMessages) {
-        messages.push(...includeMessages);
-      }
-    }
+  async load({ tableName, keys }) {
     try {
-      const perPage = perPageInput !== void 0 ? perPageInput : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-      const currentOffset = page * perPage;
-      const conditions = [`thread_id = $1`];
-      const queryParams = [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(storage.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 keyEntries = Object.entries(keys).map(([key, value]) => [utils.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.client.oneOrNone(
+        `SELECT * FROM ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} WHERE ${conditions}`,
+        values
+      );
+      if (!result) {
+        return null;
       }
-      const excludeIds = messages.map((m) => m.id);
-      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + paramIndex}`).join(", ");
-      paramIndex += excludeIds.length;
-      const dataQuery = `${selectStatement} FROM ${this.getTableName(
-        storage.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 || []);
-      const messagesWithParsedContent = messages.map((message) => {
-        if (typeof message.content === "string") {
-          try {
-            return { ...message, content: JSON.parse(message.content) };
-          } catch {
-            return message;
-          }
+      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+        const snapshot = result;
+        if (typeof snapshot.snapshot === "string") {
+          snapshot.snapshot = JSON.parse(snapshot.snapshot);
         }
-        return message;
-      });
-      const list = new agent.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
-      };
+        return snapshot;
+      }
+      return result;
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_LOAD_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
-            page
+            tableName
           }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
     }
   }
-  async saveMessages({
-    messages,
-    format
-  }) {
-    if (messages.length === 0) return messages;
-    const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      throw new error.MastraError({
-        id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY,
-        text: `Thread ID is required`
-      });
-    }
-    const thread = await this.getThreadById({ threadId });
-    if (!thread) {
-      throw new error.MastraError({
-        id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY,
-        text: `Thread ${threadId} not found`,
-        details: {
-          threadId
-        }
-      });
+  async batchInsert({ tableName, records }) {
+    try {
+      await this.client.query("BEGIN");
+      for (const record of records) {
+        await this.insert({ tableName, record });
+      }
+      await this.client.query("COMMIT");
+    } catch (error$1) {
+      await this.client.query("ROLLBACK");
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_BATCH_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: records.length
+          }
+        },
+        error$1
+      );
     }
+  }
+  async dropTable({ tableName }) {
     try {
-      await this.db.tx(async (t) => {
-        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(storage.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 || (/* @__PURE__ */ new Date()).toISOString(),
-              message.role,
-              message.type || "v2",
-              message.resourceId
-            ]
-          );
-        });
-        const threadUpdate = t.none(
-          `UPDATE ${this.getTableName(storage.TABLE_THREADS)} 
-           SET "updatedAt" = $1 
-           WHERE id = $2`,
-          [(/* @__PURE__ */ new Date()).toISOString(), threadId]
-        );
-        await Promise.all([...messageInserts, threadUpdate]);
-      });
-      const messagesWithParsedContent = messages.map((message) => {
-        if (typeof message.content === "string") {
-          try {
-            return { ...message, content: JSON.parse(message.content) };
-          } catch {
-            return message;
-          }
-        }
-        return message;
-      });
-      const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId
+      const schemaName = getSchemaName(this.schemaName);
+      const tableNameWithSchema = getTableName({ indexName: tableName, schemaName });
+      await this.client.none(`DROP TABLE IF EXISTS ${tableNameWithSchema}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_DROP_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
           }
         },
         error$1
       );
     }
   }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    snapshot
-  }) {
+};
+function transformScoreRow(row) {
+  let input = void 0;
+  if (row.input) {
     try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      await this.db.none(
-        `INSERT INTO ${this.getTableName(storage.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]
-      );
+      input = JSON.parse(row.input);
+    } catch {
+      input = row.input;
+    }
+  }
+  return {
+    ...row,
+    input,
+    createdAt: row.createdAtZ || row.createdAt,
+    updatedAt: row.updatedAtZ || row.updatedAt
+  };
+}
+var ScoresPG = class extends storage.ScoresStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async getScoreById({ id }) {
+    try {
+      const result = await this.client.oneOrNone(`SELECT * FROM ${storage.TABLE_SCORERS} WHERE id = $1`, [id]);
+      return transformScoreRow(result);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_GET_SCORE_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName,
-            runId
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
+  async getScoresByScorerId({
+    scorerId,
+    pagination
   }) {
     try {
-      const result = await this.load({
-        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId
-        }
-      });
-      if (!result) {
-        return null;
+      const total = await this.client.oneOrNone(
+        `SELECT COUNT(*) FROM ${storage.TABLE_SCORERS} WHERE "scorerId" = $1`,
+        [scorerId]
+      );
+      if (total?.count === "0" || !total?.count) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
       }
-      return result.snapshot;
+      const result = await this.client.manyOrNone(
+        `SELECT * FROM ${storage.TABLE_SCORERS} WHERE "scorerId" = $1 LIMIT $2 OFFSET $3`,
+        [scorerId, pagination.perPage, pagination.page * pagination.perPage]
+      );
+      return {
+        pagination: {
+          total: Number(total?.count) || 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: Number(total?.count) > (pagination.page + 1) * pagination.perPage
+        },
+        scores: result
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName,
-            runId
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async hasColumn(table, column) {
-    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;
-  }
-  parseWorkflowRun(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,
-      resourceId: row.resourceId
-    };
-  }
-  async getWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    limit,
-    offset,
-    resourceId
-  } = {}) {
+  async saveScore(score) {
     try {
-      const conditions = [];
-      const values = [];
-      let paramIndex = 1;
-      if (workflowName) {
-        conditions.push(`workflow_name = $${paramIndex}`);
-        values.push(workflowName);
-        paramIndex++;
-      }
-      if (resourceId) {
-        const hasResourceId = await this.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
-        if (hasResourceId) {
-          conditions.push(`"resourceId" = $${paramIndex}`);
-          values.push(resourceId);
-          paramIndex++;
-        } else {
-          console.warn(`[${storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+      const { input, ...rest } = score;
+      await this.operations.insert({
+        tableName: storage.TABLE_SCORERS,
+        record: {
+          ...rest,
+          input: JSON.stringify(input),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         }
-      }
-      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 ${this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT)} ${whereClause}`,
-          values
-        );
-        total = Number(countResult.count);
-      }
-      const query = `
-      SELECT * FROM ${this.getTableName(storage.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) => {
-        return this.parseWorkflowRun(row);
       });
-      return { runs, total: total || runs.length };
+      const scoreFromDb = await this.getScoreById({ id: score.id });
+      return { score: scoreFromDb };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUNS_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_SAVE_SCORE_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName: workflowName || "all"
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async getWorkflowRunById({
+  async getScoresByRunId({
     runId,
-    workflowName
+    pagination
   }) {
     try {
-      const conditions = [];
-      const values = [];
-      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 ")}` : "";
-      const query = `
-      SELECT * FROM ${this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT)} 
-      ${whereClause} 
-    `;
-      const queryValues = values;
-      const result = await this.db.oneOrNone(query, queryValues);
-      if (!result) {
-        return null;
+      const total = await this.client.oneOrNone(
+        `SELECT COUNT(*) FROM ${storage.TABLE_SCORERS} WHERE "runId" = $1`,
+        [runId]
+      );
+      console.log(`total: ${total?.count}`);
+      console.log(`typeof total: ${typeof total?.count}`);
+      if (total?.count === "0" || !total?.count) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
       }
-      return this.parseWorkflowRun(result);
+      const result = await this.client.manyOrNone(
+        `SELECT * FROM ${storage.TABLE_SCORERS} WHERE "runId" = $1 LIMIT $2 OFFSET $3`,
+        [runId, pagination.perPage, pagination.page * pagination.perPage]
+      );
+      return {
+        pagination: {
+          total: Number(total?.count) || 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: Number(total?.count) > (pagination.page + 1) * pagination.perPage
+        },
+        scores: result
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_GET_SCORES_BY_RUN_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            runId,
-            workflowName: workflowName || ""
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async close() {
-    this.pgp.end();
-  }
-  async getEvals(options = {}) {
-    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const conditions = [];
-    const queryParams = [];
-    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(storage.TABLE_EVALS)} ${whereClause}`;
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
     try {
-      const countResult = await this.db.one(countQuery, queryParams);
-      const total = parseInt(countResult.count, 10);
-      const currentOffset = page * perPage;
-      if (total === 0) {
+      const total = await this.client.oneOrNone(
+        `SELECT COUNT(*) FROM ${storage.TABLE_SCORERS} WHERE "entityId" = $1 AND "entityType" = $2`,
+        [entityId, entityType]
+      );
+      if (total?.count === "0" || !total?.count) {
         return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
         };
       }
-      const dataQuery = `SELECT * FROM ${this.getTableName(
-        storage.TABLE_EVALS
-      )} ${whereClause} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
+      const result = await this.client.manyOrNone(
+        `SELECT * FROM ${storage.TABLE_SCORERS} WHERE "entityId" = $1 AND "entityType" = $2 LIMIT $3 OFFSET $4`,
+        [entityId, entityType, pagination.perPage, pagination.page * pagination.perPage]
+      );
       return {
-        evals: rows?.map((row) => this.transformEvalRow(row)) ?? [],
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + (rows?.length ?? 0) < total
+        pagination: {
+          total: Number(total?.count) || 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: Number(total?.count) > (pagination.page + 1) * pagination.perPage
+        },
+        scores: result
       };
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_EVALS_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            agentName: agentName || "all",
-            type: type || "all",
-            page,
-            perPage
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      throw mastraError;
     }
   }
-  async updateMessages({
-    messages
+};
+var TracesPG = class extends storage.TracesStorage {
+  client;
+  operations;
+  schema;
+  constructor({
+    client,
+    operations,
+    schema
   }) {
-    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(
-      storage.TABLE_MESSAGES
-    )} WHERE id IN ($1:list)`;
-    const existingMessagesDb = await this.db.manyOrNone(selectQuery, [messageIds]);
-    if (existingMessagesDb.length === 0) {
-      return [];
+    super();
+    this.client = client;
+    this.operations = operations;
+    this.schema = schema;
+  }
+  async getTraces(args) {
+    if (args.fromDate || args.toDate) {
+      args.dateRange = {
+        start: args.fromDate,
+        end: args.toDate
+      };
     }
-    const existingMessages = existingMessagesDb.map((msg) => {
-      if (typeof msg.content === "string") {
-        try {
-          msg.content = JSON.parse(msg.content);
-        } catch {
-        }
+    try {
+      const result = await this.getTracesPaginated(args);
+      return result.traces;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const currentOffset = page * perPage;
+    const queryParams = [];
+    const conditions = [];
+    let paramIndex = 1;
+    if (name) {
+      conditions.push(`name LIKE $${paramIndex++}`);
+      queryParams.push(`${name}%`);
+    }
+    if (scope) {
+      conditions.push(`scope = $${paramIndex++}`);
+      queryParams.push(scope);
+    }
+    if (attributes) {
+      Object.entries(attributes).forEach(([key, value]) => {
+        const parsedKey = utils.parseFieldKey(key);
+        conditions.push(`attributes->>'${parsedKey}' = $${paramIndex++}`);
+        queryParams.push(value);
+      });
+    }
+    if (filters) {
+      Object.entries(filters).forEach(([key, value]) => {
+        const parsedKey = utils.parseFieldKey(key);
+        conditions.push(`"${parsedKey}" = $${paramIndex++}`);
+        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 ")}` : "";
+    try {
+      const countResult = await this.client.oneOrNone(
+        `SELECT COUNT(*) FROM ${getTableName({ indexName: storage.TABLE_TRACES, schemaName: getSchemaName(this.schema) })} ${whereClause}`,
+        queryParams
+      );
+      const total = Number(countResult?.count ?? 0);
+      if (total === 0) {
+        return {
+          traces: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
       }
-      return msg;
-    });
-    const threadIdsToUpdate = /* @__PURE__ */ new Set();
-    await this.db.tx(async (t) => {
-      const queries = [];
-      const columnMapping = {
-        threadId: "thread_id"
+      const dataResult = await this.client.manyOrNone(
+        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_TRACES, schemaName: getSchemaName(this.schema) })} ${whereClause} ORDER BY "startTime" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
+        [...queryParams, perPage, currentOffset]
+      );
+      const traces = dataResult.map((row) => ({
+        id: row.id,
+        parentSpanId: row.parentSpanId,
+        traceId: row.traceId,
+        name: row.name,
+        scope: row.scope,
+        kind: row.kind,
+        status: storage.safelyParseJSON(row.status),
+        events: storage.safelyParseJSON(row.events),
+        links: storage.safelyParseJSON(row.links),
+        attributes: storage.safelyParseJSON(row.attributes),
+        startTime: row.startTime,
+        endTime: row.endTime,
+        other: storage.safelyParseJSON(row.other),
+        createdAt: row.createdAtZ || row.createdAt
+      }));
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + traces.length < total
       };
-      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 = [];
-        const values = [];
-        let paramIndex = 1;
-        const updatableFields = { ...fieldsToUpdate };
-        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]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: storage.TABLE_TRACES,
+      records
+    });
+  }
+};
+function parseWorkflowRun(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,
+    resourceId: row.resourceId,
+    createdAt: new Date(row.createdAtZ || row.createdAt),
+    updatedAt: new Date(row.updatedAtZ || row.updatedAt)
+  };
+}
+var WorkflowsPG = class extends storage.WorkflowsStorage {
+  client;
+  operations;
+  schema;
+  constructor({
+    client,
+    operations,
+    schema
+  }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+    this.schema = schema;
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await this.client.none(
+        `INSERT INTO ${storage.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 = $3, "updatedAt" = $5`,
+        [workflowName, runId, JSON.stringify(snapshot), now, now]
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    try {
+      const result = await this.operations.load({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: { workflow_name: workflowName, run_id: runId }
+      });
+      return result ? result.snapshot : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    try {
+      const conditions = [];
+      const values = [];
+      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 ")}` : "";
+      const query = `
+          SELECT * FROM ${getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: this.schema })} 
+          ${whereClause} 
+        `;
+      const queryValues = values;
+      const result = await this.client.oneOrNone(query, queryValues);
+      if (!result) {
+        return null;
+      }
+      return parseWorkflowRun(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            runId,
+            workflowName: workflowName || ""
           }
-        }
-        if (setClauses.length > 0) {
-          values.push(id);
-          const sql = `UPDATE ${this.getTableName(
-            storage.TABLE_MESSAGES
-          )} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
-          queries.push(t.none(sql, values));
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    try {
+      const conditions = [];
+      const values = [];
+      let paramIndex = 1;
+      if (workflowName) {
+        conditions.push(`workflow_name = $${paramIndex}`);
+        values.push(workflowName);
+        paramIndex++;
+      }
+      if (resourceId) {
+        const hasResourceId = await this.operations.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        if (hasResourceId) {
+          conditions.push(`"resourceId" = $${paramIndex}`);
+          values.push(resourceId);
+          paramIndex++;
+        } else {
+          console.warn(`[${storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
         }
       }
-      if (threadIdsToUpdate.size > 0) {
-        queries.push(
-          t.none(`UPDATE ${this.getTableName(storage.TABLE_THREADS)} SET "updatedAt" = NOW() WHERE id IN ($1:list)`, [
-            Array.from(threadIdsToUpdate)
-          ])
-        );
+      if (fromDate) {
+        conditions.push(`"createdAt" >= $${paramIndex}`);
+        values.push(fromDate);
+        paramIndex++;
       }
-      if (queries.length > 0) {
-        await t.batch(queries);
+      if (toDate) {
+        conditions.push(`"createdAt" <= $${paramIndex}`);
+        values.push(toDate);
+        paramIndex++;
       }
-    });
-    const updatedMessages = await this.db.manyOrNone(selectQuery, [messageIds]);
-    return (updatedMessages || []).map((message) => {
-      if (typeof message.content === "string") {
-        try {
-          message.content = JSON.parse(message.content);
-        } catch {
-        }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      let total = 0;
+      if (limit !== void 0 && offset !== void 0) {
+        const countResult = await this.client.one(
+          `SELECT COUNT(*) as count FROM ${getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: this.schema })} ${whereClause}`,
+          values
+        );
+        total = Number(countResult.count);
       }
-      return message;
-    });
+      const query = `
+          SELECT * FROM ${getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: this.schema })} 
+          ${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.client.manyOrNone(query, queryValues);
+      const runs = (result || []).map((row) => {
+        return parseWorkflowRun(row);
+      });
+      return { runs, total: total || runs.length };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUNS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName: workflowName || "all"
+          }
+        },
+        error$1
+      );
+    }
   }
-  async getResourceById({ resourceId }) {
-    const tableName = this.getTableName(storage.TABLE_RESOURCES);
-    const result = await this.db.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [
-      resourceId
-    ]);
-    if (!result) {
-      return null;
+};
+
+// src/storage/index.ts
+var PostgresStore = class extends storage.MastraStorage {
+  db;
+  pgp;
+  client;
+  schema;
+  stores;
+  constructor(config) {
+    try {
+      if ("connectionString" in config) {
+        if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
+          throw new Error(
+            "PostgresStore: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults."
+          );
+        }
+      } else {
+        const required = ["host", "database", "user", "password"];
+        for (const key of required) {
+          if (!(key in config) || typeof config[key] !== "string" || config[key].trim() === "") {
+            throw new Error(
+              `PostgresStore: ${key} must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults.`
+            );
+          }
+        }
+      }
+      super({ name: "PostgresStore" });
+      this.pgp = pgPromise__default.default();
+      this.schema = config.schemaName || "public";
+      this.db = this.pgp(
+        `connectionString` in config ? { connectionString: config.connectionString } : {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+          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 error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_INITIALIZATION_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        e
+      );
     }
+  }
+  get supports() {
     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
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true
     };
   }
+  /** @deprecated use getEvals instead */
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async getEvals(options = {}) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async batchTraceInsert({ records }) {
+    return this.stores.traces.batchTraceInsert({ records });
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    return this.stores.operations.createTable({ tableName, schema });
+  }
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
+  }
+  async clearTable({ tableName }) {
+    return this.stores.operations.clearTable({ tableName });
+  }
+  async dropTable({ tableName }) {
+    return this.stores.operations.dropTable({ tableName });
+  }
+  async insert({ tableName, record }) {
+    return this.stores.operations.insert({ tableName, record });
+  }
+  async batchInsert({ tableName, records }) {
+    return this.stores.operations.batchInsert({ tableName, records });
+  }
+  async load({ tableName, keys }) {
+    return this.stores.operations.load({ tableName, keys });
+  }
+  /**
+   * Memory
+   */
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  async getThreadsByResourceId(args) {
+    return this.stores.memory.getThreadsByResourceId(args);
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  async saveThread({ thread }) {
+    return this.stores.memory.saveThread({ thread });
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    return this.stores.memory.updateThread({ id, title, metadata });
+  }
+  async deleteThread({ threadId }) {
+    return this.stores.memory.deleteThread({ threadId });
+  }
+  async getMessages(args) {
+    return this.stores.memory.getMessages(args);
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async updateMessages({
+    messages
+  }) {
+    return this.stores.memory.updateMessages({ messages });
+  }
+  async getResourceById({ resourceId }) {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
   async saveResource({ resource }) {
-    const tableName = this.getTableName(storage.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;
+    return this.stores.memory.saveResource({ resource });
   }
   async updateResource({
     resourceId,
     workingMemory,
     metadata
   }) {
-    const existingResource = await this.getResourceById({ resourceId });
-    if (!existingResource) {
-      const newResource = {
-        id: resourceId,
-        workingMemory,
-        metadata: metadata || {},
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      return this.saveResource({ resource: newResource });
-    }
-    const updatedResource = {
-      ...existingResource,
-      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
-      metadata: {
-        ...existingResource.metadata,
-        ...metadata
-      },
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const tableName = this.getTableName(storage.TABLE_RESOURCES);
-    const updates = [];
-    const values = [];
-    let paramIndex = 1;
-    if (workingMemory !== void 0) {
-      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;
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
+  }
+  /**
+   * Workflows
+   */
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
+  async close() {
+    this.pgp.end();
+  }
+  /**
+   * Scorers
+   */
+  async getScoreById({ id: _id }) {
+    return this.stores.scores.getScoreById({ id: _id });
+  }
+  async getScoresByScorerId({
+    scorerId: _scorerId,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination });
+  }
+  async saveScore(_score) {
+    return this.stores.scores.saveScore(_score);
+  }
+  async getScoresByRunId({
+    runId: _runId,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId: _runId, pagination: _pagination });
+  }
+  async getScoresByEntityId({
+    entityId: _entityId,
+    entityType: _entityType,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({
+      entityId: _entityId,
+      entityType: _entityType,
+      pagination: _pagination
+    });
   }
 };