@mastra/upstash 0.12.3 → 0.12.4-alpha.1

package/dist/index.js

@@ -949,6 +949,60 @@ var StoreMemoryUpstash = class extends MemoryStorage {
       );
     }
   }
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    try {
+      const threadIds = /* @__PURE__ */ new Set();
+      const messageKeys = [];
+      for (const messageId of messageIds) {
+        const pattern = getMessageKey("*", messageId);
+        const keys = await this.operations.scanKeys(pattern);
+        for (const key of keys) {
+          const message = await this.client.get(key);
+          if (message && message.id === messageId) {
+            messageKeys.push(key);
+            if (message.threadId) {
+              threadIds.add(message.threadId);
+            }
+            break;
+          }
+        }
+      }
+      if (messageKeys.length === 0) {
+        return;
+      }
+      const pipeline = this.client.pipeline();
+      for (const key of messageKeys) {
+        pipeline.del(key);
+      }
+      if (threadIds.size > 0) {
+        for (const threadId of threadIds) {
+          const threadKey = getKey(TABLE_THREADS, { id: threadId });
+          const thread = await this.client.get(threadKey);
+          if (thread) {
+            const updatedThread = {
+              ...thread,
+              updatedAt: /* @__PURE__ */ new Date()
+            };
+            pipeline.set(threadKey, processRecord(TABLE_THREADS, updatedThread).processedRecord);
+          }
+        }
+      }
+      await pipeline.exec();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_UPSTASH_DELETE_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
+        },
+        error
+      );
+    }
+  }
 };
 var StoreOperationsUpstash = class extends StoreOperations {
   client;
@@ -1613,7 +1667,8 @@ var UpstashStore = class extends MastraStorage {
       selectByIncludeResourceScope: true,
       resourceWorkingMemory: true,
       hasColumn: false,
-      createTable: false
+      createTable: false,
+      deleteMessages: true
     };
   }
   /**
@@ -1737,6 +1792,9 @@ var UpstashStore = class extends MastraStorage {
   async updateMessages(args) {
     return this.stores.memory.updateMessages(args);
   }
+  async deleteMessages(messageIds) {
+    return this.stores.memory.deleteMessages(messageIds);
+  }
   async getResourceById({ resourceId }) {
     return this.stores.memory.getResourceById({ resourceId });
   }
@@ -1993,11 +2051,18 @@ var UpstashVector = class extends MastraVector {
    * @param {UpsertVectorParams} params - The parameters for the upsert operation.
    * @returns {Promise<string[]>} A promise that resolves to the IDs of the upserted vectors.
    */
