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

package/dist/index.cjs

@@ -54,6 +54,9 @@ function getMessageKey(threadId, messageId) {
   const key = getKey(storage.TABLE_MESSAGES, { threadId, id: messageId });
   return key;
 }
+function getMessageIndexKey(messageId) {
+  return `msg-idx:${messageId}`;
+}
 var StoreMemoryUpstash = class extends storage.MemoryStorage {
   client;
   operations;
@@ -320,6 +323,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
             }
           }
           pipeline.set(key, message);
+          pipeline.set(getMessageIndexKey(message.id), message.threadId);
           pipeline.zadd(getThreadMessagesKey(message.threadId), {
             score,
             member: message.id
@@ -350,43 +354,60 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       );
     }
   }
-  async _getIncludedMessages(threadId, include) {
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+  /**
+   * Lookup threadId for a message - tries index first (O(1)), falls back to scan (backwards compatible)
+   */
+  async _getThreadIdForMessage(messageId) {
+    const indexedThreadId = await this.client.get(getMessageIndexKey(messageId));
+    if (indexedThreadId) {
+      return indexedThreadId;
+    }
+    const existingKeyPattern = getMessageKey("*", messageId);
+    const keys = await this.operations.scanKeys(existingKeyPattern);
+    if (keys.length === 0) return null;
+    const messageData = await this.client.get(keys[0]);
+    if (!messageData) return null;
+    if (messageData.threadId) {
+      await this.client.set(getMessageIndexKey(messageId), messageData.threadId);
+    }
+    return messageData.threadId || null;
+  }
+  async _getIncludedMessages(include) {
+    if (!include?.length) return [];
     const messageIds = /* @__PURE__ */ new Set();
     const messageIdToThreadIds = {};
-    if (include?.length) {
-      for (const item of include) {
-        messageIds.add(item.id);
-        const itemThreadId = item.threadId || threadId;
-        messageIdToThreadIds[item.id] = itemThreadId;
-        const itemThreadMessagesKey = getThreadMessagesKey(itemThreadId);
-        const rank = await this.client.zrank(itemThreadMessagesKey, item.id);
-        if (rank === null) continue;
-        if (item.withPreviousMessages) {
-          const start = Math.max(0, rank - item.withPreviousMessages);
-          const prevIds = rank === 0 ? [] : await this.client.zrange(itemThreadMessagesKey, start, rank - 1);
-          prevIds.forEach((id) => {
-            messageIds.add(id);
-            messageIdToThreadIds[id] = itemThreadId;
-          });
-        }
-        if (item.withNextMessages) {
-          const nextIds = await this.client.zrange(itemThreadMessagesKey, rank + 1, rank + item.withNextMessages);
-          nextIds.forEach((id) => {
-            messageIds.add(id);
-            messageIdToThreadIds[id] = itemThreadId;
-          });
-        }
+    for (const item of include) {
+      const itemThreadId = await this._getThreadIdForMessage(item.id);
+      if (!itemThreadId) continue;
+      messageIds.add(item.id);
+      messageIdToThreadIds[item.id] = itemThreadId;
+      const itemThreadMessagesKey = getThreadMessagesKey(itemThreadId);
+      const rank = await this.client.zrank(itemThreadMessagesKey, item.id);
+      if (rank === null) continue;
+      if (item.withPreviousMessages) {
+        const start = Math.max(0, rank - item.withPreviousMessages);
+        const prevIds = rank === 0 ? [] : await this.client.zrange(itemThreadMessagesKey, start, rank - 1);
+        prevIds.forEach((id) => {
+          messageIds.add(id);
+          messageIdToThreadIds[id] = itemThreadId;
+        });
+      }
+      if (item.withNextMessages) {
+        const nextIds = await this.client.zrange(itemThreadMessagesKey, rank + 1, rank + item.withNextMessages);
+        nextIds.forEach((id) => {
+          messageIds.add(id);
+          messageIdToThreadIds[id] = itemThreadId;
+        });
       }
-      const pipeline = this.client.pipeline();
-      Array.from(messageIds).forEach((id) => {
-        const tId = messageIdToThreadIds[id] || threadId;
-        pipeline.get(getMessageKey(tId, id));
-      });
-      const results = await pipeline.exec();
-      return results.filter((result) => result !== null);
     }
-    return [];
+    if (messageIds.size === 0) return [];
+    const pipeline = this.client.pipeline();
+    Array.from(messageIds).forEach((id) => {
+      const tId = messageIdToThreadIds[id];
+      pipeline.get(getMessageKey(tId, id));
+    });
+    const results = await pipeline.exec();
+    return results.filter((result) => result !== null);
   }
   parseStoredMessage(storedMessage) {
     const defaultMessageContent = { format: 2, parts: [{ type: "text", text: "" }] };
@@ -400,17 +421,49 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
   async listMessagesById({ messageIds }) {
     if (messageIds.length === 0) return { messages: [] };
     try {
-      const threadKeys = await this.client.keys("thread:*");
-      const result = await Promise.all(
-        threadKeys.map((threadKey) => {
-          const threadId = threadKey.split(":")[1];
-          if (!threadId) throw new Error(`Failed to parse thread ID from thread key "${threadKey}"`);
-          return this.client.mget(
-            messageIds.map((id) => getMessageKey(threadId, id))
-          );
-        })
-      );
-      const rawMessages = result.flat(1).filter((msg) => !!msg);
+      const rawMessages = [];
+      const indexPipeline = this.client.pipeline();
+      messageIds.forEach((id) => indexPipeline.get(getMessageIndexKey(id)));
+      const indexResults = await indexPipeline.exec();
+      const indexedIds = [];
+      const unindexedIds = [];
+      messageIds.forEach((id, i) => {
+        const threadId = indexResults[i];
+        if (threadId) {
+          indexedIds.push({ messageId: id, threadId });
+        } else {
+          unindexedIds.push(id);
+        }
+      });
+      if (indexedIds.length > 0) {
+        const messagePipeline = this.client.pipeline();
+        indexedIds.forEach(({ messageId, threadId }) => messagePipeline.get(getMessageKey(threadId, messageId)));
+        const messageResults = await messagePipeline.exec();
+        rawMessages.push(...messageResults.filter((msg) => msg !== null));
+      }
+      if (unindexedIds.length > 0) {
+        const threadKeys = await this.client.keys("thread:*");
+        const result = await Promise.all(
+          threadKeys.map((threadKey) => {
+            const threadId = threadKey.split(":")[1];
+            if (!threadId) throw new Error(`Failed to parse thread ID from thread key "${threadKey}"`);
+            return this.client.mget(
+              unindexedIds.map((id) => getMessageKey(threadId, id))
+            );
+          })
+        );
+        const foundMessages = result.flat(1).filter((msg) => !!msg);
+        rawMessages.push(...foundMessages);
+        if (foundMessages.length > 0) {
+          const backfillPipeline = this.client.pipeline();
+          foundMessages.forEach((msg) => {
+            if (msg.threadId) {
+              backfillPipeline.set(getMessageIndexKey(msg.id), msg.threadId);
+            }
+          });
+          await backfillPipeline.exec();
+        }
+      }
       const list = new agent.MessageList().add(rawMessages.map(this.parseStoredMessage), "memory");
       return { messages: list.get.all.db() };
     } catch (error$1) {
@@ -429,18 +482,18 @@ var StoreMemoryUpstash = 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];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
       throw new error.MastraError(
         {
           id: "STORAGE_UPSTASH_LIST_MESSAGES_INVALID_THREAD_ID",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : 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")
       );
     }
-    const threadMessagesKey = getThreadMessagesKey(threadId);
     const perPage = storage.normalizePerPage(perPageInput, 40);
     const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     try {
@@ -457,11 +510,18 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       }
       let includedMessages = [];
       if (include && include.length > 0) {
-        const included = await this._getIncludedMessages(threadId, include);
+        const included = await this._getIncludedMessages(include);
         includedMessages = included.map(this.parseStoredMessage);
       }
-      const allMessageIds = await this.client.zrange(threadMessagesKey, 0, -1);
-      if (allMessageIds.length === 0) {
+      const allMessageIdsWithThreads = [];
+      for (const tid of threadIds) {
+        const threadMessagesKey = getThreadMessagesKey(tid);
+        const messageIds2 = await this.client.zrange(threadMessagesKey, 0, -1);
+        for (const mid of messageIds2) {
+          allMessageIdsWithThreads.push({ threadId: tid, messageId: mid });
+        }
+      }
+      if (allMessageIdsWithThreads.length === 0) {
         return {
           messages: [],
           total: 0,
@@ -471,7 +531,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
         };
       }
       const pipeline = this.client.pipeline();
-      allMessageIds.forEach((id) => pipeline.get(getMessageKey(threadId, id)));
+      allMessageIdsWithThreads.forEach(({ threadId: tid, messageId }) => pipeline.get(getMessageKey(tid, messageId)));
       const results = await pipeline.exec();
       let messagesData = results.filter((msg) => msg !== null).map(this.parseStoredMessage);
       if (resourceId) {
@@ -500,13 +560,11 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
         }
         return 0;
       };
-      if (orderBy) {
-        messagesData.sort((a, b) => {
-          const aValue = getFieldValue(a);
-          const bValue = getFieldValue(b);
-          return direction === "ASC" ? aValue - bValue : bValue - aValue;
-        });
-      }
+      messagesData.sort((a, b) => {
+        const aValue = getFieldValue(a);
+        const bValue = getFieldValue(b);
+        return direction === "ASC" ? aValue - bValue : bValue - aValue;
+      });
       const total = messagesData.length;
       const start = offset;
       const end = perPageInput === false ? total : start + perPage;
@@ -527,23 +585,11 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       }
       const list = new agent.MessageList().add(allMessages, "memory");
       let finalMessages = list.get.all.db();
-      if (orderBy) {
-        finalMessages = finalMessages.sort((a, b) => {
-          const aValue = getFieldValue(a);
-          const bValue = getFieldValue(b);
-          return direction === "ASC" ? aValue - bValue : bValue - aValue;
-        });
-      } else {
-        const messageIdToPosition = /* @__PURE__ */ new Map();
-        allMessageIds.forEach((id, index) => {
-          messageIdToPosition.set(id, index);
-        });
-        finalMessages = finalMessages.sort((a, b) => {
-          const aPos = messageIdToPosition.get(a.id) ?? Number.MAX_SAFE_INTEGER;
-          const bPos = messageIdToPosition.get(b.id) ?? Number.MAX_SAFE_INTEGER;
-          return aPos - bPos;
-        });
-      }
+      finalMessages = finalMessages.sort((a, b) => {
+        const aValue = getFieldValue(a);
+        const bValue = getFieldValue(b);
+        return direction === "ASC" ? aValue - bValue : bValue - aValue;
+      });
       const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
       const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
       const hasMore = perPageInput !== false && !allThreadMessagesReturned && end < total;
@@ -561,7 +607,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
             resourceId: resourceId ?? ""
           }
         },
@@ -766,13 +812,33 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
     try {
       const threadIds = /* @__PURE__ */ new Set();
       const messageKeys = [];
-      for (const messageId of messageIds) {
+      const foundMessageIds = [];
+      const indexPipeline = this.client.pipeline();
+      messageIds.forEach((id) => indexPipeline.get(getMessageIndexKey(id)));
+      const indexResults = await indexPipeline.exec();
+      const indexedMessages = [];
+      const unindexedMessageIds = [];
+      messageIds.forEach((id, i) => {
+        const threadId = indexResults[i];
+        if (threadId) {
+          indexedMessages.push({ messageId: id, threadId });
+        } else {
+          unindexedMessageIds.push(id);
+        }
+      });
+      for (const { messageId, threadId } of indexedMessages) {
+        messageKeys.push(getMessageKey(threadId, messageId));
+        foundMessageIds.push(messageId);
+        threadIds.add(threadId);
+      }
+      for (const messageId of unindexedMessageIds) {
         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);
+            foundMessageIds.push(messageId);
             if (message.threadId) {
               threadIds.add(message.threadId);
             }
@@ -787,6 +853,9 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       for (const key of messageKeys) {
         pipeline.del(key);
       }
+      for (const messageId of foundMessageIds) {
+        pipeline.del(getMessageIndexKey(messageId));
+      }
       if (threadIds.size > 0) {
         for (const threadId of threadIds) {
           const threadKey = getKey(storage.TABLE_THREADS, { id: threadId });
@@ -962,32 +1031,7 @@ var StoreOperationsUpstash = class extends storage.StoreOperations {
   }
 };
 function transformScoreRow(row) {
-  const parseField = (v) => {
-    if (typeof v === "string") {
-      try {
-        return JSON.parse(v);
-      } catch {
-        return v;
-      }
-    }
-    return v;
-  };
-  return {
-    ...row,
-    scorer: parseField(row.scorer),
-    preprocessStepResult: parseField(row.preprocessStepResult),
-    generateScorePrompt: row.generateScorePrompt,
-    generateReasonPrompt: row.generateReasonPrompt,
-    analyzeStepResult: parseField(row.analyzeStepResult),
-    metadata: parseField(row.metadata),
-    input: parseField(row.input),
-    output: parseField(row.output),
-    additionalContext: parseField(row.additionalContext),
-    requestContext: parseField(row.requestContext),
-    entity: parseField(row.entity),
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt
-  };
+  return storage.transformScoreRow(row);
 }
 var ScoresUpstash = class extends storage.ScoresStorage {
   client;
@@ -1011,7 +1055,9 @@ var ScoresUpstash = class extends storage.ScoresStorage {
           id: "STORAGE_UPSTASH_STORAGE_GET_SCORE_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { id }
+          details: {
+            ...id && { id }
+          }
         },
         error$1
       );
@@ -2001,6 +2047,11 @@ var UpstashVector = class extends vector.MastraVector {
     try {
       await this.client.deleteNamespace(namespace);
     } catch (error$1) {
+      const errorMessage = error$1?.message || "";
+      if (errorMessage.includes("does not exist") || errorMessage.includes("not found")) {
+        this.logger.info(`Namespace ${namespace} does not exist, treating as already deleted`);
+        return;
+      }
       throw new error.MastraError(
         {
           id: "STORAGE_UPSTASH_VECTOR_DELETE_INDEX_FAILED",
@@ -2013,47 +2064,124 @@ var UpstashVector = class extends vector.MastraVector {
     }
   }
   /**
-   * Updates a vector by its ID with the provided vector and/or metadata.
-   * @param indexName - The name of the namespace containing the vector.
-   * @param id - The ID of the vector to update.
-   * @param update - An object containing the vector and/or metadata to update.
-   * @param update.vector - An optional array of numbers representing the new vector.
-   * @param update.metadata - An optional record containing the new metadata.
+   * Updates a vector by its ID or multiple vectors matching a filter.
+   * @param params - Parameters containing the id or filter for targeting the vector(s) to update
+   * @param params.indexName - The name of the namespace containing the vector.
+   * @param params.id - The ID of the vector to update (mutually exclusive with filter).
+   * @param params.filter - Filter to match multiple vectors to update (mutually exclusive with id).
+   * @param params.update - An object containing the vector and/or metadata to update.
    * @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: namespace, id, update }) {
-    if (!update.vector && !update.metadata && !update.sparseVector) {
+  async updateVector(params) {
+    const { indexName: namespace, update } = params;
+    const upstashUpdate = update;
+    const sparseVector = upstashUpdate.sparseVector;
+    if ("id" in params && params.id && "filter" in params && params.filter) {
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_UPDATE_MUTUALLY_EXCLUSIVE",
+        text: "Cannot specify both id and filter - they are mutually exclusive",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (!("id" in params && params.id) && !("filter" in params && params.filter)) {
       throw new error.MastraError({
-        id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+        id: "STORAGE_UPSTASH_VECTOR_UPDATE_NO_TARGET",
+        text: "Either id or filter must be provided",
         domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY,
-        details: { namespace, id },
-        text: "No update data provided"
+        category: error.ErrorCategory.USER,
+        details: { namespace }
       });
     }
-    if (!update.vector && !update.sparseVector && update.metadata) {
+    if (!update.vector && !update.metadata && !sparseVector) {
       throw new error.MastraError({
-        id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+        id: "STORAGE_UPSTASH_VECTOR_UPDATE_NO_PAYLOAD",
+        text: "No update data provided",
         domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY,
-        details: { namespace, id },
-        text: "Both vector and metadata must be provided for an update"
+        category: error.ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if ("filter" in params && params.filter && Object.keys(params.filter).length === 0) {
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_UPDATE_EMPTY_FILTER",
+        text: "Filter cannot be an empty filter object",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { namespace }
       });
     }
     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 });
+      const ns = this.client.namespace(namespace);
+      if ("id" in params && params.id) {
+        const points = { id: params.id };
+        if (!update.vector || !update.metadata) {
+          try {
+            const existing = await ns.fetch([params.id], {
+              includeVectors: true,
+              includeMetadata: true
+            });
+            if (existing && existing.length > 0 && existing[0]) {
+              if (!update.vector && existing[0]?.vector) {
+                points.vector = existing[0].vector;
+              }
+              if (!update.metadata && existing[0]?.metadata) {
+                points.metadata = existing[0].metadata;
+              }
+            }
+          } catch (fetchError) {
+            this.logger.warn(`Failed to fetch existing vector ${params.id} for partial update: ${fetchError}`);
+          }
+        }
+        if (update.vector) points.vector = update.vector;
+        if (update.metadata) points.metadata = update.metadata;
+        if (sparseVector) points.sparseVector = sparseVector;
+        await ns.upsert(points);
+      } else if ("filter" in params && params.filter) {
+        const filterString = this.transformFilter(params.filter);
+        if (filterString) {
+          const stats = await this.describeIndex({ indexName: namespace });
+          const dummyVector = new Array(stats.dimension).fill(1 / Math.sqrt(stats.dimension));
+          const needsVectors = !update.vector;
+          const results = await ns.query({
+            vector: dummyVector,
+            topK: 1e3,
+            // Upstash's max query limit
+            filter: filterString,
+            includeVectors: needsVectors,
+            includeMetadata: needsVectors
+          });
+          for (const result of results) {
+            const points = { id: `${result.id}` };
+            if (update.vector) {
+              points.vector = update.vector;
+            } else if (result.vector) {
+              points.vector = result.vector;
+            }
+            if (update.metadata) {
+              points.metadata = update.metadata;
+            } else if (result.metadata) {
+              points.metadata = result.metadata;
+            }
+            if (sparseVector) points.sparseVector = sparseVector;
+            await ns.upsert(points);
+          }
+        }
+      }
     } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
           id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { namespace, id }
+          details: {
+            namespace,
+            ..."id" in params && params.id && { id: params.id },
+            ..."filter" in params && params.filter && { filter: JSON.stringify(params.filter) }
+          }
         },
         error$1
       );
@@ -2068,22 +2196,109 @@ var UpstashVector = class extends vector.MastraVector {
    */
   async deleteVector({ indexName: namespace, id }) {
     try {
-      await this.client.delete(id, {
-        namespace
-      });
+      const ns = this.client.namespace(namespace);
+      await ns.delete(id);
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
           id: "STORAGE_UPSTASH_VECTOR_DELETE_VECTOR_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { namespace, id }
+          details: {
+            namespace,
+            ...id && { id }
+          }
         },
         error$1
       );
       this.logger?.error(mastraError.toString());
     }
   }
+  /**
+   * Deletes multiple vectors by IDs or filter.
+   * @param indexName - The name of the namespace containing the vectors.
+   * @param ids - Array of vector IDs to delete (mutually exclusive with filter).
+   * @param filter - Filter to match vectors to delete (mutually exclusive with ids).
+   * @returns A promise that resolves when the deletion is complete.
+   * @throws Will throw an error if both ids and filter are provided, or if neither is provided.
+   */
+  async deleteVectors({ indexName: namespace, filter, ids }) {
+    if (ids && filter) {
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_DELETE_VECTORS_MUTUALLY_EXCLUSIVE",
+        text: "Cannot specify both ids and filter - they are mutually exclusive",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (!ids && !filter) {
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_DELETE_VECTORS_NO_TARGET",
+        text: "Either filter or ids must be provided",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (ids && ids.length === 0) {
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_DELETE_VECTORS_EMPTY_IDS",
+        text: "Cannot delete with empty ids array",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (filter && Object.keys(filter).length === 0) {
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_VECTOR_DELETE_VECTORS_EMPTY_FILTER",
+        text: "Cannot delete with empty filter object",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    try {
+      const ns = this.client.namespace(namespace);
+      if (ids) {
+        await ns.delete(ids);
+      } else if (filter) {
+        const filterString = this.transformFilter(filter);
+        if (filterString) {
+          const stats = await this.describeIndex({ indexName: namespace });
+          const dummyVector = new Array(stats.dimension).fill(1 / Math.sqrt(stats.dimension));
+          const results = await ns.query({
+            vector: dummyVector,
+            topK: 1e3,
+            // Upstash's max query limit
+            filter: filterString,
+            includeVectors: false,
+            includeMetadata: false
+          });
+          const idsToDelete = results.map((r) => `${r.id}`);
+          if (idsToDelete.length > 0) {
+            await ns.delete(idsToDelete);
+          }
+        }
+      }
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_DELETE_VECTORS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            ...filter && { filter: JSON.stringify(filter) },
+            ...ids && { idsCount: ids.length }
+          }
+        },
+        error$1
+      );
+    }
+  }
 };
 
 // src/vector/prompt.ts