@mastra/pg 1.9.0 → 1.9.1-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @mastra/pg
 
+## 1.9.1-alpha.1
+
+### Patch Changes
+
+- Fixed vector similarity queries to leverage HNSW and IVFFlat indexes. When querying without filters on an HNSW or IVFFlat-indexed table, ORDER BY and LIMIT are now placed inside the CTE so PostgreSQL can use the index for faster approximate nearest neighbor searches instead of scanning all rows. ([#14574](https://github.com/mastra-ai/mastra/pull/14574))
+
+- Fixed vector operations failing when pgvector extension is installed in a custom schema. The search_path is now set before index creation and vector similarity queries, ensuring operator classes (e.g. vector_cosine_ops) and distance operators (e.g. <=>) resolve correctly regardless of where the extension is installed. Previously, only table creation set the search_path, causing CREATE INDEX and query operations to fail with unresolvable operator errors. ([#14526](https://github.com/mastra-ai/mastra/pull/14526))
+
+- Added `entityVersionId`, `parentEntityVersionId`, and `rootEntityVersionId` columns to observability storage tables (spans, metrics, scores, feedback, logs) for filtering and grouping traces by entity version. Added ALTER TABLE migrations for existing databases. Added `targetType`, `targetId`, `agentVersion`, and `status` filters to `listExperiments`, and `traceId` and `status` filters to `listExperimentResults`. ([#15317](https://github.com/mastra-ai/mastra/pull/15317))
+
+- Updated dependencies [[`cbdf3e1`](https://github.com/mastra-ai/mastra/commit/cbdf3e12b3d0c30a6e5347be658e2009648c130a), [`8fe46d3`](https://github.com/mastra-ai/mastra/commit/8fe46d354027f3f0f0846e64219772348de106dd), [`18c67db`](https://github.com/mastra-ai/mastra/commit/18c67dbb9c9ebc26f26f65f7d3ff836e5691ef46), [`8dcc77e`](https://github.com/mastra-ai/mastra/commit/8dcc77e78a5340f5848f74b9e9f1b3da3513c1f5), [`aa67fc5`](https://github.com/mastra-ai/mastra/commit/aa67fc59ee8a5eeff1f23eb05970b8d7a536c8ff), [`fa8140b`](https://github.com/mastra-ai/mastra/commit/fa8140bcd4251d2e3ac85fdc5547dfc4f372b5be), [`190f452`](https://github.com/mastra-ai/mastra/commit/190f45258b0640e2adfc8219fa3258cdc5b8f071), [`7e7bf60`](https://github.com/mastra-ai/mastra/commit/7e7bf606886bf374a6f9d4ca9b09dd83d0533372), [`184907d`](https://github.com/mastra-ai/mastra/commit/184907d775d8609c03c26e78ccaf37315f3aa287), [`0c4cd13`](https://github.com/mastra-ai/mastra/commit/0c4cd131931c04ac5405373c932a242dbe88edd6), [`b16a753`](https://github.com/mastra-ai/mastra/commit/b16a753d5748440248d7df82e29bb987a9c8386c)]:
+  - @mastra/core@1.25.0-alpha.3
+
+## 1.9.1-alpha.0
+
+### Patch Changes
+
+- Fixed `batchInsert` and `batchUpdate` in `@mastra/pg` to run on a single Postgres transaction connection. ([#15312](https://github.com/mastra-ai/mastra/pull/15312))
+
+  This prevents pooled `BEGIN`/`COMMIT`/`ROLLBACK` calls from landing on different connections and leaving idle transactions open during batch writes.
+
+- Fixed "column does not exist" errors when using experiment review features on databases created before the review pipeline was introduced. Startup now automatically migrates older experiment tables to the latest schema. ([#15304](https://github.com/mastra-ai/mastra/pull/15304))
+
 ## 1.9.0
 
 ### Minor Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-pg
 description: Documentation for @mastra/pg. Use when working with @mastra/pg APIs, configuration, or implementation.
 metadata:
   package: "@mastra/pg"
-  version: "1.9.0"
+  version: "1.9.1-alpha.1"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.9.0",
+  "version": "1.9.1-alpha.1",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-memory-storage.md

@@ -118,8 +118,6 @@ export const agent = new Agent({
 })
 ```
 
-> **Warning:** Agent-level storage isn't supported when using [Mastra Cloud Store](https://mastra.ai/docs/mastra-cloud/deployment). If you use Mastra Cloud Store, configure storage on the Mastra instance instead. This limitation doesn't apply if you bring your own database.
-
 ## Threads and resources
 
 Mastra organizes conversations using two identifiers:

package/dist/docs/references/docs-memory-working-memory.md

@@ -397,4 +397,4 @@ const response = await agent.generate('What do you know about me?', {
 
 - [Working memory with template](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-template)
 - [Working memory with schema](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-schema)
-- [Per-resource working memory](https://github.com/mastra-ai/mastra/tree/main/examples/memory-per-resource-example) - Complete example showing resource-scoped memory persistence
+- [Per-resource working memory](https://github.com/mastra-ai/mastra/tree/main/examples/memory-per-resource-example): Complete example showing resource-scoped memory persistence

package/dist/index.cjs

@@ -734,6 +734,25 @@ var PgVector = class extends vector.MastraVector {
       return null;
     }
   }
+  /**
+   * Sets search_path on the client connection so that vector operators (e.g. <=>, vector_cosine_ops)
+   * are resolvable when the pgvector extension is installed in a non-default schema.
+   *
+   * PostgreSQL's default search_path is ("$user", public). If the extension lives in a custom schema
+   * (e.g. "myapp"), operator classes and distance operators won't resolve without this.
+   */
+  async ensureSearchPath(client) {
+    if (!this.vectorExtensionSchema) {
+      await this.detectVectorExtensionSchema(client);
+    }
+    if (this.vectorExtensionSchema && this.vectorExtensionSchema !== "public" && this.vectorExtensionSchema !== "pg_catalog") {
+      const schemas = /* @__PURE__ */ new Set();
+      schemas.add(this.vectorExtensionSchema);
+      if (this.schema) schemas.add(this.schema);
+      schemas.add("public");
+      await client.query(`SET search_path TO ${[...schemas].map((s) => `"${s}"`).join(", ")}`);
+    }
+  }
   /**
    * Checks if the installed pgvector version supports halfvec type.
    * halfvec was introduced in pgvector 0.7.0.
@@ -947,6 +966,7 @@ var PgVector = class extends vector.MastraVector {
     }
     const client = await this.pool.connect();
     try {
+      await this.ensureSearchPath(client);
       await client.query("BEGIN");
       const translatedFilter = this.transformFilter(filter);
       const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter, minScore, topK);
@@ -966,7 +986,23 @@ var PgVector = class extends vector.MastraVector {
       const qualifiedVectorType = this.getVectorTypeName(indexInfo.vectorType, indexInfo.dimension);
       const distanceExpr = `embedding ${ops.distanceOperator} '${vectorStr}'::${qualifiedVectorType}`;
       const scoreExpr = ops.scoreExpr(distanceExpr);
-      const query = `
+      const hasFilter = filterQuery.trim().length > 0;
+      const useIndexedOrder = indexInfo.type === "hnsw" && !hasFilter && minScore <= 0;
+      const query = useIndexedOrder ? `
+        WITH vector_scores AS (
+          SELECT
+            vector_id as id,
+            ${scoreExpr} as score,
+            metadata
+            ${includeVector ? ", embedding" : ""}
+          FROM ${tableName}
+          ORDER BY ${distanceExpr}
+          LIMIT $2
+        )
+        SELECT *
+        FROM vector_scores
+        WHERE score > $1
+        ORDER BY score DESC` : `
         WITH vector_scores AS (
           SELECT
             vector_id as id,
@@ -1019,6 +1055,7 @@ var PgVector = class extends vector.MastraVector {
     const { tableName } = this.getTableName(indexName);
     const client = await this.pool.connect();
     try {
+      await this.ensureSearchPath(client);
       await client.query("BEGIN");
       if (deleteFilter) {
         this.logger?.debug(`Deleting vectors matching filter before upsert`, { indexName, deleteFilter });
@@ -1269,9 +1306,6 @@ var PgVector = class extends vector.MastraVector {
             }
           });
         }
-        if (this.schema && this.vectorExtensionSchema && this.schema !== this.vectorExtensionSchema && this.vectorExtensionSchema !== "pg_catalog") {
-          await client.query(`SET search_path TO ${this.getSchemaName()}, "${this.vectorExtensionSchema}"`);
-        }
         const qualifiedVectorType = this.getVectorTypeName(vectorType);
         await client.query(`
           CREATE TABLE IF NOT EXISTS ${tableName} (
@@ -1414,6 +1448,7 @@ var PgVector = class extends vector.MastraVector {
         this.describeIndexCache.delete(indexName);
         return;
       }
+      await this.ensureSearchPath(client);
       const effectiveVectorType = existingIndexInfo?.vectorType ?? vectorType;
       const metricOp = this.getVectorOps(effectiveVectorType, metric).operatorClass;
       let indexSQL;
@@ -1764,6 +1799,7 @@ var PgVector = class extends vector.MastraVector {
         });
       }
       client = await this.pool.connect();
+      await this.ensureSearchPath(client);
       const { tableName } = this.getTableName(indexName);
       const indexInfo = await this.getIndexInfo({ indexName });
       const qualifiedVectorType = this.getVectorTypeName(indexInfo.vectorType, indexInfo.dimension);
@@ -2002,6 +2038,7 @@ var PoolAdapter = class {
   constructor($pool) {
     this.$pool = $pool;
   }
+  $pool;
   connect() {
     return this.$pool.connect();
   }
@@ -2070,6 +2107,7 @@ var TransactionClient = class {
   constructor(client) {
     this.client = client;
   }
+  client;
   async none(query, values) {
     await this.client.query(query, values);
     return null;
@@ -2499,36 +2537,39 @@ var PgDB = class extends base.MastraBase {
         return storage.getDefaultValue(type);
     }
   }
-  async insert({ tableName, record }) {
-    try {
-      this.addTimestampZColumns(record);
-      const filteredRecord = await this.filterRecordToKnownColumns(tableName, record);
-      const schemaName = getSchemaName(this.schemaName);
-      const columns = Object.keys(filteredRecord).map((col) => utils.parseSqlIdentifier(col, "column name"));
-      if (columns.length === 0) return;
-      const values = this.prepareValuesForInsert(filteredRecord, tableName);
-      const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
-      const fullTableName = getTableName({ indexName: tableName, schemaName });
-      const columnList = columns.map((c) => `"${c}"`).join(", ");
-      if (tableName === storage.TABLE_SPANS) {
-        const updateColumns = columns.filter((c) => c !== "traceId" && c !== "spanId");
-        if (updateColumns.length > 0) {
-          const updateClause = updateColumns.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ");
-          await this.client.none(
-            `INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})
+  async executeInsert(client, { tableName, record }) {
+    this.addTimestampZColumns(record);
+    const filteredRecord = await this.filterRecordToKnownColumns(tableName, record);
+    const schemaName = getSchemaName(this.schemaName);
+    const columns = Object.keys(filteredRecord).map((col) => utils.parseSqlIdentifier(col, "column name"));
+    if (columns.length === 0) return;
+    const values = this.prepareValuesForInsert(filteredRecord, tableName);
+    const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+    const fullTableName = getTableName({ indexName: tableName, schemaName });
+    const columnList = columns.map((c) => `"${c}"`).join(", ");
+    if (tableName === storage.TABLE_SPANS) {
+      const updateColumns = columns.filter((c) => c !== "traceId" && c !== "spanId");
+      if (updateColumns.length > 0) {
+        const updateClause = updateColumns.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ");
+        await client.none(
+          `INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})
              ON CONFLICT ("traceId", "spanId") DO UPDATE SET ${updateClause}`,
-            values
-          );
-        } else {
-          await this.client.none(
-            `INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})
-             ON CONFLICT ("traceId", "spanId") DO NOTHING`,
-            values
-          );
-        }
+          values
+        );
       } else {
-        await this.client.none(`INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})`, values);
+        await client.none(
+          `INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})
+             ON CONFLICT ("traceId", "spanId") DO NOTHING`,
+          values
+        );
       }
+    } else {
+      await client.none(`INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})`, values);
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      await this.executeInsert(this.client, { tableName, record });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -3003,13 +3044,12 @@ Note: This migration may take some time for large tables.
   }
   async batchInsert({ tableName, records }) {
     try {
-      await this.client.query("BEGIN");
-      for (const record of records) {
-        await this.insert({ tableName, record });
-      }
-      await this.client.query("COMMIT");
+      await this.client.tx(async (tx) => {
+        for (const record of records) {
+          await this.executeInsert(tx, { tableName, record });
+        }
+      });
     } catch (error$1) {
-      await this.client.query("ROLLBACK");
       throw new error.MastraError(
         {
           id: storage.createStorageErrorId("PG", "BATCH_INSERT", "FAILED"),
@@ -3287,30 +3327,7 @@ Note: This migration may take some time for large tables.
     data
   }) {
     try {
-      const filteredData = await this.filterRecordToKnownColumns(tableName, data);
-      if (Object.keys(filteredData).length === 0) return;
-      const setColumns = [];
-      const setValues = [];
-      let paramIndex = 1;
-      Object.entries(filteredData).forEach(([key, value]) => {
-        const parsedKey = utils.parseSqlIdentifier(key, "column name");
-        setColumns.push(`"${parsedKey}" = $${paramIndex++}`);
-        setValues.push(this.prepareValue(value, key, tableName));
-      });
-      const whereConditions = [];
-      const whereValues = [];
-      Object.entries(keys).forEach(([key, value]) => {
-        const parsedKey = utils.parseSqlIdentifier(key, "column name");
-        whereConditions.push(`"${parsedKey}" = $${paramIndex++}`);
-        whereValues.push(this.prepareValue(value, key, tableName));
-      });
-      const tableName_ = getTableName({
-        indexName: tableName,
-        schemaName: getSchemaName(this.schemaName)
-      });
-      const sql = `UPDATE ${tableName_} SET ${setColumns.join(", ")} WHERE ${whereConditions.join(" AND ")}`;
-      const values = [...setValues, ...whereValues];
-      await this.client.none(sql, values);
+      await this.executeUpdate(this.client, { tableName, keys, data });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -3330,13 +3347,12 @@ Note: This migration may take some time for large tables.
     updates
   }) {
     try {
-      await this.client.query("BEGIN");
-      for (const { keys, data } of updates) {
-        await this.update({ tableName, keys, data });
-      }
-      await this.client.query("COMMIT");
+      await this.client.tx(async (tx) => {
+        for (const { keys, data } of updates) {
+          await this.executeUpdate(tx, { tableName, keys, data });
+        }
+      });
     } catch (error$1) {
-      await this.client.query("ROLLBACK");
       throw new error.MastraError(
         {
           id: storage.createStorageErrorId("PG", "BATCH_UPDATE", "FAILED"),
@@ -3395,6 +3411,36 @@ Note: This migration may take some time for large tables.
   async deleteData({ tableName }) {
     return this.clearTable({ tableName });
   }
+  async executeUpdate(client, {
+    tableName,
+    keys,
+    data
+  }) {
+    const filteredData = await this.filterRecordToKnownColumns(tableName, data);
+    if (Object.keys(filteredData).length === 0) return;
+    const setColumns = [];
+    const setValues = [];
+    let paramIndex = 1;
+    Object.entries(filteredData).forEach(([key, value]) => {
+      const parsedKey = utils.parseSqlIdentifier(key, "column name");
+      setColumns.push(`"${parsedKey}" = $${paramIndex++}`);
+      setValues.push(this.prepareValue(value, key, tableName));
+    });
+    const whereConditions = [];
+    const whereValues = [];
+    Object.entries(keys).forEach(([key, value]) => {
+      const parsedKey = utils.parseSqlIdentifier(key, "column name");
+      whereConditions.push(`"${parsedKey}" = $${paramIndex++}`);
+      whereValues.push(this.prepareValue(value, key, tableName));
+    });
+    const tableName_ = getTableName({
+      indexName: tableName,
+      schemaName: getSchemaName(this.schemaName)
+    });
+    const sql = `UPDATE ${tableName_} SET ${setColumns.join(", ")} WHERE ${whereConditions.join(" AND ")}`;
+    const values = [...setValues, ...whereValues];
+    await client.none(sql, values);
+  }
 };
 function getSchemaName2(schema) {
   return schema ? `"${utils.parseSqlIdentifier(schema, "schema name")}"` : void 0;
@@ -5308,6 +5354,16 @@ var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
   async init() {
     await this.#db.createTable({ tableName: storage.TABLE_EXPERIMENTS, schema: storage.EXPERIMENTS_SCHEMA });
     await this.#db.createTable({ tableName: storage.TABLE_EXPERIMENT_RESULTS, schema: storage.EXPERIMENT_RESULTS_SCHEMA });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_EXPERIMENTS,
+      schema: storage.EXPERIMENTS_SCHEMA,
+      ifNotExists: ["agentVersion"]
+    });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_EXPERIMENT_RESULTS,
+      schema: storage.EXPERIMENT_RESULTS_SCHEMA,
+      ifNotExists: ["status", "tags"]
+    });
     await this.createDefaultIndexes();
     await this.createCustomIndexes();
   }
@@ -5547,6 +5603,22 @@ var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
         conditions.push(`"datasetId" = $${paramIndex++}`);
         queryParams.push(args.datasetId);
       }
+      if (args.targetType) {
+        conditions.push(`"targetType" = $${paramIndex++}`);
+        queryParams.push(args.targetType);
+      }
+      if (args.targetId) {
+        conditions.push(`"targetId" = $${paramIndex++}`);
+        queryParams.push(args.targetId);
+      }
+      if (args.agentVersion) {
+        conditions.push(`"agentVersion" = $${paramIndex++}`);
+        queryParams.push(args.agentVersion);
+      }
+      if (args.status) {
+        conditions.push(`"status" = $${paramIndex++}`);
+        queryParams.push(args.status);
+      }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       const countResult = await this.#db.client.one(
         `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`,
@@ -5735,9 +5807,21 @@ var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
     try {
       const { page, perPage: perPageInput } = args.pagination;
       const tableName = getTableName2({ indexName: storage.TABLE_EXPERIMENT_RESULTS, schemaName: getSchemaName2(this.#schema) });
+      const conditions = ['"experimentId" = $1'];
+      const queryParams = [args.experimentId];
+      let paramIndex = 2;
+      if (args.traceId) {
+        conditions.push(`"traceId" = $${paramIndex++}`);
+        queryParams.push(args.traceId);
+      }
+      if (args.status) {
+        conditions.push(`"status" = $${paramIndex++}`);
+        queryParams.push(args.status);
+      }
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
       const countResult = await this.#db.client.one(
-        `SELECT COUNT(*) as count FROM ${tableName} WHERE "experimentId" = $1`,
-        [args.experimentId]
+        `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`,
+        queryParams
       );
       const total = parseInt(countResult.count, 10);
       if (total === 0) {
@@ -5747,8 +5831,8 @@ var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
       const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const limitValue = perPageInput === false ? total : perPage;
       const rows = await this.#db.client.manyOrNone(
-        `SELECT * FROM ${tableName} WHERE "experimentId" = $1 ORDER BY "startedAt" ASC LIMIT $2 OFFSET $3`,
-        [args.experimentId, limitValue, offset]
+        `SELECT * FROM ${tableName} ${whereClause} ORDER BY "startedAt" ASC LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+        [...queryParams, limitValue, offset]
       );
       return {
         results: (rows || []).map((row) => this.transformExperimentResultRow(row)),