@mastra/pg 0.11.0 → 0.11.1-alpha.1

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var error = require('@mastra/core/error');
 var utils = require('@mastra/core/utils');
 var vector = require('@mastra/core/vector');
 var asyncMutex = require('async-mutex');
@@ -376,43 +377,57 @@ var PgVector = class extends vector.MastraVector {
     schemaName,
     pgPoolOptions
   }) {
-    if (!connectionString || connectionString.trim() === "") {
-      throw new Error(
-        "PgVector: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults."
-      );
-    }
-    super();
-    this.schema = schemaName;
-    const basePool = new pg__default.default.Pool({
-      connectionString,
-      max: 20,
-      // Maximum number of clients in the pool
-      idleTimeoutMillis: 3e4,
-      // Close idle connections after 30 seconds
-      connectionTimeoutMillis: 2e3,
-      // Fail fast if can't connect
-      ...pgPoolOptions
-    });
-    const telemetry = this.__getTelemetry();
-    this.pool = telemetry?.traceClass(basePool, {
-      spanNamePrefix: "pg-vector",
-      attributes: {
-        "vector.type": "postgres"
+    try {
+      if (!connectionString || connectionString.trim() === "") {
+        throw new Error(
+          "PgVector: connectionString must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults."
+        );
       }
-    }) ?? basePool;
-    void (async () => {
-      const existingIndexes = await this.listIndexes();
-      void existingIndexes.map(async (indexName) => {
-        const info = await this.getIndexInfo({ indexName });
-        const key = await this.getIndexCacheKey({
-          indexName,
-          metric: info.metric,
-          dimension: info.dimension,
-          type: info.type
-        });
-        this.createdIndexes.set(indexName, key);
+      super();
+      this.schema = schemaName;
+      const basePool = new pg__default.default.Pool({
+        connectionString,
+        max: 20,
+        // Maximum number of clients in the pool
+        idleTimeoutMillis: 3e4,
+        // Close idle connections after 30 seconds
+        connectionTimeoutMillis: 2e3,
+        // Fail fast if can't connect
+        ...pgPoolOptions
       });
-    })();
+      const telemetry = this.__getTelemetry();
+      this.pool = telemetry?.traceClass(basePool, {
+        spanNamePrefix: "pg-vector",
+        attributes: {
+          "vector.type": "postgres"
+        }
+      }) ?? basePool;
+      void (async () => {
+        const existingIndexes = await this.listIndexes();
+        void existingIndexes.map(async (indexName) => {
+          const info = await this.getIndexInfo({ indexName });
+          const key = await this.getIndexCacheKey({
+            indexName,
+            metric: info.metric,
+            dimension: info.dimension,
+            type: info.type
+          });
+          this.createdIndexes.set(indexName, key);
+        });
+      })();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_INITIALIZATION_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            schemaName: schemaName ?? ""
+          }
+        },
+        error$1
+      );
+    }
   }
   getMutexByName(indexName) {
     if (!this.mutexesByName.has(indexName)) this.mutexesByName.set(indexName, new asyncMutex.Mutex());
@@ -451,11 +466,27 @@ var PgVector = class extends vector.MastraVector {
     ef,
     probes
   }) {
-    if (!Number.isInteger(topK) || topK <= 0) {
-      throw new Error("topK must be a positive integer");
-    }
-    if (!Array.isArray(queryVector) || !queryVector.every((x) => typeof x === "number" && Number.isFinite(x))) {
-      throw new Error("queryVector must be an array of finite numbers");
+    try {
+      if (!Number.isInteger(topK) || topK <= 0) {
+        throw new Error("topK must be a positive integer");
+      }
+      if (!Array.isArray(queryVector) || !queryVector.every((x) => typeof x === "number" && Number.isFinite(x))) {
+        throw new Error("queryVector must be an array of finite numbers");
+      }
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_QUERY_INVALID_INPUT",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.USER,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
     const client = await this.pool.connect();
     try {
@@ -494,6 +525,20 @@ var PgVector = class extends vector.MastraVector {
         metadata,
         ...includeVector && embedding && { vector: JSON.parse(embedding) }
       }));
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -518,18 +563,43 @@ var PgVector = class extends vector.MastraVector {
       }
       await client.query("COMMIT");
       return vectorIds;
-    } catch (error) {
+    } catch (error$1) {
       await client.query("ROLLBACK");
-      if (error instanceof Error && error.message?.includes("expected") && error.message?.includes("dimensions")) {
-        const match = error.message.match(/expected (\d+) dimensions, not (\d+)/);
+      if (error$1 instanceof Error && error$1.message?.includes("expected") && error$1.message?.includes("dimensions")) {
+        const match = error$1.message.match(/expected (\d+) dimensions, not (\d+)/);
         if (match) {
           const [, expected, actual] = match;
-          throw new Error(
-            `Vector dimension mismatch: Index "${indexName}" expects ${expected} dimensions but got ${actual} dimensions. Either use a matching embedding model or delete and recreate the index with the new dimension.`
+          const mastraError2 = new error.MastraError(
+            {
+              id: "MASTRA_STORAGE_PG_VECTOR_UPSERT_INVALID_INPUT",
+              domain: error.ErrorDomain.MASTRA_VECTOR,
+              category: error.ErrorCategory.USER,
+              text: `Vector dimension mismatch: Index "${indexName}" expects ${expected} dimensions but got ${actual} dimensions. Either use a matching embedding model or delete and recreate the index with the new dimension.`,
+              details: {
+                indexName,
+                expected: expected ?? "",
+                actual: actual ?? ""
+              }
+            },
+            error$1
           );
+          this.logger?.trackException(mastraError2);
+          throw mastraError2;
         }
       }
-      throw error;
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -597,11 +667,27 @@ var PgVector = class extends vector.MastraVector {
     buildIndex = true
   }) {
     const { tableName } = this.getTableName(indexName);
-    if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
-      throw new Error("Invalid index name format");
-    }
-    if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
+    try {
+      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
+        throw new Error("Invalid index name format");
+      }
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_CREATE_INDEX_INVALID_INPUT",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.USER,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
     const indexCacheKey = await this.getIndexCacheKey({ indexName, dimension, type: indexConfig.type, metric });
     if (this.cachedIndexExists(indexName, indexCacheKey)) {
@@ -634,12 +720,40 @@ var PgVector = class extends vector.MastraVector {
       } finally {
         client.release();
       }
+    }).catch((error$1) => {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_CREATE_INDEX_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     });
   }
   async buildIndex({ indexName, metric = "cosine", indexConfig }) {
     const client = await this.pool.connect();
     try {
       await this.setupIndex({ indexName, metric, indexConfig }, client);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_BUILD_INDEX_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -736,6 +850,17 @@ var PgVector = class extends vector.MastraVector {
         `;
       const vectorTables = await client.query(vectorTablesQuery, [this.schema || "public"]);
       return vectorTables.rows.map((row) => row.table_name);
+    } catch (e) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        e
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -815,7 +940,19 @@ var PgVector = class extends vector.MastraVector {
       };
     } catch (e) {
       await client.query("ROLLBACK");
-      throw new Error(`Failed to describe vector table: ${e.message}`);
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        e
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -826,9 +963,21 @@ var PgVector = class extends vector.MastraVector {
       const { tableName } = this.getTableName(indexName);
       await client.query(`DROP TABLE IF EXISTS ${tableName} CASCADE`);
       this.createdIndexes.delete(indexName);
-    } catch (error) {
+    } catch (error$1) {
       await client.query("ROLLBACK");
-      throw new Error(`Failed to delete vector table: ${error.message}`);
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -840,7 +989,19 @@ var PgVector = class extends vector.MastraVector {
       await client.query(`TRUNCATE ${tableName}`);
     } catch (e) {
       await client.query("ROLLBACK");
-      throw new Error(`Failed to truncate vector table: ${e.message}`);
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_TRUNCATE_INDEX_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        e
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -859,11 +1020,12 @@ var PgVector = class extends vector.MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }) {
-    if (!update.vector && !update.metadata) {
-      throw new Error("No updates provided");
-    }
-    const client = await this.pool.connect();
+    let client;
     try {
+      if (!update.vector && !update.metadata) {
+        throw new Error("No updates provided");
+      }
+      client = await this.pool.connect();
       let updateParts = [];
       let values = [id];
       let valueIndex = 2;
@@ -886,10 +1048,23 @@ var PgVector = class extends vector.MastraVector {
         WHERE vector_id = $1
       `;
       await client.query(query, values);
-    } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            id
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
-      client.release();
+      client?.release();
     }
   }
   /**
@@ -900,18 +1075,32 @@ var PgVector = class extends vector.MastraVector {
    * @throws Will throw an error if the deletion operation fails.
    */
   async deleteVector({ indexName, id }) {
-    const client = await this.pool.connect();
+    let client;
     try {
+      client = await this.pool.connect();
       const { tableName } = this.getTableName(indexName);
       const query = `
         DELETE FROM ${tableName}
         WHERE vector_id = $1
       `;
       await client.query(query, [id]);
-    } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_VECTOR_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            id
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
-      client.release();
+      client?.release();
     }
   }
 };
