@mastra/pg 0.11.0 → 0.11.1-alpha.1

package/dist/index.js

@@ -1,3 +1,4 @@
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
 import { MastraVector } from '@mastra/core/vector';
 import { Mutex } from 'async-mutex';
@@ -368,43 +369,57 @@ var PgVector = class extends 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.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.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) {
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_INITIALIZATION_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            schemaName: schemaName ?? ""
+          }
+        },
+        error
+      );
+    }
   }
   getMutexByName(indexName) {
     if (!this.mutexesByName.has(indexName)) this.mutexesByName.set(indexName, new Mutex());
@@ -443,11 +458,27 @@ var PgVector = class extends 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) {
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_QUERY_INVALID_INPUT",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.USER,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
     const client = await this.pool.connect();
     try {
@@ -486,6 +517,20 @@ var PgVector = class extends MastraVector {
         metadata,
         ...includeVector && embedding && { vector: JSON.parse(embedding) }
       }));
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_QUERY_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -516,12 +561,37 @@ var PgVector = class extends MastraVector {
         const match = error.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 MastraError(
+            {
+              id: "MASTRA_STORAGE_PG_VECTOR_UPSERT_INVALID_INPUT",
+              domain: ErrorDomain.MASTRA_VECTOR,
+              category: 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
           );
+          this.logger?.trackException(mastraError2);
+          throw mastraError2;
         }
       }
