@mastra/pg 1.0.0-beta.1 → 1.0.0-beta.3

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @mastra/pg
 
+## 1.0.0-beta.3
+
+### Patch Changes
+
+- fix(pg): qualify vector type to fix schema lookup ([#10786](https://github.com/mastra-ai/mastra/pull/10786))
+
+- feat(storage): support querying messages from multiple threads ([#10663](https://github.com/mastra-ai/mastra/pull/10663))
+  - Fixed TypeScript errors where `threadId: string | string[]` was being passed to places expecting `Scalar` type
+  - Added proper multi-thread support for `listMessages` across all adapters when `threadId` is an array
+  - Updated `_getIncludedMessages` to look up message threadId by ID (since message IDs are globally unique)
+  - **upstash**: Added `msg-idx:{messageId}` index for O(1) message lookups (backwards compatible with fallback to scan for old messages, with automatic backfill)
+
+- fix: ensure score responses match saved payloads for Mastra Stores. ([#10557](https://github.com/mastra-ai/mastra/pull/10557))
+
+- Unify transformScoreRow functions across storage adapters ([#10648](https://github.com/mastra-ai/mastra/pull/10648))
+
+  Added a unified `transformScoreRow` function in `@mastra/core/storage` that provides schema-driven row transformation for score data. This eliminates code duplication across 10 storage adapters while maintaining store-specific behavior through configurable options:
+  - `preferredTimestampFields`: Preferred source fields for timestamps (PostgreSQL, Cloudflare D1)
+  - `convertTimestamps`: Convert timestamp strings to Date objects (MSSQL, MongoDB, ClickHouse)
+  - `nullValuePattern`: Skip values matching pattern (ClickHouse's `'_null_'`)
+  - `fieldMappings`: Map source column names to schema fields (LibSQL's `additionalLLMContext`)
+
+  Each store adapter now uses the unified function with appropriate options, reducing ~200 lines of duplicate transformation logic while ensuring consistent behavior across all storage backends.
+
+- Updated dependencies [[`ac0d2f4`](https://github.com/mastra-ai/mastra/commit/ac0d2f4ff8831f72c1c66c2be809706d17f65789), [`1a0d3fc`](https://github.com/mastra-ai/mastra/commit/1a0d3fc811482c9c376cdf79ee615c23bae9b2d6), [`85a628b`](https://github.com/mastra-ai/mastra/commit/85a628b1224a8f64cd82ea7f033774bf22df7a7e), [`c237233`](https://github.com/mastra-ai/mastra/commit/c23723399ccedf7f5744b3f40997b79246bfbe64), [`15f9e21`](https://github.com/mastra-ai/mastra/commit/15f9e216177201ea6e3f6d0bfb063fcc0953444f), [`ff94dea`](https://github.com/mastra-ai/mastra/commit/ff94dea935f4e34545c63bcb6c29804732698809), [`5b2ff46`](https://github.com/mastra-ai/mastra/commit/5b2ff4651df70c146523a7fca773f8eb0a2272f8), [`db41688`](https://github.com/mastra-ai/mastra/commit/db4168806d007417e2e60b4f68656dca4e5f40c9), [`5ca599d`](https://github.com/mastra-ai/mastra/commit/5ca599d0bb59a1595f19f58473fcd67cc71cef58), [`bff1145`](https://github.com/mastra-ai/mastra/commit/bff114556b3cbadad9b2768488708f8ad0e91475), [`5c8ca24`](https://github.com/mastra-ai/mastra/commit/5c8ca247094e0cc2cdbd7137822fb47241f86e77), [`e191844`](https://github.com/mastra-ai/mastra/commit/e1918444ca3f80e82feef1dad506cd4ec6e2875f), [`22553f1`](https://github.com/mastra-ai/mastra/commit/22553f11c63ee5e966a9c034a349822249584691), [`7237163`](https://github.com/mastra-ai/mastra/commit/72371635dbf96a87df4b073cc48fc655afbdce3d), [`2500740`](https://github.com/mastra-ai/mastra/commit/2500740ea23da067d6e50ec71c625ab3ce275e64), [`873ecbb`](https://github.com/mastra-ai/mastra/commit/873ecbb517586aa17d2f1e99283755b3ebb2863f), [`4f9bbe5`](https://github.com/mastra-ai/mastra/commit/4f9bbe5968f42c86f4930b8193de3c3c17e5bd36), [`02e51fe`](https://github.com/mastra-ai/mastra/commit/02e51feddb3d4155cfbcc42624fd0d0970d032c0), [`8f3fa3a`](https://github.com/mastra-ai/mastra/commit/8f3fa3a652bb77da092f913ec51ae46e3a7e27dc), [`cd29ad2`](https://github.com/mastra-ai/mastra/commit/cd29ad23a255534e8191f249593849ed29160886), [`bdf4d8c`](https://github.com/mastra-ai/mastra/commit/bdf4d8cdc656d8a2c21d81834bfa3bfa70f56c16), [`854e3da`](https://github.com/mastra-ai/mastra/commit/854e3dad5daac17a91a20986399d3a51f54bf68b), [`ce18d38`](https://github.com/mastra-ai/mastra/commit/ce18d38678c65870350d123955014a8432075fd9), [`cccf9c8`](https://github.com/mastra-ai/mastra/commit/cccf9c8b2d2dfc1a5e63919395b83d78c89682a0), [`61a5705`](https://github.com/mastra-ai/mastra/commit/61a570551278b6743e64243b3ce7d73de915ca8a), [`db70a48`](https://github.com/mastra-ai/mastra/commit/db70a48aeeeeb8e5f92007e8ede52c364ce15287), [`f0fdc14`](https://github.com/mastra-ai/mastra/commit/f0fdc14ee233d619266b3d2bbdeea7d25cfc6d13), [`db18bc9`](https://github.com/mastra-ai/mastra/commit/db18bc9c3825e2c1a0ad9a183cc9935f6691bfa1), [`9b37b56`](https://github.com/mastra-ai/mastra/commit/9b37b565e1f2a76c24f728945cc740c2b09be9da), [`41a23c3`](https://github.com/mastra-ai/mastra/commit/41a23c32f9877d71810f37e24930515df2ff7a0f), [`5d171ad`](https://github.com/mastra-ai/mastra/commit/5d171ad9ef340387276b77c2bb3e83e83332d729), [`f03ae60`](https://github.com/mastra-ai/mastra/commit/f03ae60500fe350c9d828621006cdafe1975fdd8), [`d1e74a0`](https://github.com/mastra-ai/mastra/commit/d1e74a0a293866dece31022047f5dbab65a304d0), [`39e7869`](https://github.com/mastra-ai/mastra/commit/39e7869bc7d0ee391077ce291474d8a84eedccff), [`5761926`](https://github.com/mastra-ai/mastra/commit/57619260c4a2cdd598763abbacd90de594c6bc76), [`c900fdd`](https://github.com/mastra-ai/mastra/commit/c900fdd504c41348efdffb205cfe80d48c38fa33), [`604a79f`](https://github.com/mastra-ai/mastra/commit/604a79fecf276e26a54a3fe01bb94e65315d2e0e), [`887f0b4`](https://github.com/mastra-ai/mastra/commit/887f0b4746cdbd7cb7d6b17ac9f82aeb58037ea5), [`2562143`](https://github.com/mastra-ai/mastra/commit/256214336b4faa78646c9c1776612393790d8784), [`ef11a61`](https://github.com/mastra-ai/mastra/commit/ef11a61920fa0ed08a5b7ceedd192875af119749)]:
+  - @mastra/core@1.0.0-beta.6
+
+## 1.0.0-beta.2
+
+### Patch Changes
+
+- Add new deleteVectors, updateVector by filter ([#10408](https://github.com/mastra-ai/mastra/pull/10408))
+
+- Updated dependencies [[`21a15de`](https://github.com/mastra-ai/mastra/commit/21a15de369fe82aac26bb642ed7be73505475e8b), [`feb7ee4`](https://github.com/mastra-ai/mastra/commit/feb7ee4d09a75edb46c6669a3beaceec78811747), [`b0e2ea5`](https://github.com/mastra-ai/mastra/commit/b0e2ea5b52c40fae438b9e2f7baee6f0f89c5442), [`c456e01`](https://github.com/mastra-ai/mastra/commit/c456e0149e3c176afcefdbd9bb1d2c5917723725), [`ab035c2`](https://github.com/mastra-ai/mastra/commit/ab035c2ef6d8cc7bb25f06f1a38508bd9e6f126b), [`1a46a56`](https://github.com/mastra-ai/mastra/commit/1a46a566f45a3fcbadc1cf36bf86d351f264bfa3), [`3cf540b`](https://github.com/mastra-ai/mastra/commit/3cf540b9fbfea8f4fc8d3a2319a4e6c0b0cbfd52), [`1c6ce51`](https://github.com/mastra-ai/mastra/commit/1c6ce51f875915ab57fd36873623013699a2a65d), [`898a972`](https://github.com/mastra-ai/mastra/commit/898a9727d286c2510d6b702dfd367e6aaf5c6b0f), [`a97003a`](https://github.com/mastra-ai/mastra/commit/a97003aa1cf2f4022a41912324a1e77263b326b8), [`ccc141e`](https://github.com/mastra-ai/mastra/commit/ccc141ed27da0abc3a3fc28e9e5128152e8e37f4), [`fe3b897`](https://github.com/mastra-ai/mastra/commit/fe3b897c2ccbcd2b10e81b099438c7337feddf89), [`00123ba`](https://github.com/mastra-ai/mastra/commit/00123ba96dc9e5cd0b110420ebdba56d8f237b25), [`29c4309`](https://github.com/mastra-ai/mastra/commit/29c4309f818b24304c041bcb4a8f19b5f13f6b62), [`16785ce`](https://github.com/mastra-ai/mastra/commit/16785ced928f6f22638f4488cf8a125d99211799), [`de8239b`](https://github.com/mastra-ai/mastra/commit/de8239bdcb1d8c0cfa06da21f1569912a66bbc8a), [`b5e6cd7`](https://github.com/mastra-ai/mastra/commit/b5e6cd77fc8c8e64e0494c1d06cee3d84e795d1e), [`3759cb0`](https://github.com/mastra-ai/mastra/commit/3759cb064935b5f74c65ac2f52a1145f7352899d), [`651e772`](https://github.com/mastra-ai/mastra/commit/651e772eb1475fb13e126d3fcc01751297a88214), [`b61b93f`](https://github.com/mastra-ai/mastra/commit/b61b93f9e058b11dd2eec169853175d31dbdd567), [`bae33d9`](https://github.com/mastra-ai/mastra/commit/bae33d91a63fbb64d1e80519e1fc1acaed1e9013), [`c0b731f`](https://github.com/mastra-ai/mastra/commit/c0b731fb27d712dc8582e846df5c0332a6a0c5ba), [`43ca8f2`](https://github.com/mastra-ai/mastra/commit/43ca8f2c7334851cc7b4d3d2f037d8784bfbdd5f), [`2ca67cc`](https://github.com/mastra-ai/mastra/commit/2ca67cc3bb1f6a617353fdcab197d9efebe60d6f), [`9e67002`](https://github.com/mastra-ai/mastra/commit/9e67002b52c9be19936c420a489dbee9c5fd6a78), [`35edc49`](https://github.com/mastra-ai/mastra/commit/35edc49ac0556db609189641d6341e76771b81fc)]:
+  - @mastra/core@1.0.0-beta.5
+
 ## 1.0.0-beta.1
 
 ### Patch Changes

package/README.md

@@ -327,6 +327,9 @@ The system automatically detects configuration changes and only rebuilds indexes
 - `buildIndex({indexName, metric?, indexConfig?})`: Build or rebuild vector index
 - `upsert({indexName, vectors, metadata?, ids?})`: Add or update vectors
 - `query({indexName, queryVector, topK?, filter?, includeVector?, minScore?})`: Search for similar vectors
+- `updateVector({ indexName, id?, filter?, update })`: Update a single vector by ID or metadata filter
+- `deleteVector({ indexName, id })`: Delete a single vector by ID
+- `deleteVectors({ indexName, ids?, filter? })`: Delete multiple vectors by IDs or metadata filter
 - `listIndexes()`: List all vector-enabled tables
 - `describeIndex(indexName)`: Get table statistics and index configuration
 - `deleteIndex(indexName)`: Delete a table

package/dist/index.cjs

@@ -152,12 +152,20 @@ var createBasicOperator = (symbol) => {
   };
 };
 var createNumericOperator = (symbol) => {
-  return (key, paramIndex) => {
+  return (key, paramIndex, value) => {
     const jsonPathKey = parseJsonPathKey(key);
-    return {
-      sql: `(metadata#>>'{${jsonPathKey}}')::numeric ${symbol} $${paramIndex}`,
-      needsValue: true
-    };
+    const isNumeric = typeof value === "number" || typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "";
+    if (isNumeric) {
+      return {
+        sql: `(metadata#>>'{${jsonPathKey}}')::numeric ${symbol} $${paramIndex}::numeric`,
+        needsValue: true
+      };
+    } else {
+      return {
+        sql: `metadata#>>'{${jsonPathKey}}' ${symbol} $${paramIndex}::text`,
+        needsValue: true
+      };
+    }
   };
 };
 function buildElemMatchConditions(value, paramIndex) {
@@ -338,6 +346,83 @@ var parseJsonPathKey = (key) => {
 function escapeLikePattern(str) {
   return str.replace(/([%_\\])/g, "\\$1");
 }
+function buildDeleteFilterQuery(filter) {
+  const values = [];
+  function buildCondition(key, value, parentPath) {
+    if (["$and", "$or", "$not", "$nor"].includes(key)) {
+      return handleLogicalOperator(key, value);
+    }
+    if (!value || typeof value !== "object") {
+      values.push(value);
+      return `metadata#>>'{${parseJsonPathKey(key)}}' = $${values.length}`;
+    }
+    const [[operator, operatorValue] = []] = Object.entries(value);
+    if (operator === "$not") {
+      const entries = Object.entries(operatorValue);
+      const conditions2 = entries.map(([nestedOp, nestedValue]) => {
+        if (!FILTER_OPERATORS[nestedOp]) {
+          throw new Error(`Invalid operator in $not condition: ${nestedOp}`);
+        }
+        const operatorFn2 = FILTER_OPERATORS[nestedOp];
+        const operatorResult2 = operatorFn2(key, values.length + 1, nestedValue);
+        if (operatorResult2.needsValue) {
+          values.push(nestedValue);
+        }
+        return operatorResult2.sql;
+      }).join(" AND ");
+      return `NOT (${conditions2})`;
+    }
+    const operatorFn = FILTER_OPERATORS[operator];
+    const operatorResult = operatorFn(key, values.length + 1, operatorValue);
+    if (operatorResult.needsValue) {
+      const transformedValue = operatorResult.transformValue ? operatorResult.transformValue() : operatorValue;
+      if (Array.isArray(transformedValue) && operator === "$elemMatch") {
+        values.push(...transformedValue);
+      } else {
+        values.push(transformedValue);
+      }
+    }
+    return operatorResult.sql;
+  }
+  function handleLogicalOperator(key, value, parentPath) {
+    if (key === "$not") {
+      const entries = Object.entries(value);
+      const conditions3 = entries.map(([fieldKey, fieldValue]) => buildCondition(fieldKey, fieldValue)).join(" AND ");
+      return `NOT (${conditions3})`;
+    }
+    if (!value || value.length === 0) {
+      switch (key) {
+        case "$and":
+        case "$nor":
+          return "true";
+        // Empty $and/$nor match everything
+        case "$or":
+          return "false";
+        // Empty $or matches nothing
+        default:
+          return "true";
+      }
+    }
+    const joinOperator = key === "$or" || key === "$nor" ? "OR" : "AND";
+    const conditions2 = value.map((f) => {
+      const entries = Object.entries(f || {});
+      if (entries.length === 0) return "";
+      const [firstKey, firstValue] = entries[0] || [];
+      if (["$and", "$or", "$not", "$nor"].includes(firstKey)) {
+        return buildCondition(firstKey, firstValue);
+      }
+      return entries.map(([k, v]) => buildCondition(k, v)).join(` ${joinOperator} `);
+    });
+    const joined = conditions2.join(` ${joinOperator} `);
+    const operatorFn = FILTER_OPERATORS[key];
+    return operatorFn(joined, 0, value).sql;
+  }
+  if (!filter) {
+    return { sql: "", values };
+  }
+  const conditions = Object.entries(filter).map(([key, value]) => buildCondition(key, value)).filter(Boolean).join(" AND ");
+  return { sql: conditions ? `WHERE ${conditions}` : "", values };
+}
 function buildFilterQuery(filter, minScore, topK) {
   const values = [minScore, topK];
   function buildCondition(key, value, parentPath) {
@@ -537,9 +622,6 @@ var PgVector = class extends vector.MastraVector {
       if (this.vectorExtensionSchema === "pg_catalog") {
         return "vector";
       }
-      if (this.vectorExtensionSchema === (this.schema || "public")) {
-        return "vector";
-      }
       const validatedSchema = utils.parseSqlIdentifier(this.vectorExtensionSchema, "vector extension schema");
       return `${validatedSchema}.vector`;
     }
@@ -659,11 +741,31 @@ var PgVector = class extends vector.MastraVector {
       client.release();
     }
   }
-  async upsert({ indexName, vectors, metadata, ids }) {
+  async upsert({
+    indexName,
+    vectors,
+    metadata,
+    ids,
+    deleteFilter
+  }) {
     const { tableName } = this.getTableName(indexName);
     const client = await this.pool.connect();
     try {
       await client.query("BEGIN");
+      if (deleteFilter) {
+        this.logger?.debug(`Deleting vectors matching filter before upsert`, { indexName, deleteFilter });
+        const translatedFilter = this.transformFilter(deleteFilter);
+        const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(translatedFilter);
+        const whereClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
+        if (whereClause) {
+          const deleteQuery = `DELETE FROM ${tableName} WHERE ${whereClause}`;
+          const result = await client.query(deleteQuery, filterValues);
+          this.logger?.debug(`Deleted ${result.rowCount || 0} vectors before upsert`, {
+            indexName,
+            deletedCount: result.rowCount || 0
+          });
+        }
+      }
       const vectorIds = ids || vectors.map(() => crypto.randomUUID());
       const vectorType = this.getVectorTypeName();
       for (let i = 0; i < vectors.length; i++) {
@@ -679,6 +781,11 @@ var PgVector = class extends vector.MastraVector {
         await client.query(query, [vectorIds[i], `[${vectors[i]?.join(",")}]`, JSON.stringify(metadata?.[i] || {})]);
       }
       await client.query("COMMIT");
+      this.logger?.debug(`Upserted ${vectors.length} vectors to ${indexName}`, {
+        indexName,
+        vectorCount: vectors.length,
+        hadDeleteFilter: !!deleteFilter
+      });
       return vectorIds;
     } catch (error$1) {
       await client.query("ROLLBACK");
@@ -1236,17 +1343,36 @@ var PgVector = class extends vector.MastraVector {
    * @returns A promise that resolves when the update is complete.
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
-  async updateVector({ indexName, id, update }) {
+  async updateVector({ indexName, id, filter, update }) {
     let client;
     try {
       if (!update.vector && !update.metadata) {
         throw new Error("No updates provided");
       }
+      if (!id && !filter) {
+        throw new error.MastraError({
+          id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_MISSING_PARAMS",
+          text: "Either id or filter must be provided",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        });
+      }
+      if (id && filter) {
+        throw new error.MastraError({
+          id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_CONFLICTING_PARAMS",
+          text: "Cannot provide both id and filter - they are mutually exclusive",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        });
+      }
       client = await this.pool.connect();
-      let updateParts = [];
-      let values = [id];
-      let valueIndex = 2;
+      const { tableName } = this.getTableName(indexName);
       const vectorType = this.getVectorTypeName();
+      let updateParts = [];
+      let values = [];
+      let valueIndex = 1;
       if (update.vector) {
         updateParts.push(`embedding = $${valueIndex}::${vectorType}`);
         values.push(`[${update.vector.join(",")}]`);
@@ -1255,18 +1381,60 @@ var PgVector = class extends vector.MastraVector {
       if (update.metadata) {
         updateParts.push(`metadata = $${valueIndex}::jsonb`);
         values.push(JSON.stringify(update.metadata));
+        valueIndex++;
       }
       if (updateParts.length === 0) {
         return;
       }
-      const { tableName } = this.getTableName(indexName);
+      let whereClause;
+      let whereValues;
+      if (id) {
+        whereClause = `vector_id = $${valueIndex}`;
+        whereValues = [id];
+      } else {
+        if (!filter || Object.keys(filter).length === 0) {
+          throw new error.MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_EMPTY_FILTER",
+            text: "Cannot update with empty filter",
+            domain: error.ErrorDomain.MASTRA_VECTOR,
+            category: error.ErrorCategory.USER,
+            details: { indexName }
+          });
+        }
+        const translatedFilter = this.transformFilter(filter);
+        const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(translatedFilter);
+        whereClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
+        if (!whereClause) {
+          throw new error.MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_INVALID_FILTER",
+            text: "Filter produced empty WHERE clause",
+            domain: error.ErrorDomain.MASTRA_VECTOR,
+            category: error.ErrorCategory.USER,
+            details: { indexName, filter: JSON.stringify(filter) }
+          });
+        }
+        whereClause = whereClause.replace(/\$(\d+)/g, (match, num) => {
+          const newIndex = parseInt(num) + valueIndex - 1;
+          return `$${newIndex}`;
+        });
+        whereValues = filterValues;
+      }
       const query = `
         UPDATE ${tableName}
         SET ${updateParts.join(", ")}
-        WHERE vector_id = $1
+        WHERE ${whereClause}
       `;
-      await client.query(query, values);
+      const result = await client.query(query, [...values, ...whereValues]);
+      this.logger?.info(`Updated ${result.rowCount || 0} vectors in ${indexName}`, {
+        indexName,
+        id: id ? id : void 0,
+        filter: filter ? filter : void 0,
+        updatedCount: result.rowCount || 0
+      });
     } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
       const mastraError = new error.MastraError(
         {
           id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_VECTOR_FAILED",
@@ -1274,7 +1442,8 @@ var PgVector = class extends vector.MastraVector {
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
             indexName,
-            id
+            ...id && { id },
+            ...filter && { filter: JSON.stringify(filter) }
           }
         },
         error$1
@@ -1321,6 +1490,106 @@ var PgVector = class extends vector.MastraVector {
       client?.release();
     }
   }
+  /**
+   * Delete vectors matching a metadata filter.
+   * @param indexName - The name of the index containing the vectors.
+   * @param filter - The filter to match vectors for deletion.
+   * @returns A promise that resolves when the deletion is complete.
+   * @throws Will throw an error if the deletion operation fails.
+   */
+  async deleteVectors({ indexName, filter, ids }) {
+    let client;
+    try {
+      client = await this.pool.connect();
+      const { tableName } = this.getTableName(indexName);
+      if (!filter && !ids) {
+        throw new error.MastraError({
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_MISSING_PARAMS",
+          text: "Either filter or ids must be provided",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        });
+      }
+      if (filter && ids) {
+        throw new error.MastraError({
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_CONFLICTING_PARAMS",
+          text: "Cannot provide both filter and ids - they are mutually exclusive",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        });
+      }
+      let query;
+      let values;
+      if (ids) {
+        if (ids.length === 0) {
+          throw new error.MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_DELETE_EMPTY_IDS",
+            text: "Cannot delete with empty ids array",
+            domain: error.ErrorDomain.MASTRA_VECTOR,
+            category: error.ErrorCategory.USER,
+            details: { indexName }
+          });
+        }
+        const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
+        query = `DELETE FROM ${tableName} WHERE vector_id IN (${placeholders})`;
+        values = ids;
+      } else {
+        if (!filter || Object.keys(filter).length === 0) {
+          throw new error.MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_DELETE_EMPTY_FILTER",
+            text: "Cannot delete with empty filter. Use deleteIndex to delete all vectors.",
+            domain: error.ErrorDomain.MASTRA_VECTOR,
+            category: error.ErrorCategory.USER,
+            details: { indexName }
+          });
+        }
+        const translatedFilter = this.transformFilter(filter);
+        const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(translatedFilter);
+        const whereClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
+        if (!whereClause) {
+          throw new error.MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_DELETE_INVALID_FILTER",
+            text: "Filter produced empty WHERE clause",
+            domain: error.ErrorDomain.MASTRA_VECTOR,
+            category: error.ErrorCategory.USER,
+            details: { indexName, filter: JSON.stringify(filter) }
+          });
+        }
+        query = `DELETE FROM ${tableName} WHERE ${whereClause}`;
+        values = filterValues;
+      }
+      const result = await client.query(query, values);
+      this.logger?.info(`Deleted ${result.rowCount || 0} vectors from ${indexName}`, {
+        indexName,
+        filter: filter ? filter : void 0,
+        ids: ids ? ids : void 0,
+        deletedCount: result.rowCount || 0
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_VECTORS_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            ...filter && { filter: JSON.stringify(filter) },
+            ...ids && { idsCount: ids.length }
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
+    } finally {
+      client?.release();
+    }
+  }
 };
 function getSchemaName(schema) {
   return schema ? `"${utils.parseSqlIdentifier(schema, "schema name")}"` : void 0;
@@ -1642,6 +1911,20 @@ var MemoryPG = class extends storage.MemoryStorage {
       const threadTableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
       await this.client.tx(async (t) => {
         await t.none(`DELETE FROM ${tableName} WHERE thread_id = $1`, [threadId]);
+        const schemaName = this.schema || "public";
+        const vectorTables = await t.manyOrNone(
+          `
+          SELECT tablename 
+          FROM pg_tables 
+          WHERE schemaname = $1 
+          AND (tablename = 'memory_messages' OR tablename LIKE 'memory_messages_%')
+        `,
+          [schemaName]
+        );
+        for (const { tablename } of vectorTables) {
+          const vectorTableName = getTableName({ indexName: tablename, schemaName: getSchemaName(this.schema) });
+          await t.none(`DELETE FROM ${vectorTableName} WHERE metadata->>'thread_id' = $1`, [threadId]);
+        }
         await t.none(`DELETE FROM ${threadTableName} WHERE id = $1`, [threadId]);
       });
     } catch (error$1) {
@@ -1658,28 +1941,26 @@ var MemoryPG = class extends storage.MemoryStorage {
       );
     }
   }
-  async _getIncludedMessages({
-    threadId,
-    include
-  }) {
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    if (!include) return null;
+  async _getIncludedMessages({ include }) {
+    if (!include || include.length === 0) return null;
     const unionQueries = [];
     const params = [];
     let paramIdx = 1;
     const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
     for (const inc of include) {
       const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const searchId = inc.threadId || threadId;
       unionQueries.push(
         `
             SELECT * FROM (
-              WITH ordered_messages AS (
+              WITH target_thread AS (
+                SELECT thread_id FROM ${tableName} WHERE id = $${paramIdx}
+              ),
+              ordered_messages AS (
                 SELECT 
                   *,
                   ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
                 FROM ${tableName}
-                WHERE thread_id = $${paramIdx}
+                WHERE thread_id = (SELECT thread_id FROM target_thread)
               )
               SELECT
                 m.id,
@@ -1691,24 +1972,24 @@ var MemoryPG = class extends storage.MemoryStorage {
                 m.thread_id AS "threadId",
                 m."resourceId"
               FROM ordered_messages m
-              WHERE m.id = $${paramIdx + 1}
+              WHERE m.id = $${paramIdx}
               OR EXISTS (
                 SELECT 1 FROM ordered_messages target
-                WHERE target.id = $${paramIdx + 1}
+                WHERE target.id = $${paramIdx}
                 AND (
                   -- Get previous messages (messages that come BEFORE the target)
-                  (m.row_num < target.row_num AND m.row_num >= target.row_num - $${paramIdx + 2})
+                  (m.row_num < target.row_num AND m.row_num >= target.row_num - $${paramIdx + 1})
                   OR
                   -- Get next messages (messages that come AFTER the target)
-                  (m.row_num > target.row_num AND m.row_num <= target.row_num + $${paramIdx + 3})
+                  (m.row_num > target.row_num AND m.row_num <= target.row_num + $${paramIdx + 2})
                 )
               )
             ) AS query_${paramIdx}
             `
         // Keep ASC for final sorting after fetching context
       );
-      params.push(searchId, id, withPreviousMessages, withNextMessages);
-      paramIdx += 4;
+      params.push(id, withPreviousMessages, withNextMessages);
+      paramIdx += 3;
     }
     const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
     const includedRows = await this.client.manyOrNone(finalQuery, params);
@@ -1772,15 +2053,18 @@ var MemoryPG = class extends storage.MemoryStorage {
   }
   async listMessages(args) {
     const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
+    const threadIds = (Array.isArray(threadId) ? threadId : [threadId]).filter(
+      (id) => typeof id === "string"
+    );
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
       throw new error.MastraError(
         {
           id: "STORAGE_PG_LIST_MESSAGES_INVALID_THREAD_ID",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { threadId: Array.isArray(threadId) ? String(threadId) : String(threadId) }
         },
-        new Error("threadId must be a non-empty string")
+        new Error("threadId must be a non-empty string or array of non-empty strings")
       );
     }
     if (page < 0) {
@@ -1790,7 +2074,7 @@ var MemoryPG = class extends storage.MemoryStorage {
         category: error.ErrorCategory.USER,
         text: "Page number must be non-negative",
         details: {
-          threadId,
+          threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
           page
         }
       });
@@ -1802,9 +2086,10 @@ var MemoryPG = class extends storage.MemoryStorage {
       const orderByStatement = `ORDER BY "${field}" ${direction}`;
       const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
       const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
-      const conditions = [`thread_id = $1`];
-      const queryParams = [threadId];
-      let paramIndex = 2;
+      const threadPlaceholders = threadIds.map((_, i) => `$${i + 1}`).join(", ");
+      const conditions = [`thread_id IN (${threadPlaceholders})`];
+      const queryParams = [...threadIds];
+      let paramIndex = threadIds.length + 1;
       if (resourceId) {
         conditions.push(`"resourceId" = $${paramIndex++}`);
         queryParams.push(resourceId);
@@ -1836,7 +2121,7 @@ var MemoryPG = class extends storage.MemoryStorage {
       }
       const messageIds = new Set(messages.map((m) => m.id));
       if (include && include.length > 0) {
-        const includeMessages = await this._getIncludedMessages({ threadId, include });
+        const includeMessages = await this._getIncludedMessages({ include });
         if (includeMessages) {
           for (const includeMsg of includeMessages) {
             if (!messageIds.has(includeMsg.id)) {
@@ -1863,7 +2148,10 @@ var MemoryPG = class extends storage.MemoryStorage {
         }
         return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
       });
-      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const threadIdSet = new Set(threadIds);
+      const returnedThreadMessageIds = new Set(
+        finalMessages.filter((m) => m.threadId && threadIdSet.has(m.threadId)).map((m) => m.id)
+      );
       const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
       const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total;
       return {
@@ -1880,7 +2168,7 @@ var MemoryPG = class extends storage.MemoryStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
             resourceId: resourceId ?? ""
           }
         },
@@ -3335,20 +3623,12 @@ var StoreOperationsPG = class extends storage.StoreOperations {
   }
 };
 function transformScoreRow(row) {
-  return {
-    ...row,
-    input: storage.safelyParseJSON(row.input),
-    scorer: storage.safelyParseJSON(row.scorer),
-    preprocessStepResult: storage.safelyParseJSON(row.preprocessStepResult),
-    analyzeStepResult: storage.safelyParseJSON(row.analyzeStepResult),
-    metadata: storage.safelyParseJSON(row.metadata),
-    output: storage.safelyParseJSON(row.output),
-    additionalContext: storage.safelyParseJSON(row.additionalContext),
-    requestContext: storage.safelyParseJSON(row.requestContext),
-    entity: storage.safelyParseJSON(row.entity),
-    createdAt: row.createdAtZ || row.createdAt,
-    updatedAt: row.updatedAtZ || row.updatedAt
-  };
+  return storage.transformScoreRow(row, {
+    preferredTimestampFields: {
+      createdAt: "createdAtZ",
+      updatedAt: "updatedAtZ"
+    }
+  });
 }
 var ScoresPG = class extends storage.ScoresStorage {
   client;
@@ -3495,8 +3775,6 @@ var ScoresPG = class extends storage.ScoresStorage {
           scorer: scorer ? JSON.stringify(scorer) : null,
           preprocessStepResult: preprocessStepResult ? JSON.stringify(preprocessStepResult) : null,
           analyzeStepResult: analyzeStepResult ? JSON.stringify(analyzeStepResult) : null,
-          metadata: metadata ? JSON.stringify(metadata) : null,
-          additionalContext: additionalContext ? JSON.stringify(additionalContext) : null,
           requestContext: requestContext ? JSON.stringify(requestContext) : null,
           entity: entity ? JSON.stringify(entity) : null,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),