@mastra/dynamodb 0.0.0-new-scorer-api-20250801075530 → 0.0.0-partial-response-backport-20251204204441

package/README.md

@@ -138,7 +138,3 @@ This implementation uses a single-table design pattern with ElectroDB, which off
 3. **Simplified administration**: Only one table to monitor and back up
 4. **Reduced complexity**: Consistent access patterns across entities
 5. **Transaction support**: Atomic operations across different entity types
-
-## License
-
-MIT

package/dist/entities/index.d.ts

@@ -534,6 +534,10 @@ export declare function getElectroDbService(client: DynamoDBDocumentClient, tabl
                 type: "string";
                 required: false;
             };
+            spanId: {
+                type: "string";
+                required: false;
+            };
             runId: {
                 type: "string";
                 required: true;
@@ -550,6 +554,10 @@ export declare function getElectroDbService(client: DynamoDBDocumentClient, tabl
                 set: (value?: Record<string, unknown> | string) => string | undefined;
                 get: (value?: string) => any;
             };
+            preprocessPrompt: {
+                type: "string";
+                required: false;
+            };
             preprocessStepResult: {
                 type: "string";
                 required: false;
@@ -740,6 +748,17 @@ export declare function getElectroDbService(client: DynamoDBDocumentClient, tabl
                     composite: "createdAt"[];
                 };
             };
+            bySpan: {
+                index: string;
+                pk: {
+                    field: string;
+                    composite: ("entity" | "traceId" | "spanId")[];
+                };
+                sk: {
+                    field: string;
+                    composite: "createdAt"[];
+                };
+            };
         };
     }>;
 }>;

package/dist/entities/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entities/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,sBAAsB,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgBpF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entities/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,sBAAsB,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgBpF"}

package/dist/entities/score.d.ts

@@ -18,6 +18,10 @@ export declare const scoreEntity: Entity<string, string, string, {
             type: "string";
             required: false;
         };
+        spanId: {
+            type: "string";
+            required: false;
+        };
         runId: {
             type: "string";
             required: true;
@@ -34,6 +38,10 @@ export declare const scoreEntity: Entity<string, string, string, {
             set: (value?: Record<string, unknown> | string) => string | undefined;
             get: (value?: string) => any;
         };
+        preprocessPrompt: {
+            type: "string";
+            required: false;
+        };
         preprocessStepResult: {
             type: "string";
             required: false;
@@ -224,6 +232,17 @@ export declare const scoreEntity: Entity<string, string, string, {
                 composite: "createdAt"[];
             };
         };
+        bySpan: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "traceId" | "spanId")[];
+            };
+            sk: {
+                field: string;
+                composite: "createdAt"[];
+            };
+        };
     };
 }>;
 //# sourceMappingURL=score.d.ts.map

package/dist/entities/score.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"score.d.ts","sourceRoot":"","sources":["../../src/entities/score.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGnC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;0BA+BJ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA8CN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;;;;;0BAoBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkExB,CAAC"}
+{"version":3,"file":"score.d.ts","sourceRoot":"","sources":["../../src/entities/score.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGnC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAmCJ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;;;;;0BAoBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA8CN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;0BAgBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;;;;;0BAoBN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;0BAMhC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuExB,CAAC"}

package/dist/index.cjs

@@ -6,6 +6,7 @@ var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
 var electrodb = require('electrodb');
 var agent = require('@mastra/core/agent');
+var scores = require('@mastra/core/scores');
 
 // src/storage/index.ts
 
@@ -372,6 +373,10 @@ var scoreEntity = new electrodb.Entity({
       type: "string",
       required: false
     },
+    spanId: {
+      type: "string",
+      required: false
+    },
     runId: {
       type: "string",
       required: true
@@ -420,6 +425,10 @@ var scoreEntity = new electrodb.Entity({
         return value;
       }
     },
+    preprocessPrompt: {
+      type: "string",
+      required: false
+    },
     preprocessStepResult: {
       type: "string",
       required: false,
@@ -658,6 +667,11 @@ var scoreEntity = new electrodb.Entity({
       index: "gsi6",
       pk: { field: "gsi6pk", composite: ["entity", "threadId"] },
       sk: { field: "gsi6sk", composite: ["createdAt"] }
+    },
+    bySpan: {
+      index: "gsi7",
+      pk: { field: "gsi7pk", composite: ["entity", "traceId", "spanId"] },
+      sk: { field: "gsi7sk", composite: ["createdAt"] }
     }
   }
 });
@@ -1123,6 +1137,20 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       // transformed by the ElectroDB entity getters.
     };
   }
