@mastra/dynamodb 0.0.0-netlify-no-bundle-20251127120354 → 0.0.0-partial-response-backport-20251204204441

package/dist/index.cjs

@@ -6,7 +6,7 @@ var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
 var electrodb = require('electrodb');
 var agent = require('@mastra/core/agent');
-var evals = require('@mastra/core/evals');
+var scores = require('@mastra/core/scores');
 
 // src/storage/index.ts
 
@@ -568,7 +568,7 @@ var scoreEntity = new electrodb.Entity({
         return value;
       }
     },
-    requestContext: {
+    runtimeContext: {
       type: "string",
       required: false,
       set: (value) => {
@@ -939,6 +939,187 @@ function getElectroDbService(client, tableName) {
     }
   );
 }
+var LegacyEvalsDynamoDB = class extends storage.LegacyEvalsStorage {
+  service;
+  tableName;
+  constructor({ service, tableName }) {
+    super();
+    this.service = service;
+    this.tableName = tableName;
+  }
+  // Eval operations
+  async getEvalsByAgentName(agentName, type) {
+    this.logger.debug("Getting evals for agent", { agentName, type });
+    try {
+      const query = this.service.entities.eval.query.byAgent({ entity: "eval", agent_name: agentName });
+      const results = await query.go({ order: "desc", limit: 100 });
+      if (!results.data.length) {
+        return [];
+      }
+      let filteredData = results.data;
+      if (type) {
+        filteredData = filteredData.filter((evalRecord) => {
+          try {
+            const testInfo = evalRecord.test_info && typeof evalRecord.test_info === "string" ? JSON.parse(evalRecord.test_info) : void 0;
+            if (type === "test" && !testInfo) {
+              return false;
+            }
+            if (type === "live" && testInfo) {
+              return false;
+            }
+          } catch (e) {
+            this.logger.warn("Failed to parse test_info during filtering", { record: evalRecord, error: e });
+          }
+          return true;
+        });
+      }
+      return filteredData.map((evalRecord) => {
+        try {
+          return {
+            input: evalRecord.input,
+            output: evalRecord.output,
+            // Safely parse result and test_info
+            result: evalRecord.result && typeof evalRecord.result === "string" ? JSON.parse(evalRecord.result) : void 0,
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            // Keep as string from DDB?
+            metricName: evalRecord.metric_name,
+            instructions: evalRecord.instructions,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id,
+            testInfo: evalRecord.test_info && typeof evalRecord.test_info === "string" ? JSON.parse(evalRecord.test_info) : void 0
+          };
+        } catch (parseError) {
+          this.logger.error("Failed to parse eval record", { record: evalRecord, error: parseError });
+          return {
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id
+          };
+        }
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error$1
+      );
+    }
+  }
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    this.logger.debug("Getting evals with pagination", { agentName, type, page, perPage, dateRange });
+    try {
+      let query;
+      if (agentName) {
+        query = this.service.entities.eval.query.byAgent({ entity: "eval", agent_name: agentName });
+      } else {
+        query = this.service.entities.eval.query.byEntity({ entity: "eval" });
+      }
+      const results = await query.go({
+        order: "desc",
+        pages: "all"
+        // Get all pages to apply filtering and pagination
+      });
+      if (!results.data.length) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      let filteredData = results.data;
+      if (type) {
+        filteredData = filteredData.filter((evalRecord) => {
+          try {
+            const testInfo = evalRecord.test_info && typeof evalRecord.test_info === "string" ? JSON.parse(evalRecord.test_info) : void 0;
+            if (type === "test" && !testInfo) {
+              return false;
+            }
+            if (type === "live" && testInfo) {
+              return false;
+            }
+          } catch (e) {
+            this.logger.warn("Failed to parse test_info during filtering", { record: evalRecord, error: e });
+          }
+          return true;
+        });
+      }
+      if (dateRange) {
+        const fromDate = dateRange.start;
+        const toDate = dateRange.end;
+        filteredData = filteredData.filter((evalRecord) => {
+          const recordDate = new Date(evalRecord.created_at);
+          if (fromDate && recordDate < fromDate) {
+            return false;
+          }
+          if (toDate && recordDate > toDate) {
+            return false;
+          }
+          return true;
+        });
+      }
+      const total = filteredData.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedData = filteredData.slice(start, end);
+      const evals = paginatedData.map((evalRecord) => {
+        try {
+          return {
+            input: evalRecord.input,
+            output: evalRecord.output,
+            result: evalRecord.result && typeof evalRecord.result === "string" ? JSON.parse(evalRecord.result) : void 0,
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            metricName: evalRecord.metric_name,
+            instructions: evalRecord.instructions,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id,
+            testInfo: evalRecord.test_info && typeof evalRecord.test_info === "string" ? JSON.parse(evalRecord.test_info) : void 0
+          };
+        } catch (parseError) {
+          this.logger.error("Failed to parse eval record", { record: evalRecord, error: parseError });
+          return {
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id
+          };
+        }
+      });
+      const hasMore = end < total;
+      return {
+        evals,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_EVALS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            agentName: agentName || "all",
+            type: type || "all",
+            page,
+            perPage
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
 var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
   service;
   constructor({ service }) {
@@ -957,17 +1138,17 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
     };
   }
   // Helper function to transform and sort threads
-  transformAndSortThreads(rawThreads, field, direction) {
+  transformAndSortThreads(rawThreads, orderBy, sortDirection) {
     return rawThreads.map((data) => ({
       ...data,
       // Convert date strings back to Date objects for consistency
       createdAt: typeof data.createdAt === "string" ? new Date(data.createdAt) : data.createdAt,
       updatedAt: typeof data.updatedAt === "string" ? new Date(data.updatedAt) : data.updatedAt
     })).sort((a, b) => {
-      const fieldA = field === "createdAt" ? a.createdAt : a.updatedAt;
-      const fieldB = field === "createdAt" ? b.createdAt : b.updatedAt;
+      const fieldA = orderBy === "createdAt" ? a.createdAt : a.updatedAt;
+      const fieldB = orderBy === "createdAt" ? b.createdAt : b.updatedAt;
       const comparison = fieldA.getTime() - fieldB.getTime();
-      return direction === "DESC" ? -comparison : comparison;
+      return sortDirection === "DESC" ? -comparison : comparison;
     });
   }
   async getThreadById({ threadId }) {
@@ -998,6 +1179,32 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       );
     }
   }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+   */
+  async getThreadsByResourceId(args) {
+    const resourceId = args.resourceId;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
+    this.logger.debug("Getting threads by resource ID", { resourceId, orderBy, sortDirection });
+    try {
+      const result = await this.service.entities.thread.query.byResource({ entity: "thread", resourceId }).go();
+      if (!result.data.length) {
+        return [];
+      }
+      return this.transformAndSortThreads(result.data, orderBy, sortDirection);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
   async saveThread({ thread }) {
     this.logger.debug("Saving thread", { threadId: thread.id });
     const now = /* @__PURE__ */ new Date();
@@ -1017,7 +1224,7 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
         resourceId: thread.resourceId,
         title: threadData.title,
         createdAt: thread.createdAt || now,
-        updatedAt: thread.updatedAt || now,
+        updatedAt: now,
         metadata: thread.metadata
       };
     } catch (error$1) {
@@ -1077,7 +1284,7 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
   async deleteThread({ threadId }) {
     this.logger.debug("Deleting thread", { threadId });
     try {
-      const { messages } = await this.listMessages({ threadId, perPage: false });
+      const messages = await this.getMessages({ threadId });
       if (messages.length > 0) {
         const batchSize = 25;
         for (let i = 0; i < messages.length; i += batchSize) {
@@ -1106,175 +1313,104 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       );
     }
   }
-  async listMessagesById({ messageIds }) {
-    this.logger.debug("Getting messages by ID", { messageIds });
-    if (messageIds.length === 0) return { messages: [] };
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format
+  }) {
+    this.logger.debug("Getting messages", { threadId, selectBy });
     try {
-      const results = await Promise.all(
-        messageIds.map((id) => this.service.entities.message.query.primary({ entity: "message", id }).go())
-      );
-      const data = results.map((result) => result.data).flat(1);
-      let parsedMessages = data.map((data2) => this.parseMessageData(data2)).filter((msg) => "content" in msg);
-      const uniqueMessages = parsedMessages.filter(
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+      const messages = [];
+      const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      }
+      if (limit !== 0) {
+        const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
+        let results;
+        if (limit !== Number.MAX_SAFE_INTEGER && limit > 0) {
+          results = await query.go({ limit, order: "desc" });
+          results.data = results.data.reverse();
+        } else {
+          results = await query.go();
+        }
+        let allThreadMessages = results.data.map((data) => this.parseMessageData(data)).filter((msg) => "content" in msg);
+        allThreadMessages.sort((a, b) => {
+          const timeA = a.createdAt.getTime();
+          const timeB = b.createdAt.getTime();
+          if (timeA === timeB) {
+            return a.id.localeCompare(b.id);
+          }
+          return timeA - timeB;
+        });
+        messages.push(...allThreadMessages);
+      }
+      messages.sort((a, b) => {
+        const timeA = a.createdAt.getTime();
+        const timeB = b.createdAt.getTime();
+        if (timeA === timeB) {
+          return a.id.localeCompare(b.id);
+        }
+        return timeA - timeB;
+      });
+      const uniqueMessages = messages.filter(
         (message, index, self) => index === self.findIndex((m) => m.id === message.id)
       );
-      const list = new agent.MessageList().add(uniqueMessages, "memory");
-      return { messages: list.get.all.db() };
+      const list = new agent.MessageList({ threadId, resourceId }).add(uniqueMessages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_LIST_MESSAGES_BY_ID_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { messageIds: JSON.stringify(messageIds) }
+          details: { threadId, resourceId: resourceId ?? "" }
         },
         error$1
       );
     }
   }
-  async listMessages(args) {
-    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_DYNAMODB_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 perPage = storage.normalizePerPage(perPageInput, 40);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    this.logger.debug("Getting messages by ID", { messageIds });
+    if (messageIds.length === 0) return [];
     try {
-      if (page < 0) {
-        throw new error.MastraError(
-          {
-            id: "STORAGE_DYNAMODB_LIST_MESSAGES_INVALID_PAGE",
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            details: { page }
-          },
-          new Error("page must be >= 0")
-        );
-      }
-      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-      this.logger.debug("Getting messages with listMessages", {
-        threadId,
-        resourceId,
-        perPageInput,
-        offset,
-        perPage,
-        page,
-        field,
-        direction
-      });
-      const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
-      const results = await query.go();
-      let allThreadMessages = results.data.map((data) => this.parseMessageData(data)).filter((msg) => "content" in msg && typeof msg.content === "object");
-      if (resourceId) {
-        allThreadMessages = allThreadMessages.filter((msg) => msg.resourceId === resourceId);
-      }
-      if (filter?.dateRange) {
-        const dateRange = filter.dateRange;
-        allThreadMessages = allThreadMessages.filter((msg) => {
-          const createdAt = new Date(msg.createdAt).getTime();
-          if (dateRange.start) {
-            const startTime = dateRange.start instanceof Date ? dateRange.start.getTime() : new Date(dateRange.start).getTime();
-            if (createdAt < startTime) return false;
-          }
-          if (dateRange.end) {
-            const endTime = dateRange.end instanceof Date ? dateRange.end.getTime() : new Date(dateRange.end).getTime();
-            if (createdAt > endTime) return false;
-          }
-          return true;
-        });
-      }
-      allThreadMessages.sort((a, b) => {
-        const aValue = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
-        const bValue = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
-        if (aValue === bValue) {
-          return a.id.localeCompare(b.id);
-        }
-        return direction === "ASC" ? aValue - bValue : bValue - aValue;
-      });
-      const total = allThreadMessages.length;
-      const paginatedMessages = allThreadMessages.slice(offset, offset + perPage);
-      const paginatedCount = paginatedMessages.length;
-      if (total === 0 && paginatedCount === 0 && (!include || include.length === 0)) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      const messageIds = new Set(paginatedMessages.map((m) => m.id));
-      let includeMessages = [];
-      if (include && include.length > 0) {
-        const selectBy = { include };
-        includeMessages = await this._getIncludedMessages(threadId, selectBy);
-        for (const includeMsg of includeMessages) {
-          if (!messageIds.has(includeMsg.id)) {
-            paginatedMessages.push(includeMsg);
-            messageIds.add(includeMsg.id);
-          }
-        }
-      }
-      const list = new agent.MessageList().add(paginatedMessages, "memory");
-      let finalMessages = list.get.all.db();
-      finalMessages = finalMessages.sort((a, b) => {
-        const aValue = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
-        const bValue = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
-        if (aValue === bValue) {
-          return a.id.localeCompare(b.id);
-        }
-        return direction === "ASC" ? aValue - bValue : bValue - aValue;
-      });
-      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
-      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
-      let hasMore = false;
-      if (perPageInput !== false && !allThreadMessagesReturned) {
-        hasMore = offset + paginatedCount < total;
-      }
-      return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore
-      };
+      const results = await Promise.all(
+        messageIds.map((id) => this.service.entities.message.query.primary({ entity: "message", id }).go())
+      );
+      const data = results.map((result) => result.data).flat(1);
+      let parsedMessages = data.map((data2) => this.parseMessageData(data2)).filter((msg) => "content" in msg);
+      const uniqueMessages = parsedMessages.filter(
+        (message, index, self) => index === self.findIndex((m) => m.id === message.id)
+      );
+      const list = new agent.MessageList().add(uniqueMessages, "memory");
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_LIST_MESSAGES_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-            resourceId: resourceId ?? ""
-          }
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
     }
   }
   async saveMessages(args) {
-    const { messages } = args;
+    const { messages, format = "v1" } = args;
     this.logger.debug("Saving messages", { count: messages.length });
     if (!messages.length) {
-      return { messages: [] };
+      return [];
     }
     const threadId = messages[0]?.threadId;
     if (!threadId) {
@@ -1328,7 +1464,8 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       }).go();
       const list = new agent.MessageList().add(messages, "memory");
-      return { messages: list.get.all.db() };
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1341,48 +1478,37 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       );
     }
   }
