@mastra/dynamodb 0.13.0 → 0.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dynamodb",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "DynamoDB storage adapter for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -36,13 +36,13 @@
     "@vitest/coverage-v8": "3.2.3",
     "@vitest/ui": "3.2.3",
     "axios": "^1.10.0",
-    "eslint": "^9.29.0",
+    "eslint": "^9.30.1",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@internal/lint": "0.0.18",
-    "@internal/storage-test-utils": "0.0.14",
-    "@mastra/core": "0.10.11"
+    "@internal/storage-test-utils": "0.0.17",
+    "@internal/lint": "0.0.21",
+    "@mastra/core": "0.11.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/entities/index.ts

@@ -2,6 +2,8 @@ import type { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 import { Service } from 'electrodb';
 import { evalEntity } from './eval';
 import { messageEntity } from './message';
+import { resourceEntity } from './resource';
+import { scoreEntity } from './score';
 import { threadEntity } from './thread';
 import { traceEntity } from './trace';
 import { workflowSnapshotEntity } from './workflow-snapshot';
@@ -13,7 +15,9 @@ export function getElectroDbService(client: DynamoDBDocumentClient, tableName: s
       message: messageEntity,
       eval: evalEntity,
       trace: traceEntity,
-      workflowSnapshot: workflowSnapshotEntity,
+      workflow_snapshot: workflowSnapshotEntity,
+      resource: resourceEntity,
+      score: scoreEntity,
     },
     {
       client,

package/src/entities/resource.ts

@@ -0,0 +1,57 @@
+import { Entity } from 'electrodb';
+import { baseAttributes } from './utils';
+
+export const resourceEntity = new Entity({
+  model: {
+    entity: 'resource',
+    version: '1',
+    service: 'mastra',
+  },
+  attributes: {
+    entity: {
+      type: 'string',
+      required: true,
+    },
+    ...baseAttributes,
+    id: {
+      type: 'string',
+      required: true,
+    },
+    workingMemory: {
+      type: 'string',
+      required: false,
+    },
+    metadata: {
+      type: 'string',
+      required: false,
+      // Stringify content object on set if it's not already a string
+      set: (value?: string | void) => {
+        if (value && typeof value !== 'string') {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      // Parse JSON string to object on get ONLY if it looks like JSON
+      get: (value?: string) => {
+        if (value && typeof value === 'string') {
+          try {
+            // Attempt to parse only if it might be JSON (e.g., starts with { or [)
+            if (value.startsWith('{') || value.startsWith('[')) {
+              return JSON.parse(value);
+            }
+          } catch {
+            // Ignore parse error, return original string
+            return value;
+          }
+        }
+        return value;
+      },
+    },
+  },
+  indexes: {
+    primary: {
+      pk: { field: 'pk', composite: ['entity', 'id'] },
+      sk: { field: 'sk', composite: ['entity'] },
+    },
+  },
+});

package/src/entities/score.ts

@@ -0,0 +1,285 @@
+import { Entity } from 'electrodb';
+import { baseAttributes } from './utils';
+
+export const scoreEntity = new Entity({
+  model: {
+    entity: 'score',
+    version: '1',
+    service: 'mastra',
+  },
+  attributes: {
+    entity: {
+      type: 'string',
+      required: true,
+    },
+    ...baseAttributes,
+    id: {
+      type: 'string',
+      required: true,
+    },
+    scorerId: {
+      type: 'string',
+      required: true,
+    },
+    traceId: {
+      type: 'string',
+      required: false,
+    },
+    runId: {
+      type: 'string',
+      required: true,
+    },
+    scorer: {
+      type: 'string',
+      required: true,
+      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;
+      },
+    },
+    extractStepResult: {
+      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,
+      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;
+      },
+    },
+    score: {
+      type: 'number',
+      required: true,
+    },
+    reason: {
+      type: 'string',
+      required: false,
+    },
+    extractPrompt: {
+      type: 'string',
+      required: false,
+    },
+    analyzePrompt: {
+      type: 'string',
+      required: false,
+    },
+    reasonPrompt: {
+      type: 'string',
+      required: false,
+    },
+    input: {
+      type: 'string',
+      required: true,
+      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;
+      },
+    },
+    output: {
+      type: 'string',
+      required: true,
+      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;
+      },
+    },
+    additionalContext: {
+      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;
+      },
+    },
+    runtimeContext: {
+      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;
+      },
+    },
+    entityType: {
+      type: 'string',
+      required: false,
+    },
+    entityData: {
+      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;
+      },
+    },
+    entityId: {
+      type: 'string',
+      required: false,
+    },
+    source: {
+      type: 'string',
+      required: true,
+    },
+    resourceId: {
+      type: 'string',
+      required: false,
+    },
+    threadId: {
+      type: 'string',
+      required: false,
+    },
+  },
+  indexes: {
+    primary: {
+      pk: { field: 'pk', composite: ['entity', 'id'] },
+      sk: { field: 'sk', composite: ['entity'] },
+    },
+    byScorer: {
+      index: 'gsi1',
+      pk: { field: 'gsi1pk', composite: ['entity', 'scorerId'] },
+      sk: { field: 'gsi1sk', composite: ['createdAt'] },
+    },
+    byRun: {
+      index: 'gsi2',
+      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'] },
+    },
+  },
+});