+  // Helper function to transform and sort threads
+  transformAndSortThreads(rawThreads, orderBy, sortDirection) {
+    return rawThreads.map((data) => ({
+      ...data,
+      // Convert date strings back to Date objects for consistency
+      createdAt: typeof data.createdAt === "string" ? new Date(data.createdAt) : data.createdAt,
+      updatedAt: typeof data.updatedAt === "string" ? new Date(data.updatedAt) : data.updatedAt
+    })).sort((a, b) => {
+      const fieldA = orderBy === "createdAt" ? a.createdAt : a.updatedAt;
+      const fieldB = orderBy === "createdAt" ? b.createdAt : b.updatedAt;
+      const comparison = fieldA.getTime() - fieldB.getTime();
+      return sortDirection === "DESC" ? -comparison : comparison;
+    });
+  }
   async getThreadById({ threadId }) {
     this.logger.debug("Getting thread by ID", { threadId });
     try {
@@ -1151,21 +1179,20 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       );
     }
   }
-  async getThreadsByResourceId({ resourceId }) {
-    this.logger.debug("Getting threads by resource ID", { resourceId });
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+   */
+  async getThreadsByResourceId(args) {
+    const resourceId = args.resourceId;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
+    this.logger.debug("Getting threads by resource ID", { resourceId, orderBy, sortDirection });
     try {
       const result = await this.service.entities.thread.query.byResource({ entity: "thread", resourceId }).go();
       if (!result.data.length) {
         return [];
       }
-      return 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.transformAndSortThreads(result.data, orderBy, sortDirection);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1187,7 +1214,7 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       resourceId: thread.resourceId,
       title: thread.title || `Thread ${thread.id}`,
       createdAt: thread.createdAt?.toISOString() || now.toISOString(),
-      updatedAt: now.toISOString(),
+      updatedAt: thread.updatedAt?.toISOString() || now.toISOString(),
       metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0
     };
     try {
@@ -1294,6 +1321,7 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
   }) {
     this.logger.debug("Getting messages", { threadId, selectBy });
     try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
       const messages = [];
       const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
       if (selectBy?.include?.length) {
@@ -1342,7 +1370,37 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
           id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { threadId, resourceId: resourceId ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    this.logger.debug("Getting messages by ID", { messageIds });
+    if (messageIds.length === 0) return [];
+    try {
+      const results = await Promise.all(
+        messageIds.map((id) => this.service.entities.message.query.primary({ entity: "message", id }).go())
+      );
+      const data = results.map((result) => result.data).flat(1);
+      let parsedMessages = data.map((data2) => this.parseMessageData(data2)).filter((msg) => "content" in msg);
+      const uniqueMessages = parsedMessages.filter(
+        (message, index, self) => index === self.findIndex((m) => m.id === message.id)
+      );
+      const list = new agent.MessageList().add(uniqueMessages, "memory");
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error$1
       );
@@ -1422,11 +1480,19 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
   }
   async getThreadsByResourceIdPaginated(args) {
     const { resourceId, page = 0, perPage = 100 } = args;
-    this.logger.debug("Getting threads by resource ID with pagination", { resourceId, page, perPage });
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
+    this.logger.debug("Getting threads by resource ID with pagination", {
+      resourceId,
+      page,
+      perPage,
+      orderBy,
+      sortDirection
+    });
     try {
       const query = this.service.entities.thread.query.byResource({ entity: "thread", resourceId });
       const results = await query.go();
-      const allThreads = results.data;
+      const allThreads = this.transformAndSortThreads(results.data, orderBy, sortDirection);
       const startIndex = page * perPage;
       const endIndex = startIndex + perPage;
       const paginatedThreads = allThreads.slice(startIndex, endIndex);
@@ -1459,6 +1525,7 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
     const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
     this.logger.debug("Getting messages with pagination", { threadId, page, perPage, fromDate, toDate, limit });
     try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
       let messages = [];
       if (selectBy?.include?.length) {
         const includeMessages = await this._getIncludedMessages(threadId, selectBy);
@@ -1505,7 +1572,8 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       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();
+      let finalMessages = format === "v2" ? list.get.all.v2() : list.get.all.v1();
+      finalMessages = finalMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
       return {
         messages: finalMessages,
         total,
@@ -1514,19 +1582,23 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
         hasMore
       };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
           id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { threadId, resourceId: resourceId ?? "" }
         },
         error$1
       );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      return { messages: [], total: 0, page, perPage, hasMore: false };
     }
   }
   // Helper method to get included messages with context
   async _getIncludedMessages(threadId, selectBy) {
+    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
     if (!selectBy?.include?.length) {
       return [];
     }
@@ -1793,7 +1865,8 @@ var StoreOperationsDynamoDB = class extends storage.StoreOperations {
       [storage.TABLE_EVALS]: "eval",
       [storage.TABLE_SCORERS]: "score",
       [storage.TABLE_TRACES]: "trace",
-      [storage.TABLE_RESOURCES]: "resource"
+      [storage.TABLE_RESOURCES]: "resource",
+      [storage.TABLE_AI_SPANS]: "ai_span"
     };
     return mapping[tableName] || null;
   }
@@ -2091,8 +2164,17 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
   }
   // Helper function to parse score data (handle JSON fields)
   parseScoreData(data) {
+    const result = {};
+    for (const key of Object.keys(storage.SCORERS_SCHEMA)) {
+      if (["traceId", "resourceId", "threadId", "spanId"].includes(key)) {
+        result[key] = data[key] === "" ? null : data[key];
+        continue;
+      }
+      result[key] = data[key];
+    }
+    result.entity = data.entityData ? data.entityData : null;
     return {
-      ...data,
+      ...result,
       // 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()
@@ -2120,34 +2202,47 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
     }
   }
   async saveScore(score) {
-    this.logger.debug("Saving score", { scorerId: score.scorerId, runId: score.runId });
+    let validatedScore;
+    try {
+      validatedScore = scores.saveScorePayloadSchema.parse(score);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_SAVE_SCORE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
     const now = /* @__PURE__ */ new Date();
     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),
-      preprocessStepResult: typeof score.preprocessStepResult === "string" ? score.preprocessStepResult : JSON.stringify(score.preprocessStepResult),
-      analyzeStepResult: typeof score.analyzeStepResult === "string" ? score.analyzeStepResult : JSON.stringify(score.analyzeStepResult),
-      score: score.score,
-      reason: score.reason,
-      preprocessPrompt: score.preprocessPrompt,
-      generateScorePrompt: score.generateScorePrompt,
-      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 || "",
+      scorerId: validatedScore.scorerId,
+      traceId: validatedScore.traceId || "",
+      spanId: validatedScore.spanId || "",
+      runId: validatedScore.runId,
+      scorer: typeof validatedScore.scorer === "string" ? validatedScore.scorer : JSON.stringify(validatedScore.scorer),
+      preprocessStepResult: typeof validatedScore.preprocessStepResult === "string" ? validatedScore.preprocessStepResult : JSON.stringify(validatedScore.preprocessStepResult),
+      analyzeStepResult: typeof validatedScore.analyzeStepResult === "string" ? validatedScore.analyzeStepResult : JSON.stringify(validatedScore.analyzeStepResult),
+      score: validatedScore.score,
+      reason: validatedScore.reason,
+      preprocessPrompt: validatedScore.preprocessPrompt,
+      generateScorePrompt: validatedScore.generateScorePrompt,
+      generateReasonPrompt: validatedScore.generateReasonPrompt,
+      analyzePrompt: validatedScore.analyzePrompt,
+      input: typeof validatedScore.input === "string" ? validatedScore.input : JSON.stringify(validatedScore.input),
+      output: typeof validatedScore.output === "string" ? validatedScore.output : JSON.stringify(validatedScore.output),
+      additionalContext: typeof validatedScore.additionalContext === "string" ? validatedScore.additionalContext : JSON.stringify(validatedScore.additionalContext),
+      runtimeContext: typeof validatedScore.runtimeContext === "string" ? validatedScore.runtimeContext : JSON.stringify(validatedScore.runtimeContext),
+      entityType: validatedScore.entityType,
+      entityData: typeof validatedScore.entity === "string" ? validatedScore.entity : JSON.stringify(validatedScore.entity),
+      entityId: validatedScore.entityId,
+      source: validatedScore.source,
+      resourceId: validatedScore.resourceId || "",
+      threadId: validatedScore.threadId || "",
       createdAt: now.toISOString(),
       updatedAt: now.toISOString()
     };
@@ -2176,9 +2271,9 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
     scorerId,
     pagination,
     entityId,
-    entityType
+    entityType,
+    source
   }) {
-    this.logger.debug("Getting scores by scorer ID", { scorerId, pagination, entityId, entityType });
     try {
       const query = this.service.entities.score.query.byScorer({ entity: "score", scorerId });
       const results = await query.go();
@@ -2189,6 +2284,9 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       if (entityType) {
         allScores = allScores.filter((score) => score.entityType === entityType);
       }
+      if (source) {
+        allScores = allScores.filter((score) => score.source === source);
+      }
       allScores.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
       const startIndex = pagination.page * pagination.perPage;
       const endIndex = startIndex + pagination.perPage;
@@ -2214,6 +2312,7 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
             scorerId: scorerId || "",
             entityId: entityId || "",
             entityType: entityType || "",
+            source: source || "",
             page: pagination.page,
             perPage: pagination.perPage
           }
@@ -2296,6 +2395,43 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       );
     }
   }
