@mastra/dynamodb 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/dist/index.js

@@ -1,10 +1,10 @@
 import { DynamoDBClient, DescribeTableCommand } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { MastraStorage, StoreOperations, TracesStorage, TABLE_TRACES, WorkflowsStorage, MemoryStorage, resolveMessageLimit, ScoresStorage, LegacyEvalsStorage, TABLE_AI_SPANS, TABLE_RESOURCES, TABLE_SCORERS, TABLE_EVALS, TABLE_WORKFLOW_SNAPSHOT, TABLE_MESSAGES, TABLE_THREADS } from '@mastra/core/storage';
+import { MemoryStorage, createStorageErrorId, normalizePerPage, calculatePagination, filterByDateRange, ScoresStorage, SCORERS_SCHEMA, WorkflowsStorage, MastraCompositeStore, TABLE_SCORERS, TABLE_WORKFLOW_SNAPSHOT, TABLE_RESOURCES, TABLE_MESSAGES, TABLE_THREADS } from '@mastra/core/storage';
 import { Entity, Service } from 'electrodb';
 import { MessageList } from '@mastra/core/agent';
-import { saveScorePayloadSchema } from '@mastra/core/scores';
+import { saveScorePayloadSchema } from '@mastra/core/evals';
 
 // src/storage/index.ts
 
@@ -58,6 +58,25 @@ var baseAttributes = {
       }
       return value;
     }
+  },
+  /**
+   * TTL attribute for DynamoDB automatic item expiration.
+   * This is a Unix timestamp (epoch seconds) that indicates when the item should be deleted.
+   *
+   * Note: For TTL to work, you must enable TTL on your DynamoDB table
+   * specifying this attribute name (default: 'ttl').
+   */
+  ttl: {
+    type: "number",
+    required: false
+  },
+  /**
+   * Alternative TTL attribute with configurable name.
+   * Use this if you've configured TTL on your DynamoDB table with 'expiresAt' as the attribute name.
+   */
+  expiresAt: {
+    type: "number",
+    required: false
   }
 };
 
@@ -423,6 +442,10 @@ var scoreEntity = new Entity({
         return value;
       }
     },