-  async listThreadsByResourceId(args) {
-    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
-    const perPage = storage.normalizePerPage(perPageInput, 100);
-    if (page < 0) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_DYNAMODB_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);
-    const { field, direction } = this.parseOrderBy(orderBy);
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page = 0, perPage = 100 } = args;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
     this.logger.debug("Getting threads by resource ID with pagination", {
       resourceId,
       page,
       perPage,
-      field,
-      direction
+      orderBy,
+      sortDirection
     });
     try {
       const query = this.service.entities.thread.query.byResource({ entity: "thread", resourceId });
       const results = await query.go();
-      const allThreads = this.transformAndSortThreads(results.data, field, direction);
-      const endIndex = offset + perPage;
-      const paginatedThreads = allThreads.slice(offset, endIndex);
+      const allThreads = this.transformAndSortThreads(results.data, orderBy, sortDirection);
+      const startIndex = page * perPage;
+      const endIndex = startIndex + perPage;
+      const paginatedThreads = allThreads.slice(startIndex, endIndex);
       const total = allThreads.length;
-      const hasMore = offset + perPage < total;
+      const hasMore = endIndex < total;
       return {
         threads: paginatedThreads,
         total,
         page,
-        perPage: perPageForResponse,
+        perPage,
         hasMore
       };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "DYNAMODB_STORAGE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { resourceId, page, perPage }
@@ -1391,6 +1517,85 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       );
     }
   }