+  async getScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    this.logger.debug("Getting scores by span", { traceId, spanId, pagination });
+    try {
+      const query = this.service.entities.score.query.bySpan({ entity: "score", traceId, spanId });
+      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_GET_SCORES_BY_SPAN_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { traceId, spanId, page: pagination.page, perPage: pagination.perPage }
+        },
+        error$1
+      );
+    }
+  }
 };
 var TracesStorageDynamoDB = class extends storage.TracesStorage {
   service;
@@ -2546,15 +2682,31 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
     super();
     this.service = service;
   }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // runtimeContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
   // Workflow operations
   async persistWorkflowSnapshot({
     workflowName,
     runId,
+    resourceId,
     snapshot
   }) {
     this.logger.debug("Persisting workflow snapshot", { workflowName, runId });
     try {
-      const resourceId = "resourceId" in snapshot ? snapshot.resourceId : void 0;
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const data = {
         entity: "workflow_snapshot",
@@ -2562,7 +2714,6 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
         workflow_name: workflowName,
         run_id: runId,
         snapshot: JSON.stringify(snapshot),
-        // Stringify the snapshot object
         createdAt: now,
         updatedAt: now,
         resourceId
@@ -2634,6 +2785,11 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
         });
         if (pageResults.data && pageResults.data.length > 0) {
           let pageFilteredData = pageResults.data;
+          if (args?.status) {
+            pageFilteredData = pageFilteredData.filter((snapshot) => {
+              return snapshot.snapshot.status === args.status;
+            });
+          }
           if (args?.fromDate || args?.toDate) {
             pageFilteredData = pageFilteredData.filter((snapshot) => {
               const createdAt = new Date(snapshot.createdAt);
@@ -2680,8 +2836,6 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
   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.");
@@ -2691,7 +2845,6 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
           workflow_name: workflowName,
           run_id: runId
         }).go();
-        console.log("result", result2);
         if (!result2.data) {
           return null;
         }
@@ -2796,7 +2949,8 @@ var DynamoDBStore = class extends storage.MastraStorage {
       resourceWorkingMemory: true,
       hasColumn: false,
       createTable: false,
-      deleteMessages: false
+      deleteMessages: false,
+      getScoresBySpan: true
     };
   }
   /**
@@ -2891,8 +3045,8 @@ var DynamoDBStore = class extends storage.MastraStorage {
   async getThreadById({ threadId }) {
     return this.stores.memory.getThreadById({ threadId });
   }
-  async getThreadsByResourceId({ resourceId }) {
-    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  async getThreadsByResourceId(args) {
+    return this.stores.memory.getThreadsByResourceId(args);
   }
   async saveThread({ thread }) {
     return this.stores.memory.saveThread({ thread });
@@ -2915,6 +3069,12 @@ var DynamoDBStore = class extends storage.MastraStorage {
   }) {
     return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format });
   }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    return this.stores.memory.getMessagesById({ messageIds, format });
+  }
   async saveMessages(args) {
     return this.stores.memory.saveMessages(args);
   }
@@ -2938,12 +3098,29 @@ var DynamoDBStore = class extends storage.MastraStorage {
     return this.stores.traces.getTracesPaginated(_args);
   }
   // Workflow operations
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext
+  }) {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
+  }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
+    resourceId,
     snapshot
   }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
   }
   async loadWorkflowSnapshot({
     workflowName,
@@ -3024,10 +3201,20 @@ var DynamoDBStore = class extends storage.MastraStorage {
     });
   }
   async getScoresByScorerId({
-    scorerId: _scorerId,
-    pagination: _pagination
+    scorerId,
+    source,
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, source, entityId, entityType, pagination });
+  }
+  async getScoresBySpan({
+    traceId,
+    spanId,
+    pagination
   }) {
-    return this.stores.scores.getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination });
+    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination });
   }
 };