@mastra/upstash 0.15.8-alpha.0 → 1.0.0-beta.0

package/dist/index.cjs

@@ -2,224 +2,15 @@
 
 var storage = require('@mastra/core/storage');
 var redis = require('@upstash/redis');
-var error = require('@mastra/core/error');
 var agent = require('@mastra/core/agent');
-var scores = require('@mastra/core/scores');
+var error = require('@mastra/core/error');
+var evals = require('@mastra/core/evals');
 var crypto = require('crypto');
 var vector = require('@mastra/core/vector');
 var vector$1 = require('@upstash/vector');
 var filter = require('@mastra/core/vector/filter');
 
 // src/storage/index.ts
-function 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()
-  };
-}
-var StoreLegacyEvalsUpstash = class extends storage.LegacyEvalsStorage {
-  client;
-  operations;
-  constructor({ client, operations }) {
-    super();
-    this.client = client;
-    this.operations = operations;
-  }
-  /**
-   * @deprecated Use getEvals instead
-   */
-  async getEvalsByAgentName(agentName, type) {
-    try {
-      const pattern = `${storage.TABLE_EVALS}:*`;
-      const keys = await this.operations.scanKeys(pattern);
-      if (keys.length === 0) {
-        return [];
-      }
-      const pipeline = this.client.pipeline();
-      keys.forEach((key) => pipeline.get(key));
-      const results = await pipeline.exec();
-      const nonNullRecords = results.filter(
-        (record) => record !== null && typeof record === "object" && "agent_name" in record && record.agent_name === agentName
-      );
-      let filteredEvals = nonNullRecords;
-      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;
-          }
-        });
-      }
-      return filteredEvals.map((record) => transformEvalRecord(record));
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_GET_EVALS_BY_AGENT_NAME_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentName }
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      return [];
-    }
-  }
-  /**
-   * 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) {
-    try {
-      const { agentName, type, page = 0, perPage = 100, dateRange } = options || {};
-      const fromDate = dateRange?.start;
-      const toDate = dateRange?.end;
-      const pattern = `${storage.TABLE_EVALS}:*`;
-      const keys = await this.operations.scanKeys(pattern);
-      if (keys.length === 0) {
-        return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
-      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);
-      }
-      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 (fromDate) {
-        filteredEvals = filteredEvals.filter((record) => {
-          const createdAt = new Date(record.created_at || record.createdAt || 0);
-          return createdAt.getTime() >= fromDate.getTime();
-        });
-      }
-      if (toDate) {
-        filteredEvals = filteredEvals.filter((record) => {
-          const createdAt = new Date(record.created_at || record.createdAt || 0);
-          return createdAt.getTime() <= 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);
-      const hasMore = end < total;
-      const evals = paginatedEvals.map((record) => transformEvalRecord(record));
-      return {
-        evals,
-        total,
-        page,
-        perPage,
-        hasMore
-      };
-    } catch (error$1) {
-      const { page = 0, perPage = 100 } = options || {};
-      const mastraError = new error.MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_GET_EVALS_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            page,
-            perPage
-          }
-        },
-        error$1
-      );
-      this.logger.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return {
-        evals: [],
-        total: 0,
-        page,
-        perPage,
-        hasMore: false
-      };
-    }
-  }
-};
 function ensureDate(value) {
   if (!value) return null;
   if (value instanceof Date) return value;
@@ -227,16 +18,6 @@ function ensureDate(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(":")}`;
@@ -252,8 +33,6 @@ function processRecord(tableName, record) {
       run_id: record.run_id,
       ...record.resourceId ? { resourceId: record.resourceId } : {}
     });
-  } else if (tableName === storage.TABLE_EVALS) {
-    key = getKey(tableName, { id: record.run_id });
   } else if (tableName === storage.TABLE_SCORERS) {
     key = getKey(tableName, { runId: record.runId });
   } else {
@@ -310,17 +89,26 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       );
     }
   }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead
-   */
-  async getThreadsByResourceId({ resourceId }) {
+  async listThreadsByResourceId(args) {
+    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+    const { field, direction } = this.parseOrderBy(orderBy);
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     try {
+      let allThreads = [];
       const pattern = `${storage.TABLE_THREADS}:*`;
       const keys = await this.operations.scanKeys(pattern);
-      if (keys.length === 0) {
-        return [];
-      }
-      const allThreads = [];
       const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
@@ -335,45 +123,22 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
           });
         }
       }