+    preprocessPrompt: {
+      type: "string",
+      required: false
+    },
     preprocessStepResult: {
       type: "string",
       required: false,
@@ -562,7 +585,29 @@ var scoreEntity = new Entity({
         return value;
       }
     },
-    runtimeContext: {
+    metadata: {
+      type: "string",
+      required: false,
+      set: (value) => {
+        if (value && typeof value !== "string") {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      get: (value) => {
+        if (value && typeof value === "string") {
+          try {
+            if (value.startsWith("{") || value.startsWith("[")) {
+              return JSON.parse(value);
+            }
+          } catch {
+            return value;
+          }
+        }
+        return value;
+      }
+    },
+    requestContext: {
       type: "string",
       required: false,
       set: (value) => {
@@ -933,193 +978,146 @@ function getElectroDbService(client, tableName) {
     }
   );
 }
-var LegacyEvalsDynamoDB = class extends LegacyEvalsStorage {
+function resolveDynamoDBConfig(config) {
+  if ("service" in config) {
+    return { service: config.service, ttl: config.ttl };
+  }
+  const dynamoClient = new DynamoDBClient({
+    region: config.region || "us-east-1",
+    endpoint: config.endpoint,
+    credentials: config.credentials
+  });
+  const client = DynamoDBDocumentClient.from(dynamoClient);
+  return {
+    service: getElectroDbService(client, config.tableName),
+    ttl: config.ttl
+  };
+}
+
+// src/storage/ttl.ts
+function calculateTtl(entityName, ttlConfig, customTtlSeconds) {
+  const entityConfig = ttlConfig?.[entityName];
+  if (!entityConfig?.enabled) {
+    return void 0;
+  }
+  const ttlSeconds = customTtlSeconds ?? entityConfig.defaultTtlSeconds;
+  if (ttlSeconds === void 0 || ttlSeconds <= 0) {
+    return void 0;
+  }
+  return Math.floor(Date.now() / 1e3) + ttlSeconds;
+}
+function getTtlAttributeName(entityName, ttlConfig) {
+  const entityConfig = ttlConfig?.[entityName];
+  return entityConfig?.attributeName ?? "ttl";
+}
+function isTtlEnabled(entityName, ttlConfig) {
+  return ttlConfig?.[entityName]?.enabled === true;
+}
+function getTtlProps(entityName, ttlConfig, customTtlSeconds) {
+  const ttlValue = calculateTtl(entityName, ttlConfig, customTtlSeconds);
+  if (ttlValue === void 0) return {};
+  const attributeName = getTtlAttributeName(entityName, ttlConfig);
+  return { [attributeName]: ttlValue };
+}
+var ENTITY_MAP = {
+  [TABLE_THREADS]: "thread",
+  [TABLE_MESSAGES]: "message",
+  [TABLE_RESOURCES]: "resource",
+  [TABLE_WORKFLOW_SNAPSHOT]: "workflow_snapshot",
+  [TABLE_SCORERS]: "score"
+};
+function getDeleteKey(entityName, item) {
+  const key = { entity: entityName };
+  switch (entityName) {
+    case "thread":
+    case "message":
+    case "resource":
+    case "score":
+      key.id = item.id;
+      break;
+    case "workflow_snapshot":
+      key.workflow_name = item.workflow_name;
+      key.run_id = item.run_id;
+      break;
+    default:
+      key.id = item.id;
+  }
+  return key;
+}
+async function deleteTableData(service, tableName) {
+  const entityName = ENTITY_MAP[tableName];
+  if (!entityName || !service.entities[entityName]) {
+    throw new Error(`No entity mapping found for table: ${tableName}`);
+  }
+  const entity = service.entities[entityName];
+  const result = await entity.scan.go({ pages: "all" });
+  if (!result.data.length) {
+    return;
+  }
+  const batchSize = 25;
+  for (let i = 0; i < result.data.length; i += batchSize) {
+    const batch = result.data.slice(i, i + batchSize);
+    const keysToDelete = batch.map((item) => getDeleteKey(entityName, item));
+    await entity.delete(keysToDelete).go();
+  }
+}
+
+// src/storage/domains/memory/index.ts
+var MemoryStorageDynamoDB = class extends MemoryStorage {
   service;
-  tableName;
-  constructor({ service, tableName }) {
+  ttlConfig;
+  constructor(config) {
     super();
-    this.service = service;
-    this.tableName = tableName;
+    const resolved = resolveDynamoDBConfig(config);
+    this.service = resolved.service;
+    this.ttlConfig = resolved.ttl;
   }
-  // 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) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { agentName }
-        },
-        error
-      );
-    }
+  async dangerouslyClearAll() {
+    await deleteTableData(this.service, TABLE_THREADS);
+    await deleteTableData(this.service, TABLE_MESSAGES);
+    await deleteTableData(this.service, TABLE_RESOURCES);
   }
-  async getEvals(options = {}) {
-    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
-    this.logger.debug("Getting evals with pagination", { agentName, type, page, perPage, dateRange });
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    this.logger.debug("Deleting messages", { count: messageIds.length });
     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;
+      const threadIds = /* @__PURE__ */ new Set();
+      const batchSize = 25;
+      for (let i = 0; i < messageIds.length; i += batchSize) {
+        const batch = messageIds.slice(i, i + batchSize);
+        const messagesToDelete = await Promise.all(
+          batch.map(async (id) => {
+            const result = await this.service.entities.message.get({ entity: "message", id }).go();
+            return result.data;
+          })
+        );
+        for (const message of messagesToDelete) {
+          if (message) {
+            if (message.threadId) {
+              threadIds.add(message.threadId);
             }
-          } catch (e) {
-            this.logger.warn("Failed to parse test_info during filtering", { record: evalRecord, error: e });
+            await this.service.entities.message.delete({ entity: "message", id: message.id }).go();
           }
-          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 now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const threadId of threadIds) {
+        await this.service.entities.thread.update({ entity: "thread", id: threadId }).set({ updatedAt: now }).go();
       }
-      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) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_EVALS_FAILED",
+          id: createStorageErrorId("DYNAMODB", "DELETE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: {
-            agentName: agentName || "all",
-            type: type || "all",
-            page,
-            perPage
-          }
+          details: { count: messageIds.length }
         },
         error
       );
     }
   }
-};
-var MemoryStorageDynamoDB = class extends MemoryStorage {
-  service;
-  constructor({ service }) {
-    super();
-    this.service = service;
-  }
   // Helper function to parse message data (handle JSON fields)
   parseMessageData(data) {
     return {
@@ -1132,17 +1130,17 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     };
   }
   // Helper function to transform and sort threads
-  transformAndSortThreads(rawThreads, orderBy, sortDirection) {
+  transformAndSortThreads(rawThreads, field, direction) {
     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 = orderBy === "createdAt" ? a.createdAt : a.updatedAt;
-      const fieldB = orderBy === "createdAt" ? b.createdAt : b.updatedAt;
+      const fieldA = field === "createdAt" ? a.createdAt : a.updatedAt;
+      const fieldB = field === "createdAt" ? b.createdAt : b.updatedAt;
       const comparison = fieldA.getTime() - fieldB.getTime();
-      return sortDirection === "DESC" ? -comparison : comparison;
+      return direction === "DESC" ? -comparison : comparison;
     });
   }
   async getThreadById({ threadId }) {
@@ -1164,7 +1162,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_THREAD_BY_ID_FAILED",
+          id: createStorageErrorId("DYNAMODB", "GET_THREAD_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { threadId }
@@ -1173,32 +1171,6 @@ var MemoryStorageDynamoDB = class extends 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) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
-        },
-        error
-      );
-    }
-  }
   async saveThread({ thread }) {
     this.logger.debug("Saving thread", { threadId: thread.id });
     const now = /* @__PURE__ */ new Date();
@@ -1209,7 +1181,8 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
       title: thread.title || `Thread ${thread.id}`,
       createdAt: thread.createdAt?.toISOString() || now.toISOString(),
       updatedAt: thread.updatedAt?.toISOString() || now.toISOString(),
-      metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0
+      metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0,
+      ...getTtlProps("thread", this.ttlConfig)
     };
     try {
       await this.service.entities.thread.upsert(threadData).go();
@@ -1218,13 +1191,13 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
         resourceId: thread.resourceId,
         title: threadData.title,
         createdAt: thread.createdAt || now,
-        updatedAt: now,
+        updatedAt: thread.updatedAt || now,
         metadata: thread.metadata
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_SAVE_THREAD_FAILED",
+          id: createStorageErrorId("DYNAMODB", "SAVE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { threadId: thread.id }
@@ -1266,7 +1239,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_UPDATE_THREAD_FAILED",
+          id: createStorageErrorId("DYNAMODB", "UPDATE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { threadId: id }
@@ -1278,7 +1251,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
   async deleteThread({ threadId }) {
     this.logger.debug("Deleting thread", { threadId });
     try {
-      const messages = await this.getMessages({ threadId });
+      const { messages } = await this.listMessages({ threadId, perPage: false });
       if (messages.length > 0) {
         const batchSize = 25;
         for (let i = 0; i < messages.length; i += batchSize) {
@@ -1298,7 +1271,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_DELETE_THREAD_FAILED",
+          id: createStorageErrorId("DYNAMODB", "DELETE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { threadId }
@@ -1307,104 +1280,166 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
       );
     }
   }
-  async getMessages({
-    threadId,
-    resourceId,
-    selectBy,
-    format
-  }) {
-    this.logger.debug("Getting messages", { threadId, selectBy });
+  async listMessagesById({ messageIds }) {
+    this.logger.debug("Getting messages by ID", { messageIds });
+    if (messageIds.length === 0) return { messages: [] };
     try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      const messages = [];
-      const limit = 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(
+      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 MessageList({ threadId, resourceId }).add(uniqueMessages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
+      const list = new MessageList().add(uniqueMessages, "memory");
+      return { messages: list.get.all.db() };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LIST_MESSAGES_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { threadId, resourceId: resourceId ?? "" }
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error
       );
     }
   }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    this.logger.debug("Getting messages by ID", { messageIds });
-    if (messageIds.length === 0) return [];
-    try {
-      const results = await Promise.all(
-        messageIds.map((id) => this.service.entities.message.query.primary({ entity: "message", id }).go())
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("DYNAMODB", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+        },
+        new Error("threadId must be a non-empty string or array of non-empty strings")
       );
-      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 perPage = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      if (page < 0) {
+        throw new MastraError(
+          {
+            id: createStorageErrorId("DYNAMODB", "LIST_MESSAGES", "INVALID_PAGE"),
+            domain: ErrorDomain.STORAGE,
+            category: 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);
+      }
+      allThreadMessages = filterByDateRange(
+        allThreadMessages,
+        (msg) => new Date(msg.createdAt),
+        filter?.dateRange
       );
-      const list = new MessageList().add(uniqueMessages, "memory");
-      if (format === `v1`) return list.get.all.v1();
-      return list.get.all.v2();
+      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(selectBy);
+        for (const includeMsg of includeMessages) {
+          if (!messageIds.has(includeMsg.id)) {
+            paginatedMessages.push(includeMsg);
+            messageIds.add(includeMsg.id);
+          }
+        }
+      }
+      const list = new 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
+      };
     } catch (error) {
-      throw new MastraError(
+      const mastraError = new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_BY_ID_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LIST_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { messageIds: JSON.stringify(messageIds) }
+          details: {
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
+          }
         },
         error
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
   async saveMessages(args) {
-    const { messages, format = "v1" } = args;
+    const { messages } = args;
     this.logger.debug("Saving messages", { count: messages.length });
     if (!messages.length) {
-      return [];
+      return { messages: [] };
     }
     const threadId = messages[0]?.threadId;
     if (!threadId) {
@@ -1414,20 +1449,18 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       return {
         entity: "message",
-        // Add entity type
         id: msg.id,
         threadId: msg.threadId,
         role: msg.role,
         type: msg.type,
         resourceId: msg.resourceId,
-        // Ensure complex fields are stringified if not handled by attribute setters
         content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
         toolCallArgs: `toolCallArgs` in msg && msg.toolCallArgs ? JSON.stringify(msg.toolCallArgs) : void 0,
         toolCallIds: `toolCallIds` in msg && msg.toolCallIds ? JSON.stringify(msg.toolCallIds) : void 0,
         toolNames: `toolNames` in msg && msg.toolNames ? JSON.stringify(msg.toolNames) : void 0,
         createdAt: msg.createdAt instanceof Date ? msg.createdAt.toISOString() : msg.createdAt || now,
-        updatedAt: now
-        // Add updatedAt
+        updatedAt: now,
+        ...getTtlProps("message", this.ttlConfig)
       };
     });
     try {
@@ -1458,12 +1491,11 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       }).go();
       const list = new MessageList().add(messages, "memory");
-      if (format === `v1`) return list.get.all.v1();
-      return list.get.all.v2();
+      return { messages: list.get.all.db() };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_SAVE_MESSAGES_FAILED",
+          id: createStorageErrorId("DYNAMODB", "SAVE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { count: messages.length }
@@ -1472,137 +1504,103 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
       );
     }
   }
-  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,
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+    try {
+      this.validatePaginationInput(page, perPageInput ?? 100);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("DYNAMODB", "LIST_THREADS", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            page,
+            ...perPageInput !== void 0 && { perPage: perPageInput }
+          }
+        },
+        error instanceof Error ? error : new Error("Invalid pagination parameters")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const { field, direction } = this.parseOrderBy(orderBy);
+    this.logger.debug("Listing threads with filters", {
+      resourceId: filter?.resourceId,
+      metadataKeys: filter?.metadata ? Object.keys(filter.metadata) : [],
       page,
       perPage,
-      orderBy,
-      sortDirection
+      field,
+      direction
     });
     try {
-      const query = this.service.entities.thread.query.byResource({ entity: "thread", resourceId });
-      const results = await query.go();
-      const allThreads = this.transformAndSortThreads(results.data, orderBy, sortDirection);
-      const startIndex = page * perPage;
-      const endIndex = startIndex + perPage;
-      const paginatedThreads = allThreads.slice(startIndex, endIndex);
+      const rawThreads = filter?.resourceId ? (await this.service.entities.thread.query.byResource({
+        entity: "thread",
+        resourceId: filter.resourceId
+      }).go({ pages: "all" })).data : (await this.service.entities.thread.scan.go({ pages: "all" })).data;
+      let allThreads = this.transformAndSortThreads(rawThreads, field, direction);
+      if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+        allThreads = allThreads.filter((thread) => {
+          let threadMeta = null;
+          if (typeof thread.metadata === "string") {
+            try {
+              threadMeta = JSON.parse(thread.metadata);
+            } catch {
+              return false;
+            }
+          } else if (thread.metadata && typeof thread.metadata === "object") {
+            threadMeta = thread.metadata;
+          }
+          if (!threadMeta) return false;
+          return Object.entries(filter.metadata).every(([key, value]) => threadMeta[key] === value);
+        });
+      }
+      const endIndex = offset + perPage;
+      const paginatedThreads = allThreads.slice(offset, endIndex);
       const total = allThreads.length;
-      const hasMore = endIndex < total;
+      const hasMore = offset + perPage < total;
       return {
         threads: paginatedThreads,
         total,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LIST_THREADS", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { resourceId, page, perPage }
+          details: {
+            ...filter?.resourceId && { resourceId: filter.resourceId },
+            hasMetadataFilter: !!(filter?.metadata && Object.keys(filter.metadata).length),
+            page,
+            perPage: perPageForResponse
+          }
         },
         error
       );
     }
   }
