@mastra/mongodb 0.11.1-alpha.0 → 0.11.1-alpha.2

package/dist/index.js

@@ -1,3 +1,4 @@
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import { MongoClient } from 'mongodb';
 import { v4 } from 'uuid';
@@ -116,28 +117,68 @@ var MongoDBVector = class extends MastraVector {
   }
   // Public methods
   async connect() {
-    await this.client.connect();
+    try {
+      await this.client.connect();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_CONNECT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   async disconnect() {
-    await this.client.close();
+    try {
+      await this.client.close();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DISCONNECT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   async createIndex({ indexName, dimension, metric = "cosine" }) {
-    if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
-    }
-    const mongoMetric = this.mongoMetricMap[metric];
-    if (!mongoMetric) {
-      throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
-    }
-    const collectionExists = await this.db.listCollections({ name: indexName }).hasNext();
-    if (!collectionExists) {
-      await this.db.createCollection(indexName);
+    let mongoMetric;
+    try {
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      mongoMetric = this.mongoMetricMap[metric];
+      if (!mongoMetric) {
+        throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_CREATE_INDEX_INVALID_ARGS",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            indexName,
+            dimension,
+            metric
+          }
+        },
+        error
+      );
     }
-    const collection = await this.getCollection(indexName);
-    const indexNameInternal = `${indexName}_vector_index`;
-    const embeddingField = this.embeddingFieldName;
-    const numDimensions = dimension;
+    let collection;
     try {
+      const collectionExists = await this.db.listCollections({ name: indexName }).hasNext();
+      if (!collectionExists) {
+        await this.db.createCollection(indexName);
+      }
+      collection = await this.getCollection(indexName);
+      const indexNameInternal = `${indexName}_vector_index`;
+      const embeddingField = this.embeddingFieldName;
+      const numDimensions = dimension;
       await collection.createSearchIndex({
         definition: {
           fields: [
@@ -154,10 +195,31 @@ var MongoDBVector = class extends MastraVector {
       });
     } catch (error) {
       if (error.codeName !== "IndexAlreadyExists") {
-        throw error;
+        throw new MastraError(
+          {
+            id: "STORAGE_MONGODB_VECTOR_CREATE_INDEX_FAILED",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY
+          },
+          error
+        );
       }
     }
-    await collection.updateOne({ _id: "__index_metadata__" }, { $set: { dimension, metric } }, { upsert: true });
+    try {
+      await collection?.updateOne({ _id: "__index_metadata__" }, { $set: { dimension, metric } }, { upsert: true });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_CREATE_INDEX_FAILED_STORE_METADATA",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+    }
   }
   /**
    * Waits for the index to be ready.
@@ -187,40 +249,54 @@ var MongoDBVector = class extends MastraVector {
     throw new Error(`Index "${indexNameInternal}" did not become ready within timeout`);
   }
   async upsert({ indexName, vectors, metadata, ids, documents }) {
-    const collection = await this.getCollection(indexName);
-    this.collectionForValidation = collection;
-    const stats = await this.describeIndex({ indexName });
-    await this.validateVectorDimensions(vectors, stats.dimension);
-    const generatedIds = ids || vectors.map(() => v4());
-    const operations = vectors.map((vector, idx) => {
-      const id = generatedIds[idx];
-      const meta = metadata?.[idx] || {};
-      const doc = documents?.[idx];
-      const normalizedMeta = Object.keys(meta).reduce(
-        (acc, key) => {
-          acc[key] = meta[key] instanceof Date ? meta[key].toISOString() : meta[key];
-          return acc;
+    try {
+      const collection = await this.getCollection(indexName);
+      this.collectionForValidation = collection;
+      const stats = await this.describeIndex({ indexName });
+      await this.validateVectorDimensions(vectors, stats.dimension);
+      const generatedIds = ids || vectors.map(() => v4());
+      const operations = vectors.map((vector, idx) => {
+        const id = generatedIds[idx];
+        const meta = metadata?.[idx] || {};
+        const doc = documents?.[idx];
+        const normalizedMeta = Object.keys(meta).reduce(
+          (acc, key) => {
+            acc[key] = meta[key] instanceof Date ? meta[key].toISOString() : meta[key];
+            return acc;
+          },
+          {}
+        );
+        const updateDoc = {
+          [this.embeddingFieldName]: vector,
+          [this.metadataFieldName]: normalizedMeta
+        };
+        if (doc !== void 0) {
+          updateDoc[this.documentFieldName] = doc;
+        }
+        return {
+          updateOne: {
+            filter: { _id: id },
+            // '_id' is a string as per MongoDBDocument interface
+            update: { $set: updateDoc },
+            upsert: true
+          }
+        };
+      });
+      await collection.bulkWrite(operations);
+      return generatedIds;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_UPSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
         },
-        {}
+        error
       );
-      const updateDoc = {
-        [this.embeddingFieldName]: vector,
-        [this.metadataFieldName]: normalizedMeta
-      };
-      if (doc !== void 0) {
-        updateDoc[this.documentFieldName] = doc;
-      }
-      return {
-        updateOne: {
-          filter: { _id: id },
-          // '_id' is a string as per MongoDBDocument interface
-          update: { $set: updateDoc },
-          upsert: true
-        }
-      };
-    });
-    await collection.bulkWrite(operations);
-    return generatedIds;
+    }
   }
   async query({
     indexName,
@@ -230,44 +306,44 @@ var MongoDBVector = class extends MastraVector {
     includeVector = false,
     documentFilter
   }) {
-    const collection = await this.getCollection(indexName, true);
-    const indexNameInternal = `${indexName}_vector_index`;
-    const mongoFilter = this.transformFilter(filter);
-    const documentMongoFilter = documentFilter ? { [this.documentFieldName]: documentFilter } : {};
-    let combinedFilter = {};
-    if (Object.keys(mongoFilter).length > 0 && Object.keys(documentMongoFilter).length > 0) {
-      combinedFilter = { $and: [mongoFilter, documentMongoFilter] };
-    } else if (Object.keys(mongoFilter).length > 0) {
-      combinedFilter = mongoFilter;
-    } else if (Object.keys(documentMongoFilter).length > 0) {
-      combinedFilter = documentMongoFilter;
-    }
-    const pipeline = [
-      {
-        $vectorSearch: {
-          index: indexNameInternal,
-          queryVector,
-          path: this.embeddingFieldName,
-          numCandidates: 100,
-          limit: topK
-        }
-      },
-      // Apply the filter using $match stage
-      ...Object.keys(combinedFilter).length > 0 ? [{ $match: combinedFilter }] : [],
-      {
-        $set: { score: { $meta: "vectorSearchScore" } }
-      },
-      {
-        $project: {
-          _id: 1,
-          score: 1,
-          metadata: `$${this.metadataFieldName}`,
-          document: `$${this.documentFieldName}`,
-          ...includeVector && { vector: `$${this.embeddingFieldName}` }
-        }
-      }
-    ];
     try {
+      const collection = await this.getCollection(indexName, true);
+      const indexNameInternal = `${indexName}_vector_index`;
+      const mongoFilter = this.transformFilter(filter);
+      const documentMongoFilter = documentFilter ? { [this.documentFieldName]: documentFilter } : {};
+      let combinedFilter = {};
+      if (Object.keys(mongoFilter).length > 0 && Object.keys(documentMongoFilter).length > 0) {
+        combinedFilter = { $and: [mongoFilter, documentMongoFilter] };
+      } else if (Object.keys(mongoFilter).length > 0) {
+        combinedFilter = mongoFilter;
+      } else if (Object.keys(documentMongoFilter).length > 0) {
+        combinedFilter = documentMongoFilter;
+      }
+      const pipeline = [
+        {
+          $vectorSearch: {
+            index: indexNameInternal,
+            queryVector,
+            path: this.embeddingFieldName,
+            numCandidates: 100,
+            limit: topK
+          }
+        },
+        // Apply the filter using $match stage
+        ...Object.keys(combinedFilter).length > 0 ? [{ $match: combinedFilter }] : [],
+        {
+          $set: { score: { $meta: "vectorSearchScore" } }
+        },
+        {
+          $project: {
+            _id: 1,
+            score: 1,
+            metadata: `$${this.metadataFieldName}`,
+            document: `$${this.documentFieldName}`,
+            ...includeVector && { vector: `$${this.embeddingFieldName}` }
+          }
+        }
+      ];
       const results = await collection.aggregate(pipeline).toArray();
       return results.map((result) => ({
         id: result._id,
@@ -277,13 +353,33 @@ var MongoDBVector = class extends MastraVector {
         document: result.document
       }));
     } catch (error) {
-      console.error("Error during vector search:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_QUERY_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
     }
   }
   async listIndexes() {
-    const collections = await this.db.listCollections().toArray();
-    return collections.map((col) => col.name);
+    try {
+      const collections = await this.db.listCollections().toArray();
+      return collections.map((col) => col.name);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_LIST_INDEXES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -292,24 +388,52 @@ var MongoDBVector = class extends MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName }) {
-    const collection = await this.getCollection(indexName, true);
-    const count = await collection.countDocuments({ _id: { $ne: "__index_metadata__" } });
-    const metadataDoc = await collection.findOne({ _id: "__index_metadata__" });
-    const dimension = metadataDoc?.dimension || 0;
-    const metric = metadataDoc?.metric || "cosine";
-    return {
-      dimension,
-      count,
-      metric
-    };
+    try {
+      const collection = await this.getCollection(indexName, true);
+      const count = await collection.countDocuments({ _id: { $ne: "__index_metadata__" } });
+      const metadataDoc = await collection.findOne({ _id: "__index_metadata__" });
+      const dimension = metadataDoc?.dimension || 0;
+      const metric = metadataDoc?.metric || "cosine";
+      return {
+        dimension,
+        count,
+        metric
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
+    }
   }
   async deleteIndex({ indexName }) {
     const collection = await this.getCollection(indexName, false);
-    if (collection) {
-      await collection.drop();
-      this.collections.delete(indexName);
-    } else {
-      throw new Error(`Index (Collection) "${indexName}" does not exist`);
+    try {
+      if (collection) {
+        await collection.drop();
+        this.collections.delete(indexName);
+      } else {
+        throw new Error(`Index (Collection) "${indexName}" does not exist`);
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DELETE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error
+      );
     }
   }
   /**
@@ -346,7 +470,18 @@ var MongoDBVector = class extends MastraVector {
       }
       await collection.findOneAndUpdate({ _id: id }, { $set: updateDoc });
     } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            id
+          }
+        },
+        error
+      );
     }
   }
   /**
@@ -361,7 +496,18 @@ var MongoDBVector = class extends MastraVector {
       const collection = await this.getCollection(indexName, true);
       await collection.deleteOne({ _id: id });
     } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DELETE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            id
+          }
+        },
+        error
+      );
     }
   }
   // Private methods
@@ -417,14 +563,26 @@ var MongoDBStore = class extends MastraStorage {
   constructor(config) {
     super({ name: "MongoDBStore" });
     this.#isConnected = false;
-    if (!config.url?.trim().length) {
-      throw new Error(
-        "MongoDBStore: url must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
-      );
-    }
-    if (!config.dbName?.trim().length) {
-      throw new Error(
-        "MongoDBStore: dbName must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
+    try {
+      if (!config.url?.trim().length) {
+        throw new Error(
+          "MongoDBStore: url must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
+        );
+      }
+      if (!config.dbName?.trim().length) {
+        throw new Error(
+          "MongoDBStore: dbName must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
+        );
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_CONSTRUCTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { url: config.url, dbName: config.dbName }
+        },
+        error
       );
     }
     this.#dbName = config.dbName;
@@ -459,7 +617,17 @@ var MongoDBStore = class extends MastraStorage {
       await collection.deleteMany({});
     } catch (error) {
       if (error instanceof Error) {
-        this.logger.error(error.message);
+        const matstraError = new MastraError(
+          {
+            id: "STORAGE_MONGODB_STORE_CLEAR_TABLE_FAILED",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { tableName }
+          },
+          error
+        );
+        this.logger.error(matstraError.message);
+        this.logger?.trackException(matstraError);
       }
     }
   }
@@ -468,8 +636,19 @@ var MongoDBStore = class extends MastraStorage {
       const collection = await this.getCollection(tableName);
       await collection.insertOne(record);
     } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
+      if (error instanceof Error) {
+        const matstraError = new MastraError(
+          {
+            id: "STORAGE_MONGODB_STORE_INSERT_FAILED",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { tableName }
+          },
+          error
+        );
+        this.logger.error(matstraError.message);
+        this.logger?.trackException(matstraError);
+      }
     }
   }
   async batchInsert({ tableName, records }) {
@@ -480,8 +659,15 @@ var MongoDBStore = class extends MastraStorage {
       const collection = await this.getCollection(tableName);
       await collection.insertMany(records);
     } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_BATCH_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async load({ tableName, keys }) {
@@ -490,8 +676,15 @@ var MongoDBStore = class extends MastraStorage {
       const collection = await this.getCollection(tableName);
       return await collection.find(keys).toArray();
     } catch (error) {
-      this.logger.error(`Error loading ${tableName} with keys ${JSON.stringify(keys)}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_LOAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async getThreadById({ threadId }) {
@@ -506,8 +699,15 @@ var MongoDBStore = class extends MastraStorage {
         metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
       };
     } catch (error) {
-      this.logger.error(`Error loading thread with ID ${threadId}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_THREAD_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
   async getThreadsByResourceId({ resourceId }) {
@@ -522,8 +722,15 @@ var MongoDBStore = class extends MastraStorage {
         metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
       }));
     } catch (error) {
-      this.logger.error(`Error loading threads by resourceId ${resourceId}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error
+      );
     }
   }
   async saveThread({ thread }) {
@@ -541,8 +748,15 @@ var MongoDBStore = class extends MastraStorage {
       );
       return thread;
     } catch (error) {
-      this.logger.error(`Error saving thread ${thread.id}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_SAVE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
+        },
+        error
+      );
     }
   }
   async updateThread({
@@ -552,7 +766,13 @@ var MongoDBStore = class extends MastraStorage {
   }) {
     const thread = await this.getThreadById({ threadId: id });
     if (!thread) {
-      throw new Error(`Thread ${id} not found`);
+      throw new MastraError({
+        id: "STORAGE_MONGODB_STORE_UPDATE_THREAD_NOT_FOUND",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        details: { threadId: id },
+        text: `Thread ${id} not found`
+      });
     }
     const updatedThread = {
       ...thread,
@@ -574,8 +794,15 @@ var MongoDBStore = class extends MastraStorage {
         }
       );
     } catch (error) {
-      this.logger.error(`Error updating thread ${id}:) ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_UPDATE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: id }
+        },
+        error
+      );
     }
     return updatedThread;
   }
@@ -586,8 +813,15 @@ var MongoDBStore = class extends MastraStorage {
       const collectionThreads = await this.getCollection(TABLE_THREADS);
       await collectionThreads.deleteOne({ id: threadId });
     } catch (error) {
-      this.logger.error(`Error deleting thread ${threadId}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_DELETE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
   async getMessages({
@@ -596,7 +830,7 @@ var MongoDBStore = class extends MastraStorage {
     format
   }) {
     try {
-      const limit = typeof selectBy?.last === "number" ? selectBy.last : 40;
+      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
       const include = selectBy?.include || [];
       let messages = [];
       let allMessages = [];
@@ -637,8 +871,15 @@ var MongoDBStore = class extends MastraStorage {
       if (format === `v2`) return list.get.all.v2();
       return list.get.all.v1();
     } catch (error) {
-      this.logger.error("Error getting messages:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
   async saveMessages({
@@ -669,7 +910,15 @@ var MongoDBStore = class extends MastraStorage {
       const collection = await this.getCollection(TABLE_MESSAGES);
       const threadsCollection = await this.getCollection(TABLE_THREADS);
       await Promise.all([
-        collection.insertMany(messagesToInsert),
+        collection.bulkWrite(
+          messagesToInsert.map((msg) => ({
+            updateOne: {
+              filter: { id: msg.id },
+              update: { $set: msg },
+              upsert: true
+            }
+          }))
+        ),
         threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
       ]);
       const list = new MessageList().add(messages, "memory");
@@ -695,41 +944,52 @@ var MongoDBStore = class extends MastraStorage {
     const offset = page * perPage;
     const query = {};
     if (name) {
-      query["name"] = `%${name}%`;
+      query["name"] = new RegExp(name);
     }
     if (scope) {
       query["scope"] = scope;
     }
     if (attributes) {
-      Object.keys(attributes).forEach((key) => {
-        query[`attributes.${key}`] = attributes[key];
-      });
+      query["$and"] = Object.entries(attributes).map(([key, value]) => ({
+        attributes: new RegExp(`"${key}":"${value}"`)
+      }));
     }
     if (filters) {
       Object.entries(filters).forEach(([key, value]) => {
         query[key] = value;
       });
     }
-    const collection = await this.getCollection(TABLE_TRACES);
-    const result = await collection.find(query, {
-      sort: { startTime: -1 }
-    }).limit(limit).skip(offset).toArray();
-    return result.map((row) => ({
-      id: row.id,
-      parentSpanId: row.parentSpanId,
-      traceId: row.traceId,
-      name: row.name,
-      scope: row.scope,
-      kind: row.kind,
-      status: safelyParseJSON(row.status),
-      events: safelyParseJSON(row.events),
-      links: safelyParseJSON(row.links),
-      attributes: safelyParseJSON(row.attributes),
-      startTime: row.startTime,
-      endTime: row.endTime,
-      other: safelyParseJSON(row.other),
-      createdAt: row.createdAt
-    }));
+    try {
+      const collection = await this.getCollection(TABLE_TRACES);
+      const result = await collection.find(query, {
+        sort: { startTime: -1 }
+      }).limit(limit).skip(offset).toArray();
+      return result.map((row) => ({
+        id: row.id,
+        parentSpanId: row.parentSpanId,
+        traceId: row.traceId,
+        name: row.name,
+        scope: row.scope,
+        kind: row.kind,
+        status: safelyParseJSON(row.status),
+        events: safelyParseJSON(row.events),
+        links: safelyParseJSON(row.links),
+        attributes: safelyParseJSON(row.attributes),
+        startTime: row.startTime,
+        endTime: row.endTime,
+        other: safelyParseJSON(row.other),
+        createdAt: row.createdAt
+      }));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_TRACES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   async getWorkflowRuns({
     workflowName,
@@ -751,37 +1011,48 @@ var MongoDBStore = class extends MastraStorage {
         query["createdAt"]["$lte"] = toDate;
       }
     }
-    const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
-    let total = 0;
-    if (limit !== void 0 && offset !== void 0) {
-      total = await collection.countDocuments(query);
-    }
-    const request = collection.find(query).sort({ createdAt: "desc" });
-    if (limit) {
-      request.limit(limit);
-    }
-    if (offset) {
-      request.skip(offset);
-    }
-    const result = await request.toArray();
-    const runs = result.map((row) => {
-      let parsedSnapshot = row.snapshot;
-      if (typeof parsedSnapshot === "string") {
-        try {
-          parsedSnapshot = JSON.parse(row.snapshot);
-        } catch (e) {
-          console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-        }
+    try {
+      const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
+      let total = 0;
+      if (limit !== void 0 && offset !== void 0) {
+        total = await collection.countDocuments(query);
       }
-      return {
-        workflowName: row.workflow_name,
-        runId: row.run_id,
-        snapshot: parsedSnapshot,
-        createdAt: new Date(row.createdAt),
-        updatedAt: new Date(row.updatedAt)
-      };
-    });
-    return { runs, total: total || runs.length };
+      const request = collection.find(query).sort({ createdAt: "desc" });
+      if (limit) {
+        request.limit(limit);
+      }
+      if (offset) {
+        request.skip(offset);
+      }
+      const result = await request.toArray();
+      const runs = result.map((row) => {
+        let parsedSnapshot = row.snapshot;
+        if (typeof parsedSnapshot === "string") {
+          try {
+            parsedSnapshot = JSON.parse(row.snapshot);
+          } catch (e) {
+            console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+          }
+        }
+        return {
+          workflowName: row.workflow_name,
+          runId: row.run_id,
+          snapshot: parsedSnapshot,
+          createdAt: new Date(row.createdAt),
+          updatedAt: new Date(row.updatedAt)
+        };
+      });
+      return { runs, total: total || runs.length };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_WORKFLOW_RUNS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   async getEvalsByAgentName(agentName, type) {
     try {
@@ -810,8 +1081,15 @@ var MongoDBStore = class extends MastraStorage {
       if (error instanceof Error && error.message.includes("no such table")) {
         return [];
       }
-      this.logger.error("Failed to get evals for the specified agent: " + error?.message);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error
+      );
     }
   }
   async persistWorkflowSnapshot({
@@ -836,8 +1114,15 @@ var MongoDBStore = class extends MastraStorage {
         { upsert: true }
       );
     } catch (error) {
-      this.logger.error(`Error persisting workflow snapshot: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   async loadWorkflowSnapshot({
@@ -857,8 +1142,15 @@ var MongoDBStore = class extends MastraStorage {
       }
       return JSON.parse(result[0].snapshot);
     } catch (error) {
-      console.error("Error loading workflow snapshot:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   async getWorkflowRunById({
@@ -880,8 +1172,15 @@ var MongoDBStore = class extends MastraStorage {
       }
       return this.parseWorkflowRun(result);
     } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { runId }
+        },
+        error
+      );
     }
   }
   parseWorkflowRun(row) {
@@ -927,10 +1226,19 @@ var MongoDBStore = class extends MastraStorage {
         console.warn("Failed to parse test_info:", e);
       }
     }
+    const resultValue = JSON.parse(row.result);
+    if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
+      throw new MastraError({
+        id: "STORAGE_MONGODB_STORE_INVALID_METRIC_FORMAT",
+        text: `Invalid MetricResult format: ${JSON.stringify(resultValue)}`,
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER
+      });
+    }
     return {
       input: row.input,
       output: row.output,
-      result: row.result,
+      result: resultValue,
       agentName: row.agent_name,
       metricName: row.metric_name,
       instructions: row.instructions,
@@ -941,16 +1249,42 @@ var MongoDBStore = class extends MastraStorage {
     };
   }
   async getTracesPaginated(_args) {
-    throw new Error("Method not implemented.");
+    throw new MastraError({
+      id: "STORAGE_MONGODB_STORE_GET_TRACES_PAGINATED_FAILED",
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.THIRD_PARTY,
+      text: "Method not implemented."
+    });
   }
   async getThreadsByResourceIdPaginated(_args) {
-    throw new Error("Method not implemented.");
+    throw new MastraError({
+      id: "STORAGE_MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.THIRD_PARTY,
+      text: "Method not implemented."
+    });
   }
   async getMessagesPaginated(_args) {
-    throw new Error("Method not implemented.");
+    throw new MastraError({
+      id: "STORAGE_MONGODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.THIRD_PARTY,
+      text: "Method not implemented."
+    });
   }
   async close() {
-    await this.#client.close();
+    try {
+      await this.#client.close();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_CLOSE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        error
+      );
+    }
   }
   async updateMessages(_args) {
     this.logger.error("updateMessages is not yet implemented in MongoDBStore");