@mastra/mongodb 0.0.0-vnext-inngest-20250508122351 → 0.0.0-vnext-20251104230439

package/dist/index.cjs

@@ -1,11 +1,19 @@
 '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 storage = require('@mastra/core/storage');
+var agent = require('@mastra/core/agent');
+var evals = require('@mastra/core/evals');
 
 // src/vector/index.ts
+
+// package.json
+var package_default = {
+  version: "0.14.6"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -110,35 +118,81 @@ var MongoDBVector = class extends vector.MastraVector {
   };
   constructor({ uri, dbName, options }) {
     super();
-    this.client = new mongodb.MongoClient(uri, options);
+    const client = new mongodb.MongoClient(uri, {
+      ...options,
+      driverInfo: {
+        name: "mastra-vector",
+        version: package_default.version
+      }
+    });
+    this.client = client;
     this.db = this.client.db(dbName);
     this.collections = /* @__PURE__ */ new Map();
   }
   // 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();
-  }
-  async createIndex(params) {
-    const { indexName, dimension, metric = "cosine" } = params;
-    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`);
+    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
+      );
     }
-    const collectionExists = await this.db.listCollections({ name: indexName }).hasNext();
-    if (!collectionExists) {
-      await this.db.createCollection(indexName);
+  }
+  async createIndex({ indexName, dimension, metric = "cosine" }) {
+    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: [
@@ -147,20 +201,66 @@ 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
+      );
+    }
   }
-  async waitForIndexReady(indexName, timeoutMs = 6e4, checkIntervalMs = 2e3) {
+  /**
+   * Waits for the index to be ready.
+   *
+   * @param {string} indexName - The name of the index to wait for
+   * @param {number} timeoutMs - The maximum time in milliseconds to wait for the index to be ready (default: 60000)
+   * @param {number} checkIntervalMs - The interval in milliseconds at which to check if the index is ready (default: 2000)
+   * @returns A promise that resolves when the index is ready
+   */
+  async waitForIndexReady({
+    indexName,
+    timeoutMs = 6e4,
+    checkIntervalMs = 2e3
+  }) {
     const collection = await this.getCollection(indexName, true);
     const indexNameInternal = `${indexName}_vector_index`;
     const startTime = Date.now();
@@ -175,83 +275,110 @@ var MongoDBVector = class extends vector.MastraVector {
     }
     throw new Error(`Index "${indexNameInternal}" did not become ready within timeout`);
   }
-  async upsert(params) {
-    const { indexName, vectors, metadata, ids, documents } = params;
-    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
+  async upsert({ indexName, vectors, metadata, ids, documents }) {
+    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;
         }
-      };
-    });
-    await collection.bulkWrite(operations);
-    return generatedIds;
+        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
+      );
+    }
   }
-  async query(params) {
-    const { indexName, queryVector, topK = 10, filter, includeVector = false, documentFilter } = params;
-    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}` }
+  async query({
+    indexName,
+    queryVector,
+    topK = 10,
+    filter,
+    includeVector = false,
+    documentFilter
+  }) {
+    try {
+      const collection = await this.getCollection(indexName, true);
+      const indexNameInternal = `${indexName}_vector_index`;
+      const mongoFilter = this.transformFilter(filter);
+      const documentMongoFilter = documentFilter ? { [this.documentFieldName]: documentFilter } : {};
+      const transformedMongoFilter = this.transformMetadataFilter(mongoFilter);
+      let combinedFilter = {};
+      if (Object.keys(transformedMongoFilter).length > 0 && Object.keys(documentMongoFilter).length > 0) {
+        combinedFilter = { $and: [transformedMongoFilter, documentMongoFilter] };
+      } else if (Object.keys(transformedMongoFilter).length > 0) {
+        combinedFilter = transformedMongoFilter;
+      } 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 } };
+        } else {
+          return [];
         }
       }
-    ];
-    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,
@@ -260,63 +387,162 @@ 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
+      );
+    }
   }
