@mastra/pg 1.6.1 → 1.7.0

package/dist/index.js

@@ -790,8 +790,12 @@ var PgVector = class extends MastraVector {
   }) {
     try {
       validateTopK("PG", topK);
-      if (!Array.isArray(queryVector) || !queryVector.every((x) => typeof x === "number" && Number.isFinite(x))) {
-        throw new Error("queryVector must be an array of finite numbers");
+      if (queryVector !== void 0) {
+        if (!Array.isArray(queryVector) || !queryVector.every((x) => typeof x === "number" && Number.isFinite(x))) {
+          throw new Error("queryVector must be an array of finite numbers");
+        }
+      } else if (!filter || Object.keys(filter).length === 0) {
+        throw new Error("Either queryVector or filter must be provided");
       }
     } catch (error) {
       const mastraError = new MastraError(
@@ -808,6 +812,46 @@ var PgVector = class extends MastraVector {
       this.logger?.trackException(mastraError);
       throw mastraError;
     }
+    if (queryVector === void 0) {
+      const client2 = await this.pool.connect();
+      try {
+        const translatedFilter = this.transformFilter(filter);
+        const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(translatedFilter);
+        const { tableName } = this.getTableName(indexName);
+        const query = `
+          SELECT
+            vector_id as id,
+            metadata
+            ${includeVector ? ", embedding" : ""}
+          FROM ${tableName}
+          ${filterQuery}
+          ORDER BY vector_id
+          LIMIT $${filterValues.length + 1}`;
+        const result = await client2.query(query, [...filterValues, topK]);
+        return result.rows.map(({ id, metadata, embedding }) => ({
+          id,
+          score: 0,
+          metadata,
+          ...includeVector && embedding && { vector: JSON.parse(embedding) }
+        }));
+      } catch (error) {
+        const mastraError = new MastraError(
+          {
+            id: createVectorErrorId("PG", "QUERY", "FAILED"),
+            domain: ErrorDomain.MASTRA_VECTOR,
+            category: ErrorCategory.THIRD_PARTY,
+            details: {
+              indexName
+            }
+          },
+          error
+        );
+        this.logger?.trackException(mastraError);
+        throw mastraError;
+      } finally {
+        client2.release();
+      }
+    }
     const client = await this.pool.connect();
     try {
       await client.query("BEGIN");
@@ -2031,6 +2075,17 @@ function generateTableSQL({
                 ADD CONSTRAINT ${workflowSnapshotConstraint}
                 UNIQUE (workflow_name, run_id);
               END IF;
+              IF EXISTS (
+                SELECT 1 FROM pg_index i
+                JOIN pg_class c ON i.indexrelid = c.oid
+                JOIN pg_namespace n ON c.relnamespace = n.oid
+                WHERE c.relname = lower('${workflowSnapshotConstraint}')
+                AND n.nspname = '${schemaFilter}'
+                AND i.indisreplident = false
+              ) THEN
+                ALTER TABLE ${getTableName({ indexName: tableName, schemaName: quotedSchemaName })}
+                REPLICA IDENTITY USING INDEX ${workflowSnapshotConstraint};
+              END IF;
             END $$;
             ` : ""}
           ${// For spans table: Include PRIMARY KEY in exports, but not in runtime (handled after deduplication)
@@ -8570,11 +8625,13 @@ var MemoryPG = class _MemoryPG extends MemoryStorage {
       const maxOvershoot = retentionFloor * 0.95;
       const overshoot = bestOverTokens - targetMessageTokens;
       const remainingAfterOver = input.currentPendingTokens - bestOverTokens;
-      if (input.forceMaxActivation && bestOverBoundary > 0) {
+      const remainingAfterUnder = input.currentPendingTokens - bestUnderTokens;
+      const minRemaining = Math.min(1e3, retentionFloor);
+      if (input.forceMaxActivation && bestOverBoundary > 0 && remainingAfterOver >= minRemaining) {
         chunksToActivate = bestOverBoundary;
-      } else if (bestOverBoundary > 0 && overshoot <= maxOvershoot && (remainingAfterOver >= 1e3 || retentionFloor === 0)) {
+      } else if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) {
         chunksToActivate = bestOverBoundary;
-      } else if (bestUnderBoundary > 0) {
+      } else if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) {
         chunksToActivate = bestUnderBoundary;
       } else if (bestOverBoundary > 0) {
         chunksToActivate = bestOverBoundary;