@mastra/mongodb 0.0.0-working-memory-per-user-20250620163010 → 0.0.0-zod-v4-compat-part-2-20250820135355

package/dist/index.cjs

@@ -1,11 +1,12 @@
 'use strict';
 
+var error = require('@mastra/core/error');
 var vector = require('@mastra/core/vector');
 var mongodb = require('mongodb');
 var uuid = require('uuid');
 var filter = require('@mastra/core/vector/filter');
-var agent = require('@mastra/core/agent');
 var storage = require('@mastra/core/storage');
+var agent = require('@mastra/core/agent');
 
 // src/vector/index.ts
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
@@ -118,28 +119,68 @@ var MongoDBVector = class extends vector.MastraVector {
   }
   // Public methods
   async connect() {
-    await this.client.connect();
+    try {
+      await this.client.connect();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_CONNECT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   async disconnect() {
-    await this.client.close();
+    try {
+      await this.client.close();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DISCONNECT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   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$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_CREATE_INDEX_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            indexName,
+            dimension,
+            metric
+          }
+        },
+        error$1
+      );
     }
-    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: [
@@ -148,18 +189,52 @@ var MongoDBVector = class extends vector.MastraVector {
               path: embeddingField,
               numDimensions,
               similarity: mongoMetric
+            },
+            {
+              type: "filter",
+              path: "_id"
             }
           ]
         },
         name: indexNameInternal,
         type: "vectorSearch"
       });
-    } catch (error) {
-      if (error.codeName !== "IndexAlreadyExists") {
-        throw error;
+      await collection.createSearchIndex({
+        definition: {
+          mappings: {
+            dynamic: true
+          }
+        },
+        name: `${indexName}_search_index`,
+        type: "search"
+      });
+    } catch (error$1) {
+      if (error$1.codeName !== "IndexAlreadyExists") {
+        throw new error.MastraError(
+          {
+            id: "STORAGE_MONGODB_VECTOR_CREATE_INDEX_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY
+          },
+          error$1
+        );
       }
     }
-    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$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_CREATE_INDEX_FAILED_STORE_METADATA",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Waits for the index to be ready.
@@ -189,40 +264,54 @@ var MongoDBVector = class extends vector.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(() => uuid.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(() => uuid.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$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
         },
-        {}
+        error$1
       );
-      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,
@@ -232,44 +321,49 @@ var MongoDBVector = class extends vector.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 vectorSearch = {
+        index: indexNameInternal,
+        queryVector,
+        path: this.embeddingFieldName,
+        numCandidates: 100,
+        limit: topK
+      };
+      if (Object.keys(combinedFilter).length > 0) {
+        const candidateIds = await collection.aggregate([{ $match: combinedFilter }, { $project: { _id: 1 } }]).map((doc) => doc._id).toArray();
+        if (candidateIds.length > 0) {
+          vectorSearch.filter = { _id: { $in: candidateIds } };
         }
       }
-    ];
-    try {
+      const pipeline = [
+        {
+          $vectorSearch: vectorSearch
+        },
+        {
+          $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,
@@ -278,14 +372,34 @@ var MongoDBVector = class extends vector.MastraVector {
         vector: includeVector ? result.vector : void 0,
         document: result.document
       }));
-    } catch (error) {
-      console.error("Error during vector search:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
     }
   }
   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$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -294,24 +408,52 @@ var MongoDBVector = class extends vector.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$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+    }
   }
   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$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -347,8 +489,19 @@ var MongoDBVector = class extends vector.MastraVector {
         updateDoc[this.metadataFieldName] = normalizedMeta;
       }
       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}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            id
+          }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -362,8 +515,19 @@ var MongoDBVector = class extends vector.MastraVector {
     try {
       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}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DELETE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            id
+          }
+        },
+        error$1
+      );
     }
   }
   // Private methods
@@ -404,21 +568,19 @@ var MongoDBVector = class extends vector.MastraVector {
     return translator.translate(filter);
   }
 };
