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

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+export { DynamoDBStoreConfig } from './_tsup-dts-rollup.cjs';
+export { DynamoDBStore } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { DynamoDBStoreConfig } from './_tsup-dts-rollup.js';
+export { DynamoDBStore } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 import { DynamoDBClient, DescribeTableCommand } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 import { MessageList } from '@mastra/core/agent';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraStorage, TABLE_TRACES, TABLE_EVALS, TABLE_WORKFLOW_SNAPSHOT, TABLE_MESSAGES, TABLE_THREADS } from '@mastra/core/storage';
 import { Entity, Service } from 'electrodb';
 
@@ -558,25 +559,39 @@ function getElectroDbService(client, tableName) {
 
 // src/storage/index.ts
 var DynamoDBStore = class extends MastraStorage {
+  tableName;
+  client;
+  service;
+  hasInitialized = null;
   constructor({ name, config }) {
     super({ name });
-    this.hasInitialized = null;
-    if (!config.tableName || typeof config.tableName !== "string" || config.tableName.trim() === "") {
-      throw new Error("DynamoDBStore: config.tableName must be provided and cannot be empty.");
-    }
-    if (!/^[a-zA-Z0-9_.-]{3,255}$/.test(config.tableName)) {
-      throw new Error(
-        `DynamoDBStore: config.tableName "${config.tableName}" contains invalid characters or is not between 3 and 255 characters long.`
+    try {
+      if (!config.tableName || typeof config.tableName !== "string" || config.tableName.trim() === "") {
+        throw new Error("DynamoDBStore: config.tableName must be provided and cannot be empty.");
+      }
+      if (!/^[a-zA-Z0-9_.-]{3,255}$/.test(config.tableName)) {
+        throw new Error(
+          `DynamoDBStore: config.tableName "${config.tableName}" contains invalid characters or is not between 3 and 255 characters long.`
+        );
+      }
+      const dynamoClient = new DynamoDBClient({
+        region: config.region || "us-east-1",
+        endpoint: config.endpoint,
+        credentials: config.credentials
+      });
+      this.tableName = config.tableName;
+      this.client = DynamoDBDocumentClient.from(dynamoClient);
+      this.service = getElectroDbService(this.client, this.tableName);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_CONSTRUCTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        error
       );
     }
-    const dynamoClient = new DynamoDBClient({
-      region: config.region || "us-east-1",
-      endpoint: config.endpoint,
-      credentials: config.credentials
-    });
-    this.tableName = config.tableName;
-    this.client = DynamoDBDocumentClient.from(dynamoClient);
-    this.service = getElectroDbService(this.client, this.tableName);
   }
   /**
    * This method is modified for DynamoDB with ElectroDB single-table design.
@@ -600,7 +615,15 @@ var DynamoDBStore = class extends MastraStorage {
       this.logger.debug(`Table ${this.tableName} exists and is accessible`);
     } catch (error) {
       this.logger.error("Error validating table access", { tableName: this.tableName, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_VALIDATE_TABLE_ACCESS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName: this.tableName }
+        },
+        error
+      );
     }
   }
   /**
@@ -619,7 +642,15 @@ var DynamoDBStore = class extends MastraStorage {
       if (error.name === "ResourceNotFoundException") {
         return false;
       }
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_VALIDATE_TABLE_EXISTS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName: this.tableName }
+        },
+        error
+      );
     }
   }
   /**
@@ -634,7 +665,15 @@ var DynamoDBStore = class extends MastraStorage {
     try {
       await this.hasInitialized;
     } catch (error) {
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_INIT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName: this.tableName }
+        },
+        error
+      );
     }
   }
   /**
@@ -654,6 +693,25 @@ var DynamoDBStore = class extends MastraStorage {
       throw err;
     });
   }
+  /**
+   * 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();
+    }
+    return processed;
+  }
+  async alterTable(_args) {
+  }
   /**
    * Clear all items from a logical "table" (entity type)
    */
@@ -661,7 +719,13 @@ var DynamoDBStore = class extends MastraStorage {
     this.logger.debug("DynamoDB clearTable called", { tableName });
     const entityName = this.getEntityNameForTable(tableName);
     if (!entityName || !this.service.entities[entityName]) {
-      throw new Error(`No entity defined for ${tableName}`);
+      throw new MastraError({
+        id: "STORAGE_DYNAMODB_STORE_CLEAR_TABLE_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "No entity defined for tableName",
+        details: { tableName }
+      });
     }
     try {
       const result = await this.service.entities[entityName].scan.go({ pages: "all" });
@@ -709,37 +773,69 @@ var DynamoDBStore = class extends MastraStorage {
       }
       this.logger.debug(`Successfully cleared all records for ${tableName}`);
     } catch (error) {
-      this.logger.error("Failed to clear table", { tableName, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_CLEAR_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   /**
    * Insert a record into the specified "table" (entity)
    */
-  async insert({ tableName, record }) {
+  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(`No entity defined for ${tableName}`);
+      throw new MastraError({
+        id: "STORAGE_DYNAMODB_STORE_INSERT_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "No entity defined for tableName",
+        details: { tableName }
+      });
     }
     try {
-      const dataToSave = { entity: entityName, ...record };
+      const dataToSave = { entity: entityName, ...this.preprocessRecord(record) };
       await this.service.entities[entityName].create(dataToSave).go();
     } catch (error) {
-      this.logger.error("Failed to insert record", { tableName, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   /**
    * Insert multiple records as a batch
    */
-  async batchInsert({ tableName, records }) {
+  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(`No entity defined for ${tableName}`);
+      throw new MastraError({
+        id: "STORAGE_DYNAMODB_STORE_BATCH_INSERT_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "No entity defined for tableName",
+        details: { tableName }
+      });
     }
-    const recordsToSave = records.map((rec) => ({ entity: entityName, ...rec }));
+    const recordsToSave = records.map((rec) => ({ entity: entityName, ...this.preprocessRecord(rec) }));
     const batchSize = 25;
     const batches = [];
     for (let i = 0; i < recordsToSave.length; i += batchSize) {
@@ -758,18 +854,34 @@ var DynamoDBStore = class extends MastraStorage {
         }
       }
     } catch (error) {
-      this.logger.error("Failed to batch insert records", { tableName, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_BATCH_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   /**
    * Load a record by its keys
    */
-  async load({ tableName, 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(`No entity defined for ${tableName}`);
+      throw new MastraError({
+        id: "STORAGE_DYNAMODB_STORE_LOAD_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "No entity defined for tableName",
+        details: { tableName }
+      });
     }
     try {
       const keyObject = { entity: entityName, ...keys };
@@ -780,8 +892,15 @@ var DynamoDBStore = class extends MastraStorage {
       let data = result.data;
       return data;
     } catch (error) {
-      this.logger.error("Failed to load record", { tableName, keys, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_LOAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   // Thread operations
@@ -794,13 +913,23 @@ var DynamoDBStore = class extends MastraStorage {
       }
       const data = result.data;
       return {
-        ...data
+        ...data,
+        // Convert date strings back to Date objects for consistency
+        createdAt: typeof data.createdAt === "string" ? new Date(data.createdAt) : data.createdAt,
+        updatedAt: typeof data.updatedAt === "string" ? new Date(data.updatedAt) : data.updatedAt
         // metadata: data.metadata ? JSON.parse(data.metadata) : undefined, // REMOVED by AI
         // metadata is already transformed by the entity's getter
       };
     } catch (error) {
-      this.logger.error("Failed to get thread by ID", { threadId, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_THREAD_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
   async getThreadsByResourceId({ resourceId }) {
@@ -811,13 +940,23 @@ var DynamoDBStore = class extends MastraStorage {
         return [];
       }
       return result.data.map((data) => ({
-        ...data
+        ...data,
+        // Convert date strings back to Date objects for consistency
+        createdAt: typeof data.createdAt === "string" ? new Date(data.createdAt) : data.createdAt,
+        updatedAt: typeof data.updatedAt === "string" ? new Date(data.updatedAt) : data.updatedAt
         // metadata: data.metadata ? JSON.parse(data.metadata) : undefined, // REMOVED by AI
         // metadata is already transformed by the entity's getter
       }));
     } catch (error) {
-      this.logger.error("Failed to get threads by resource ID", { resourceId, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error
+      );
     }
   }
   async saveThread({ thread }) {
@@ -833,7 +972,7 @@ var DynamoDBStore = class extends MastraStorage {
       metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0
     };
     try {
-      await this.service.entities.thread.create(threadData).go();
+      await this.service.entities.thread.upsert(threadData).go();
       return {
         id: thread.id,
         resourceId: thread.resourceId,
@@ -843,8 +982,15 @@ var DynamoDBStore = class extends MastraStorage {
         metadata: thread.metadata
       };
     } catch (error) {
-      this.logger.error("Failed to save thread", { threadId: thread.id, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_SAVE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
+        },
+        error
+      );
     }
   }
   async updateThread({
@@ -876,8 +1022,15 @@ var DynamoDBStore = class extends MastraStorage {
         updatedAt: now
       };
     } catch (error) {
-      this.logger.error("Failed to update thread", { threadId: id, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_UPDATE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: id }
+        },
+        error
+      );
     }
   }
   async deleteThread({ threadId }) {
@@ -885,8 +1038,15 @@ var DynamoDBStore = class extends MastraStorage {
     try {
       await this.service.entities.thread.delete({ entity: "thread", id: threadId }).go();
     } catch (error) {
-      this.logger.error("Failed to delete thread", { threadId, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_DELETE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
   async getMessages({
@@ -898,13 +1058,14 @@ var DynamoDBStore = class extends MastraStorage {
     this.logger.debug("Getting messages", { threadId, selectBy });
     try {
       const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
-      if (selectBy?.last && typeof selectBy.last === "number") {
-        const results2 = await query.go({ limit: selectBy.last, reverse: true });
+      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+      if (limit !== Number.MAX_SAFE_INTEGER) {
+        const results2 = await query.go({ limit, order: "desc" });
         const list2 = new MessageList({ threadId, resourceId }).add(
           results2.data.map((data) => this.parseMessageData(data)),
           "memory"
         );
-        if (format === `v2`) return list2.get.all.mastra();
+        if (format === `v2`) return list2.get.all.v2();
         return list2.get.all.v1();
       }
       const results = await query.go();
@@ -912,11 +1073,18 @@ var DynamoDBStore = class extends MastraStorage {
         results.data.map((data) => this.parseMessageData(data)),
         "memory"
       );
-      if (format === `v2`) return list.get.all.mastra();
+      if (format === `v2`) return list.get.all.v2();
       return list.get.all.v1();
     } catch (error) {
-      this.logger.error("Failed to get messages", { threadId, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
   async saveMessages(args) {
@@ -925,6 +1093,10 @@ var DynamoDBStore = class extends MastraStorage {
     if (!messages.length) {
       return [];
     }
+    const threadId = messages[0]?.threadId;
+    if (!threadId) {
+      throw new Error("Thread ID is required");
+    }
     const messagesToSave = messages.map((msg) => {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       return {
@@ -952,21 +1124,35 @@ var DynamoDBStore = class extends MastraStorage {
         const batch = messagesToSave.slice(i, i + batchSize);
         batches.push(batch);
       }
-      for (const batch of batches) {
-        for (const messageData of batch) {
-          if (!messageData.entity) {
-            this.logger.error("Missing entity property in message data for create", { messageData });
-            throw new Error("Internal error: Missing entity property during saveMessages");
+      await Promise.all([
+        // Process message batches
+        ...batches.map(async (batch) => {
+          for (const messageData of batch) {
+            if (!messageData.entity) {
+              this.logger.error("Missing entity property in message data for create", { messageData });
+              throw new Error("Internal error: Missing entity property during saveMessages");
+            }
+            await this.service.entities.message.put(messageData).go();
           }
-          await this.service.entities.message.create(messageData).go();
-        }
-      }
+        }),
+        // Update thread's updatedAt timestamp
+        this.service.entities.thread.update({ entity: "thread", id: threadId }).set({
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }).go()
+      ]);
       const list = new MessageList().add(messages, "memory");
       if (format === `v1`) return list.get.all.v1();
-      return list.get.all.mastra();
+      return list.get.all.v2();
     } catch (error) {
-      this.logger.error("Failed to save messages", { error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_SAVE_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { count: messages.length }
+        },
+        error
+      );
     }
   }
   // Helper function to parse message data (handle JSON fields)
@@ -1012,8 +1198,14 @@ var DynamoDBStore = class extends MastraStorage {
       } while (cursor && pagesFetched < startPage);
       return items;
     } catch (error) {
-      this.logger.error("Failed to get traces", { error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_TRACES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
     }
   }
   async batchTraceInsert({ records }) {
@@ -1029,8 +1221,15 @@ var DynamoDBStore = class extends MastraStorage {
         // Pass records with 'entity' included
       });
     } catch (error) {
-      this.logger.error("Failed to batch insert traces", { error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_BATCH_TRACE_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { count: records.length }
+        },
+        error
+      );
     }
   }
   // Workflow operations
@@ -1054,10 +1253,17 @@ var DynamoDBStore = class extends MastraStorage {
         updatedAt: now,
         resourceId
       };
-      await this.service.entities.workflowSnapshot.create(data).go();
+      await this.service.entities.workflowSnapshot.upsert(data).go();
     } catch (error) {
-      this.logger.error("Failed to persist workflow snapshot", { workflowName, runId, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   async loadWorkflowSnapshot({
@@ -1077,8 +1283,15 @@ var DynamoDBStore = class extends MastraStorage {
       }
       return result.data.snapshot;
     } catch (error) {
-      this.logger.error("Failed to load workflow snapshot", { workflowName, runId, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   async getWorkflowRuns(args) {
@@ -1139,8 +1352,15 @@ var DynamoDBStore = class extends MastraStorage {
         total
       };
     } catch (error) {
-      this.logger.error("Failed to get workflow runs", { error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_WORKFLOW_RUNS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName: args?.workflowName || "", resourceId: args?.resourceId || "" }
+        },
+        error
+      );
     }
   }
   async getWorkflowRunById(args) {
@@ -1186,8 +1406,15 @@ var DynamoDBStore = class extends MastraStorage {
         resourceId: matchingRunDbItem.resourceId
       };
     } catch (error) {
-      this.logger.error("Failed to get workflow run by ID", { runId, workflowName, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { runId, workflowName: args?.workflowName || "" }
+        },
+        error
+      );
     }
   }
   // Helper function to format workflow run
@@ -1265,10 +1492,47 @@ var DynamoDBStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      this.logger.error("Failed to get evals by agent name", { agentName, type, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error
+      );
     }
   }
+  async getTracesPaginated(_args) {
+    throw new MastraError(
+      {
+        id: "STORAGE_DYNAMODB_STORE_GET_TRACES_PAGINATED_FAILED",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY
+      },
+      new Error("Method not implemented.")
+    );
+  }
+  async getThreadsByResourceIdPaginated(_args) {
+    throw new MastraError(
+      {
+        id: "STORAGE_DYNAMODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY
+      },
+      new Error("Method not implemented.")
+    );
+  }
+  async getMessagesPaginated(_args) {
+    throw new MastraError(
+      {
+        id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY
+      },
+      new Error("Method not implemented.")
+    );
+  }
   /**
    * 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.
@@ -1279,10 +1543,20 @@ var DynamoDBStore = class extends MastraStorage {
       this.client.destroy();
       this.logger.debug("DynamoDB client closed successfully for store:", { name: this.name });
     } catch (error) {
-      this.logger.error("Error closing DynamoDB client for store:", { name: this.name, error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_CLOSE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
     }
   }
+  async updateMessages(_args) {
+    this.logger.error("updateMessages is not yet implemented in DynamoDBStore");
+    throw new Error("Method not implemented");
+  }
 };
 
 export { DynamoDBStore };