-      allThreads.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-      return allThreads;
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_GET_THREADS_BY_RESOURCE_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            resourceId
-          }
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      return [];
-    }
-  }
-  async getThreadsByResourceIdPaginated(args) {
-    const { resourceId, page = 0, perPage = 100 } = args;
-    try {
-      const allThreads = await this.getThreadsByResourceId({ resourceId });
-      const total = allThreads.length;
-      const start = page * perPage;
-      const end = start + perPage;
-      const paginatedThreads = allThreads.slice(start, end);
-      const hasMore = end < total;
+      const sortedThreads = this.sortThreads(allThreads, field, direction);
+      const total = sortedThreads.length;
+      const end = perPageInput === false ? total : offset + perPage;
+      const paginatedThreads = sortedThreads.slice(offset, end);
+      const hasMore = perPageInput === false ? false : end < total;
       return {
         threads: paginatedThreads,
         total,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -390,7 +155,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
         threads: [],
         total: 0,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore: false
       };
     }
@@ -491,8 +256,8 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
     }
   }
   async saveMessages(args) {
-    const { messages, format = "v1" } = args;
-    if (messages.length === 0) return [];
+    const { messages } = args;
+    if (messages.length === 0) return { messages: [] };
     const threadId = messages[0]?.threadId;
     try {
       if (!threadId) {
@@ -545,9 +310,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
             const pipeline2 = this.client.pipeline();
             keys.forEach((key2) => pipeline2.get(key2));
             const results = await pipeline2.exec();
-            const existingMessages = results.filter(
-              (msg) => msg !== null
-            );
+            const existingMessages = results.filter((msg) => msg !== null);
             for (const existingMessage of existingMessages) {
               const existingMessageKey = getMessageKey(existingMessage.threadId, existingMessage.id);
               if (existingMessage && existingMessage.threadId !== message.threadId) {
@@ -572,8 +335,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
         await pipeline.exec();
       }
       const list = new agent.MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -588,12 +350,12 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       );
     }
   }
-  async _getIncludedMessages(threadId, selectBy) {
+  async _getIncludedMessages(threadId, include) {
     if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
     const messageIds = /* @__PURE__ */ new Set();
     const messageIdToThreadIds = {};
-    if (selectBy?.include?.length) {
-      for (const item of selectBy.include) {
+    if (include?.length) {
+      for (const item of include) {
         messageIds.add(item.id);
         const itemThreadId = item.threadId || threadId;
         messageIdToThreadIds[item.id] = itemThreadId;
@@ -635,89 +397,8 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       content: rest.content || defaultMessageContent
     };
   }
-  async getMessages({
-    threadId,
-    resourceId,
-    selectBy,
-    format
-  }) {
-    try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      const threadMessagesKey = getThreadMessagesKey(threadId);
-      const allMessageIds = await this.client.zrange(threadMessagesKey, 0, -1);
-      const limit = storage.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.client.zrange(threadMessagesKey, 0, -1);
-        allIds.forEach((id) => {
-          messageIds.add(id);
-          messageIdToThreadIds[id] = threadId;
-        });
-      } else if (limit > 0) {
-        const latestIds = await this.client.zrange(threadMessagesKey, -limit, -1);
-        latestIds.forEach((id) => {
-          messageIds.add(id);
-          messageIdToThreadIds[id] = threadId;
-        });
-      }
-      const includedMessages = await this._getIncludedMessages(threadId, selectBy);
-      const messages = [
-        ...includedMessages,
-        ...(await Promise.all(
-          Array.from(messageIds).map(async (id) => {
-            const tId = messageIdToThreadIds[id] || threadId;
-            const byThreadId = await this.client.get(getMessageKey(tId, id));
-            if (byThreadId) return byThreadId;
-            return null;
-          })
-        )).filter((msg) => msg !== null)
-      ];
-      messages.sort((a, b) => allMessageIds.indexOf(a.id) - allMessageIds.indexOf(b.id));
-      const seen = /* @__PURE__ */ new Set();
-      const dedupedMessages = messages.filter((row) => {
-        if (seen.has(row.id)) return false;
-        seen.add(row.id);
-        return true;
-      });
-      const prepared = dedupedMessages.filter((message) => message !== null && message !== void 0).map((message) => {
-        const { _index, ...messageWithoutIndex } = message;
-        return messageWithoutIndex;
-      });
-      if (format === "v2") {
-        return prepared.map((msg) => ({
-          ...msg,
-          createdAt: new Date(msg.createdAt),
-          content: msg.content || { format: 2, parts: [{ type: "text", text: "" }] }
-        }));
-      }
-      return prepared.map((msg) => ({
-        ...msg,
-        createdAt: new Date(msg.createdAt)
-      }));
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_GET_MESSAGES_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-            resourceId: resourceId ?? ""
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    if (messageIds.length === 0) return [];
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
     try {
       const threadKeys = await this.client.keys("thread:*");
       const result = await Promise.all(
@@ -731,12 +412,11 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       );
       const rawMessages = result.flat(1).filter((msg) => !!msg);
       const list = new agent.MessageList().add(rawMessages.map(this.parseStoredMessage), "memory");
-      if (format === `v1`) return list.get.all.v1();
-      return list.get.all.v2();
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_MESSAGES_BY_ID_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_LIST_MESSAGES_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -747,61 +427,137 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       );
     }
   }
-  async getMessagesPaginated(args) {
-    const { threadId, resourceId, selectBy, format } = args;
-    const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    if (!threadId.trim()) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_UPSTASH_LIST_MESSAGES_INVALID_THREAD_ID",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        new Error("threadId must be a non-empty string")
+      );
+    }
     const threadMessagesKey = getThreadMessagesKey(threadId);
-    const messages = [];
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      const includedMessages = await this._getIncludedMessages(threadId, selectBy);
-      messages.push(...includedMessages);
-      const allMessageIds = await this.client.zrange(
-        threadMessagesKey,
-        args?.selectBy?.last ? -args.selectBy.last : 0,
-        -1
-      );
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: "STORAGE_UPSTASH_LIST_MESSAGES_INVALID_PAGE",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      let includedMessages = [];
+      if (include && include.length > 0) {
+        const included = await this._getIncludedMessages(threadId, include);
+        includedMessages = included.map(this.parseStoredMessage);
+      }
+      const allMessageIds = await this.client.zrange(threadMessagesKey, 0, -1);
       if (allMessageIds.length === 0) {
         return {
           messages: [],
           total: 0,
           page,
-          perPage,
+          perPage: perPageForResponse,
           hasMore: false
         };
       }
       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) {
-        messagesData = messagesData.filter((msg) => msg && new Date(msg.createdAt).getTime() >= fromDate.getTime());
+      let messagesData = results.filter((msg) => msg !== null).map(this.parseStoredMessage);
+      if (resourceId) {
+        messagesData = messagesData.filter((msg) => msg.resourceId === resourceId);
+      }
+      const dateRange = filter?.dateRange;
+      if (dateRange?.start) {
+        const fromDate = dateRange.start;
+        messagesData = messagesData.filter((msg) => new Date(msg.createdAt).getTime() >= fromDate.getTime());
       }
-      if (toDate) {
-        messagesData = messagesData.filter((msg) => msg && new Date(msg.createdAt).getTime() <= toDate.getTime());
+      if (dateRange?.end) {
+        const toDate = dateRange.end;
+        messagesData = messagesData.filter((msg) => new Date(msg.createdAt).getTime() <= toDate.getTime());
+      }
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const getFieldValue = (msg) => {
+        if (field === "createdAt") {
+          return new Date(msg.createdAt).getTime();
+        }
+        const value = msg[field];
+        if (typeof value === "number") {
+          return value;
+        }
+        if (value instanceof Date) {
+          return value.getTime();
+        }
+        return 0;
+      };
+      if (orderBy) {
+        messagesData.sort((a, b) => {
+          const aValue = getFieldValue(a);
+          const bValue = getFieldValue(b);
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        });
       }
-      messagesData.sort((a, b) => allMessageIds.indexOf(a.id) - allMessageIds.indexOf(b.id));
       const total = messagesData.length;
-      const start = page * perPage;
-      const end = start + perPage;
-      const hasMore = end < total;
+      const start = offset;
+      const end = perPageInput === false ? total : start + perPage;
       const paginatedMessages = messagesData.slice(start, end);
-      messages.push(...paginatedMessages);
-      const list = new agent.MessageList().add(messages, "memory");
-      const finalMessages = format === `v2` ? list.get.all.v2() : list.get.all.v1();
+      const messageIds = /* @__PURE__ */ new Set();
+      const allMessages = [];
+      for (const msg of paginatedMessages) {
+        if (!messageIds.has(msg.id)) {
+          allMessages.push(msg);
+          messageIds.add(msg.id);
+        }
+      }
+      for (const msg of includedMessages) {
+        if (!messageIds.has(msg.id)) {
+          allMessages.push(msg);
+          messageIds.add(msg.id);
+        }
+      }
+      const list = new agent.MessageList().add(allMessages, "memory");
+      let finalMessages = list.get.all.db();
+      if (orderBy) {
+        finalMessages = finalMessages.sort((a, b) => {
+          const aValue = getFieldValue(a);
+          const bValue = getFieldValue(b);
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        });
+      } else {
+        const messageIdToPosition = /* @__PURE__ */ new Map();
+        allMessageIds.forEach((id, index) => {
+          messageIdToPosition.set(id, index);
+        });
+        finalMessages = finalMessages.sort((a, b) => {
+          const aPos = messageIdToPosition.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+          const bPos = messageIdToPosition.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+          return aPos - bPos;
+        });
+      }
+      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput !== false && !allThreadMessagesReturned && end < total;
       return {
         messages: finalMessages,
         total,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_MESSAGES_PAGINATED_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_LIST_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -817,7 +573,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
         messages: [],
         total: 0,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore: false
       };
     }
@@ -984,8 +740,7 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
         if (key) {
           const updatedMessage = await this.client.get(key);
           if (updatedMessage) {
-            const v2e = updatedMessage;
-            updatedMessages.push(v2e);
+            updatedMessages.push(updatedMessage);
           }
         }
       }
@@ -1058,6 +813,17 @@ var StoreMemoryUpstash = class extends storage.MemoryStorage {
       );
     }
   }
