@mastra/dynamodb 0.0.0-share-agent-metadata-with-cloud-20250718123411 → 0.0.0-sidebar-window-undefined-fix-20251029233656

package/src/storage/index.test.ts

@@ -1,1483 +0,0 @@
-import { spawn } from 'child_process';
-import { randomUUID } from 'crypto';
-import {
-  BatchWriteItemCommand,
-  CreateTableCommand,
-  DeleteTableCommand,
-  DescribeTableCommand,
-  DynamoDBClient,
-  ListTablesCommand,
-  ScanCommand,
-  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';
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import { DynamoDBStore } from '..';
-
-const TEST_TABLE_NAME = 'mastra-single-table-test'; // Define the single table name
-const LOCAL_ENDPOINT = 'http://localhost:8000';
-const LOCAL_REGION = 'local-test'; // Use a distinct region for local testing
-
-// Docker process handle
-let dynamodbProcess: ReturnType<typeof spawn>;
-
-// AWS SDK Client for setup/teardown
-let setupClient: DynamoDBClient;
-
-// Function to wait for DynamoDB Local to be ready
-async function waitForDynamoDBLocal(client: DynamoDBClient, timeoutMs = 90000): Promise<void> {
-  const startTime = Date.now();
-  console.log(`Waiting up to ${timeoutMs / 1000}s for DynamoDB Local...`);
-  while (Date.now() - startTime < timeoutMs) {
-    try {
-      await client.send(new ListTablesCommand({}));
-      console.log('DynamoDB Local is ready.');
-      return; // Success
-    } catch (e: unknown) {
-      let errorName: string | undefined;
-
-      if (e instanceof Error) {
-        errorName = e.name;
-      } else if (
-        typeof e === 'object' &&
-        e !== null &&
-        'name' in e &&
-        typeof (e as { name: unknown }).name === 'string'
-      ) {
-        errorName = (e as { name: string }).name;
-      }
-
-      if (errorName === 'ECONNREFUSED' || errorName === 'TimeoutError' || errorName === 'ERR_INVALID_PROTOCOL') {
-        // Expected errors while starting
-        await new Promise(resolve => setTimeout(resolve, 500)); // Wait before retrying
-      } else {
-        console.error('Unexpected error waiting for DynamoDB Local:', e);
-        throw e; // Rethrow unexpected errors
-      }
-    }
-  }
-  throw new Error(`DynamoDB Local did not become ready within ${timeoutMs}ms.`);
-}
-
-// Function to clear all items from the single table
-async function clearSingleTable(client: DynamoDBClient, tableName: string) {
-  let ExclusiveStartKey: Record<string, any> | undefined;
-  let items: Record<string, any>[] = [];
-
-  // Scan all items (handling pagination)
-  do {
-    const scanOutput = await client.send(
-      new ScanCommand({
-        TableName: tableName,
-        ExclusiveStartKey,
-        ProjectionExpression: 'pk, sk', // Only need keys for deletion
-      }),
-    );
-    items = items.concat(scanOutput.Items || []);
-    ExclusiveStartKey = scanOutput.LastEvaluatedKey;
-  } while (ExclusiveStartKey);
-
-  if (items.length === 0) {
-    return; // Nothing to delete
-  }
-
-  // Batch delete items (handling DynamoDB 25 item limit per batch)
-  const deleteRequests = items.map(item => ({
-    DeleteRequest: {
-      Key: { pk: item.pk, sk: item.sk },
-    },
-  }));
-
-  for (let i = 0; i < deleteRequests.length; i += 25) {
-    const batch = deleteRequests.slice(i, i + 25);
-    const command = new BatchWriteItemCommand({
-      RequestItems: {
-        [tableName]: batch,
-      },
-    });
-    // Handle unprocessed items if necessary (though less likely with local)
-    let result = await client.send(command);
-    while (
-      result.UnprocessedItems &&
-      result.UnprocessedItems[tableName] &&
-      result.UnprocessedItems[tableName].length > 0
-    ) {
-      console.warn(`Retrying ${result.UnprocessedItems[tableName].length} unprocessed delete items...`);
-      await new Promise(res => setTimeout(res, 200)); // Simple backoff
-      const retryCommand = new BatchWriteItemCommand({ RequestItems: result.UnprocessedItems });
-      result = await client.send(retryCommand);
-    }
-  }
-  // console.log(`Cleared ${items.length} items from ${tableName}`);
-}
-
-// Start DynamoDB Local container and create table
-beforeAll(async () => {
-  // Initialize client for setup
-  setupClient = new DynamoDBClient({
-    endpoint: LOCAL_ENDPOINT,
-    region: LOCAL_REGION,
-    credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-    // Increase timeout for setup operations
-    requestHandler: { requestTimeout: 10000 },
-    // Add retries for setup commands
-    maxAttempts: 5,
-  });
-
-  // Start DynamoDB Local using docker-compose
-  console.log('Starting DynamoDB Local container...');
-  dynamodbProcess = spawn('docker-compose', ['up', '-d'], {
-    cwd: __dirname, // Ensure docker-compose runs from the test file directory if needed
-    stdio: 'pipe', // Use pipe to potentially capture output if needed
-  });
-  dynamodbProcess.stderr?.on('data', data => console.error(`docker-compose stderr: ${data}`));
-  dynamodbProcess.on('error', err => console.error('Failed to start docker-compose:', err));
-
-  // Add a short fixed delay to allow the container process to stabilize before polling
-  console.log('Waiting a few seconds for container process to stabilize...');
-  await new Promise(resolve => setTimeout(resolve, 3000)); // 3-second delay
-
-  // Wait for DynamoDB to be ready
-  try {
-    await waitForDynamoDBLocal(setupClient);
-  } catch (e) {
-    console.error('Failed to connect to DynamoDB Local after startup.', e);
-    // Attempt to stop container on failure
-    spawn('docker-compose', ['down'], { cwd: __dirname, stdio: 'pipe' });
-    throw e; // Re-throw error to fail the test suite
-  }
-
-  // Delete the table if it exists from a previous run
-  try {
-    console.log(`Checking if table ${TEST_TABLE_NAME} exists...`);
-    await setupClient.send(new DescribeTableCommand({ TableName: TEST_TABLE_NAME }));
-    console.log(`Table ${TEST_TABLE_NAME} exists, attempting deletion...`);
-    await setupClient.send(new DeleteTableCommand({ TableName: TEST_TABLE_NAME }));
-    console.log(`Waiting for table ${TEST_TABLE_NAME} to be deleted...`);
-    await waitUntilTableNotExists({ client: setupClient, maxWaitTime: 60 }, { TableName: TEST_TABLE_NAME });
-    console.log(`Table ${TEST_TABLE_NAME} deleted.`);
-  } catch (e: unknown) {
-    let errorName: string | undefined;
-
-    if (e instanceof Error) {
-      errorName = e.name;
-    } else if (
-      typeof e === 'object' &&
-      e !== null &&
-      'name' in e &&
-      typeof (e as { name: unknown }).name === 'string'
-    ) {
-      errorName = (e as { name: string }).name;
-    }
-
-    if (errorName === 'ResourceNotFoundException') {
-      console.log(`Table ${TEST_TABLE_NAME} does not exist, proceeding.`);
-    } else {
-      console.error(`Error deleting table ${TEST_TABLE_NAME}:`, e);
-      throw e; // Rethrow other errors
-    }
-  }
-
-  // Create the single table with the correct schema
-  console.log(`Creating table ${TEST_TABLE_NAME}...`);
-  try {
-    const createTableCommand = new CreateTableCommand({
-      TableName: TEST_TABLE_NAME,
-      AttributeDefinitions: [
-        { AttributeName: 'pk', AttributeType: 'S' },
-        { AttributeName: 'sk', AttributeType: 'S' },
-        { AttributeName: 'gsi1pk', AttributeType: 'S' },
-        { AttributeName: 'gsi1sk', AttributeType: 'S' },
-        { AttributeName: 'gsi2pk', AttributeType: 'S' },
-        { AttributeName: 'gsi2sk', AttributeType: 'S' },
-      ],
-      KeySchema: [
-        { AttributeName: 'pk', KeyType: 'HASH' },
-        { AttributeName: 'sk', KeyType: 'RANGE' },
-      ],
-      GlobalSecondaryIndexes: [
-        {
-          IndexName: 'gsi1',
-          KeySchema: [
-            { AttributeName: 'gsi1pk', KeyType: 'HASH' },
-            { AttributeName: 'gsi1sk', KeyType: 'RANGE' },
-          ],
-          Projection: { ProjectionType: 'ALL' },
-        },
-        {
-          IndexName: 'gsi2',
-          KeySchema: [
-            { AttributeName: 'gsi2pk', KeyType: 'HASH' },
-            { AttributeName: 'gsi2sk', KeyType: 'RANGE' },
-          ],
-          Projection: { ProjectionType: 'ALL' },
-        },
-      ],
-      BillingMode: 'PAY_PER_REQUEST', // Use PAY_PER_REQUEST for local testing ease
-    });
-    await setupClient.send(createTableCommand);
-    console.log(`Waiting for table ${TEST_TABLE_NAME} to become active...`);
-    await waitUntilTableExists({ client: setupClient, maxWaitTime: 60 }, { TableName: TEST_TABLE_NAME });
-    console.log(`Table ${TEST_TABLE_NAME} created successfully.`);
-  } catch (e) {
-    console.error(`Failed to create table ${TEST_TABLE_NAME}:`, e);
-    throw e;
-  }
-}, 60000); // Increase timeout for beforeAll to accommodate Docker startup and table creation
-
-// Stop DynamoDB Local container
-afterAll(async () => {
-  console.log('Stopping DynamoDB Local container...');
-  // Optionally delete the table
-  // try {
-  //   await setupClient.send(new DeleteTableCommand({ TableName: TEST_TABLE_NAME }));
-  //   await waitUntilTableNotExists({ client: setupClient, maxWaitTime: 60 }, { TableName: TEST_TABLE_NAME });
-  //   console.log(`Test table ${TEST_TABLE_NAME} deleted.`);
-  // } catch (error) {
-  //   console.error(`Error deleting test table ${TEST_TABLE_NAME}:`, error);
-  // }
-
-  if (setupClient) {
-    setupClient.destroy();
-  }
-
-  const stopProcess = spawn('docker-compose', ['down', '--volumes'], {
-    // Remove volumes too
-    cwd: __dirname,
-    stdio: 'pipe',
-  });
-  stopProcess.stderr?.on('data', data => console.error(`docker-compose down stderr: ${data}`));
-  stopProcess.on('error', err => console.error('Failed to stop docker-compose:', err));
-  await new Promise(resolve => stopProcess.on('close', resolve)); // Wait for compose down
-
-  if (dynamodbProcess && !dynamodbProcess.killed) {
-    dynamodbProcess.kill();
-  }
-  console.log('DynamoDB Local container stopped.');
-}, 30000); // Increase timeout for afterAll
-
-describe('DynamoDBStore Integration Tests', () => {
-  let store: DynamoDBStore;
-
-  beforeAll(async () => {
-    // Initialize main store instance used by most tests
-    store = new DynamoDBStore({
-      name: 'DynamoDBStoreTest',
-      config: {
-        tableName: TEST_TABLE_NAME,
-        endpoint: LOCAL_ENDPOINT,
-        region: LOCAL_REGION,
-        credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-      },
-    });
-    console.log('Main DynamoDBStore initialized for tests.');
-  });
-
-  beforeEach(async () => {
-    // Clear table between tests using the setup client
-    await clearSingleTable(setupClient, TEST_TABLE_NAME);
-  });
-
-  afterAll(async () => {
-    // No client.destroy() needed here as the store manages its internal client
-    // Or if the store exposes a close/destroy method, call that.
-    if (store) {
-      await store.close(); // Assuming store has a close method
-    }
-  });
-
-  // DynamoDB-specific tests
-  describe('DynamoDB-specific operations', () => {
-    describe('Entity Operations', () => {
-      test('should persist and retrieve thread metadata', async () => {
-        const now = new Date();
-        const threadId = 'metadata-thread';
-        const metadata = { user: 'test-user', complex: { nested: true, arr: [1, 'a'] } };
-        const thread: StorageThreadType = {
-          id: threadId,
-          resourceId: 'resource-meta',
-          title: 'Metadata Test Thread',
-          createdAt: now,
-          updatedAt: now,
-          metadata: metadata,
-        };
-        await store.saveThread({ thread });
-        const retrieved = await store.getThreadById({ threadId });
-        expect(retrieved).toBeDefined();
-        expect(retrieved?.metadata).toEqual(metadata); // ElectroDB should handle JSON stringify/parse
-      });
-
-      test('should handle large workflow snapshots near DynamoDB item size limit', async () => {
-        // Test remains largely the same, relies on clearSingleTable working
-        const now = Date.now();
-        const largeSnapshot: WorkflowRunState = {
-          // ... (rest of the large snapshot definition) ...
-          value: { state: 'test' },
-          context: {
-            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(
-          store.persistWorkflowSnapshot({
-            workflowName: 'test-workflow-large',
-            runId: 'test-run-large',
-            snapshot: largeSnapshot,
-          }),
-        ).resolves.not.toThrow();
-
-        const retrieved = await store.loadWorkflowSnapshot({
-          workflowName: 'test-workflow-large',
-          runId: 'test-run-large',
-        });
-
-        expect(retrieved).toEqual(largeSnapshot);
-      }, 10000); // Increase timeout for potentially large item handling
-
-      test('should handle concurrent thread updates (last writer wins)', async () => {
-        // Test remains largely the same, verifies final state
-        const threadId = 'concurrent-thread';
-        const resourceId = 'resource-123';
-        const now = new Date();
-        const thread: StorageThreadType = {
-          id: threadId,
-          resourceId,
-          title: 'Initial Title',
-          createdAt: now,
-          updatedAt: now,
-          metadata: { initial: true },
-        };
-        await store.saveThread({ thread });
-
-        // Simulate potential delay between read and write for update 1
-        const update1 = async () => {
-          await new Promise(res => setTimeout(res, 50)); // Short delay
-          await store.updateThread({
-            id: threadId,
-            title: 'Updated Thread 1',
-            metadata: { update: 1, time: Date.now() },
-          });
-        };
-        // Simulate potential delay between read and write for update 2
-        const update2 = async () => {
-          await new Promise(res => setTimeout(res, 100)); // Slightly longer delay
-          await store.updateThread({
-            id: threadId,
-            title: 'Updated Thread 2',
-            metadata: { update: 2, time: Date.now() },
-          });
-        };
-
-        await Promise.all([update1(), update2()]);
-
-        const retrieved = await store.getThreadById({ threadId });
-        expect(retrieved).toBeDefined();
-        expect(retrieved?.id).toBe(threadId);
-        // In DynamoDB default (non-conditional) updates, the last writer wins.
-        // We expect title 2 / metadata 2 because update2 started later.
-        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', () => {
-      test('should handle batch message inserts efficiently (up to 25 items) [v1 storage]', async () => {
-        const startTime = Date.now(); // Get a base time
-        const threadId = 'batch-thread';
-        const messages: MastraMessageV1[] = Array.from({ length: 25 }, (_, i) => ({
-          id: `msg-${i}`,
-          threadId,
-          resourceId: 'test-resource',
-          content: `Message ${i}`,
-          // Increment timestamp slightly for each message to ensure order
-          createdAt: new Date(startTime + i),
-          role: i % 2 === 0 ? 'user' : 'assistant',
-          type: 'text',
-        }));
-
-        // Assuming saveMessages uses BatchWriteItem internally
-        await expect(store.saveMessages({ messages })).resolves.not.toThrow();
-
-        const retrieved = await store.getMessages({ threadId });
-        expect(retrieved).toHaveLength(25);
-        // Now the order should be guaranteed by the ascending createdAt timestamp
-        expect(retrieved[0]?.content).toBe('Message 0');
-        expect(retrieved[24]?.content).toBe('Message 24');
-      });
-
-      test('should handle batch message inserts efficiently (up to 25 items) [v2 storage]', async () => {
-        const startTime = Date.now(); // Get a base time
-        const threadId = 'batch-thread';
-        const messages: MastraMessageV2[] = Array.from({ length: 25 }, (_, i) => ({
-          id: `msg-${i}`,
-          threadId,
-          resourceId: 'test-resource',
-          content: { format: 2, parts: [{ type: 'text', text: `Message ${i}` }] },
-          // Increment timestamp slightly for each message to ensure order
-          createdAt: new Date(startTime + i),
-          role: i % 2 === 0 ? 'user' : 'assistant',
-          type: 'text',
-        }));
-
-        // Assuming saveMessages uses BatchWriteItem internally
-        await expect(store.saveMessages({ messages, format: 'v2' })).resolves.not.toThrow();
-
-        const retrieved = await store.getMessages({ threadId, format: 'v2' });
-        expect(retrieved).toHaveLength(25);
-        // Now the order should be guaranteed by the ascending createdAt timestamp
-        if (retrieved[0]?.content?.parts[0]?.type !== `text`) throw new Error(`Expected text part`);
-        expect(retrieved[0].content.parts[0].text).toBe('Message 0');
-        if (retrieved[24]?.content?.parts?.[0]?.type !== `text`) throw new Error(`Expected text part`);
-        expect(retrieved[24].content.parts[0].text).toBe('Message 24');
-      });
-
-      test('should handle batch inserts exceeding 25 items (if saveMessages chunks)', async () => {
-        const startTime = Date.now(); // Get a base time
-        const threadId = 'batch-thread-large';
-        const messages: MastraMessageV1[] = Array.from({ length: 30 }, (_, i) => ({
-          id: `msg-large-${i}`,
-          threadId,
-          resourceId: 'test-resource-large',
-          content: `Large Message ${i}`,
-          // Increment timestamp slightly for each message to ensure order
-          createdAt: new Date(startTime + i),
-          role: 'user',
-          type: 'text',
-        }));
-
-        await expect(store.saveMessages({ messages })).resolves.not.toThrow();
-
-        const retrieved = await store.getMessages({ threadId });
-        expect(retrieved).toHaveLength(30); // Verify all were saved
-        // Add order check for the > 25 test as well
-        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', () => {
-      test('should maintain entity separation in single table', async () => {
-        // Test remains largely the same
-        const threadId = 'mixed-thread';
-        const workflowName = 'mixed-workflow';
-        const now = new Date();
-        const thread: StorageThreadType = {
-          id: threadId,
-          resourceId: 'mixed-resource',
-          title: 'Mixed Thread',
-          createdAt: now,
-          updatedAt: now,
-          metadata: { type: 'thread' },
-        };
-        await store.saveThread({ thread });
-
-        const workflowSnapshot: WorkflowRunState = {
-          // ...(snapshot definition)
-          value: { state: 'test' },
-          context: {
-            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 });
-
-        const retrievedThread = await store.getThreadById({ threadId });
-        const retrievedWorkflow = await store.loadWorkflowSnapshot({ workflowName, runId: 'mixed-run' });
-
-        expect(retrievedThread?.metadata?.type).toBe('thread');
-        expect(retrievedWorkflow).toEqual(workflowSnapshot);
-      });
-    });
-
-    describe('Error Handling', () => {
-      test('should handle non-existent IDs gracefully for getById methods', async () => {
-        const nonExistentId = 'does-not-exist';
-        // Test getThreadById (already partially covered but good to keep specific)
-        const thread = await store.getThreadById({ threadId: nonExistentId });
-        expect(thread).toBeNull();
-
-        // Test loadWorkflowSnapshot (already covered in Workflow tests, technically)
-        const snapshot = await store.loadWorkflowSnapshot({ workflowName: nonExistentId, runId: nonExistentId });
-        expect(snapshot).toBeNull();
-
-        // Test getWorkflowRunById (already covered in Workflow tests, technically)
-        const workflowRun = await store.getWorkflowRunById({ runId: nonExistentId });
-        expect(workflowRun).toBeNull();
-      });
-
-      test('getMessages should return empty array for non-existent thread', async () => {
-        const messages = await store.getMessages({ threadId: 'non-existent-thread' });
-        expect(messages).toEqual([]);
-      });
-
-      test('getThreadsByResourceId should return empty array for non-existent resourceId', async () => {
-        const threads = await store.getThreadsByResourceId({ resourceId: 'non-existent-resource' });
-        expect(threads).toEqual([]);
-      });
-
-      test('getTraces should return empty array when no traces match filter', async () => {
-        const tracesByName = await store.getTraces({ name: 'non-existent-trace', page: 1, perPage: 10 });
-        expect(tracesByName).toEqual([]);
-        const tracesByScope = await store.getTraces({ scope: 'non-existent-scope', page: 1, perPage: 10 });
-        expect(tracesByScope).toEqual([]);
-      });
-
-      test('getEvalsByAgentName should return empty array for non-existent agent', async () => {
-        const evals = await store.getEvalsByAgentName('non-existent-agent');
-        expect(evals).toEqual([]);
-      });
-
-      test('getWorkflowRuns should return empty result for non-existent filters', async () => {
-        const { runs: runsByName, total: totalByName } = await store.getWorkflowRuns({
-          workflowName: 'non-existent-workflow',
-        });
-        expect(runsByName).toEqual([]);
-        expect(totalByName).toBe(0);
-
-        const { runs: runsByResource, total: totalByResource } = await store.getWorkflowRuns({
-          resourceId: 'non-existent-resource',
-        });
-        expect(runsByResource).toEqual([]);
-        expect(totalByResource).toBe(0);
-      });
-    }); // End Error Handling describe
-  });
-
-  // --- Trace Operations Tests ---
-  describe('Trace Operations', () => {
-    const sampleTrace = (name: string, scope: string, startTime = Date.now()) => ({
-      id: `trace-${randomUUID()}`,
-      parentSpanId: `span-${randomUUID()}`,
-      traceId: `traceid-${randomUUID()}`,
-      name,
-      scope,
-      kind: 1, // Example kind
-      startTime: startTime,
-      endTime: startTime + 100, // Example duration
-      status: JSON.stringify({ code: 0 }), // Example status
-      attributes: JSON.stringify({ key: 'value', scopeAttr: scope }),
-      events: JSON.stringify([{ name: 'event1', timestamp: startTime + 50 }]),
-      links: JSON.stringify([]),
-      createdAt: new Date(startTime).toISOString(),
-      updatedAt: new Date(startTime).toISOString(),
-    });
-
-    test('should batch insert and retrieve traces', async () => {
-      const trace1 = sampleTrace('trace-op-1', 'scope-A');
-      const trace2 = sampleTrace('trace-op-2', 'scope-A', Date.now() + 10);
-      const trace3 = sampleTrace('trace-op-3', 'scope-B', Date.now() + 20);
-      const records = [trace1, trace2, trace3];
-
-      await expect(store.batchTraceInsert({ records })).resolves.not.toThrow();
-
-      // Retrieve all (via scan, assuming low test data volume)
-      const allTraces = await store.getTraces({ page: 1, perPage: 10 });
-      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);
-      const trace3 = sampleTrace('other-name', 'scope-X', Date.now() + 20);
-      await store.batchTraceInsert({ records: [trace1, trace2, trace3] });
-
-      const filteredTraces = await store.getTraces({ name: 'trace-filter-name', page: 1, perPage: 10 });
-      expect(filteredTraces.length).toBe(2);
-      expect(filteredTraces.every(t => t.name === 'trace-filter-name')).toBe(true);
-      // Check if sorted by startTime (GSI SK) - ascending default
-      expect(filteredTraces[0].scope).toBe('scope-X');
-      expect(filteredTraces[1].scope).toBe('scope-Y');
-    });
-
-    test('should retrieve traces filtered by scope using GSI', async () => {
-      const trace1 = sampleTrace('trace-filter-scope-A', 'scope-TARGET');
-      const trace2 = sampleTrace('trace-filter-scope-B', 'scope-OTHER', Date.now() + 10);
-      const trace3 = sampleTrace('trace-filter-scope-C', 'scope-TARGET', Date.now() + 20);
-      await store.batchTraceInsert({ records: [trace1, trace2, trace3] });
-
-      const filteredTraces = await store.getTraces({ scope: 'scope-TARGET', page: 1, perPage: 10 });
-      expect(filteredTraces.length).toBe(2);
-      expect(filteredTraces.every(t => t.scope === 'scope-TARGET')).toBe(true);
-      // Check if sorted by startTime (GSI SK) - ascending default
-      expect(filteredTraces[0].name).toBe('trace-filter-scope-A');
-      expect(filteredTraces[1].name).toBe('trace-filter-scope-C');
-    });
-
-    test('should handle pagination for getTraces', async () => {
-      const traceData = Array.from({ length: 5 }, (_, i) =>
-        sampleTrace('trace-page', `scope-page`, Date.now() + i * 10),
-      );
-      await store.batchTraceInsert({ records: traceData });
-
-      // Get page 1 (first 2 items)
-      const page1 = await store.getTraces({ name: 'trace-page', page: 1, perPage: 2 });
-      expect(page1.length).toBe(2);
-      // Use non-null assertion (!) since lengths are verified
-      expect(page1[0]!.startTime).toBe(traceData[0]!.startTime);
-      expect(page1[1]!.startTime).toBe(traceData[1]!.startTime);
-
-      // Get page 2 (next 2 items)
-      const page2 = await store.getTraces({ name: 'trace-page', page: 2, perPage: 2 });
-      expect(page2.length).toBe(2);
-      expect(page2[0]!.startTime).toBe(traceData[2]!.startTime);
-      expect(page2[1]!.startTime).toBe(traceData[3]!.startTime);
-
-      // Get page 3 (last 1 item)
-      const page3 = await store.getTraces({ name: 'trace-page', page: 3, perPage: 2 });
-      expect(page3.length).toBe(1);
-      expect(page3[0]!.startTime).toBe(traceData[4]!.startTime);
-
-      // Get page beyond results
-      const page4 = await store.getTraces({ name: 'trace-page', page: 4, perPage: 2 });
-      expect(page4.length).toBe(0);
-    });
-  }); // End Trace Operations describe
-
-  // --- Eval Operations Tests ---
-  describe('Eval Operations', () => {
-    const sampleEval = (agentName: string, isTest = false, createdAt = new Date()) => {
-      const testInfo = isTest ? { testPath: 'test/path.ts', testName: 'Test Name' } : undefined;
-      return {
-        entity: 'eval', // Important for saving
-        agent_name: agentName,
-        input: 'Sample input',
-        output: 'Sample output',
-        result: JSON.stringify({ score: Math.random() }), // Random score
-        metric_name: 'sample-metric',
-        instructions: 'Sample instructions',
-        test_info: testInfo ? JSON.stringify(testInfo) : undefined,
-        global_run_id: `global-${randomUUID()}`,
-        run_id: `run-${randomUUID()}`,
-        created_at: createdAt.toISOString(),
-        // Add core MastraStorage fields
-        createdAt: createdAt.toISOString(),
-        updatedAt: createdAt.toISOString(),
-        metadata: JSON.stringify({ custom: 'eval_meta' }),
-      };
-    };
-
-    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';
-      const time1 = new Date();
-      const time2 = new Date(Date.now() + 1000);
-      const time3 = new Date(Date.now() + 2000);
-      const time4 = new Date(Date.now() + 3000);
-
-      const eval1_live = sampleEval(agent1, false, time1);
-      const eval1_test = sampleEval(agent1, true, time2);
-      const eval2_live = sampleEval(agent2, false, time3);
-      const eval1_live_later = sampleEval(agent1, false, time4);
-
-      // Use generic batchInsert (which expects entity prop already set)
-      await store.batchInsert({
-        tableName: TABLE_EVALS,
-        records: [eval1_live, eval1_test, eval2_live, eval1_live_later],
-      });
-
-      // Get all for agent1 (expecting DESCENDING order now)
-      const allAgent1 = await store.getEvalsByAgentName(agent1);
-      expect(allAgent1.length).toBe(3);
-      // Assert descending order (newest first)
-      expect(allAgent1[0]!.runId).toBe(eval1_live_later.run_id); // Newest (time4)
-      expect(allAgent1[1]!.runId).toBe(eval1_test.run_id); // Middle (time2)
-      expect(allAgent1[2]!.runId).toBe(eval1_live.run_id); // Oldest (time1)
-
-      // Get only live for agent1 (should be 2, ordered descending)
-      const liveAgent1 = await store.getEvalsByAgentName(agent1, 'live');
-      expect(liveAgent1.length).toBe(2);
-      // Assert descending order
-      expect(liveAgent1[0]!.runId).toBe(eval1_live_later.run_id); // Newest live (time4)
-      expect(liveAgent1[1]!.runId).toBe(eval1_live.run_id); // Oldest live (time1)
-
-      // Get only test for agent1 (should be 1)
-      const testAgent1 = await store.getEvalsByAgentName(agent1, 'test');
-      expect(testAgent1.length).toBe(1);
-      expect(testAgent1[0]!.runId).toBe(eval1_test.run_id);
-      expect(testAgent1[0]!.testInfo).toEqual(JSON.parse(eval1_test.test_info!));
-
-      // Get for agent2 (should be 1)
-      const allAgent2 = await store.getEvalsByAgentName(agent2);
-      expect(allAgent2.length).toBe(1);
-      expect(allAgent2[0]!.runId).toBe(eval2_live.run_id);
-
-      // Get for non-existent agent
-      const none = await store.getEvalsByAgentName('non-existent-agent');
-      expect(none.length).toBe(0);
-    });
-  }); // End Eval Operations describe
-
-  // --- Workflow Operations Tests ---
-  describe('Workflow Operations', () => {
-    const sampleWorkflowSnapshot = (
-      workflowName: string,
-      runId: string,
-      resourceId?: string,
-      createdAt = new Date(),
-      status = 'running',
-    ): { recordData: Record<string, any>; snapshot: WorkflowRunState } => {
-      const snapshot: WorkflowRunState = {
-        value: { currentState: status },
-        context: {
-          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 {
-        recordData: {
-          entity: 'workflow_snapshot',
-          workflow_name: workflowName,
-          run_id: runId,
-          snapshot: JSON.stringify(snapshot),
-          createdAt: createdAt.toISOString(),
-          updatedAt: createdAt.toISOString(),
-          resourceId: resourceId, // Store resourceId directly if available
-          metadata: JSON.stringify({ wf: 'meta' }),
-        },
-        snapshot: snapshot,
-      };
-    };
-
-    test('should persist and load a workflow snapshot', async () => {
-      const wfName = 'persist-test-wf';
-      const runId = `run-${randomUUID()}`;
-      const { snapshot } = sampleWorkflowSnapshot(wfName, runId);
-
-      await expect(
-        store.persistWorkflowSnapshot({
-          workflowName: wfName,
-          runId: runId,
-          snapshot: snapshot,
-        }),
-      ).resolves.not.toThrow();
-
-      const loadedSnapshot = await store.loadWorkflowSnapshot({
-        workflowName: wfName,
-        runId: runId,
-      });
-      // Compare only relevant parts, as persist might add internal fields
-      expect(loadedSnapshot?.runId).toEqual(snapshot.runId);
-      expect(loadedSnapshot?.value).toEqual(snapshot.value);
-      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()}`;
-      const runId2 = `run-${randomUUID()}`;
-      const wf1 = sampleWorkflowSnapshot(wfName, runId1);
-      const wf2 = sampleWorkflowSnapshot(wfName, runId2);
-
-      await store.batchInsert({ tableName: TABLE_WORKFLOW_SNAPSHOT, records: [wf1.recordData, wf2.recordData] });
-
-      const found = await store.getWorkflowRunById({ runId: runId1, workflowName: wfName });
-      expect(found).toBeDefined();
-      expect(found!.runId).toBe(runId1);
-      expect(found!.workflowName).toBe(wfName);
-
-      const notFound = await store.getWorkflowRunById({ runId: 'non-existent', workflowName: wfName });
-      expect(notFound).toBeNull();
-    });
-
-    test('getWorkflowRuns should return all runs when no filters applied', async () => {
-      const wfName = 'get-runs-all';
-      const runId1 = `run-${randomUUID()}`;
-      const runId2 = `run-${randomUUID()}`;
-      const wf1 = sampleWorkflowSnapshot(wfName, runId1, undefined, new Date(Date.now() - 1000));
-      const wf2 = sampleWorkflowSnapshot(wfName, runId2, undefined, new Date());
-
-      await store.batchInsert({ tableName: TABLE_WORKFLOW_SNAPSHOT, records: [wf1.recordData, wf2.recordData] });
-
-      const { runs, total } = await store.getWorkflowRuns(); // No filters
-      // Note: Scan order is not guaranteed, check for presence and count
-      expect(total).toBe(2);
-      expect(runs.length).toBe(2);
-      expect(runs.map(r => r.runId)).toEqual(expect.arrayContaining([runId1, runId2]));
-    });
-
-    test('getWorkflowRuns should filter by workflowName', async () => {
-      const wfName1 = 'get-runs-filter-name1';
-      const wfName2 = 'get-runs-filter-name2';
-      const runId1 = `run-${randomUUID()}`;
-      const runId2 = `run-${randomUUID()}`;
-      const wf1 = sampleWorkflowSnapshot(wfName1, runId1);
-      const wf2 = sampleWorkflowSnapshot(wfName2, runId2);
-
-      await store.batchInsert({ tableName: TABLE_WORKFLOW_SNAPSHOT, records: [wf1.recordData, wf2.recordData] });
-
-      const { runs, total } = await store.getWorkflowRuns({ workflowName: wfName1 });
-      expect(total).toBe(1);
-      expect(runs.length).toBe(1);
-      expect(runs[0]!.runId).toBe(runId1);
-    });
-
-    test('getWorkflowRuns should filter by resourceId', async () => {
-      const wfName = 'get-runs-filter-resource';
-      const resource1 = 'resource-filter-1';
-      const resource2 = 'resource-filter-2';
-      const runId1 = `run-${randomUUID()}`;
-      const runId2 = `run-${randomUUID()}`;
-      const runId3 = `run-${randomUUID()}`;
-      const wf1 = sampleWorkflowSnapshot(wfName, runId1, resource1);
-      const wf2 = sampleWorkflowSnapshot(wfName, runId2, resource2);
-      const wf3 = sampleWorkflowSnapshot(wfName, runId3, resource1);
-
-      await store.batchInsert({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        records: [wf1.recordData, wf2.recordData, wf3.recordData],
-      });
-
-      const { runs, total } = await store.getWorkflowRuns({ resourceId: resource1 });
-      // Note: Scan order not guaranteed
-      expect(total).toBe(2);
-      expect(runs.length).toBe(2);
-      expect(runs.map(r => r.runId)).toEqual(expect.arrayContaining([runId1, runId3]));
-      expect(runs.every(r => r.resourceId === resource1)).toBe(true);
-    });
-
-    test('getWorkflowRuns should filter by date range', async () => {
-      const wfName = 'get-runs-filter-date';
-      const time1 = new Date(2024, 0, 10); // Jan 10 2024
-      const time2 = new Date(2024, 0, 15); // Jan 15 2024
-      const time3 = new Date(2024, 0, 20); // Jan 20 2024
-      const runId1 = `run-${randomUUID()}`;
-      const runId2 = `run-${randomUUID()}`;
-      const runId3 = `run-${randomUUID()}`;
-      const wf1 = sampleWorkflowSnapshot(wfName, runId1, undefined, time1);
-      const wf2 = sampleWorkflowSnapshot(wfName, runId2, undefined, time2);
-      const wf3 = sampleWorkflowSnapshot(wfName, runId3, undefined, time3);
-
-      await store.batchInsert({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        records: [wf1.recordData, wf2.recordData, wf3.recordData],
-      });
-
-      const { runs, total } = await store.getWorkflowRuns({
-        fromDate: new Date(2024, 0, 12), // Jan 12
-        toDate: new Date(2024, 0, 18), // Jan 18
-      });
-      expect(total).toBe(1);
-      expect(runs.length).toBe(1);
-      expect(runs[0]!.runId).toBe(runId2); // Only wf2 falls within the range
-    });
-
-    test('getWorkflowRuns should handle pagination (limit/offset)', async () => {
-      const wfName = 'get-runs-pagination';
-      const snapshots = Array.from({ length: 5 }, (_, i) =>
-        sampleWorkflowSnapshot(wfName, `run-page-${i}`, undefined, new Date(Date.now() + i * 1000)),
-      );
-      await store.batchInsert({ tableName: TABLE_WORKFLOW_SNAPSHOT, records: snapshots.map(s => s.recordData) });
-
-      // Get page 1 (limit 2, offset 0)
-      const page1 = await store.getWorkflowRuns({ workflowName: wfName, limit: 2, offset: 0 });
-      expect(page1.total).toBe(5);
-      expect(page1.runs.length).toBe(2);
-      // Scan order not guaranteed, check for presence of two expected runs
-      const page1Ids = page1.runs.map(r => r.runId);
-      expect(snapshots.slice(0, 2).map(s => s!.recordData.run_id)).toEqual(expect.arrayContaining(page1Ids));
-
-      // Get page 2 (limit 2, offset 2)
-      const page2 = await store.getWorkflowRuns({ workflowName: wfName, limit: 2, offset: 2 });
-      expect(page2.total).toBe(5);
-      expect(page2.runs.length).toBe(2);
-      const page2Ids = page2.runs.map(r => r.runId);
-      expect(snapshots.slice(2, 4).map(s => s!.recordData.run_id)).toEqual(expect.arrayContaining(page2Ids));
-
-      // Get page 3 (limit 2, offset 4)
-      const page3 = await store.getWorkflowRuns({ workflowName: wfName, limit: 2, offset: 4 });
-      expect(page3.total).toBe(5);
-      expect(page3.runs.length).toBe(1);
-      // Use explicit type assertion for runs array access to fix linter error
-      expect((page3.runs as WorkflowRun[])[0]!.runId).toBe(snapshots[4]!.recordData.run_id);
-
-      // Get page beyond results (offset 5)
-      const page4 = await store.getWorkflowRuns({ workflowName: wfName, limit: 2, offset: 5 });
-      expect(page4.total).toBe(5);
-      expect(page4.runs.length).toBe(0);
-    });
-  }); // End Workflow Operations describe
-
-  // --- Initialization & Configuration Tests ---
-  describe('Initialization & Configuration', () => {
-    test('should throw error if tableName is missing in config', () => {
-      expect(() => {
-        new DynamoDBStore({
-          name: 'MissingTableStore',
-          config: {
-            endpoint: LOCAL_ENDPOINT,
-            region: LOCAL_REGION,
-            credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-          } as any, // Cast to any to bypass compile-time check for this specific test
-        });
-      }).toThrow(/tableName must be provided/); // Check for specific error message if possible
-    });
-
-    test('should throw error during operations if table does not exist', async () => {
-      // Use a valid but random table name unlikely to exist
-      const nonExistentTableName = `non-existent-${randomUUID()}`;
-      const storeWithInvalidTable = new DynamoDBStore({
-        name: 'InvalidTableStore',
-        config: {
-          tableName: nonExistentTableName,
-          endpoint: LOCAL_ENDPOINT,
-          region: LOCAL_REGION,
-          credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-        },
-      });
-
-      await expect(storeWithInvalidTable.getThreadById({ threadId: 'any-id' }))
-        .rejects // Update regex to match either DDB error or ElectroDB wrapper
-        .toThrow(/ResourceNotFoundException|Table.*does not exist|Cannot do operations on a non-existent table/);
-    });
-
-    test('init() should throw error if table does not exist', async () => {
-      // Use a valid but random table name unlikely to exist
-      const nonExistentTableName = `non-existent-init-${randomUUID()}`;
-      const storeWithInvalidTable = new DynamoDBStore({
-        name: 'InvalidTableStoreInit',
-        config: {
-          tableName: nonExistentTableName,
-          endpoint: LOCAL_ENDPOINT,
-          region: LOCAL_REGION,
-          credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-        },
-      });
-
-      await expect(storeWithInvalidTable.init())
-        .rejects // Update regex here too for consistency
-        .toThrow(/ResourceNotFoundException|Table.*does not exist|Cannot do operations on a non-existent table/);
-    });
-  }); // End Initialization & Configuration describe
-
-  // --- Generic Storage Methods Tests ---
-  describe('Generic Storage Methods (`insert`, `load`, `batchInsert`, `clearTable`)', () => {
-    // Declare genericStore specific to this block
-    let genericStore: DynamoDBStore;
-
-    beforeAll(() => {
-      // Initialize genericStore using the same config as the main store
-      genericStore = new DynamoDBStore({
-        name: 'DynamoDBGenericTest',
-        config: {
-          tableName: TEST_TABLE_NAME, // Ensure this uses the correct test table
-          endpoint: LOCAL_ENDPOINT,
-          region: LOCAL_REGION,
-          credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
-        },
-      });
-      console.log('Generic test store initialized for generic tests.');
-    });
-
-    const sampleThreadData = (id: string) => ({
-      entity: 'thread',
-      id: id,
-      resourceId: `resource-${randomUUID()}`,
-      title: 'Generic Test Thread',
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      metadata: JSON.stringify({ generic: true }),
-    });
-
-    test('insert() should save a record', async () => {
-      const threadId = `thread-${randomUUID()}`;
-      const record = sampleThreadData(threadId);
-      // Use the genericStore instance
-      await expect(genericStore.insert({ tableName: TABLE_THREADS, record })).resolves.not.toThrow();
-      const loaded = await genericStore.load<StorageThreadType>({ tableName: TABLE_THREADS, keys: { id: threadId } });
-      expect(loaded).not.toBeNull();
-      if (loaded) {
-        expect(loaded.id).toBe(threadId);
-        expect(loaded.title).toBe('Generic Test Thread');
-        expect(loaded.metadata).toEqual({ generic: true });
-      }
-    });
-
-    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' } });
-      expect(loaded).toBeNull();
-    });
-
-    test('batchInsert() should save multiple records', async () => {
-      const threadId1 = `thread-batch-${randomUUID()}`;
-      const threadId2 = `thread-batch-${randomUUID()}`;
-      const records = [sampleThreadData(threadId1), sampleThreadData(threadId2)];
-      // Use the genericStore instance
-      await expect(genericStore.batchInsert({ tableName: TABLE_THREADS, records })).resolves.not.toThrow();
-      const loaded1 = await genericStore.load<StorageThreadType>({ tableName: TABLE_THREADS, keys: { id: threadId1 } });
-      const loaded2 = await genericStore.load<StorageThreadType>({ tableName: TABLE_THREADS, keys: { id: threadId2 } });
-      expect(loaded1).toBeDefined();
-      expect(loaded2).toBeDefined();
-      expect(loaded1?.id).toBe(threadId1);
-      expect(loaded2?.id).toBe(threadId2);
-    });
-
-    test('clearTable() should remove all records for the logical table', async () => {
-      const threadId1 = `thread-clear-${randomUUID()}`;
-      const threadId2 = `thread-clear-${randomUUID()}`;
-      const records = [sampleThreadData(threadId1), sampleThreadData(threadId2)];
-      // Use the genericStore instance
-      await genericStore.batchInsert({ tableName: TABLE_THREADS, records });
-      expect(
-        await genericStore.load<StorageThreadType>({ tableName: TABLE_THREADS, keys: { id: threadId1 } }),
-      ).toBeDefined();
-      expect(
-        await genericStore.load<StorageThreadType>({ tableName: TABLE_THREADS, keys: { id: threadId2 } }),
-      ).toBeDefined();
-      await expect(genericStore.clearTable({ tableName: TABLE_THREADS })).resolves.not.toThrow();
-      expect(
-        await genericStore.load<StorageThreadType>({ tableName: TABLE_THREADS, keys: { id: threadId1 } }),
-      ).toBeNull();
-      expect(
-        await genericStore.load<StorageThreadType>({ tableName: TABLE_THREADS, keys: { id: threadId2 } }),
-      ).toBeNull();
-    });
-  }); // End Generic Storage Methods describe
-});