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

package/dist/index.js

@@ -1,4 +1,4 @@
-import { MastraStorage, StoreOperations, ScoresStorage, TABLE_SCORERS, normalizePerPage, calculatePagination, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MemoryStorage, TABLE_THREADS, TABLE_RESOURCES, TABLE_MESSAGES, serializeDate } from '@mastra/core/storage';
+import { MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ensureDate, createStorageErrorId, normalizePerPage, calculatePagination, filterByDateRange, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MastraStorage, createVectorErrorId, serializeDate, transformScoreRow as transformScoreRow$1 } from '@mastra/core/storage';
 import { Redis } from '@upstash/redis';
 import { MessageList } from '@mastra/core/agent';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
@@ -9,13 +9,6 @@ import { Index } from '@upstash/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/storage/index.ts
-function ensureDate(value) {
-  if (!value) return null;
-  if (value instanceof Date) return value;
-  if (typeof value === "string") return new Date(value);
-  if (typeof value === "number") return new Date(value);
-  return null;
-}
 function getKey(tableName, keys) {
   const keyParts = Object.entries(keys).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}:${value}`);
   return `${tableName}:${keyParts.join(":")}`;
@@ -32,7 +25,7 @@ function processRecord(tableName, record) {
       ...record.resourceId ? { resourceId: record.resourceId } : {}
     });
   } else if (tableName === TABLE_SCORERS) {
-    key = getKey(tableName, { runId: record.runId });
+    key = getKey(tableName, { id: record.id });
   } else {
     key = getKey(tableName, { id: record.id });
   }
@@ -44,6 +37,107 @@ function processRecord(tableName, record) {
   return { key, processedRecord };
 }
 
+// src/storage/db/index.ts
+function resolveUpstashConfig(config) {
+  if ("client" in config) {
+    return config.client;
+  }
+  return new Redis({
+    url: config.url,
+    token: config.token
+  });
+}
+var UpstashDB = class {
+  client;
+  constructor({ client }) {
+    this.client = client;
+  }
+  async insert({ tableName, record }) {
+    const { key, processedRecord } = processRecord(tableName, record);
+    try {
+      await this.client.set(key, processedRecord);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "INSERT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    }
+  }
+  async get({ tableName, keys }) {
+    const key = getKey(tableName, keys);
+    try {
+      const data = await this.client.get(key);
+      return data || null;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "LOAD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    }
+  }
+  async scanAndDelete(pattern, batchSize = 1e4) {
+    let cursor = "0";
+    let totalDeleted = 0;
+    do {
+      const [nextCursor, keys] = await this.client.scan(cursor, {
+        match: pattern,
+        count: batchSize
+      });
+      if (keys.length > 0) {
+        await this.client.del(...keys);
+        totalDeleted += keys.length;
+      }
+      cursor = nextCursor;
+    } while (cursor !== "0");
+    return totalDeleted;
+  }
+  async scanKeys(pattern, batchSize = 1e4) {
+    let cursor = "0";
+    let keys = [];
+    do {
+      const [nextCursor, batch] = await this.client.scan(cursor, {
+        match: pattern,
+        count: batchSize
+      });
+      keys.push(...batch);
+      cursor = nextCursor;
+    } while (cursor !== "0");
+    return keys;
+  }
+  async deleteData({ tableName }) {
+    const pattern = `${tableName}:*`;
+    try {
+      await this.scanAndDelete(pattern);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "CLEAR_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    }
+  }
+};
+
 // src/storage/domains/memory/index.ts
 function getThreadMessagesKey(threadId) {
   return `thread:${threadId}:messages`;
@@ -52,17 +146,26 @@ function getMessageKey(threadId, messageId) {
   const key = getKey(TABLE_MESSAGES, { threadId, id: messageId });
   return key;
 }
+function getMessageIndexKey(messageId) {
+  return `msg-idx:${messageId}`;
+}
 var StoreMemoryUpstash = class extends MemoryStorage {
   client;
-  operations;
-  constructor({ client, operations }) {
+  #db;
+  constructor(config) {
     super();
+    const client = resolveUpstashConfig(config);
     this.client = client;
-    this.operations = operations;
+    this.#db = new UpstashDB({ client });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: TABLE_THREADS });
+    await this.#db.deleteData({ tableName: TABLE_MESSAGES });
+    await this.#db.deleteData({ tableName: TABLE_RESOURCES });
   }
   async getThreadById({ threadId }) {
     try {
-      const thread = await this.operations.load({
+      const thread = await this.#db.get({
         tableName: TABLE_THREADS,
         keys: { id: threadId }
       });
@@ -76,7 +179,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_THREAD_BY_ID_FAILED",
+          id: createStorageErrorId("UPSTASH", "GET_THREAD_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -94,7 +197,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     if (page < 0) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
+          id: createStorageErrorId("UPSTASH", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.USER,
           details: { page }
@@ -106,7 +209,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     try {
       let allThreads = [];
       const pattern = `${TABLE_THREADS}:*`;
-      const keys = await this.operations.scanKeys(pattern);
+      const keys = await this.#db.scanKeys(pattern);
       const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
@@ -136,7 +239,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       const mastraError = new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
+          id: createStorageErrorId("UPSTASH", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -160,7 +263,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
   }
   async saveThread({ thread }) {
     try {
-      await this.operations.insert({
+      await this.#db.insert({
         tableName: TABLE_THREADS,
         record: thread
       });
@@ -168,7 +271,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       const mastraError = new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_SAVE_THREAD_FAILED",
+          id: createStorageErrorId("UPSTASH", "SAVE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -190,7 +293,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     const thread = await this.getThreadById({ threadId: id });
     if (!thread) {
       throw new MastraError({
-        id: "STORAGE_UPSTASH_STORAGE_UPDATE_THREAD_FAILED",
+        id: createStorageErrorId("UPSTASH", "UPDATE_THREAD", "FAILED"),
         domain: ErrorDomain.STORAGE,
         category: ErrorCategory.USER,
         text: `Thread ${id} not found`,
@@ -213,7 +316,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_UPDATE_THREAD_FAILED",
+          id: createStorageErrorId("UPSTASH", "UPDATE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -238,11 +341,11 @@ var StoreMemoryUpstash = class extends MemoryStorage {
         pipeline.del(messageKey);
       }
       await pipeline.exec();
-      await this.operations.scanAndDelete(getMessageKey(threadId, "*"));
+      await this.#db.scanAndDelete(getMessageKey(threadId, "*"));
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_DELETE_THREAD_FAILED",
+          id: createStorageErrorId("UPSTASH", "DELETE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -268,7 +371,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_SAVE_MESSAGES_INVALID_ARGS",
+          id: createStorageErrorId("UPSTASH", "SAVE_MESSAGES", "INVALID_ARGS"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.USER
         },
@@ -303,7 +406,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
           const createdAtScore = new Date(message.createdAt).getTime();
           const score = message._index !== void 0 ? message._index : createdAtScore;
           const existingKeyPattern = getMessageKey("*", message.id);
-          const keys = await this.operations.scanKeys(existingKeyPattern);
+          const keys = await this.#db.scanKeys(existingKeyPattern);
           if (keys.length > 0) {
             const pipeline2 = this.client.pipeline();
             keys.forEach((key2) => pipeline2.get(key2));
@@ -318,6 +421,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
             }
           }
           pipeline.set(key, message);
+          pipeline.set(getMessageIndexKey(message.id), message.threadId);
           pipeline.zadd(getThreadMessagesKey(message.threadId), {
             score,
             member: message.id
@@ -337,7 +441,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_SAVE_MESSAGES_FAILED",
+          id: createStorageErrorId("UPSTASH", "SAVE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -348,43 +452,60 @@ var StoreMemoryUpstash = class extends 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.#db.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: "" }] };
@@ -398,23 +519,55 @@ var StoreMemoryUpstash = class extends 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 MessageList().add(rawMessages.map(this.parseStoredMessage), "memory");
       return { messages: list.get.all.db() };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_LIST_MESSAGES_BY_ID_FAILED",
+          id: createStorageErrorId("UPSTASH", "LIST_MESSAGES_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -427,25 +580,25 @@ var StoreMemoryUpstash = class extends 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 MastraError(
         {
-          id: "STORAGE_UPSTASH_LIST_MESSAGES_INVALID_THREAD_ID",
+          id: createStorageErrorId("UPSTASH", "LIST_MESSAGES", "INVALID_THREAD_ID"),
           domain: ErrorDomain.STORAGE,
           category: 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 = normalizePerPage(perPageInput, 40);
     const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
     try {
       if (page < 0) {
         throw new MastraError(
           {
-            id: "STORAGE_UPSTASH_LIST_MESSAGES_INVALID_PAGE",
+            id: createStorageErrorId("UPSTASH", "LIST_MESSAGES", "INVALID_PAGE"),
             domain: ErrorDomain.STORAGE,
             category: ErrorCategory.USER,
             details: { page }
@@ -455,11 +608,18 @@ var StoreMemoryUpstash = class extends 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,
@@ -469,21 +629,17 @@ var StoreMemoryUpstash = class extends 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) {
         messagesData = messagesData.filter((msg) => msg.resourceId === resourceId);
       }
-      const dateRange = filter?.dateRange;
-      if (dateRange?.start) {
-        const fromDate = dateRange.start;
-        messagesData = messagesData.filter((msg) => new Date(msg.createdAt).getTime() >= fromDate.getTime());
-      }
-      if (dateRange?.end) {
-        const toDate = dateRange.end;
-        messagesData = messagesData.filter((msg) => new Date(msg.createdAt).getTime() <= toDate.getTime());
-      }
+      messagesData = filterByDateRange(
+        messagesData,
+        (msg) => new Date(msg.createdAt),
+        filter?.dateRange
+      );
       const { field, direction } = this.parseOrderBy(orderBy, "ASC");
       const getFieldValue = (msg) => {
         if (field === "createdAt") {
@@ -498,13 +654,11 @@ var StoreMemoryUpstash = class extends 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;
@@ -525,23 +679,11 @@ var StoreMemoryUpstash = class extends MemoryStorage {
       }
       const list = new 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;
@@ -555,11 +697,11 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       const mastraError = new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_LIST_MESSAGES_FAILED",
+          id: createStorageErrorId("UPSTASH", "LIST_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
             resourceId: resourceId ?? ""
           }
         },
@@ -656,7 +798,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
       const messageIdToKey = {};
       for (const messageId of messageIds) {
         const pattern = getMessageKey("*", messageId);
-        const keys = await this.operations.scanKeys(pattern);
+        const keys = await this.#db.scanKeys(pattern);
         for (const key of keys) {
           const message = await this.client.get(key);
           if (message && message.id === messageId) {
@@ -746,7 +888,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_UPDATE_MESSAGES_FAILED",
+          id: createStorageErrorId("UPSTASH", "UPDATE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -764,13 +906,33 @@ var StoreMemoryUpstash = class extends 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);
+        const keys = await this.#db.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);
             }
@@ -785,6 +947,9 @@ var StoreMemoryUpstash = class extends 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(TABLE_THREADS, { id: threadId });
@@ -802,7 +967,7 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_DELETE_MESSAGES_FAILED",
+          id: createStorageErrorId("UPSTASH", "DELETE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { messageIds: messageIds.join(", ") }
@@ -822,182 +987,137 @@ var StoreMemoryUpstash = class extends MemoryStorage {
       }
     });
   }
-};
-var StoreOperationsUpstash = class extends StoreOperations {
-  client;
-  constructor({ client }) {
-    super();
-    this.client = client;
-  }
-  async createTable({
-    tableName: _tableName,
-    schema: _schema
-  }) {
-  }
-  async alterTable({
-    tableName: _tableName,
-    schema: _schema,
-    ifNotExists: _ifNotExists
-  }) {
-  }
-  async clearTable({ tableName }) {
-    const pattern = `${tableName}:*`;
-    try {
-      await this.scanAndDelete(pattern);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_CLEAR_TABLE_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error
-      );
+  async cloneThread(args) {
+    const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
+    const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
+    if (!sourceThread) {
+      throw new MastraError({
+        id: createStorageErrorId("UPSTASH", "CLONE_THREAD", "SOURCE_NOT_FOUND"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Source thread with id ${sourceThreadId} not found`,
+        details: { sourceThreadId }
+      });
     }