@@ -922,35 +1111,46 @@ var PostgresStore = class extends storage.MastraStorage {
   setupSchemaPromise = null;
   schemaSetupComplete = void 0;
   constructor(config) {
-    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() === "") {
+    try {
+      if ("connectionString" in config) {
+        if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
           throw new Error(
-            `PostgresStore: ${key} must be provided and cannot be empty. Passing an empty string may cause fallback to local Postgres defaults.`
+            "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
+        }
+      );
+    } catch (e) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_INITIALIZATION_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        e
+      );
     }
-    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
-      }
-    );
   }
   get supports() {
     return {
@@ -1011,10 +1211,20 @@ var PostgresStore = class extends storage.MastraStorage {
         await this.insert({ tableName, record });
       }
       await this.db.query("COMMIT");
-    } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
+    } catch (error$1) {
       await this.db.query("ROLLBACK");
-      throw error;
+      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
+      );
     }
   }
   /**
@@ -1071,8 +1281,24 @@ var PostgresStore = class extends storage.MastraStorage {
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(storage.TABLE_TRACES)} ${whereClause}`;
-    const countResult = await this.db.one(countQuery, queryParams);
-    const total = parseInt(countResult.count, 10);
+    let total = 0;
+    try {
+      const countResult = await this.db.one(countQuery, queryParams);
+      total = parseInt(countResult.count, 10);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TOTAL_COUNT",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name ?? "",
+            scope: args.scope ?? ""
+          }
+        },
+        error$1
+      );
+    }
     if (total === 0) {
       return {
         traces: [],
@@ -1086,30 +1312,45 @@ var PostgresStore = class extends storage.MastraStorage {
       storage.TABLE_TRACES
     )} ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
     const finalQueryParams = [...queryParams, perPage, currentOffset];
-    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
-    }));
-    return {
-      traces,
-      total,
-      page,
-      perPage,
-      hasMore: currentOffset + traces.length < total
-    };
+    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
+      }));
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + traces.length < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TRACES",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name ?? "",
+            scope: args.scope ?? ""
+          }
+        },
+        error$1
+      );
+    }
   }
   async setupSchema() {
     if (!this.schema || this.schemaSetupComplete) {
@@ -1183,9 +1424,18 @@ var PostgresStore = class extends storage.MastraStorage {
         ` : ""}
       `;
       await this.db.none(sql);
-    } catch (error) {
-      console.error(`Error creating table ${tableName}:`, error);
-      throw error;
+    } 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
+      );
     }
   }
   getDefaultValue(type) {
@@ -1223,19 +1473,35 @@ var PostgresStore = class extends storage.MastraStorage {
           this.logger?.debug?.(`Ensured column ${parsedColumnName} exists in table ${fullTableName}`);
         }
       }
-    } catch (error) {
-      this.logger?.error?.(
-        `Error altering table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_ALTER_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
       );
-      throw new Error(`Failed to alter table ${tableName}: ${error}`);
     }
   }
   async clearTable({ tableName }) {
     try {
       await this.db.none(`TRUNCATE TABLE ${this.getTableName(tableName)} CASCADE`);
-    } catch (error) {
-      console.error(`Error clearing table ${tableName}:`, error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_CLEAR_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
     }
   }
   async insert({ tableName, record }) {
@@ -1247,9 +1513,18 @@ var PostgresStore = class extends storage.MastraStorage {
         `INSERT INTO ${this.getTableName(tableName)} (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
         values
       );
-    } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
     }
   }
   async load({ tableName, keys }) {
@@ -1272,9 +1547,18 @@ var PostgresStore = class extends storage.MastraStorage {
         return snapshot;
       }
       return result;
-    } catch (error) {
-      console.error(`Error loading from ${tableName}:`, error);
-      throw error;
+    } 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
+          }
+        },
+        error$1
+      );
     }
   }
   async getThreadById({ threadId }) {
@@ -1300,9 +1584,18 @@ var PostgresStore = class extends storage.MastraStorage {
         createdAt: thread.createdAt,
         updatedAt: thread.updatedAt
       };
-    } catch (error) {
-      console.error(`Error getting thread ${threadId}:`, error);
-      throw error;
+    } 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
+      );
     }
   }
   /**
@@ -1361,8 +1654,21 @@ var PostgresStore = class extends storage.MastraStorage {
         perPage,
         hasMore: currentOffset + threads.length < total
       };
-    } catch (error) {
-      this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId,
+            page
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
     }
   }
@@ -1393,9 +1699,18 @@ var PostgresStore = class extends storage.MastraStorage {
         ]
       );
       return thread;
-    } catch (error) {
-      console.error("Error saving thread:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_SAVE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: thread.id
+          }
+        },
+        error$1
+      );
     }
   }
   async updateThread({
@@ -1403,20 +1718,29 @@ var PostgresStore = class extends storage.MastraStorage {
     title,
     metadata
   }) {
+    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 existingThread = await this.getThreadById({ threadId: id });
-      if (!existingThread) {
-        throw new Error(`Thread ${id} not found`);
-      }
-      const mergedMetadata = {
-        ...existingThread.metadata,
-        ...metadata
-      };
       const thread = await this.db.one(
         `UPDATE ${this.getTableName(storage.TABLE_THREADS)}
         SET title = $1,
-            metadata = $2,
-            "updatedAt" = $3
+        metadata = $2,
+        "updatedAt" = $3
         WHERE id = $4
         RETURNING *`,
         [title, mergedMetadata, (/* @__PURE__ */ new Date()).toISOString(), id]