+  async getMessagesPaginated(args) {
+    const { threadId, resourceId, selectBy, format = "v1" } = args;
+    const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+    this.logger.debug("Getting messages with pagination", { threadId, page, perPage, fromDate, toDate, limit });
+    try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+      let messages = [];
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      }
+      if (limit !== 0) {
+        const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
+        let results;
+        if (limit !== Number.MAX_SAFE_INTEGER && limit > 0) {
+          results = await query.go({ limit, order: "desc" });
+          results.data = results.data.reverse();
+        } else {
+          results = await query.go();
+        }
+        let allThreadMessages = results.data.map((data) => this.parseMessageData(data)).filter((msg) => "content" in msg);
+        allThreadMessages.sort((a, b) => {
+          const timeA = a.createdAt.getTime();
+          const timeB = b.createdAt.getTime();
+          if (timeA === timeB) {
+            return a.id.localeCompare(b.id);
+          }
+          return timeA - timeB;
+        });
+        const excludeIds = messages.map((m) => m.id);
+        if (excludeIds.length > 0) {
+          allThreadMessages = allThreadMessages.filter((msg) => !excludeIds.includes(msg.id));
+        }
+        messages.push(...allThreadMessages);
+      }
+      messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      if (fromDate || toDate) {
+        messages = messages.filter((msg) => {
+          const createdAt = new Date(msg.createdAt).getTime();
+          if (fromDate && createdAt < new Date(fromDate).getTime()) return false;
+          if (toDate && createdAt > new Date(toDate).getTime()) return false;
+          return true;
+        });
+      }
+      const total = messages.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedMessages = messages.slice(start, end);
+      const hasMore = end < total;
+      const list = new agent.MessageList({ threadId, resourceId }).add(paginatedMessages, "memory");
+      let finalMessages = format === "v2" ? list.get.all.v2() : list.get.all.v1();
+      finalMessages = finalMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId: resourceId ?? "" }
+        },
+        error$1
+      );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      return { messages: [], total: 0, page, perPage, hasMore: false };
+    }
+  }
   // Helper method to get included messages with context
   async _getIncludedMessages(threadId, selectBy) {
     if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
@@ -1657,10 +1862,11 @@ var StoreOperationsDynamoDB = class extends storage.StoreOperations {
       [storage.TABLE_THREADS]: "thread",
       [storage.TABLE_MESSAGES]: "message",
       [storage.TABLE_WORKFLOW_SNAPSHOT]: "workflow_snapshot",
+      [storage.TABLE_EVALS]: "eval",
       [storage.TABLE_SCORERS]: "score",
       [storage.TABLE_TRACES]: "trace",
       [storage.TABLE_RESOURCES]: "resource",
-      [storage.TABLE_SPANS]: "ai_span"
+      [storage.TABLE_AI_SPANS]: "ai_span"
     };
     return mapping[tableName] || null;
   }