-      throw error;
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_UPSERT_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -589,11 +659,27 @@ var PgVector = class extends 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) {
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_CREATE_INDEX_INVALID_INPUT",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.USER,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
     const indexCacheKey = await this.getIndexCacheKey({ indexName, dimension, type: indexConfig.type, metric });
     if (this.cachedIndexExists(indexName, indexCacheKey)) {
@@ -626,12 +712,40 @@ var PgVector = class extends MastraVector {
       } finally {
         client.release();
       }
+    }).catch((error) => {
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_CREATE_INDEX_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+      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) {
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_BUILD_INDEX_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -728,6 +842,17 @@ var PgVector = class extends MastraVector {
         `;
       const vectorTables = await client.query(vectorTablesQuery, [this.schema || "public"]);
       return vectorTables.rows.map((row) => row.table_name);
+    } catch (e) {
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_LIST_INDEXES_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        e
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -807,7 +932,19 @@ var PgVector = class extends MastraVector {
       };
     } catch (e) {
       await client.query("ROLLBACK");
-      throw new Error(`Failed to describe vector table: ${e.message}`);
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        e
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -820,7 +957,19 @@ var PgVector = class extends MastraVector {
       this.createdIndexes.delete(indexName);
     } catch (error) {
       await client.query("ROLLBACK");
-      throw new Error(`Failed to delete vector table: ${error.message}`);
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_INDEX_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -832,7 +981,19 @@ var PgVector = class extends 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 MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_TRUNCATE_INDEX_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        e
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
       client.release();
     }
@@ -851,11 +1012,12 @@ var PgVector = class extends 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;
@@ -879,9 +1041,22 @@ var PgVector = class extends MastraVector {
       `;
       await client.query(query, values);
     } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index: ${indexName}: ${error.message}`);
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            id
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
-      client.release();
+      client?.release();
     }
   }
   /**
@@ -892,8 +1067,9 @@ var PgVector = class extends 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}
@@ -901,9 +1077,22 @@ var PgVector = class extends MastraVector {
       `;
       await client.query(query, [id]);
     } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index: ${indexName}: ${error.message}`);
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_VECTOR_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            id
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     } finally {
-      client.release();
+      client?.release();
     }
   }
 };
@@ -914,35 +1103,46 @@ var PostgresStore = class extends 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();
+      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 MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_INITIALIZATION_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        e
+      );
     }
-    super({ name: "PostgresStore" });
-    this.pgp = pgPromise();
-    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 {
@@ -1004,9 +1204,19 @@ var PostgresStore = class extends MastraStorage {
       }
       await this.db.query("COMMIT");
     } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
       await this.db.query("ROLLBACK");
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_BATCH_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: records.length
+          }
+        },
+        error
+      );
     }
   }
   /**
@@ -1063,8 +1273,24 @@ var PostgresStore = class extends MastraStorage {
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(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) {
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TOTAL_COUNT",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name ?? "",
+            scope: args.scope ?? ""
+          }
+        },
+        error
+      );
+    }
     if (total === 0) {
       return {
         traces: [],
@@ -1078,30 +1304,45 @@ var PostgresStore = class extends MastraStorage {
       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) {
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TRACES",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name ?? "",
+            scope: args.scope ?? ""
+          }
+        },
+        error
+      );
+    }
   }
   async setupSchema() {
     if (!this.schema || this.schemaSetupComplete) {
@@ -1176,8 +1417,17 @@ var PostgresStore = class extends MastraStorage {
       `;
       await this.db.none(sql);
     } catch (error) {
-      console.error(`Error creating table ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_CREATE_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
     }
   }
   getDefaultValue(type) {
@@ -1216,18 +1466,34 @@ var PostgresStore = class extends MastraStorage {
         }
       }
     } catch (error) {
-      this.logger?.error?.(
-        `Error altering table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_ALTER_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
       );
-      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;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_CLEAR_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
     }
   }
   async insert({ tableName, record }) {
@@ -1240,8 +1506,17 @@ var PostgresStore = class extends MastraStorage {
         values
       );
     } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
     }
   }
   async load({ tableName, keys }) {
@@ -1265,8 +1540,17 @@ var PostgresStore = class extends MastraStorage {
       }
       return result;
     } catch (error) {
-      console.error(`Error loading from ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_LOAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
     }
   }
   async getThreadById({ threadId }) {
@@ -1293,8 +1577,17 @@ var PostgresStore = class extends MastraStorage {
         updatedAt: thread.updatedAt
       };
     } catch (error) {
-      console.error(`Error getting thread ${threadId}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_THREAD_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error
+      );
     }
   }
   /**
@@ -1354,7 +1647,20 @@ var PostgresStore = class extends MastraStorage {
         hasMore: currentOffset + threads.length < total
       };
     } catch (error) {
-      this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId,
+            page
+          }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
     }
   }
@@ -1386,8 +1692,17 @@ var PostgresStore = class extends MastraStorage {
       );
       return thread;
     } catch (error) {
-      console.error("Error saving thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_SAVE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: thread.id
+          }
+        },
+        error
+      );
     }
   }
   async updateThread({
@@ -1395,20 +1710,29 @@ var PostgresStore = class extends MastraStorage {
     title,
     metadata
   }) {
+    const existingThread = await this.getThreadById({ threadId: id });
+    if (!existingThread) {
+      throw new MastraError({
+        id: "MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Thread ${id} not found`,
+        details: {
+          threadId: id,
+          title
+        }
+      });
+    }
+    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(TABLE_THREADS)}
         SET title = $1,
-            metadata = $2,
-            "updatedAt" = $3
+        metadata = $2,
+        "updatedAt" = $3
         WHERE id = $4
         RETURNING *`,
         [title, mergedMetadata, (/* @__PURE__ */ new Date()).toISOString(), id]
@@ -1420,8 +1744,18 @@ var PostgresStore = class extends MastraStorage {
         updatedAt: thread.updatedAt
       };
     } catch (error) {
-      console.error("Error updating thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_UPDATE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id,
+            title
+          }
+        },
+        error
+      );
     }
   }
   async deleteThread({ threadId }) {
@@ -1431,26 +1765,34 @@ var PostgresStore = class extends MastraStorage {
         await t.none(`DELETE FROM ${this.getTableName(TABLE_THREADS)} WHERE id = $1`, [threadId]);
       });
     } catch (error) {
-      console.error("Error deleting thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_DELETE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error
+      );
     }
   }
