@mastra/mongodb 1.3.0 → 1.3.1-alpha.0

package/dist/index.cjs

@@ -14,7 +14,7 @@ var evals = require('@mastra/core/evals');
 
 // package.json
 var package_default = {
-  version: "1.3.0"};
+  version: "1.3.1-alpha.0"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -908,7 +908,9 @@ var SNAPSHOT_FIELDS = [
   "inputProcessors",
   "outputProcessors",
   "memory",
-  "scorers"
+  "scorers",
+  "mcpClients",
+  "requestContextSchema"
 ];
 var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsStorage {
   #connector;
@@ -1518,6 +1520,584 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
     return result;
   }
 };
+var SNAPSHOT_FIELDS2 = ["name", "description", "servers"];
+var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.MCPClientsStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_COLLECTIONS = [storage.TABLE_MCP_CLIENTS, storage.TABLE_MCP_CLIENT_VERSIONS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MongoDBMCPClientsStorage.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_MCP_CLIENTS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_MCP_CLIENTS, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_MCP_CLIENTS, keys: { updatedAt: -1 } },
+      { collection: storage.TABLE_MCP_CLIENTS, keys: { authorId: 1 } },
+      { collection: storage.TABLE_MCP_CLIENT_VERSIONS, keys: { id: 1 }, options: { unique: true } },
+      {
+        collection: storage.TABLE_MCP_CLIENT_VERSIONS,
+        keys: { mcpClientId: 1, versionNumber: -1 },
+        options: { unique: true }
+      },
+      { collection: storage.TABLE_MCP_CLIENT_VERSIONS, keys: { mcpClientId: 1, createdAt: -1 } }
+    ];
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        const collection = await this.getCollection(indexDef.collection);
+        await collection.createIndex(indexDef.keys, indexDef.options);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index on ${indexDef.collection}:`, error);
+      }
+    }
+  }
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        const collection = await this.getCollection(indexDef.collection);
+        await collection.createIndex(indexDef.keys, indexDef.options);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index on ${indexDef.collection}:`, error);
+      }
+    }
+  }
+  async init() {
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  async dangerouslyClearAll() {
+    const versionsCollection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+    await versionsCollection.deleteMany({});
+    const mcpClientsCollection = await this.getCollection(storage.TABLE_MCP_CLIENTS);
+    await mcpClientsCollection.deleteMany({});
+  }
+  // ==========================================================================
+  // MCP Client CRUD
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENTS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformMCPClient(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_MCP_CLIENT_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async create(input) {
+    const { mcpClient } = input;
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENTS);
+      const existing = await collection.findOne({ id: mcpClient.id });
+      if (existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "CREATE_MCP_CLIENT", "ALREADY_EXISTS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id: mcpClient.id },
+          text: `MCP client with id ${mcpClient.id} already exists`
+        });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const newMCPClient = {
+        id: mcpClient.id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: mcpClient.authorId,
+        metadata: mcpClient.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection.insertOne(this.serializeMCPClient(newMCPClient));
+      const snapshotConfig = {};
+      for (const field of SNAPSHOT_FIELDS2) {
+        if (mcpClient[field] !== void 0) {
+          snapshotConfig[field] = mcpClient[field];
+        }
+      }
+      const versionId = crypto.randomUUID();
+      try {
+        await this.createVersion({
+          id: versionId,
+          mcpClientId: mcpClient.id,
+          versionNumber: 1,
+          ...snapshotConfig,
+          changedFields: Object.keys(snapshotConfig),
+          changeMessage: "Initial version"
+        });
+      } catch (versionError) {
+        await collection.deleteOne({ id: mcpClient.id });
+        throw versionError;
+      }
+      return newMCPClient;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: mcpClient.id }
+        },
+        error$1
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENTS);
+      const existingMCPClient = await collection.findOne({ id });
+      if (!existingMCPClient) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_MCP_CLIENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id },
+          text: `MCP client with id ${id} not found`
+        });
+      }
+      const updateDoc = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const metadataFields = {
+        authorId: updates.authorId,
+        activeVersionId: updates.activeVersionId,
+        metadata: updates.metadata,
+        status: updates.status
+      };
+      const configFields = {};
+      for (const field of SNAPSHOT_FIELDS2) {
+        if (updates[field] !== void 0) {
+          configFields[field] = updates[field];
+        }
+      }
+      if (Object.keys(configFields).length > 0) {
+        const latestVersion = await this.getLatestVersion(id);
+        if (!latestVersion) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "UPDATE_MCP_CLIENT", "NO_VERSION"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            text: `Cannot update config fields for MCP client ${id} - no versions exist`,
+            details: { id }
+          });
+        }
+        const existingSnapshot = this.extractSnapshotFields(latestVersion);
+        await this.createVersion({
+          id: crypto.randomUUID(),
+          mcpClientId: id,
+          versionNumber: latestVersion.versionNumber + 1,
+          ...existingSnapshot,
+          ...configFields,
+          changedFields: Object.keys(configFields),
+          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
+        });
+      }
+      if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
+      if (metadataFields.activeVersionId !== void 0) {
+        updateDoc.activeVersionId = metadataFields.activeVersionId;
+        if (metadataFields.status === void 0) {
+          updateDoc.status = "published";
+        }
+      }
+      if (metadataFields.status !== void 0) {
+        updateDoc.status = metadataFields.status;
+      }
+      if (metadataFields.metadata !== void 0) {
+        const existingMetadata = existingMCPClient.metadata || {};
+        updateDoc.metadata = { ...existingMetadata, ...metadataFields.metadata };
+      }
+      await collection.updateOne({ id }, { $set: updateDoc });
+      const updatedMCPClient = await collection.findOne({ id });
+      if (!updatedMCPClient) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_MCP_CLIENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `MCP client with id ${id} was deleted during update`,
+          details: { id }
+        });
+      }
+      return this.transformMCPClient(updatedMCPClient);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      await this.deleteVersionsByParentId(id);
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENTS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async list(args) {
+    try {
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+      const { field, direction } = this.parseOrderBy(orderBy);
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("MONGODB", "LIST_MCP_CLIENTS", "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 collection = await this.getCollection(storage.TABLE_MCP_CLIENTS);
+      const filter = {};
+      if (authorId) {
+        filter.authorId = authorId;
+      }
+      if (metadata) {
+        for (const [key, value] of Object.entries(metadata)) {
+          filter[`metadata.${key}`] = value;
+        }
+      }
+      const total = await collection.countDocuments(filter);
+      if (total === 0 || perPage === 0) {
+        return {
+          mcpClients: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find(filter).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const results = await cursor.toArray();
+      const mcpClients = results.map((doc) => this.transformMCPClient(doc));
+      return {
+        mcpClients,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput !== false && offset + perPage < total
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_MCP_CLIENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // MCP Client Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+      const now = /* @__PURE__ */ new Date();
+      const versionDoc = {
+        id: input.id,
+        mcpClientId: input.mcpClientId,
+        versionNumber: input.versionNumber,
+        changedFields: input.changedFields ?? void 0,
+        changeMessage: input.changeMessage ?? void 0,
+        createdAt: now
+      };
+      for (const field of SNAPSHOT_FIELDS2) {
+        if (input[field] !== void 0) {
+          versionDoc[field] = input[field];
+        }
+      }
+      await collection.insertOne(versionDoc);
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_MCP_CLIENT_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, mcpClientId: input.mcpClientId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_MCP_CLIENT_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(mcpClientId, versionNumber) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+      const result = await collection.findOne({ mcpClientId, versionNumber });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_MCP_CLIENT_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(mcpClientId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+      const result = await collection.find({ mcpClientId }).sort({ versionNumber: -1 }).limit(1).toArray();
+      if (!result || result.length === 0) {
+        return null;
+      }
+      return this.transformVersion(result[0]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_LATEST_MCP_CLIENT_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { mcpClientId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_MCP_CLIENT_VERSIONS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 20);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseVersionOrderBy(orderBy);
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+      const total = await collection.countDocuments({ mcpClientId });
+      if (total === 0 || perPage === 0) {
+        return {
+          versions: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find({ mcpClientId }).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const results = await cursor.toArray();
+      const versions = results.map((doc) => this.transformVersion(doc));
+      return {
+        versions,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput !== false && offset + perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_MCP_CLIENT_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_MCP_CLIENT_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByParentId(mcpClientId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+      await collection.deleteMany({ mcpClientId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_VERSIONS_BY_MCP_CLIENT_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(mcpClientId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+      return await collection.countDocuments({ mcpClientId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "COUNT_MCP_CLIENT_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  transformMCPClient(doc) {
+    const { _id, ...rest } = doc;
+    return {
+      id: rest.id,
+      status: rest.status,
+      activeVersionId: rest.activeVersionId,
+      authorId: rest.authorId,
+      metadata: rest.metadata,
+      createdAt: rest.createdAt instanceof Date ? rest.createdAt : new Date(rest.createdAt),
+      updatedAt: rest.updatedAt instanceof Date ? rest.updatedAt : new Date(rest.updatedAt)
+    };
+  }
+  serializeMCPClient(mcpClient) {
+    return {
+      id: mcpClient.id,
+      status: mcpClient.status,
+      activeVersionId: mcpClient.activeVersionId,
+      authorId: mcpClient.authorId,
+      metadata: mcpClient.metadata,
+      createdAt: mcpClient.createdAt,
+      updatedAt: mcpClient.updatedAt
+    };
+  }
+  transformVersion(doc) {
+    const { _id, ...version } = doc;
+    const result = {
+      id: version.id,
+      mcpClientId: version.mcpClientId,
+      versionNumber: version.versionNumber,
+      changedFields: version.changedFields,
+      changeMessage: version.changeMessage,
+      createdAt: version.createdAt instanceof Date ? version.createdAt : new Date(version.createdAt)
+    };
+    for (const field of SNAPSHOT_FIELDS2) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
+  }
+  extractSnapshotFields(version) {
+    const result = {};
+    for (const field of SNAPSHOT_FIELDS2) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
+  }
+};
 function formatDateForMongoDB(date) {
   return typeof date === "string" ? new Date(date) : date;
 }
@@ -3859,7 +4439,7 @@ Note: This migration may take some time for large collections.
     return span;
   }
 };
-var SNAPSHOT_FIELDS2 = ["name", "description", "content", "rules"];
+var SNAPSHOT_FIELDS3 = ["name", "description", "content", "rules"];
 var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends storage.PromptBlocksStorage {
   #connector;
   #skipDefaultIndexes;
@@ -3976,7 +4556,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
       };
       await collection.insertOne(this.serializeBlock(newBlock));
       const snapshotConfig = {};
-      for (const field of SNAPSHOT_FIELDS2) {
+      for (const field of SNAPSHOT_FIELDS3) {
         if (promptBlock[field] !== void 0) {
           snapshotConfig[field] = promptBlock[field];
         }
@@ -4030,7 +4610,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
         status: updates.status
       };
       const configFields = {};
-      for (const field of SNAPSHOT_FIELDS2) {
+      for (const field of SNAPSHOT_FIELDS3) {
         if (updates[field] !== void 0) {
           configFields[field] = updates[field];
         }
@@ -4195,7 +4775,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
         changeMessage: input.changeMessage ?? void 0,
         createdAt: now
       };
-      for (const field of SNAPSHOT_FIELDS2) {
+      for (const field of SNAPSHOT_FIELDS3) {
         if (input[field] !== void 0) {
           versionDoc[field] = input[field];
         }
@@ -4415,7 +4995,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
       changeMessage: version.changeMessage,
       createdAt: version.createdAt instanceof Date ? version.createdAt : new Date(version.createdAt)
     };
-    for (const field of SNAPSHOT_FIELDS2) {
+    for (const field of SNAPSHOT_FIELDS3) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -4424,7 +5004,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
   }
   extractSnapshotFields(version) {
     const result = {};
-    for (const field of SNAPSHOT_FIELDS2) {
+    for (const field of SNAPSHOT_FIELDS3) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -4432,7 +5012,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
     return result;
   }
 };
-var SNAPSHOT_FIELDS3 = [
+var SNAPSHOT_FIELDS4 = [
   "name",
   "description",
   "type",
@@ -4558,7 +5138,7 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
       };
       await collection.insertOne(this.serializeScorerDefinition(newScorerDefinition));
       const snapshotConfig = {};
-      for (const field of SNAPSHOT_FIELDS3) {
+      for (const field of SNAPSHOT_FIELDS4) {
         if (scorerDefinition[field] !== void 0) {
           snapshotConfig[field] = scorerDefinition[field];
         }
@@ -4612,7 +5192,7 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
         status: updates.status
       };
       const configFields = {};
-      for (const field of SNAPSHOT_FIELDS3) {
+      for (const field of SNAPSHOT_FIELDS4) {
         if (updates[field] !== void 0) {
           configFields[field] = updates[field];
         }
@@ -4777,7 +5357,7 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
         changeMessage: input.changeMessage ?? void 0,
         createdAt: now
       };
-      for (const field of SNAPSHOT_FIELDS3) {
+      for (const field of SNAPSHOT_FIELDS4) {
         if (input[field] !== void 0) {
           versionDoc[field] = input[field];
         }
@@ -4997,7 +5577,7 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
       changeMessage: version.changeMessage,
       createdAt: version.createdAt instanceof Date ? version.createdAt : new Date(version.createdAt)
     };
-    for (const field of SNAPSHOT_FIELDS3) {
+    for (const field of SNAPSHOT_FIELDS4) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -5006,7 +5586,7 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
   }
   extractSnapshotFields(version) {
     const result = {};
-    for (const field of SNAPSHOT_FIELDS3) {
+    for (const field of SNAPSHOT_FIELDS4) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -5680,6 +6260,7 @@ var MongoDBStore = class extends storage.MastraCompositeStore {
     const agents = new MongoDBAgentsStorage(domainConfig);
     const promptBlocks = new MongoDBPromptBlocksStorage(domainConfig);
     const scorerDefinitions = new MongoDBScorerDefinitionsStorage(domainConfig);
+    const mcpClients = new MongoDBMCPClientsStorage(domainConfig);
     this.stores = {
       memory,
       scores,
@@ -5687,7 +6268,8 @@ var MongoDBStore = class extends storage.MastraCompositeStore {
       observability,
       agents,
       promptBlocks,
-      scorerDefinitions
+      scorerDefinitions,
+      mcpClients
     };
   }
   /**
@@ -5809,6 +6391,7 @@ Example Complex Query:
 exports.MONGODB_PROMPT = MONGODB_PROMPT;
 exports.MemoryStorageMongoDB = MemoryStorageMongoDB;
 exports.MongoDBAgentsStorage = MongoDBAgentsStorage;
+exports.MongoDBMCPClientsStorage = MongoDBMCPClientsStorage;
 exports.MongoDBPromptBlocksStorage = MongoDBPromptBlocksStorage;
 exports.MongoDBScorerDefinitionsStorage = MongoDBScorerDefinitionsStorage;
 exports.MongoDBStore = MongoDBStore;