@mastra/mongodb 1.4.0 → 1.5.0-alpha.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { createVectorErrorId, AgentsStorage, TABLE_AGENTS, TABLE_AGENT_VERSIONS, createStorageErrorId, normalizePerPage, calculatePagination, BlobStore, TABLE_SKILL_BLOBS, MCPClientsStorage, TABLE_MCP_CLIENTS, TABLE_MCP_CLIENT_VERSIONS, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, safelyParseJSON, ObservabilityStorage, TABLE_SPANS, listTracesArgsSchema, toTraceSpans, PromptBlocksStorage, TABLE_PROMPT_BLOCKS, TABLE_PROMPT_BLOCK_VERSIONS, ScorerDefinitionsStorage, TABLE_SCORER_DEFINITIONS, TABLE_SCORER_DEFINITION_VERSIONS, ScoresStorage, TABLE_SCORERS, SkillsStorage, TABLE_SKILLS, TABLE_SKILL_VERSIONS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, WorkspacesStorage, TABLE_WORKSPACES, TABLE_WORKSPACE_VERSIONS, MastraCompositeStore, TraceStatus, transformScoreRow as transformScoreRow$1 } from '@mastra/core/storage';
+import { createVectorErrorId, AgentsStorage, TABLE_AGENTS, TABLE_AGENT_VERSIONS, createStorageErrorId, normalizePerPage, calculatePagination, BlobStore, TABLE_SKILL_BLOBS, MCPClientsStorage, TABLE_MCP_CLIENTS, TABLE_MCP_CLIENT_VERSIONS, MCPServersStorage, TABLE_MCP_SERVERS, TABLE_MCP_SERVER_VERSIONS, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, safelyParseJSON, ObservabilityStorage, TABLE_SPANS, listTracesArgsSchema, toTraceSpans, PromptBlocksStorage, TABLE_PROMPT_BLOCKS, TABLE_PROMPT_BLOCK_VERSIONS, ScorerDefinitionsStorage, TABLE_SCORER_DEFINITIONS, TABLE_SCORER_DEFINITION_VERSIONS, ScoresStorage, TABLE_SCORERS, SkillsStorage, TABLE_SKILLS, TABLE_SKILL_VERSIONS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, WorkspacesStorage, TABLE_WORKSPACES, TABLE_WORKSPACE_VERSIONS, MastraCompositeStore, TraceStatus, transformScoreRow as transformScoreRow$1 } from '@mastra/core/storage';
 import { MastraVector, validateUpsertInput, validateVectorValues } from '@mastra/core/vector';
 import { MongoClient } from 'mongodb';
 import { v4 } from 'uuid';
@@ -12,7 +12,7 @@ import { saveScorePayloadSchema } from '@mastra/core/evals';
 
 // package.json
 var package_default = {
-  version: "1.4.0"};
+  version: "1.5.0-alpha.0"};
 var MongoDBFilterTranslator = class extends BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -2228,6 +2228,559 @@ var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends MCPClient
     return result;
   }
 };