-function safelyParseJSON(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
-  }
-}
-var MongoDBStore = class extends storage.MastraStorage {
-  #isConnected = false;
+var MongoDBConnector = class _MongoDBConnector {
   #client;
-  #db;
   #dbName;
-  constructor(config) {
-    super({ name: "MongoDBStore" });
+  #handler;
+  #isConnected;
+  #db;
+  constructor(options) {
+    this.#client = options.client;
+    this.#dbName = options.dbName;
+    this.#handler = options.handler;
     this.#isConnected = false;
+  }
+  static fromDatabaseConfig(config) {
     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."
@@ -429,321 +591,1248 @@ var MongoDBStore = class extends storage.MastraStorage {
         "MongoDBStore: dbName must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
       );
     }
-    this.#dbName = config.dbName;
-    this.#client = new mongodb.MongoClient(config.url, config.options);
+    return new _MongoDBConnector({
+      client: new mongodb.MongoClient(config.url, config.options),
+      dbName: config.dbName,
+      handler: void 0
+    });
+  }
+  static fromConnectionHandler(handler) {
+    return new _MongoDBConnector({
+      client: void 0,
+      dbName: void 0,
+      handler
+    });
   }
   async getConnection() {
-    if (this.#isConnected) {
+    if (this.#client) {
+      if (this.#isConnected && this.#db) {
+        return this.#db;
+      }
+      await this.#client.connect();
+      this.#db = this.#client.db(this.#dbName);
+      this.#isConnected = true;
       return this.#db;
     }
-    await this.#client.connect();
-    this.#db = this.#client.db(this.#dbName);
-    this.#isConnected = true;
-    return this.#db;
+    throw new Error("MongoDBStore: client cannot be empty. Check your MongoDBConnector configuration.");
   }
   async getCollection(collectionName) {
+    if (this.#handler) {
+      return this.#handler.getCollection(collectionName);
+    }
     const db = await this.getConnection();
     return db.collection(collectionName);
   }
-  async createTable() {
-  }
-  /**
-   * No-op: This backend is schemaless and does not require schema changes.
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
-  async alterTable(_args) {
-  }
-  async clearTable({ tableName }) {
-    try {
-      const collection = await this.getCollection(tableName);
-      await collection.deleteMany({});
-    } catch (error) {
-      if (error instanceof Error) {
-        this.logger.error(error.message);
-      }
-    }
-  }
-  async insert({ tableName, record }) {
-    try {
-      const collection = await this.getCollection(tableName);
-      await collection.insertOne(record);
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
-  }
-  async batchInsert({ tableName, records }) {
-    if (!records.length) {
+  async close() {
+    if (this.#client) {
+      await this.#client.close();
+      this.#isConnected = false;
       return;
     }
-    try {
-      const collection = await this.getCollection(tableName);
-      await collection.insertMany(records);
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
+    if (this.#handler) {
+      await this.#handler.close();
     }
   }
-  async load({ tableName, keys }) {
-    this.logger.info(`Loading ${tableName} with keys ${JSON.stringify(keys)}`);
+};
+function transformEvalRow(row) {
+  let testInfoValue = null;
+  if (row.test_info) {
     try {
-      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;
+      testInfoValue = typeof row.test_info === "string" ? storage.safelyParseJSON(row.test_info) : row.test_info;
+    } catch (e) {
+      console.warn("Failed to parse test_info:", e);
     }
   }
-  async getThreadById({ threadId }) {
-    try {
-      const collection = await this.getCollection(storage.TABLE_THREADS);
-      const result = await collection.findOne({ id: threadId });
-      if (!result) {
-        return null;
-      }
-      return {
-        ...result,
-        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;
-    }
+  let resultValue;
+  try {
+    resultValue = typeof row.result === "string" ? storage.safelyParseJSON(row.result) : row.result;
+  } catch (e) {
+    console.warn("Failed to parse result:", e);
+    throw new Error("Invalid result format");
   }
-  async getThreadsByResourceId({ resourceId }) {
+  return {
+    agentName: row.agent_name,
+    input: row.input,
+    output: row.output,
+    result: resultValue,
+    metricName: row.metric_name,
+    instructions: row.instructions,
+    testInfo: testInfoValue,
+    globalRunId: row.global_run_id,
+    runId: row.run_id,
+    createdAt: row.createdAt
+  };
+}
+var LegacyEvalsMongoDB = class extends storage.LegacyEvalsStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  /** @deprecated use getEvals instead */
+  async getEvalsByAgentName(agentName, type) {
     try {
-      const collection = await this.getCollection(storage.TABLE_THREADS);
-      const results = await collection.find({ resourceId }).toArray();
-      if (!results.length) {
+      const query = {
+        agent_name: agentName
+      };
+      if (type === "test") {
+        query["test_info"] = { $ne: null };
+      }
+      if (type === "live") {
+        query["test_info"] = null;
+      }
+      const collection = await this.operations.getCollection(storage.TABLE_EVALS);
+      const documents = await collection.find(query).sort({ created_at: "desc" }).toArray();
+      const result = documents.map((row) => transformEvalRow(row));
+      return result.filter((row) => {
+        if (type === "live") {
+          return !Boolean(row.testInfo?.testPath);
+        }
+        if (type === "test") {
+          return row.testInfo?.testPath !== null;
+        }
+        return true;
+      });
+    } catch (error$1) {
+      if (error$1 instanceof Error && error$1.message.includes("no such table")) {
         return [];
       }
-      return results.map((result) => ({
-        ...result,
-        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;
-    }
-  }
-  async saveThread({ thread }) {
-    try {
-      const collection = await this.getCollection(storage.TABLE_THREADS);
-      await collection.updateOne(
-        { id: thread.id },
+      throw new error.MastraError(
         {
-          $set: {
-            ...thread,
-            metadata: JSON.stringify(thread.metadata)
-          }
+          id: "STORAGE_MONGODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName }
         },
-        { upsert: true }
+        error$1
       );
-      return thread;
-    } catch (error) {
-      this.logger.error(`Error saving thread ${thread.id}: ${error}`);
-      throw error;
     }
   }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    const thread = await this.getThreadById({ threadId: id });
-    if (!thread) {
-      throw new Error(`Thread ${id} not found`);
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const currentOffset = page * perPage;
+    const query = {};
+    if (agentName) {
+      query["agent_name"] = agentName;
     }
-    const updatedThread = {
-      ...thread,
-      title,
-      metadata: {
-        ...thread.metadata,
-        ...metadata
+    if (type === "test") {
+      query["test_info"] = { $ne: null };
+    } else if (type === "live") {
+      query["test_info"] = null;
+    }
+    if (fromDate || toDate) {
+      query["createdAt"] = {};
+      if (fromDate) {
+        query["createdAt"]["$gte"] = fromDate;
       }
-    };
+      if (toDate) {
+        query["createdAt"]["$lte"] = toDate;
+      }
+    }
     try {
-      const collection = await this.getCollection(storage.TABLE_THREADS);
-      await collection.updateOne(
-        { id },
+      const collection = await this.operations.getCollection(storage.TABLE_EVALS);
+      let total = 0;
+      if (page === 0 || perPage < 1e3) {
+        total = await collection.countDocuments(query);
+      }
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const documents = await collection.find(query).sort({ created_at: "desc" }).skip(currentOffset).limit(perPage).toArray();
+      const evals = documents.map((row) => transformEvalRow(row));
+      const filteredEvals = evals.filter((row) => {
+        if (type === "live") {
+          return !Boolean(row.testInfo?.testPath);
+        }
+        if (type === "test") {
+          return row.testInfo?.testPath !== null;
+        }
+        return true;
+      });
+      const hasMore = currentOffset + filteredEvals.length < total;
+      return {
+        evals: filteredEvals,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
         {
-          $set: {
-            title,
-            metadata: JSON.stringify(updatedThread.metadata)
+          id: "STORAGE_MONGODB_STORE_GET_EVALS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            agentName: agentName || "all",
+            type: type || "all",
+            page,
+            perPage
           }
-        }
+        },
+        error$1
       );
-    } catch (error) {
-      this.logger.error(`Error updating thread ${id}:) ${error}`);
-      throw error;
     }
-    return updatedThread;
   }
-  async deleteThread({ threadId }) {
+};
+
+// src/storage/domains/utils.ts
+function formatDateForMongoDB(date) {
+  return typeof date === "string" ? new Date(date) : date;
+}
+
+// src/storage/domains/memory/index.ts
+var MemoryStorageMongoDB = class extends storage.MemoryStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  parseRow(row) {
+    let content = row.content;
+    if (typeof content === "string") {
+      try {
+        content = JSON.parse(content);
+      } catch {
+      }
+    }
+    const result = {
+      id: row.id,
+      content,
+      role: row.role,
+      createdAt: formatDateForMongoDB(row.createdAt),
+      threadId: row.thread_id,
+      resourceId: row.resourceId
+    };
+    if (row.type && row.type !== "v2") result.type = row.type;
+    return result;
+  }
+  async _getIncludedMessages({
+    threadId,
+    selectBy
+  }) {
+    const include = selectBy?.include;
+    if (!include) return null;
+    const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+    const includedMessages = [];
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      const searchThreadId = inc.threadId || threadId;
+      const allMessages = await collection.find({ thread_id: searchThreadId }).sort({ createdAt: 1 }).toArray();
+      const targetIndex = allMessages.findIndex((msg) => msg.id === id);
+      if (targetIndex === -1) continue;
+      const startIndex = Math.max(0, targetIndex - withPreviousMessages);
+      const endIndex = Math.min(allMessages.length - 1, targetIndex + withNextMessages);
+      for (let i = startIndex; i <= endIndex; i++) {
+        includedMessages.push(allMessages[i]);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const dedupedMessages = includedMessages.filter((msg) => {
+      if (seen.has(msg.id)) return false;
+      seen.add(msg.id);
+      return true;
+    });
+    return dedupedMessages.map((row) => this.parseRow(row));
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    try {
+      const messages = [];
+      const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      }
+      const excludeIds = messages.map((m) => m.id);
+      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const query = { thread_id: threadId };
+      if (excludeIds.length > 0) {
+        query.id = { $nin: excludeIds };
+      }
+      if (limit > 0) {
+        const remainingMessages = await collection.find(query).sort({ createdAt: -1 }).limit(limit).toArray();
+        messages.push(...remainingMessages.map((row) => this.parseRow(row)));
+      }
+      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === "v2") return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_GET_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  async getMessagesPaginated(args) {
+    const { threadId, format, selectBy } = args;
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
+    const perPage = perPageInput !== void 0 ? perPageInput : storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const messages = [];
+    if (selectBy?.include?.length) {
+      try {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      } catch (error$1) {
+        throw new error.MastraError(
+          {
+            id: "MONGODB_STORE_GET_MESSAGES_PAGINATED_GET_INCLUDE_MESSAGES_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: { threadId }
+          },
+          error$1
+        );
+      }
+    }
+    try {
+      const currentOffset = page * perPage;
+      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const query = { thread_id: threadId };
+      if (fromDate) {
+        query.createdAt = { ...query.createdAt, $gte: fromDate };
+      }
+      if (toDate) {
+        query.createdAt = { ...query.createdAt, $lte: toDate };
+      }
+      const total = await collection.countDocuments(query);
+      if (total === 0 && messages.length === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const excludeIds = messages.map((m) => m.id);
+      if (excludeIds.length > 0) {
+        query.id = { $nin: excludeIds };
+      }
+      const dataResult = await collection.find(query).sort({ createdAt: -1 }).skip(currentOffset).limit(perPage).toArray();
+      messages.push(...dataResult.map((row) => this.parseRow(row)));
+      const messagesToReturn = format === "v1" ? new agent.MessageList().add(messages, "memory").get.all.v1() : new agent.MessageList().add(messages, "memory").get.all.v2();
+      return {
+        messages: messagesToReturn,
+        total,
+        page,
+        perPage,
+        hasMore: (page + 1) * perPage < total
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MONGODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      return { messages: [], total: 0, page, perPage, hasMore: false };
+    }
+  }
+  async saveMessages({
+    messages,
+    format
+  }) {
+    if (messages.length === 0) return messages;
+    try {
+      const threadId = messages[0]?.threadId;
+      if (!threadId) {
+        throw new Error("Thread ID is required");
+      }
+      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const threadsCollection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const messagesToInsert = messages.map((message) => {
+        const time = message.createdAt || /* @__PURE__ */ new Date();
+        if (!message.threadId) {
+          throw new Error(
+            "Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred."
+          );
+        }
+        if (!message.resourceId) {
+          throw new Error(
+            "Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred."
+          );
+        }
+        return {
+          updateOne: {
+            filter: { id: message.id },
+            update: {
+              $set: {
+                id: message.id,
+                thread_id: message.threadId,
+                content: typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
+                role: message.role,
+                type: message.type || "v2",
+                createdAt: formatDateForMongoDB(time),
+                resourceId: message.resourceId
+              }
+            },
+            upsert: true
+          }
+        };
+      });
+      await Promise.all([
+        collection.bulkWrite(messagesToInsert),
+        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
+      ]);
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === "v2") return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_SAVE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+    const existingMessages = await collection.find({ id: { $in: messageIds } }).toArray();
+    const existingMessagesParsed = existingMessages.map((msg) => this.parseRow(msg));
+    if (existingMessagesParsed.length === 0) {
+      return [];
+    }
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    const bulkOps = [];
+    for (const existingMessage of existingMessagesParsed) {
+      const updatePayload = messages.find((m) => m.id === existingMessage.id);
+      if (!updatePayload) continue;
+      const { id, ...fieldsToUpdate } = updatePayload;
+      if (Object.keys(fieldsToUpdate).length === 0) continue;
+      threadIdsToUpdate.add(existingMessage.threadId);
+      if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+        threadIdsToUpdate.add(updatePayload.threadId);
+      }
+      const updateDoc = {};
+      const updatableFields = { ...fieldsToUpdate };
+      if (updatableFields.content) {
+        const newContent = {
+          ...existingMessage.content,
+          ...updatableFields.content,
+          // Deep merge metadata if it exists on both
+          ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
+            metadata: {
+              ...existingMessage.content.metadata,
+              ...updatableFields.content.metadata
+            }
+          } : {}
+        };
+        updateDoc.content = JSON.stringify(newContent);
+        delete updatableFields.content;
+      }
+      for (const key in updatableFields) {
+        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+          const dbKey = key === "threadId" ? "thread_id" : key;
+          let value = updatableFields[key];
+          if (typeof value === "object" && value !== null) {
+            value = JSON.stringify(value);
+          }
+          updateDoc[dbKey] = value;
+        }
+      }
+      if (Object.keys(updateDoc).length > 0) {
+        bulkOps.push({
+          updateOne: {
+            filter: { id },
+            update: { $set: updateDoc }
+          }
+        });
+      }
+    }
+    if (bulkOps.length > 0) {
+      await collection.bulkWrite(bulkOps);
+    }
+    if (threadIdsToUpdate.size > 0) {
+      const threadsCollection = await this.operations.getCollection(storage.TABLE_THREADS);
+      await threadsCollection.updateMany(
+        { id: { $in: Array.from(threadIdsToUpdate) } },
+        { $set: { updatedAt: /* @__PURE__ */ new Date() } }
+      );
+    }
+    const updatedMessages = await collection.find({ id: { $in: messageIds } }).toArray();
+    return updatedMessages.map((row) => this.parseRow(row));
+  }
+  async getResourceById({ resourceId }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      const result = await collection.findOne({ id: resourceId });
+      if (!result) {
+        return null;
+      }
+      return {
+        id: result.id,
+        workingMemory: result.workingMemory || "",
+        metadata: typeof result.metadata === "string" ? storage.safelyParseJSON(result.metadata) : result.metadata,
+        createdAt: formatDateForMongoDB(result.createdAt),
+        updatedAt: formatDateForMongoDB(result.updatedAt)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_RESOURCE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveResource({ resource }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      await collection.updateOne(
+        { id: resource.id },
+        {
+          $set: {
+            ...resource,
+            metadata: JSON.stringify(resource.metadata)
+          }
+        },
+        { upsert: true }
+      );
+      return resource;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_SAVE_RESOURCE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId: resource.id }
+        },
+        error$1
+      );
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    try {
+      const existingResource = await this.getResourceById({ resourceId });
+      if (!existingResource) {
+        const newResource = {
+          id: resourceId,
+          workingMemory: workingMemory || "",
+          metadata: metadata || {},
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        return this.saveResource({ resource: newResource });
+      }
+      const updatedResource = {
+        ...existingResource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+        metadata: metadata ? { ...existingResource.metadata, ...metadata } : existingResource.metadata,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      const updateDoc = { updatedAt: updatedResource.updatedAt };
+      if (workingMemory !== void 0) {
+        updateDoc.workingMemory = workingMemory;
+      }
+      if (metadata) {
+        updateDoc.metadata = JSON.stringify(updatedResource.metadata);
+      }
+      await collection.updateOne({ id: resourceId }, { $set: updateDoc });
+      return updatedResource;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_UPDATE_RESOURCE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadById({ threadId }) {
     try {
-      const collectionMessages = await this.getCollection(storage.TABLE_MESSAGES);
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const result = await collection.findOne({ id: threadId });
+      if (!result) {
+        return null;
+      }
+      return {
+        ...result,
+        metadata: typeof result.metadata === "string" ? storage.safelyParseJSON(result.metadata) : result.metadata
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_THREAD_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const results = await collection.find({ resourceId }).sort({ updatedAt: -1 }).toArray();
+      if (!results.length) {
+        return [];
+      }
+      return results.map((result) => ({
+        ...result,
+        metadata: typeof result.metadata === "string" ? storage.safelyParseJSON(result.metadata) : result.metadata
+      }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    try {
+      const { resourceId, page, perPage } = args;
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const query = { resourceId };
+      const total = await collection.countDocuments(query);
+      const threads = await collection.find(query).sort({ updatedAt: -1 }).skip(page * perPage).limit(perPage).toArray();
+      return {
+        threads: threads.map((thread) => ({
+          id: thread.id,
+          title: thread.title,
+          resourceId: thread.resourceId,
+          createdAt: formatDateForMongoDB(thread.createdAt),
+          updatedAt: formatDateForMongoDB(thread.updatedAt),
+          metadata: thread.metadata || {}
+        })),
+        total,
+        page,
+        perPage,
+        hasMore: (page + 1) * perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId: args.resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveThread({ thread }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      await collection.updateOne(
+        { id: thread.id },
+        {
+          $set: {
+            ...thread,
+            metadata: thread.metadata
+          }
+        },
+        { upsert: true }
+      );
+      return thread;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_SAVE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
+        },
+        error$1
+      );
+    }
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    const thread = await this.getThreadById({ threadId: id });
+    if (!thread) {
+      throw new error.MastraError({
+        id: "STORAGE_MONGODB_STORE_UPDATE_THREAD_NOT_FOUND",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY,
+        details: { threadId: id, status: 404 },
+        text: `Thread ${id} not found`
+      });
+    }
+    const updatedThread = {
+      ...thread,
+      title,
+      metadata: {
+        ...thread.metadata,
+        ...metadata
+      }
+    };
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      await collection.updateOne(
+        { id },
+        {
+          $set: {
+            title,
+            metadata: updatedThread.metadata
+          }
+        }
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_UPDATE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: id }
+        },
+        error$1
+      );
+    }
+    return updatedThread;
+  }
+  async deleteThread({ threadId }) {
+    try {
+      const collectionMessages = await this.operations.getCollection(storage.TABLE_MESSAGES);
       await collectionMessages.deleteMany({ thread_id: threadId });
-      const collectionThreads = await this.getCollection(storage.TABLE_THREADS);
+      const collectionThreads = await this.operations.getCollection(storage.TABLE_THREADS);
       await collectionThreads.deleteOne({ id: threadId });
-    } catch (error) {
-      this.logger.error(`Error deleting thread ${threadId}: ${error}`);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_DELETE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+};
+var StoreOperationsMongoDB = class extends storage.StoreOperations {
+  #connector;
+  constructor(config) {
+    super();
+    this.#connector = config.connector;
+  }
+  async getCollection(collectionName) {
+    return this.#connector.getCollection(collectionName);
+  }
+  async hasColumn(_table, _column) {
+    return true;
+  }
+  async createTable() {
+  }
+  async alterTable(_args) {
+  }
+  async clearTable({ tableName }) {
+    try {
+      const collection = await this.getCollection(tableName);
+      await collection.deleteMany({});
+    } catch (error$1) {
+      if (error$1 instanceof Error) {
+        const matstraError = new error.MastraError(
+          {
+            id: "STORAGE_MONGODB_STORE_CLEAR_TABLE_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: { tableName }
+          },
+          error$1
+        );
+        this.logger.error(matstraError.message);
+        this.logger?.trackException(matstraError);
+      }
+    }
+  }
+  async dropTable({ tableName }) {
+    try {
+      const collection = await this.getCollection(tableName);
+      await collection.drop();
+    } catch (error$1) {
+      if (error$1 instanceof Error && error$1.message.includes("ns not found")) {
+        return;
+      }
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_DROP_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  processJsonbFields(tableName, record) {
+    const schema = storage.TABLE_SCHEMAS[tableName];
+    return Object.fromEntries(
+      Object.entries(schema).map(([key, value]) => {
+        if (value.type === "jsonb" && record[key] && typeof record[key] === "string") {
+          return [key, storage.safelyParseJSON(record[key])];
+        }
+        return [key, record[key]];
+      })
+    );
+  }
+  async insert({ tableName, record }) {
+    try {
+      const collection = await this.getCollection(tableName);
+      const recordToInsert = this.processJsonbFields(tableName, record);
+      await collection.insertOne(recordToInsert);
+    } catch (error$1) {
+      if (error$1 instanceof Error) {
+        const matstraError = new error.MastraError(
+          {
+            id: "STORAGE_MONGODB_STORE_INSERT_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: { tableName }
+          },
+          error$1
+        );
+        this.logger.error(matstraError.message);
+        this.logger?.trackException(matstraError);
+      }
+    }
+  }
+  async batchInsert({ tableName, records }) {
+    if (!records.length) {
+      return;
+    }
+    try {
+      const collection = await this.getCollection(tableName);
+      const processedRecords = records.map((record) => this.processJsonbFields(tableName, record));
+      await collection.insertMany(processedRecords);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_BATCH_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async load({ tableName, keys }) {
+    this.logger.info(`Loading ${tableName} with keys ${JSON.stringify(keys)}`);
+    try {
+      const collection = await this.getCollection(tableName);
+      return await collection.find(keys).toArray();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_LOAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+};
+function transformScoreRow(row) {
+  let scorerValue = null;
+  if (row.scorer) {
+    try {
+      scorerValue = typeof row.scorer === "string" ? storage.safelyParseJSON(row.scorer) : row.scorer;
+    } catch (e) {
+      console.warn("Failed to parse scorer:", e);
+    }
+  }
+  let extractStepResultValue = null;
+  if (row.extractStepResult) {
+    try {
+      extractStepResultValue = typeof row.extractStepResult === "string" ? storage.safelyParseJSON(row.extractStepResult) : row.extractStepResult;
+    } catch (e) {
+      console.warn("Failed to parse extractStepResult:", e);
+    }
+  }
+  let analyzeStepResultValue = null;
+  if (row.analyzeStepResult) {
+    try {
+      analyzeStepResultValue = typeof row.analyzeStepResult === "string" ? storage.safelyParseJSON(row.analyzeStepResult) : row.analyzeStepResult;
+    } catch (e) {
+      console.warn("Failed to parse analyzeStepResult:", e);
+    }
+  }
+  let inputValue = null;
+  if (row.input) {
+    try {
+      inputValue = typeof row.input === "string" ? storage.safelyParseJSON(row.input) : row.input;
+    } catch (e) {
+      console.warn("Failed to parse input:", e);
+    }
+  }
+  let outputValue = null;
+  if (row.output) {
+    try {
+      outputValue = typeof row.output === "string" ? storage.safelyParseJSON(row.output) : row.output;
+    } catch (e) {
+      console.warn("Failed to parse output:", e);
+    }
+  }
+  let entityValue = null;
+  if (row.entity) {
+    try {
+      entityValue = typeof row.entity === "string" ? storage.safelyParseJSON(row.entity) : row.entity;
+    } catch (e) {
+      console.warn("Failed to parse entity:", e);
+    }
+  }
+  let runtimeContextValue = null;
+  if (row.runtimeContext) {
+    try {
+      runtimeContextValue = typeof row.runtimeContext === "string" ? storage.safelyParseJSON(row.runtimeContext) : row.runtimeContext;
+    } catch (e) {
+      console.warn("Failed to parse runtimeContext:", e);
+    }
+  }
+  return {
+    id: row.id,
+    entityId: row.entityId,
+    entityType: row.entityType,
+    scorerId: row.scorerId,
+    traceId: row.traceId,
+    runId: row.runId,
+    scorer: scorerValue,
+    extractStepResult: extractStepResultValue,
+    analyzeStepResult: analyzeStepResultValue,
+    score: row.score,
+    reason: row.reason,
+    extractPrompt: row.extractPrompt,
+    analyzePrompt: row.analyzePrompt,
+    reasonPrompt: row.reasonPrompt,
+    input: inputValue,
+    output: outputValue,
+    additionalContext: row.additionalContext,
+    runtimeContext: runtimeContextValue,
+    entity: entityValue,
+    source: row.source,
+    resourceId: row.resourceId,
+    threadId: row.threadId,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+var ScoresStorageMongoDB = class extends storage.ScoresStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  async getScoreById({ id }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const document = await collection.findOne({ id });
+      if (!document) {
+        return null;
+      }
+      return transformScoreRow(document);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_SCORE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async saveScore(score) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const scoreId = `score-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const scoreData = {
+        id: scoreId,
+        entityId: score.entityId,
+        entityType: score.entityType,
+        scorerId: score.scorerId,
+        traceId: score.traceId || "",
+        runId: score.runId,
+        scorer: typeof score.scorer === "string" ? storage.safelyParseJSON(score.scorer) : score.scorer,
+        extractStepResult: typeof score.extractStepResult === "string" ? storage.safelyParseJSON(score.extractStepResult) : score.extractStepResult,
+        analyzeStepResult: typeof score.analyzeStepResult === "string" ? storage.safelyParseJSON(score.analyzeStepResult) : score.analyzeStepResult,
+        score: score.score,
+        reason: score.reason,
+        extractPrompt: score.extractPrompt,
+        analyzePrompt: score.analyzePrompt,
+        reasonPrompt: score.reasonPrompt,
+        input: typeof score.input === "string" ? storage.safelyParseJSON(score.input) : score.input,
+        output: typeof score.output === "string" ? storage.safelyParseJSON(score.output) : score.output,
+        additionalContext: score.additionalContext,
+        runtimeContext: typeof score.runtimeContext === "string" ? storage.safelyParseJSON(score.runtimeContext) : score.runtimeContext,
+        entity: typeof score.entity === "string" ? storage.safelyParseJSON(score.entity) : score.entity,
+        source: score.source,
+        resourceId: score.resourceId || "",
+        threadId: score.threadId || "",
+        createdAt: now,
+        updatedAt: now
+      };
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      await collection.insertOne(scoreData);
+      const savedScore = {
+        ...score,
+        id: scoreId,
+        createdAt: now,
+        updatedAt: now
+      };
+      return { score: savedScore };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_SAVE_SCORE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerId: score.scorerId, runId: score.runId }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType
+  }) {
+    try {
+      const query = { scorerId };
+      if (entityId) {
+        query.entityId = entityId;
+      }
+      if (entityType) {
+        query.entityType = entityType;
+      }
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments(query);
+      const currentOffset = pagination.page * pagination.perPage;
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          }
+        };
+      }
+      const documents = await collection.find(query).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      const hasMore = currentOffset + scores.length < total;
+      return {
+        scores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerId, page: pagination.page, perPage: pagination.perPage }
+        },
+        error$1
+      );
     }
   }
-  async getMessages({
-    threadId,
-    selectBy,
-    format
+  async getScoresByRunId({
+    runId,
+    pagination
   }) {
     try {
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-      const include = selectBy?.include || [];
-      let messages = [];
-      let allMessages = [];
-      const collection = await this.getCollection(storage.TABLE_MESSAGES);
-      allMessages = (await collection.find({ thread_id: threadId }).sort({ createdAt: -1 }).toArray()).map(
-        (row) => this.parseRow(row)
-      );
-      if (include.length) {
-        const idToIndex = /* @__PURE__ */ new Map();
-        allMessages.forEach((msg, idx) => {
-          idToIndex.set(msg.id, idx);
-        });
-        const selectedIndexes = /* @__PURE__ */ new Set();
-        for (const inc of include) {
-          const idx = idToIndex.get(inc.id);
-          if (idx === void 0) continue;
-          for (let i = 1; i <= (inc.withPreviousMessages || 0); i++) {
-            if (idx + i < allMessages.length) selectedIndexes.add(idx + i);
-          }
-          selectedIndexes.add(idx);
-          for (let i = 1; i <= (inc.withNextMessages || 0); i++) {
-            if (idx - i >= 0) selectedIndexes.add(idx - i);
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments({ runId });
+      const currentOffset = pagination.page * pagination.perPage;
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
           }
-        }
-        messages.push(
-          ...Array.from(selectedIndexes).map((i) => allMessages[i]).filter((m) => !!m)
-        );
+        };
       }
-      const excludeIds = new Set(messages.map((m) => m.id));
-      for (const msg of allMessages) {
-        if (messages.length >= limit) break;
-        if (!excludeIds.has(msg.id)) {
-          messages.push(msg);
+      const documents = await collection.find({ runId }).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      const hasMore = currentOffset + scores.length < total;
+      return {
+        scores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
         }
-      }
-      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      const list = new agent.MessageList().add(messages.slice(0, limit), "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      this.logger.error("Error getting messages:", error);
-      throw error;
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_RUN_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { runId, page: pagination.page, perPage: pagination.perPage }
+        },
+        error$1
+      );
     }
   }
-  async saveMessages({
-    messages,
-    format
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
   }) {
-    if (!messages.length) {
-      return messages;
-    }
-    const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      this.logger.error("Thread ID is required to save messages");
-      throw new Error("Thread ID is required");
-    }
     try {
-      const messagesToInsert = messages.map((message) => {
-        const time = message.createdAt || /* @__PURE__ */ new Date();
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments({ entityId, entityType });
+      const currentOffset = pagination.page * pagination.perPage;
+      if (total === 0) {
         return {
-          id: message.id,
-          thread_id: threadId,
-          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
-          role: message.role,
-          type: message.type,
-          resourceId: message.resourceId,
-          createdAt: time instanceof Date ? time.toISOString() : time
+          scores: [],
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          }
         };
-      });
-      const collection = await this.getCollection(storage.TABLE_MESSAGES);
-      const threadsCollection = await this.getCollection(storage.TABLE_THREADS);
-      await Promise.all([
-        collection.insertMany(messagesToInsert),
-        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
-      ]);
-      const list = new agent.MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      this.logger.error("Failed to save messages in database: " + error?.message);
-      throw error;
-    }
-  }
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-    filters
-  } = {
-    page: 0,
-    perPage: 100
-  }) {
-    const limit = perPage;
-    const offset = page * perPage;
+      }
+      const documents = await collection.find({ entityId, entityType }).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      const hasMore = currentOffset + scores.length < total;
+      return {
+        scores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { entityId, entityType, page: pagination.page, perPage: pagination.perPage }
+        },
+        error$1
+      );
+    }
+  }
+};
+var TracesStorageMongoDB = class extends storage.TracesStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  async getTraces(args) {
+    if (args.fromDate || args.toDate) {
+      args.dateRange = {
+        start: args.fromDate,
+        end: args.toDate
+      };
+    }
+    try {
+      const result = await this.getTracesPaginated(args);
+      return result.traces;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const currentOffset = 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.${key}`]: value
+      }));
     }
     if (filters) {
       Object.entries(filters).forEach(([key, value]) => {
         query[key] = value;
       });
     }
-    const collection = await this.getCollection(storage.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
-    }));
-  }
-  async getWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    limit,
-    offset
-  } = {}) {
-    const query = {};
-    if (workflowName) {
-      query["workflow_name"] = workflowName;
-    }
     if (fromDate || toDate) {
       query["createdAt"] = {};
       if (fromDate) {
@@ -753,68 +1842,68 @@ var MongoDBStore = class extends storage.MastraStorage {
         query["createdAt"]["$lte"] = toDate;
       }
     }
-    const collection = await this.getCollection(storage.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.operations.getCollection(storage.TABLE_TRACES);
+      const total = await collection.countDocuments(query);
+      if (total === 0) {
+        return {
+          traces: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
       }
+      const result = await collection.find(query, {
+        sort: { startTime: -1 }
+      }).limit(perPage).skip(currentOffset).toArray();
+      const traces = result.map((row) => ({
+        id: row.id,
+        parentSpanId: row.parentSpanId,
+        traceId: row.traceId,
+        name: row.name,
+        scope: row.scope,
+        kind: row.kind,
+        status: storage.safelyParseJSON(row.status),
+        events: storage.safelyParseJSON(row.events),
+        links: storage.safelyParseJSON(row.links),
+        attributes: storage.safelyParseJSON(row.attributes),
+        startTime: row.startTime,
+        endTime: row.endTime,
+        other: storage.safelyParseJSON(row.other),
+        createdAt: row.createdAt
+      }));
       return {
-        workflowName: row.workflow_name,
-        runId: row.run_id,
-        snapshot: parsedSnapshot,
-        createdAt: new Date(row.createdAt),
-        updatedAt: new Date(row.updatedAt)
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + traces.length < total
       };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: storage.TABLE_TRACES,
+      records
     });
-    return { runs, total: total || runs.length };
   }
-  async getEvalsByAgentName(agentName, type) {
-    try {
-      const query = {
-        agent_name: agentName
-      };
-      if (type === "test") {
-        query["test_info"] = { $ne: null };
-      }
-      if (type === "live") {
-        query["test_info"] = null;
-      }
-      const collection = await this.getCollection(storage.TABLE_EVALS);
-      const documents = await collection.find(query).sort({ created_at: "desc" }).toArray();
-      const result = documents.map((row) => this.transformEvalRow(row));
-      return result.filter((row) => {
-        if (type === "live") {
-          return !Boolean(row.testInfo?.testPath);
-        }
-        if (type === "test") {
-          return row.testInfo?.testPath !== null;
-        }
-        return true;
-      });
-    } catch (error) {
-      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;
-    }
+};
+var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
   }
   async persistWorkflowSnapshot({
     workflowName,
@@ -822,24 +1911,30 @@ var MongoDBStore = class extends storage.MastraStorage {
     snapshot
   }) {
     try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
       await collection.updateOne(
         { workflow_name: workflowName, run_id: runId },
         {
           $set: {
-            snapshot: JSON.stringify(snapshot),
-            updatedAt: now
-          },
-          $setOnInsert: {
-            createdAt: now
+            workflow_name: workflowName,
+            run_id: runId,
+            snapshot,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
           }
         },
         { upsert: true }
       );
-    } catch (error) {
-      this.logger.error(`Error persisting workflow snapshot: ${error}`);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
     }
   }
   async loadWorkflowSnapshot({
@@ -847,7 +1942,7 @@ var MongoDBStore = class extends storage.MastraStorage {
     runId
   }) {
     try {
-      const result = await this.load({
+      const result = await this.operations.load({
         tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
         keys: {
           workflow_name: workflowName,
@@ -857,40 +1952,98 @@ var MongoDBStore = class extends storage.MastraStorage {
       if (!result?.length) {
         return null;
       }
-      return JSON.parse(result[0].snapshot);
-    } catch (error) {
-      console.error("Error loading workflow snapshot:", error);
-      throw error;
+      return typeof result[0].snapshot === "string" ? storage.safelyParseJSON(result[0].snapshot) : result[0].snapshot;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
     }
   }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
+  async getWorkflowRuns(args) {
+    const options = args || {};
+    try {
+      const query = {};
+      if (options.workflowName) {
+        query["workflow_name"] = options.workflowName;
+      }
+      if (options.fromDate) {
+        query["createdAt"] = { $gte: options.fromDate };
+      }
+      if (options.toDate) {
+        if (query["createdAt"]) {
+          query["createdAt"].$lte = options.toDate;
+        } else {
+          query["createdAt"] = { $lte: options.toDate };
+        }
+      }
+      if (options.resourceId) {
+        query["resourceId"] = options.resourceId;
+      }
+      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const total = await collection.countDocuments(query);
+      let cursor = collection.find(query).sort({ createdAt: -1 });
+      if (options.offset) {
+        cursor = cursor.skip(options.offset);
+      }
+      if (options.limit) {
+        cursor = cursor.limit(options.limit);
+      }
+      const results = await cursor.toArray();
+      const runs = results.map((row) => this.parseWorkflowRun(row));
+      return {
+        runs,
+        total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_WORKFLOW_RUNS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName: options.workflowName || "unknown" }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById(args) {
     try {
       const query = {};
-      if (runId) {
-        query["run_id"] = runId;
+      if (args.runId) {
+        query["run_id"] = args.runId;
       }
-      if (workflowName) {
-        query["workflow_name"] = workflowName;
+      if (args.workflowName) {
+        query["workflow_name"] = args.workflowName;
       }
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
       const result = await collection.findOne(query);
       if (!result) {
         return null;
       }
       return this.parseWorkflowRun(result);
-    } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { runId: args.runId }
+        },
+        error$1
+      );
     }
   }
   parseWorkflowRun(row) {
     let parsedSnapshot = row.snapshot;
     if (typeof parsedSnapshot === "string") {
       try {
-        parsedSnapshot = JSON.parse(row.snapshot);
+        parsedSnapshot = typeof row.snapshot === "string" ? storage.safelyParseJSON(row.snapshot) : row.snapshot;
       } catch (e) {
         console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
       }
@@ -899,64 +2052,250 @@ var MongoDBStore = class extends storage.MastraStorage {
       workflowName: row.workflow_name,
       runId: row.run_id,
       snapshot: parsedSnapshot,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt),
       resourceId: row.resourceId
     };
   }
-  parseRow(row) {
-    let content = row.content;
-    try {
-      content = JSON.parse(row.content);
-    } catch {
+};
+
+// src/storage/index.ts
+var loadConnector = (config) => {
+  try {
+    if ("connectorHandler" in config) {
+      return MongoDBConnector.fromConnectionHandler(config.connectorHandler);
     }
+  } catch (error$1) {
+    throw new error.MastraError(
+      {
+        id: "STORAGE_MONGODB_STORE_CONSTRUCTOR_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { connectionHandler: true }
+      },
+      error$1
+    );
+  }
+  try {
+    return MongoDBConnector.fromDatabaseConfig({
+      options: config.options,
+      url: config.url,
+      dbName: config.dbName
+    });
+  } catch (error$1) {
+    throw new error.MastraError(
+      {
+        id: "STORAGE_MONGODB_STORE_CONSTRUCTOR_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { url: config?.url, dbName: config?.dbName }
+      },
+      error$1
+    );
+  }
+};
+var MongoDBStore = class extends storage.MastraStorage {
+  #connector;
+  stores;
+  get supports() {
     return {
-      id: row.id,
-      content,
-      role: row.role,
-      type: row.type,
-      createdAt: new Date(row.createdAt),
-      threadId: row.thread_id,
-      resourceId: row.resourceId
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: false,
+      createTable: false,
+      deleteMessages: false
     };
   }
-  transformEvalRow(row) {
-    let testInfoValue = null;
-    if (row.test_info) {
-      try {
-        testInfoValue = typeof row.test_info === "string" ? JSON.parse(row.test_info) : row.test_info;
-      } catch (e) {
-        console.warn("Failed to parse test_info:", e);
-      }
-    }
-    return {
-      input: row.input,
-      output: row.output,
-      result: row.result,
-      agentName: row.agent_name,
-      metricName: row.metric_name,
-      instructions: row.instructions,
-      testInfo: testInfoValue,
-      globalRunId: row.global_run_id,
-      runId: row.run_id,
-      createdAt: row.created_at
+  constructor(config) {
+    super({ name: "MongoDBStore" });
+    this.stores = {};
+    this.#connector = loadConnector(config);
+    const operations = new StoreOperationsMongoDB({
+      connector: this.#connector
+    });
+    const memory = new MemoryStorageMongoDB({
+      operations
+    });
+    const traces = new TracesStorageMongoDB({
+      operations
+    });
+    const legacyEvals = new LegacyEvalsMongoDB({
+      operations
+    });
+    const scores = new ScoresStorageMongoDB({
+      operations
+    });
+    const workflows = new WorkflowsStorageMongoDB({
+      operations
+    });
+    this.stores = {
+      operations,
+      memory,
+      traces,
+      legacyEvals,
+      scores,
+      workflows
     };
   }
-  async getTracesPaginated(_args) {
-    throw new Error("Method not implemented.");
+  async createTable({
+    tableName,
+    schema
+  }) {
+    return this.stores.operations.createTable({ tableName, schema });
+  }
+  async alterTable(_args) {
+    return this.stores.operations.alterTable(_args);
+  }
+  async dropTable({ tableName }) {
+    return this.stores.operations.dropTable({ tableName });
+  }
+  async clearTable({ tableName }) {
+    return this.stores.operations.clearTable({ 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 });
+  }
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
+  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 getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, selectBy, format });
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
   }
   async getThreadsByResourceIdPaginated(_args) {
-    throw new Error("Method not implemented.");
+    return this.stores.memory.getThreadsByResourceIdPaginated(_args);
   }
   async getMessagesPaginated(_args) {
-    throw new Error("Method not implemented.");
+    return this.stores.memory.getMessagesPaginated(_args);
+  }
+  async updateMessages(_args) {
+    return this.stores.memory.updateMessages(_args);
+  }
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async getWorkflowRuns(args) {
+    return this.stores.workflows.getWorkflowRuns(args);
+  }
+  async getEvals(options = {}) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
   }
   async close() {
-    await this.#client.close();
+    try {
+      await this.#connector.close();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_CLOSE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
   }
-  async updateMessages(_args) {
-    this.logger.error("updateMessages is not yet implemented in MongoDBStore");
-    throw new Error("Method not implemented");
+  /**
+   * SCORERS
+   */
+  async getScoreById({ id }) {
+    return this.stores.scores.getScoreById({ id });
+  }
+  async saveScore(score) {
+    return this.stores.scores.saveScore(score);
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType });
+  }
+  /**
+   * RESOURCES
+   */
+  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
+    });
   }
 };
 
@@ -1058,3 +2397,5 @@ Example Complex Query:
 exports.MONGODB_PROMPT = MONGODB_PROMPT;
 exports.MongoDBStore = MongoDBStore;
 exports.MongoDBVector = MongoDBVector;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map