@@ -1845,10 +2051,6 @@ var StoreOperationsDynamoDB = class extends storage.StoreOperations {
             if (!item.id) throw new Error(`Missing required key 'id' for entity 'score'`);
             key.id = item.id;
             break;
-          case "resource":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'resource'`);
-            key.id = item.id;
-            break;
           default:
             this.logger.warn(`Unknown entity type encountered during clearTable: ${entityName}`);
             throw new Error(`Cannot construct delete key for unknown entity type: ${entityName}`);
@@ -2002,7 +2204,7 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
   async saveScore(score) {
     let validatedScore;
     try {
-      validatedScore = evals.saveScorePayloadSchema.parse(score);
+      validatedScore = scores.saveScorePayloadSchema.parse(score);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -2015,33 +2217,35 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
     }
     const now = /* @__PURE__ */ new Date();
     const scoreId = `score-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const scorer = typeof validatedScore.scorer === "string" ? validatedScore.scorer : JSON.stringify(validatedScore.scorer);
-    const preprocessStepResult = typeof validatedScore.preprocessStepResult === "string" ? validatedScore.preprocessStepResult : JSON.stringify(validatedScore.preprocessStepResult);
-    const analyzeStepResult = typeof validatedScore.analyzeStepResult === "string" ? validatedScore.analyzeStepResult : JSON.stringify(validatedScore.analyzeStepResult);
-    const input = typeof validatedScore.input === "string" ? validatedScore.input : JSON.stringify(validatedScore.input);
-    const output = typeof validatedScore.output === "string" ? validatedScore.output : JSON.stringify(validatedScore.output);
-    const requestContext = typeof validatedScore.requestContext === "string" ? validatedScore.requestContext : JSON.stringify(validatedScore.requestContext);
-    const entity = typeof validatedScore.entity === "string" ? validatedScore.entity : JSON.stringify(validatedScore.entity);
-    const scoreData = Object.fromEntries(
-      Object.entries({
-        ...validatedScore,
-        entity: "score",
-        id: scoreId,
-        scorer,
-        preprocessStepResult,
-        analyzeStepResult,
-        input,
-        output,
-        requestContext,
-        entityData: entity,
-        traceId: validatedScore.traceId || "",
-        resourceId: validatedScore.resourceId || "",
-        threadId: validatedScore.threadId || "",
-        spanId: validatedScore.spanId || "",
-        createdAt: now.toISOString(),
-        updatedAt: now.toISOString()
-      }).filter(([_, value]) => value !== void 0 && value !== null)
-    );
+    const scoreData = {
+      entity: "score",
+      id: scoreId,
+      scorerId: validatedScore.scorerId,
+      traceId: validatedScore.traceId || "",
+      spanId: validatedScore.spanId || "",
+      runId: validatedScore.runId,
+      scorer: typeof validatedScore.scorer === "string" ? validatedScore.scorer : JSON.stringify(validatedScore.scorer),
+      preprocessStepResult: typeof validatedScore.preprocessStepResult === "string" ? validatedScore.preprocessStepResult : JSON.stringify(validatedScore.preprocessStepResult),
+      analyzeStepResult: typeof validatedScore.analyzeStepResult === "string" ? validatedScore.analyzeStepResult : JSON.stringify(validatedScore.analyzeStepResult),
+      score: validatedScore.score,
+      reason: validatedScore.reason,
+      preprocessPrompt: validatedScore.preprocessPrompt,
+      generateScorePrompt: validatedScore.generateScorePrompt,
+      generateReasonPrompt: validatedScore.generateReasonPrompt,
+      analyzePrompt: validatedScore.analyzePrompt,
+      input: typeof validatedScore.input === "string" ? validatedScore.input : JSON.stringify(validatedScore.input),
+      output: typeof validatedScore.output === "string" ? validatedScore.output : JSON.stringify(validatedScore.output),
+      additionalContext: typeof validatedScore.additionalContext === "string" ? validatedScore.additionalContext : JSON.stringify(validatedScore.additionalContext),
+      runtimeContext: typeof validatedScore.runtimeContext === "string" ? validatedScore.runtimeContext : JSON.stringify(validatedScore.runtimeContext),
+      entityType: validatedScore.entityType,
+      entityData: typeof validatedScore.entity === "string" ? validatedScore.entity : JSON.stringify(validatedScore.entity),
+      entityId: validatedScore.entityId,
+      source: validatedScore.source,
+      resourceId: validatedScore.resourceId || "",
+      threadId: validatedScore.threadId || "",
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString()
+    };
     try {
       await this.service.entities.score.upsert(scoreData).go();
       const savedScore = {
@@ -2063,7 +2267,7 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       );
     }
   }