@@ -1427,9 +1751,19 @@ var PostgresStore = class extends storage.MastraStorage {
         createdAt: thread.createdAt,
         updatedAt: thread.updatedAt
       };
-    } catch (error) {
-      console.error("Error updating thread:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id,
+            title
+          }
+        },
+        error$1
+      );
     }
   }
   async deleteThread({ threadId }) {
@@ -1438,27 +1772,35 @@ var PostgresStore = class extends storage.MastraStorage {
         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]);
       });
-    } catch (error) {
-      console.error("Error deleting thread:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_DELETE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
     }
   }
-  async getMessages(args) {
-    const { threadId, format, selectBy } = args;
-    const selectStatement = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId"`;
-    const orderByStatement = `ORDER BY "createdAt" DESC`;
-    try {
-      let rows = [];
-      const include = selectBy?.include || [];
-      if (include.length) {
-        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(
-            `
+  async _getIncludedMessages({
+    threadId,
+    selectBy,
+    orderByStatement
+  }) {
+    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 
@@ -1490,34 +1832,45 @@ var PostgresStore = class extends storage.MastraStorage {
               )
             ) AS query_${paramIdx}
             `
-            // Keep ASC for final sorting after fetching context
-          );
-          params.push(searchId, id, withPreviousMessages, withNextMessages);
-          paramIdx += 4;
-        }
-        const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
-        const includedRows = await this.db.manyOrNone(finalQuery, params);
-        const seen = /* @__PURE__ */ new Set();
-        const dedupedRows = includedRows.filter((row) => {
-          if (seen.has(row.id)) return false;
-          seen.add(row.id);
-          return true;
-        });
-        rows = dedupedRows;
-      } else {
-        const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
-        if (limit === 0 && selectBy?.last !== false) ; else {
-          let query = `${selectStatement} FROM ${this.getTableName(
-            storage.TABLE_MESSAGES
-          )} WHERE thread_id = $1 ${orderByStatement}`;
-          const queryParams = [threadId];
-          if (limit !== void 0 && selectBy?.last !== false) {
-            query += ` LIMIT $2`;
-            queryParams.push(limit);
-          }
-          rows = await this.db.manyOrNone(query, queryParams);
+        // Keep ASC for final sorting after fetching context
+      );
+      params.push(searchId, id, withPreviousMessages, withNextMessages);
+      paramIdx += 4;
+    }
+    const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+    const includedRows = await this.db.manyOrNone(finalQuery, params);
+    const seen = /* @__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"`;
+    const orderByStatement = `ORDER BY "createdAt" DESC`;
+    const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+    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 {
@@ -1534,8 +1887,20 @@ var PostgresStore = class extends storage.MastraStorage {
       return format === "v2" ? sortedMessages.map(
         (m) => ({ ...m, content: m.content || { format: 2, parts: [{ type: "text", text: "" }] } })
       ) : sortedMessages;
-    } catch (error) {
-      this.logger.error("Error getting messages:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return [];
     }
   }
@@ -1546,6 +1911,13 @@ var PostgresStore = class extends storage.MastraStorage {
     const toDate = dateRange?.end;
     const selectStatement = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId"`;
     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);
+      }
+    }
     try {
       const perPage = perPageInput !== void 0 ? perPageInput : 40;
       const currentOffset = page * perPage;
@@ -1577,7 +1949,8 @@ var PostgresStore = class extends storage.MastraStorage {
         storage.TABLE_MESSAGES
       )} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
       const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
-      const list = new agent.MessageList().add(rows || [], "memory");
+      messages.push(...rows || []);
+      const list = new agent.MessageList().add(messages, "memory");
       const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
       return {
         messages: messagesToReturn,
@@ -1586,8 +1959,21 @@ var PostgresStore = class extends storage.MastraStorage {
         perPage,
         hasMore: currentOffset + rows.length < total
       };
-    } catch (error) {
-      this.logger.error("Error getting messages:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+            page
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
     }
   }
@@ -1596,15 +1982,28 @@ var PostgresStore = class extends storage.MastraStorage {
     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 {
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
-      }
-      const thread = await this.getThreadById({ threadId });
-      if (!thread) {
-        throw new Error(`Thread ${threadId} not found`);
-      }
       await this.db.tx(async (t) => {
         const messageInserts = messages.map((message) => {
           if (!message.threadId) {
@@ -1642,9 +2041,18 @@ var PostgresStore = class extends storage.MastraStorage {
       const list = new agent.MessageList().add(messages, "memory");
       if (format === `v2`) return list.get.all.v2();
       return list.get.all.v1();
-    } catch (error) {
-      console.error("Error saving messages:", error);
-      throw error;
+    } 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
+          }
+        },
+        error$1
+      );
     }
   }
   async persistWorkflowSnapshot({
@@ -1667,9 +2075,19 @@ var PostgresStore = class extends storage.MastraStorage {
             "updatedAt" = EXCLUDED."updatedAt"`,
         [workflowName, runId, JSON.stringify(snapshot), now, now]
       );
-    } catch (error) {
-      console.error("Error persisting workflow snapshot:", error);
-      throw error;
+    } 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,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
     }
   }
   async loadWorkflowSnapshot({
@@ -1688,9 +2106,19 @@ var PostgresStore = class extends storage.MastraStorage {
         return null;
       }
       return result.snapshot;
-    } catch (error) {
-      console.error("Error loading workflow snapshot:", error);
-      throw error;
+    } 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,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
     }
   }
   async hasColumn(table, column) {
@@ -1777,9 +2205,18 @@ var PostgresStore = class extends storage.MastraStorage {
         return this.parseWorkflowRun(row);
       });
       return { runs, total: total || runs.length };
-    } catch (error) {
-      console.error("Error getting workflow runs:", error);
-      throw error;
+    } 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 getWorkflowRunById({
@@ -1811,9 +2248,19 @@ var PostgresStore = class extends storage.MastraStorage {
         return null;
       }
       return this.parseWorkflowRun(result);
-    } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
+    } 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 || ""
+          }
+        },
+        error$1
+      );
     }
   }
   async close() {
@@ -1845,29 +2292,144 @@ var PostgresStore = class extends storage.MastraStorage {
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(storage.TABLE_EVALS)} ${whereClause}`;
-    const countResult = await this.db.one(countQuery, queryParams);
-    const total = parseInt(countResult.count, 10);
-    const currentOffset = page * perPage;
-    if (total === 0) {
+    try {
+      const countResult = await this.db.one(countQuery, queryParams);
+      const total = parseInt(countResult.count, 10);
+      const currentOffset = page * perPage;
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const dataQuery = `SELECT * FROM ${this.getTableName(
+        storage.TABLE_EVALS
+      )} ${whereClause} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
       return {
-        evals: [],
-        total: 0,
+        evals: rows?.map((row) => this.transformEvalRow(row)) ?? [],
+        total,
         page,
         perPage,
-        hasMore: false
+        hasMore: currentOffset + (rows?.length ?? 0) < total
       };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_EVALS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            agentName: agentName || "all",
+            type: type || "all",
+            page,
+            perPage
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
-    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]);
-    return {
-      evals: rows?.map((row) => this.transformEvalRow(row)) ?? [],
-      total,
-      page,
-      perPage,
-      hasMore: currentOffset + (rows?.length ?? 0) < total
-    };
+  }
+  async updateMessages({
+    messages
+  }) {
+    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 [];
+    }
+    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.db.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 ${this.getTableName(
+            storage.TABLE_MESSAGES
+          )} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
+          queries.push(t.none(sql, values));
+        }
+      }
+      if (threadIdsToUpdate.size > 0) {
+        queries.push(
+          t.none(`UPDATE ${this.getTableName(storage.TABLE_THREADS)} SET "updatedAt" = NOW() WHERE id IN ($1:list)`, [
+            Array.from(threadIdsToUpdate)
+          ])
+        );
+      }
+      if (queries.length > 0) {
+        await t.batch(queries);
+      }
+    });
+    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 {
+        }
+      }
+      return message;
+    });
   }
 };