@mastra/dynamodb 0.0.0-pass-headers-for-create-mastra-client-20250529200245 → 0.0.0-share-agent-metadata-with-cloud-20250718110128

package/package.json

@@ -1,37 +1,51 @@
 {
   "name": "@mastra/dynamodb",
-  "version": "0.0.0-pass-headers-for-create-mastra-client-20250529200245",
+  "version": "0.0.0-share-agent-metadata-with-cloud-20250718110128",
   "description": "DynamoDB storage adapter for Mastra",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.0.0",
-    "@aws-sdk/lib-dynamodb": "^3.0.0",
-    "electrodb": "^3.4.1"
+    "@aws-sdk/client-dynamodb": "^3.840.0",
+    "@aws-sdk/lib-dynamodb": "^3.840.0",
+    "electrodb": "^3.4.3"
   },
   "peerDependencies": {
-    "@mastra/core": "^0.10.0"
+    "@mastra/core": "0.0.0-share-agent-metadata-with-cloud-20250718110128"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.52.1",
-    "@types/node": "^20.17.27",
-    "@vitest/coverage-v8": "3.0.9",
-    "@vitest/ui": "3.0.9",
-    "axios": "^1.8.4",
-    "eslint": "^9.23.0",
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.0.9",
-    "@internal/lint": "0.0.0-pass-headers-for-create-mastra-client-20250529200245",
-    "@mastra/core": "0.0.0-pass-headers-for-create-mastra-client-20250529200245"
+    "@microsoft/api-extractor": "^7.52.8",
+    "@types/node": "^20.19.0",
+    "@vitest/coverage-v8": "3.2.3",
+    "@vitest/ui": "3.2.3",
+    "axios": "^1.10.0",
+    "eslint": "^9.30.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.0-share-agent-metadata-with-cloud-20250718110128",
+    "@mastra/core": "0.0.0-share-agent-metadata-with-cloud-20250718110128",
+    "@internal/storage-test-utils": "0.0.16"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --clean --treeshake=smallest --splitting",
+    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
     "dev": "tsup --watch",
     "clean": "rm -rf dist",
     "lint": "eslint .",

package/src/storage/index.test.ts

@@ -11,6 +11,7 @@ import {
   waitUntilTableExists,
   waitUntilTableNotExists,
 } from '@aws-sdk/client-dynamodb';
+import { createSampleMessageV2, createSampleThread } from '@internal/storage-test-utils';
 import type { MastraMessageV1, StorageThreadType, WorkflowRun, WorkflowRunState } from '@mastra/core';
 import type { MastraMessageV2 } from '@mastra/core/agent';
 import { TABLE_EVALS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT } from '@mastra/core/storage';
@@ -320,10 +321,12 @@ describe('DynamoDBStore Integration Tests', () => {
             input: { source: 'test' },
             step1: { status: 'success', output: { data: 'test' } },
           } as unknown as WorkflowRunState['context'],
+          serializedStepGraph: [],
           activePaths: [{ stepPath: ['test'], stepId: 'step1', status: 'success' }],
           suspendedPaths: { test: [1] },
           runId: 'test-run-large', // Use unique runId
           timestamp: now,
+          status: 'success',
         };
 
         await expect(
@@ -386,6 +389,215 @@ describe('DynamoDBStore Integration Tests', () => {
         expect(retrieved?.title).toBe('Updated Thread 2');
         expect(retrieved?.metadata?.update).toBe(2);
       });
+
+      test('getMessages should return the N most recent messages [v2 storage]', async () => {
+        const threadId = 'last-selector-thread';
+        const start = Date.now();
+
+        // Insert 10 messages with increasing timestamps
+        const messages: MastraMessageV2[] = Array.from({ length: 10 }, (_, i) => ({
+          id: `m-${i}`,
+          threadId,
+          resourceId: 'r',
+          content: { format: 2, parts: [{ type: 'text', text: `msg-${i}` }] },
+          createdAt: new Date(start + i), // 0..9 ms apart
+          role: 'user',
+          type: 'text',
+        }));
+        await store.saveMessages({ messages, format: 'v2' });
+
+        const last3 = await store.getMessages({
+          format: 'v2',
+          threadId,
+          selectBy: { last: 3 },
+        });
+
+        expect(last3).toHaveLength(3);
+        expect(last3.map(m => (m.content.parts[0] as { type: string; text: string }).text)).toEqual([
+          'msg-7',
+          'msg-8',
+          'msg-9',
+        ]);
+      });
+
+      test('getMessages should return the N most recent messages [v1 storage]', async () => {
+        const threadId = 'last-selector-thread';
+        const start = Date.now();
+
+        // Insert 10 messages with increasing timestamps
+        const messages: MastraMessageV1[] = Array.from({ length: 10 }, (_, i) => ({
+          id: `m-${i}`,
+          threadId,
+          resourceId: 'r',
+          content: `msg-${i}`,
+          createdAt: new Date(start + i), // 0..9 ms apart
+          role: 'user',
+          type: 'text',
+        }));
+        await store.saveMessages({ messages });
+
+        const last3 = await store.getMessages({
+          threadId,
+          selectBy: { last: 3 },
+        });
+
+        expect(last3).toHaveLength(3);
+        expect(last3.map(m => m.content)).toEqual(['msg-7', 'msg-8', 'msg-9']);
+      });
+
+      test('should update thread updatedAt when a message is saved to it', async () => {
+        const thread: StorageThreadType = {
+          id: 'thread-update-test',
+          resourceId: 'resource-update',
+          title: 'Update Test Thread',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          metadata: { test: true },
+        };
+        await store.saveThread({ thread });
+
+        // Get the initial thread to capture the original updatedAt
+        const initialThread = await store.getThreadById({ threadId: thread.id });
+        expect(initialThread).toBeDefined();
+        const originalUpdatedAt = initialThread!.updatedAt;
+
+        // Wait a small amount to ensure different timestamp
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Create and save a message to the thread
+        const message: MastraMessageV1 = {
+          id: 'msg-update-test',
+          threadId: thread.id,
+          resourceId: 'resource-update',
+          content: 'Test message for update',
+          createdAt: new Date(),
+          role: 'user',
+          type: 'text',
+        };
+        await store.saveMessages({ messages: [message] });
+
+        // Retrieve the thread again and check that updatedAt was updated
+        const updatedThread = await store.getThreadById({ threadId: thread.id });
+        expect(updatedThread).toBeDefined();
+        expect(updatedThread!.updatedAt.getTime()).toBeGreaterThan(originalUpdatedAt.getTime());
+      });
+
+      test('saveThread upsert: should create new thread when thread does not exist', async () => {
+        const threadId = `upsert-new-${randomUUID()}`;
+        const now = new Date();
+        const thread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-upsert-new',
+          title: 'New Thread via Upsert',
+          createdAt: now,
+          updatedAt: now,
+          metadata: { operation: 'create', test: true },
+        };
+
+        // Save the thread (should create new)
+        await expect(store.saveThread({ thread })).resolves.not.toThrow();
+
+        // Verify the thread was created
+        const retrieved = await store.getThreadById({ threadId });
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.id).toBe(threadId);
+        expect(retrieved?.title).toBe('New Thread via Upsert');
+        expect(retrieved?.resourceId).toBe('resource-upsert-new');
+        expect(retrieved?.metadata).toEqual({ operation: 'create', test: true });
+      });
+
+      test('saveThread upsert: should update existing thread when thread already exists', async () => {
+        const threadId = `upsert-update-${randomUUID()}`;
+        const initialCreatedAt = new Date();
+
+        // Create initial thread
+        const initialThread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-upsert-initial',
+          title: 'Initial Thread Title',
+          createdAt: initialCreatedAt,
+          updatedAt: initialCreatedAt,
+          metadata: { operation: 'initial', version: 1 },
+        };
+        await store.saveThread({ thread: initialThread });
+
+        // Wait a small amount to ensure different timestamp
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Update the thread with same ID but different data
+        const updatedThread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-upsert-updated',
+          title: 'Updated Thread Title',
+          createdAt: initialCreatedAt, // Keep original creation time
+          updatedAt: new Date(), // New update time
+          metadata: { operation: 'update', version: 2 },
+        };
+        await expect(store.saveThread({ thread: updatedThread })).resolves.not.toThrow();
+
+        // Verify the thread was updated
+        const retrieved = await store.getThreadById({ threadId });
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.id).toBe(threadId);
+        expect(retrieved?.title).toBe('Updated Thread Title');
+        expect(retrieved?.resourceId).toBe('resource-upsert-updated');
+        expect(retrieved?.metadata).toEqual({ operation: 'update', version: 2 });
+
+        // updatedAt should be newer than the initial creation time
+        expect(retrieved?.updatedAt.getTime()).toBeGreaterThan(initialCreatedAt.getTime());
+        // createdAt should remain exactly equal to the initial creation time
+        expect(retrieved?.createdAt.getTime()).toBe(initialCreatedAt.getTime());
+      });
+
+      test('saveThread upsert: should handle complex metadata updates', async () => {
+        const threadId = `upsert-metadata-${randomUUID()}`;
+        const initialMetadata = {
+          user: 'initial-user',
+          tags: ['initial', 'test'],
+          count: 1,
+        };
+
+        // Create initial thread with complex metadata
+        const initialThread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-metadata-test',
+          title: 'Metadata Test Thread',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          metadata: initialMetadata,
+        };
+        await store.saveThread({ thread: initialThread });
+
+        // Wait a small amount to ensure different timestamp
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Update with completely different metadata structure
+        const updatedMetadata = {
+          user: 'updated-user',
+          settings: { theme: 'light', language: 'ja', notifications: true },
+          tags: ['updated', 'upsert', 'complex'],
+          count: 5,
+          newField: { nested: { deeply: 'value' } },
+        };
+
+        const updatedThread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-metadata-test',
+          title: 'Updated Metadata Thread',
+          createdAt: initialThread.createdAt,
+          updatedAt: new Date(),
+          metadata: updatedMetadata,
+        };
+        await expect(store.saveThread({ thread: updatedThread })).resolves.not.toThrow();
+
+        // Verify the metadata was completely replaced
+        const retrieved = await store.getThreadById({ threadId });
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.metadata).toEqual(updatedMetadata);
+        expect(retrieved?.metadata?.user).toBe('updated-user');
+        expect(retrieved?.metadata?.tags).toEqual(['updated', 'upsert', 'complex']);
+        expect(retrieved?.title).toBe('Updated Metadata Thread');
+      });
     });
 
     describe('Batch Operations', () => {
@@ -461,6 +673,82 @@ describe('DynamoDBStore Integration Tests', () => {
         expect(retrieved[0]?.content).toBe('Large Message 0');
         expect(retrieved[29]?.content).toBe('Large Message 29');
       });
+
+      test('should upsert messages: duplicate id+threadId results in update, not duplicate row', async () => {
+        const thread = await createSampleThread();
+        await store.saveThread({ thread });
+        const baseMessage = createSampleMessageV2({
+          threadId: thread.id,
+          createdAt: new Date(),
+          content: { content: 'Original' },
+          resourceId: thread.resourceId,
+        });
+
+        // Insert the message for the first time
+        await store.saveMessages({ messages: [baseMessage], format: 'v2' });
+
+        // // Insert again with the same id and threadId but different content
+        const updatedMessage = {
+          ...createSampleMessageV2({
+            threadId: thread.id,
+            createdAt: new Date(),
+            content: { content: 'Updated' },
+            resourceId: thread.resourceId,
+          }),
+          id: baseMessage.id,
+        };
+
+        await store.saveMessages({ messages: [updatedMessage], format: 'v2' });
+
+        // Retrieve messages for the thread
+        const retrievedMessages = await store.getMessages({ threadId: thread.id, format: 'v2' });
+
+        // Only one message should exist for that id+threadId
+        expect(retrievedMessages.filter(m => m.id === baseMessage.id)).toHaveLength(1);
+
+        // The content should be the updated one
+        expect(retrievedMessages.find(m => m.id === baseMessage.id)?.content.content).toBe('Updated');
+      });
+
+      test('should upsert messages: duplicate id and different threadid', async () => {
+        const thread1 = await createSampleThread();
+        const thread2 = await createSampleThread();
+        await store.saveThread({ thread: thread1 });
+        await store.saveThread({ thread: thread2 });
+
+        const message = createSampleMessageV2({
+          threadId: thread1.id,
+          createdAt: new Date(),
+          content: { content: 'Thread1 Content' },
+          resourceId: thread1.resourceId,
+        });
+
+        // Insert message into thread1
+        await store.saveMessages({ messages: [message], format: 'v2' });
+
+        // Attempt to insert a message with the same id but different threadId
+        const conflictingMessage = {
+          ...createSampleMessageV2({
+            threadId: thread2.id, // different thread
+            content: { content: 'Thread2 Content' },
+            resourceId: thread2.resourceId,
+          }),
+          id: message.id,
+        };
+
+        // Save should save the message to the new thread
+        await store.saveMessages({ messages: [conflictingMessage], format: 'v2' });
+
+        // Retrieve messages for both threads
+        const thread1Messages = await store.getMessages({ threadId: thread1.id, format: 'v2' });
+        const thread2Messages = await store.getMessages({ threadId: thread2.id, format: 'v2' });
+
+        // Thread 1 should NOT have the message with that id
+        expect(thread1Messages.find(m => m.id === message.id)).toBeUndefined();
+
+        // Thread 2 should have the message with that id
+        expect(thread2Messages.find(m => m.id === message.id)?.content.content).toBe('Thread2 Content');
+      });
     });
 
     describe('Single-Table Design', () => {
@@ -486,10 +774,12 @@ describe('DynamoDBStore Integration Tests', () => {
             step1: { status: 'success', output: { data: 'test' } },
             input: { source: 'test' },
           } as unknown as WorkflowRunState['context'],
+          serializedStepGraph: [],
           activePaths: [{ stepPath: ['test'], stepId: 'step1', status: 'success' }],
           suspendedPaths: { test: [1] },
           runId: 'mixed-run',
           timestamp: Date.now(),
+          status: 'success',
         };
         await store.persistWorkflowSnapshot({ workflowName, runId: 'mixed-run', snapshot: workflowSnapshot });
 
@@ -587,6 +877,37 @@ describe('DynamoDBStore Integration Tests', () => {
       expect(allTraces.length).toBe(3);
     });
 
+    test('should handle Date objects for createdAt/updatedAt fields in batchTraceInsert', async () => {
+      // This test specifically verifies the bug from the issue where Date objects
+      // were passed instead of ISO strings and ElectroDB validation failed
+      const now = new Date();
+      const traceWithDateObjects = {
+        id: `trace-${randomUUID()}`,
+        parentSpanId: `span-${randomUUID()}`,
+        traceId: `traceid-${randomUUID()}`,
+        name: 'test-trace-with-dates',
+        scope: 'default-tracer',
+        kind: 1,
+        startTime: now.getTime(),
+        endTime: now.getTime() + 100,
+        status: JSON.stringify({ code: 0 }),
+        attributes: JSON.stringify({ key: 'value' }),
+        events: JSON.stringify([]),
+        links: JSON.stringify([]),
+        // These are Date objects, not ISO strings - this should be handled by ElectroDB attribute setters
+        createdAt: now,
+        updatedAt: now,
+      };
+
+      // This should not throw a validation error due to Date object type
+      await expect(store.batchTraceInsert({ records: [traceWithDateObjects] })).resolves.not.toThrow();
+
+      // Verify the trace was saved correctly
+      const allTraces = await store.getTraces({ name: 'test-trace-with-dates', page: 1, perPage: 10 });
+      expect(allTraces.length).toBe(1);
+      expect(allTraces[0].name).toBe('test-trace-with-dates');
+    });
+
     test('should retrieve traces filtered by name using GSI', async () => {
       const trace1 = sampleTrace('trace-filter-name', 'scope-X');
       const trace2 = sampleTrace('trace-filter-name', 'scope-Y', Date.now() + 10);
@@ -668,6 +989,40 @@ describe('DynamoDBStore Integration Tests', () => {
       };
     };
 
+    test('should handle Date objects for createdAt/updatedAt fields in eval batchInsert', async () => {
+      // Test that eval entity properly handles Date objects in createdAt/updatedAt fields
+      const now = new Date();
+      const evalWithDateObjects = {
+        entity: 'eval',
+        agent_name: 'test-agent-dates',
+        input: 'Test input',
+        output: 'Test output',
+        result: JSON.stringify({ score: 0.95 }),
+        metric_name: 'test-metric',
+        instructions: 'Test instructions',
+        global_run_id: `global-${randomUUID()}`,
+        run_id: `run-${randomUUID()}`,
+        created_at: now, // Date object instead of ISO string
+        // These are Date objects, not ISO strings - should be handled by ElectroDB attribute setters
+        createdAt: now,
+        updatedAt: now,
+        metadata: JSON.stringify({ test: 'meta' }),
+      };
+
+      // This should not throw a validation error due to Date object type
+      await expect(
+        store.batchInsert({
+          tableName: TABLE_EVALS,
+          records: [evalWithDateObjects],
+        }),
+      ).resolves.not.toThrow();
+
+      // Verify the eval was saved correctly
+      const evals = await store.getEvalsByAgentName('test-agent-dates');
+      expect(evals.length).toBe(1);
+      expect(evals[0].agentName).toBe('test-agent-dates');
+    });
+
     test('should retrieve evals by agent name using GSI and filter by type', async () => {
       const agent1 = 'eval-agent-1';
       const agent2 = 'eval-agent-2';
@@ -734,10 +1089,12 @@ describe('DynamoDBStore Integration Tests', () => {
           step1: { status: 'success', output: { data: 'test' } },
           input: { source: 'test' },
         } as unknown as WorkflowRunState['context'],
+        serializedStepGraph: [],
         activePaths: [],
         suspendedPaths: {},
         runId: runId,
         timestamp: createdAt.getTime(),
+        status: 'success',
         ...(resourceId && { resourceId: resourceId }), // Conditionally add resourceId to snapshot
       };
       return {
@@ -778,6 +1135,53 @@ describe('DynamoDBStore Integration Tests', () => {
       expect(loadedSnapshot?.context).toEqual(snapshot.context);
     });
 
+    test('should allow updating an existing workflow snapshot', async () => {
+      const wfName = 'update-test-wf';
+      const runId = `run-${randomUUID()}`;
+
+      // Create initial snapshot
+      const { snapshot: initialSnapshot } = sampleWorkflowSnapshot(wfName, runId);
+
+      await expect(
+        store.persistWorkflowSnapshot({
+          workflowName: wfName,
+          runId: runId,
+          snapshot: initialSnapshot,
+        }),
+      ).resolves.not.toThrow();
+
+      // Create updated snapshot with different data
+      const updatedSnapshot: WorkflowRunState = {
+        ...initialSnapshot,
+        value: { currentState: 'completed' },
+        context: {
+          step1: { status: 'success', output: { data: 'updated-test' } },
+          step2: { status: 'success', output: { data: 'new-step' } },
+          input: { source: 'updated-test' },
+        } as unknown as WorkflowRunState['context'],
+        timestamp: Date.now(),
+      };
+
+      // This should succeed (update existing snapshot)
+      await expect(
+        store.persistWorkflowSnapshot({
+          workflowName: wfName,
+          runId: runId,
+          snapshot: updatedSnapshot,
+        }),
+      ).resolves.not.toThrow();
+
+      // Verify the snapshot was updated
+      const loadedSnapshot = await store.loadWorkflowSnapshot({
+        workflowName: wfName,
+        runId: runId,
+      });
+
+      expect(loadedSnapshot?.runId).toEqual(updatedSnapshot.runId);
+      expect(loadedSnapshot?.value).toEqual(updatedSnapshot.value);
+      expect(loadedSnapshot?.context).toEqual(updatedSnapshot.context);
+    });
+
     test('getWorkflowRunById should retrieve correct run', async () => {
       const wfName = 'get-by-id-wf';
       const runId1 = `run-${randomUUID()}`;
@@ -1009,6 +1413,32 @@ describe('DynamoDBStore Integration Tests', () => {
       }
     });
 
+    test('insert() should handle Date objects for createdAt/updatedAt fields', async () => {
+      // Test that individual insert method properly handles Date objects in date fields
+      const now = new Date();
+      const recordWithDates = {
+        id: `thread-${randomUUID()}`,
+        resourceId: `resource-${randomUUID()}`,
+        title: 'Thread with Date Objects',
+        // These are Date objects, not ISO strings - should be handled by preprocessing
+        createdAt: now,
+        updatedAt: now,
+        metadata: JSON.stringify({ test: 'with-dates' }),
+      };
+
+      // This should not throw a validation error due to Date object type
+      await expect(genericStore.insert({ tableName: TABLE_THREADS, record: recordWithDates })).resolves.not.toThrow();
+
+      // Verify the record was saved correctly
+      const loaded = await genericStore.load<StorageThreadType>({
+        tableName: TABLE_THREADS,
+        keys: { id: recordWithDates.id },
+      });
+      expect(loaded).not.toBeNull();
+      expect(loaded?.id).toBe(recordWithDates.id);
+      expect(loaded?.title).toBe('Thread with Date Objects');
+    });
+
     test('load() should return null for non-existent record', async () => {
       // Use the genericStore instance
       const loaded = await genericStore.load({ tableName: TABLE_THREADS, keys: { id: 'non-existent-generic' } });
@@ -1050,4 +1480,4 @@ describe('DynamoDBStore Integration Tests', () => {
       ).toBeNull();
     });
   }); // End Generic Storage Methods describe
-}); // End Main Describe
+});