package/src/storage/domains/legacy-evals/index.ts

@@ -0,0 +1,243 @@
+import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
+import type { EvalRow, PaginationArgs, PaginationInfo } from '@mastra/core/storage';
+import { LegacyEvalsStorage } from '@mastra/core/storage';
+import type { Service } from 'electrodb';
+
+export class LegacyEvalsDynamoDB extends LegacyEvalsStorage {
+  service: Service<Record<string, any>>;
+  tableName: string;
+
+  constructor({ service, tableName }: { service: Service<Record<string, any>>; tableName: string }) {
+    super();
+    this.service = service;
+    this.tableName = tableName;
+  }
+
+  // Eval operations
+  async getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
+    this.logger.debug('Getting evals for agent', { agentName, type });
+
+    try {
+      // Query evals by agent name using the GSI
+      // Provide *all* composite key components for the 'byAgent' index ('entity', 'agent_name')
+      const query = this.service.entities.eval.query.byAgent({ entity: 'eval', agent_name: agentName });
+
+      // Fetch potentially all items in descending order, using the correct 'order' option
+      const results = await query.go({ order: 'desc', limit: 100 }); // Use order: 'desc'
+
+      if (!results.data.length) {
+        return [];
+      }
+
+      // Filter by type if specified
+      let filteredData = results.data;
+      if (type) {
+        filteredData = filteredData.filter((evalRecord: Record<string, any>) => {
+          try {
+            // Need to handle potential parse errors for test_info
+            const testInfo =
+              evalRecord.test_info && typeof evalRecord.test_info === 'string'
+                ? JSON.parse(evalRecord.test_info)
+                : undefined;
+
+            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 });
+            // Decide how to handle parse errors - exclude or include? Including for now.
+          }
+          return true;
+        });
+      }
+
+      // Format the results - ElectroDB transforms most attributes, but we need to map/parse
+      return filteredData.map((evalRecord: Record<string, any>) => {
+        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) : undefined,
+            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)
+                : undefined,
+          } as EvalRow;
+        } catch (parseError) {
+          this.logger.error('Failed to parse eval record', { record: evalRecord, error: parseError });
+          // Return a partial record or null/undefined on error?
+          // Returning partial for now, might need adjustment based on requirements.
+          return {
+            agentName: evalRecord.agent_name,
+            createdAt: evalRecord.created_at,
+            runId: evalRecord.run_id,
+            globalRunId: evalRecord.global_run_id,
+          } as Partial<EvalRow> as EvalRow; // Cast needed for return type
+        }
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_DYNAMODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName },
+        },
+        error,
+      );
+    }
+  }
+
+  async getEvals(
+    options: {
+      agentName?: string;
+      type?: 'test' | 'live';
+    } & PaginationArgs = {},
+  ): Promise<PaginationInfo & { evals: EvalRow[] }> {
+    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 by specific agent name
+        query = this.service.entities.eval.query.byAgent({ entity: 'eval', agent_name: agentName });
+      } else {
+        // Query all evals using the primary index
+        query = this.service.entities.eval.query.byEntity({ entity: 'eval' });
+      }
+
+      // For DynamoDB, we need to fetch all data and apply pagination in memory
+      // since DynamoDB doesn't support traditional offset-based pagination
+      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,
+        };
+      }
+
+      // Filter by type if specified
+      let filteredData = results.data;
+      if (type) {
+        filteredData = filteredData.filter((evalRecord: Record<string, any>) => {
+          try {
+            const testInfo =
+              evalRecord.test_info && typeof evalRecord.test_info === 'string'
+                ? JSON.parse(evalRecord.test_info)
+                : undefined;
+
+            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;
+        });
+      }
+
+      // Apply date range filtering if specified
+      if (dateRange) {
+        const fromDate = dateRange.start;
+        const toDate = dateRange.end;
+
+        filteredData = filteredData.filter((evalRecord: Record<string, any>) => {
+          const recordDate = new Date(evalRecord.created_at);
+
+          if (fromDate && recordDate < fromDate) {
+            return false;
+          }
+          if (toDate && recordDate > toDate) {
+            return false;
+          }
+          return true;
+        });
+      }
+
+      // Apply pagination
+      const total = filteredData.length;
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedData = filteredData.slice(start, end);
+
+      // Transform to EvalRow format
+      const evals = paginatedData.map((evalRecord: Record<string, any>) => {
+        try {
+          return {
+            input: evalRecord.input,
+            output: evalRecord.output,
+            result:
+              evalRecord.result && typeof evalRecord.result === 'string' ? JSON.parse(evalRecord.result) : undefined,
+            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)
+                : undefined,
+          } as EvalRow;
+        } 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,
+          } as Partial<EvalRow> as EvalRow;
+        }
+      });
+
+      const hasMore = end < total;
+
+      return {
+        evals,
+        total,
+        page,
+        perPage,
+        hasMore,
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_DYNAMODB_STORE_GET_EVALS_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            agentName: agentName || 'all',
+            type: type || 'all',
+            page,
+            perPage,
+          },
+        },
+        error,
+      );
+    }
+  }
+}