@mastra/upstash 0.11.1-alpha.0 → 0.11.1-alpha.2

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var agent = require('@mastra/core/agent');
+var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
 var redis = require('@upstash/redis');
 var vector = require('@mastra/core/vector');
@@ -19,7 +20,8 @@ var UpstashStore = class extends storage.MastraStorage {
   }
   get supports() {
     return {
-      selectByIncludeResourceScope: true
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true
     };
   }
   transformEvalRecord(record) {
@@ -198,8 +200,18 @@ var UpstashStore = class extends storage.MastraStorage {
         });
       }
       return filteredEvals.map((record) => this.transformEvalRecord(record));
-    } catch (error) {
-      console.error("Failed to get evals for the specified agent:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return [];
     }
   }
@@ -213,8 +225,19 @@ var UpstashStore = class extends storage.MastraStorage {
         end: args.toDate
       };
     }
-    const { traces } = await this.getTracesPaginated(args);
-    return traces;
+    try {
+      const { traces } = await this.getTracesPaginated(args);
+      return traces;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   async getTracesPaginated(args) {
     const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
@@ -297,8 +320,21 @@ var UpstashStore = class extends storage.MastraStorage {
         perPage: resolvedPerPage,
         hasMore
       };
-    } catch (error) {
-      console.error("Failed to get traces:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name || "",
+            scope: args.scope || ""
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return {
         traces: [],
         total: 0,
@@ -312,7 +348,21 @@ var UpstashStore = class extends storage.MastraStorage {
     tableName,
     schema
   }) {
-    await this.redis.set(`schema:${tableName}`, schema);
+    try {
+      await this.redis.set(`schema:${tableName}`, schema);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_CREATE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
   }
   /**
    * No-op: This backend is schemaless and does not require schema changes.
@@ -324,43 +374,113 @@ var UpstashStore = class extends storage.MastraStorage {
   }
   async clearTable({ tableName }) {
     const pattern = `${tableName}:*`;
-    await this.scanAndDelete(pattern);
+    try {
+      await this.scanAndDelete(pattern);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_CLEAR_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
   }
   async insert({ tableName, record }) {
     const { key, processedRecord } = this.processRecord(tableName, record);
-    await this.redis.set(key, processedRecord);
+    try {
+      await this.redis.set(key, processedRecord);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
   }
   async batchInsert(input) {
     const { tableName, records } = input;
     if (!records.length) return;
     const batchSize = 1e3;
-    for (let i = 0; i < records.length; i += batchSize) {
-      const batch = records.slice(i, i + batchSize);
-      const pipeline = this.redis.pipeline();
-      for (const record of batch) {
-        const { key, processedRecord } = this.processRecord(tableName, record);
-        pipeline.set(key, processedRecord);
+    try {
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const pipeline = this.redis.pipeline();
+        for (const record of batch) {
+          const { key, processedRecord } = this.processRecord(tableName, record);
+          pipeline.set(key, processedRecord);
+        }
+        await pipeline.exec();
       }
-      await pipeline.exec();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_BATCH_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
     }
   }
   async load({ tableName, keys }) {
     const key = this.getKey(tableName, keys);
-    const data = await this.redis.get(key);
-    return data || null;
+    try {
+      const data = await this.redis.get(key);
+      return data || null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_LOAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
   }
   async getThreadById({ threadId }) {
-    const thread = await this.load({
-      tableName: storage.TABLE_THREADS,
-      keys: { id: threadId }
-    });
-    if (!thread) return null;
-    return {
-      ...thread,
-      createdAt: this.ensureDate(thread.createdAt),
-      updatedAt: this.ensureDate(thread.updatedAt),
-      metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
-    };
+    try {
+      const thread = await this.load({
+        tableName: storage.TABLE_THREADS,
+        keys: { id: threadId }
+      });
+      if (!thread) return null;
+      return {
+        ...thread,
+        createdAt: this.ensureDate(thread.createdAt),
+        updatedAt: this.ensureDate(thread.updatedAt),
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_THREAD_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    }
   }
   /**
    * @deprecated use getThreadsByResourceIdPaginated instead
@@ -389,8 +509,20 @@ var UpstashStore = class extends storage.MastraStorage {
       }
       allThreads.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
       return allThreads;
-    } catch (error) {
-      console.error("Error in getThreadsByResourceId:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return [];
     }
   }
@@ -410,8 +542,22 @@ var UpstashStore = class extends storage.MastraStorage {
         perPage,
         hasMore
       };
-    } catch (error) {
-      console.error("Error in getThreadsByResourceIdPaginated:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId,
+            page,
+            perPage
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return {
         threads: [],
         total: 0,
@@ -422,11 +568,28 @@ var UpstashStore = class extends storage.MastraStorage {
     }
   }
   async saveThread({ thread }) {
-    await this.insert({
-      tableName: storage.TABLE_THREADS,
-      record: thread
-    });
-    return thread;
+    try {
+      await this.insert({
+        tableName: storage.TABLE_THREADS,
+        record: thread
+      });
+      return thread;
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_SAVE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: thread.id
+          }
+        },
+        error$1
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
+      throw mastraError;
+    }
   }
   async updateThread({
     id,
@@ -435,7 +598,15 @@ var UpstashStore = class extends storage.MastraStorage {
   }) {
     const thread = await this.getThreadById({ threadId: id });
     if (!thread) {
-      throw new Error(`Thread ${id} not found`);
+      throw new error.MastraError({
+        id: "STORAGE_UPSTASH_STORAGE_UPDATE_THREAD_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread ${id} not found`,
+        details: {
+          threadId: id
+        }
+      });
     }
     const updatedThread = {
       ...thread,
@@ -445,34 +616,73 @@ var UpstashStore = class extends storage.MastraStorage {
         ...metadata
       }
     };
-    await this.saveThread({ thread: updatedThread });
-    return updatedThread;
+    try {
+      await this.saveThread({ thread: updatedThread });
+      return updatedThread;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_UPDATE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id
+          }
+        },
+        error$1
+      );
+    }
   }
   async deleteThread({ threadId }) {
     const threadKey = this.getKey(storage.TABLE_THREADS, { id: threadId });
     const threadMessagesKey = this.getThreadMessagesKey(threadId);
-    const messageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-    const pipeline = this.redis.pipeline();
-    pipeline.del(threadKey);
-    pipeline.del(threadMessagesKey);
-    for (let i = 0; i < messageIds.length; i++) {
-      const messageId = messageIds[i];
-      const messageKey = this.getMessageKey(threadId, messageId);
-      pipeline.del(messageKey);
+    try {
+      const messageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
+      const pipeline = this.redis.pipeline();
+      pipeline.del(threadKey);
+      pipeline.del(threadMessagesKey);
+      for (let i = 0; i < messageIds.length; i++) {
+        const messageId = messageIds[i];
+        const messageKey = this.getMessageKey(threadId, messageId);
+        pipeline.del(messageKey);
+      }
+      await pipeline.exec();
+      await this.scanAndDelete(this.getMessageKey(threadId, "*"));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_DELETE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
     }
-    await pipeline.exec();
-    await this.scanAndDelete(this.getMessageKey(threadId, "*"));
   }
   async saveMessages(args) {
     const { messages, format = "v1" } = args;
     if (messages.length === 0) return [];
     const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      throw new Error("Thread ID is required");
-    }
-    const thread = await this.getThreadById({ threadId });
-    if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+    try {
+      if (!threadId) {
+        throw new Error("Thread ID is required");
+      }
+      const thread = await this.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_SAVE_MESSAGES_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
     }
     const messagesWithIndex = messages.map((message, index) => ({
       ...message,
@@ -480,32 +690,63 @@ var UpstashStore = class extends storage.MastraStorage {
     }));
     const threadKey = this.getKey(storage.TABLE_THREADS, { id: threadId });
     const existingThread = await this.redis.get(threadKey);
-    const batchSize = 1e3;
-    for (let i = 0; i < messagesWithIndex.length; i += batchSize) {
-      const batch = messagesWithIndex.slice(i, i + batchSize);
-      const pipeline = this.redis.pipeline();
-      for (const message of batch) {
-        const key = this.getMessageKey(message.threadId, message.id);
-        const createdAtScore = new Date(message.createdAt).getTime();
-        const score = message._index !== void 0 ? message._index : createdAtScore;
-        pipeline.set(key, message);
-        pipeline.zadd(this.getThreadMessagesKey(message.threadId), {
-          score,
-          member: message.id
-        });
-      }
-      if (i === 0 && existingThread) {
-        const updatedThread = {
-          ...existingThread,
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        pipeline.set(threadKey, this.processRecord(storage.TABLE_THREADS, updatedThread).processedRecord);
+    try {
+      const batchSize = 1e3;
+      for (let i = 0; i < messagesWithIndex.length; i += batchSize) {
+        const batch = messagesWithIndex.slice(i, i + batchSize);
+        const pipeline = this.redis.pipeline();
+        for (const message of batch) {
+          const key = this.getMessageKey(message.threadId, message.id);
+          const createdAtScore = new Date(message.createdAt).getTime();
+          const score = message._index !== void 0 ? message._index : createdAtScore;
+          const existingKeyPattern = this.getMessageKey("*", message.id);
+          const keys = await this.scanKeys(existingKeyPattern);
+          if (keys.length > 0) {
+            const pipeline2 = this.redis.pipeline();
+            keys.forEach((key2) => pipeline2.get(key2));
+            const results = await pipeline2.exec();
+            const existingMessages = results.filter(
+              (msg) => msg !== null
+            );
+            for (const existingMessage of existingMessages) {
+              const existingMessageKey = this.getMessageKey(existingMessage.threadId, existingMessage.id);
+              if (existingMessage && existingMessage.threadId !== message.threadId) {
+                pipeline.del(existingMessageKey);
+                pipeline.zrem(this.getThreadMessagesKey(existingMessage.threadId), existingMessage.id);
+              }
+            }
+          }
+          pipeline.set(key, message);
+          pipeline.zadd(this.getThreadMessagesKey(message.threadId), {
+            score,
+            member: message.id
+          });
+        }
+        if (i === 0 && existingThread) {
+          const updatedThread = {
+            ...existingThread,
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          pipeline.set(threadKey, this.processRecord(storage.TABLE_THREADS, updatedThread).processedRecord);
+        }
+        await pipeline.exec();
       }
-      await pipeline.exec();
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_SAVE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
     }
-    const list = new agent.MessageList().add(messages, "memory");
-    if (format === `v2`) return list.get.all.v2();
-    return list.get.all.v1();
   }
   async _getIncludedMessages(threadId, selectBy) {
     const messageIds = /* @__PURE__ */ new Set();
@@ -550,63 +791,72 @@ var UpstashStore = class extends storage.MastraStorage {
     format
   }) {
     const threadMessagesKey = this.getThreadMessagesKey(threadId);
-    const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-    let limit;
-    if (typeof selectBy?.last === "number") {
-      limit = Math.max(0, selectBy.last);
-    } else if (selectBy?.last === false) {
-      limit = 0;
-    } else {
-      limit = Number.MAX_SAFE_INTEGER;
-    }
-    const messageIds = /* @__PURE__ */ new Set();
-    const messageIdToThreadIds = {};
-    if (limit === 0 && !selectBy?.include) {
-      return [];
-    }
-    if (limit === Number.MAX_SAFE_INTEGER) {
-      const allIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-      allIds.forEach((id) => {
-        messageIds.add(id);
-        messageIdToThreadIds[id] = threadId;
+    try {
+      const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
+      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+      const messageIds = /* @__PURE__ */ new Set();
+      const messageIdToThreadIds = {};
+      if (limit === 0 && !selectBy?.include) {
+        return [];
+      }
+      if (limit === Number.MAX_SAFE_INTEGER) {
+        const allIds = await this.redis.zrange(threadMessagesKey, 0, -1);
+        allIds.forEach((id) => {
+          messageIds.add(id);
+          messageIdToThreadIds[id] = threadId;
+        });
+      } else if (limit > 0) {
+        const latestIds = await this.redis.zrange(threadMessagesKey, -limit, -1);
+        latestIds.forEach((id) => {
+          messageIds.add(id);
+          messageIdToThreadIds[id] = threadId;
+        });
+      }
+      const includedMessages = await this._getIncludedMessages(threadId, selectBy);
+      const messages = [
+        ...includedMessages,
+        ...(await Promise.all(
+          Array.from(messageIds).map(async (id) => {
+            const tId = messageIdToThreadIds[id] || threadId;
+            const byThreadId = await this.redis.get(
+              this.getMessageKey(tId, id)
+            );
+            if (byThreadId) return byThreadId;
+            return null;
+          })
+        )).filter((msg) => msg !== null)
+      ];
+      messages.sort((a, b) => allMessageIds.indexOf(a.id) - allMessageIds.indexOf(b.id));
+      const seen = /* @__PURE__ */ new Set();
+      const dedupedMessages = messages.filter((row) => {
+        if (seen.has(row.id)) return false;
+        seen.add(row.id);
+        return true;
       });
-    } else if (limit > 0) {
-      const latestIds = await this.redis.zrange(threadMessagesKey, -limit, -1);
-      latestIds.forEach((id) => {
-        messageIds.add(id);
-        messageIdToThreadIds[id] = threadId;
+      const prepared = dedupedMessages.filter((message) => message !== null && message !== void 0).map((message) => {
+        const { _index, ...messageWithoutIndex } = message;
+        return messageWithoutIndex;
       });
+      if (format === "v2") {
+        return prepared.map((msg) => ({
+          ...msg,
+          content: msg.content || { format: 2, parts: [{ type: "text", text: "" }] }
+        }));
+      }
+      return prepared;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
     }
-    const includedMessages = await this._getIncludedMessages(threadId, selectBy);
-    const messages = [
-      ...includedMessages,
-      ...(await Promise.all(
-        Array.from(messageIds).map(async (id) => {
-          const tId = messageIdToThreadIds[id] || threadId;
-          const byThreadId = await this.redis.get(this.getMessageKey(tId, id));
-          if (byThreadId) return byThreadId;
-          return null;
-        })
-      )).filter((msg) => msg !== null)
-    ];
-    messages.sort((a, b) => allMessageIds.indexOf(a.id) - allMessageIds.indexOf(b.id));
-    const seen = /* @__PURE__ */ new Set();
-    const dedupedMessages = messages.filter((row) => {
-      if (seen.has(row.id)) return false;
-      seen.add(row.id);
-      return true;
-    });
-    const prepared = dedupedMessages.filter((message) => message !== null && message !== void 0).map((message) => {
-      const { _index, ...messageWithoutIndex } = message;
-      return messageWithoutIndex;
-    });
-    if (format === "v2") {
-      return prepared.map((msg) => ({
-        ...msg,
-        content: msg.content || { format: 2, parts: [{ type: "text", text: "" }] }
-      }));
-    }
-    return prepared;
   }
   async getMessagesPaginated(args) {
     const { threadId, selectBy, format } = args;
@@ -615,9 +865,9 @@ var UpstashStore = class extends storage.MastraStorage {
     const toDate = dateRange?.end;
     const threadMessagesKey = this.getThreadMessagesKey(threadId);
     const messages = [];
-    const includedMessages = await this._getIncludedMessages(threadId, selectBy);
-    messages.push(...includedMessages);
     try {
+      const includedMessages = await this._getIncludedMessages(threadId, selectBy);
+      messages.push(...includedMessages);
       const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
       if (allMessageIds.length === 0) {
         return {
@@ -654,8 +904,20 @@ var UpstashStore = class extends storage.MastraStorage {
         perPage,
         hasMore
       };
-    } catch (error) {
-      console.error("Failed to get paginated messages:", error);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return {
         messages: [],
         total: 0,
@@ -667,17 +929,33 @@ var UpstashStore = class extends storage.MastraStorage {
   }
   async persistWorkflowSnapshot(params) {
     const { namespace = "workflows", workflowName, runId, snapshot } = params;
-    await this.insert({
-      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-      record: {
-        namespace,
-        workflow_name: workflowName,
-        run_id: runId,
-        snapshot,
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      }
-    });
+    try {
+      await this.insert({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace,
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
   }
   async loadWorkflowSnapshot(params) {
     const { namespace = "workflows", workflowName, runId } = params;
@@ -686,9 +964,25 @@ var UpstashStore = class extends storage.MastraStorage {
       workflow_name: workflowName,
       run_id: runId
     });
-    const data = await this.redis.get(key);
-    if (!data) return null;
-    return data.snapshot;
+    try {
+      const data = await this.redis.get(key);
+      if (!data) return null;
+      return data.snapshot;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Get all evaluations with pagination and total count
@@ -775,9 +1069,22 @@ var UpstashStore = class extends storage.MastraStorage {
         perPage,
         hasMore
       };
-    } catch (error) {
+    } catch (error$1) {
       const { page = 0, perPage = 100 } = options || {};
-      console.error("Failed to get evals:", error);
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_EVALS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            page,
+            perPage
+          }
+        },
+        error$1
+      );
+      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return {
         evals: [],
         total: 0,
@@ -829,9 +1136,20 @@ var UpstashStore = class extends storage.MastraStorage {
         runs = runs.slice(offset, offset + limit);
       }
       return { runs, total };
-    } catch (error) {
-      console.error("Error getting workflow runs:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUNS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            workflowName: workflowName || "",
+            resourceId: resourceId || ""
+          }
+        },
+        error$1
+      );
     }
   }
   async getWorkflowRunById({
@@ -851,9 +1169,20 @@ var UpstashStore = class extends storage.MastraStorage {
       const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
       if (!data) return null;
       return this.parseWorkflowRun(data);
-    } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            runId,
+            workflowName: workflowName || ""
+          }
+        },
+        error$1
+      );
     }
   }
   async close() {
@@ -862,6 +1191,75 @@ var UpstashStore = class extends storage.MastraStorage {
     this.logger.error("updateMessages is not yet implemented in UpstashStore");
     throw new Error("Method not implemented");
   }
+  async getResourceById({ resourceId }) {
+    try {
+      const key = `${storage.TABLE_RESOURCES}:${resourceId}`;
+      const data = await this.redis.get(key);
+      if (!data) {
+        return null;
+      }
+      return {
+        ...data,
+        createdAt: new Date(data.createdAt),
+        updatedAt: new Date(data.updatedAt),
+        // Ensure workingMemory is always returned as a string, regardless of automatic parsing
+        workingMemory: typeof data.workingMemory === "object" ? JSON.stringify(data.workingMemory) : data.workingMemory,
+        metadata: typeof data.metadata === "string" ? JSON.parse(data.metadata) : data.metadata
+      };
+    } catch (error) {
+      this.logger.error("Error getting resource by ID:", error);
+      throw error;
+    }
+  }
+  async saveResource({ resource }) {
+    try {
+      const key = `${storage.TABLE_RESOURCES}:${resource.id}`;
+      const serializedResource = {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata),
+        createdAt: resource.createdAt.toISOString(),
+        updatedAt: resource.updatedAt.toISOString()
+      };
+      await this.redis.set(key, serializedResource);
+      return resource;
+    } catch (error) {
+      this.logger.error("Error saving resource:", error);
+      throw error;
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    try {
+      const existingResource = await this.getResourceById({ resourceId });
+      if (!existingResource) {
+        const newResource = {
+          id: resourceId,
+          workingMemory,
+          metadata: metadata || {},
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        return this.saveResource({ resource: newResource });
+      }
+      const updatedResource = {
+        ...existingResource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+        metadata: {
+          ...existingResource.metadata,
+          ...metadata
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await this.saveResource({ resource: updatedResource });
+      return updatedResource;
+    } catch (error) {
+      this.logger.error("Error updating resource:", error);
+      throw error;
+    }
+  }
 };
 var UpstashFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
@@ -1083,14 +1481,26 @@ var UpstashVector = class extends vector.MastraVector {
       vector,
       metadata: metadata?.[index]
     }));
-    await this.client.upsert(points, {
-      namespace
-    });
-    return generatedIds;
+    try {
+      await this.client.upsert(points, {
+        namespace
+      });
+      return generatedIds;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace, vectorCount: vectors.length }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Transforms a Mastra vector filter into an Upstash-compatible filter string.
-   * @param {VectorFilter} [filter] - The filter to transform.
+   * @param {UpstashVectorFilter} [filter] - The filter to transform.
    * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
    */
   transformFilter(filter) {
@@ -1117,29 +1527,52 @@ var UpstashVector = class extends vector.MastraVector {
     filter,
     includeVector = false
   }) {
-    const ns = this.client.namespace(namespace);
-    const filterString = this.transformFilter(filter);
-    const results = await ns.query({
-      topK,
-      vector: queryVector,
-      includeVectors: includeVector,
-      includeMetadata: true,
-      ...filterString ? { filter: filterString } : {}
-    });
-    return (results || []).map((result) => ({
-      id: `${result.id}`,
-      score: result.score,
-      metadata: result.metadata,
-      ...includeVector && { vector: result.vector || [] }
-    }));
+    try {
+      const ns = this.client.namespace(namespace);
+      const filterString = this.transformFilter(filter);
+      const results = await ns.query({
+        topK,
+        vector: queryVector,
+        includeVectors: includeVector,
+        includeMetadata: true,
+        ...filterString ? { filter: filterString } : {}
+      });
+      return (results || []).map((result) => ({
+        id: `${result.id}`,
+        score: result.score,
+        metadata: result.metadata,
+        ...includeVector && { vector: result.vector || [] }
+      }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace, topK }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Lists all namespaces in the Upstash vector index, which correspond to indexes.
    * @returns {Promise<string[]>} A promise that resolves to a list of index names.
    */
   async listIndexes() {
-    const indexes = await this.client.listNamespaces();
-    return indexes.filter(Boolean);
+    try {
+      const indexes = await this.client.listNamespaces();
+      return indexes.filter(Boolean);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -1148,12 +1581,24 @@ var UpstashVector = class extends vector.MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName: namespace }) {
-    const info = await this.client.info();
-    return {
-      dimension: info.dimension,
-      count: info.namespaces?.[namespace]?.vectorCount || 0,
-      metric: info?.similarityFunction?.toLowerCase()
-    };
+    try {
+      const info = await this.client.info();
+      return {
+        dimension: info.dimension,
+        count: info.namespaces?.[namespace]?.vectorCount || 0,
+        metric: info?.similarityFunction?.toLowerCase()
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Deletes an index (namespace).
@@ -1163,8 +1608,16 @@ var UpstashVector = class extends vector.MastraVector {
   async deleteIndex({ indexName: namespace }) {
     try {
       await this.client.deleteNamespace(namespace);
-    } catch (error) {
-      this.logger.error("Failed to delete namespace:", error);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -1185,6 +1638,18 @@ var UpstashVector = class extends vector.MastraVector {
       if (!update.vector && update.metadata) {
         throw new Error("Both vector and metadata must be provided for an update");
       }
+    } catch (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 }
+        },
+        error$1
+      );
+    }
+    try {
       const updatePayload = { id };
       if (update.vector) {
         updatePayload.vector = update.vector;
@@ -1200,8 +1665,16 @@ var UpstashVector = class extends vector.MastraVector {
       await this.client.upsert(points, {
         namespace
       });
-    } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${namespace}: ${error.message}`);
+    } catch (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 }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -1216,8 +1689,17 @@ var UpstashVector = class extends vector.MastraVector {
       await this.client.delete(id, {
         namespace
       });
-    } catch (error) {
-      this.logger.error(`Failed to delete vector by id: ${id} for namespace: ${namespace}:`, error);
+    } 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 }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
     }
   }
 };