@mastra/dynamodb 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/index.cjs

@@ -939,11 +939,113 @@ function getElectroDbService(client, tableName) {
     }
   );
 }
+function resolveDynamoDBConfig(config) {
+  if ("service" in config) {
+    return config.service;
+  }
+  const dynamoClient = new clientDynamodb.DynamoDBClient({
+    region: config.region || "us-east-1",
+    endpoint: config.endpoint,
+    credentials: config.credentials
+  });
+  const client = libDynamodb.DynamoDBDocumentClient.from(dynamoClient);
+  return getElectroDbService(client, config.tableName);
+}
+var ENTITY_MAP = {
+  [storage.TABLE_THREADS]: "thread",
+  [storage.TABLE_MESSAGES]: "message",
+  [storage.TABLE_RESOURCES]: "resource",
+  [storage.TABLE_WORKFLOW_SNAPSHOT]: "workflow_snapshot",
+  [storage.TABLE_SCORERS]: "score"
+};
+function getDeleteKey(entityName, item) {
+  const key = { entity: entityName };
+  switch (entityName) {
+    case "thread":
+    case "message":
+    case "resource":
+    case "score":
+      key.id = item.id;
+      break;
+    case "workflow_snapshot":
+      key.workflow_name = item.workflow_name;
+      key.run_id = item.run_id;
+      break;
+    default:
+      key.id = item.id;
+  }
+  return key;
+}
+async function deleteTableData(service, tableName) {
+  const entityName = ENTITY_MAP[tableName];
+  if (!entityName || !service.entities[entityName]) {
+    throw new Error(`No entity mapping found for table: ${tableName}`);
+  }
+  const entity = service.entities[entityName];
+  const result = await entity.scan.go({ pages: "all" });
+  if (!result.data.length) {
+    return;
+  }
+  const batchSize = 25;
+  for (let i = 0; i < result.data.length; i += batchSize) {
+    const batch = result.data.slice(i, i + batchSize);
+    const keysToDelete = batch.map((item) => getDeleteKey(entityName, item));
+    await entity.delete(keysToDelete).go();
+  }
+}
+
+// src/storage/domains/memory/index.ts
 var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
   service;
-  constructor({ service }) {
+  constructor(config) {
     super();
-    this.service = service;
+    this.service = resolveDynamoDBConfig(config);
+  }
+  async dangerouslyClearAll() {
+    await deleteTableData(this.service, storage.TABLE_THREADS);
+    await deleteTableData(this.service, storage.TABLE_MESSAGES);
+    await deleteTableData(this.service, storage.TABLE_RESOURCES);
+  }
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    this.logger.debug("Deleting messages", { count: messageIds.length });
+    try {
+      const threadIds = /* @__PURE__ */ new Set();
+      const batchSize = 25;
+      for (let i = 0; i < messageIds.length; i += batchSize) {
+        const batch = messageIds.slice(i, i + batchSize);
+        const messagesToDelete = await Promise.all(
+          batch.map(async (id) => {
+            const result = await this.service.entities.message.get({ entity: "message", id }).go();
+            return result.data;
+          })
+        );
+        for (const message of messagesToDelete) {
+          if (message) {
+            if (message.threadId) {
+              threadIds.add(message.threadId);
+            }
+            await this.service.entities.message.delete({ entity: "message", id: message.id }).go();
+          }
+        }
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const threadId of threadIds) {
+        await this.service.entities.thread.update({ entity: "thread", id: threadId }).set({ updatedAt: now }).go();
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DYNAMODB", "DELETE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: messageIds.length }
+        },
+        error$1
+      );
+    }
   }
   // Helper function to parse message data (handle JSON fields)
   parseMessageData(data) {
@@ -1637,334 +1739,14 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
     }
   }
 };