+  sortThreads(threads, field, direction) {
+    return threads.sort((a, b) => {
+      const aValue = new Date(a[field]).getTime();
+      const bValue = new Date(b[field]).getTime();
+      if (direction === "ASC") {
+        return aValue - bValue;
+      } else {
+        return bValue - aValue;
+      }
+    });
+  }
 };
 var StoreOperationsUpstash = class extends storage.StoreOperations {
   client;
@@ -1217,7 +983,7 @@ function transformScoreRow(row) {
     input: parseField(row.input),
     output: parseField(row.output),
     additionalContext: parseField(row.additionalContext),
-    runtimeContext: parseField(row.runtimeContext),
+    requestContext: parseField(row.requestContext),
     entity: parseField(row.entity),
     createdAt: row.createdAt,
     updatedAt: row.updatedAt
@@ -1251,7 +1017,7 @@ var ScoresUpstash = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresByScorerId({
+  async listScoresByScorerId({
     scorerId,
     entityId,
     entityType,
@@ -1260,16 +1026,27 @@ var ScoresUpstash = class extends storage.ScoresStorage {
   }) {
     const pattern = `${storage.TABLE_SCORERS}:*`;
     const keys = await this.operations.scanKeys(pattern);
+    const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
         scores: [],
-        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+        pagination: { total: 0, page, perPage: perPageInput, 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) => {
+    const filtered = results.map((raw) => {
+      if (!raw) return null;
+      if (typeof raw === "string") {
+        try {
+          return JSON.parse(raw);
+        } catch {
+          return null;
+        }
+      }
+      return raw;
+    }).filter((row) => {
       if (!row || typeof row !== "object") return false;
       if (row.scorerId !== scorerId) return false;
       if (entityId && row.entityId !== entityId) return false;
@@ -1277,10 +1054,10 @@ var ScoresUpstash = class extends storage.ScoresStorage {
       if (source && row.source !== source) return false;
       return true;
     });
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? filtered.length : start + perPage;
     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 {
@@ -1288,7 +1065,7 @@ var ScoresUpstash = class extends storage.ScoresStorage {
       pagination: {
         total,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore: end < total
       }
     };
@@ -1296,7 +1073,7 @@ var ScoresUpstash = class extends storage.ScoresStorage {
   async saveScore(score) {
     let validatedScore;
     try {
-      validatedScore = scores.saveScorePayloadSchema.parse(score);
+      validatedScore = evals.saveScorePayloadSchema.parse(score);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1323,26 +1100,37 @@ var ScoresUpstash = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresByRunId({
+  async listScoresByRunId({
     runId,
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${storage.TABLE_SCORERS}:*`;
     const keys = await this.operations.scanKeys(pattern);
+    const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
         scores: [],
-        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+        pagination: { total: 0, page, perPage: perPageInput, 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 filtered = results.map((raw) => {
+      if (!raw) return null;
+      if (typeof raw === "string") {
+        try {
+          return JSON.parse(raw);
+        } catch {
+          return null;
+        }
+      }
+      return raw;
+    }).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 perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? filtered.length : start + perPage;
     const paged = filtered.slice(start, end);
     const scores = paged.map((row) => transformScoreRow(row));
     return {
@@ -1350,37 +1138,48 @@ var ScoresUpstash = class extends storage.ScoresStorage {
       pagination: {
         total,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore: end < total
       }
     };
   }
-  async getScoresByEntityId({
+  async listScoresByEntityId({
     entityId,
     entityType,
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${storage.TABLE_SCORERS}:*`;
     const keys = await this.operations.scanKeys(pattern);
+    const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
         scores: [],
-        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+        pagination: { total: 0, page, perPage: perPageInput, 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) => {
+    const filtered = results.map((raw) => {
+      if (!raw) return null;
+      if (typeof raw === "string") {
+        try {
+          return JSON.parse(raw);
+        } catch {
+          return null;
+        }
+      }
+      return raw;
+    }).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 perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? filtered.length : start + perPage;
     const paged = filtered.slice(start, end);
     const scores = paged.map((row) => transformScoreRow(row));
     return {
@@ -1388,37 +1187,48 @@ var ScoresUpstash = class extends storage.ScoresStorage {
       pagination: {
         total,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore: end < total
       }
     };
   }
-  async getScoresBySpan({
+  async listScoresBySpan({
     traceId,
     spanId,
     pagination = { page: 0, perPage: 20 }
   }) {
     const pattern = `${storage.TABLE_SCORERS}:*`;
     const keys = await this.operations.scanKeys(pattern);
+    const { page, perPage: perPageInput } = pagination;
     if (keys.length === 0) {
       return {
         scores: [],
-        pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }
+        pagination: { total: 0, page, perPage: perPageInput, 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) => {
+    const filtered = results.map((raw) => {
+      if (!raw) return null;
+      if (typeof raw === "string") {
+        try {
+          return JSON.parse(raw);
+        } catch {
+          return null;
+        }
+      }
+      return raw;
+    }).filter((row) => {
       if (!row || typeof row !== "object") return false;
       if (row.traceId !== traceId) return false;
       if (row.spanId !== spanId) return false;
       return true;
     });
     const total = filtered.length;
-    const { page, perPage } = pagination;
-    const start = page * perPage;
-    const end = start + perPage;
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const end = perPageInput === false ? filtered.length : start + perPage;
     const paged = filtered.slice(start, end);
     const scores = paged.map((row) => transformScoreRow(row));
     return {
@@ -1426,156 +1236,12 @@ var ScoresUpstash = class extends storage.ScoresStorage {
       pagination: {
         total,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore: end < total
       }
     };
   }
 };
-var TracesUpstash = class extends storage.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$1) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_GET_TRACES_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  async getTracesPaginated(args) {
-    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    try {
-      const pattern = `${storage.TABLE_TRACES}:*`;
-      const keys = await this.operations.scanKeys(pattern);
-      if (keys.length === 0) {
-        return {
-          traces: [],
-          total: 0,
-          page,
-          perPage: perPage || 100,
-          hasMore: false
-        };
-      }
-      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);
-      }
-      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) {
-        filteredTraces = filteredTraces.filter(
-          (record) => new Date(record.createdAt).getTime() >= new Date(fromDate).getTime()
-        );
-      }
-      if (toDate) {
-        filteredTraces = filteredTraces.filter(
-          (record) => new Date(record.createdAt).getTime() <= new Date(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: 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;
-      return {
-        traces: paginatedTraces,
-        total,
-        page,
-        perPage: resolvedPerPage,
-        hasMore
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "STORAGE_UPSTASH_STORAGE_GET_TRACES_PAGINATED_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            name: args.name || "",
-            scope: args.scope || ""
-          }
-        },
-        error$1
-      );
-      this.logger?.trackException(mastraError);
-      this.logger.error(mastraError.toString());
-      return {
-        traces: [],
-        total: 0,
-        page,
-        perPage: perPage || 100,
-        hasMore: false
-      };
-    }
-  }
-  async batchTraceInsert(args) {
-    return this.operations.batchInsert({
-      tableName: storage.TABLE_TRACES,
-      records: args.records
-    });
-  }
-};
 function parseWorkflowRun(row) {
   let parsedSnapshot = row.snapshot;
   if (typeof parsedSnapshot === "string") {
@@ -1607,7 +1273,7 @@ var WorkflowsUpstash = class extends storage.WorkflowsStorage {
     // runId,
     // stepId,
     // result,
-    // runtimeContext,
+    // requestContext,
   }) {
     throw new Error("Method not implemented.");
   }
@@ -1708,15 +1374,26 @@ var WorkflowsUpstash = class extends storage.WorkflowsStorage {
       );
     }
   }
-  async getWorkflowRuns({
+  async listWorkflowRuns({
     workflowName,
     fromDate,
     toDate,
-    limit,
-    offset,
+    perPage,
+    page,
     resourceId
   }) {
     try {
+      if (page !== void 0 && page < 0) {
+        throw new error.MastraError(
+          {
+            id: "UPSTASH_STORE_INVALID_PAGE",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
       let pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows" }) + ":*";
       if (workflowName && resourceId) {
         pattern = getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
@@ -1750,14 +1427,16 @@ var WorkflowsUpstash = class extends storage.WorkflowsStorage {
         return true;
       }).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
       const total = runs.length;
-      if (limit !== void 0 && offset !== void 0) {
-        runs = runs.slice(offset, offset + limit);
+      if (typeof perPage === "number" && typeof page === "number") {
+        const normalizedPerPage = storage.normalizePerPage(perPage, Number.MAX_SAFE_INTEGER);
+        const offset = page * normalizedPerPage;
+        runs = runs.slice(offset, offset + normalizedPerPage);
       }
       return { runs, total };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_UPSTASH_STORAGE_GET_WORKFLOW_RUNS_FAILED",
+          id: "STORAGE_UPSTASH_STORAGE_LIST_WORKFLOW_RUNS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -1777,24 +1456,20 @@ var UpstashStore = class extends storage.MastraStorage {
   redis;
   stores;
   constructor(config) {
-    super({ name: "Upstash" });
+    super({ id: config.id, name: "Upstash" });
     this.redis = new redis.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
+      memory
     };
   }
   get supports() {
@@ -1804,35 +1479,9 @@ var UpstashStore = class extends storage.MastraStorage {
       hasColumn: false,
       createTable: false,
       deleteMessages: true,
-      getScoresBySpan: true
+      listScoresBySpan: true
     };
   }
-  /**
-   * @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
@@ -1866,15 +1515,6 @@ var UpstashStore = class extends storage.MastraStorage {
   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 });
   }
@@ -1891,30 +1531,17 @@ var UpstashStore = class extends storage.MastraStorage {
   async saveMessages(args) {
     return this.stores.memory.saveMessages(args);
   }
-  async getMessages({
-    threadId,
-    selectBy,
-    format
-  }) {
-    return this.stores.memory.getMessages({ threadId, selectBy, format });
-  }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    return this.stores.memory.getMessagesById({ messageIds, format });
-  }
-  async getMessagesPaginated(args) {
-    return this.stores.memory.getMessagesPaginated(args);
+  async listMessagesById({ messageIds }) {
+    return this.stores.memory.listMessagesById({ messageIds });
   }
   async updateWorkflowResults({
     workflowName,
     runId,
     stepId,
     result,
-    runtimeContext
+    requestContext
   }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
   }
   async updateWorkflowState({
     workflowName,
@@ -1929,15 +1556,15 @@ var UpstashStore = class extends storage.MastraStorage {
   async loadWorkflowSnapshot(params) {
     return this.stores.workflows.loadWorkflowSnapshot(params);
   }
-  async getWorkflowRuns({
+  async listWorkflowRuns({
     workflowName,
     fromDate,
     toDate,
-    limit,
-    offset,
+    perPage,
+    page,
     resourceId
   } = {}) {
-    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+    return this.stores.workflows.listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId });
   }
   async getWorkflowRunById({
     runId,
@@ -1972,38 +1599,38 @@ var UpstashStore = class extends storage.MastraStorage {
   async saveScore(score) {
     return this.stores.scores.saveScore(score);
   }
-  async getScoresByRunId({
+  async listScoresByRunId({
     runId,
     pagination
   }) {
-    return this.stores.scores.getScoresByRunId({ runId, pagination });
+    return this.stores.scores.listScoresByRunId({ runId, pagination });
   }
-  async getScoresByEntityId({
+  async listScoresByEntityId({
     entityId,
     entityType,
     pagination
   }) {
-    return this.stores.scores.getScoresByEntityId({
+    return this.stores.scores.listScoresByEntityId({
       entityId,
       entityType,
       pagination
     });
   }
-  async getScoresByScorerId({
+  async listScoresByScorerId({
     scorerId,
     pagination,
     entityId,
     entityType,
     source
   }) {
-    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
+    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
   }
-  async getScoresBySpan({
+  async listScoresBySpan({
     traceId,
     spanId,
     pagination
   }) {
-    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination });
+    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
   }
 };
 var UpstashFilterTranslator = class extends filter.BaseFilterTranslator {
@@ -2204,11 +1831,12 @@ var UpstashVector = class extends vector.MastraVector {
   /**
    * Creates a new UpstashVector instance.
    * @param {object} params - The parameters for the UpstashVector.
+   * @param {string} params.id - The unique identifier for this vector store instance.
    * @param {string} params.url - The URL of the Upstash vector index.
    * @param {string} params.token - The token for the Upstash vector index.
    */
-  constructor({ url, token }) {
-    super();
+  constructor({ url, token, id }) {
+    super({ id });
     this.client = new vector$1.Index({
       url,
       token