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

package/src/storage/index.ts

@@ -1,11 +1,13 @@
 import { MessageList } from '@mastra/core/agent';
 import type { MastraMessageContentV2, MastraMessageV2 } from '@mastra/core/agent';
+import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import type { MetricResult, TestInfo } from '@mastra/core/eval';
 import type { StorageThreadType, MastraMessageV1 } from '@mastra/core/memory';
 import {
   MastraStorage,
   TABLE_MESSAGES,
   TABLE_THREADS,
+  TABLE_RESOURCES,
   TABLE_WORKFLOW_SNAPSHOT,
   TABLE_EVALS,
   TABLE_TRACES,
@@ -14,6 +16,7 @@ import type {
   TABLE_NAMES,
   StorageColumn,
   StorageGetMessagesArg,
+  StorageResourceType,
   EvalRow,
   WorkflowRuns,
   WorkflowRun,
@@ -42,9 +45,11 @@ export class UpstashStore extends MastraStorage {
 
   public get supports(): {
     selectByIncludeResourceScope: boolean;
+    resourceWorkingMemory: boolean;
   } {
     return {
       selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
     };
   }
 
@@ -271,7 +276,17 @@ export class UpstashStore extends MastraStorage {
       // Transform to EvalRow format
       return filteredEvals.map(record => this.transformEvalRecord(record));
     } catch (error) {
-      console.error('Failed to get evals for the specified agent:', error);
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_EVALS_BY_AGENT_NAME_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName },
+        },
+        error,
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return [];
     }
   }
@@ -286,8 +301,19 @@ export class UpstashStore extends MastraStorage {
         end: args.toDate,
       };
     }
-    const { traces } = await this.getTracesPaginated(args);
-    return traces;
+    try {
+      const { traces } = await this.getTracesPaginated(args);
+      return traces;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_TRACES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+        },
+        error,
+      );
+    }
   }
 
   public async getTracesPaginated(
@@ -389,7 +415,20 @@ export class UpstashStore extends MastraStorage {
         hasMore,
       };
     } catch (error) {
-      console.error('Failed to get traces:', error);
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_TRACES_PAGINATED_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name || '',
+            scope: args.scope || '',
+          },
+        },
+        error,
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return {
         traces: [],
         total: 0,
@@ -409,7 +448,21 @@ export class UpstashStore extends MastraStorage {
   }): Promise<void> {
     // Redis is schemaless, so we don't need to create tables
     // But we can store the schema for reference
-    await this.redis.set(`schema:${tableName}`, schema);
+    try {
+      await this.redis.set(`schema:${tableName}`, schema);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_CREATE_TABLE_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+          },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -428,13 +481,41 @@ export class UpstashStore extends MastraStorage {
 
   async clearTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
     const pattern = `${tableName}:*`;
-    await this.scanAndDelete(pattern);
+    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 insert({ tableName, record }: { tableName: TABLE_NAMES; record: Record<string, any> }): Promise<void> {
     const { key, processedRecord } = this.processRecord(tableName, record);
 
-    await this.redis.set(key, processedRecord);
+    try {
+      await this.redis.set(key, processedRecord);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_INSERT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+          },
+        },
+        error,
+      );
+    }
   }
 
   async batchInsert(input: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
@@ -442,37 +523,79 @@ export class UpstashStore extends MastraStorage {
     if (!records.length) return;
 
     const batchSize = 1000;
-    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) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_BATCH_INSERT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+          },
+        },
+        error,
+      );
     }
   }
 
   async load<R>({ tableName, keys }: { tableName: TABLE_NAMES; keys: Record<string, string> }): Promise<R | null> {
     const key = this.getKey(tableName, keys);
-    const data = await this.redis.get<R>(key);
-    return data || null;
+    try {
+      const data = await this.redis.get<R>(key);
+      return data || null;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_LOAD_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+          },
+        },
+        error,
+      );
+    }
   }
 
   async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
-    const thread = await this.load<StorageThreadType>({
-      tableName: TABLE_THREADS,
-      keys: { id: threadId },
-    });
+    try {
+      const thread = await this.load<StorageThreadType>({
+        tableName: TABLE_THREADS,
+        keys: { id: threadId },
+      });
 
-    if (!thread) return null;
+      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,
-    };
+      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) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_THREAD_BY_ID_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+          },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -507,7 +630,19 @@ export class UpstashStore extends MastraStorage {
       allThreads.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
       return allThreads;
     } catch (error) {
-      console.error('Error in getThreadsByResourceId:', error);
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_THREADS_BY_RESOURCE_ID_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId,
+          },
+        },
+        error,
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return [];
     }
   }
