@mastra/upstash 0.12.1 → 0.12.2

package/dist/index.js

@@ -1,157 +1,49 @@
-import { MessageList } from '@mastra/core/agent';
-import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { MastraStorage, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_TRACES, TABLE_THREADS, TABLE_RESOURCES } from '@mastra/core/storage';
+import { MastraStorage, StoreOperations, TracesStorage, TABLE_TRACES, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MemoryStorage, TABLE_THREADS, resolveMessageLimit, TABLE_RESOURCES, LegacyEvalsStorage, TABLE_EVALS, TABLE_MESSAGES, serializeDate } from '@mastra/core/storage';
 import { Redis } from '@upstash/redis';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
+import { MessageList } from '@mastra/core/agent';
 import { MastraVector } from '@mastra/core/vector';
 import { Index } from '@upstash/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/storage/index.ts
-var UpstashStore = class extends MastraStorage {
-  redis;
-  constructor(config) {
-    super({ name: "Upstash" });
-    this.redis = new Redis({
-      url: config.url,
-      token: config.token
-    });
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true
-    };
-  }
-  transformEvalRecord(record) {
-    let result = record.result;
-    if (typeof result === "string") {
-      try {
-        result = JSON.parse(result);
-      } catch {
-        console.warn("Failed to parse result JSON:");
-      }
-    }
-    let testInfo = record.test_info;
-    if (typeof testInfo === "string") {
-      try {
-        testInfo = JSON.parse(testInfo);
-      } catch {
-        console.warn("Failed to parse test_info JSON:");
-      }
-    }
-    return {
-      agentName: record.agent_name,
-      input: record.input,
-      output: record.output,
-      result,
-      metricName: record.metric_name,
-      instructions: record.instructions,
-      testInfo,
-      globalRunId: record.global_run_id,
-      runId: record.run_id,
-      createdAt: typeof record.created_at === "string" ? record.created_at : record.created_at instanceof Date ? record.created_at.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  parseJSON(value) {
-    if (typeof value === "string") {
-      try {
-        return JSON.parse(value);
-      } catch {
-        return value;
-      }
+function transformEvalRecord(record) {
+  let result = record.result;
+  if (typeof result === "string") {
+    try {
+      result = JSON.parse(result);
+    } catch {
+      console.warn("Failed to parse result JSON:");
     }
-    return value;
-  }
-  getKey(tableName, keys) {
-    const keyParts = Object.entries(keys).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}:${value}`);
-    return `${tableName}:${keyParts.join(":")}`;
-  }
-  /**
-   * Scans for keys matching the given pattern using SCAN and returns them as an array.
-   * @param pattern Redis key pattern, e.g. "table:*"
-   * @param batchSize Number of keys to scan per batch (default: 1000)
-   */
-  async scanKeys(pattern, batchSize = 1e4) {
-    let cursor = "0";
-    let keys = [];
-    do {
-      const [nextCursor, batch] = await this.redis.scan(cursor, {
-        match: pattern,
-        count: batchSize
-      });
-      keys.push(...batch);
-      cursor = nextCursor;
-    } while (cursor !== "0");
-    return keys;
-  }
-  /**
-   * Deletes all keys matching the given pattern using SCAN and DEL in batches.
-   * @param pattern Redis key pattern, e.g. "table:*"
-   * @param batchSize Number of keys to delete per batch (default: 1000)
-   */
-  async scanAndDelete(pattern, batchSize = 1e4) {
-    let cursor = "0";
-    let totalDeleted = 0;
-    do {
-      const [nextCursor, keys] = await this.redis.scan(cursor, {
-        match: pattern,
-        count: batchSize
-      });
-      if (keys.length > 0) {
-        await this.redis.del(...keys);
-        totalDeleted += keys.length;
-      }
-      cursor = nextCursor;
-    } while (cursor !== "0");
-    return totalDeleted;
-  }
-  getMessageKey(threadId, messageId) {
-    const key = this.getKey(TABLE_MESSAGES, { threadId, id: messageId });
-    return key;
   }
-  getThreadMessagesKey(threadId) {
-    return `thread:${threadId}:messages`;
-  }
-  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}`);
-      }
+  let testInfo = record.test_info;
+  if (typeof testInfo === "string") {
+    try {
+      testInfo = JSON.parse(testInfo);
+    } catch {
+      console.warn("Failed to parse test_info JSON:");
     }
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: this.ensureDate(row.createdAt),
-      updatedAt: this.ensureDate(row.updatedAt),
-      resourceId: row.resourceId
-    };
   }
-  processRecord(tableName, record) {
-    let key;
-    if (tableName === TABLE_MESSAGES) {
-      key = this.getKey(tableName, { threadId: record.threadId, id: record.id });
-    } else if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
-      key = this.getKey(tableName, {
-        namespace: record.namespace || "workflows",
-        workflow_name: record.workflow_name,
-        run_id: record.run_id,
-        ...record.resourceId ? { resourceId: record.resourceId } : {}
-      });
-    } else if (tableName === TABLE_EVALS) {
-      key = this.getKey(tableName, { id: record.run_id });
-    } else {
-      key = this.getKey(tableName, { id: record.id });
-    }
-    const processedRecord = {
-      ...record,
-      createdAt: this.serializeDate(record.createdAt),
-      updatedAt: this.serializeDate(record.updatedAt)
-    };
-    return { key, processedRecord };
+  return {
+    agentName: record.agent_name,
+    input: record.input,
+    output: record.output,
+    result,
+    metricName: record.metric_name,
+    instructions: record.instructions,
+    testInfo,
+    globalRunId: record.global_run_id,
+    runId: record.run_id,
+    createdAt: typeof record.created_at === "string" ? record.created_at : record.created_at instanceof Date ? record.created_at.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var StoreLegacyEvalsUpstash = class extends LegacyEvalsStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
   }
   /**
    * @deprecated Use getEvals instead
@@ -159,11 +51,11 @@ var UpstashStore = class extends MastraStorage {
   async getEvalsByAgentName(agentName, type) {
     try {
       const pattern = `${TABLE_EVALS}:*`;
-      const keys = await this.scanKeys(pattern);
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return [];
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
       const nonNullRecords = results.filter(
@@ -197,7 +89,7 @@ var UpstashStore = class extends MastraStorage {
           }
         });
       }
-      return filteredEvals.map((record) => this.transformEvalRecord(record));
+      return filteredEvals.map((record) => transformEvalRecord(record));
     } catch (error) {
       const mastraError = new MastraError(
         {
@@ -214,148 +106,198 @@ var UpstashStore = class extends MastraStorage {
     }
   }
   /**
-   * @deprecated use getTracesPaginated instead
+   * Get all evaluations with pagination and total count
+   * @param options Pagination and filtering options
+   * @returns Object with evals array and total count
    */
-  async getTraces(args) {
-    if (args.fromDate || args.toDate) {
-      args.dateRange = {
-        start: args.fromDate,
-        end: args.toDate
-      };
-    }
-    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
-      );
-    }
-  }
-  async getTracesPaginated(args) {
-    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
+  async getEvals(options) {
     try {
-      const pattern = `${TABLE_TRACES}:*`;
-      const keys = await this.scanKeys(pattern);
+      const { agentName, type, page = 0, perPage = 100, dateRange } = options || {};
+      const fromDate = dateRange?.start;
+      const toDate = dateRange?.end;
+      const pattern = `${TABLE_EVALS}:*`;
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return {
-          traces: [],
+          evals: [],
           total: 0,
           page,
-          perPage: perPage || 100,
+          perPage,
           hasMore: false
         };
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
-      let filteredTraces = results.filter(
-        (record) => record !== null && typeof record === "object"
-      );
-      if (name) {
-        filteredTraces = filteredTraces.filter((record) => record.name?.toLowerCase().startsWith(name.toLowerCase()));
-      }
-      if (scope) {
-        filteredTraces = filteredTraces.filter((record) => record.scope === scope);
+      let filteredEvals = results.map((result) => result).filter((record) => record !== null && typeof record === "object");
+      if (agentName) {
+        filteredEvals = filteredEvals.filter((record) => record.agent_name === agentName);
       }
-      if (attributes) {
-        filteredTraces = filteredTraces.filter((record) => {
-          const recordAttributes = record.attributes;
-          if (!recordAttributes) return false;
-          const parsedAttributes = typeof recordAttributes === "string" ? JSON.parse(recordAttributes) : recordAttributes;
-          return Object.entries(attributes).every(([key, value]) => parsedAttributes[key] === value);
+      if (type === "test") {
+        filteredEvals = filteredEvals.filter((record) => {
+          if (!record.test_info) return false;
+          try {
+            if (typeof record.test_info === "string") {
+              const parsedTestInfo = JSON.parse(record.test_info);
+              return parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo;
+            }
+            return typeof record.test_info === "object" && "testPath" in record.test_info;
+          } catch {
+            return false;
+          }
+        });
+      } else if (type === "live") {
+        filteredEvals = filteredEvals.filter((record) => {
+          if (!record.test_info) return true;
+          try {
+            if (typeof record.test_info === "string") {
+              const parsedTestInfo = JSON.parse(record.test_info);
+              return !(parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo);
+            }
+            return !(typeof record.test_info === "object" && "testPath" in record.test_info);
+          } catch {
+            return true;
+          }
         });
-      }
-      if (filters) {
-        filteredTraces = filteredTraces.filter(
-          (record) => Object.entries(filters).every(([key, value]) => record[key] === value)
-        );
       }
       if (fromDate) {
-        filteredTraces = filteredTraces.filter(
-          (record) => new Date(record.createdAt).getTime() >= new Date(fromDate).getTime()
-        );
+        filteredEvals = filteredEvals.filter((record) => {
+          const createdAt = new Date(record.created_at || record.createdAt || 0);
+          return createdAt.getTime() >= fromDate.getTime();
+        });
       }
       if (toDate) {
-        filteredTraces = filteredTraces.filter(
-          (record) => new Date(record.createdAt).getTime() <= new Date(toDate).getTime()
-        );
+        filteredEvals = filteredEvals.filter((record) => {
+          const createdAt = new Date(record.created_at || record.createdAt || 0);
+          return createdAt.getTime() <= toDate.getTime();
+        });
       }
-      filteredTraces.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-      const transformedTraces = filteredTraces.map((record) => ({
-        id: record.id,
-        parentSpanId: record.parentSpanId,
-        traceId: record.traceId,
-        name: record.name,
-        scope: record.scope,
-        kind: record.kind,
-        status: this.parseJSON(record.status),
-        events: this.parseJSON(record.events),
-        links: this.parseJSON(record.links),
-        attributes: this.parseJSON(record.attributes),
-        startTime: record.startTime,
-        endTime: record.endTime,
-        other: this.parseJSON(record.other),
-        createdAt: this.ensureDate(record.createdAt)
-      }));
-      const total = transformedTraces.length;
-      const resolvedPerPage = perPage || 100;
-      const start = page * resolvedPerPage;
-      const end = start + resolvedPerPage;
-      const paginatedTraces = transformedTraces.slice(start, end);
+      filteredEvals.sort((a, b) => {
+        const dateA = new Date(a.created_at || a.createdAt || 0).getTime();
+        const dateB = new Date(b.created_at || b.createdAt || 0).getTime();
+        return dateB - dateA;
+      });
+      const total = filteredEvals.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedEvals = filteredEvals.slice(start, end);
       const hasMore = end < total;
+      const evals = paginatedEvals.map((record) => transformEvalRecord(record));
       return {
-        traces: paginatedTraces,
+        evals,
         total,
         page,
-        perPage: resolvedPerPage,
+        perPage,
         hasMore
       };
     } catch (error) {
+      const { page = 0, perPage = 100 } = options || {};
       const mastraError = new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_TRACES_PAGINATED_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_GET_EVALS_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            name: args.name || "",
-            scope: args.scope || ""
+            page,
+            perPage
           }
         },
         error
       );
-      this.logger?.trackException(mastraError);
       this.logger.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return {
-        traces: [],
+        evals: [],
         total: 0,
         page,
-        perPage: perPage || 100,
+        perPage,
         hasMore: false
       };
     }
   }
-  async createTable({
-    tableName,
-    schema
-  }) {
+};
+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 parseJSON(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function getKey(tableName, keys) {
+  const keyParts = Object.entries(keys).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}:${value}`);
+  return `${tableName}:${keyParts.join(":")}`;
+}
+function processRecord(tableName, record) {
+  let key;
+  if (tableName === TABLE_MESSAGES) {
+    key = getKey(tableName, { threadId: record.threadId, id: record.id });
+  } else if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
+    key = getKey(tableName, {
+      namespace: record.namespace || "workflows",
+      workflow_name: record.workflow_name,
+      run_id: record.run_id,
+      ...record.resourceId ? { resourceId: record.resourceId } : {}
+    });
+  } else if (tableName === TABLE_EVALS) {
+    key = getKey(tableName, { id: record.run_id });
+  } else {
+    key = getKey(tableName, { id: record.id });
+  }
+  const processedRecord = {
+    ...record,
+    createdAt: serializeDate(record.createdAt),
+    updatedAt: serializeDate(record.updatedAt)
+  };
+  return { key, processedRecord };
+}
+
+// src/storage/domains/memory/index.ts
+function getThreadMessagesKey(threadId) {
+  return `thread:${threadId}:messages`;
+}
+function getMessageKey(threadId, messageId) {
+  const key = getKey(TABLE_MESSAGES, { threadId, id: messageId });
+  return key;
+}
+var StoreMemoryUpstash = class extends MemoryStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async getThreadById({ threadId }) {
     try {
-      await this.redis.set(`schema:${tableName}`, schema);
+      const thread = await this.operations.load({
+        tableName: TABLE_THREADS,
+        keys: { id: threadId }
+      });
+      if (!thread) return null;
+      return {
+        ...thread,
+        createdAt: ensureDate(thread.createdAt),
+        updatedAt: ensureDate(thread.updatedAt),
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+      };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_CREATE_TABLE_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_GET_THREAD_BY_ID_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId
           }
         },
         error
@@ -363,135 +305,17 @@ var UpstashStore = class extends MastraStorage {
     }
   }
   /**
-   * 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
+   * @deprecated use getThreadsByResourceIdPaginated instead
    */
-  async alterTable(_args) {
-  }
-  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 insert({ tableName, record }) {
-    const { key, processedRecord } = this.processRecord(tableName, record);
-    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) {
-    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.redis.pipeline();
-        for (const record of batch) {
-          const { key, processedRecord } = this.processRecord(tableName, record);
-          pipeline.set(key, processedRecord);
-        }
-        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({ tableName, keys }) {
-    const key = this.getKey(tableName, keys);
-    try {
-      const data = await this.redis.get(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 }) {
-    try {
-      const thread = await this.load({
-        tableName: 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) {
-      throw new MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_GET_THREAD_BY_ID_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId
-          }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead
-   */
-  async getThreadsByResourceId({ resourceId }) {
+  async getThreadsByResourceId({ resourceId }) {
     try {
       const pattern = `${TABLE_THREADS}:*`;
-      const keys = await this.scanKeys(pattern);
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return [];
       }
       const allThreads = [];
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
       for (let i = 0; i < results.length; i++) {
@@ -499,8 +323,8 @@ var UpstashStore = class extends MastraStorage {
         if (thread && thread.resourceId === resourceId) {
           allThreads.push({
             ...thread,
-            createdAt: this.ensureDate(thread.createdAt),
-            updatedAt: this.ensureDate(thread.updatedAt),
+            createdAt: ensureDate(thread.createdAt),
+            updatedAt: ensureDate(thread.updatedAt),
             metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
           });
         }
@@ -567,7 +391,7 @@ var UpstashStore = class extends MastraStorage {
   }
   async saveThread({ thread }) {
     try {
-      await this.insert({
+      await this.operations.insert({
         tableName: TABLE_THREADS,
         record: thread
       });
@@ -632,20 +456,20 @@ var UpstashStore = class extends MastraStorage {
     }
   }
   async deleteThread({ threadId }) {
-    const threadKey = this.getKey(TABLE_THREADS, { id: threadId });
-    const threadMessagesKey = this.getThreadMessagesKey(threadId);
+    const threadKey = getKey(TABLE_THREADS, { id: threadId });
+    const threadMessagesKey = getThreadMessagesKey(threadId);
     try {
-      const messageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-      const pipeline = this.redis.pipeline();
+      const messageIds = await this.client.zrange(threadMessagesKey, 0, -1);
+      const pipeline = this.client.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);
+        const messageKey = getMessageKey(threadId, messageId);
         pipeline.del(messageKey);
       }
       await pipeline.exec();
-      await this.scanAndDelete(this.getMessageKey(threadId, "*"));
+      await this.operations.scanAndDelete(getMessageKey(threadId, "*"));
     } catch (error) {
       throw new MastraError(
         {
@@ -682,40 +506,52 @@ var UpstashStore = class extends MastraStorage {
         error
       );
     }
-    const messagesWithIndex = messages.map((message, index) => ({
-      ...message,
-      _index: index
-    }));
-    const threadKey = this.getKey(TABLE_THREADS, { id: threadId });
-    const existingThread = await this.redis.get(threadKey);
+    const messagesWithIndex = messages.map((message, index) => {
+      if (!message.threadId) {
+        throw new Error(
+          `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+        );
+      }
+      if (!message.resourceId) {
+        throw new Error(
+          `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+        );
+      }
+      return {
+        ...message,
+        _index: index
+      };
+    });
+    const threadKey = getKey(TABLE_THREADS, { id: threadId });
+    const existingThread = await this.client.get(threadKey);
     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();
+        const pipeline = this.client.pipeline();
         for (const message of batch) {
-          const key = this.getMessageKey(message.threadId, message.id);
+          const key = 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);
+          const existingKeyPattern = getMessageKey("*", message.id);
+          const keys = await this.operations.scanKeys(existingKeyPattern);
           if (keys.length > 0) {
-            const pipeline2 = this.redis.pipeline();
+            const pipeline2 = this.client.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);
+              const existingMessageKey = getMessageKey(existingMessage.threadId, existingMessage.id);
               if (existingMessage && existingMessage.threadId !== message.threadId) {
                 pipeline.del(existingMessageKey);
-                pipeline.zrem(this.getThreadMessagesKey(existingMessage.threadId), existingMessage.id);
+                pipeline.zrem(getThreadMessagesKey(existingMessage.threadId), existingMessage.id);
               }
             }
           }
           pipeline.set(key, message);
-          pipeline.zadd(this.getThreadMessagesKey(message.threadId), {
+          pipeline.zadd(getThreadMessagesKey(message.threadId), {
             score,
             member: message.id
           });
@@ -725,7 +561,7 @@ var UpstashStore = class extends MastraStorage {
             ...existingThread,
             updatedAt: /* @__PURE__ */ new Date()
           };
-          pipeline.set(threadKey, this.processRecord(TABLE_THREADS, updatedThread).processedRecord);
+          pipeline.set(threadKey, processRecord(TABLE_THREADS, updatedThread).processedRecord);
         }
         await pipeline.exec();
       }
@@ -754,29 +590,29 @@ var UpstashStore = class extends MastraStorage {
         messageIds.add(item.id);
         const itemThreadId = item.threadId || threadId;
         messageIdToThreadIds[item.id] = itemThreadId;
-        const itemThreadMessagesKey = this.getThreadMessagesKey(itemThreadId);
-        const rank = await this.redis.zrank(itemThreadMessagesKey, item.id);
+        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.redis.zrange(itemThreadMessagesKey, start, rank - 1);
+          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.redis.zrange(itemThreadMessagesKey, rank + 1, rank + 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.redis.pipeline();
+      const pipeline = this.client.pipeline();
       Array.from(messageIds).forEach((id) => {
         const tId = messageIdToThreadIds[id] || threadId;
-        pipeline.get(this.getMessageKey(tId, id));
+        pipeline.get(getMessageKey(tId, id));
       });
       const results = await pipeline.exec();
       return results.filter((result) => result !== null);
@@ -788,23 +624,23 @@ var UpstashStore = class extends MastraStorage {
     selectBy,
     format
   }) {
-    const threadMessagesKey = this.getThreadMessagesKey(threadId);
+    const threadMessagesKey = getThreadMessagesKey(threadId);
     try {
-      const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+      const allMessageIds = await this.client.zrange(threadMessagesKey, 0, -1);
+      const limit = 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);
+        const allIds = await this.client.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);
+        const latestIds = await this.client.zrange(threadMessagesKey, -limit, -1);
         latestIds.forEach((id) => {
           messageIds.add(id);
           messageIdToThreadIds[id] = threadId;
@@ -816,9 +652,7 @@ var UpstashStore = class extends MastraStorage {
         ...(await Promise.all(
           Array.from(messageIds).map(async (id) => {
             const tId = messageIdToThreadIds[id] || threadId;
-            const byThreadId = await this.redis.get(
-              this.getMessageKey(tId, id)
-            );
+            const byThreadId = await this.client.get(getMessageKey(tId, id));
             if (byThreadId) return byThreadId;
             return null;
           })
@@ -838,10 +672,14 @@ var UpstashStore = class extends MastraStorage {
       if (format === "v2") {
         return prepared.map((msg) => ({
           ...msg,
+          createdAt: new Date(msg.createdAt),
           content: msg.content || { format: 2, parts: [{ type: "text", text: "" }] }
         }));
       }
-      return prepared;
+      return prepared.map((msg) => ({
+        ...msg,
+        createdAt: new Date(msg.createdAt)
+      }));
     } catch (error) {
       throw new MastraError(
         {
@@ -861,12 +699,16 @@ var UpstashStore = class extends MastraStorage {
     const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
     const fromDate = dateRange?.start;
     const toDate = dateRange?.end;
-    const threadMessagesKey = this.getThreadMessagesKey(threadId);
+    const threadMessagesKey = getThreadMessagesKey(threadId);
     const messages = [];
     try {
       const includedMessages = await this._getIncludedMessages(threadId, selectBy);
       messages.push(...includedMessages);
-      const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
+      const allMessageIds = await this.client.zrange(
+        threadMessagesKey,
+        args?.selectBy?.last ? -args.selectBy.last : 0,
+        -1
+      );
       if (allMessageIds.length === 0) {
         return {
           messages: [],
@@ -876,8 +718,8 @@ var UpstashStore = class extends MastraStorage {
           hasMore: false
         };
       }
-      const pipeline = this.redis.pipeline();
-      allMessageIds.forEach((id) => pipeline.get(this.getMessageKey(threadId, id)));
+      const pipeline = this.client.pipeline();
+      allMessageIds.forEach((id) => pipeline.get(getMessageKey(threadId, id)));
       const results = await pipeline.exec();
       let messagesData = results.filter((msg) => msg !== null);
       if (fromDate) {
@@ -925,206 +767,795 @@ var UpstashStore = class extends MastraStorage {
       };
     }
   }
-  async persistWorkflowSnapshot(params) {
-    const { namespace = "workflows", workflowName, runId, snapshot } = params;
+  async getResourceById({ resourceId }) {
     try {
-      await this.insert({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        record: {
-          namespace,
-          workflow_name: workflowName,
-          run_id: runId,
-          snapshot,
+      const key = `${TABLE_RESOURCES}:${resourceId}`;
+      const data = await this.client.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 = `${TABLE_RESOURCES}:${resource.id}`;
+      const serializedResource = {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata),
+        createdAt: resource.createdAt.toISOString(),
+        updatedAt: resource.updatedAt.toISOString()
+      };
+      await this.client.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;
+    }
+  }
+  async updateMessages(args) {
+    const { messages } = args;
+    if (messages.length === 0) {
+      return [];
+    }
+    try {
+      const messageIds = messages.map((m) => m.id);
+      const existingMessages = [];
+      const messageIdToKey = {};
+      for (const messageId of messageIds) {
+        const pattern = getMessageKey("*", messageId);
+        const keys = await this.operations.scanKeys(pattern);
+        for (const key of keys) {
+          const message = await this.client.get(key);
+          if (message && message.id === messageId) {
+            existingMessages.push(message);
+            messageIdToKey[messageId] = key;
+            break;
+          }
         }
-      });
+      }
+      if (existingMessages.length === 0) {
+        return [];
+      }
+      const threadIdsToUpdate = /* @__PURE__ */ new Set();
+      const pipeline = this.client.pipeline();
+      for (const existingMessage of existingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        threadIdsToUpdate.add(existingMessage.threadId);
+        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+        const updatedMessage = { ...existingMessage };
+        if (fieldsToUpdate.content) {
+          const existingContent = existingMessage.content;
+          const newContent = {
+            ...existingContent,
+            ...fieldsToUpdate.content,
+            // Deep merge metadata if it exists on both
+            ...existingContent?.metadata && fieldsToUpdate.content.metadata ? {
+              metadata: {
+                ...existingContent.metadata,
+                ...fieldsToUpdate.content.metadata
+              }
+            } : {}
+          };
+          updatedMessage.content = newContent;
+        }
+        for (const key2 in fieldsToUpdate) {
+          if (Object.prototype.hasOwnProperty.call(fieldsToUpdate, key2) && key2 !== "content") {
+            updatedMessage[key2] = fieldsToUpdate[key2];
+          }
+        }
+        const key = messageIdToKey[id];
+        if (key) {
+          if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+            const oldThreadMessagesKey = getThreadMessagesKey(existingMessage.threadId);
+            pipeline.zrem(oldThreadMessagesKey, id);
+            pipeline.del(key);
+            const newKey = getMessageKey(updatePayload.threadId, id);
+            pipeline.set(newKey, updatedMessage);
+            const newThreadMessagesKey = getThreadMessagesKey(updatePayload.threadId);
+            const score = updatedMessage._index !== void 0 ? updatedMessage._index : new Date(updatedMessage.createdAt).getTime();
+            pipeline.zadd(newThreadMessagesKey, { score, member: id });
+          } else {
+            pipeline.set(key, updatedMessage);
+          }
+        }
+      }
+      const now = /* @__PURE__ */ new Date();
+      for (const threadId of threadIdsToUpdate) {
+        if (threadId) {
+          const threadKey = getKey(TABLE_THREADS, { id: threadId });
+          const existingThread = await this.client.get(threadKey);
+          if (existingThread) {
+            const updatedThread = {
+              ...existingThread,
+              updatedAt: now
+            };
+            pipeline.set(threadKey, processRecord(TABLE_THREADS, updatedThread).processedRecord);
+          }
+        }
+      }
+      await pipeline.exec();
+      const updatedMessages = [];
+      for (const messageId of messageIds) {
+        const key = messageIdToKey[messageId];
+        if (key) {
+          const updatedMessage = await this.client.get(key);
+          if (updatedMessage) {
+            const v2e = updatedMessage;
+            updatedMessages.push(v2e);
+          }
+        }
+      }
+      return updatedMessages;
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_UPDATE_MESSAGES_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            namespace,
-            workflowName,
-            runId
+            messageIds: messages.map((m) => m.id).join(",")
           }
         },
         error
       );
     }
   }
-  async loadWorkflowSnapshot(params) {
-    const { namespace = "workflows", workflowName, runId } = params;
-    const key = this.getKey(TABLE_WORKFLOW_SNAPSHOT, {
-      namespace,
-      workflow_name: workflowName,
-      run_id: runId
-    });
+};
+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 {
-      const data = await this.redis.get(key);
-      if (!data) return null;
-      return data.snapshot;
+      await this.scanAndDelete(pattern);
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_CLEAR_TABLE_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            namespace,
-            workflowName,
-            runId
+            tableName
           }
         },
         error
       );
     }
   }
-  /**
-   * Get all evaluations with pagination and total count
-   * @param options Pagination and filtering options
-   * @returns Object with evals array and total count
-   */
-  async getEvals(options) {
+  async dropTable({ tableName }) {
+    return this.clearTable({ tableName });
+  }
+  async insert({ tableName, record }) {
+    const { key, processedRecord } = processRecord(tableName, record);
     try {
-      const { agentName, type, page = 0, perPage = 100, dateRange } = options || {};
-      const fromDate = dateRange?.start;
-      const toDate = dateRange?.end;
-      const pattern = `${TABLE_EVALS}:*`;
-      const keys = await this.scanKeys(pattern);
-      if (keys.length === 0) {
-        return {
-          evals: [],
-          total: 0,
+      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
+      );
+    }
+  }
+  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();
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_BATCH_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    }
+  }
+  async load({ tableName, keys }) {
+    const key = getKey(tableName, keys);
+    try {
+      const data = await this.client.get(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 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),
+    extractStepResult: parseField(row.extractStepResult),
+    analyzeStepResult: parseField(row.analyzeStepResult),
+    metadata: parseField(row.metadata),
+    input: parseField(row.input),
+    output: parseField(row.output),
+    additionalContext: parseField(row.additionalContext),
+    runtimeContext: parseField(row.runtimeContext),
+    entity: parseField(row.entity),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+var ScoresUpstash = class extends ScoresStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async getScoreById({ id }) {
+    try {
+      const data = await this.operations.load({
+        tableName: TABLE_SCORERS,
+        keys: { id }
+      });
+      if (!data) return null;
+      return transformScoreRow(data);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_SCORE_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error
+      );
+    }
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    const pattern = `${TABLE_SCORERS}:*`;
+    const keys = await this.operations.scanKeys(pattern);
+    if (keys.length === 0) {
+      return {
+        scores: [],
+        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+      };
+    }
+    const pipeline = this.client.pipeline();
+    keys.forEach((key) => pipeline.get(key));
+    const results = await pipeline.exec();
+    const filtered = results.map((row) => row).filter((row) => !!row && typeof row === "object" && row.scorerId === scorerId);
+    const total = filtered.length;
+    const { page, perPage } = pagination;
+    const start = page * perPage;
+    const end = start + perPage;
+    const paged = filtered.slice(start, end);
+    const scores = paged.map((row) => transformScoreRow(row));
+    return {
+      scores,
+      pagination: {
+        total,
+        page,
+        perPage,
+        hasMore: end < total
+      }
+    };
+  }
+  async saveScore(score) {
+    const { key, processedRecord } = processRecord(TABLE_SCORERS, score);
+    try {
+      await this.client.set(key, processedRecord);
+      return { score };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_SAVE_SCORE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: score.id }
+        },
+        error
+      );
+    }
+  }
+  async getScoresByRunId({
+    runId,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    const pattern = `${TABLE_SCORERS}:*`;
+    const keys = await this.operations.scanKeys(pattern);
+    if (keys.length === 0) {
+      return {
+        scores: [],
+        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+      };
+    }
+    const pipeline = this.client.pipeline();
+    keys.forEach((key) => pipeline.get(key));
+    const results = await pipeline.exec();
+    const filtered = results.map((row) => row).filter((row) => !!row && typeof row === "object" && row.runId === runId);
+    const total = filtered.length;
+    const { page, perPage } = pagination;
+    const start = page * perPage;
+    const end = start + perPage;
+    const paged = filtered.slice(start, end);
+    const scores = paged.map((row) => transformScoreRow(row));
+    return {
+      scores,
+      pagination: {
+        total,
+        page,
+        perPage,
+        hasMore: end < total
+      }
+    };
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination = { page: 0, perPage: 20 }
+  }) {
+    const pattern = `${TABLE_SCORERS}:*`;
+    const keys = await this.operations.scanKeys(pattern);
+    if (keys.length === 0) {
+      return {
+        scores: [],
+        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+      };
+    }
+    const pipeline = this.client.pipeline();
+    keys.forEach((key) => pipeline.get(key));
+    const results = await pipeline.exec();
+    const filtered = results.map((row) => row).filter((row) => {
+      if (!row || typeof row !== "object") return false;
+      if (row.entityId !== entityId) return false;
+      if (entityType && row.entityType !== entityType) return false;
+      return true;
+    });
+    const total = filtered.length;
+    const { page, perPage } = pagination;
+    const start = page * perPage;
+    const end = start + perPage;
+    const paged = filtered.slice(start, end);
+    const scores = paged.map((row) => transformScoreRow(row));
+    return {
+      scores,
+      pagination: {
+        total,
+        page,
+        perPage,
+        hasMore: end < total
+      }
+    };
+  }
+};
+var TracesUpstash = class extends TracesStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
+  async getTraces(args) {
+    if (args.fromDate || args.toDate) {
+      args.dateRange = {
+        start: args.fromDate,
+        end: args.toDate
+      };
+    }
+    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
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    try {
+      const pattern = `${TABLE_TRACES}:*`;
+      const keys = await this.operations.scanKeys(pattern);
+      if (keys.length === 0) {
+        return {
+          traces: [],
+          total: 0,
           page,
-          perPage,
+          perPage: perPage || 100,
           hasMore: false
         };
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
-      let filteredEvals = results.map((result) => result).filter((record) => record !== null && typeof record === "object");
-      if (agentName) {
-        filteredEvals = filteredEvals.filter((record) => record.agent_name === agentName);
+      let filteredTraces = results.filter(
+        (record) => record !== null && typeof record === "object"
+      );
+      if (name) {
+        filteredTraces = filteredTraces.filter((record) => record.name?.toLowerCase().startsWith(name.toLowerCase()));
       }
-      if (type === "test") {
-        filteredEvals = filteredEvals.filter((record) => {
-          if (!record.test_info) return false;
-          try {
-            if (typeof record.test_info === "string") {
-              const parsedTestInfo = JSON.parse(record.test_info);
-              return parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo;
-            }
-            return typeof record.test_info === "object" && "testPath" in record.test_info;
-          } catch {
-            return false;
-          }
-        });
-      } else if (type === "live") {
-        filteredEvals = filteredEvals.filter((record) => {
-          if (!record.test_info) return true;
-          try {
-            if (typeof record.test_info === "string") {
-              const parsedTestInfo = JSON.parse(record.test_info);
-              return !(parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo);
-            }
-            return !(typeof record.test_info === "object" && "testPath" in record.test_info);
-          } catch {
-            return true;
-          }
+      if (scope) {
+        filteredTraces = filteredTraces.filter((record) => record.scope === scope);
+      }
+      if (attributes) {
+        filteredTraces = filteredTraces.filter((record) => {
+          const recordAttributes = record.attributes;
+          if (!recordAttributes) return false;
+          const parsedAttributes = typeof recordAttributes === "string" ? JSON.parse(recordAttributes) : recordAttributes;
+          return Object.entries(attributes).every(([key, value]) => parsedAttributes[key] === value);
         });
       }
+      if (filters) {
+        filteredTraces = filteredTraces.filter(
+          (record) => Object.entries(filters).every(([key, value]) => record[key] === value)
+        );
+      }
       if (fromDate) {
-        filteredEvals = filteredEvals.filter((record) => {
-          const createdAt = new Date(record.created_at || record.createdAt || 0);
-          return createdAt.getTime() >= fromDate.getTime();
-        });
+        filteredTraces = filteredTraces.filter(
+          (record) => new Date(record.createdAt).getTime() >= new Date(fromDate).getTime()
+        );
       }
       if (toDate) {
-        filteredEvals = filteredEvals.filter((record) => {
-          const createdAt = new Date(record.created_at || record.createdAt || 0);
-          return createdAt.getTime() <= toDate.getTime();
-        });
+        filteredTraces = filteredTraces.filter(
+          (record) => new Date(record.createdAt).getTime() <= new Date(toDate).getTime()
+        );
       }
-      filteredEvals.sort((a, b) => {
-        const dateA = new Date(a.created_at || a.createdAt || 0).getTime();
-        const dateB = new Date(b.created_at || b.createdAt || 0).getTime();
-        return dateB - dateA;
-      });
-      const total = filteredEvals.length;
-      const start = page * perPage;
-      const end = start + perPage;
-      const paginatedEvals = filteredEvals.slice(start, end);
+      filteredTraces.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+      const transformedTraces = filteredTraces.map((record) => ({
+        id: record.id,
+        parentSpanId: record.parentSpanId,
+        traceId: record.traceId,
+        name: record.name,
+        scope: record.scope,
+        kind: record.kind,
+        status: parseJSON(record.status),
+        events: parseJSON(record.events),
+        links: parseJSON(record.links),
+        attributes: parseJSON(record.attributes),
+        startTime: record.startTime,
+        endTime: record.endTime,
+        other: parseJSON(record.other),
+        createdAt: ensureDate(record.createdAt)
+      }));
+      const total = transformedTraces.length;
+      const resolvedPerPage = perPage || 100;
+      const start = page * resolvedPerPage;
+      const end = start + resolvedPerPage;
+      const paginatedTraces = transformedTraces.slice(start, end);
       const hasMore = end < total;
-      const evals = paginatedEvals.map((record) => this.transformEvalRecord(record));
       return {
-        evals,
+        traces: paginatedTraces,
         total,
         page,
-        perPage,
+        perPage: resolvedPerPage,
         hasMore
       };
     } catch (error) {
-      const { page = 0, perPage = 100 } = options || {};
-      const mastraError = new MastraError(
+      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,
+        page,
+        perPage: perPage || 100,
+        hasMore: false
+      };
+    }
+  }
+  async batchTraceInsert(args) {
+    return this.operations.batchInsert({
+      tableName: TABLE_TRACES,
+      records: args.records
+    });
+  }
+};
+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 }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async persistWorkflowSnapshot(params) {
+    const { namespace = "workflows", workflowName, runId, snapshot } = params;
+    try {
+      await this.operations.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace,
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ 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) {
+    const { namespace = "workflows", workflowName, runId } = params;
+    const key = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+      namespace,
+      workflow_name: workflowName,
+      run_id: runId
+    });
+    try {
+      const data = await this.client.get(key);
+      if (!data) return null;
+      return data.snapshot;
+    } catch (error) {
+      throw new MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_EVALS_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            page,
-            perPage
+            namespace,
+            workflowName,
+            runId
+          }
+        },
+        error
+      );
+    }
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    try {
+      const key = getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName, run_id: runId }) + "*";
+      const keys = await this.operations.scanKeys(key);
+      const workflows = await Promise.all(
+        keys.map(async (key2) => {
+          const data2 = await this.client.get(key2);
+          return data2;
+        })
+      );
+      const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
+      if (!data) return null;
+      return parseWorkflowRun(data);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            namespace: "workflows",
+            runId,
+            workflowName: workflowName || ""
           }
         },
         error
       );
-      this.logger.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return {
-        evals: [],
-        total: 0,
-        page,
-        perPage,
-        hasMore: false
-      };
     }
   }
   async getWorkflowRuns({
-    namespace,
     workflowName,
     fromDate,
     toDate,
     limit,
     offset,
     resourceId
-  } = { namespace: "workflows" }) {
+  }) {
     try {
-      let pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace }) + ":*";
+      let pattern = getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows" }) + ":*";
       if (workflowName && resourceId) {
-        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, {
-          namespace,
+        pattern = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+          namespace: "workflows",
           workflow_name: workflowName,
           run_id: "*",
           resourceId
         });
       } else if (workflowName) {
-        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName }) + ":*";
+        pattern = getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows", workflow_name: workflowName }) + ":*";
       } else if (resourceId) {
-        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: "*", run_id: "*", resourceId });
+        pattern = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+          namespace: "workflows",
+          workflow_name: "*",
+          run_id: "*",
+          resourceId
+        });
       }
-      const keys = await this.scanKeys(pattern);
+      const keys = await this.operations.scanKeys(pattern);
       if (keys.length === 0) {
         return { runs: [], total: 0 };
       }
-      const pipeline = this.redis.pipeline();
+      const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       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) => this.parseWorkflowRun(w)).filter((w) => {
+      ).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => parseWorkflowRun(w)).filter((w) => {
         if (fromDate && w.createdAt < fromDate) return false;
         if (toDate && w.createdAt > toDate) return false;
         return true;
@@ -1141,7 +1572,7 @@ var UpstashStore = class extends MastraStorage {
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            namespace,
+            namespace: "workflows",
             workflowName: workflowName || "",
             resourceId: resourceId || ""
           }
@@ -1150,113 +1581,203 @@ var UpstashStore = class extends MastraStorage {
       );
     }
   }
+};
+
+// src/storage/index.ts
+var UpstashStore = class extends MastraStorage {
+  redis;
+  stores;
+  constructor(config) {
+    super({ name: "Upstash" });
+    this.redis = new Redis({
+      url: config.url,
+      token: config.token
+    });
+    const operations = new StoreOperationsUpstash({ client: this.redis });
+    const traces = new TracesUpstash({ client: this.redis, operations });
+    const scores = new ScoresUpstash({ client: this.redis, operations });
+    const workflows = new WorkflowsUpstash({ client: this.redis, operations });
+    const memory = new StoreMemoryUpstash({ client: this.redis, operations });
+    const legacyEvals = new StoreLegacyEvalsUpstash({ client: this.redis, operations });
+    this.stores = {
+      operations,
+      traces,
+      scores,
+      workflows,
+      memory,
+      legacyEvals
+    };
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: false,
+      createTable: false
+    };
+  }
+  /**
+   * @deprecated Use getEvals instead
+   */
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  /**
+   * Get all evaluations with pagination and total count
+   * @param options Pagination and filtering options
+   * @returns Object with evals array and total count
+   */
+  async getEvals(options) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async batchTraceInsert(args) {
+    return this.stores.traces.batchTraceInsert(args);
+  }
+  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 });
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  async getThreadsByResourceId({ resourceId }) {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  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 getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, selectBy, format });
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
+  async persistWorkflowSnapshot(params) {
+    return this.stores.workflows.persistWorkflowSnapshot(params);
+  }
+  async loadWorkflowSnapshot(params) {
+    return this.stores.workflows.loadWorkflowSnapshot(params);
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
   async getWorkflowRunById({
-    namespace = "workflows",
     runId,
     workflowName
   }) {
-    try {
-      const key = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId }) + "*";
-      const keys = await this.scanKeys(key);
-      const workflows = await Promise.all(
-        keys.map(async (key2) => {
-          const data2 = await this.redis.get(key2);
-          return data2;
-        })
-      );
-      const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
-      if (!data) return null;
-      return this.parseWorkflowRun(data);
-    } catch (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
-      );
-    }
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
   }
   async close() {
   }
-  async updateMessages(_args) {
-    this.logger.error("updateMessages is not yet implemented in UpstashStore");
-    throw new Error("Method not implemented");
+  async updateMessages(args) {
+    return this.stores.memory.updateMessages(args);
   }
   async getResourceById({ resourceId }) {
-    try {
-      const key = `${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;
-    }
+    return this.stores.memory.getResourceById({ resourceId });
   }
   async saveResource({ resource }) {
-    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;
-    }
+    return this.stores.memory.saveResource({ resource });
   }
   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;
-    }
+    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 getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({
+      entityId,
+      entityType,
+      pagination
+    });
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination });
   }
 };
 var UpstashFilterTranslator = class extends BaseFilterTranslator {