@mastra/dynamodb 0.13.0 → 0.13.1

package/dist/index.cjs

@@ -2,10 +2,10 @@
 
 var clientDynamodb = require('@aws-sdk/client-dynamodb');
 var libDynamodb = require('@aws-sdk/lib-dynamodb');
-var agent = require('@mastra/core/agent');
 var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
 var electrodb = require('electrodb');
+var agent = require('@mastra/core/agent');
 
 // src/storage/index.ts
 
@@ -296,9 +296,9 @@ var messageEntity = new electrodb.Entity({
     }
   }
 });
-var threadEntity = new electrodb.Entity({
+var resourceEntity = new electrodb.Entity({
   model: {
-    entity: "thread",
+    entity: "resource",
     version: "1",
     service: "mastra"
   },
@@ -312,25 +312,21 @@ var threadEntity = new electrodb.Entity({
       type: "string",
       required: true
     },
-    resourceId: {
-      type: "string",
-      required: true
-    },
-    title: {
+    workingMemory: {
       type: "string",
-      required: true
+      required: false
     },
     metadata: {
       type: "string",
       required: false,
-      // Stringify metadata object on set if it's not already a string
+      // Stringify content object on set if it's not already a string
       set: (value) => {
         if (value && typeof value !== "string") {
           return JSON.stringify(value);
         }
         return value;
       },
-      // Parse JSON string to object on get
+      // Parse JSON string to object on get ONLY if it looks like JSON
       get: (value) => {
         if (value && typeof value === "string") {
           try {
@@ -348,18 +344,13 @@ var threadEntity = new electrodb.Entity({
   indexes: {
     primary: {
       pk: { field: "pk", composite: ["entity", "id"] },
-      sk: { field: "sk", composite: ["id"] }
-    },
-    byResource: {
-      index: "gsi1",
-      pk: { field: "gsi1pk", composite: ["entity", "resourceId"] },
-      sk: { field: "gsi1sk", composite: ["createdAt"] }
+      sk: { field: "sk", composite: ["entity"] }
     }
   }
 });
-var traceEntity = new electrodb.Entity({
+var scoreEntity = new electrodb.Entity({
   model: {
-    entity: "trace",
+    entity: "score",
     version: "1",
     service: "mastra"
   },
@@ -373,123 +364,275 @@ var traceEntity = new electrodb.Entity({
       type: "string",
       required: true
     },
-    parentSpanId: {
+    scorerId: {
+      type: "string",
+      required: true
+    },
+    traceId: {
       type: "string",
       required: false
     },
-    name: {
+    runId: {
       type: "string",
       required: true
     },
-    traceId: {
+    scorer: {
       type: "string",
-      required: true
+      required: true,
+      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;
+      }
     },
-    scope: {
+    extractStepResult: {
       type: "string",
-      required: true
+      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;
+      }
     },
-    kind: {
+    analyzeStepResult: {
+      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;
+      }
+    },
+    score: {
       type: "number",
       required: true
     },
-    attributes: {
+    reason: {
       type: "string",
-      // JSON stringified
-      required: false,
-      // Stringify object on set
+      required: false
+    },
+    extractPrompt: {
+      type: "string",
+      required: false
+    },
+    analyzePrompt: {
+      type: "string",
+      required: false
+    },
+    reasonPrompt: {
+      type: "string",
+      required: false
+    },
+    input: {
+      type: "string",
+      required: true,
       set: (value) => {
         if (value && typeof value !== "string") {
           return JSON.stringify(value);
         }
         return value;
       },
-      // Parse JSON string to object on get
       get: (value) => {
-        return value ? JSON.parse(value) : value;
+        if (value && typeof value === "string") {
+          try {
+            if (value.startsWith("{") || value.startsWith("[")) {
+              return JSON.parse(value);
+            }
+          } catch {
+            return value;
+          }
+        }
+        return value;
       }
     },
-    status: {
+    output: {
+      type: "string",
+      required: true,
+      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;
+      }
+    },
+    additionalContext: {
       type: "string",
-      // JSON stringified
       required: false,
-      // Stringify object on set
       set: (value) => {
         if (value && typeof value !== "string") {
           return JSON.stringify(value);
         }
         return value;
       },
-      // Parse JSON string to object on get
       get: (value) => {
+        if (value && typeof value === "string") {
+          try {
+            if (value.startsWith("{") || value.startsWith("[")) {
+              return JSON.parse(value);
+            }
+          } catch {
+            return value;
+          }
+        }
         return value;
       }
     },
-    events: {
+    runtimeContext: {
       type: "string",
-      // JSON stringified
       required: false,
-      // Stringify object on set
       set: (value) => {
         if (value && typeof value !== "string") {
           return JSON.stringify(value);
         }
         return value;
       },
-      // Parse JSON string to object on get
       get: (value) => {
+        if (value && typeof value === "string") {
+          try {
+            if (value.startsWith("{") || value.startsWith("[")) {
+              return JSON.parse(value);
+            }
+          } catch {
+            return value;
+          }
+        }
         return value;
       }
     },
-    links: {
+    entityType: {
+      type: "string",
+      required: false
+    },
+    entityData: {
       type: "string",
-      // JSON stringified
       required: false,
-      // Stringify object on set
       set: (value) => {
         if (value && typeof value !== "string") {
           return JSON.stringify(value);
         }
         return value;
       },
-      // Parse JSON string to object on get
       get: (value) => {
+        if (value && typeof value === "string") {
+          try {
+            if (value.startsWith("{") || value.startsWith("[")) {
+              return JSON.parse(value);
+            }
+          } catch {
+            return value;
+          }
+        }
         return value;
       }
     },
-    other: {
+    entityId: {
       type: "string",
       required: false
     },
-    startTime: {
-      type: "number",
+    source: {
+      type: "string",
       required: true
     },
-    endTime: {
-      type: "number",
-      required: true
+    resourceId: {
+      type: "string",
+      required: false
+    },
+    threadId: {
+      type: "string",
+      required: false
     }
   },
   indexes: {
     primary: {
       pk: { field: "pk", composite: ["entity", "id"] },
-      sk: { field: "sk", composite: [] }
+      sk: { field: "sk", composite: ["entity"] }
     },
-    byName: {
+    byScorer: {
       index: "gsi1",
-      pk: { field: "gsi1pk", composite: ["entity", "name"] },
-      sk: { field: "gsi1sk", composite: ["startTime"] }
+      pk: { field: "gsi1pk", composite: ["entity", "scorerId"] },
+      sk: { field: "gsi1sk", composite: ["createdAt"] }
     },
-    byScope: {
+    byRun: {
       index: "gsi2",
-      pk: { field: "gsi2pk", composite: ["entity", "scope"] },
-      sk: { field: "gsi2sk", composite: ["startTime"] }
+      pk: { field: "gsi2pk", composite: ["entity", "runId"] },
+      sk: { field: "gsi2sk", composite: ["createdAt"] }
+    },
+    byTrace: {
+      index: "gsi3",
+      pk: { field: "gsi3pk", composite: ["entity", "traceId"] },
+      sk: { field: "gsi3sk", composite: ["createdAt"] }
+    },
+    byEntityData: {
+      index: "gsi4",
+      pk: { field: "gsi4pk", composite: ["entity", "entityId"] },
+      sk: { field: "gsi4sk", composite: ["createdAt"] }
+    },
+    byResource: {
+      index: "gsi5",
+      pk: { field: "gsi5pk", composite: ["entity", "resourceId"] },
+      sk: { field: "gsi5sk", composite: ["createdAt"] }
+    },
+    byThread: {
+      index: "gsi6",
+      pk: { field: "gsi6pk", composite: ["entity", "threadId"] },
+      sk: { field: "gsi6sk", composite: ["createdAt"] }
     }
   }
 });
-var workflowSnapshotEntity = new electrodb.Entity({
+var threadEntity = new electrodb.Entity({
   model: {
-    entity: "workflow_snapshot",
+    entity: "thread",
     version: "1",
     service: "mastra"
   },
@@ -499,19 +642,22 @@ var workflowSnapshotEntity = new electrodb.Entity({
       required: true
     },
     ...baseAttributes,
-    workflow_name: {
+    id: {
       type: "string",
       required: true
     },
-    run_id: {
+    resourceId: {
       type: "string",
       required: true
     },
-    snapshot: {
+    title: {
       type: "string",
-      // JSON stringified
-      required: true,
-      // Stringify snapshot object on set
+      required: true
+    },
+    metadata: {
+      type: "string",
+      required: false,
+      // Stringify metadata object on set if it's not already a string
       set: (value) => {
         if (value && typeof value !== "string") {
           return JSON.stringify(value);
@@ -520,114 +666,1146 @@ var workflowSnapshotEntity = new electrodb.Entity({
       },
       // Parse JSON string to object on get
       get: (value) => {
-        return value ? JSON.parse(value) : value;
+        if (value && typeof value === "string") {
+          try {
+            if (value.startsWith("{") || value.startsWith("[")) {
+              return JSON.parse(value);
+            }
+          } catch {
+            return value;
+          }
+        }
+        return value;
       }
-    },
-    resourceId: {
-      type: "string",
-      required: false
     }
   },
   indexes: {
     primary: {
-      pk: { field: "pk", composite: ["entity", "workflow_name"] },
-      sk: { field: "sk", composite: ["run_id"] }
+      pk: { field: "pk", composite: ["entity", "id"] },
+      sk: { field: "sk", composite: ["id"] }
     },
-    // GSI to allow querying by run_id efficiently without knowing the workflow_name
+    byResource: {
+      index: "gsi1",
+      pk: { field: "gsi1pk", composite: ["entity", "resourceId"] },
+      sk: { field: "gsi1sk", composite: ["createdAt"] }
+    }
+  }
+});
+var traceEntity = new electrodb.Entity({
+  model: {
+    entity: "trace",
+    version: "1",
+    service: "mastra"
+  },
+  attributes: {
+    entity: {
+      type: "string",
+      required: true
+    },
+    ...baseAttributes,
+    id: {
+      type: "string",
+      required: true
+    },
+    parentSpanId: {
+      type: "string",
+      required: false
+    },
+    name: {
+      type: "string",
+      required: true
+    },
+    traceId: {
+      type: "string",
+      required: true
+    },
+    scope: {
+      type: "string",
+      required: true
+    },
+    kind: {
+      type: "number",
+      required: true
+    },
+    attributes: {
+      type: "string",
+      // JSON stringified
+      required: false,
+      // Stringify object on set
+      set: (value) => {
+        if (value && typeof value !== "string") {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      // Parse JSON string to object on get
+      get: (value) => {
+        return value ? JSON.parse(value) : value;
+      }
+    },
+    status: {
+      type: "string",
+      // JSON stringified
+      required: false,
+      // Stringify object on set
+      set: (value) => {
+        if (value && typeof value !== "string") {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      // Parse JSON string to object on get
+      get: (value) => {
+        return value;
+      }
+    },
+    events: {
+      type: "string",
+      // JSON stringified
+      required: false,
+      // Stringify object on set
+      set: (value) => {
+        if (value && typeof value !== "string") {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      // Parse JSON string to object on get
+      get: (value) => {
+        return value;
+      }
+    },
+    links: {
+      type: "string",
+      // JSON stringified
+      required: false,
+      // Stringify object on set
+      set: (value) => {
+        if (value && typeof value !== "string") {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      // Parse JSON string to object on get
+      get: (value) => {
+        return value;
+      }
+    },
+    other: {
+      type: "string",
+      required: false
+    },
+    startTime: {
+      type: "number",
+      required: true
+    },
+    endTime: {
+      type: "number",
+      required: true
+    }
+  },
+  indexes: {
+    primary: {
+      pk: { field: "pk", composite: ["entity", "id"] },
+      sk: { field: "sk", composite: [] }
+    },
+    byName: {
+      index: "gsi1",
+      pk: { field: "gsi1pk", composite: ["entity", "name"] },
+      sk: { field: "gsi1sk", composite: ["startTime"] }
+    },
+    byScope: {
+      index: "gsi2",
+      pk: { field: "gsi2pk", composite: ["entity", "scope"] },
+      sk: { field: "gsi2sk", composite: ["startTime"] }
+    }
+  }
+});
+var workflowSnapshotEntity = new electrodb.Entity({
+  model: {
+    entity: "workflow_snapshot",
+    version: "1",
+    service: "mastra"
+  },
+  attributes: {
+    entity: {
+      type: "string",
+      required: true
+    },
+    ...baseAttributes,
+    workflow_name: {
+      type: "string",
+      required: true
+    },
+    run_id: {
+      type: "string",
+      required: true
+    },
+    snapshot: {
+      type: "string",
+      // JSON stringified
+      required: true,
+      // Stringify snapshot object on set
+      set: (value) => {
+        if (value && typeof value !== "string") {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      // Parse JSON string to object on get
+      get: (value) => {
+        return value ? JSON.parse(value) : value;
+      }
+    },
+    resourceId: {
+      type: "string",
+      required: false
+    }
+  },
+  indexes: {
+    primary: {
+      pk: { field: "pk", composite: ["entity", "workflow_name"] },
+      sk: { field: "sk", composite: ["run_id"] }
+    },
+    // GSI to allow querying by run_id efficiently without knowing the workflow_name
     gsi2: {
       index: "gsi2",
       pk: { field: "gsi2pk", composite: ["entity", "run_id"] },
       sk: { field: "gsi2sk", composite: ["workflow_name"] }
     }
   }
-});
-
-// src/entities/index.ts
-function getElectroDbService(client, tableName) {
-  return new electrodb.Service(
-    {
-      thread: threadEntity,
-      message: messageEntity,
-      eval: evalEntity,
-      trace: traceEntity,
-      workflowSnapshot: workflowSnapshotEntity
-    },
-    {
-      client,
-      table: tableName
-    }
-  );
-}
-
-// src/storage/index.ts
-var DynamoDBStore = class extends storage.MastraStorage {
-  tableName;
-  client;
-  service;
-  hasInitialized = null;
-  constructor({ name, config }) {
-    super({ name });
+});
+
+// src/entities/index.ts
+function getElectroDbService(client, tableName) {
+  return new electrodb.Service(
+    {
+      thread: threadEntity,
+      message: messageEntity,
+      eval: evalEntity,
+      trace: traceEntity,
+      workflow_snapshot: workflowSnapshotEntity,
+      resource: resourceEntity,
+      score: scoreEntity
+    },
+    {
+      client,
+      table: tableName
+    }
+  );
+}
+var LegacyEvalsDynamoDB = class extends storage.LegacyEvalsStorage {
+  service;
+  tableName;
+  constructor({ service, tableName }) {
+    super();
+    this.service = service;
+    this.tableName = tableName;
+  }
+  // Eval operations
+  async getEvalsByAgentName(agentName, type) {
+    this.logger.debug("Getting evals for agent", { agentName, type });
+    try {
+      const query = this.service.entities.eval.query.byAgent({ entity: "eval", agent_name: agentName });
+      const results = await query.go({ order: "desc", limit: 100 });
+      if (!results.data.length) {
+        return [];
+      }
+      let filteredData = results.data;
+      if (type) {
+        filteredData = filteredData.filter((evalRecord) => {
+          try {
+            const testInfo = evalRecord.test_info && typeof evalRecord.test_info === "string" ? JSON.parse(evalRecord.test_info) : void 0;
+            if (type === "test" && !testInfo) {
+              return false;
+            }
+            if (type === "live" && testInfo) {
+              return false;
+            }
+          } catch (e) {
+            this.logger.warn("Failed to parse test_info during filtering", { record: evalRecord, error: e });
+          }
+          return true;
+        });
+      }
+      return filteredData.map((evalRecord) => {
+        try {
+          return {
+            input: evalRecord.input,
+            output: evalRecord.output,
+            // Safely parse result and test_info
+            result: evalRecord.result && typeof evalRecord.result === "string" ? JSON.parse(evalRecord.result) : void 0,
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            // Keep as string from DDB?
+            metricName: evalRecord.metric_name,
+            instructions: evalRecord.instructions,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id,
+            testInfo: evalRecord.test_info && typeof evalRecord.test_info === "string" ? JSON.parse(evalRecord.test_info) : void 0
+          };
+        } catch (parseError) {
+          this.logger.error("Failed to parse eval record", { record: evalRecord, error: parseError });
+          return {
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id
+          };
+        }
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error$1
+      );
+    }
+  }
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    this.logger.debug("Getting evals with pagination", { agentName, type, page, perPage, dateRange });
+    try {
+      let query;
+      if (agentName) {
+        query = this.service.entities.eval.query.byAgent({ entity: "eval", agent_name: agentName });
+      } else {
+        query = this.service.entities.eval.query.byEntity({ entity: "eval" });
+      }
+      const results = await query.go({
+        order: "desc",
+        pages: "all"
+        // Get all pages to apply filtering and pagination
+      });
+      if (!results.data.length) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      let filteredData = results.data;
+      if (type) {
+        filteredData = filteredData.filter((evalRecord) => {
+          try {
+            const testInfo = evalRecord.test_info && typeof evalRecord.test_info === "string" ? JSON.parse(evalRecord.test_info) : void 0;
+            if (type === "test" && !testInfo) {
+              return false;
+            }
+            if (type === "live" && testInfo) {
+              return false;
+            }
+          } catch (e) {
+            this.logger.warn("Failed to parse test_info during filtering", { record: evalRecord, error: e });
+          }
+          return true;
+        });
+      }
+      if (dateRange) {
+        const fromDate = dateRange.start;
+        const toDate = dateRange.end;
+        filteredData = filteredData.filter((evalRecord) => {
+          const recordDate = new Date(evalRecord.created_at);
+          if (fromDate && recordDate < fromDate) {
+            return false;
+          }
+          if (toDate && recordDate > toDate) {
+            return false;
+          }
+          return true;
+        });
+      }
+      const total = filteredData.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedData = filteredData.slice(start, end);
+      const evals = paginatedData.map((evalRecord) => {
+        try {
+          return {
+            input: evalRecord.input,
+            output: evalRecord.output,
+            result: evalRecord.result && typeof evalRecord.result === "string" ? JSON.parse(evalRecord.result) : void 0,
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            metricName: evalRecord.metric_name,
+            instructions: evalRecord.instructions,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id,
+            testInfo: evalRecord.test_info && typeof evalRecord.test_info === "string" ? JSON.parse(evalRecord.test_info) : void 0
+          };
+        } catch (parseError) {
+          this.logger.error("Failed to parse eval record", { record: evalRecord, error: parseError });
+          return {
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id
+          };
+        }
+      });
+      const hasMore = end < total;
+      return {
+        evals,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_EVALS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            agentName: agentName || "all",
+            type: type || "all",
+            page,
+            perPage
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
+var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
+  service;
+  constructor({ service }) {
+    super();
+    this.service = service;
+  }
+  // Helper function to parse message data (handle JSON fields)
+  parseMessageData(data) {
+    return {
+      ...data,
+      // Ensure dates are Date objects if needed (ElectroDB might return strings)
+      createdAt: data.createdAt ? new Date(data.createdAt) : void 0,
+      updatedAt: data.updatedAt ? new Date(data.updatedAt) : void 0
+      // Other fields like content, toolCallArgs etc. are assumed to be correctly
+      // transformed by the ElectroDB entity getters.
+    };
+  }
+  async getThreadById({ threadId }) {
+    this.logger.debug("Getting thread by ID", { threadId });
+    try {
+      const result = await this.service.entities.thread.get({ entity: "thread", id: threadId }).go();
+      if (!result.data) {
+        return null;
+      }
+      const data = result.data;
+      return {
+        ...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
+        // metadata: data.metadata ? JSON.parse(data.metadata) : undefined, // REMOVED by AI
+        // metadata is already transformed by the entity's getter
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_THREAD_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    this.logger.debug("Getting threads by resource ID", { resourceId });
+    try {
+      const result = await this.service.entities.thread.query.byResource({ entity: "thread", resourceId }).go();
+      if (!result.data.length) {
+        return [];
+      }
+      return result.data.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
+        // metadata: data.metadata ? JSON.parse(data.metadata) : undefined, // REMOVED by AI
+        // metadata is already transformed by the entity's getter
+      }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveThread({ thread }) {
+    this.logger.debug("Saving thread", { threadId: thread.id });
+    const now = /* @__PURE__ */ new Date();
+    const threadData = {
+      entity: "thread",
+      id: thread.id,
+      resourceId: thread.resourceId,
+      title: thread.title || `Thread ${thread.id}`,
+      createdAt: thread.createdAt?.toISOString() || now.toISOString(),
+      updatedAt: now.toISOString(),
+      metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0
+    };
+    try {
+      await this.service.entities.thread.upsert(threadData).go();
+      return {
+        id: thread.id,
+        resourceId: thread.resourceId,
+        title: threadData.title,
+        createdAt: thread.createdAt || now,
+        updatedAt: now,
+        metadata: thread.metadata
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_SAVE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
+        },
+        error$1
+      );
+    }
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    this.logger.debug("Updating thread", { threadId: id });
+    try {
+      const existingThread = await this.getThreadById({ threadId: id });
+      if (!existingThread) {
+        throw new Error(`Thread not found: ${id}`);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const updateData = {
+        updatedAt: now.toISOString()
+      };
+      if (title) {
+        updateData.title = title;
+      }
+      if (metadata) {
+        const existingMetadata = existingThread.metadata ? typeof existingThread.metadata === "string" ? JSON.parse(existingThread.metadata) : existingThread.metadata : {};
+        const mergedMetadata = { ...existingMetadata, ...metadata };
+        updateData.metadata = JSON.stringify(mergedMetadata);
+      }
+      await this.service.entities.thread.update({ entity: "thread", id }).set(updateData).go();
+      return {
+        ...existingThread,
+        title: title || existingThread.title,
+        metadata: metadata ? { ...existingThread.metadata, ...metadata } : existingThread.metadata,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_UPDATE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteThread({ threadId }) {
+    this.logger.debug("Deleting thread", { threadId });
+    try {
+      const messages = await this.getMessages({ threadId });
+      if (messages.length > 0) {
+        const batchSize = 25;
+        for (let i = 0; i < messages.length; i += batchSize) {
+          const batch = messages.slice(i, i + batchSize);
+          await Promise.all(
+            batch.map(
+              (message) => this.service.entities.message.delete({
+                entity: "message",
+                id: message.id,
+                threadId: message.threadId
+              }).go()
+            )
+          );
+        }
+      }
+      await this.service.entities.thread.delete({ entity: "thread", id: threadId }).go();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_DELETE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format
+  }) {
+    this.logger.debug("Getting messages", { threadId, selectBy });
+    try {
+      const messages = [];
+      const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      }
+      if (limit !== 0) {
+        const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
+        let results;
+        if (limit !== Number.MAX_SAFE_INTEGER && limit > 0) {
+          results = await query.go({ limit, order: "desc" });
+          results.data = results.data.reverse();
+        } else {
+          results = await query.go();
+        }
+        let allThreadMessages = results.data.map((data) => this.parseMessageData(data)).filter((msg) => "content" in msg);
+        allThreadMessages.sort((a, b) => {
+          const timeA = a.createdAt.getTime();
+          const timeB = b.createdAt.getTime();
+          if (timeA === timeB) {
+            return a.id.localeCompare(b.id);
+          }
+          return timeA - timeB;
+        });
+        messages.push(...allThreadMessages);
+      }
+      messages.sort((a, b) => {
+        const timeA = a.createdAt.getTime();
+        const timeB = b.createdAt.getTime();
+        if (timeA === timeB) {
+          return a.id.localeCompare(b.id);
+        }
+        return timeA - timeB;
+      });
+      const uniqueMessages = messages.filter(
+        (message, index, self) => index === self.findIndex((m) => m.id === message.id)
+      );
+      const list = new agent.MessageList({ threadId, resourceId }).add(uniqueMessages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveMessages(args) {
+    const { messages, format = "v1" } = args;
+    this.logger.debug("Saving messages", { count: messages.length });
+    if (!messages.length) {
+      return [];
+    }
+    const threadId = messages[0]?.threadId;
+    if (!threadId) {
+      throw new Error("Thread ID is required");
+    }
+    const messagesToSave = messages.map((msg) => {
+      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
+      };
+    });
+    try {
+      const savedMessageIds = [];
+      for (const messageData of messagesToSave) {
+        if (!messageData.entity) {
+          this.logger.error("Missing entity property in message data for create", { messageData });
+          throw new Error("Internal error: Missing entity property during saveMessages");
+        }
+        try {
+          await this.service.entities.message.put(messageData).go();
+          savedMessageIds.push(messageData.id);
+        } catch (error) {
+          for (const savedId of savedMessageIds) {
+            try {
+              await this.service.entities.message.delete({ entity: "message", id: savedId }).go();
+            } catch (rollbackError) {
+              this.logger.error("Failed to rollback message during save error", {
+                messageId: savedId,
+                error: rollbackError
+              });
+            }
+          }
+          throw error;
+        }
+      }
+      await this.service.entities.thread.update({ entity: "thread", id: threadId }).set({
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }).go();
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_SAVE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: messages.length }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page = 0, perPage = 100 } = args;
+    this.logger.debug("Getting threads by resource ID with pagination", { resourceId, page, perPage });
+    try {
+      const query = this.service.entities.thread.query.byResource({ entity: "thread", resourceId });
+      const results = await query.go();
+      const allThreads = results.data;
+      const startIndex = page * perPage;
+      const endIndex = startIndex + perPage;
+      const paginatedThreads = allThreads.slice(startIndex, endIndex);
+      const total = allThreads.length;
+      const hasMore = endIndex < total;
+      return {
+        threads: paginatedThreads,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId, page, perPage }
+        },
+        error$1
+      );
+    }
+  }
+  async getMessagesPaginated(args) {
+    const { threadId, resourceId, selectBy, format = "v1" } = args;
+    const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+    this.logger.debug("Getting messages with pagination", { threadId, page, perPage, fromDate, toDate, limit });
+    try {
+      let messages = [];
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages(threadId, selectBy);
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      }
+      if (limit !== 0) {
+        const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
+        let results;
+        if (limit !== Number.MAX_SAFE_INTEGER && limit > 0) {
+          results = await query.go({ limit, order: "desc" });
+          results.data = results.data.reverse();
+        } else {
+          results = await query.go();
+        }
+        let allThreadMessages = results.data.map((data) => this.parseMessageData(data)).filter((msg) => "content" in msg);
+        allThreadMessages.sort((a, b) => {
+          const timeA = a.createdAt.getTime();
+          const timeB = b.createdAt.getTime();
+          if (timeA === timeB) {
+            return a.id.localeCompare(b.id);
+          }
+          return timeA - timeB;
+        });
+        const excludeIds = messages.map((m) => m.id);
+        if (excludeIds.length > 0) {
+          allThreadMessages = allThreadMessages.filter((msg) => !excludeIds.includes(msg.id));
+        }
+        messages.push(...allThreadMessages);
+      }
+      messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      if (fromDate || toDate) {
+        messages = messages.filter((msg) => {
+          const createdAt = new Date(msg.createdAt).getTime();
+          if (fromDate && createdAt < new Date(fromDate).getTime()) return false;
+          if (toDate && createdAt > new Date(toDate).getTime()) return false;
+          return true;
+        });
+      }
+      const total = messages.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedMessages = messages.slice(start, end);
+      const hasMore = end < total;
+      const list = new agent.MessageList({ threadId, resourceId }).add(paginatedMessages, "memory");
+      const finalMessages = format === "v2" ? list.get.all.v2() : list.get.all.v1();
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  // Helper method to get included messages with context
+  async _getIncludedMessages(threadId, selectBy) {
+    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;
+        this.logger.debug("Getting included messages for", {
+          id,
+          targetThreadId,
+          searchThreadId,
+          withPreviousMessages,
+          withNextMessages
+        });
+        const query = this.service.entities.message.query.byThread({ entity: "message", threadId: searchThreadId });
+        const results = await query.go();
+        const allMessages = results.data.map((data) => this.parseMessageData(data)).filter((msg) => "content" in msg && typeof msg.content === "object");
+        this.logger.debug("Found messages in thread", {
+          threadId: searchThreadId,
+          messageCount: allMessages.length,
+          messageIds: allMessages.map((m) => m.id)
+        });
+        allMessages.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 targetIndex = allMessages.findIndex((msg) => msg.id === id);
+        if (targetIndex === -1) {
+          this.logger.warn("Target message not found", { id, threadId: searchThreadId });
+          continue;
+        }
+        this.logger.debug("Found target message at index", { id, targetIndex, totalMessages: allMessages.length });
+        const startIndex = Math.max(0, targetIndex - withPreviousMessages);
+        const endIndex = Math.min(allMessages.length, targetIndex + withNextMessages + 1);
+        const contextMessages = allMessages.slice(startIndex, endIndex);
+        this.logger.debug("Context messages", {
+          startIndex,
+          endIndex,
+          contextCount: contextMessages.length,
+          contextIds: contextMessages.map((m) => m.id)
+        });
+        includeMessages.push(...contextMessages);
+      } catch (error) {
+        this.logger.warn("Failed to get included message", { messageId: includeItem.id, error });
+      }
+    }
+    this.logger.debug("Total included messages", {
+      count: includeMessages.length,
+      ids: includeMessages.map((m) => m.id)
+    });
+    return includeMessages;
+  }
+  async updateMessages(args) {
+    const { messages } = args;
+    this.logger.debug("Updating messages", { count: messages.length });
+    if (!messages.length) {
+      return [];
+    }
+    const updatedMessages = [];
+    const affectedThreadIds = /* @__PURE__ */ new Set();
+    try {
+      for (const updateData of messages) {
+        const { id, ...updates } = updateData;
+        const existingMessage = await this.service.entities.message.get({ entity: "message", id }).go();
+        if (!existingMessage.data) {
+          this.logger.warn("Message not found for update", { id });
+          continue;
+        }
+        const existingMsg = this.parseMessageData(existingMessage.data);
+        const originalThreadId = existingMsg.threadId;
+        affectedThreadIds.add(originalThreadId);
+        const updatePayload = {
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if ("role" in updates && updates.role !== void 0) updatePayload.role = updates.role;
+        if ("type" in updates && updates.type !== void 0) updatePayload.type = updates.type;
+        if ("resourceId" in updates && updates.resourceId !== void 0) updatePayload.resourceId = updates.resourceId;
+        if ("threadId" in updates && updates.threadId !== void 0 && updates.threadId !== null) {
+          updatePayload.threadId = updates.threadId;
+          affectedThreadIds.add(updates.threadId);
+        }
+        if (updates.content) {
+          const existingContent = existingMsg.content;
+          let newContent = { ...existingContent };
+          if (updates.content.metadata !== void 0) {
+            newContent.metadata = {
+              ...existingContent.metadata || {},
+              ...updates.content.metadata || {}
+            };
+          }
+          if (updates.content.content !== void 0) {
+            newContent.content = updates.content.content;
+          }
+          if ("parts" in updates.content && updates.content.parts !== void 0) {
+            newContent.parts = updates.content.parts;
+          }
+          updatePayload.content = JSON.stringify(newContent);
+        }
+        await this.service.entities.message.update({ entity: "message", id }).set(updatePayload).go();
+        const updatedMessage = await this.service.entities.message.get({ entity: "message", id }).go();
+        if (updatedMessage.data) {
+          updatedMessages.push(this.parseMessageData(updatedMessage.data));
+        }
+      }
+      for (const threadId of affectedThreadIds) {
+        await this.service.entities.thread.update({ entity: "thread", id: threadId }).set({
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }).go();
+      }
+      return updatedMessages;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_UPDATE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: messages.length }
+        },
+        error$1
+      );
+    }
+  }
+  async getResourceById({ resourceId }) {
+    this.logger.debug("Getting resource by ID", { resourceId });
+    try {
+      const result = await this.service.entities.resource.get({ entity: "resource", id: resourceId }).go();
+      if (!result.data) {
+        return null;
+      }
+      const data = result.data;
+      return {
+        ...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,
+        // Ensure workingMemory is always returned as a string, regardless of automatic parsing
+        workingMemory: typeof data.workingMemory === "object" ? JSON.stringify(data.workingMemory) : data.workingMemory
+        // metadata is already transformed by the entity's getter
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_RESOURCE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveResource({ resource }) {
+    this.logger.debug("Saving resource", { resourceId: resource.id });
+    const now = /* @__PURE__ */ new Date();
+    const resourceData = {
+      entity: "resource",
+      id: resource.id,
+      workingMemory: resource.workingMemory,
+      metadata: resource.metadata ? JSON.stringify(resource.metadata) : void 0,
+      createdAt: resource.createdAt?.toISOString() || now.toISOString(),
+      updatedAt: now.toISOString()
+    };
     try {
-      if (!config.tableName || typeof config.tableName !== "string" || config.tableName.trim() === "") {
-        throw new Error("DynamoDBStore: config.tableName must be provided and cannot be empty.");
-      }
-      if (!/^[a-zA-Z0-9_.-]{3,255}$/.test(config.tableName)) {
-        throw new Error(
-          `DynamoDBStore: config.tableName "${config.tableName}" contains invalid characters or is not between 3 and 255 characters long.`
-        );
-      }
-      const dynamoClient = new clientDynamodb.DynamoDBClient({
-        region: config.region || "us-east-1",
-        endpoint: config.endpoint,
-        credentials: config.credentials
-      });
-      this.tableName = config.tableName;
-      this.client = libDynamodb.DynamoDBDocumentClient.from(dynamoClient);
-      this.service = getElectroDbService(this.client, this.tableName);
+      await this.service.entities.resource.upsert(resourceData).go();
+      return {
+        id: resource.id,
+        workingMemory: resource.workingMemory,
+        metadata: resource.metadata,
+        createdAt: resource.createdAt || now,
+        updatedAt: now
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_CONSTRUCTOR_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_SAVE_RESOURCE_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId: resource.id }
         },
         error$1
       );
     }
   }
-  /**
-   * This method is modified for DynamoDB with ElectroDB single-table design.
-   * It assumes the table is created and managed externally via CDK/CloudFormation.
-   *
-   * 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 });
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    this.logger.debug("Updating resource", { resourceId });
     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.`
-        );
+      const existingResource = await this.getResourceById({ resourceId });
+      if (!existingResource) {
+        const newResource = {
+          id: resourceId,
+          workingMemory,
+          metadata: metadata || {},
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        return this.saveResource({ resource: newResource });
       }
-      this.logger.debug(`Table ${this.tableName} exists and is accessible`);
+      const now = /* @__PURE__ */ new Date();
+      const updateData = {
+        updatedAt: now.toISOString()
+      };
+      if (workingMemory !== void 0) {
+        updateData.workingMemory = workingMemory;
+      }
+      if (metadata) {
+        const existingMetadata = existingResource.metadata || {};
+        const mergedMetadata = { ...existingMetadata, ...metadata };
+        updateData.metadata = JSON.stringify(mergedMetadata);
+      }
+      await this.service.entities.resource.update({ entity: "resource", id: resourceId }).set(updateData).go();
+      return {
+        ...existingResource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+        metadata: metadata ? { ...existingResource.metadata, ...metadata } : existingResource.metadata,
+        updatedAt: now
+      };
     } catch (error$1) {
-      this.logger.error("Error validating table access", { tableName: this.tableName, error: error$1 });
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_VALIDATE_TABLE_ACCESS_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_UPDATE_RESOURCE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName: this.tableName }
+          details: { resourceId }
         },
         error$1
       );
     }
   }
+};
+var StoreOperationsDynamoDB = class extends storage.StoreOperations {
+  client;
+  tableName;
+  service;
+  constructor({
+    service,
+    tableName,
+    client
+  }) {
+    super();
+    this.service = service;
+    this.client = client;
+    this.tableName = tableName;
+  }
+  async hasColumn() {
+    return true;
+  }
+  async dropTable() {
+  }
+  // Helper methods for entity/table mapping
+  getEntityNameForTable(tableName) {
+    const mapping = {
+      [storage.TABLE_THREADS]: "thread",
+      [storage.TABLE_MESSAGES]: "message",
+      [storage.TABLE_WORKFLOW_SNAPSHOT]: "workflow_snapshot",
+      [storage.TABLE_EVALS]: "eval",
+      [storage.TABLE_SCORERS]: "score",
+      [storage.TABLE_TRACES]: "trace",
+      [storage.TABLE_RESOURCES]: "resource"
+    };
+    return mapping[tableName] || null;
+  }
+  /**
+   * 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
@@ -656,20 +1834,30 @@ var DynamoDBStore = class extends storage.MastraStorage {
     }
   }
   /**
-   * Initialize storage, validating the externally managed table is accessible.
-   * For the single-table design, we only validate once that we can access
-   * the table that was created via CDK/CloudFormation.
+   * This method is modified for DynamoDB with ElectroDB single-table design.
+   * It assumes the table is created and managed externally via CDK/CloudFormation.
+   *
+   * 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 init() {
-    if (this.hasInitialized === null) {
-      this.hasInitialized = this._performInitializationAndStore();
-    }
+  async createTable({ tableName }) {
+    this.logger.debug("Validating access to externally managed table", { tableName, physicalTable: this.tableName });
     try {
-      await this.hasInitialized;
+      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$1) {
+      this.logger.error("Error validating table access", { tableName: this.tableName, error: error$1 });
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_INIT_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_VALIDATE_TABLE_ACCESS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { tableName: this.tableName }
@@ -678,39 +1866,32 @@ var DynamoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  /**
-   * Performs the actual table validation and stores the promise.
-   * Handles resetting the stored promise on failure to allow retries.
-   */
-  _performInitializationAndStore() {
-    return this.validateTableExists().then((exists) => {
-      if (!exists) {
-        throw new Error(
-          `Table ${this.tableName} does not exist or is not accessible. Ensure it's created via CDK/CloudFormation before using this store.`
-        );
-      }
-      return true;
-    }).catch((err) => {
-      this.hasInitialized = null;
-      throw err;
-    });
-  }
-  /**
-   * 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();
+  async insert({ tableName, record }) {
+    this.logger.debug("DynamoDB insert called", { tableName });
+    const entityName = this.getEntityNameForTable(tableName);
+    if (!entityName || !this.service.entities[entityName]) {
+      throw new error.MastraError({
+        id: "STORAGE_DYNAMODB_STORE_INSERT_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "No entity defined for tableName",
+        details: { tableName }
+      });
     }
-    if (processed.created_at instanceof Date) {
-      processed.created_at = processed.created_at.toISOString();
+    try {
+      const dataToSave = { entity: entityName, ...this.preprocessRecord(record) };
+      await this.service.entities[entityName].create(dataToSave).go();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
     }
-    return processed;
   }
   async alterTable(_args) {
   }
@@ -747,10 +1928,10 @@ var DynamoDBStore = class extends storage.MastraStorage {
             if (!item.id) throw new Error(`Missing required key 'id' for entity 'message'`);
             key.id = item.id;
             break;
-          case "workflowSnapshot":
+          case "workflow_snapshot":
             if (!item.workflow_name)
-              throw new Error(`Missing required key 'workflow_name' for entity 'workflowSnapshot'`);
-            if (!item.run_id) throw new Error(`Missing required key 'run_id' for entity 'workflowSnapshot'`);
+              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;
@@ -758,59 +1939,30 @@ var DynamoDBStore = class extends storage.MastraStorage {
             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;
-          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$1) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_CLEAR_TABLE_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Insert a record into the specified "table" (entity)
-   */
-  async insert({
-    tableName,
-    record
-  }) {
-    this.logger.debug("DynamoDB insert called", { tableName });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new error.MastraError({
-        id: "STORAGE_DYNAMODB_STORE_INSERT_INVALID_ARGS",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
+          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;
       });
-    }
-    try {
-      const dataToSave = { entity: entityName, ...this.preprocessRecord(record) };
-      await this.service.entities[entityName].create(dataToSave).go();
+      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$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_INSERT_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_CLEAR_TABLE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { tableName }
@@ -822,10 +1974,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
   /**
    * Insert multiple records as a batch
    */
-  async batchInsert({
-    tableName,
-    records
-  }) {
+  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]) {
@@ -870,10 +2019,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
   /**
    * Load a record by its keys
    */
-  async load({
-    tableName,
-    keys
-  }) {
+  async load({ tableName, keys }) {
     this.logger.debug("DynamoDB load called", { tableName, keys });
     const entityName = this.getEntityNameForTable(tableName);
     if (!entityName || !this.service.entities[entityName]) {
@@ -905,268 +2051,227 @@ var DynamoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  // Thread operations
-  async getThreadById({ threadId }) {
-    this.logger.debug("Getting thread by ID", { threadId });
+};
+var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
+  service;
+  constructor({ service }) {
+    super();
+    this.service = service;
+  }
+  // Helper function to parse score data (handle JSON fields)
+  parseScoreData(data) {
+    return {
+      ...data,
+      // Convert date strings back to Date objects for consistency
+      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 }) {
+    this.logger.debug("Getting score by ID", { id });
     try {
-      const result = await this.service.entities.thread.get({ entity: "thread", id: threadId }).go();
+      const result = await this.service.entities.score.get({ entity: "score", id }).go();
       if (!result.data) {
         return null;
       }
-      const data = result.data;
-      return {
-        ...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
-        // metadata: data.metadata ? JSON.parse(data.metadata) : undefined, // REMOVED by AI
-        // metadata is already transformed by the entity's getter
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_GET_THREAD_BY_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
-        },
-        error$1
-      );
-    }
-  }
-  async getThreadsByResourceId({ resourceId }) {
-    this.logger.debug("Getting threads by resource ID", { resourceId });
-    try {
-      const result = await this.service.entities.thread.query.byResource({ entity: "thread", resourceId }).go();
-      if (!result.data.length) {
-        return [];
-      }
-      return result.data.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
-        // metadata: data.metadata ? JSON.parse(data.metadata) : undefined, // REMOVED by AI
-        // metadata is already transformed by the entity's getter
-      }));
+      return this.parseScoreData(result.data);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_GET_SCORE_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
+          details: { id }
         },
         error$1
       );
     }
   }
-  async saveThread({ thread }) {
-    this.logger.debug("Saving thread", { threadId: thread.id });
+  async saveScore(score) {
+    this.logger.debug("Saving score", { scorerId: score.scorerId, runId: score.runId });
     const now = /* @__PURE__ */ new Date();
-    const threadData = {
-      entity: "thread",
-      id: thread.id,
-      resourceId: thread.resourceId,
-      title: thread.title || `Thread ${thread.id}`,
-      createdAt: thread.createdAt?.toISOString() || now.toISOString(),
-      updatedAt: now.toISOString(),
-      metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0
+    const scoreId = `score-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const scoreData = {
+      entity: "score",
+      id: scoreId,
+      scorerId: score.scorerId,
+      traceId: score.traceId || "",
+      runId: score.runId,
+      scorer: typeof score.scorer === "string" ? score.scorer : JSON.stringify(score.scorer),
+      extractStepResult: typeof score.extractStepResult === "string" ? score.extractStepResult : JSON.stringify(score.extractStepResult),
+      analyzeStepResult: typeof score.analyzeStepResult === "string" ? score.analyzeStepResult : JSON.stringify(score.analyzeStepResult),
+      score: score.score,
+      reason: score.reason,
+      extractPrompt: score.extractPrompt,
+      analyzePrompt: score.analyzePrompt,
+      reasonPrompt: score.reasonPrompt,
+      input: typeof score.input === "string" ? score.input : JSON.stringify(score.input),
+      output: typeof score.output === "string" ? score.output : JSON.stringify(score.output),
+      additionalContext: typeof score.additionalContext === "string" ? score.additionalContext : JSON.stringify(score.additionalContext),
+      runtimeContext: typeof score.runtimeContext === "string" ? score.runtimeContext : JSON.stringify(score.runtimeContext),
+      entityType: score.entityType,
+      entityData: typeof score.entity === "string" ? score.entity : JSON.stringify(score.entity),
+      entityId: score.entityId,
+      source: score.source,
+      resourceId: score.resourceId || "",
+      threadId: score.threadId || "",
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString()
     };
     try {
-      await this.service.entities.thread.upsert(threadData).go();
-      return {
-        id: thread.id,
-        resourceId: thread.resourceId,
-        title: threadData.title,
-        createdAt: thread.createdAt || now,
-        updatedAt: now,
-        metadata: thread.metadata
+      await this.service.entities.score.upsert(scoreData).go();
+      const savedScore = {
+        ...score,
+        id: scoreId,
+        createdAt: now,
+        updatedAt: now
       };
+      return { score: savedScore };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_SAVE_THREAD_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_SAVE_SCORE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId: thread.id }
+          details: { scorerId: score.scorerId, runId: score.runId }
         },
         error$1
       );
     }
   }
-  async updateThread({
-    id,
-    title,
-    metadata
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType
   }) {
-    this.logger.debug("Updating thread", { threadId: id });
+    this.logger.debug("Getting scores by scorer ID", { scorerId, pagination, entityId, entityType });
     try {
-      const existingThread = await this.getThreadById({ threadId: id });
-      if (!existingThread) {
-        throw new Error(`Thread not found: ${id}`);
-      }
-      const now = /* @__PURE__ */ new Date();
-      const updateData = {
-        updatedAt: now.toISOString()
-      };
-      if (title) {
-        updateData.title = title;
+      const query = this.service.entities.score.query.byScorer({ entity: "score", scorerId });
+      const results = await query.go();
+      let allScores = results.data.map((data) => this.parseScoreData(data));
+      if (entityId) {
+        allScores = allScores.filter((score) => score.entityId === entityId);
       }
-      if (metadata) {
-        updateData.metadata = JSON.stringify(metadata);
+      if (entityType) {
+        allScores = allScores.filter((score) => score.entityType === entityType);
       }
-      await this.service.entities.thread.update({ entity: "thread", id }).set(updateData).go();
+      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 total = allScores.length;
+      const hasMore = endIndex < total;
       return {
-        ...existingThread,
-        title: title || existingThread.title,
-        metadata: metadata || existingThread.metadata,
-        updatedAt: now
+        scores: paginatedScores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
+        }
       };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_UPDATE_THREAD_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId: id }
+          details: {
+            scorerId: scorerId || "",
+            entityId: entityId || "",
+            entityType: entityType || "",
+            page: pagination.page,
+            perPage: pagination.perPage
+          }
         },
         error$1
       );
     }
   }
-  async deleteThread({ threadId }) {
-    this.logger.debug("Deleting thread", { threadId });
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    this.logger.debug("Getting scores by run ID", { runId, pagination });
     try {
-      await this.service.entities.thread.delete({ entity: "thread", id: threadId }).go();
+      const query = this.service.entities.score.query.byRun({ entity: "score", runId });
+      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 total = allScores.length;
+      const hasMore = endIndex < total;
+      return {
+        scores: paginatedScores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
+        }
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_DELETE_THREAD_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_GET_SCORES_BY_RUN_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { runId, page: pagination.page, perPage: pagination.perPage }
         },
         error$1
       );
     }
   }
-  async getMessages({
-    threadId,
-    resourceId,
-    selectBy,
-    format
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
   }) {
-    this.logger.debug("Getting messages", { threadId, selectBy });
+    this.logger.debug("Getting scores by entity ID", { entityId, entityType, pagination });
     try {
-      const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
-      if (limit !== Number.MAX_SAFE_INTEGER) {
-        const results2 = await query.go({ limit, order: "desc" });
-        const list2 = new agent.MessageList({ threadId, resourceId }).add(
-          results2.data.map((data) => this.parseMessageData(data)),
-          "memory"
-        );
-        if (format === `v2`) return list2.get.all.v2();
-        return list2.get.all.v1();
-      }
+      const query = this.service.entities.score.query.byEntityData({ entity: "score", entityId });
       const results = await query.go();
-      const list = new agent.MessageList({ threadId, resourceId }).add(
-        results.data.map((data) => this.parseMessageData(data)),
-        "memory"
-      );
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
-        },
-        error$1
-      );
-    }
-  }
-  async saveMessages(args) {
-    const { messages, format = "v1" } = args;
-    this.logger.debug("Saving messages", { count: messages.length });
-    if (!messages.length) {
-      return [];
-    }
-    const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      throw new Error("Thread ID is required");
-    }
-    const messagesToSave = messages.map((msg) => {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
+      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 total = allScores.length;
+      const hasMore = endIndex < total;
       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
+        scores: paginatedScores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
+        }
       };
-    });
-    try {
-      const batchSize = 25;
-      const batches = [];
-      for (let i = 0; i < messagesToSave.length; i += batchSize) {
-        const batch = messagesToSave.slice(i, i + batchSize);
-        batches.push(batch);
-      }
-      await Promise.all([
-        // Process message batches
-        ...batches.map(async (batch) => {
-          for (const messageData of batch) {
-            if (!messageData.entity) {
-              this.logger.error("Missing entity property in message data for create", { messageData });
-              throw new Error("Internal error: Missing entity property during saveMessages");
-            }
-            await this.service.entities.message.put(messageData).go();
-          }
-        }),
-        // Update thread's updatedAt timestamp
-        this.service.entities.thread.update({ entity: "thread", id: threadId }).set({
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).go()
-      ]);
-      const list = new agent.MessageList().add(messages, "memory");
-      if (format === `v1`) return list.get.all.v1();
-      return list.get.all.v2();
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_SAVE_MESSAGES_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { count: messages.length }
+          details: { entityId, entityType, page: pagination.page, perPage: pagination.perPage }
         },
         error$1
       );
     }
   }
-  // Helper function to parse message data (handle JSON fields)
-  parseMessageData(data) {
-    return {
-      ...data,
-      // Ensure dates are Date objects if needed (ElectroDB might return strings)
-      createdAt: data.createdAt ? new Date(data.createdAt) : void 0,
-      updatedAt: data.updatedAt ? new Date(data.updatedAt) : void 0
-      // Other fields like content, toolCallArgs etc. are assumed to be correctly
-      // transformed by the ElectroDB entity getters.
-    };
+};
+var TracesStorageDynamoDB = class extends storage.TracesStorage {
+  service;
+  operations;
+  constructor({ service, operations }) {
+    super();
+    this.service = service;
+    this.operations = operations;
   }
   // Trace operations
   async getTraces(args) {
@@ -1217,7 +2322,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
     }
     try {
       const recordsToSave = records.map((rec) => ({ entity: "trace", ...rec }));
-      await this.batchInsert({
+      await this.operations.batchInsert({
         tableName: storage.TABLE_TRACES,
         records: recordsToSave
         // Pass records with 'entity' included
@@ -1225,15 +2330,190 @@ var DynamoDBStore = class extends storage.MastraStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_BATCH_TRACE_INSERT_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_BATCH_TRACE_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: records.length }
+        },
+        error$1
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    this.logger.debug("Getting traces with pagination", { name, scope, page, perPage, attributes, filters, dateRange });
+    try {
+      let query;
+      if (name) {
+        query = this.service.entities.trace.query.byName({ entity: "trace", name });
+      } else if (scope) {
+        query = this.service.entities.trace.query.byScope({ entity: "trace", scope });
+      } else {
+        this.logger.warn("Performing a scan operation on traces - consider using a more specific query");
+        query = this.service.entities.trace.scan;
+      }
+      const results = await query.go({
+        order: "desc",
+        pages: "all"
+        // Get all pages to apply filtering and pagination
+      });
+      if (!results.data.length) {
+        return {
+          traces: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      let filteredData = results.data;
+      if (attributes) {
+        filteredData = filteredData.filter((item) => {
+          try {
+            let itemAttributes = {};
+            if (item.attributes) {
+              if (typeof item.attributes === "string") {
+                if (item.attributes === "[object Object]") {
+                  itemAttributes = {};
+                } else {
+                  try {
+                    itemAttributes = JSON.parse(item.attributes);
+                  } catch {
+                    itemAttributes = {};
+                  }
+                }
+              } else if (typeof item.attributes === "object") {
+                itemAttributes = item.attributes;
+              }
+            }
+            return Object.entries(attributes).every(([key, value]) => itemAttributes[key] === value);
+          } catch (e) {
+            this.logger.warn("Failed to parse attributes during filtering", { item, error: e });
+            return false;
+          }
+        });
+      }
+      if (dateRange?.start) {
+        filteredData = filteredData.filter((item) => {
+          const itemDate = new Date(item.createdAt);
+          return itemDate >= dateRange.start;
+        });
+      }
+      if (dateRange?.end) {
+        filteredData = filteredData.filter((item) => {
+          const itemDate = new Date(item.createdAt);
+          return itemDate <= dateRange.end;
+        });
+      }
+      const total = filteredData.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedData = filteredData.slice(start, end);
+      const traces = paginatedData.map((item) => {
+        let attributes2;
+        if (item.attributes) {
+          if (typeof item.attributes === "string") {
+            if (item.attributes === "[object Object]") {
+              attributes2 = void 0;
+            } else {
+              try {
+                attributes2 = JSON.parse(item.attributes);
+              } catch {
+                attributes2 = void 0;
+              }
+            }
+          } else if (typeof item.attributes === "object") {
+            attributes2 = item.attributes;
+          }
+        }
+        let status;
+        if (item.status) {
+          if (typeof item.status === "string") {
+            try {
+              status = JSON.parse(item.status);
+            } catch {
+              status = void 0;
+            }
+          } else if (typeof item.status === "object") {
+            status = item.status;
+          }
+        }
+        let events;
+        if (item.events) {
+          if (typeof item.events === "string") {
+            try {
+              events = JSON.parse(item.events);
+            } catch {
+              events = void 0;
+            }
+          } else if (Array.isArray(item.events)) {
+            events = item.events;
+          }
+        }
+        let links;
+        if (item.links) {
+          if (typeof item.links === "string") {
+            try {
+              links = JSON.parse(item.links);
+            } catch {
+              links = void 0;
+            }
+          } else if (Array.isArray(item.links)) {
+            links = item.links;
+          }
+        }
+        return {
+          id: item.id,
+          parentSpanId: item.parentSpanId,
+          name: item.name,
+          traceId: item.traceId,
+          scope: item.scope,
+          kind: item.kind,
+          attributes: attributes2,
+          status,
+          events,
+          links,
+          other: item.other,
+          startTime: item.startTime,
+          endTime: item.endTime,
+          createdAt: item.createdAt
+        };
+      });
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: end < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_TRACES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { count: records.length }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
+};
+function formatWorkflowRun(snapshotData) {
+  return {
+    workflowName: snapshotData.workflow_name,
+    runId: snapshotData.run_id,
+    snapshot: snapshotData.snapshot,
+    createdAt: new Date(snapshotData.createdAt),
+    updatedAt: new Date(snapshotData.updatedAt),
+    resourceId: snapshotData.resourceId
+  };
+}
+var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
+  service;
+  constructor({ service }) {
+    super();
+    this.service = service;
+  }
   // Workflow operations
   async persistWorkflowSnapshot({
     workflowName,
@@ -1255,7 +2535,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
         updatedAt: now,
         resourceId
       };
-      await this.service.entities.workflowSnapshot.upsert(data).go();
+      await this.service.entities.workflow_snapshot.upsert(data).go();
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1274,7 +2554,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
   }) {
     this.logger.debug("Loading workflow snapshot", { workflowName, runId });
     try {
-      const result = await this.service.entities.workflowSnapshot.get({
+      const result = await this.service.entities.workflow_snapshot.get({
         entity: "workflow_snapshot",
         // Add entity type
         workflow_name: workflowName,
@@ -1303,14 +2583,14 @@ var DynamoDBStore = class extends storage.MastraStorage {
       const offset = args?.offset || 0;
       let query;
       if (args?.workflowName) {
-        query = this.service.entities.workflowSnapshot.query.primary({
+        query = this.service.entities.workflow_snapshot.query.primary({
           entity: "workflow_snapshot",
           // Add entity type
           workflow_name: args.workflowName
         });
       } else {
         this.logger.warn("Performing a scan operation on workflow snapshots - consider using a more specific query");
-        query = this.service.entities.workflowSnapshot.scan;
+        query = this.service.entities.workflow_snapshot.scan;
       }
       const allMatchingSnapshots = [];
       let cursor = null;
@@ -1348,7 +2628,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
       }
       const total = allMatchingSnapshots.length;
       const paginatedData = allMatchingSnapshots.slice(offset, offset + limit);
-      const runs = paginatedData.map((snapshot) => this.formatWorkflowRun(snapshot));
+      const runs = paginatedData.map((snapshot) => formatWorkflowRun(snapshot));
       return {
         runs,
         total
@@ -1368,15 +2648,18 @@ var DynamoDBStore = class extends storage.MastraStorage {
   async getWorkflowRunById(args) {
     const { runId, workflowName } = args;
     this.logger.debug("Getting workflow run by ID", { runId, workflowName });
+    console.log("workflowName", workflowName);
+    console.log("runId", runId);
     try {
       if (workflowName) {
         this.logger.debug("WorkflowName provided, using direct GET operation.");
-        const result2 = await this.service.entities.workflowSnapshot.get({
+        const result2 = await this.service.entities.workflow_snapshot.get({
           entity: "workflow_snapshot",
           // Entity type for PK
           workflow_name: workflowName,
           run_id: runId
         }).go();
+        console.log("result", result2);
         if (!result2.data) {
           return null;
         }
@@ -1393,7 +2676,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
       this.logger.debug(
         'WorkflowName not provided. Attempting to find workflow run by runId using GSI. Ensure GSI (e.g., "byRunId") is defined on the workflowSnapshot entity with run_id as its key and provisioned in DynamoDB.'
       );
-      const result = await this.service.entities.workflowSnapshot.query.gsi2({ entity: "workflow_snapshot", run_id: runId }).go();
+      const result = await this.service.entities.workflow_snapshot.query.gsi2({ entity: "workflow_snapshot", run_id: runId }).go();
       const matchingRunDbItem = result.data && result.data.length > 0 ? result.data[0] : null;
       if (!matchingRunDbItem) {
         return null;
@@ -1419,121 +2702,247 @@ var DynamoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  // Helper function to format workflow run
-  formatWorkflowRun(snapshotData) {
-    return {
-      workflowName: snapshotData.workflow_name,
-      runId: snapshotData.run_id,
-      snapshot: snapshotData.snapshot,
-      createdAt: new Date(snapshotData.createdAt),
-      updatedAt: new Date(snapshotData.updatedAt),
-      resourceId: snapshotData.resourceId
-    };
+};
+
+// src/storage/index.ts
+var DynamoDBStore = class extends storage.MastraStorage {
+  tableName;
+  client;
+  service;
+  hasInitialized = null;
+  stores;
+  constructor({ name, config }) {
+    super({ name });
+    try {
+      if (!config.tableName || typeof config.tableName !== "string" || config.tableName.trim() === "") {
+        throw new Error("DynamoDBStore: config.tableName must be provided and cannot be empty.");
+      }
+      if (!/^[a-zA-Z0-9_.-]{3,255}$/.test(config.tableName)) {
+        throw new Error(
+          `DynamoDBStore: config.tableName "${config.tableName}" contains invalid characters or is not between 3 and 255 characters long.`
+        );
+      }
+      const dynamoClient = new clientDynamodb.DynamoDBClient({
+        region: config.region || "us-east-1",
+        endpoint: config.endpoint,
+        credentials: config.credentials
+      });
+      this.tableName = config.tableName;
+      this.client = libDynamodb.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 });
+      this.stores = {
+        operations,
+        legacyEvals: new LegacyEvalsDynamoDB({ service: this.service, tableName: this.tableName }),
+        traces,
+        workflows,
+        memory,
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_CONSTRUCTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
   }
-  // Helper methods for entity/table mapping
-  getEntityNameForTable(tableName) {
-    const mapping = {
-      [storage.TABLE_THREADS]: "thread",
-      [storage.TABLE_MESSAGES]: "message",
-      [storage.TABLE_WORKFLOW_SNAPSHOT]: "workflowSnapshot",
-      [storage.TABLE_EVALS]: "eval",
-      [storage.TABLE_TRACES]: "trace"
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: false,
+      createTable: false
     };
-    return mapping[tableName] || null;
   }
-  // Eval operations
-  async getEvalsByAgentName(agentName, type) {
-    this.logger.debug("Getting evals for agent", { agentName, type });
+  /**
+   * 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 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
-          };
-        }
+      const command = new clientDynamodb.DescribeTableCommand({
+        TableName: this.tableName
       });
+      await this.client.send(command);
+      return true;
+    } catch (error$1) {
+      if (error$1.name === "ResourceNotFoundException") {
+        return false;
+      }
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_VALIDATE_TABLE_EXISTS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName: this.tableName }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Initialize storage, validating the externally managed table is accessible.
+   * For the single-table design, we only validate once that we can access
+   * the table that was created via CDK/CloudFormation.
+   */
+  async init() {
+    if (this.hasInitialized === null) {
+      this.hasInitialized = this._performInitializationAndStore();
+    }
+    try {
+      await this.hasInitialized;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_DYNAMODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          id: "STORAGE_DYNAMODB_STORE_INIT_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentName }
+          details: { tableName: this.tableName }
         },
         error$1
       );
     }
   }
+  /**
+   * Performs the actual table validation and stores the promise.
+   * Handles resetting the stored promise on failure to allow retries.
+   */
+  _performInitializationAndStore() {
+    return this.validateTableExists().then((exists) => {
+      if (!exists) {
+        throw new Error(
+          `Table ${this.tableName} does not exist or is not accessible. Ensure it's created via CDK/CloudFormation before using this store.`
+        );
+      }
+      return true;
+    }).catch((err) => {
+      this.hasInitialized = null;
+      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({ resourceId }) {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
+  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 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) {
-    throw new error.MastraError(
-      {
-        id: "STORAGE_DYNAMODB_STORE_GET_TRACES_PAGINATED_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY
-      },
-      new Error("Method not implemented.")
-    );
+    return this.stores.traces.getTracesPaginated(_args);
   }
-  async getThreadsByResourceIdPaginated(_args) {
-    throw new error.MastraError(
-      {
-        id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY
-      },
-      new Error("Method not implemented.")
-    );
+  // Workflow operations
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
   }
-  async getMessagesPaginated(_args) {
-    throw new error.MastraError(
-      {
-        id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY
-      },
-      new Error("Method not implemented.")
-    );
+  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.
@@ -1555,9 +2964,37 @@ var DynamoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  async updateMessages(_args) {
-    this.logger.error("updateMessages is not yet implemented in DynamoDBStore");
-    throw new Error("Method not implemented");
+  /**
+   * 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: _scorerId,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination });
   }
 };