@mastra/pg 0.11.1-alpha.0 → 0.11.1-alpha.2

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');
@@ -44,10 +45,10 @@ var PGFilterTranslator = class extends filter.BaseFilterTranslator {
     }
     const entries = Object.entries(node);
     const result = {};
-    if ("$options" in node && !("$regex" in node)) {
+    if (node && "$options" in node && !("$regex" in node)) {
       throw new Error("$options is not valid without $regex");
     }
-    if ("$regex" in node) {
+    if (node && "$regex" in node) {
       const options = node.$options || "";
       return withPath(this.translateRegexPattern(node.$regex, options));
     }
@@ -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,39 +1111,51 @@ 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 {
-      selectByIncludeResourceScope: true
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true
     };
   }
   getTableName(indexName) {
@@ -1011,10 +1212,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 +1282,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 +1313,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 +1425,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 +1474,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 +1514,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 +1548,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 +1585,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 +1655,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 +1700,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 +1719,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 +1752,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 +1773,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 +1833,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 +1888,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,8 +1912,15 @@ 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 perPage = perPageInput !== void 0 ? perPageInput : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
       const currentOffset = page * perPage;
       const conditions = [`thread_id = $1`];
       const queryParams = [threadId];
@@ -1564,7 +1937,7 @@ var PostgresStore = class extends storage.MastraStorage {
       const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(storage.TABLE_MESSAGES)} ${whereClause}`;
       const countResult = await this.db.one(countQuery, queryParams);
       const total = parseInt(countResult.count, 10);
-      if (total === 0) {
+      if (total === 0 && messages.length === 0) {
         return {
           messages: [],
           total: 0,
@@ -1573,11 +1946,15 @@ var PostgresStore = class extends storage.MastraStorage {
           hasMore: false
         };
       }
+      const excludeIds = messages.map((m) => m.id);
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + paramIndex}`).join(", ");
+      paramIndex += excludeIds.length;
       const dataQuery = `${selectStatement} FROM ${this.getTableName(
         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");
+      )} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""}${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, ...excludeIds, perPage, currentOffset]);
+      messages.push(...rows || []);
+      const list = new agent.MessageList().add(messages, "memory");
       const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
       return {
         messages: messagesToReturn,
@@ -1586,8 +1963,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 +1986,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) {
@@ -1619,7 +2022,13 @@ var PostgresStore = class extends storage.MastraStorage {
           }
           return t.none(
             `INSERT INTO ${this.getTableName(storage.TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type, "resourceId") 
-             VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+             VALUES ($1, $2, $3, $4, $5, $6, $7)
+             ON CONFLICT (id) DO UPDATE SET
+              thread_id = EXCLUDED.thread_id,
+              content = EXCLUDED.content,
+              role = EXCLUDED.role,
+              type = EXCLUDED.type,
+              "resourceId" = EXCLUDED."resourceId"`,
             [
               message.id,
               message.threadId,
@@ -1642,9 +2051,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 +2085,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 +2116,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 +2215,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 +2258,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 +2302,49 @@ 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
@@ -1964,6 +2441,82 @@ var PostgresStore = class extends storage.MastraStorage {
       return message;
     });
   }
+  async getResourceById({ resourceId }) {
+    const tableName = this.getTableName(storage.TABLE_RESOURCES);
+    const result = await this.db.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [
+      resourceId
+    ]);
+    if (!result) {
+      return null;
+    }
+    return {
+      ...result,
+      // Ensure workingMemory is always returned as a string, regardless of automatic parsing
+      workingMemory: typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
+      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
+    };
+  }
+  async saveResource({ resource }) {
+    const tableName = this.getTableName(storage.TABLE_RESOURCES);
+    await this.db.none(
+      `INSERT INTO ${tableName} (id, "workingMemory", metadata, "createdAt", "updatedAt") 
+       VALUES ($1, $2, $3, $4, $5)`,
+      [
+        resource.id,
+        resource.workingMemory,
+        JSON.stringify(resource.metadata),
+        resource.createdAt.toISOString(),
+        resource.updatedAt.toISOString()
+      ]
+    );
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const existingResource = await this.getResourceById({ resourceId });
+    if (!existingResource) {
+      const newResource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      return this.saveResource({ resource: newResource });
+    }
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const tableName = this.getTableName(storage.TABLE_RESOURCES);
+    const updates = [];
+    const values = [];
+    let paramIndex = 1;
+    if (workingMemory !== void 0) {
+      updates.push(`"workingMemory" = $${paramIndex}`);
+      values.push(workingMemory);
+      paramIndex++;
+    }
+    if (metadata) {
+      updates.push(`metadata = $${paramIndex}`);
+      values.push(JSON.stringify(updatedResource.metadata));
+      paramIndex++;
+    }
+    updates.push(`"updatedAt" = $${paramIndex}`);
+    values.push(updatedResource.updatedAt.toISOString());
+    paramIndex++;
+    values.push(resourceId);
+    await this.db.none(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = $${paramIndex}`, values);
+    return updatedResource;
+  }
 };
 
 // src/vector/prompt.ts