-  async upsert({ indexName: namespace, vectors, metadata, ids }) {
+  async upsert({
+    indexName: namespace,
+    vectors,
+    metadata,
+    ids,
+    sparseVectors
+  }) {
     const generatedIds = ids || vectors.map(() => crypto.randomUUID());
     const points = vectors.map((vector, index) => ({
       id: generatedIds[index],
       vector,
+      ...sparseVectors?.[index] && { sparseVector: sparseVectors[index] },
       metadata: metadata?.[index]
     }));
     try {
@@ -2044,7 +2109,10 @@ var UpstashVector = class extends MastraVector {
     queryVector,
     topK = 10,
     filter,
-    includeVector = false
+    includeVector = false,
+    sparseVector,
+    fusionAlgorithm,
+    queryMode
   }) {
     try {
       const ns = this.client.namespace(namespace);
@@ -2052,9 +2120,12 @@ var UpstashVector = class extends MastraVector {
       const results = await ns.query({
         topK,
         vector: queryVector,
+        ...sparseVector && { sparseVector },
         includeVectors: includeVector,
         includeMetadata: true,
-        ...filterString ? { filter: filterString } : {}
+        ...filterString ? { filter: filterString } : {},
+        ...fusionAlgorithm && { fusionAlgorithm },
+        ...queryMode && { queryMode }
       });
       return (results || []).map((result) => ({
         id: `${result.id}`,
@@ -2150,40 +2221,30 @@ var UpstashVector = class extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName: namespace, id, update }) {
-    try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No update data provided");
-      }
-      if (!update.vector && update.metadata) {
-        throw new Error("Both vector and metadata must be provided for an update");
-      }
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { namespace, id }
-        },
-        error
-      );
+    if (!update.vector && !update.metadata && !update.sparseVector) {
+      throw new MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        details: { namespace, id },
+        text: "No update data provided"
+      });
     }
-    try {
-      const updatePayload = { id };
-      if (update.vector) {
-        updatePayload.vector = update.vector;
-      }
-      if (update.metadata) {
-        updatePayload.metadata = update.metadata;
-      }
-      const points = {
-        id: updatePayload.id,
-        vector: updatePayload.vector,
-        metadata: updatePayload.metadata
-      };
-      await this.client.upsert(points, {
-        namespace
+    if (!update.vector && !update.sparseVector && update.metadata) {
+      throw new MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        details: { namespace, id },
+        text: "Both vector and metadata must be provided for an update"
       });
+    }
+    try {
+      const points = { id };
+      if (update.vector) points.vector = update.vector;
+      if (update.metadata) points.metadata = update.metadata;
+      if (update.sparseVector) points.sparseVector = update.sparseVector;
+      await this.client.upsert(points, { namespace });
     } catch (error) {
       throw new MastraError(
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.12.3",
+  "version": "0.12.4-alpha.1",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@upstash/redis": "^1.35.0",
+    "@upstash/redis": "^1.35.1",
     "@upstash/vector": "^1.2.2"
   },
   "devDependencies": {
@@ -31,9 +31,9 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@internal/lint": "0.0.22",
-    "@internal/storage-test-utils": "0.0.18",
-    "@mastra/core": "0.11.1"
+    "@internal/lint": "0.0.23",
+    "@internal/storage-test-utils": "0.0.19",
+    "@mastra/core": "0.12.0-alpha.2"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.7-0 <0.12.0-0"

package/src/storage/domains/memory/index.ts

@@ -899,4 +899,74 @@ export class StoreMemoryUpstash extends MemoryStorage {
       );
     }
   }
+
+  async deleteMessages(messageIds: string[]): Promise<void> {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+
+    try {
+      const threadIds = new Set<string>();
+      const messageKeys: string[] = [];
+
+      // Find all message keys and collect thread IDs
+      for (const messageId of messageIds) {
+        const pattern = getMessageKey('*', messageId);
+        const keys = await this.operations.scanKeys(pattern);
+
+        for (const key of keys) {
+          const message = await this.client.get<MastraMessageV2 | MastraMessageV1>(key);
+          if (message && message.id === messageId) {
+            messageKeys.push(key);
+            if (message.threadId) {
+              threadIds.add(message.threadId);
+            }
+            break;
+          }
+        }
+      }
+
+      if (messageKeys.length === 0) {
+        // none of the message ids existed
+        return;
+      }
+
+      const pipeline = this.client.pipeline();
+
+      // Delete all messages
+      for (const key of messageKeys) {
+        pipeline.del(key);
+      }
+
+      // Update thread timestamps
+      if (threadIds.size > 0) {
+        for (const threadId of threadIds) {
+          const threadKey = getKey(TABLE_THREADS, { id: threadId });
+          const thread = await this.client.get<StorageThreadType>(threadKey);
+          if (thread) {
+            const updatedThread = {
+              ...thread,
+              updatedAt: new Date(),
+            };
+            pipeline.set(threadKey, processRecord(TABLE_THREADS, updatedThread).processedRecord);
+          }
+        }
+      }
+
+      // Execute all operations
+      await pipeline.exec();
+
+      // TODO: Delete from vector store if semantic recall is enabled
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_DELETE_MESSAGES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(', ') },
+        },
+        error,
+      );
+    }
+  }
 }

package/src/storage/index.ts

@@ -65,6 +65,7 @@ export class UpstashStore extends MastraStorage {
       resourceWorkingMemory: true,
       hasColumn: false,
       createTable: false,
+      deleteMessages: true,
     };
   }
 
@@ -281,6 +282,10 @@ export class UpstashStore extends MastraStorage {
     return this.stores.memory.updateMessages(args);
   }
 
+  async deleteMessages(messageIds: string[]): Promise<void> {
+    return this.stores.memory.deleteMessages(messageIds);
+  }
+
   async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
     return this.stores.memory.getResourceById({ resourceId });
   }