-  }
-  async dropTable({ tableName }) {
-    return this.clearTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    const { key, processedRecord } = processRecord(tableName, record);
-    try {
-      await this.client.set(key, processedRecord);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_INSERT_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error
-      );
+    const newThreadId = providedThreadId || crypto.randomUUID();
+    const existingThread = await this.getThreadById({ threadId: newThreadId });
+    if (existingThread) {
+      throw new MastraError({
+        id: createStorageErrorId("UPSTASH", "CLONE_THREAD", "THREAD_EXISTS"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Thread with id ${newThreadId} already exists`,
+        details: { newThreadId }
+      });
     }
-  }
-  async batchInsert(input) {
-    const { tableName, records } = input;
-    if (!records.length) return;
-    const batchSize = 1e3;
     try {
-      for (let i = 0; i < records.length; i += batchSize) {
-        const batch = records.slice(i, i + batchSize);
-        const pipeline = this.client.pipeline();
-        for (const record of batch) {
-          const { key, processedRecord } = processRecord(tableName, record);
-          pipeline.set(key, processedRecord);
-        }
-        await pipeline.exec();
+      const threadMessagesKey = getThreadMessagesKey(sourceThreadId);
+      const messageIds = await this.client.zrange(threadMessagesKey, 0, -1);
+      const pipeline = this.client.pipeline();
+      for (const mid of messageIds) {
+        pipeline.get(getMessageKey(sourceThreadId, mid));
       }
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_BATCH_INSERT_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+      const results = await pipeline.exec();
+      let sourceMessages = results.filter((msg) => msg !== null).map((msg) => ({
+        ...msg,
+        createdAt: new Date(msg.createdAt)
+      }));
+      if (options?.messageFilter?.startDate || options?.messageFilter?.endDate) {
+        sourceMessages = filterByDateRange(sourceMessages, (msg) => new Date(msg.createdAt), {
+          start: options.messageFilter?.startDate,
+          end: options.messageFilter?.endDate
+        });
+      }
+      if (options?.messageFilter?.messageIds && options.messageFilter.messageIds.length > 0) {
+        const messageIdSet = new Set(options.messageFilter.messageIds);
+        sourceMessages = sourceMessages.filter((msg) => messageIdSet.has(msg.id));
+      }
+      sourceMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      if (options?.messageLimit && options.messageLimit > 0 && sourceMessages.length > options.messageLimit) {
+        sourceMessages = sourceMessages.slice(-options.messageLimit);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const lastMessageId = sourceMessages.length > 0 ? sourceMessages[sourceMessages.length - 1].id : void 0;
+      const cloneMetadata = {
+        sourceThreadId,
+        clonedAt: now,
+        ...lastMessageId && { lastMessageId }
+      };
+      const newThread = {
+        id: newThreadId,
+        resourceId: resourceId || sourceThread.resourceId,
+        title: title || (sourceThread.title ? `Clone of ${sourceThread.title}` : void 0),
+        metadata: {
+          ...metadata,
+          clone: cloneMetadata
         },
-        error
-      );
-    }
-  }
-  async load({ tableName, keys }) {
-    const key = getKey(tableName, keys);
-    try {
-      const data = await this.client.get(key);
-      return data || null;
+        createdAt: now,
+        updatedAt: now
+      };
+      const writePipeline = this.client.pipeline();
+      const threadKey = getKey(TABLE_THREADS, { id: newThreadId });
+      writePipeline.set(threadKey, processRecord(TABLE_THREADS, newThread).processedRecord);
+      const clonedMessages = [];
+      const targetResourceId = resourceId || sourceThread.resourceId;
+      const newThreadMessagesKey = getThreadMessagesKey(newThreadId);
+      for (let i = 0; i < sourceMessages.length; i++) {
+        const sourceMsg = sourceMessages[i];
+        const newMessageId = crypto.randomUUID();
+        const { _index, ...restMsg } = sourceMsg;
+        const newMessage = {
+          ...restMsg,
+          id: newMessageId,
+          threadId: newThreadId,
+          resourceId: targetResourceId
+        };
+        const messageKey = getMessageKey(newThreadId, newMessageId);
+        writePipeline.set(messageKey, newMessage);
+        writePipeline.set(getMessageIndexKey(newMessageId), newThreadId);
+        writePipeline.zadd(newThreadMessagesKey, {
+          score: i,
+          member: newMessageId
+        });
+        clonedMessages.push(newMessage);
+      }
+      await writePipeline.exec();
+      return {
+        thread: newThread,
+        clonedMessages
+      };
     } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_LOAD_FAILED",
+          id: createStorageErrorId("UPSTASH", "CLONE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          details: { sourceThreadId, newThreadId }
         },
         error
       );
     }
   }
-  async hasColumn(_tableName, _column) {
-    return true;
-  }
-  async scanKeys(pattern, batchSize = 1e4) {
-    let cursor = "0";
-    let keys = [];
-    do {
-      const [nextCursor, batch] = await this.client.scan(cursor, {
-        match: pattern,
-        count: batchSize
-      });
-      keys.push(...batch);
-      cursor = nextCursor;
-    } while (cursor !== "0");
-    return keys;
-  }
-  async scanAndDelete(pattern, batchSize = 1e4) {
-    let cursor = "0";
-    let totalDeleted = 0;
-    do {
-      const [nextCursor, keys] = await this.client.scan(cursor, {
-        match: pattern,
-        count: batchSize
-      });
-      if (keys.length > 0) {
-        await this.client.del(...keys);
-        totalDeleted += keys.length;
-      }
-      cursor = nextCursor;
-    } while (cursor !== "0");
-    return totalDeleted;
-  }
 };
-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
-  };
+function transformScoreRow(row) {
+  return transformScoreRow$1(row);
 }
 var ScoresUpstash = class extends ScoresStorage {
   client;
-  operations;
-  constructor({ client, operations }) {
+  #db;
+  constructor(config) {
     super();
+    const client = resolveUpstashConfig(config);
     this.client = client;
-    this.operations = operations;
+    this.#db = new UpstashDB({ client });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: TABLE_SCORERS });
   }
   async getScoreById({ id }) {
     try {
-      const data = await this.operations.load({
+      const data = await this.#db.get({
         tableName: TABLE_SCORERS,
         keys: { id }
       });
@@ -1006,10 +1126,12 @@ var ScoresUpstash = class extends ScoresStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_SCORE_BY_ID_FAILED",
+          id: createStorageErrorId("UPSTASH", "GET_SCORE_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { id }
+          details: {
+            ...id && { id }
+          }
         },
         error
       );
@@ -1023,7 +1145,7 @@ var ScoresUpstash = class extends ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${TABLE_SCORERS}:*`;
-    const keys = await this.operations.scanKeys(pattern);
+    const keys = await this.#db.scanKeys(pattern);
     const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
@@ -1075,24 +1197,41 @@ var ScoresUpstash = class extends ScoresStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_SAVE_SCORE_VALIDATION_FAILED",
+          id: createStorageErrorId("UPSTASH", "SAVE_SCORE", "VALIDATION_FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
+          category: ErrorCategory.USER,
+          details: {
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
+          }
         },
         error
       );
     }
-    const { key, processedRecord } = processRecord(TABLE_SCORERS, validatedScore);
+    const now = /* @__PURE__ */ new Date();
+    const id = crypto.randomUUID();
+    const createdAt = now;
+    const updatedAt = now;
+    const scoreWithId = {
+      ...validatedScore,
+      id,
+      createdAt,
+      updatedAt
+    };
+    const { key, processedRecord } = processRecord(TABLE_SCORERS, scoreWithId);
     try {
       await this.client.set(key, processedRecord);
-      return { score };
+      return { score: { ...validatedScore, id, createdAt, updatedAt } };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_SAVE_SCORE_FAILED",
+          id: createStorageErrorId("UPSTASH", "SAVE_SCORE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { id: score.id }
+          details: { id }
         },
         error
       );
@@ -1103,7 +1242,7 @@ var ScoresUpstash = class extends ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${TABLE_SCORERS}:*`;
-    const keys = await this.operations.scanKeys(pattern);
+    const keys = await this.#db.scanKeys(pattern);
     const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
@@ -1147,7 +1286,7 @@ var ScoresUpstash = class extends ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${TABLE_SCORERS}:*`;
-    const keys = await this.operations.scanKeys(pattern);
+    const keys = await this.#db.scanKeys(pattern);
     const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
@@ -1196,7 +1335,7 @@ var ScoresUpstash = class extends ScoresStorage {
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${TABLE_SCORERS}:*`;
-    const keys = await this.operations.scanKeys(pattern);
+    const keys = await this.#db.scanKeys(pattern);
     const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
@@ -1240,52 +1379,129 @@ var ScoresUpstash = class extends ScoresStorage {
     };
   }
 };
-function parseWorkflowRun(row) {
-  let parsedSnapshot = row.snapshot;
-  if (typeof parsedSnapshot === "string") {
-    try {
-      parsedSnapshot = JSON.parse(row.snapshot);
-    } catch (e) {
-      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-    }
-  }
-  return {
-    workflowName: row.workflow_name,
-    runId: row.run_id,
-    snapshot: parsedSnapshot,
-    createdAt: ensureDate(row.createdAt),
-    updatedAt: ensureDate(row.updatedAt),
-    resourceId: row.resourceId
-  };
-}
 var WorkflowsUpstash = class extends WorkflowsStorage {
   client;
-  operations;
-  constructor({ client, operations }) {
+  #db;
+  constructor(config) {
     super();
+    const client = resolveUpstashConfig(config);
     this.client = client;
-    this.operations = operations;
-  }
-  updateWorkflowResults({
-    // workflowName,
-    // runId,
-    // stepId,
-    // result,
-    // requestContext,
+    this.#db = new UpstashDB({ client });
+  }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: ensureDate(row.createdAt),
+      updatedAt: ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: TABLE_WORKFLOW_SNAPSHOT });
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
   }) {
-    throw new Error("Method not implemented.");
+    try {
+      const existingSnapshot = await this.loadWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId
+      });
+      let snapshot;
+      if (!existingSnapshot) {
+        snapshot = {
+          context: {},
+          activePaths: [],
+          timestamp: Date.now(),
+          suspendedPaths: {},
+          activeStepsPath: {},
+          resumeLabels: {},
+          serializedStepGraph: [],
+          status: "pending",
+          value: {},
+          waitingPaths: {},
+          runId,
+          requestContext: {}
+        };
+      } else {
+        snapshot = existingSnapshot;
+      }
+      snapshot.context[stepId] = result;
+      snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+      await this.persistWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId,
+        snapshot
+      });
+      return snapshot.context;
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId, stepId }
+        },
+        error
+      );
+    }
   }
-  updateWorkflowState({
-    // workflowName,
-    // runId,
-    // opts,
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
   }) {
-    throw new Error("Method not implemented.");
+    try {
+      const existingSnapshot = await this.loadWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId
+      });
+      if (!existingSnapshot || !existingSnapshot.context) {
+        return void 0;
+      }
+      const updatedSnapshot = { ...existingSnapshot, ...opts };
+      await this.persistWorkflowSnapshot({
+        namespace: "workflows",
+        workflowName,
+        runId,
+        snapshot: updatedSnapshot
+      });
+      return updatedSnapshot;
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "UPDATE_WORKFLOW_STATE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
+    }
   }
   async persistWorkflowSnapshot(params) {
-    const { namespace = "workflows", workflowName, runId, resourceId, snapshot } = params;
+    const { namespace = "workflows", workflowName, runId, resourceId, snapshot, createdAt, updatedAt } = params;
     try {
-      await this.operations.insert({
+      await this.#db.insert({
         tableName: TABLE_WORKFLOW_SNAPSHOT,
         record: {
           namespace,
@@ -1293,14 +1509,14 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
           run_id: runId,
           resourceId,
           snapshot,
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
+          createdAt: createdAt ?? /* @__PURE__ */ new Date(),
+          updatedAt: updatedAt ?? /* @__PURE__ */ new Date()
         }
       });
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          id: createStorageErrorId("UPSTASH", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -1327,7 +1543,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          id: createStorageErrorId("UPSTASH", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -1346,7 +1562,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
   }) {
     try {
       const key = getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName, run_id: runId }) + "*";
-      const keys = await this.operations.scanKeys(key);
+      const keys = await this.#db.scanKeys(key);
       const workflows = await Promise.all(
         keys.map(async (key2) => {
           const data2 = await this.client.get(key2);
@@ -1355,11 +1571,11 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
       );
       const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
       if (!data) return null;
-      return parseWorkflowRun(data);
+      return this.parseWorkflowRun(data);
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          id: createStorageErrorId("UPSTASH", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -1372,6 +1588,26 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
       );
     }
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    const key = getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName, run_id: runId });
+    try {
+      await this.client.del(key);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace: "workflows",
+            runId,
+            workflowName
+          }
+        },
+        error
+      );
+    }
+  }
   async listWorkflowRuns({
     workflowName,
     fromDate,
@@ -1380,12 +1616,12 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
     page,
     resourceId,
     status
-  }) {
+  } = {}) {
     try {
       if (page !== void 0 && page < 0) {
         throw new MastraError(
           {
-            id: "UPSTASH_STORE_INVALID_PAGE",
+            id: createStorageErrorId("UPSTASH", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
             domain: ErrorDomain.STORAGE,
             category: ErrorCategory.USER,
             details: { page }
@@ -1411,7 +1647,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
           resourceId
         });
       }
-      const keys = await this.operations.scanKeys(pattern);
+      const keys = await this.#db.scanKeys(pattern);
       if (keys.length === 0) {
         return { runs: [], total: 0 };
       }
@@ -1420,7 +1656,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
       const results = await pipeline.exec();
       let runs = results.map((result) => result).filter(
         (record) => record !== null && record !== void 0 && typeof record === "object" && "workflow_name" in record
-      ).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => parseWorkflowRun(w)).filter((w) => {
+      ).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => this.parseWorkflowRun(w)).filter((w) => {
         if (fromDate && w.createdAt < fromDate) return false;
         if (toDate && w.createdAt > toDate) return false;
         if (status) {
@@ -1429,7 +1665,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
             try {
               snapshot = JSON.parse(snapshot);
             } catch (e) {
-              console.warn(`Failed to parse snapshot for workflow ${w.workflowName}: ${e}`);
+              this.logger.warn(`Failed to parse snapshot for workflow ${w.workflowName}: ${e}`);
               return false;
             }
           }
@@ -1445,9 +1681,10 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
       }
       return { runs, total };
     } catch (error) {
+      if (error instanceof MastraError) throw error;
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_LIST_WORKFLOW_RUNS_FAILED",
+          id: createStorageErrorId("UPSTASH", "LIST_WORKFLOW_RUNS", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -1463,179 +1700,39 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
 };
 
 // src/storage/index.ts
+var isClientConfig = (config) => {
+  return "client" in config;
+};
 var UpstashStore = class extends MastraStorage {
   redis;
   stores;
   constructor(config) {
-    super({ id: config.id, name: "Upstash" });
-    this.redis = new Redis({
-      url: config.url,
-      token: config.token
-    });
-    const operations = new StoreOperationsUpstash({ client: this.redis });
-    const scores = new ScoresUpstash({ client: this.redis, operations });
-    const workflows = new WorkflowsUpstash({ client: this.redis, operations });
-    const memory = new StoreMemoryUpstash({ client: this.redis, operations });
+    super({ id: config.id, name: "Upstash", disableInit: config.disableInit });
+    if (isClientConfig(config)) {
+      this.redis = config.client;
+    } else {
+      if (!config.url || typeof config.url !== "string" || config.url.trim() === "") {
+        throw new Error("UpstashStore: url is required and cannot be empty.");
+      }
+      if (!config.token || typeof config.token !== "string" || config.token.trim() === "") {
+        throw new Error("UpstashStore: token is required and cannot be empty.");
+      }
+      this.redis = new Redis({
+        url: config.url,
+        token: config.token
+      });
+    }
+    const scores = new ScoresUpstash({ client: this.redis });
+    const workflows = new WorkflowsUpstash({ client: this.redis });
+    const memory = new StoreMemoryUpstash({ client: this.redis });
     this.stores = {
-      operations,
       scores,
       workflows,
       memory
     };
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: false,
-      createTable: false,
-      deleteMessages: true,
-      listScoresBySpan: true
-    };
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-  /**
-   * No-op: This backend is schemaless and does not require schema changes.
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
-  async alterTable(args) {
-    return this.stores.operations.alterTable(args);
-  }
-  async clearTable({ tableName }) {
-    return this.stores.operations.clearTable({ tableName });
-  }
-  async dropTable({ tableName }) {
-    return this.stores.operations.dropTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    return this.stores.operations.insert({ tableName, record });
-  }
-  async batchInsert(input) {
-    return this.stores.operations.batchInsert(input);
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
-  async getThreadById({ threadId }) {
-    return this.stores.memory.getThreadById({ threadId });
-  }
-  async saveThread({ thread }) {
-    return this.stores.memory.saveThread({ thread });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.stores.memory.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    return this.stores.memory.deleteThread({ threadId });
-  }
-  async saveMessages(args) {
-    return this.stores.memory.saveMessages(args);
-  }
-  async listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
-  }
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot(params) {
-    return this.stores.workflows.persistWorkflowSnapshot(params);
-  }
-  async loadWorkflowSnapshot(params) {
-    return this.stores.workflows.loadWorkflowSnapshot(params);
-  }
-  async listWorkflowRuns(args = {}) {
-    return this.stores.workflows.listWorkflowRuns(args);
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
   async close() {
   }
-  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 });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
-  }
-  async getScoreById({ id: _id }) {
-    return this.stores.scores.getScoreById({ id: _id });
-  }
-  async saveScore(score) {
-    return this.stores.scores.saveScore(score);
-  }
-  async listScoresByRunId({
-    runId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByRunId({ runId, pagination });
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({
-      entityId,
-      entityType,
-      pagination
-    });
-  }
-  async listScoresByScorerId({
-    scorerId,
-    pagination,
-    entityId,
-    entityType,
-    source
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
-  }
 };
 var UpstashFilterTranslator = class extends BaseFilterTranslator {
   getSupportedOperators() {
@@ -1873,7 +1970,7 @@ var UpstashVector = class extends MastraVector {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_VECTOR_UPSERT_FAILED",
+          id: createVectorErrorId("UPSTASH", "UPSERT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { namespace, vectorCount: vectors.length }
@@ -1936,7 +2033,7 @@ var UpstashVector = class extends MastraVector {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_VECTOR_QUERY_FAILED",
+          id: createVectorErrorId("UPSTASH", "QUERY", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { namespace, topK }
@@ -1956,7 +2053,7 @@ var UpstashVector = class extends MastraVector {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_VECTOR_LIST_INDEXES_FAILED",
+          id: createVectorErrorId("UPSTASH", "LIST_INDEXES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -1981,7 +2078,7 @@ var UpstashVector = class extends MastraVector {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_VECTOR_DESCRIBE_INDEX_FAILED",
+          id: createVectorErrorId("UPSTASH", "DESCRIBE_INDEX", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { namespace }
@@ -1999,9 +2096,14 @@ var UpstashVector = class extends MastraVector {
     try {
       await this.client.deleteNamespace(namespace);
     } catch (error) {
+      const errorMessage = error?.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 MastraError(
         {
-          id: "STORAGE_UPSTASH_VECTOR_DELETE_INDEX_FAILED",
+          id: createVectorErrorId("UPSTASH", "DELETE_INDEX", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { namespace }
@@ -2011,47 +2113,124 @@ var UpstashVector = class extends 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 MastraError({
+        id: createVectorErrorId("UPSTASH", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
+        text: "Cannot specify both id and filter - they are mutually exclusive",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (!("id" in params && params.id) && !("filter" in params && params.filter)) {
+      throw new MastraError({
+        id: createVectorErrorId("UPSTASH", "UPDATE_VECTOR", "NO_TARGET"),
+        text: "Either id or filter must be provided",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (!update.vector && !update.metadata && !sparseVector) {
       throw new MastraError({
-        id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+        id: createVectorErrorId("UPSTASH", "UPDATE_VECTOR", "NO_PAYLOAD"),
+        text: "No update data provided",
         domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.THIRD_PARTY,
-        details: { namespace, id },
-        text: "No update data provided"
+        category: ErrorCategory.USER,
+        details: { namespace }
       });
     }
-    if (!update.vector && !update.sparseVector && update.metadata) {
+    if ("filter" in params && params.filter && Object.keys(params.filter).length === 0) {
       throw new MastraError({
-        id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+        id: createVectorErrorId("UPSTASH", "UPDATE_VECTOR", "EMPTY_FILTER"),
+        text: "Filter cannot be an empty filter object",
         domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.THIRD_PARTY,
-        details: { namespace, id },
-        text: "Both vector and metadata must be provided for an update"
+        category: 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) {
+      if (error instanceof MastraError) throw error;
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED",
+          id: createVectorErrorId("UPSTASH", "UPDATE_VECTOR", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: 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
       );
@@ -2066,22 +2245,109 @@ var UpstashVector = class extends 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) {
       const mastraError = new MastraError(
         {
-          id: "STORAGE_UPSTASH_VECTOR_DELETE_VECTOR_FAILED",
+          id: createVectorErrorId("UPSTASH", "DELETE_VECTOR", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { namespace, id }
+          details: {
+            namespace,
+            ...id && { id }
+          }
         },
         error
       );
       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 MastraError({
+        id: createVectorErrorId("UPSTASH", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
+        text: "Cannot specify both ids and filter - they are mutually exclusive",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (!ids && !filter) {
+      throw new MastraError({
+        id: createVectorErrorId("UPSTASH", "DELETE_VECTORS", "NO_TARGET"),
+        text: "Either filter or ids must be provided",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (ids && ids.length === 0) {
+      throw new MastraError({
+        id: createVectorErrorId("UPSTASH", "DELETE_VECTORS", "EMPTY_IDS"),
+        text: "Cannot delete with empty ids array",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { namespace }
+      });
+    }
+    if (filter && Object.keys(filter).length === 0) {
+      throw new MastraError({
+        id: createVectorErrorId("UPSTASH", "DELETE_VECTORS", "EMPTY_FILTER"),
+        text: "Cannot delete with empty filter object",
+        domain: ErrorDomain.STORAGE,
+        category: 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) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createVectorErrorId("UPSTASH", "DELETE_VECTORS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            ...filter && { filter: JSON.stringify(filter) },
+            ...ids && { idsCount: ids.length }
+          }
+        },
+        error
+      );
+    }
+  }
 };
 
 // src/vector/prompt.ts
@@ -2159,6 +2425,6 @@ Example Complex Query:
   ]
 }`;
 
-export { UPSTASH_PROMPT, UpstashStore, UpstashVector };
+export { ScoresUpstash, StoreMemoryUpstash, UPSTASH_PROMPT, UpstashStore, UpstashVector, WorkflowsUpstash };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map