-  async listScoresByScorerId({
+  async getScoresByScorerId({
     scorerId,
     pagination,
     entityId,
@@ -2084,19 +2288,18 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
         allScores = allScores.filter((score) => score.source === source);
       }
       allScores.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const startIndex = pagination.page * pagination.perPage;
+      const endIndex = startIndex + pagination.perPage;
+      const paginatedScores = allScores.slice(startIndex, endIndex);
       const total = allScores.length;
-      const end = perPageInput === false ? allScores.length : start + perPage;
-      const paginatedScores = allScores.slice(start, end);
+      const hasMore = endIndex < total;
       return {
         scores: paginatedScores,
         pagination: {
           total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
         }
       };
     } catch (error$1) {
@@ -2118,7 +2321,7 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       );
     }
   }
-  async listScoresByRunId({
+  async getScoresByRunId({
     runId,
     pagination
   }) {
@@ -2128,19 +2331,18 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       const results = await query.go();
       const allScores = results.data.map((data) => this.parseScoreData(data));
       allScores.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const startIndex = pagination.page * pagination.perPage;
+      const endIndex = startIndex + pagination.perPage;
+      const paginatedScores = allScores.slice(startIndex, endIndex);
       const total = allScores.length;
-      const end = perPageInput === false ? allScores.length : start + perPage;
-      const paginatedScores = allScores.slice(start, end);
+      const hasMore = endIndex < total;
       return {
         scores: paginatedScores,
         pagination: {
           total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
         }
       };
     } catch (error$1) {
@@ -2155,7 +2357,7 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       );
     }
   }