-  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 = 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();
+  // Helper method to get included messages with context
+  async _getIncludedMessages(selectBy) {
+    if (!selectBy?.include?.length) {
+      return [];
+    }
+    const includeMessages = [];
+    for (const includeItem of selectBy.include) {
+      try {
+        const { id, withPreviousMessages = 0, withNextMessages = 0 } = includeItem;
+        const targetResult = await this.service.entities.message.get({ entity: "message", id }).go();
+        if (!targetResult.data) {
+          this.logger.warn("Target message not found", { id });
+          continue;
         }
-        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 MessageList({ threadId, resourceId }).add(paginatedMessages, "memory");
-      const finalMessages = format === "v2" ? list.get.all.v2() : list.get.all.v1();
-      return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage,
-        hasMore
-      };
-    } catch (error) {
-      const mastraError = new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { threadId, resourceId: resourceId ?? "" }
-        },
-        error
-      );
-      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");
-    if (!selectBy?.include?.length) {
-      return [];
-    }
-    const includeMessages = [];
-    for (const includeItem of selectBy.include) {
-      try {
-        const { id, threadId: targetThreadId, withPreviousMessages = 0, withNextMessages = 0 } = includeItem;
-        const searchThreadId = targetThreadId || threadId;
+        const targetMessageData = targetResult.data;
+        const searchThreadId = targetMessageData.threadId;
         this.logger.debug("Getting included messages for", {
           id,
-          targetThreadId,
           searchThreadId,
           withPreviousMessages,
           withNextMessages
@@ -1625,7 +1623,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
         });
         const targetIndex = allMessages.findIndex((msg) => msg.id === id);
         if (targetIndex === -1) {
-          this.logger.warn("Target message not found", { id, threadId: searchThreadId });
+          this.logger.warn("Target message not found in thread", { id, threadId: searchThreadId });
           continue;
         }
         this.logger.debug("Found target message at index", { id, targetIndex, totalMessages: allMessages.length });
@@ -1710,7 +1708,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_UPDATE_MESSAGES_FAILED",
+          id: createStorageErrorId("DYNAMODB", "UPDATE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { count: messages.length }
@@ -1739,7 +1737,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_RESOURCE_BY_ID_FAILED",
+          id: createStorageErrorId("DYNAMODB", "GET_RESOURCE_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { resourceId }
@@ -1757,7 +1755,8 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
       workingMemory: resource.workingMemory,
       metadata: resource.metadata ? JSON.stringify(resource.metadata) : void 0,
       createdAt: resource.createdAt?.toISOString() || now.toISOString(),
-      updatedAt: now.toISOString()
+      updatedAt: now.toISOString(),
+      ...getTtlProps("resource", this.ttlConfig)
     };
     try {
       await this.service.entities.resource.upsert(resourceData).go();
@@ -1771,7 +1770,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_SAVE_RESOURCE_FAILED",
+          id: createStorageErrorId("DYNAMODB", "SAVE_RESOURCE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { resourceId: resource.id }
@@ -1820,7 +1819,7 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_UPDATE_RESOURCE_FAILED",
+          id: createStorageErrorId("DYNAMODB", "UPDATE_RESOURCE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { resourceId }
@@ -1830,339 +1829,40 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
     }
   }
 };
-var StoreOperationsDynamoDB = class extends StoreOperations {
-  client;
-  tableName;
+var ScoresStorageDynamoDB = class extends ScoresStorage {
   service;
-  constructor({
-    service,
-    tableName,
-    client
-  }) {
+  ttlConfig;
+  constructor(config) {
     super();
-    this.service = service;
-    this.client = client;
-    this.tableName = tableName;
-  }
-  async hasColumn() {
-    return true;
+    const resolved = resolveDynamoDBConfig(config);
+    this.service = resolved.service;
+    this.ttlConfig = resolved.ttl;
   }
-  async dropTable() {
-  }
-  // Helper methods for entity/table mapping
-  getEntityNameForTable(tableName) {
-    const mapping = {
-      [TABLE_THREADS]: "thread",
-      [TABLE_MESSAGES]: "message",
-      [TABLE_WORKFLOW_SNAPSHOT]: "workflow_snapshot",
-      [TABLE_EVALS]: "eval",
-      [TABLE_SCORERS]: "score",
-      [TABLE_TRACES]: "trace",
-      [TABLE_RESOURCES]: "resource",
-      [TABLE_AI_SPANS]: "ai_span"
-    };
-    return mapping[tableName] || null;
+  async dangerouslyClearAll() {
+    await deleteTableData(this.service, TABLE_SCORERS);
   }
   /**
-   * Pre-processes a record to ensure Date objects are converted to ISO strings
-   * This is necessary because ElectroDB validation happens before setters are applied
-   */
-  preprocessRecord(record) {
-    const processed = { ...record };
-    if (processed.createdAt instanceof Date) {
-      processed.createdAt = processed.createdAt.toISOString();
-    }
-    if (processed.updatedAt instanceof Date) {
-      processed.updatedAt = processed.updatedAt.toISOString();
-    }
-    if (processed.created_at instanceof Date) {
-      processed.created_at = processed.created_at.toISOString();
-    }
-    if (processed.result && typeof processed.result === "object") {
-      processed.result = JSON.stringify(processed.result);
-    }
-    if (processed.test_info && typeof processed.test_info === "object") {
-      processed.test_info = JSON.stringify(processed.test_info);
-    } else if (processed.test_info === void 0 || processed.test_info === null) {
-      delete processed.test_info;
-    }
-    if (processed.snapshot && typeof processed.snapshot === "object") {
-      processed.snapshot = JSON.stringify(processed.snapshot);
-    }
-    if (processed.attributes && typeof processed.attributes === "object") {
-      processed.attributes = JSON.stringify(processed.attributes);
-    }
-    if (processed.status && typeof processed.status === "object") {
-      processed.status = JSON.stringify(processed.status);
-    }
-    if (processed.events && typeof processed.events === "object") {
-      processed.events = JSON.stringify(processed.events);
-    }
-    if (processed.links && typeof processed.links === "object") {
-      processed.links = JSON.stringify(processed.links);
-    }
-    return processed;
-  }
-  /**
-   * Validates that the required DynamoDB table exists and is accessible.
-   * This does not check the table structure - it assumes the table
-   * was created with the correct structure via CDK/CloudFormation.
-   */
-  async validateTableExists() {
-    try {
-      const command = new DescribeTableCommand({
-        TableName: this.tableName
-      });
-      await this.client.send(command);
-      return true;
-    } catch (error) {
-      if (error.name === "ResourceNotFoundException") {
-        return false;
-      }
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_VALIDATE_TABLE_EXISTS_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName: this.tableName }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * This method is modified for DynamoDB with ElectroDB single-table design.
-   * It assumes the table is created and managed externally via CDK/CloudFormation.
+   * DynamoDB-specific score row transformation.
    *
-   * This implementation only validates that the required table exists and is accessible.
-   * No table creation is attempted - we simply check if we can access the table.
-   */
-  async createTable({ tableName }) {
-    this.logger.debug("Validating access to externally managed table", { tableName, physicalTable: this.tableName });
-    try {
-      const tableExists = await this.validateTableExists();
-      if (!tableExists) {
-        this.logger.error(
-          `Table ${this.tableName} does not exist or is not accessible. It should be created via CDK/CloudFormation.`
-        );
-        throw new Error(
-          `Table ${this.tableName} does not exist or is not accessible. Ensure it's created via CDK/CloudFormation before using this store.`
-        );
-      }
-      this.logger.debug(`Table ${this.tableName} exists and is accessible`);
-    } catch (error) {
-      this.logger.error("Error validating table access", { tableName: this.tableName, error });
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_VALIDATE_TABLE_ACCESS_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName: this.tableName }
-        },
-        error
-      );
-    }
-  }
-  async insert({ tableName, record }) {
-    this.logger.debug("DynamoDB insert called", { tableName });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new MastraError({
-        id: "STORAGE_DYNAMODB_STORE_INSERT_INVALID_ARGS",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
-      });
-    }
-    try {
-      const dataToSave = { entity: entityName, ...this.preprocessRecord(record) };
-      await this.service.entities[entityName].create(dataToSave).go();
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_INSERT_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  async alterTable(_args) {
-  }
-  /**
-   * Clear all items from a logical "table" (entity type)
-   */
-  async clearTable({ tableName }) {
-    this.logger.debug("DynamoDB clearTable called", { tableName });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new MastraError({
-        id: "STORAGE_DYNAMODB_STORE_CLEAR_TABLE_INVALID_ARGS",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
-      });
-    }
-    try {
-      const result = await this.service.entities[entityName].scan.go({ pages: "all" });
-      if (!result.data.length) {
-        this.logger.debug(`No records found to clear for ${tableName}`);
-        return;
-      }
-      this.logger.debug(`Found ${result.data.length} records to delete for ${tableName}`);
-      const keysToDelete = result.data.map((item) => {
-        const key = { entity: entityName };
-        switch (entityName) {
-          case "thread":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'thread'`);
-            key.id = item.id;
-            break;
-          case "message":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'message'`);
-            key.id = item.id;
-            break;
-          case "workflow_snapshot":
-            if (!item.workflow_name)
-              throw new Error(`Missing required key 'workflow_name' for entity 'workflow_snapshot'`);
-            if (!item.run_id) throw new Error(`Missing required key 'run_id' for entity 'workflow_snapshot'`);
-            key.workflow_name = item.workflow_name;
-            key.run_id = item.run_id;
-            break;
-          case "eval":
-            if (!item.run_id) throw new Error(`Missing required key 'run_id' for entity 'eval'`);
-            key.run_id = item.run_id;
-            break;
-          case "trace":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'trace'`);
-            key.id = item.id;
-            break;
-          case "score":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'score'`);
-            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}`);
-        }
-        return key;
-      });
-      const batchSize = 25;
-      for (let i = 0; i < keysToDelete.length; i += batchSize) {
-        const batchKeys = keysToDelete.slice(i, i + batchSize);
-        await this.service.entities[entityName].delete(batchKeys).go();
-      }
-      this.logger.debug(`Successfully cleared all records for ${tableName}`);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_CLEAR_TABLE_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Insert multiple records as a batch
+   * Note: This implementation does NOT use coreTransformScoreRow because:
+   * 1. ElectroDB already parses JSON fields via its entity getters
+   * 2. DynamoDB stores empty strings for null values (which need special handling)
+   * 3. 'entity' is a reserved ElectroDB key, so we use 'entityData' column
    */
-  async batchInsert({ tableName, records }) {
-    this.logger.debug("DynamoDB batchInsert called", { tableName, count: records.length });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new MastraError({
-        id: "STORAGE_DYNAMODB_STORE_BATCH_INSERT_INVALID_ARGS",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
-      });
-    }
-    const recordsToSave = records.map((rec) => ({ entity: entityName, ...this.preprocessRecord(rec) }));
-    const batchSize = 25;
-    const batches = [];
-    for (let i = 0; i < recordsToSave.length; i += batchSize) {
-      const batch = recordsToSave.slice(i, i + batchSize);
-      batches.push(batch);
-    }
-    try {
-      for (const batch of batches) {
-        for (const recordData of batch) {
-          if (!recordData.entity) {
-            this.logger.error("Missing entity property in record data for batchInsert", { recordData, tableName });
-            throw new Error(`Internal error: Missing entity property during batchInsert for ${tableName}`);
-          }
-          this.logger.debug("Attempting to create record in batchInsert:", { entityName, recordData });
-          await this.service.entities[entityName].create(recordData).go();
-        }
-      }
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_BATCH_INSERT_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Load a record by its keys
-   */
-  async load({ tableName, keys }) {
-    this.logger.debug("DynamoDB load called", { tableName, keys });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new MastraError({
-        id: "STORAGE_DYNAMODB_STORE_LOAD_INVALID_ARGS",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
-      });
-    }
-    try {
-      const keyObject = { entity: entityName, ...keys };
-      const result = await this.service.entities[entityName].get(keyObject).go();
-      if (!result.data) {
-        return null;
+  parseScoreData(data) {
+    const result = {};
+    for (const key of Object.keys(SCORERS_SCHEMA)) {
+      if (["traceId", "resourceId", "threadId", "spanId"].includes(key)) {
+        result[key] = data[key] === "" ? null : data[key];
+        continue;
       }
-      let data = result.data;
-      return data;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_LOAD_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
+      result[key] = data[key];
     }
-  }
-};
-var ScoresStorageDynamoDB = class extends ScoresStorage {
-  service;
-  constructor({ service }) {
-    super();
-    this.service = service;
-  }
-  // Helper function to parse score data (handle JSON fields)
-  parseScoreData(data) {
+    result.entity = data.entityData ?? null;
     return {
-      ...data,
-      // Convert date strings back to Date objects for consistency
+      ...result,
       createdAt: data.createdAt ? new Date(data.createdAt) : /* @__PURE__ */ new Date(),
       updatedAt: data.updatedAt ? new Date(data.updatedAt) : /* @__PURE__ */ new Date()
-      // JSON fields are already transformed by the entity's getters
     };
   }
   async getScoreById({ id }) {
@@ -2176,7 +1876,7 @@ var ScoresStorageDynamoDB = class extends ScoresStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_SCORE_BY_ID_FAILED",
+          id: createStorageErrorId("DYNAMODB", "GET_SCORE_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { id }
@@ -2192,57 +1892,68 @@ var ScoresStorageDynamoDB = class extends ScoresStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_SAVE_SCORE_FAILED",
+          id: createStorageErrorId("DYNAMODB", "SAVE_SCORE", "VALIDATION_FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
+          category: ErrorCategory.USER,
+          details: {
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
+          }
         },
         error
       );
     }
     const now = /* @__PURE__ */ new Date();
-    const scoreId = `score-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    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()
-    };
+    const scoreId = crypto.randomUUID();
+    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 metadata = typeof validatedScore.metadata === "string" ? validatedScore.metadata : validatedScore.metadata ? JSON.stringify(validatedScore.metadata) : void 0;
+    const additionalContext = typeof validatedScore.additionalContext === "string" ? validatedScore.additionalContext : validatedScore.additionalContext ? JSON.stringify(validatedScore.additionalContext) : void 0;
+    const scoreData = Object.fromEntries(
+      Object.entries({
+        ...validatedScore,
+        entity: "score",
+        id: scoreId,
+        scorer,
+        preprocessStepResult,
+        analyzeStepResult,
+        input,
+        output,
+        requestContext,
+        metadata,
+        additionalContext,
+        entityData: entity,
+        traceId: validatedScore.traceId || "",
+        resourceId: validatedScore.resourceId || "",
+        threadId: validatedScore.threadId || "",
+        spanId: validatedScore.spanId || "",
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString(),
+        ...getTtlProps("score", this.ttlConfig)
+      }).filter(([_, value]) => value !== void 0 && value !== null)
+    );
     try {
       await this.service.entities.score.upsert(scoreData).go();
-      const savedScore = {
-        ...score,
-        id: scoreId,
-        createdAt: now,
-        updatedAt: now
+      return {
+        score: {
+          ...validatedScore,
+          id: scoreId,
+          createdAt: now,
+          updatedAt: now
+        }
       };
-      return { score: savedScore };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_SAVE_SCORE_FAILED",
+          id: createStorageErrorId("DYNAMODB", "SAVE_SCORE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { scorerId: score.scorerId, runId: score.runId }
@@ -2251,7 +1962,7 @@ var ScoresStorageDynamoDB = class extends ScoresStorage {
       );
     }
   }
-  async getScoresByScorerId({
+  async listScoresByScorerId({
     scorerId,
     pagination,
     entityId,
@@ -2272,24 +1983,25 @@ var ScoresStorageDynamoDB = class extends ScoresStorage {
         allScores = allScores.filter((score) => score.source === source);
       }
       allScores.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-      const startIndex = pagination.page * pagination.perPage;
-      const endIndex = startIndex + pagination.perPage;
-      const paginatedScores = allScores.slice(startIndex, endIndex);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
       const total = allScores.length;
-      const hasMore = endIndex < total;
+      const end = perPageInput === false ? allScores.length : start + perPage;
+      const paginatedScores = allScores.slice(start, end);
       return {
         scores: paginatedScores,
         pagination: {
           total,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         }
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LIST_SCORES_BY_SCORER_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
@@ -2305,7 +2017,7 @@ var ScoresStorageDynamoDB = class extends ScoresStorage {
       );
     }
   }
-  async getScoresByRunId({
+  async listScoresByRunId({
     runId,
     pagination
   }) {
@@ -2315,24 +2027,25 @@ var ScoresStorageDynamoDB = class extends 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 startIndex = pagination.page * pagination.perPage;
-      const endIndex = startIndex + pagination.perPage;
-      const paginatedScores = allScores.slice(startIndex, endIndex);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
       const total = allScores.length;
-      const hasMore = endIndex < total;
+      const end = perPageInput === false ? allScores.length : start + perPage;
+      const paginatedScores = allScores.slice(start, end);
       return {
         scores: paginatedScores,
         pagination: {
           total,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         }
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_SCORES_BY_RUN_ID_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LIST_SCORES_BY_RUN_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { runId, page: pagination.page, perPage: pagination.perPage }
@@ -2341,7 +2054,7 @@ var ScoresStorageDynamoDB = class extends ScoresStorage {
       );
     }
   }
-  async getScoresByEntityId({
+  async listScoresByEntityId({
     entityId,
     entityType,
     pagination
@@ -2353,24 +2066,25 @@ var ScoresStorageDynamoDB = class extends 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 startIndex = pagination.page * pagination.perPage;
-      const endIndex = startIndex + pagination.perPage;
-      const paginatedScores = allScores.slice(startIndex, endIndex);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
       const total = allScores.length;
-      const hasMore = endIndex < total;
+      const end = perPageInput === false ? allScores.length : start + perPage;
+      const paginatedScores = allScores.slice(start, end);
       return {
         scores: paginatedScores,
         pagination: {
           total,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         }
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LIST_SCORES_BY_ENTITY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { entityId, entityType, page: pagination.page, perPage: pagination.perPage }
@@ -2379,7 +2093,7 @@ var ScoresStorageDynamoDB = class extends ScoresStorage {
       );
     }
   }
-  async getScoresBySpan({
+  async listScoresBySpan({
     traceId,
     spanId,
     pagination
@@ -2390,24 +2104,25 @@ var ScoresStorageDynamoDB = class extends 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 startIndex = pagination.page * pagination.perPage;
-      const endIndex = startIndex + pagination.perPage;
-      const paginatedScores = allScores.slice(startIndex, endIndex);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
       const total = allScores.length;
-      const hasMore = endIndex < total;
+      const end = perPageInput === false ? allScores.length : start + perPage;
+      const paginatedScores = allScores.slice(start, end);
       return {
         scores: paginatedScores,
         pagination: {
           total,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         }
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_SCORES_BY_SPAN_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LIST_SCORES_BY_SPAN", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { traceId, spanId, page: pagination.page, perPage: pagination.perPage }
@@ -2417,239 +2132,6 @@ var ScoresStorageDynamoDB = class extends ScoresStorage {
     }
   }
 };
-var TracesStorageDynamoDB = class extends 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) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_GET_TRACES_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  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: TABLE_TRACES,
-        records: recordsToSave
-        // Pass records with 'entity' included
-      });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_BATCH_TRACE_INSERT_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { count: records.length }
-        },
-        error
-      );
-    }
-  }
-  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) {
-      throw new MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_GET_TRACES_PAGINATED_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-};
 function formatWorkflowRun(snapshotData) {
   return {
     workflowName: snapshotData.workflow_name,
@@ -2660,54 +2142,228 @@ function formatWorkflowRun(snapshotData) {
     resourceId: snapshotData.resourceId
   };
 }
+var MAX_RETRIES = 5;
+var BASE_DELAY_MS = 50;
 var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
   service;
-  constructor({ service }) {
+  ttlConfig;
+  constructor(config) {
     super();
-    this.service = service;
+    const resolved = resolveDynamoDBConfig(config);
+    this.service = resolved.service;
+    this.ttlConfig = resolved.ttl;
+  }
+  supportsConcurrentUpdates() {
+    return true;
+  }
+  async dangerouslyClearAll() {
+    await deleteTableData(this.service, TABLE_WORKFLOW_SNAPSHOT);
+  }
+  /**
+   * Helper to check if an error is a DynamoDB conditional check failure
+   */
+  isConditionalCheckFailed(error) {
+    if (error && typeof error === "object") {
+      const err = error;
+      if (err.name === "ConditionalCheckFailedException" || err.code === "ConditionalCheckFailedException" || (err.__type?.includes("ConditionalCheckFailedException") ?? false)) {
+        return true;
+      }
+      if (err.message?.includes("conditional request failed")) {
+        return true;
+      }
+      if (err.cause && typeof err.cause === "object") {
+        const cause = err.cause;
+        if (cause.name === "ConditionalCheckFailedException" || cause.code === "ConditionalCheckFailedException") {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Helper to delay with exponential backoff and jitter
+   */
+  async delay(attempt) {
+    const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+    const jitter = Math.random() * backoff * 0.5;
+    await new Promise((resolve) => setTimeout(resolve, backoff + jitter));
   }
-  updateWorkflowResults({
-    // workflowName,
-    // runId,
-    // stepId,
-    // result,
-    // runtimeContext,
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
   }) {
-    throw new Error("Method not implemented.");
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const existingRecord = await this.service.entities.workflow_snapshot.get({
+          entity: "workflow_snapshot",
+          workflow_name: workflowName,
+          run_id: runId
+        }).go();
+        const now = /* @__PURE__ */ new Date();
+        let snapshot;
+        let previousUpdatedAt;
+        if (!existingRecord.data) {
+          snapshot = {
+            context: {},
+            activePaths: [],
+            timestamp: Date.now(),
+            suspendedPaths: {},
+            activeStepsPath: {},
+            resumeLabels: {},
+            serializedStepGraph: [],
+            status: "pending",
+            value: {},
+            waitingPaths: {},
+            runId,
+            requestContext: {}
+          };
+        } else {
+          snapshot = existingRecord.data.snapshot;
+          previousUpdatedAt = existingRecord.data.updatedAt;
+        }
+        snapshot.context[stepId] = result;
+        snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+        const data = {
+          entity: "workflow_snapshot",
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot: JSON.stringify(snapshot),
+          createdAt: existingRecord.data?.createdAt ?? now.toISOString(),
+          updatedAt: now.toISOString(),
+          ...getTtlProps("workflow_snapshot", this.ttlConfig)
+        };
+        if (previousUpdatedAt) {
+          await this.service.entities.workflow_snapshot.upsert(data).where((attr, op) => op.eq(attr.updatedAt, previousUpdatedAt)).go();
+        } else {
+          await this.service.entities.workflow_snapshot.create(data).where((attr, op) => op.notExists(attr.run_id)).go();
+        }
+        return snapshot.context;
+      } catch (error) {
+        if (this.isConditionalCheckFailed(error)) {
+          if (attempt < MAX_RETRIES - 1) {
+            this.logger.debug(
+              `Optimistic locking conflict in updateWorkflowResults, retrying (attempt ${attempt + 1})`
+            );
+            await this.delay(attempt);
+            continue;
+          }
+        }
+        if (error instanceof MastraError) throw error;
+        throw new MastraError(
+          {
+            id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { workflowName, runId, stepId }
+          },
+          error
+        );
+      }
+    }
+    throw new MastraError(
+      {
+        id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_RESULTS", "MAX_RETRIES_EXCEEDED"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        details: { workflowName, runId, stepId }
+      },
+      new Error("Max retries exceeded for optimistic locking")
+    );
   }
-  updateWorkflowState({
-    // workflowName,
-    // runId,
-    // opts,
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
   }) {
-    throw new Error("Method not implemented.");
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const existingRecord = await this.service.entities.workflow_snapshot.get({
+          entity: "workflow_snapshot",
+          workflow_name: workflowName,
+          run_id: runId
+        }).go();
+        if (!existingRecord.data) {
+          return void 0;
+        }
+        const existingSnapshot = existingRecord.data.snapshot;
+        if (!existingSnapshot || !existingSnapshot.context) {
+          return void 0;
+        }
+        const previousUpdatedAt = existingRecord.data.updatedAt;
+        const updatedSnapshot = { ...existingSnapshot, ...opts };
+        const now = /* @__PURE__ */ new Date();
+        const data = {
+          entity: "workflow_snapshot",
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot: JSON.stringify(updatedSnapshot),
+          createdAt: existingRecord.data.createdAt,
+          updatedAt: now.toISOString(),
+          resourceId: existingRecord.data.resourceId,
+          ...getTtlProps("workflow_snapshot", this.ttlConfig)
+        };
+        await this.service.entities.workflow_snapshot.upsert(data).where((attr, op) => op.eq(attr.updatedAt, previousUpdatedAt)).go();
+        return updatedSnapshot;
+      } catch (error) {
+        if (this.isConditionalCheckFailed(error)) {
+          if (attempt < MAX_RETRIES - 1) {
+            this.logger.debug(`Optimistic locking conflict in updateWorkflowState, retrying (attempt ${attempt + 1})`);
+            await this.delay(attempt);
+            continue;
+          }
+        }
+        if (error instanceof MastraError) throw error;
+        throw new MastraError(
+          {
+            id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_STATE", "FAILED"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { workflowName, runId }
+          },
+          error
+        );
+      }
+    }
+    throw new MastraError(
+      {
+        id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_STATE", "MAX_RETRIES_EXCEEDED"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        details: { workflowName, runId }
+      },
+      new Error("Max retries exceeded for optimistic locking")
+    );
   }
   // Workflow operations
   async persistWorkflowSnapshot({
     workflowName,
     runId,
     resourceId,
-    snapshot
+    snapshot,
+    createdAt,
+    updatedAt
   }) {
     this.logger.debug("Persisting workflow snapshot", { workflowName, runId });
     try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const now = /* @__PURE__ */ new Date();
       const data = {
         entity: "workflow_snapshot",
-        // Add entity type
         workflow_name: workflowName,
         run_id: runId,
         snapshot: JSON.stringify(snapshot),
-        // Stringify the snapshot object
-        createdAt: now,
-        updatedAt: now,
-        resourceId
+        createdAt: (createdAt ?? now).toISOString(),
+        updatedAt: (updatedAt ?? now).toISOString(),
+        resourceId,
+        ...getTtlProps("workflow_snapshot", this.ttlConfig)
       };
       await this.service.entities.workflow_snapshot.upsert(data).go();
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          id: createStorageErrorId("DYNAMODB", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { workflowName, runId }
@@ -2735,7 +2391,7 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { workflowName, runId }
@@ -2744,11 +2400,24 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
       );
     }
   }
-  async getWorkflowRuns(args) {
+  async listWorkflowRuns(args) {
     this.logger.debug("Getting workflow runs", { args });
     try {
-      const limit = args?.limit || 10;
-      const offset = args?.offset || 0;
+      const perPage = args?.perPage !== void 0 ? args.perPage : 10;
+      const page = args?.page !== void 0 ? args.page : 0;
+      if (page < 0) {
+        throw new MastraError(
+          {
+            id: createStorageErrorId("DYNAMODB", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const normalizedPerPage = normalizePerPage(perPage, 10);
+      const offset = page * normalizedPerPage;
       let query;
       if (args?.workflowName) {
         query = this.service.entities.workflow_snapshot.query.primary({
@@ -2770,6 +2439,11 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
         });
         if (pageResults.data && pageResults.data.length > 0) {
           let pageFilteredData = pageResults.data;
+          if (args?.status) {
+            pageFilteredData = pageFilteredData.filter((snapshot) => {
+              return snapshot.snapshot.status === args.status;
+            });
+          }
           if (args?.fromDate || args?.toDate) {
             pageFilteredData = pageFilteredData.filter((snapshot) => {
               const createdAt = new Date(snapshot.createdAt);
@@ -2795,7 +2469,7 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
         return { runs: [], total: 0 };
       }
       const total = allMatchingSnapshots.length;
-      const paginatedData = allMatchingSnapshots.slice(offset, offset + limit);
+      const paginatedData = allMatchingSnapshots.slice(offset, offset + normalizedPerPage);
       const runs = paginatedData.map((snapshot) => formatWorkflowRun(snapshot));
       return {
         runs,
@@ -2804,7 +2478,7 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_WORKFLOW_RUNS_FAILED",
+          id: createStorageErrorId("DYNAMODB", "LIST_WORKFLOW_RUNS", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { workflowName: args?.workflowName || "", resourceId: args?.resourceId || "" }
@@ -2858,7 +2532,7 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          id: createStorageErrorId("DYNAMODB", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { runId, workflowName: args?.workflowName || "" }
@@ -2867,17 +2541,41 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
       );
     }
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    this.logger.debug("Deleting workflow run by ID", { runId, workflowName });
+    try {
+      await this.service.entities.workflow_snapshot.delete({
+        entity: "workflow_snapshot",
+        workflow_name: workflowName,
+        run_id: runId
+      }).go();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("DYNAMODB", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { runId, workflowName }
+        },
+        error
+      );
+    }
+  }
 };
 
 // src/storage/index.ts
-var DynamoDBStore = class extends MastraStorage {
+var isClientConfig = (config) => {
+  return "client" in config;
+};
+var DynamoDBStore = class extends MastraCompositeStore {
   tableName;
   client;
   service;
+  ttlConfig;
   hasInitialized = null;
   stores;
   constructor({ name, config }) {
-    super({ name });
+    super({ id: config.id, name, disableInit: config.disableInit });
     try {
       if (!config.tableName || typeof config.tableName !== "string" || config.tableName.trim() === "") {
         throw new Error("DynamoDBStore: config.tableName must be provided and cannot be empty.");
@@ -2887,27 +2585,24 @@ var DynamoDBStore = class extends MastraStorage {
           `DynamoDBStore: config.tableName "${config.tableName}" contains invalid characters or is not between 3 and 255 characters long.`
         );
       }
-      const dynamoClient = new DynamoDBClient({
-        region: config.region || "us-east-1",
-        endpoint: config.endpoint,
-        credentials: config.credentials
-      });
       this.tableName = config.tableName;
-      this.client = DynamoDBDocumentClient.from(dynamoClient);
+      this.ttlConfig = config.ttl;
+      if (isClientConfig(config)) {
+        this.client = config.client;
+      } else {
+        const dynamoClient = new DynamoDBClient({
+          region: config.region || "us-east-1",
+          endpoint: config.endpoint,
+          credentials: config.credentials
+        });
+        this.client = DynamoDBDocumentClient.from(dynamoClient);
+      }
       this.service = getElectroDbService(this.client, this.tableName);
-      const operations = new StoreOperationsDynamoDB({
-        service: this.service,
-        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 });
+      const domainConfig = { service: this.service, ttl: this.ttlConfig };
+      const workflows = new WorkflowStorageDynamoDB(domainConfig);
+      const memory = new MemoryStorageDynamoDB(domainConfig);
+      const scores = new ScoresStorageDynamoDB(domainConfig);
       this.stores = {
-        operations,
-        legacyEvals: new LegacyEvalsDynamoDB({ service: this.service, tableName: this.tableName }),
-        traces,
         workflows,
         memory,
         scores
@@ -2915,7 +2610,7 @@ var DynamoDBStore = class extends MastraStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_CONSTRUCTOR_FAILED",
+          id: createStorageErrorId("DYNAMODB", "CONSTRUCTOR", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.USER
         },
@@ -2923,16 +2618,6 @@ var DynamoDBStore = class extends MastraStorage {
       );
     }
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: false,
-      createTable: false,
-      deleteMessages: false,
-      getScoresBySpan: true
-    };
-  }
   /**
    * Validates that the required DynamoDB table exists and is accessible.
    * This does not check the table structure - it assumes the table
@@ -2951,7 +2636,7 @@ var DynamoDBStore = class extends MastraStorage {
       }
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_VALIDATE_TABLE_EXISTS_FAILED",
+          id: createStorageErrorId("DYNAMODB", "VALIDATE_TABLE_EXISTS", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { tableName: this.tableName }
@@ -2974,7 +2659,7 @@ var DynamoDBStore = class extends MastraStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_INIT_FAILED",
+          id: createStorageErrorId("DYNAMODB", "INIT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { tableName: this.tableName }
@@ -3000,143 +2685,10 @@ var DynamoDBStore = class extends MastraStorage {
       throw err;
     });
   }
-  async createTable({ tableName, schema }) {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-  async alterTable(_args) {
-    return this.stores.operations.alterTable(_args);
-  }
-  async clearTable({ tableName }) {
-    return this.stores.operations.clearTable({ tableName });
-  }
-  async dropTable({ tableName }) {
-    return this.stores.operations.dropTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    return this.stores.operations.insert({ tableName, record });
-  }
-  async batchInsert({ tableName, records }) {
-    return this.stores.operations.batchInsert({ tableName, records });
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
-  // Thread operations
-  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 });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.stores.memory.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    return this.stores.memory.deleteThread({ threadId });
-  }
-  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,
-    runtimeContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-  async getWorkflowRuns(args) {
-    return this.stores.workflows.getWorkflowRuns(args);
-  }
-  async getWorkflowRunById(args) {
-    return this.stores.workflows.getWorkflowRunById(args);
-  }
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    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.
+   *
+   * This will close the DynamoDB client, including pre-configured clients.
    */
   async close() {
     this.logger.debug("Closing DynamoDB client for store:", { name: this.name });
@@ -3146,7 +2698,7 @@ var DynamoDBStore = class extends MastraStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_CLOSE_FAILED",
+          id: createStorageErrorId("DYNAMODB", "CLOSE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -3154,50 +2706,8 @@ var DynamoDBStore = class extends MastraStorage {
       );
     }
   }
-  /**
-   * SCORERS - Not implemented
-   */
-  async getScoreById({ id: _id }) {
-    return this.stores.scores.getScoreById({ id: _id });
-  }
-  async saveScore(_score) {
-    return this.stores.scores.saveScore(_score);
-  }
-  async getScoresByRunId({
-    runId: _runId,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.getScoresByRunId({ runId: _runId, pagination: _pagination });
-  }
-  async getScoresByEntityId({
-    entityId: _entityId,
-    entityType: _entityType,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.getScoresByEntityId({
-      entityId: _entityId,
-      entityType: _entityType,
-      pagination: _pagination
-    });
-  }
-  async getScoresByScorerId({
-    scorerId,
-    source,
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.getScoresByScorerId({ scorerId, source, entityId, entityType, pagination });
-  }
-  async getScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination });
-  }
 };
 
-export { DynamoDBStore };
+export { DynamoDBStore, MemoryStorageDynamoDB, ScoresStorageDynamoDB, WorkflowStorageDynamoDB, calculateTtl, getTtlAttributeName, getTtlProps, isTtlEnabled };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map