@@ -536,7 +671,21 @@ export class UpstashStore extends MastraStorage {
         hasMore,
       };
     } catch (error) {
-      console.error('Error in getThreadsByResourceIdPaginated:', error);
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId,
+            page,
+            perPage,
+          },
+        },
+        error,
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
       return {
         threads: [],
         total: 0,
@@ -548,11 +697,28 @@ export class UpstashStore extends MastraStorage {
   }
 
   async saveThread({ thread }: { thread: StorageThreadType }): Promise<StorageThreadType> {
-    await this.insert({
-      tableName: TABLE_THREADS,
-      record: thread,
-    });
-    return thread;
+    try {
+      await this.insert({
+        tableName: TABLE_THREADS,
+        record: thread,
+      });
+      return thread;
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_SAVE_THREAD_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: thread.id,
+          },
+        },
+        error,
+      );
+      this.logger?.trackException(mastraError);
+      this.logger.error(mastraError.toString());
+      throw mastraError;
+    }
   }
 
   async updateThread({
@@ -566,7 +732,15 @@ export class UpstashStore extends MastraStorage {
   }): Promise<StorageThreadType> {
     const thread = await this.getThreadById({ threadId: id });
     if (!thread) {
-      throw new Error(`Thread ${id} not found`);
+      throw new MastraError({
+        id: 'STORAGE_UPSTASH_STORAGE_UPDATE_THREAD_FAILED',
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Thread ${id} not found`,
+        details: {
+          threadId: id,
+        },
+      });
     }
 
     const updatedThread = {
@@ -578,30 +752,58 @@ export class UpstashStore extends MastraStorage {
       },
     };
 
-    await this.saveThread({ thread: updatedThread });
-    return updatedThread;
+    try {
+      await this.saveThread({ thread: updatedThread });
+      return updatedThread;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_UPDATE_THREAD_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id,
+          },
+        },
+        error,
+      );
+    }
   }
 
   async deleteThread({ threadId }: { threadId: string }): Promise<void> {
     // Delete thread metadata and sorted set
     const threadKey = this.getKey(TABLE_THREADS, { id: threadId });
     const threadMessagesKey = this.getThreadMessagesKey(threadId);
-    const messageIds: string[] = await this.redis.zrange(threadMessagesKey, 0, -1);
+    try {
+      const messageIds: string[] = await this.redis.zrange(threadMessagesKey, 0, -1);
 
-    const pipeline = this.redis.pipeline();
-    pipeline.del(threadKey);
-    pipeline.del(threadMessagesKey);
+      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 as string);
-      pipeline.del(messageKey);
-    }
+      for (let i = 0; i < messageIds.length; i++) {
+        const messageId = messageIds[i];
+        const messageKey = this.getMessageKey(threadId, messageId as string);
+        pipeline.del(messageKey);
+      }
 
-    await pipeline.exec();
+      await pipeline.exec();
 
-    // Bulk delete all message keys for this thread if any remain
-    await this.scanAndDelete(this.getMessageKey(threadId, '*'));
+      // Bulk delete all message keys for this thread if any remain
+      await this.scanAndDelete(this.getMessageKey(threadId, '*'));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_DELETE_THREAD_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+          },
+        },
+        error,
+      );
+    }
   }
 
   async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
@@ -613,14 +815,25 @@ export class UpstashStore extends MastraStorage {
     if (messages.length === 0) return [];
 
     const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      throw new Error('Thread ID is required');
-    }
+    try {
+      if (!threadId) {
+        throw new Error('Thread ID is required');
+      }
 
-    // Check if thread exists
-    const thread = await this.getThreadById({ threadId });
-    if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+      // Check if thread exists
+      const thread = await this.getThreadById({ threadId });
+      if (!thread) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_SAVE_MESSAGES_INVALID_ARGS',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+        },
+        error,
+      );
     }
 
     // Add an index to each message to maintain order
@@ -633,41 +846,76 @@ export class UpstashStore extends MastraStorage {
     const threadKey = this.getKey(TABLE_THREADS, { id: threadId });
     const existingThread = await this.redis.get<StorageThreadType>(threadKey);
 
-    const batchSize = 1000;
-    for (let i = 0; i < messagesWithIndex.length; i += batchSize) {
-      const batch = messagesWithIndex.slice(i, i + batchSize);
-      const pipeline = this.redis.pipeline();
+    try {
+      const batchSize = 1000;
+      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 !== undefined ? message._index : createdAtScore;
+
+          // Check if this message id exists in another thread
+          const existingKeyPattern = this.getMessageKey('*', message.id);
+          const keys = await this.scanKeys(existingKeyPattern);
+
+          if (keys.length > 0) {
+            const pipeline2 = this.redis.pipeline();
+            keys.forEach(key => pipeline2.get(key));
+            const results = await pipeline2.exec();
+            const existingMessages = results.filter(
+              (msg): msg is MastraMessageV2 | MastraMessageV1 => msg !== null,
+            ) as (MastraMessageV2 | MastraMessageV1)[];
+            for (const existingMessage of existingMessages) {
+              const existingMessageKey = this.getMessageKey(existingMessage.threadId!, existingMessage.id);
+              if (existingMessage && existingMessage.threadId !== message.threadId) {
+                pipeline.del(existingMessageKey);
+                // Remove from old thread's sorted set
+                pipeline.zrem(this.getThreadMessagesKey(existingMessage.threadId!), existingMessage.id);
+              }
+            }
+          }
 
-      for (const message of batch) {
-        const key = this.getMessageKey(message.threadId!, message.id);
-        const createdAtScore = new Date(message.createdAt).getTime();
-        const score = message._index !== undefined ? message._index : createdAtScore;
+          // Store the message data
+          pipeline.set(key, message);
 
-        // Store the message data
-        pipeline.set(key, message);
+          // Add to sorted set for this thread
+          pipeline.zadd(this.getThreadMessagesKey(message.threadId!), {
+            score,
+            member: message.id,
+          });
+        }
 
-        // Add to sorted set for this thread
-        pipeline.zadd(this.getThreadMessagesKey(message.threadId!), {
-          score,
-          member: message.id,
-        });
-      }
+        // Update the thread's updatedAt field (only in the first batch)
+        if (i === 0 && existingThread) {
+          const updatedThread = {
+            ...existingThread,
+            updatedAt: new Date(),
+          };
+          pipeline.set(threadKey, this.processRecord(TABLE_THREADS, updatedThread).processedRecord);
+        }
 
-      // Update the thread's updatedAt field (only in the first batch)
-      if (i === 0 && existingThread) {
-        const updatedThread = {
-          ...existingThread,
-          updatedAt: new Date(),
-        };
-        pipeline.set(threadKey, this.processRecord(TABLE_THREADS, updatedThread).processedRecord);
+        await pipeline.exec();
       }
 
-      await pipeline.exec();
+      const list = new MessageList().add(messages, 'memory');
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_SAVE_MESSAGES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+          },
+        },
+        error,
+      );
     }
-
-    const list = new MessageList().add(messages, 'memory');
-    if (format === `v2`) return list.get.all.v2();
-    return list.get.all.v1();
   }
 
   private async _getIncludedMessages(
@@ -734,89 +982,96 @@ export class UpstashStore extends MastraStorage {
     format,
   }: StorageGetMessagesArg & { format?: 'v1' | 'v2' }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
     const threadMessagesKey = this.getThreadMessagesKey(threadId);
-    const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-    // When selectBy is undefined or selectBy.last is undefined, get ALL messages (not just 40)
-    let limit: number;
-    if (typeof selectBy?.last === 'number') {
-      limit = Math.max(0, selectBy.last);
-    } else if (selectBy?.last === false) {
-      limit = 0;
-    } else {
-      // No limit specified - get all messages
-      limit = Number.MAX_SAFE_INTEGER;
-    }
+    try {
+      const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
+      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
 
-    const messageIds = new Set<string>();
-    const messageIdToThreadIds: Record<string, string> = {};
+      const messageIds = new Set<string>();
+      const messageIdToThreadIds: Record<string, string> = {};
 
-    if (limit === 0 && !selectBy?.include) {
-      return [];
-    }
-
-    // Then get the most recent messages (or all if no limit)
-    if (limit === Number.MAX_SAFE_INTEGER) {
-      // Get all messages
-      const allIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-      allIds.forEach(id => {
-        messageIds.add(id as string);
-        messageIdToThreadIds[id as string] = threadId;
-      });
-    } else if (limit > 0) {
-      // Get limited number of recent messages
-      const latestIds = await this.redis.zrange(threadMessagesKey, -limit, -1);
-      latestIds.forEach(id => {
-        messageIds.add(id as string);
-        messageIdToThreadIds[id as string] = threadId;
-      });
-    }
+      if (limit === 0 && !selectBy?.include) {
+        return [];
+      }
 
-    const includedMessages = await this._getIncludedMessages(threadId, selectBy);
+      // Then get the most recent messages (or all if no limit)
+      if (limit === Number.MAX_SAFE_INTEGER) {
+        // Get all messages
+        const allIds = await this.redis.zrange(threadMessagesKey, 0, -1);
+        allIds.forEach(id => {
+          messageIds.add(id as string);
+          messageIdToThreadIds[id as string] = threadId;
+        });
+      } else if (limit > 0) {
+        // Get limited number of recent messages
+        const latestIds = await this.redis.zrange(threadMessagesKey, -limit, -1);
+        latestIds.forEach(id => {
+          messageIds.add(id as string);
+          messageIdToThreadIds[id as string] = threadId;
+        });
+      }
 
-    // Fetch all needed messages in parallel
-    const messages = [
-      ...includedMessages,
-      ...((
-        await Promise.all(
-          Array.from(messageIds).map(async id => {
-            const tId = messageIdToThreadIds[id] || threadId;
-            const byThreadId = await this.redis.get<MastraMessageV2 & { _index?: number }>(this.getMessageKey(tId, id));
-            if (byThreadId) return byThreadId;
+      const includedMessages = await this._getIncludedMessages(threadId, selectBy);
+
+      // Fetch all needed messages in parallel
+      const messages = [
+        ...includedMessages,
+        ...((
+          await Promise.all(
+            Array.from(messageIds).map(async id => {
+              const tId = messageIdToThreadIds[id] || threadId;
+              const byThreadId = await this.redis.get<MastraMessageV2 & { _index?: number }>(
+                this.getMessageKey(tId, id),
+              );
+              if (byThreadId) return byThreadId;
+
+              return null;
+            }),
+          )
+        ).filter(msg => msg !== null) as (MastraMessageV2 & { _index?: number })[]),
+      ];
 
-            return null;
-          }),
-        )
-      ).filter(msg => msg !== null) as (MastraMessageV2 & { _index?: number })[]),
-    ];
+      // Sort messages by their position in the sorted set
+      messages.sort((a, b) => allMessageIds.indexOf(a!.id) - allMessageIds.indexOf(b!.id));
 
-    // Sort messages by their position in the sorted set
-    messages.sort((a, b) => allMessageIds.indexOf(a!.id) - allMessageIds.indexOf(b!.id));
+      const seen = new Set<string>();
+      const dedupedMessages = messages.filter(row => {
+        if (seen.has(row.id)) return false;
+        seen.add(row.id);
+        return true;
+      });
 
-    const seen = new Set<string>();
-    const dedupedMessages = messages.filter(row => {
-      if (seen.has(row.id)) return false;
-      seen.add(row.id);
-      return true;
-    });
+      // Remove _index before returning and handle format conversion properly
+      const prepared = dedupedMessages
+        .filter(message => message !== null && message !== undefined)
+        .map(message => {
+          const { _index, ...messageWithoutIndex } = message as MastraMessageV2 & { _index?: number };
+          return messageWithoutIndex as unknown as MastraMessageV1;
+        });
 
-    // Remove _index before returning and handle format conversion properly
-    const prepared = dedupedMessages
-      .filter(message => message !== null && message !== undefined)
-      .map(message => {
-        const { _index, ...messageWithoutIndex } = message as MastraMessageV2 & { _index?: number };
-        return messageWithoutIndex as unknown as MastraMessageV1;
-      });
+      // For backward compatibility, return messages directly without using MessageList
+      // since MessageList has deduplication logic that can cause issues
+      if (format === 'v2') {
+        // Convert V1 format back to V2 format
+        return prepared.map(msg => ({
+          ...msg,
+          content: msg.content || { format: 2, parts: [{ type: 'text', text: '' }] },
+        })) as MastraMessageV2[];
+      }
 
-    // For backward compatibility, return messages directly without using MessageList
-    // since MessageList has deduplication logic that can cause issues
-    if (format === 'v2') {
-      // Convert V1 format back to V2 format
-      return prepared.map(msg => ({
-        ...msg,
-        content: msg.content || { format: 2, parts: [{ type: 'text', text: '' }] },
-      })) as MastraMessageV2[];
+      return prepared;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_MESSAGES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+          },
+        },
+        error,
+      );
     }
-
-    return prepared;
   }
 
   public async getMessagesPaginated(
@@ -831,10 +1086,10 @@ export class UpstashStore extends MastraStorage {
     const threadMessagesKey = this.getThreadMessagesKey(threadId);
     const messages: (MastraMessageV2 | MastraMessageV1)[] = [];
 
-    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 {
@@ -891,7 +1146,19 @@ export class UpstashStore extends MastraStorage {
         hasMore,
       };
     } catch (error) {
-      console.error('Failed to get paginated messages:', error);
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_MESSAGES_PAGINATED_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+          },
+        },
+        error,
+      );
+      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return {
         messages: [],
         total: 0,
@@ -909,17 +1176,33 @@ export class UpstashStore extends MastraStorage {
     snapshot: WorkflowRunState;
   }): Promise<void> {
     const { namespace = 'workflows', workflowName, runId, snapshot } = params;
-    await this.insert({
-      tableName: TABLE_WORKFLOW_SNAPSHOT,
-      record: {
-        namespace,
-        workflow_name: workflowName,
-        run_id: runId,
-        snapshot,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      },
-    });
+    try {
+      await this.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace,
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            workflowName,
+            runId,
+          },
+        },
+        error,
+      );
+    }
   }
 
   async loadWorkflowSnapshot(params: {
@@ -933,14 +1216,30 @@ export class UpstashStore extends MastraStorage {
       workflow_name: workflowName,
       run_id: runId,
     });
-    const data = await this.redis.get<{
-      namespace: string;
-      workflow_name: string;
-      run_id: string;
-      snapshot: WorkflowRunState;
-    }>(key);
-    if (!data) return null;
-    return data.snapshot;
+    try {
+      const data = await this.redis.get<{
+        namespace: string;
+        workflow_name: string;
+        run_id: string;
+        snapshot: WorkflowRunState;
+      }>(key);
+      if (!data) return null;
+      return data.snapshot;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            workflowName,
+            runId,
+          },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -1063,7 +1362,20 @@ export class UpstashStore extends MastraStorage {
       };
     } catch (error) {
       const { page = 0, perPage = 100 } = options || {};
-      console.error('Failed to get evals:', error);
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_EVALS_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            page,
+            perPage,
+          },
+        },
+        error,
+      );
+      this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return {
         evals: [],
         total: 0,
@@ -1146,8 +1458,19 @@ export class UpstashStore extends MastraStorage {
 
       return { runs, total };
     } catch (error) {
-      console.error('Error getting workflow runs:', error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUNS_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            workflowName: workflowName || '',
+            resourceId: resourceId || '',
+          },
+        },
+        error,
+      );
     }
   }
 
@@ -1180,8 +1503,19 @@ export class UpstashStore extends MastraStorage {
       if (!data) return null;
       return this.parseWorkflowRun(data);
     } catch (error) {
-      console.error('Error getting workflow run by ID:', error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace,
+            runId,
+            workflowName: workflowName || '',
+          },
+        },
+        error,
+      );
     }
   }
 
@@ -1199,4 +1533,88 @@ export class UpstashStore extends MastraStorage {
     this.logger.error('updateMessages is not yet implemented in UpstashStore');
     throw new Error('Method not implemented');
   }
+
+  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
+    try {
+      const key = `${TABLE_RESOURCES}:${resourceId}`;
+      const data = await this.redis.get<StorageResourceType>(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 }: { resource: StorageResourceType }): Promise<StorageResourceType> {
+    try {
+      const key = `${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,
+  }: {
+    resourceId: string;
+    workingMemory?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<StorageResourceType> {
+    try {
+      const existingResource = await this.getResourceById({ resourceId });
+
+      if (!existingResource) {
+        // Create new resource if it doesn't exist
+        const newResource: StorageResourceType = {
+          id: resourceId,
+          workingMemory,
+          metadata: metadata || {},
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        };
+        return this.saveResource({ resource: newResource });
+      }
+
+      const updatedResource = {
+        ...existingResource,
+        workingMemory: workingMemory !== undefined ? workingMemory : existingResource.workingMemory,
+        metadata: {
+          ...existingResource.metadata,
+          ...metadata,
+        },
+        updatedAt: new Date(),
+      };
+
+      await this.saveResource({ resource: updatedResource });
+      return updatedResource;
+    } catch (error) {
+      this.logger.error('Error updating resource:', error);
+      throw error;
+    }
+  }
 }