-  async listScoresByEntityId({
+  async getScoresByEntityId({
     entityId,
     entityType,
     pagination
@@ -2167,19 +2369,18 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       let allScores = results.data.map((data) => this.parseScoreData(data));
       allScores = allScores.filter((score) => score.entityType === entityType);
       allScores.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const startIndex = pagination.page * pagination.perPage;
+      const endIndex = startIndex + pagination.perPage;
+      const paginatedScores = allScores.slice(startIndex, endIndex);
       const total = allScores.length;
-      const end = perPageInput === false ? allScores.length : start + perPage;
-      const paginatedScores = allScores.slice(start, end);
+      const hasMore = endIndex < total;
       return {
         scores: paginatedScores,
         pagination: {
           total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
         }
       };
     } catch (error$1) {
@@ -2194,7 +2395,7 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       );
     }
   }
-  async listScoresBySpan({
+  async getScoresBySpan({
     traceId,
     spanId,
     pagination
@@ -2205,19 +2406,18 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       const results = await query.go();
       const allScores = results.data.map((data) => this.parseScoreData(data));
       allScores.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = storage.normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
-      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const startIndex = pagination.page * pagination.perPage;
+      const endIndex = startIndex + pagination.perPage;
+      const paginatedScores = allScores.slice(startIndex, endIndex);
       const total = allScores.length;
-      const end = perPageInput === false ? allScores.length : start + perPage;
-      const paginatedScores = allScores.slice(start, end);
+      const hasMore = endIndex < total;
       return {
         scores: paginatedScores,
         pagination: {
           total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: end < total
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
         }
       };
     } catch (error$1) {
@@ -2233,6 +2433,239 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
     }
   }
 };
+var TracesStorageDynamoDB = class extends storage.TracesStorage {
+  service;
+  operations;
+  constructor({ service, operations }) {
+    super();
+    this.service = service;
+    this.operations = operations;
+  }
+  // Trace operations
+  async getTraces(args) {
+    const { name, scope, page, perPage } = args;
+    this.logger.debug("Getting traces", { name, scope, page, perPage });
+    try {
+      let query;
+      if (name) {
+        query = this.service.entities.trace.query.byName({ entity: "trace", name });
+      } else if (scope) {
+        query = this.service.entities.trace.query.byScope({ entity: "trace", scope });
+      } else {
+        this.logger.warn("Performing a scan operation on traces - consider using a more specific query");
+        query = this.service.entities.trace.scan;
+      }
+      let items = [];
+      let cursor = null;
+      let pagesFetched = 0;
+      const startPage = page > 0 ? page : 1;
+      do {
+        const results = await query.go({ cursor, limit: perPage });
+        pagesFetched++;
+        if (pagesFetched === startPage) {
+          items = results.data;
+          break;
+        }
+        cursor = results.cursor;
+        if (!cursor && results.data.length > 0 && pagesFetched < startPage) {
+          break;
+        }
+      } while (cursor && pagesFetched < startPage);
+      return items;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    if (!records.length) {
+      return;
+    }
+    try {
+      const recordsToSave = records.map((rec) => ({ entity: "trace", ...rec }));
+      await this.operations.batchInsert({
+        tableName: storage.TABLE_TRACES,
+        records: recordsToSave
+        // Pass records with 'entity' included
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_BATCH_TRACE_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: records.length }
+        },
+        error$1
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    this.logger.debug("Getting traces with pagination", { name, scope, page, perPage, attributes, filters, dateRange });
+    try {
+      let query;
+      if (name) {
+        query = this.service.entities.trace.query.byName({ entity: "trace", name });
+      } else if (scope) {
+        query = this.service.entities.trace.query.byScope({ entity: "trace", scope });
+      } else {
+        this.logger.warn("Performing a scan operation on traces - consider using a more specific query");
+        query = this.service.entities.trace.scan;
+      }
+      const results = await query.go({
+        order: "desc",
+        pages: "all"
+        // Get all pages to apply filtering and pagination
+      });
+      if (!results.data.length) {
+        return {
+          traces: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      let filteredData = results.data;
+      if (attributes) {
+        filteredData = filteredData.filter((item) => {
+          try {
+            let itemAttributes = {};
+            if (item.attributes) {
+              if (typeof item.attributes === "string") {
+                if (item.attributes === "[object Object]") {
+                  itemAttributes = {};
+                } else {
+                  try {
+                    itemAttributes = JSON.parse(item.attributes);
+                  } catch {
+                    itemAttributes = {};
+                  }
+                }
+              } else if (typeof item.attributes === "object") {
+                itemAttributes = item.attributes;
+              }
+            }
+            return Object.entries(attributes).every(([key, value]) => itemAttributes[key] === value);
+          } catch (e) {
+            this.logger.warn("Failed to parse attributes during filtering", { item, error: e });
+            return false;
+          }
+        });
+      }
+      if (dateRange?.start) {
+        filteredData = filteredData.filter((item) => {
+          const itemDate = new Date(item.createdAt);
+          return itemDate >= dateRange.start;
+        });
+      }
+      if (dateRange?.end) {
+        filteredData = filteredData.filter((item) => {
+          const itemDate = new Date(item.createdAt);
+          return itemDate <= dateRange.end;
+        });
+      }
+      const total = filteredData.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedData = filteredData.slice(start, end);
+      const traces = paginatedData.map((item) => {
+        let attributes2;
+        if (item.attributes) {
+          if (typeof item.attributes === "string") {
+            if (item.attributes === "[object Object]") {
+              attributes2 = void 0;
+            } else {
+              try {
+                attributes2 = JSON.parse(item.attributes);
+              } catch {
+                attributes2 = void 0;
+              }
+            }
+          } else if (typeof item.attributes === "object") {
+            attributes2 = item.attributes;
+          }
+        }
+        let status;
+        if (item.status) {
+          if (typeof item.status === "string") {
+            try {
+              status = JSON.parse(item.status);
+            } catch {
+              status = void 0;
+            }
+          } else if (typeof item.status === "object") {
+            status = item.status;
+          }
+        }
+        let events;
+        if (item.events) {
+          if (typeof item.events === "string") {
+            try {
+              events = JSON.parse(item.events);
+            } catch {
+              events = void 0;
+            }
+          } else if (Array.isArray(item.events)) {
+            events = item.events;
+          }
+        }
+        let links;
+        if (item.links) {
+          if (typeof item.links === "string") {
+            try {
+              links = JSON.parse(item.links);
+            } catch {
+              links = void 0;
+            }
+          } else if (Array.isArray(item.links)) {
+            links = item.links;
+          }
+        }
+        return {
+          id: item.id,
+          parentSpanId: item.parentSpanId,
+          name: item.name,
+          traceId: item.traceId,
+          scope: item.scope,
+          kind: item.kind,
+          attributes: attributes2,
+          status,
+          events,
+          links,
+          other: item.other,
+          startTime: item.startTime,
+          endTime: item.endTime,
+          createdAt: item.createdAt
+        };
+      });
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: end < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+};
 function formatWorkflowRun(snapshotData) {
   return {
     workflowName: snapshotData.workflow_name,
@@ -2254,7 +2687,7 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
     // runId,
     // stepId,
     // result,
-    // requestContext,
+    // runtimeContext,
   }) {
     throw new Error("Method not implemented.");
   }
@@ -2326,24 +2759,11 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
       );
     }
   }
-  async listWorkflowRuns(args) {
+  async getWorkflowRuns(args) {
     this.logger.debug("Getting workflow runs", { args });
     try {
-      const perPage = args?.perPage !== void 0 ? args.perPage : 10;
-      const page = args?.page !== void 0 ? args.page : 0;
-      if (page < 0) {
-        throw new error.MastraError(
-          {
-            id: "DYNAMODB_STORE_INVALID_PAGE",
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            details: { page }
-          },
-          new Error("page must be >= 0")
-        );
-      }
-      const normalizedPerPage = storage.normalizePerPage(perPage, 10);
-      const offset = page * normalizedPerPage;
+      const limit = args?.limit || 10;
+      const offset = args?.offset || 0;
       let query;
       if (args?.workflowName) {
         query = this.service.entities.workflow_snapshot.query.primary({
@@ -2395,7 +2815,7 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
         return { runs: [], total: 0 };
       }
       const total = allMatchingSnapshots.length;
-      const paginatedData = allMatchingSnapshots.slice(offset, offset + normalizedPerPage);
+      const paginatedData = allMatchingSnapshots.slice(offset, offset + limit);
       const runs = paginatedData.map((snapshot) => formatWorkflowRun(snapshot));
       return {
         runs,
@@ -2404,7 +2824,7 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_LIST_WORKFLOW_RUNS_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_GET_WORKFLOW_RUNS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { workflowName: args?.workflowName || "", resourceId: args?.resourceId || "" }
@@ -2477,7 +2897,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
   hasInitialized = null;
   stores;
   constructor({ name, config }) {
-    super({ id: config.id, name });
+    super({ name });
     try {
       if (!config.tableName || typeof config.tableName !== "string" || config.tableName.trim() === "") {
         throw new Error("DynamoDBStore: config.tableName must be provided and cannot be empty.");
@@ -2500,11 +2920,14 @@ var DynamoDBStore = class extends storage.MastraStorage {
         tableName: this.tableName,
         client: this.client
       });
+      const traces = new TracesStorageDynamoDB({ service: this.service, operations });
       const workflows = new WorkflowStorageDynamoDB({ service: this.service });
       const memory = new MemoryStorageDynamoDB({ service: this.service });
       const scores = new ScoresStorageDynamoDB({ service: this.service });
       this.stores = {
         operations,
+        legacyEvals: new LegacyEvalsDynamoDB({ service: this.service, tableName: this.tableName }),
+        traces,
         workflows,
         memory,
         scores
@@ -2527,7 +2950,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
       hasColumn: false,
       createTable: false,
       deleteMessages: false,
-      listScoresBySpan: true
+      getScoresBySpan: true
     };
   }
   /**
@@ -2622,6 +3045,9 @@ var DynamoDBStore = class extends storage.MastraStorage {
   async getThreadById({ threadId }) {
     return this.stores.memory.getThreadById({ threadId });
   }
+  async getThreadsByResourceId(args) {
+    return this.stores.memory.getThreadsByResourceId(args);
+  }
   async saveThread({ thread }) {
     return this.stores.memory.saveThread({ thread });
   }
@@ -2635,24 +3061,51 @@ var DynamoDBStore = class extends storage.MastraStorage {
   async deleteThread({ threadId }) {
     return this.stores.memory.deleteThread({ threadId });
   }
-  async listMessagesById(args) {
-    return this.stores.memory.listMessagesById(args);
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format });
+  }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    return this.stores.memory.getMessagesById({ messageIds, format });
   }
   async saveMessages(args) {
     return this.stores.memory.saveMessages(args);
   }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
   async updateMessages(_args) {
     return this.stores.memory.updateMessages(_args);
   }
+  // Trace operations
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async batchTraceInsert({ records }) {
+    return this.stores.traces.batchTraceInsert({ records });
+  }
+  async getTracesPaginated(_args) {
+    return this.stores.traces.getTracesPaginated(_args);
+  }
   // Workflow operations
   async updateWorkflowResults({
     workflowName,
     runId,
     stepId,
     result,
-    requestContext
+    runtimeContext
   }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
   }
   async updateWorkflowState({
     workflowName,
@@ -2675,8 +3128,8 @@ var DynamoDBStore = class extends storage.MastraStorage {
   }) {
     return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
   }
-  async listWorkflowRuns(args) {
-    return this.stores.workflows.listWorkflowRuns(args);
+  async getWorkflowRuns(args) {
+    return this.stores.workflows.getWorkflowRuns(args);
   }
   async getWorkflowRunById(args) {
     return this.stores.workflows.getWorkflowRunById(args);
@@ -2694,6 +3147,13 @@ var DynamoDBStore = class extends storage.MastraStorage {
   }) {
     return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
   }
+  // Eval operations
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async getEvals(options) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
   /**
    * Closes the DynamoDB client connection and cleans up resources.
    * Should be called when the store is no longer needed, e.g., at the end of tests or application shutdown.
@@ -2723,38 +3183,38 @@ var DynamoDBStore = class extends storage.MastraStorage {
   async saveScore(_score) {
     return this.stores.scores.saveScore(_score);
   }
-  async listScoresByRunId({
+  async getScoresByRunId({
     runId: _runId,
     pagination: _pagination
   }) {
-    return this.stores.scores.listScoresByRunId({ runId: _runId, pagination: _pagination });
+    return this.stores.scores.getScoresByRunId({ runId: _runId, pagination: _pagination });
   }
-  async listScoresByEntityId({
+  async getScoresByEntityId({
     entityId: _entityId,
     entityType: _entityType,
     pagination: _pagination
   }) {
-    return this.stores.scores.listScoresByEntityId({
+    return this.stores.scores.getScoresByEntityId({
       entityId: _entityId,
       entityType: _entityType,
       pagination: _pagination
     });
   }
-  async listScoresByScorerId({
+  async getScoresByScorerId({
     scorerId,
     source,
     entityId,
     entityType,
     pagination
   }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, source, entityId, entityType, pagination });
+    return this.stores.scores.getScoresByScorerId({ scorerId, source, entityId, entityType, pagination });
   }
-  async listScoresBySpan({
+  async getScoresBySpan({
     traceId,
     spanId,
     pagination
   }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
+    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination });
   }
 };