-  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 
@@ -1482,34 +1824,45 @@ var PostgresStore = class extends 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(
-            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(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 {
@@ -1527,7 +1880,19 @@ var PostgresStore = class extends MastraStorage {
         (m) => ({ ...m, content: m.content || { format: 2, parts: [{ type: "text", text: "" }] } })
       ) : sortedMessages;
     } catch (error) {
-      this.logger.error("Error getting messages:", error);
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return [];
     }
   }
@@ -1538,6 +1903,13 @@ var PostgresStore = class extends 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;
@@ -1569,7 +1941,8 @@ var PostgresStore = class extends MastraStorage {
         TABLE_MESSAGES
       )} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
       const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
-      const list = new MessageList().add(rows || [], "memory");
+      messages.push(...rows || []);
+      const list = new MessageList().add(messages, "memory");
       const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
       return {
         messages: messagesToReturn,
@@ -1579,7 +1952,20 @@ var PostgresStore = class extends MastraStorage {
         hasMore: currentOffset + rows.length < total
       };
     } catch (error) {
-      this.logger.error("Error getting messages:", error);
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+            page
+          }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
     }
   }
@@ -1588,15 +1974,28 @@ var PostgresStore = class extends MastraStorage {
     format
   }) {
     if (messages.length === 0) return messages;
+    const threadId = messages[0]?.threadId;
+    if (!threadId) {
+      throw new MastraError({
+        id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        text: `Thread ID is required`
+      });
+    }
+    const thread = await this.getThreadById({ threadId });
+    if (!thread) {
+      throw new MastraError({
+        id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        text: `Thread ${threadId} not found`,
+        details: {
+          threadId
+        }
+      });
+    }
     try {
-      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) {
@@ -1635,8 +2034,17 @@ var PostgresStore = class extends MastraStorage {
       if (format === `v2`) return list.get.all.v2();
       return list.get.all.v1();
     } catch (error) {
-      console.error("Error saving messages:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_SAVE_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error
+      );
     }
   }
   async persistWorkflowSnapshot({
@@ -1660,8 +2068,18 @@ var PostgresStore = class extends MastraStorage {
         [workflowName, runId, JSON.stringify(snapshot), now, now]
       );
     } catch (error) {
-      console.error("Error persisting workflow snapshot:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error
+      );
     }
   }
   async loadWorkflowSnapshot({
@@ -1681,8 +2099,18 @@ var PostgresStore = class extends MastraStorage {
       }
       return result.snapshot;
     } catch (error) {
-      console.error("Error loading workflow snapshot:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error
+      );
     }
   }
   async hasColumn(table, column) {
@@ -1770,8 +2198,17 @@ var PostgresStore = class extends MastraStorage {
       });
       return { runs, total: total || runs.length };
     } catch (error) {
-      console.error("Error getting workflow runs:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUNS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName: workflowName || "all"
+          }
+        },
+        error
+      );
     }
   }
   async getWorkflowRunById({
@@ -1804,8 +2241,18 @@ var PostgresStore = class extends MastraStorage {
       }
       return this.parseWorkflowRun(result);
     } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            runId,
+            workflowName: workflowName || ""
+          }
+        },
+        error
+      );
     }
   }
   async close() {
@@ -1837,29 +2284,144 @@ var PostgresStore = class extends MastraStorage {
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(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(
+        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) {
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_STORE_GET_EVALS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            agentName: agentName || "all",
+            type: type || "all",
+            page,
+            perPage
+          }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
-    const dataQuery = `SELECT * FROM ${this.getTableName(
-      TABLE_EVALS
-    )} ${whereClause} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-    const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
-    return {
-      evals: rows?.map((row) => this.transformEvalRow(row)) ?? [],
-      total,
-      page,
-      perPage,
-      hasMore: currentOffset + (rows?.length ?? 0) < total
-    };
+  }
+  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(
+      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(
+            TABLE_MESSAGES
+          )} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
+          queries.push(t.none(sql, values));
+        }
+      }
+      if (threadIdsToUpdate.size > 0) {
+        queries.push(
+          t.none(`UPDATE ${this.getTableName(TABLE_THREADS)} SET "updatedAt" = NOW() WHERE id IN ($1:list)`, [
+            Array.from(threadIdsToUpdate)
+          ])
+        );
+      }
+      if (queries.length > 0) {
+        await t.batch(queries);
+      }
+    });
+    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;
+    });
   }
 };