-var StoreOperationsDynamoDB = class extends storage.StoreOperations {
-  client;
-  tableName;
-  service;
-  constructor({
-    service,
-    tableName,
-    client
-  }) {
-    super();
-    this.service = service;
-    this.client = client;
-    this.tableName = tableName;
-  }
-  async hasColumn() {
-    return true;
-  }
-  async dropTable() {
-  }
-  // Helper methods for entity/table mapping
-  getEntityNameForTable(tableName) {
-    const mapping = {
-      [storage.TABLE_THREADS]: "thread",
-      [storage.TABLE_MESSAGES]: "message",
-      [storage.TABLE_WORKFLOW_SNAPSHOT]: "workflow_snapshot",
-      [storage.TABLE_SCORERS]: "score",
-      [storage.TABLE_TRACES]: "trace",
-      [storage.TABLE_RESOURCES]: "resource",
-      [storage.TABLE_SPANS]: "ai_span",
-      mastra_agents: "agent"
-    };
-    return mapping[tableName] || null;
-  }
-  /**
-   * Pre-processes a record to ensure Date objects are converted to ISO strings
-   * This is necessary because ElectroDB validation happens before setters are applied
-   */
-  preprocessRecord(record) {
-    const processed = { ...record };
-    if (processed.createdAt instanceof Date) {
-      processed.createdAt = processed.createdAt.toISOString();
-    }
-    if (processed.updatedAt instanceof Date) {
-      processed.updatedAt = processed.updatedAt.toISOString();
-    }
-    if (processed.created_at instanceof Date) {
-      processed.created_at = processed.created_at.toISOString();
-    }
-    if (processed.result && typeof processed.result === "object") {
-      processed.result = JSON.stringify(processed.result);
-    }
-    if (processed.test_info && typeof processed.test_info === "object") {
-      processed.test_info = JSON.stringify(processed.test_info);
-    } else if (processed.test_info === void 0 || processed.test_info === null) {
-      delete processed.test_info;
-    }
-    if (processed.snapshot && typeof processed.snapshot === "object") {
-      processed.snapshot = JSON.stringify(processed.snapshot);
-    }
-    if (processed.attributes && typeof processed.attributes === "object") {
-      processed.attributes = JSON.stringify(processed.attributes);
-    }
-    if (processed.status && typeof processed.status === "object") {
-      processed.status = JSON.stringify(processed.status);
-    }
-    if (processed.events && typeof processed.events === "object") {
-      processed.events = JSON.stringify(processed.events);
-    }
-    if (processed.links && typeof processed.links === "object") {
-      processed.links = JSON.stringify(processed.links);
-    }
-    return processed;
-  }
-  /**
-   * Validates that the required DynamoDB table exists and is accessible.
-   * This does not check the table structure - it assumes the table
-   * was created with the correct structure via CDK/CloudFormation.
-   */
-  async validateTableExists() {
-    try {
-      const command = new clientDynamodb.DescribeTableCommand({
-        TableName: this.tableName
-      });
-      await this.client.send(command);
-      return true;
-    } catch (error$1) {
-      if (error$1.name === "ResourceNotFoundException") {
-        return false;
-      }
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("DYNAMODB", "VALIDATE_TABLE_EXISTS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName: this.tableName }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * This method is modified for DynamoDB with ElectroDB single-table design.
-   * It assumes the table is created and managed externally via CDK/CloudFormation.
-   *
-   * This implementation only validates that the required table exists and is accessible.
-   * No table creation is attempted - we simply check if we can access the table.
-   */
-  async createTable({ tableName }) {
-    this.logger.debug("Validating access to externally managed table", { tableName, physicalTable: this.tableName });
-    try {
-      const tableExists = await this.validateTableExists();
-      if (!tableExists) {
-        this.logger.error(
-          `Table ${this.tableName} does not exist or is not accessible. It should be created via CDK/CloudFormation.`
-        );
-        throw new Error(
-          `Table ${this.tableName} does not exist or is not accessible. Ensure it's created via CDK/CloudFormation before using this store.`
-        );
-      }
-      this.logger.debug(`Table ${this.tableName} exists and is accessible`);
-    } catch (error$1) {
-      this.logger.error("Error validating table access", { tableName: this.tableName, error: error$1 });
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("DYNAMODB", "VALIDATE_TABLE_ACCESS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName: this.tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async insert({ tableName, record }) {
-    this.logger.debug("DynamoDB insert called", { tableName });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("DYNAMODB", "INSERT", "INVALID_ARGS"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
-      });
-    }
-    try {
-      const dataToSave = { entity: entityName, ...this.preprocessRecord(record) };
-      await this.service.entities[entityName].create(dataToSave).go();
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("DYNAMODB", "INSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async alterTable(_args) {
-  }
-  /**
-   * Clear all items from a logical "table" (entity type)
-   */
-  async clearTable({ tableName }) {
-    this.logger.debug("DynamoDB clearTable called", { tableName });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("DYNAMODB", "CLEAR_TABLE", "INVALID_ARGS"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
-      });
-    }
-    try {
-      const result = await this.service.entities[entityName].scan.go({ pages: "all" });
-      if (!result.data.length) {
-        this.logger.debug(`No records found to clear for ${tableName}`);
-        return;
-      }
-      this.logger.debug(`Found ${result.data.length} records to delete for ${tableName}`);
-      const keysToDelete = result.data.map((item) => {
-        const key = { entity: entityName };
-        switch (entityName) {
-          case "thread":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'thread'`);
-            key.id = item.id;
-            break;
-          case "message":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'message'`);
-            key.id = item.id;
-            break;
-          case "workflow_snapshot":
-            if (!item.workflow_name)
-              throw new Error(`Missing required key 'workflow_name' for entity 'workflow_snapshot'`);
-            if (!item.run_id) throw new Error(`Missing required key 'run_id' for entity 'workflow_snapshot'`);
-            key.workflow_name = item.workflow_name;
-            key.run_id = item.run_id;
-            break;
-          case "eval":
-            if (!item.run_id) throw new Error(`Missing required key 'run_id' for entity 'eval'`);
-            key.run_id = item.run_id;
-            break;
-          case "trace":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'trace'`);
-            key.id = item.id;
-            break;
-          case "score":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'score'`);
-            key.id = item.id;
-            break;
-          case "resource":
-            if (!item.id) throw new Error(`Missing required key 'id' for entity 'resource'`);
-            key.id = item.id;
-            break;
-          default:
-            this.logger.warn(`Unknown entity type encountered during clearTable: ${entityName}`);
-            throw new Error(`Cannot construct delete key for unknown entity type: ${entityName}`);
-        }
-        return key;
-      });
-      const batchSize = 25;
-      for (let i = 0; i < keysToDelete.length; i += batchSize) {
-        const batchKeys = keysToDelete.slice(i, i + batchSize);
-        await this.service.entities[entityName].delete(batchKeys).go();
-      }
-      this.logger.debug(`Successfully cleared all records for ${tableName}`);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("DYNAMODB", "CLEAR_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Insert multiple records as a batch
-   */
-  async batchInsert({ tableName, records }) {
-    this.logger.debug("DynamoDB batchInsert called", { tableName, count: records.length });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("DYNAMODB", "BATCH_INSERT", "INVALID_ARGS"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
-      });
-    }
-    const recordsToSave = records.map((rec) => ({ entity: entityName, ...this.preprocessRecord(rec) }));
-    const batchSize = 25;
-    const batches = [];
-    for (let i = 0; i < recordsToSave.length; i += batchSize) {
-      const batch = recordsToSave.slice(i, i + batchSize);
-      batches.push(batch);
-    }
-    try {
-      for (const batch of batches) {
-        for (const recordData of batch) {
-          if (!recordData.entity) {
-            this.logger.error("Missing entity property in record data for batchInsert", { recordData, tableName });
-            throw new Error(`Internal error: Missing entity property during batchInsert for ${tableName}`);
-          }
-          this.logger.debug("Attempting to create record in batchInsert:", { entityName, recordData });
-          await this.service.entities[entityName].create(recordData).go();
-        }
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("DYNAMODB", "BATCH_INSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Load a record by its keys
-   */
-  async load({ tableName, keys }) {
-    this.logger.debug("DynamoDB load called", { tableName, keys });
-    const entityName = this.getEntityNameForTable(tableName);
-    if (!entityName || !this.service.entities[entityName]) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("DYNAMODB", "LOAD", "INVALID_ARGS"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No entity defined for tableName",
-        details: { tableName }
-      });
-    }
-    try {
-      const keyObject = { entity: entityName, ...keys };
-      const result = await this.service.entities[entityName].get(keyObject).go();
-      if (!result.data) {
-        return null;
-      }
-      let data = result.data;
-      return data;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("DYNAMODB", "LOAD", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-};
 var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
   service;
-  constructor({ service }) {
+  constructor(config) {
     super();
-    this.service = service;
+    this.service = resolveDynamoDBConfig(config);
+  }
+  async dangerouslyClearAll() {
+    await deleteTableData(this.service, storage.TABLE_SCORERS);
   }
   /**
    * DynamoDB-specific score row transformation.
@@ -2021,7 +1803,7 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
-            scorer: score.scorer?.id ?? "unknown",
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
             entityId: score.entityId ?? "unknown",
             entityType: score.entityType ?? "unknown",
             traceId: score.traceId ?? "",
@@ -2264,44 +2046,104 @@ function formatWorkflowRun(snapshotData) {
 }
 var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
   service;
-  constructor({ service }) {
+  constructor(config) {
     super();
-    this.service = service;
+    this.service = resolveDynamoDBConfig(config);
   }
-  updateWorkflowResults({
-    // workflowName,
-    // runId,
-    // stepId,
-    // result,
-    // requestContext,
+  async dangerouslyClearAll() {
+    await deleteTableData(this.service, storage.TABLE_WORKFLOW_SNAPSHOT);
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
   }) {
-    throw new Error("Method not implemented.");
+    try {
+      const existingSnapshot = await this.loadWorkflowSnapshot({ workflowName, runId });
+      let snapshot;
+      if (!existingSnapshot) {
+        snapshot = {
+          context: {},
+          activePaths: [],
+          timestamp: Date.now(),
+          suspendedPaths: {},
+          activeStepsPath: {},
+          resumeLabels: {},
+          serializedStepGraph: [],
+          status: "pending",
+          value: {},
+          waitingPaths: {},
+          runId,
+          requestContext: {}
+        };
+      } else {
+        snapshot = existingSnapshot;
+      }
+      snapshot.context[stepId] = result;
+      snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+      await this.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+      return snapshot.context;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId, stepId }
+        },
+        error$1
+      );
+    }
   }
-  updateWorkflowState({
-    // workflowName,
-    // runId,
-    // opts,
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
   }) {
-    throw new Error("Method not implemented.");
+    try {
+      const existingSnapshot = await this.loadWorkflowSnapshot({ workflowName, runId });
+      if (!existingSnapshot || !existingSnapshot.context) {
+        return void 0;
+      }
+      const updatedSnapshot = { ...existingSnapshot, ...opts };
+      await this.persistWorkflowSnapshot({ workflowName, runId, snapshot: updatedSnapshot });
+      return updatedSnapshot;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_STATE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
+    }
   }
   // Workflow operations
   async persistWorkflowSnapshot({
     workflowName,
     runId,
     resourceId,
-    snapshot
+    snapshot,
+    createdAt,
+    updatedAt
   }) {
     this.logger.debug("Persisting workflow snapshot", { workflowName, runId });
     try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const now = /* @__PURE__ */ new Date();
       const data = {
         entity: "workflow_snapshot",
         // Add entity type
         workflow_name: workflowName,
         run_id: runId,
         snapshot: JSON.stringify(snapshot),
-        createdAt: now,
-        updatedAt: now,
+        createdAt: (createdAt ?? now).toISOString(),
+        updatedAt: (updatedAt ?? now).toISOString(),
         resourceId
       };
       await this.service.entities.workflow_snapshot.upsert(data).go();
@@ -2509,6 +2351,9 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
 };
 
 // src/storage/index.ts
+var isClientConfig = (config) => {
+  return "client" in config;
+};
 var DynamoDBStore = class extends storage.MastraStorage {
   tableName;
   client;
@@ -2526,24 +2371,23 @@ var DynamoDBStore = class extends storage.MastraStorage {
           `DynamoDBStore: config.tableName "${config.tableName}" contains invalid characters or is not between 3 and 255 characters long.`
         );
       }
-      const dynamoClient = new clientDynamodb.DynamoDBClient({
-        region: config.region || "us-east-1",
-        endpoint: config.endpoint,
-        credentials: config.credentials
-      });
       this.tableName = config.tableName;
-      this.client = libDynamodb.DynamoDBDocumentClient.from(dynamoClient);
+      if (isClientConfig(config)) {
+        this.client = config.client;
+      } else {
+        const dynamoClient = new clientDynamodb.DynamoDBClient({
+          region: config.region || "us-east-1",
+          endpoint: config.endpoint,
+          credentials: config.credentials
+        });
+        this.client = libDynamodb.DynamoDBDocumentClient.from(dynamoClient);
+      }
       this.service = getElectroDbService(this.client, this.tableName);
-      const operations = new StoreOperationsDynamoDB({
-        service: this.service,
-        tableName: this.tableName,
-        client: this.client
-      });
-      const workflows = new WorkflowStorageDynamoDB({ service: this.service });
-      const memory = new MemoryStorageDynamoDB({ service: this.service });
-      const scores = new ScoresStorageDynamoDB({ service: this.service });
+      const domainConfig = { service: this.service };
+      const workflows = new WorkflowStorageDynamoDB(domainConfig);
+      const memory = new MemoryStorageDynamoDB(domainConfig);
+      const scores = new ScoresStorageDynamoDB(domainConfig);
       this.stores = {
-        operations,
         workflows,
         memory,
         scores
@@ -2565,8 +2409,11 @@ var DynamoDBStore = class extends storage.MastraStorage {
       resourceWorkingMemory: true,
       hasColumn: false,
       createTable: false,
-      deleteMessages: false,
-      listScoresBySpan: true
+      deleteMessages: true,
+      observability: false,
+      indexManagement: false,
+      listScoresBySpan: true,
+      agents: false
     };
   }
   /**
@@ -2636,109 +2483,10 @@ var DynamoDBStore = class extends storage.MastraStorage {
       throw err;
     });
   }
-  async createTable({ tableName, schema }) {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-  async alterTable(_args) {
-    return this.stores.operations.alterTable(_args);
-  }
-  async clearTable({ tableName }) {
-    return this.stores.operations.clearTable({ tableName });
-  }
-  async dropTable({ tableName }) {
-    return this.stores.operations.dropTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    return this.stores.operations.insert({ tableName, record });
-  }
-  async batchInsert({ tableName, records }) {
-    return this.stores.operations.batchInsert({ tableName, records });
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
-  // Thread operations
-  async getThreadById({ threadId }) {
-    return this.stores.memory.getThreadById({ threadId });
-  }
-  async saveThread({ thread }) {
-    return this.stores.memory.saveThread({ thread });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.stores.memory.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    return this.stores.memory.deleteThread({ threadId });
-  }
-  async listMessagesById(args) {
-    return this.stores.memory.listMessagesById(args);
-  }
-  async saveMessages(args) {
-    return this.stores.memory.saveMessages(args);
-  }
-  async updateMessages(_args) {
-    return this.stores.memory.updateMessages(_args);
-  }
-  // Workflow operations
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-  async listWorkflowRuns(args) {
-    return this.stores.workflows.listWorkflowRuns(args);
-  }
-  async getWorkflowRunById(args) {
-    return this.stores.workflows.getWorkflowRunById(args);
-  }
-  async deleteWorkflowRunById({ runId, workflowName }) {
-    return this.stores.workflows.deleteWorkflowRunById({ runId, workflowName });
-  }
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
-  }
   /**
    * Closes the DynamoDB client connection and cleans up resources.
-   * Should be called when the store is no longer needed, e.g., at the end of tests or application shutdown.
+   *
+   * This will close the DynamoDB client, including pre-configured clients.
    */
   async close() {
     this.logger.debug("Closing DynamoDB client for store:", { name: this.name });
@@ -2756,48 +2504,6 @@ var DynamoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  /**
-   * SCORERS - Not implemented
-   */
-  async getScoreById({ id: _id }) {
-    return this.stores.scores.getScoreById({ id: _id });
-  }
-  async saveScore(score) {
-    return this.stores.scores.saveScore(score);
-  }
-  async listScoresByRunId({
-    runId: _runId,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.listScoresByRunId({ runId: _runId, pagination: _pagination });
-  }
-  async listScoresByEntityId({
-    entityId: _entityId,
-    entityType: _entityType,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({
-      entityId: _entityId,
-      entityType: _entityType,
-      pagination: _pagination
-    });
-  }
-  async listScoresByScorerId({
-    scorerId,
-    source,
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, source, entityId, entityType, pagination });
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
-  }
 };
 
 exports.DynamoDBStore = DynamoDBStore;