-  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
-    };
+  /**
+   * Retrieves statistics about a vector index.
+   *
+   * @param {string} indexName - The name of the index to describe
+   * @returns A promise that resolves to the index statistics including dimension, count and metric
+   */
+  async describeIndex({ indexName }) {
+    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) {
+  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
+      );
     }
   }
-  async updateIndexById(indexName, id, update) {
-    if (!update.vector && !update.metadata) {
-      throw new Error("No updates provided");
-    }
-    const collection = await this.getCollection(indexName, true);
-    const updateDoc = {};
-    if (update.vector) {
-      updateDoc[this.embeddingFieldName] = update.vector;
-    }
-    if (update.metadata) {
-      const normalizedMeta = Object.keys(update.metadata).reduce(
-        (acc, key) => {
-          acc[key] = update.metadata[key] instanceof Date ? update.metadata[key].toISOString() : update.metadata[key];
-          return acc;
+  /**
+   * Updates a vector by its ID with the provided vector and/or metadata.
+   * @param indexName - The name of the index containing the vector.
+   * @param id - The ID of the vector to update.
+   * @param update - An object containing the vector and/or metadata to update.
+   * @param update.vector - An optional array of numbers representing the new vector.
+   * @param update.metadata - An optional record containing the new metadata.
+   * @returns A promise that resolves when the update is complete.
+   * @throws Will throw an error if no updates are provided or if the update operation fails.
+   */
+  async updateVector({ indexName, id, update }) {
+    try {
+      if (!update.vector && !update.metadata) {
+        throw new Error("No updates provided");
+      }
+      const collection = await this.getCollection(indexName, true);
+      const updateDoc = {};
+      if (update.vector) {
+        const stats = await this.describeIndex({ indexName });
+        await this.validateVectorDimensions([update.vector], stats.dimension);
+        updateDoc[this.embeddingFieldName] = update.vector;
+      }
+      if (update.metadata) {
+        const normalizedMeta = Object.keys(update.metadata).reduce(
+          (acc, key) => {
+            acc[key] = update.metadata[key] instanceof Date ? update.metadata[key].toISOString() : update.metadata[key];
+            return acc;
+          },
+          {}
+        );
+        updateDoc[this.metadataFieldName] = normalizedMeta;
+      }
+      await collection.findOneAndUpdate({ _id: id }, { $set: updateDoc });
+    } 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
       );
-      updateDoc[this.metadataFieldName] = normalizedMeta;
     }
-    await collection.findOneAndUpdate({ _id: id }, { $set: updateDoc });
   }
-  async deleteIndexById(indexName, id) {
+  /**
+   * Deletes a vector by its ID.
+   * @param indexName - The name of the index containing the vector.
+   * @param id - The ID of the vector to delete.
+   * @returns A promise that resolves when the deletion is complete.
+   * @throws Will throw an error if the deletion operation fails.
+   */
+  async deleteVector({ indexName, id }) {
     try {
       const collection = await this.getCollection(indexName, true);
       await collection.deleteOne({ _id: id });
-    } catch (error) {
-      throw new Error(`Failed to delete index 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
@@ -356,6 +582,2142 @@ var MongoDBVector = class extends vector.MastraVector {
     if (!filter) return {};
     return translator.translate(filter);
   }
+  /**
+   * Transform metadata field filters to use MongoDB dot notation.
+   * Fields that are stored in the metadata subdocument need to be prefixed with 'metadata.'
+   * This handles filters from the Memory system which expects direct field access.
+   *
+   * @param filter - The filter object to transform
+   * @returns Transformed filter with metadata fields properly prefixed
+   */
+  transformMetadataFilter(filter) {
+    if (!filter || typeof filter !== "object") return filter;
+    const transformed = {};
+    for (const [key, value] of Object.entries(filter)) {
+      if (key.startsWith("$")) {
+        if (Array.isArray(value)) {
+          transformed[key] = value.map((item) => this.transformMetadataFilter(item));
+        } else {
+          transformed[key] = this.transformMetadataFilter(value);
+        }
+      } else if (key.startsWith("metadata.")) {
+        transformed[key] = value;
+      } else if (this.isMetadataField(key)) {
+        transformed[`metadata.${key}`] = value;
+      } else {
+        transformed[key] = value;
+      }
+    }
+    return transformed;
+  }
+  /**
+   * Determine if a field should be treated as a metadata field.
+   * Common metadata fields include thread_id, resource_id, message_id, and any field
+   * that doesn't start with underscore (MongoDB system fields).
+   */
+  isMetadataField(key) {
+    if (key.startsWith("_")) return false;
+    const documentFields = ["_id", this.embeddingFieldName, this.documentFieldName];
+    if (documentFields.includes(key)) return false;
+    return true;
+  }
+};
+var MongoDBConnector = class _MongoDBConnector {
+  #client;
+  #dbName;
+  #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."
+      );
+    }
+    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."
+      );
+    }
+    const client = new mongodb.MongoClient(config.url, {
+      ...config.options,
+      driverInfo: {
+        name: "mastra-storage",
+        version: package_default.version
+      }
+    });
+    return new _MongoDBConnector({
+      client,
+      dbName: config.dbName,
+      handler: void 0
+    });
+  }
+  static fromConnectionHandler(handler) {
+    return new _MongoDBConnector({
+      client: void 0,
+      dbName: void 0,
+      handler
+    });
+  }
+  async getConnection() {
+    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;
+    }
+    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 close() {
+    if (this.#client) {
+      await this.#client.close();
+      this.#isConnected = false;
+      return;
+    }
+    if (this.#handler) {
+      await this.#handler.close();
+    }
+  }
+};
+
+// 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
+  }) {
+    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+    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));
+  }
+  /**
+   * @deprecated use listMessages instead for paginated results.
+   */
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy
+  }) {
+    try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+      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 (resourceId) {
+        query.resourceId = resourceId;
+      }
+      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");
+      return { messages: list.get.all.db() };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_GET_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId: resourceId ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const rawMessages = await collection.find({ id: { $in: messageIds } }).sort({ createdAt: -1 }).toArray();
+      const list = new agent.MessageList().add(
+        rawMessages.map(this.parseRow),
+        "memory"
+      );
+      return { messages: list.get.all.db() };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_LIST_MESSAGES_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error$1
+      );
+    }
+  }
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    if (!threadId.trim()) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_LIST_MESSAGES_INVALID_THREAD_ID",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        new Error("threadId must be a non-empty string")
+      );
+    }
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_LIST_MESSAGES_INVALID_PAGE",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseOrderBy(orderBy);
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const query = { thread_id: threadId };
+      if (resourceId) {
+        query.resourceId = resourceId;
+      }
+      if (filter?.dateRange?.start) {
+        query.createdAt = { ...query.createdAt, $gte: filter.dateRange.start };
+      }
+      if (filter?.dateRange?.end) {
+        query.createdAt = { ...query.createdAt, $lte: filter.dateRange.end };
+      }
+      const total = await collection.countDocuments(query);
+      const messages = [];
+      if (perPage !== 0) {
+        const sortObj = { [field]: sortOrder };
+        let cursor = collection.find(query).sort(sortObj).skip(offset);
+        if (perPageInput !== false) {
+          cursor = cursor.limit(perPage);
+        }
+        const dataResult = await cursor.toArray();
+        messages.push(...dataResult.map((row) => this.parseRow(row)));
+      }
+      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(messages.map((m) => m.id));
+      if (include && include.length > 0) {
+        const selectBy = { include };
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              messages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
+      }
+      const list = new agent.MessageList().add(messages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const isDateField = field === "createdAt" || field === "updatedAt";
+        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MONGODB_STORE_LIST_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+            resourceId: resourceId ?? ""
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
+  async saveMessages({ messages }) {
+    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");
+      return { messages: list.get.all.db() };
+    } 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 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 listThreadsByResourceId(args) {
+    try {
+      const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: "STORAGE_MONGODB_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const { field, direction } = this.parseOrderBy(orderBy);
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const query = { resourceId };
+      const total = await collection.countDocuments(query);
+      if (perPage === 0) {
+        return {
+          threads: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: offset < total
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find(query).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const threads = await cursor.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: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_LIST_THREADS_BY_RESOURCE_ID_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.operations.getCollection(storage.TABLE_THREADS);
+      await collectionThreads.deleteOne({ id: threadId });
+    } 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 ObservabilityMongoDB = class extends storage.ObservabilityStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  get aiTracingStrategy() {
+    return {
+      preferred: "batch-with-updates",
+      supported: ["batch-with-updates", "insert-only"]
+    };
+  }
+  async createAISpan(span) {
+    try {
+      const startedAt = span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt;
+      const endedAt = span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt;
+      const record = {
+        ...span,
+        startedAt,
+        endedAt,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return this.operations.insert({ tableName: storage.TABLE_AI_SPANS, record });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_CREATE_AI_SPAN_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            spanId: span.spanId,
+            traceId: span.traceId,
+            spanType: span.spanType,
+            spanName: span.name
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getAITrace(traceId) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_AI_SPANS);
+      const spans = await collection.find({ traceId }).sort({ startedAt: -1 }).toArray();
+      if (!spans || spans.length === 0) {
+        return null;
+      }
+      return {
+        traceId,
+        spans: spans.map((span) => this.transformSpanFromMongo(span))
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_GET_AI_TRACE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async updateAISpan({
+    spanId,
+    traceId,
+    updates
+  }) {
+    try {
+      const data = { ...updates };
+      if (data.endedAt instanceof Date) {
+        data.endedAt = data.endedAt.toISOString();
+      }
+      if (data.startedAt instanceof Date) {
+        data.startedAt = data.startedAt.toISOString();
+      }
+      const updateData = {
+        ...data,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.operations.update({
+        tableName: storage.TABLE_AI_SPANS,
+        keys: { spanId, traceId },
+        data: updateData
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_UPDATE_AI_SPAN_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            spanId,
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getAITracesPaginated({
+    filters,
+    pagination
+  }) {
+    const page = pagination?.page ?? 0;
+    const perPage = pagination?.perPage ?? 10;
+    const { entityId, entityType, ...actualFilters } = filters || {};
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_AI_SPANS);
+      const mongoFilter = {
+        parentSpanId: null,
+        // Only get root spans for traces
+        ...actualFilters
+      };
+      if (pagination?.dateRange) {
+        const dateFilter = {};
+        if (pagination.dateRange.start) {
+          dateFilter.$gte = pagination.dateRange.start instanceof Date ? pagination.dateRange.start.toISOString() : pagination.dateRange.start;
+        }
+        if (pagination.dateRange.end) {
+          dateFilter.$lte = pagination.dateRange.end instanceof Date ? pagination.dateRange.end.toISOString() : pagination.dateRange.end;
+        }
+        if (Object.keys(dateFilter).length > 0) {
+          mongoFilter.startedAt = dateFilter;
+        }
+      }
+      if (entityId && entityType) {
+        let name = "";
+        if (entityType === "workflow") {
+          name = `workflow run: '${entityId}'`;
+        } else if (entityType === "agent") {
+          name = `agent run: '${entityId}'`;
+        } else {
+          const error$1 = new error.MastraError({
+            id: "MONGODB_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: {
+              entityType
+            },
+            text: `Cannot filter by entity type: ${entityType}`
+          });
+          throw error$1;
+        }
+        mongoFilter.name = name;
+      }
+      const count = await collection.countDocuments(mongoFilter);
+      if (count === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage,
+            hasMore: false
+          },
+          spans: []
+        };
+      }
+      const spans = await collection.find(mongoFilter).sort({ startedAt: -1 }).skip(page * perPage).limit(perPage).toArray();
+      return {
+        pagination: {
+          total: count,
+          page,
+          perPage,
+          hasMore: spans.length === perPage
+        },
+        spans: spans.map((span) => this.transformSpanFromMongo(span))
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  async batchCreateAISpans(args) {
+    try {
+      const records = args.records.map((record) => {
+        const startedAt = record.startedAt instanceof Date ? record.startedAt.toISOString() : record.startedAt;
+        const endedAt = record.endedAt instanceof Date ? record.endedAt.toISOString() : record.endedAt;
+        return {
+          ...record,
+          startedAt,
+          endedAt,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      });
+      return this.operations.batchInsert({
+        tableName: storage.TABLE_AI_SPANS,
+        records
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_BATCH_CREATE_AI_SPANS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  async batchUpdateAISpans(args) {
+    try {
+      return this.operations.batchUpdate({
+        tableName: storage.TABLE_AI_SPANS,
+        updates: args.records.map((record) => {
+          const data = { ...record.updates };
+          if (data.endedAt instanceof Date) {
+            data.endedAt = data.endedAt.toISOString();
+          }
+          if (data.startedAt instanceof Date) {
+            data.startedAt = data.startedAt.toISOString();
+          }
+          const updateData = {
+            ...data,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          return {
+            keys: { spanId: record.spanId, traceId: record.traceId },
+            data: updateData
+          };
+        })
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_BATCH_UPDATE_AI_SPANS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  async batchDeleteAITraces(args) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_AI_SPANS);
+      await collection.deleteMany({
+        traceId: { $in: args.traceIds }
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_BATCH_DELETE_AI_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Transform MongoDB document to AISpanRecord format
+   */
+  transformSpanFromMongo(doc) {
+    const { _id, ...span } = doc;
+    if (span.startedAt && typeof span.startedAt === "string") {
+      span.startedAt = span.startedAt;
+    }
+    if (span.endedAt && typeof span.endedAt === "string") {
+      span.endedAt = span.endedAt;
+    }
+    if (span.createdAt && typeof span.createdAt === "string") {
+      span.createdAt = new Date(span.createdAt);
+    }
+    if (span.updatedAt && typeof span.updatedAt === "string") {
+      span.updatedAt = new Date(span.updatedAt);
+    }
+    return span;
+  }
+};
+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) {
+      const mastraError = 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(mastraError.message);
+      this.logger?.trackException(mastraError);
+      throw mastraError;
+    }
+  }
+  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];
+    if (!schema) {
+      return record;
+    }
+    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) {
+      const mastraError = 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(mastraError.message);
+      this.logger?.trackException(mastraError);
+      throw mastraError;
+    }
+  }
+  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
+      );
+    }
+  }
+  async update({
+    tableName,
+    keys,
+    data
+  }) {
+    try {
+      const collection = await this.getCollection(tableName);
+      const processedData = this.processJsonbFields(tableName, data);
+      const cleanData = Object.fromEntries(Object.entries(processedData).filter(([_, value]) => value !== void 0));
+      await collection.updateOne(keys, { $set: cleanData });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_UPDATE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async batchUpdate({
+    tableName,
+    updates
+  }) {
+    if (!updates.length) {
+      return;
+    }
+    try {
+      const collection = await this.getCollection(tableName);
+      const bulkOps = updates.map(({ keys, data }) => {
+        const processedData = this.processJsonbFields(tableName, data);
+        const cleanData = Object.fromEntries(Object.entries(processedData).filter(([_, value]) => value !== void 0));
+        return {
+          updateOne: {
+            filter: keys,
+            update: { $set: cleanData }
+          }
+        };
+      });
+      await collection.bulkWrite(bulkOps);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_BATCH_UPDATE_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 preprocessStepResultValue = null;
+  if (row.preprocessStepResult) {
+    try {
+      preprocessStepResultValue = typeof row.preprocessStepResult === "string" ? storage.safelyParseJSON(row.preprocessStepResult) : row.preprocessStepResult;
+    } catch (e) {
+      console.warn("Failed to parse preprocessStepResult:", 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 requestContextValue = null;
+  if (row.requestContext) {
+    try {
+      requestContextValue = typeof row.requestContext === "string" ? storage.safelyParseJSON(row.requestContext) : row.requestContext;
+    } catch (e) {
+      console.warn("Failed to parse requestContext:", e);
+    }
+  }
+  let metadataValue = null;
+  if (row.metadata) {
+    try {
+      metadataValue = typeof row.metadata === "string" ? storage.safelyParseJSON(row.metadata) : row.metadata;
+    } catch (e) {
+      console.warn("Failed to parse metadata:", e);
+    }
+  }
+  return {
+    id: row.id,
+    entityId: row.entityId,
+    entityType: row.entityType,
+    scorerId: row.scorerId,
+    traceId: row.traceId,
+    spanId: row.spanId,
+    runId: row.runId,
+    scorer: scorerValue,
+    preprocessStepResult: preprocessStepResultValue,
+    preprocessPrompt: row.preprocessPrompt,
+    analyzeStepResult: analyzeStepResultValue,
+    generateScorePrompt: row.generateScorePrompt,
+    score: row.score,
+    analyzePrompt: row.analyzePrompt,
+    reasonPrompt: row.reasonPrompt,
+    metadata: metadataValue,
+    input: inputValue,
+    output: outputValue,
+    additionalContext: row.additionalContext,
+    requestContext: requestContextValue,
+    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) {
+    let validatedScore;
+    try {
+      validatedScore = evals.saveScorePayloadSchema.parse(score);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_SAVE_SCORE_VALIDATION_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const scoreId = `score-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const scoreData = {
+        id: scoreId,
+        entityId: validatedScore.entityId,
+        entityType: validatedScore.entityType,
+        scorerId: validatedScore.scorerId,
+        traceId: validatedScore.traceId || "",
+        spanId: validatedScore.spanId || "",
+        runId: validatedScore.runId,
+        scorer: typeof validatedScore.scorer === "string" ? storage.safelyParseJSON(validatedScore.scorer) : validatedScore.scorer,
+        preprocessStepResult: typeof validatedScore.preprocessStepResult === "string" ? storage.safelyParseJSON(validatedScore.preprocessStepResult) : validatedScore.preprocessStepResult,
+        analyzeStepResult: typeof validatedScore.analyzeStepResult === "string" ? storage.safelyParseJSON(validatedScore.analyzeStepResult) : validatedScore.analyzeStepResult,
+        score: validatedScore.score,
+        reason: validatedScore.reason,
+        preprocessPrompt: validatedScore.preprocessPrompt,
+        generateScorePrompt: validatedScore.generateScorePrompt,
+        generateReasonPrompt: validatedScore.generateReasonPrompt,
+        analyzePrompt: validatedScore.analyzePrompt,
+        input: typeof validatedScore.input === "string" ? storage.safelyParseJSON(validatedScore.input) : validatedScore.input,
+        output: typeof validatedScore.output === "string" ? storage.safelyParseJSON(validatedScore.output) : validatedScore.output,
+        additionalContext: validatedScore.additionalContext,
+        requestContext: typeof validatedScore.requestContext === "string" ? storage.safelyParseJSON(validatedScore.requestContext) : validatedScore.requestContext,
+        entity: typeof validatedScore.entity === "string" ? storage.safelyParseJSON(validatedScore.entity) : validatedScore.entity,
+        source: validatedScore.source,
+        resourceId: validatedScore.resourceId || "",
+        threadId: validatedScore.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 listScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType,
+    source
+  }) {
+    try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const query = { scorerId };
+      if (entityId) {
+        query.entityId = entityId;
+      }
+      if (entityType) {
+        query.entityType = entityType;
+      }
+      if (source) {
+        query.source = source;
+      }
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments(query);
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageInput,
+            hasMore: false
+          }
+        };
+      }
+      const end = perPageInput === false ? total : start + perPage;
+      let cursor = collection.find(query).sort({ createdAt: "desc" }).skip(start);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const documents = await cursor.toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      return {
+        scores,
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } 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 listScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments({ runId });
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageInput,
+            hasMore: false
+          }
+        };
+      }
+      const end = perPageInput === false ? total : start + perPage;
+      let cursor = collection.find({ runId }).sort({ createdAt: "desc" }).skip(start);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const documents = await cursor.toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      return {
+        scores,
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } 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 listScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments({ entityId, entityType });
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageInput,
+            hasMore: false
+          }
+        };
+      }
+      const end = perPageInput === false ? total : start + perPage;
+      let cursor = collection.find({ entityId, entityType }).sort({ createdAt: "desc" }).skip(start);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const documents = await cursor.toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      return {
+        scores,
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } 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
+      );
+    }
+  }
+  async listScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const query = { traceId, spanId };
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments(query);
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageInput,
+            hasMore: false
+          }
+        };
+      }
+      const end = perPageInput === false ? total : start + perPage;
+      let cursor = collection.find(query).sort({ createdAt: "desc" }).skip(start);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const documents = await cursor.toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      return {
+        scores,
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_SPAN_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { traceId, spanId, page: pagination.page, perPage: pagination.perPage }
+        },
+        error$1
+      );
+    }
+  }
+};
+var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // requestContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot
+  }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      await collection.updateOne(
+        { workflow_name: workflowName, run_id: runId },
+        {
+          $set: {
+            workflow_name: workflowName,
+            run_id: runId,
+            resourceId,
+            snapshot,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { upsert: true }
+      );
+    } 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({
+    workflowName,
+    runId
+  }) {
+    try {
+      const result = await this.operations.load({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          workflow_name: workflowName,
+          run_id: runId
+        }
+      });
+      if (!result?.length) {
+        return null;
+      }
+      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 listWorkflowRuns(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);
+      let total = 0;
+      let cursor = collection.find(query).sort({ createdAt: -1 });
+      if (options.page !== void 0 && typeof options.perPage === "number") {
+        if (options.page < 0) {
+          throw new error.MastraError(
+            {
+              id: "STORAGE_MONGODB_INVALID_PAGE",
+              domain: error.ErrorDomain.STORAGE,
+              category: error.ErrorCategory.USER,
+              details: { page: options.page }
+            },
+            new Error("page must be >= 0")
+          );
+        }
+        total = await collection.countDocuments(query);
+        const normalizedPerPage = storage.normalizePerPage(options.perPage, Number.MAX_SAFE_INTEGER);
+        if (normalizedPerPage === 0) {
+          return { runs: [], total };
+        }
+        const offset = options.page * normalizedPerPage;
+        cursor = cursor.skip(offset);
+        cursor = cursor.limit(Math.min(normalizedPerPage, 2147483647));
+      }
+      const results = await cursor.toArray();
+      const runs = results.map((row) => this.parseWorkflowRun(row));
+      return {
+        runs,
+        total: total || runs.length
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_LIST_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 (args.runId) {
+        query["run_id"] = args.runId;
+      }
+      if (args.workflowName) {
+        query["workflow_name"] = args.workflowName;
+      }
+      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$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 = typeof row.snapshot === "string" ? storage.safelyParseJSON(row.snapshot) : 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),
+      resourceId: row.resourceId
+    };
+  }
+};
+
+// 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 {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: false,
+      createTable: false,
+      deleteMessages: false,
+      listScoresBySpan: true
+    };
+  }
+  constructor(config) {
+    super({ name: "MongoDBStore" });
+    this.stores = {};
+    this.#connector = loadConnector(config);
+    const operations = new StoreOperationsMongoDB({
+      connector: this.#connector
+    });
+    const memory = new MemoryStorageMongoDB({
+      operations
+    });
+    const scores = new ScoresStorageMongoDB({
+      operations
+    });
+    const workflows = new WorkflowsStorageMongoDB({
+      operations
+    });
+    const observability = new ObservabilityMongoDB({
+      operations
+    });
+    this.stores = {
+      operations,
+      memory,
+      scores,
+      workflows,
+      observability
+    };
+  }
+  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 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(args) {
+    return this.stores.memory.getMessages(args);
+  }
+  async listMessagesById({ messageIds }) {
+    return this.stores.memory.listMessagesById({ messageIds });
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async updateMessages(_args) {
+    return this.stores.memory.updateMessages(_args);
+  }
+  async listWorkflowRuns(args) {
+    return this.stores.workflows.listWorkflowRuns(args);
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
+  }) {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
+  async 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
+      );
+    }
+  }
+  /**
+   * SCORERS
+   */
+  async getScoreById({ id }) {
+    return this.stores.scores.getScoreById({ id });
+  }
+  async saveScore(score) {
+    return this.stores.scores.saveScore(score);
+  }
+  async listScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.listScoresByRunId({ runId, pagination });
+  }
+  async listScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.listScoresByEntityId({ entityId, entityType, pagination });
+  }
+  async listScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType,
+    source
+  }) {
+    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
+  }
+  async listScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * AI Tracing/Observability
+   */
+  async createAISpan(span) {
+    if (!this.stores.observability) {
+      throw new error.MastraError({
+        id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.SYSTEM,
+        text: "Observability storage is not initialized"
+      });
+    }
+    return this.stores.observability.createAISpan(span);
+  }
+  async updateAISpan({
+    spanId,
+    traceId,
+    updates
+  }) {
+    if (!this.stores.observability) {
+      throw new error.MastraError({
+        id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.SYSTEM,
+        text: "Observability storage is not initialized"
+      });
+    }
+    return this.stores.observability.updateAISpan({ spanId, traceId, updates });
+  }
+  async getAITrace(traceId) {
+    if (!this.stores.observability) {
+      throw new error.MastraError({
+        id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.SYSTEM,
+        text: "Observability storage is not initialized"
+      });
+    }
+    return this.stores.observability.getAITrace(traceId);
+  }
+  async getAITracesPaginated(args) {
+    if (!this.stores.observability) {
+      throw new error.MastraError({
+        id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.SYSTEM,
+        text: "Observability storage is not initialized"
+      });
+    }
+    return this.stores.observability.getAITracesPaginated(args);
+  }
+  async batchCreateAISpans(args) {
+    if (!this.stores.observability) {
+      throw new error.MastraError({
+        id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.SYSTEM,
+        text: "Observability storage is not initialized"
+      });
+    }
+    return this.stores.observability.batchCreateAISpans(args);
+  }
+  async batchUpdateAISpans(args) {
+    if (!this.stores.observability) {
+      throw new error.MastraError({
+        id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.SYSTEM,
+        text: "Observability storage is not initialized"
+      });
+    }
+    return this.stores.observability.batchUpdateAISpans(args);
+  }
+  async batchDeleteAITraces(args) {
+    if (!this.stores.observability) {
+      throw new error.MastraError({
+        id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.SYSTEM,
+        text: "Observability storage is not initialized"
+      });
+    }
+    return this.stores.observability.batchDeleteAITraces(args);
+  }
 };
 
 // src/vector/prompt.ts
@@ -454,4 +2816,7 @@ Example Complex Query:
 }`;
 
 exports.MONGODB_PROMPT = MONGODB_PROMPT;
+exports.MongoDBStore = MongoDBStore;
 exports.MongoDBVector = MongoDBVector;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map