@mastra/dynamodb 0.0.0-update-stores-peerDeps-20250723031338 → 0.0.0-vector-query-tool-provider-options-20250828222356

package/src/entities/score.ts

@@ -73,6 +73,28 @@ export const scoreEntity = new Entity({
         return value;
       },
     },
+    preprocessStepResult: {
+      type: 'string',
+      required: false,
+      set: (value?: Record<string, unknown> | string) => {
+        if (value && typeof value !== 'string') {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      get: (value?: string) => {
+        if (value && typeof value === 'string') {
+          try {
+            if (value.startsWith('{') || value.startsWith('[')) {
+              return JSON.parse(value);
+            }
+          } catch {
+            return value;
+          }
+        }
+        return value;
+      },
+    },
     analyzeStepResult: {
       type: 'string',
       required: false,
@@ -111,10 +133,20 @@ export const scoreEntity = new Entity({
       type: 'string',
       required: false,
     },
+
+    // Deprecated in favor of generateReasonPrompt
     reasonPrompt: {
       type: 'string',
       required: false,
     },
+    generateScorePrompt: {
+      type: 'string',
+      required: false,
+    },
+    generateReasonPrompt: {
+      type: 'string',
+      required: false,
+    },
     input: {
       type: 'string',
       required: true,

package/src/storage/domains/memory/index.ts

@@ -3,7 +3,12 @@ import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import type { StorageThreadType, MastraMessageV1, MastraMessageV2 } from '@mastra/core/memory';
 import { MemoryStorage, resolveMessageLimit } from '@mastra/core/storage';
-import type { PaginationInfo, StorageGetMessagesArg, StorageResourceType } from '@mastra/core/storage';
+import type {
+  PaginationInfo,
+  StorageGetMessagesArg,
+  StorageResourceType,
+  ThreadSortOptions,
+} from '@mastra/core/storage';
 import type { Service } from 'electrodb';
 
 export class MemoryStorageDynamoDB extends MemoryStorage {
@@ -27,6 +32,24 @@ export class MemoryStorageDynamoDB extends MemoryStorage {
     };
   }
 
+  // Helper function to transform and sort threads
+  private transformAndSortThreads(rawThreads: any[], orderBy: string, sortDirection: string): StorageThreadType[] {
+    return rawThreads
+      .map((data: any) => ({
+        ...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: StorageThreadType, b: StorageThreadType) => {
+        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;
+      }) as StorageThreadType[];
+  }
+
   async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
     this.logger.debug('Getting thread by ID', { threadId });
     try {
@@ -59,8 +82,16 @@ export class MemoryStorageDynamoDB extends MemoryStorage {
     }
   }
 
-  async getThreadsByResourceId({ resourceId }: { resourceId: string }): Promise<StorageThreadType[]> {
-    this.logger.debug('Getting threads by resource ID', { resourceId });
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+   */
+  public async getThreadsByResourceId(args: { resourceId: string } & ThreadSortOptions): Promise<StorageThreadType[]> {
+    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();
 
@@ -68,15 +99,8 @@ export class MemoryStorageDynamoDB extends MemoryStorage {
         return [];
       }
 
-      // ElectroDB handles the transformation with attribute getters
-      return result.data.map((data: any) => ({
-        ...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
-      })) as StorageThreadType[];
+      // Use shared helper method for transformation and sorting
+      return this.transformAndSortThreads(result.data, orderBy, sortDirection);
     } catch (error) {
       throw new MastraError(
         {
@@ -101,7 +125,7 @@ export class MemoryStorageDynamoDB extends 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) : undefined,
     };
 
@@ -326,6 +350,62 @@ export class MemoryStorageDynamoDB extends MemoryStorage {
     }
   }
 
+  public async getMessagesById({
+    messageIds,
+    format,
+  }: {
+    messageIds: string[];
+    format: 'v1';
+  }): Promise<MastraMessageV1[]>;
+  public async getMessagesById({
+    messageIds,
+    format,
+  }: {
+    messageIds: string[];
+    format?: 'v2';
+  }): Promise<MastraMessageV2[]>;
+  public async getMessagesById({
+    messageIds,
+    format,
+  }: {
+    messageIds: string[];
+    format?: 'v1' | 'v2';
+  }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
+    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((data: any) => this.parseMessageData(data))
+        .filter((msg: any): msg is MastraMessageV2 => 'content' in msg);
+
+      // Deduplicate messages by ID (like libsql)
+      const uniqueMessages = parsedMessages.filter(
+        (message, index, self) => index === self.findIndex(m => m.id === message.id),
+      );
+
+      const list = new MessageList().add(uniqueMessages, 'memory');
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_DYNAMODB_STORE_GET_MESSAGES_BY_ID_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { messageIds: JSON.stringify(messageIds) },
+        },
+        error,
+      );
+    }
+  }
+
   async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
   async saveMessages(args: { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[]>;
   async saveMessages(
@@ -417,13 +497,24 @@ export class MemoryStorageDynamoDB extends MemoryStorage {
     }
   }
 
-  async getThreadsByResourceIdPaginated(args: {
-    resourceId: string;
-    page?: number;
-    perPage?: number;
-  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+  async getThreadsByResourceIdPaginated(
+    args: {
+      resourceId: string;
+      page?: number;
+      perPage?: number;
+    } & ThreadSortOptions,
+  ): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
     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 {
       // Query threads by resource ID using the GSI
@@ -431,7 +522,9 @@ export class MemoryStorageDynamoDB extends MemoryStorage {
 
       // Get all threads for this resource ID (DynamoDB doesn't support OFFSET/LIMIT)
       const results = await query.go();
-      const allThreads = results.data;
+
+      // Use shared helper method for transformation and sorting
+      const allThreads = this.transformAndSortThreads(results.data, orderBy, sortDirection);
 
       // Apply pagination in memory
       const startIndex = page * perPage;

package/src/storage/domains/operations/index.ts

@@ -3,6 +3,7 @@ import type { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import {
   StoreOperations,
+  TABLE_AI_SPANS,
   TABLE_EVALS,
   TABLE_MESSAGES,
   TABLE_RESOURCES,
@@ -49,6 +50,7 @@ export class StoreOperationsDynamoDB extends StoreOperations {
       [TABLE_SCORERS]: 'score',
       [TABLE_TRACES]: 'trace',
       [TABLE_RESOURCES]: 'resource',
+      [TABLE_AI_SPANS]: 'ai_span',
     };
     return mapping[tableName] || null;
   }

package/src/storage/domains/score/index.ts

@@ -1,5 +1,5 @@
 import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
-import type { ScoreRowData } from '@mastra/core/scores';
+import type { ScoreRowData, ScoringSource } from '@mastra/core/scores';
 import { ScoresStorage } from '@mastra/core/storage';
 import type { PaginationInfo, StoragePagination } from '@mastra/core/storage';
 import type { Service } from 'electrodb';
@@ -58,13 +58,16 @@ export class ScoresStorageDynamoDB extends ScoresStorage {
       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),
+      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,
-      extractPrompt: score.extractPrompt,
+      preprocessPrompt: score.preprocessPrompt,
+      generateScorePrompt: score.generateScorePrompt,
       analyzePrompt: score.analyzePrompt,
       reasonPrompt: score.reasonPrompt,
       input: typeof score.input === 'string' ? score.input : JSON.stringify(score.input),
@@ -112,14 +115,14 @@ export class ScoresStorageDynamoDB extends ScoresStorage {
     pagination,
     entityId,
     entityType,
+    source,
   }: {
     scorerId: string;
     pagination: StoragePagination;
     entityId?: string;
     entityType?: string;
+    source?: ScoringSource;
   }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    this.logger.debug('Getting scores by scorer ID', { scorerId, pagination, entityId, entityType });
-
     try {
       // Query scores by scorer ID using the GSI
       const query = this.service.entities.score.query.byScorer({ entity: 'score', scorerId });
@@ -135,6 +138,9 @@ export class ScoresStorageDynamoDB extends ScoresStorage {
       if (entityType) {
         allScores = allScores.filter((score: ScoreRowData) => score.entityType === entityType);
       }
+      if (source) {
+        allScores = allScores.filter((score: ScoreRowData) => score.source === source);
+      }
 
       // Sort by createdAt DESC (newest first)
       allScores.sort((a: ScoreRowData, b: ScoreRowData) => b.createdAt.getTime() - a.createdAt.getTime());
@@ -167,6 +173,7 @@ export class ScoresStorageDynamoDB extends ScoresStorage {
             scorerId: scorerId || '',
             entityId: entityId || '',
             entityType: entityType || '',
+            source: source || '',
             page: pagination.page,
             perPage: pagination.perPage,
           },

package/src/storage/domains/workflows/index.ts

@@ -1,7 +1,7 @@
 import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import { WorkflowsStorage } from '@mastra/core/storage';
 import type { WorkflowRun, WorkflowRuns } from '@mastra/core/storage';
-import type { WorkflowRunState } from '@mastra/core/workflows';
+import type { StepResult, WorkflowRunState } from '@mastra/core/workflows';
 import type { Service } from 'electrodb';
 
 // Define the structure for workflow snapshot items retrieved from DynamoDB
@@ -34,6 +34,43 @@ export class WorkflowStorageDynamoDB extends WorkflowsStorage {
     this.service = service;
   }
 
+  updateWorkflowResults(
+    {
+      // workflowName,
+      // runId,
+      // stepId,
+      // result,
+      // runtimeContext,
+    }: {
+      workflowName: string;
+      runId: string;
+      stepId: string;
+      result: StepResult<any, any, any, any>;
+      runtimeContext: Record<string, any>;
+    },
+  ): Promise<Record<string, StepResult<any, any, any, any>>> {
+    throw new Error('Method not implemented.');
+  }
+  updateWorkflowState(
+    {
+      // workflowName,
+      // runId,
+      // opts,
+    }: {
+      workflowName: string;
+      runId: string;
+      opts: {
+        status: string;
+        result?: StepResult<any, any, any, any>;
+        error?: string;
+        suspendedPaths?: Record<string, number[]>;
+        waitingPaths?: Record<string, number[]>;
+      };
+    },
+  ): Promise<WorkflowRunState | undefined> {
+    throw new Error('Method not implemented.');
+  }
+
   // Workflow operations
   async persistWorkflowSnapshot({
     workflowName,

package/src/storage/index.ts

@@ -4,7 +4,7 @@ import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import type { StorageThreadType, MastraMessageV2, MastraMessageV1 } from '@mastra/core/memory';
 
-import type { ScoreRowData } from '@mastra/core/scores';
+import type { ScoreRowData, ScoringSource } from '@mastra/core/scores';
 import { MastraStorage } from '@mastra/core/storage';
 import type {
   EvalRow,
@@ -19,9 +19,10 @@ import type {
   StorageDomains,
   PaginationArgs,
   StorageResourceType,
+  ThreadSortOptions,
 } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
-import type { WorkflowRunState } from '@mastra/core/workflows';
+import type { StepResult, WorkflowRunState } from '@mastra/core/workflows';
 import type { Service } from 'electrodb';
 import { getElectroDbService } from '../entities';
 import { LegacyEvalsDynamoDB } from './domains/legacy-evals';
@@ -121,6 +122,7 @@ export class DynamoDBStore extends MastraStorage {
       resourceWorkingMemory: true,
       hasColumn: false,
       createTable: false,
+      deleteMessages: false,
     };
   }
 
@@ -253,8 +255,8 @@ export class DynamoDBStore extends MastraStorage {
     return this.stores.memory.getThreadById({ threadId });
   }
 
-  async getThreadsByResourceId({ resourceId }: { resourceId: string }): Promise<StorageThreadType[]> {
-    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  async getThreadsByResourceId(args: { resourceId: string } & ThreadSortOptions): Promise<StorageThreadType[]> {
+    return this.stores.memory.getThreadsByResourceId(args);
   }
 
   async saveThread({ thread }: { thread: StorageThreadType }): Promise<StorageThreadType> {
@@ -289,6 +291,18 @@ export class DynamoDBStore extends MastraStorage {
     return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format });
   }
 
+  async getMessagesById({ messageIds, format }: { messageIds: string[]; format: 'v1' }): Promise<MastraMessageV1[]>;
+  async getMessagesById({ messageIds, format }: { messageIds: string[]; format?: 'v2' }): Promise<MastraMessageV2[]>;
+  async getMessagesById({
+    messageIds,
+    format,
+  }: {
+    messageIds: string[];
+    format?: 'v1' | 'v2';
+  }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
+    return this.stores.memory.getMessagesById({ messageIds, format });
+  }
+
   async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
   async saveMessages(args: { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[]>;
   async saveMessages(
@@ -297,11 +311,13 @@ export class DynamoDBStore extends MastraStorage {
     return this.stores.memory.saveMessages(args);
   }
 
-  async getThreadsByResourceIdPaginated(args: {
-    resourceId: string;
-    page: number;
-    perPage: number;
-  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+  async getThreadsByResourceIdPaginated(
+    args: {
+      resourceId: string;
+      page: number;
+      perPage: number;
+    } & ThreadSortOptions,
+  ): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
     return this.stores.memory.getThreadsByResourceIdPaginated(args);
   }
 
@@ -342,6 +358,40 @@ export class DynamoDBStore extends MastraStorage {
   }
 
   // Workflow operations
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext,
+  }: {
+    workflowName: string;
+    runId: string;
+    stepId: string;
+    result: StepResult<any, any, any, any>;
+    runtimeContext: Record<string, any>;
+  }): Promise<Record<string, StepResult<any, any, any, any>>> {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+  }
+
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts,
+  }: {
+    workflowName: string;
+    runId: string;
+    opts: {
+      status: string;
+      result?: StepResult<any, any, any, any>;
+      error?: string;
+      suspendedPaths?: Record<string, number[]>;
+      waitingPaths?: Record<string, number[]>;
+    };
+  }): Promise<WorkflowRunState | undefined> {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
+  }
+
   async persistWorkflowSnapshot({
     workflowName,
     runId,
@@ -471,12 +521,18 @@ export class DynamoDBStore extends MastraStorage {
   }
 
   async getScoresByScorerId({
-    scorerId: _scorerId,
-    pagination: _pagination,
+    scorerId,
+    source,
+    entityId,
+    entityType,
+    pagination,
   }: {
     scorerId: string;
+    entityId?: string;
+    entityType?: string;
+    source?: ScoringSource;
     pagination: StoragePagination;
   }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    return this.stores.scores.getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination });
+    return this.stores.scores.getScoresByScorerId({ scorerId, source, entityId, entityType, pagination });
   }
 }