+var SNAPSHOT_FIELDS3 = [
+  "name",
+  "version",
+  "description",
+  "instructions",
+  "repository",
+  "releaseDate",
+  "isLatest",
+  "packageCanonical",
+  "tools",
+  "agents",
+  "workflows"
+];
+var MongoDBMCPServersStorage = class _MongoDBMCPServersStorage extends MCPServersStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_COLLECTIONS = [TABLE_MCP_SERVERS, TABLE_MCP_SERVER_VERSIONS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MongoDBMCPServersStorage.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: TABLE_MCP_SERVERS, keys: { id: 1 }, options: { unique: true } },
+      { collection: TABLE_MCP_SERVERS, keys: { createdAt: -1 } },
+      { collection: TABLE_MCP_SERVERS, keys: { updatedAt: -1 } },
+      { collection: TABLE_MCP_SERVERS, keys: { authorId: 1 } },
+      { collection: TABLE_MCP_SERVER_VERSIONS, keys: { id: 1 }, options: { unique: true } },
+      {
+        collection: TABLE_MCP_SERVER_VERSIONS,
+        keys: { mcpServerId: 1, versionNumber: -1 },
+        options: { unique: true }
+      },
+      { collection: TABLE_MCP_SERVER_VERSIONS, keys: { mcpServerId: 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(TABLE_MCP_SERVER_VERSIONS);
+    await versionsCollection.deleteMany({});
+    const mcpServersCollection = await this.getCollection(TABLE_MCP_SERVERS);
+    await mcpServersCollection.deleteMany({});
+  }
+  // ==========================================================================
+  // MCP Server CRUD
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVERS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformMCPServer(result);
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "GET_MCP_SERVER_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error
+      );
+    }
+  }
+  async create(input) {
+    const { mcpServer } = input;
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVERS);
+      const existing = await collection.findOne({ id: mcpServer.id });
+      if (existing) {
+        throw new MastraError({
+          id: createStorageErrorId("MONGODB", "CREATE_MCP_SERVER", "ALREADY_EXISTS"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { id: mcpServer.id },
+          text: `MCP server with id ${mcpServer.id} already exists`
+        });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const newMCPServer = {
+        id: mcpServer.id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: mcpServer.authorId,
+        metadata: mcpServer.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection.insertOne(this.serializeMCPServer(newMCPServer));
+      const snapshotConfig = {};
+      for (const field of SNAPSHOT_FIELDS3) {
+        if (mcpServer[field] !== void 0) {
+          snapshotConfig[field] = mcpServer[field];
+        }
+      }
+      const versionId = randomUUID();
+      try {
+        await this.createVersion({
+          id: versionId,
+          mcpServerId: mcpServer.id,
+          versionNumber: 1,
+          ...snapshotConfig,
+          changedFields: Object.keys(snapshotConfig),
+          changeMessage: "Initial version"
+        });
+      } catch (versionError) {
+        await collection.deleteOne({ id: mcpServer.id });
+        throw versionError;
+      }
+      return newMCPServer;
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "CREATE_MCP_SERVER", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: mcpServer.id }
+        },
+        error
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVERS);
+      const existingMCPServer = await collection.findOne({ id });
+      if (!existingMCPServer) {
+        throw new MastraError({
+          id: createStorageErrorId("MONGODB", "UPDATE_MCP_SERVER", "NOT_FOUND"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { id },
+          text: `MCP server 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
+      };
+      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 = metadataFields.status;
+      }
+      if (metadataFields.metadata !== void 0) {
+        const existingMetadata = existingMCPServer.metadata || {};
+        updateDoc.metadata = { ...existingMetadata, ...metadataFields.metadata };
+      }
+      await collection.updateOne({ id }, { $set: updateDoc });
+      const updatedMCPServer = await collection.findOne({ id });
+      if (!updatedMCPServer) {
+        throw new MastraError({
+          id: createStorageErrorId("MONGODB", "UPDATE_MCP_SERVER", "NOT_FOUND_AFTER_UPDATE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.SYSTEM,
+          text: `MCP server with id ${id} was deleted during update`,
+          details: { id }
+        });
+      }
+      return this.transformMCPServer(updatedMCPServer);
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "UPDATE_MCP_SERVER", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      await this.deleteVersionsByParentId(id);
+      const collection = await this.getCollection(TABLE_MCP_SERVERS);
+      await collection.deleteOne({ id });
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "DELETE_MCP_SERVER", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error
+      );
+    }
+  }
+  async list(args) {
+    try {
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status = "published" } = args || {};
+      const { field, direction } = this.parseOrderBy(orderBy);
+      if (page < 0) {
+        throw new MastraError(
+          {
+            id: createStorageErrorId("MONGODB", "LIST_MCP_SERVERS", "INVALID_PAGE"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const collection = await this.getCollection(TABLE_MCP_SERVERS);
+      const filter = {};
+      filter.status = status;
+      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 {
+          mcpServers: [],
+          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 mcpServers = results.map((doc) => this.transformMCPServer(doc));
+      return {
+        mcpServers,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput !== false && offset + perPage < total
+      };
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "LIST_MCP_SERVERS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  // ==========================================================================
+  // MCP Server Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVER_VERSIONS);
+      const now = /* @__PURE__ */ new Date();
+      const versionDoc = {
+        id: input.id,
+        mcpServerId: input.mcpServerId,
+        versionNumber: input.versionNumber,
+        changedFields: input.changedFields ?? void 0,
+        changeMessage: input.changeMessage ?? void 0,
+        createdAt: now
+      };
+      for (const field of SNAPSHOT_FIELDS3) {
+        if (input[field] !== void 0) {
+          versionDoc[field] = input[field];
+        }
+      }
+      await collection.insertOne(versionDoc);
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "CREATE_MCP_SERVER_VERSION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, mcpServerId: input.mcpServerId }
+        },
+        error
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVER_VERSIONS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "GET_MCP_SERVER_VERSION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error
+      );
+    }
+  }
+  async getVersionByNumber(mcpServerId, versionNumber) {
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVER_VERSIONS);
+      const result = await collection.findOne({ mcpServerId, versionNumber });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "GET_MCP_SERVER_VERSION_BY_NUMBER", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId, versionNumber }
+        },
+        error
+      );
+    }
+  }
+  async getLatestVersion(mcpServerId) {
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVER_VERSIONS);
+      const result = await collection.find({ mcpServerId }).sort({ versionNumber: -1 }).limit(1).toArray();
+      if (!result || result.length === 0) {
+        return null;
+      }
+      return this.transformVersion(result[0]);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "GET_LATEST_MCP_SERVER_VERSION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId }
+        },
+        error
+      );
+    }
+  }
+  async listVersions(input) {
+    const { mcpServerId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "LIST_MCP_SERVER_VERSIONS", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 20);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseVersionOrderBy(orderBy);
+      const collection = await this.getCollection(TABLE_MCP_SERVER_VERSIONS);
+      const total = await collection.countDocuments({ mcpServerId });
+      if (total === 0 || perPage === 0) {
+        return {
+          versions: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find({ mcpServerId }).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) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "LIST_MCP_SERVER_VERSIONS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId }
+        },
+        error
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVER_VERSIONS);
+      await collection.deleteOne({ id });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "DELETE_MCP_SERVER_VERSION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error
+      );
+    }
+  }
+  async deleteVersionsByParentId(mcpServerId) {
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVER_VERSIONS);
+      await collection.deleteMany({ mcpServerId });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "DELETE_VERSIONS_BY_MCP_SERVER_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId }
+        },
+        error
+      );
+    }
+  }
+  async countVersions(mcpServerId) {
+    try {
+      const collection = await this.getCollection(TABLE_MCP_SERVER_VERSIONS);
+      return await collection.countDocuments({ mcpServerId });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "COUNT_MCP_SERVER_VERSIONS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId }
+        },
+        error
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  transformMCPServer(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)
+    };
+  }
+  serializeMCPServer(mcpServer) {
+    return {
+      id: mcpServer.id,
+      status: mcpServer.status,
+      activeVersionId: mcpServer.activeVersionId,
+      authorId: mcpServer.authorId,
+      metadata: mcpServer.metadata,
+      createdAt: mcpServer.createdAt,
+      updatedAt: mcpServer.updatedAt
+    };
+  }
+  transformVersion(doc) {
+    const { _id, ...version } = doc;
+    const result = {
+      id: version.id,
+      mcpServerId: version.mcpServerId,
+      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_FIELDS3) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
+  }
+};
 function formatDateForMongoDB(date) {
   return typeof date === "string" ? new Date(date) : date;
 }
@@ -3602,32 +4155,40 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends MemoryStorage {
       const retentionFloor = input.messageTokensThreshold * (1 - input.activationRatio);
       const targetMessageTokens = Math.max(0, input.currentPendingTokens - retentionFloor);
       let cumulativeMessageTokens = 0;
-      let bestBoundary = 0;
-      let bestBoundaryMessageTokens = 0;
+      let bestOverBoundary = 0;
+      let bestOverTokens = 0;
+      let bestUnderBoundary = 0;
+      let bestUnderTokens = 0;
       for (let i = 0; i < chunks.length; i++) {
         cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
         const boundary = i + 1;
-        const isUnder = cumulativeMessageTokens <= targetMessageTokens;
-        const bestIsUnder = bestBoundaryMessageTokens <= targetMessageTokens;
-        if (bestBoundary === 0) {
-          bestBoundary = boundary;
-          bestBoundaryMessageTokens = cumulativeMessageTokens;
-        } else if (isUnder && !bestIsUnder) {
-          bestBoundary = boundary;
-          bestBoundaryMessageTokens = cumulativeMessageTokens;
-        } else if (isUnder && bestIsUnder) {
-          if (cumulativeMessageTokens > bestBoundaryMessageTokens) {
-            bestBoundary = boundary;
-            bestBoundaryMessageTokens = cumulativeMessageTokens;
+        if (cumulativeMessageTokens >= targetMessageTokens) {
+          if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
+            bestOverBoundary = boundary;
+            bestOverTokens = cumulativeMessageTokens;
           }
-        } else if (!isUnder && !bestIsUnder) {
-          if (cumulativeMessageTokens < bestBoundaryMessageTokens) {
-            bestBoundary = boundary;
-            bestBoundaryMessageTokens = cumulativeMessageTokens;
+        } else {
+          if (cumulativeMessageTokens > bestUnderTokens) {
+            bestUnderBoundary = boundary;
+            bestUnderTokens = cumulativeMessageTokens;
           }
         }
       }
-      const chunksToActivate = bestBoundary === 0 ? 1 : bestBoundary;
+      const maxOvershoot = retentionFloor * 0.95;
+      const overshoot = bestOverTokens - targetMessageTokens;
+      const remainingAfterOver = input.currentPendingTokens - bestOverTokens;
+      let chunksToActivate;
+      if (input.forceMaxActivation && bestOverBoundary > 0) {
+        chunksToActivate = bestOverBoundary;
+      } else if (bestOverBoundary > 0 && overshoot <= maxOvershoot && (remainingAfterOver >= 1e3 || retentionFloor === 0)) {
+        chunksToActivate = bestOverBoundary;
+      } else if (bestUnderBoundary > 0) {
+        chunksToActivate = bestUnderBoundary;
+      } else if (bestOverBoundary > 0) {
+        chunksToActivate = bestOverBoundary;
+      } else {
+        chunksToActivate = 1;
+      }
       const activatedChunks = chunks.slice(0, chunksToActivate);
       const remainingChunks = chunks.slice(chunksToActivate);
       const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
@@ -3659,6 +4220,7 @@ ${activatedContent}` : activatedContent;
           }
         }
       );
+      const latestChunkHints = activatedChunks[activatedChunks.length - 1];
       return {
         chunksActivated: activatedChunks.length,
         messageTokensActivated: activatedMessageTokens,
@@ -3673,7 +4235,9 @@ ${activatedContent}` : activatedContent;
           observationTokens: c.tokenCount,
           messageCount: c.messageIds.length,
           observations: c.observations
-        }))
+        })),
+        suggestedContinuation: latestChunkHints?.suggestedContinuation ?? void 0,
+        currentTask: latestChunkHints?.currentTask ?? void 0
       };
     } catch (error) {
       if (error instanceof MastraError) {
@@ -4571,7 +5135,7 @@ Note: This migration may take some time for large collections.
     return span;
   }
 };
-var SNAPSHOT_FIELDS3 = ["name", "description", "content", "rules"];
+var SNAPSHOT_FIELDS4 = ["name", "description", "content", "rules"];
 var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends PromptBlocksStorage {
   #connector;
   #skipDefaultIndexes;
@@ -4688,7 +5252,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends Promp
       };
       await collection.insertOne(this.serializeBlock(newBlock));
       const snapshotConfig = {};
-      for (const field of SNAPSHOT_FIELDS3) {
+      for (const field of SNAPSHOT_FIELDS4) {
         if (promptBlock[field] !== void 0) {
           snapshotConfig[field] = promptBlock[field];
         }
@@ -4877,7 +5441,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends Promp
         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];
         }
@@ -5097,7 +5661,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends Promp
       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];
       }
@@ -5105,7 +5669,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends Promp
     return result;
   }
 };
-var SNAPSHOT_FIELDS4 = [
+var SNAPSHOT_FIELDS5 = [
   "name",
   "description",
   "type",
@@ -5231,7 +5795,7 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
       };
       await collection.insertOne(this.serializeScorerDefinition(newScorerDefinition));
       const snapshotConfig = {};
-      for (const field of SNAPSHOT_FIELDS4) {
+      for (const field of SNAPSHOT_FIELDS5) {
         if (scorerDefinition[field] !== void 0) {
           snapshotConfig[field] = scorerDefinition[field];
         }
@@ -5422,7 +5986,7 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
         changeMessage: input.changeMessage ?? void 0,
         createdAt: now
       };
-      for (const field of SNAPSHOT_FIELDS4) {
+      for (const field of SNAPSHOT_FIELDS5) {
         if (input[field] !== void 0) {
           versionDoc[field] = input[field];
         }
@@ -5642,7 +6206,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_FIELDS4) {
+    for (const field of SNAPSHOT_FIELDS5) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -6018,7 +6582,7 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends ScoresStorage {
     }
   }
 };
-var SNAPSHOT_FIELDS5 = [
+var SNAPSHOT_FIELDS6 = [
   "name",
   "description",
   "instructions",
@@ -6147,7 +6711,7 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends SkillsStorage {
       };
       await collection.insertOne(this.serializeSkill(newSkill));
       const snapshotConfig = {};
-      for (const field of SNAPSHOT_FIELDS5) {
+      for (const field of SNAPSHOT_FIELDS6) {
         if (skill[field] !== void 0) {
           snapshotConfig[field] = skill[field];
         }
@@ -6205,7 +6769,7 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends SkillsStorage {
         status: updates.status
       };
       const configFields = {};
-      for (const field of SNAPSHOT_FIELDS5) {
+      for (const field of SNAPSHOT_FIELDS6) {
         if (updates[field] !== void 0) {
           configFields[field] = updates[field];
         }
@@ -6366,7 +6930,7 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends SkillsStorage {
         changeMessage: input.changeMessage ?? void 0,
         createdAt: now
       };
-      for (const field of SNAPSHOT_FIELDS5) {
+      for (const field of SNAPSHOT_FIELDS6) {
         if (input[field] !== void 0) {
           versionDoc[field] = input[field];
         }
@@ -6584,7 +7148,7 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends SkillsStorage {
       changeMessage: version.changeMessage,
       createdAt: version.createdAt instanceof Date ? version.createdAt : new Date(version.createdAt)
     };
-    for (const field of SNAPSHOT_FIELDS5) {
+    for (const field of SNAPSHOT_FIELDS6) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -6593,7 +7157,7 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends SkillsStorage {
   }
   extractSnapshotFields(version) {
     const result = {};
-    for (const field of SNAPSHOT_FIELDS5) {
+    for (const field of SNAPSHOT_FIELDS6) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -6879,7 +7443,7 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends WorkflowsSt
     };
   }
 };
-var SNAPSHOT_FIELDS6 = [
+var SNAPSHOT_FIELDS7 = [
   "name",
   "description",
   "filesystem",
@@ -7018,7 +7582,7 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends Workspace
       };
       await collection.insertOne(this.serializeWorkspace(newWorkspace));
       const snapshotConfig = {};
-      for (const field of SNAPSHOT_FIELDS6) {
+      for (const field of SNAPSHOT_FIELDS7) {
         if (workspace[field] !== void 0) {
           snapshotConfig[field] = workspace[field];
         }
@@ -7077,7 +7641,7 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends Workspace
         status: updates.status
       };
       const configFields = {};
-      for (const field of SNAPSHOT_FIELDS6) {
+      for (const field of SNAPSHOT_FIELDS7) {
         if (updates[field] !== void 0) {
           configFields[field] = updates[field];
         }
@@ -7242,7 +7806,7 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends Workspace
         changeMessage: input.changeMessage ?? void 0,
         createdAt: now
       };
-      for (const field of SNAPSHOT_FIELDS6) {
+      for (const field of SNAPSHOT_FIELDS7) {
         if (input[field] !== void 0) {
           versionDoc[field] = input[field];
         }
@@ -7462,7 +8026,7 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends Workspace
       changeMessage: version.changeMessage,
       createdAt: version.createdAt instanceof Date ? version.createdAt : new Date(version.createdAt)
     };
-    for (const field of SNAPSHOT_FIELDS6) {
+    for (const field of SNAPSHOT_FIELDS7) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -7471,7 +8035,7 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends Workspace
   }
   extractSnapshotFields(version) {
     const result = {};
-    for (const field of SNAPSHOT_FIELDS6) {
+    for (const field of SNAPSHOT_FIELDS7) {
       if (version[field] !== void 0) {
         result[field] = version[field];
       }
@@ -7500,6 +8064,7 @@ var MongoDBStore = class extends MastraCompositeStore {
     const promptBlocks = new MongoDBPromptBlocksStorage(domainConfig);
     const scorerDefinitions = new MongoDBScorerDefinitionsStorage(domainConfig);
     const mcpClients = new MongoDBMCPClientsStorage(domainConfig);
+    const mcpServers = new MongoDBMCPServersStorage(domainConfig);
     const workspaces = new MongoDBWorkspacesStorage(domainConfig);
     const skills = new MongoDBSkillsStorage(domainConfig);
     const blobs = new MongoDBBlobStore(domainConfig);
@@ -7512,6 +8077,7 @@ var MongoDBStore = class extends MastraCompositeStore {
       promptBlocks,
       scorerDefinitions,
       mcpClients,
+      mcpServers,
       workspaces,
       skills,
       blobs
@@ -7633,6 +8199,6 @@ Example Complex Query:
   ]
 }`;
 
-export { MONGODB_PROMPT, MemoryStorageMongoDB, MongoDBAgentsStorage, MongoDBBlobStore, MongoDBMCPClientsStorage, MongoDBPromptBlocksStorage, MongoDBScorerDefinitionsStorage, MongoDBSkillsStorage, MongoDBStore, MongoDBVector, MongoDBWorkspacesStorage, ObservabilityMongoDB, ScoresStorageMongoDB, WorkflowsStorageMongoDB };
+export { MONGODB_PROMPT, MemoryStorageMongoDB, MongoDBAgentsStorage, MongoDBBlobStore, MongoDBMCPClientsStorage, MongoDBMCPServersStorage, MongoDBPromptBlocksStorage, MongoDBScorerDefinitionsStorage, MongoDBSkillsStorage, MongoDBStore, MongoDBVector, MongoDBWorkspacesStorage, ObservabilityMongoDB, ScoresStorageMongoDB, WorkflowsStorageMongoDB };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map