@mastra/mongodb 1.2.0-alpha.0 → 1.3.0-alpha.0

package/dist/index.cjs

@@ -14,7 +14,7 @@ var evals = require('@mastra/core/evals');
 
 // package.json
 var package_default = {
-  version: "1.2.0-alpha.0"};
+  version: "1.3.0-alpha.0"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -973,6 +973,42 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
   async init() {
     await this.createDefaultIndexes();
     await this.createCustomIndexes();
+    await this.#migrateToolsToJsonbFormat();
+  }
+  /**
+   * Migrates the tools field from string[] format to object format { "tool-key": { "description": "..." } }.
+   * This handles the transition from the old format where tools were stored as an array of string keys
+   * to the new format where tools can have per-agent description overrides.
+   */
+  async #migrateToolsToJsonbFormat() {
+    try {
+      const versionsCollection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+      const cursor = versionsCollection.find({ tools: { $type: "array" } });
+      const updates = [];
+      for await (const doc of cursor) {
+        if (Array.isArray(doc.tools)) {
+          const toolsObject = {};
+          for (const toolKey of doc.tools) {
+            if (typeof toolKey === "string") {
+              toolsObject[toolKey] = {};
+            }
+          }
+          updates.push({ id: doc.id, tools: toolsObject });
+        }
+      }
+      if (updates.length > 0) {
+        const bulkOps = updates.map((update) => ({
+          updateOne: {
+            filter: { id: update.id },
+            update: { $set: { tools: update.tools } }
+          }
+        }));
+        await versionsCollection.bulkWrite(bulkOps);
+        this.logger?.info?.(`Migrated ${updates.length} agent version tools from array to object format`);
+      }
+    } catch (error) {
+      this.logger?.warn?.("Failed to migrate tools to object format:", error);
+    }
   }
   async dangerouslyClearAll() {
     const versionsCollection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
@@ -980,7 +1016,7 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
     const agentsCollection = await this.getCollection(storage.TABLE_AGENTS);
     await agentsCollection.deleteMany({});
   }
-  async getAgentById({ id }) {
+  async getById(id) {
     try {
       const collection = await this.getCollection(storage.TABLE_AGENTS);
       const result = await collection.findOne({ id });
@@ -1000,7 +1036,8 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       );
     }
   }
-  async createAgent({ agent }) {
+  async create(input) {
+    const { agent } = input;
     try {
       const collection = await this.getCollection(storage.TABLE_AGENTS);
       const existing = await collection.findOne({ id: agent.id });
@@ -1050,7 +1087,8 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       );
     }
   }
-  async updateAgent({ id, ...updates }) {
+  async update(input) {
+    const { id, ...updates } = input;
     try {
       const collection = await this.getCollection(storage.TABLE_AGENTS);
       const existingAgent = await collection.findOne({ id });
@@ -1089,14 +1127,17 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
             details: { id }
           });
         }
+        const sanitizedConfigFields = Object.fromEntries(
+          Object.entries(configFields).map(([key, value]) => [key, value === null ? void 0 : value])
+        );
         const versionInput = {
           id: crypto.randomUUID(),
           agentId: id,
           versionNumber: nextVersionNumber,
           ...this.extractSnapshotFields(latestVersion),
           // Start from latest version
-          ...configFields,
-          // Apply updates
+          ...sanitizedConfigFields,
+          // Apply updates (null values converted to undefined)
           changedFields: Object.keys(configFields),
           changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
         };
@@ -1137,9 +1178,9 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       );
     }
   }
-  async deleteAgent({ id }) {
+  async delete(id) {
     try {
-      await this.deleteVersionsByAgentId(id);
+      await this.deleteVersionsByParentId(id);
       const collection = await this.getCollection(storage.TABLE_AGENTS);
       await collection.deleteOne({ id });
     } catch (error$1) {
@@ -1154,7 +1195,7 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       );
     }
   }
-  async listAgents(args) {
+  async list(args) {
     try {
       const { page = 0, perPage: perPageInput, orderBy } = args || {};
       const { field, direction } = this.parseOrderBy(orderBy);
@@ -1210,123 +1251,6 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       );
     }
   }
-  async listAgentsResolved(args) {
-    try {
-      const { page = 0, perPage: perPageInput, orderBy } = args || {};
-      const { field, direction } = this.parseOrderBy(orderBy);
-      if (page < 0) {
-        throw new error.MastraError(
-          {
-            id: storage.createStorageErrorId("MONGODB", "LIST_AGENTS_RESOLVED", "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 agentsCollection = await this.getCollection(storage.TABLE_AGENTS);
-      const total = await agentsCollection.countDocuments({});
-      if (total === 0 || perPage === 0) {
-        return {
-          agents: [],
-          total,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      const sortOrder = direction === "ASC" ? 1 : -1;
-      const pipeline = [
-        // Sort agents
-        { $sort: { [field]: sortOrder } },
-        // Paginate
-        { $skip: offset }
-      ];
-      if (perPageInput !== false) {
-        pipeline.push({ $limit: perPage });
-      }
-      pipeline.push({
-        $lookup: {
-          from: storage.TABLE_AGENT_VERSIONS,
-          localField: "activeVersionId",
-          foreignField: "id",
-          as: "activeVersion"
-        }
-      });
-      pipeline.push({
-        $lookup: {
-          from: storage.TABLE_AGENT_VERSIONS,
-          let: { agentId: "$id" },
-          pipeline: [
-            { $match: { $expr: { $eq: ["$agentId", "$$agentId"] } } },
-            { $sort: { versionNumber: -1 } },
-            { $limit: 1 }
-          ],
-          as: "latestVersion"
-        }
-      });
-      pipeline.push({
-        $addFields: {
-          version: {
-            $cond: {
-              if: { $gt: [{ $size: "$activeVersion" }, 0] },
-              then: { $arrayElemAt: ["$activeVersion", 0] },
-              else: { $arrayElemAt: ["$latestVersion", 0] }
-            }
-          }
-        }
-      });
-      pipeline.push({
-        $project: {
-          activeVersion: 0,
-          latestVersion: 0
-        }
-      });
-      const results = await agentsCollection.aggregate(pipeline).toArray();
-      const resolvedAgents = results.map((doc) => {
-        const agent = this.transformAgent(doc);
-        if (doc.version) {
-          const version = this.transformVersion(doc.version);
-          const {
-            id: _versionId,
-            agentId: _agentId,
-            versionNumber: _versionNumber,
-            changedFields: _changedFields,
-            changeMessage: _changeMessage,
-            createdAt: _createdAt,
-            ...snapshotConfig
-          } = version;
-          return {
-            ...agent,
-            ...snapshotConfig
-          };
-        }
-        return agent;
-      });
-      return {
-        agents: resolvedAgents,
-        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_AGENTS_RESOLVED", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
   /**
    * Transforms a raw MongoDB document into a thin StorageAgentType record.
    * Only returns metadata-level fields (no config/snapshot fields).
@@ -1525,7 +1449,7 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       );
     }
   }
-  async deleteVersionsByAgentId(agentId) {
+  async deleteVersionsByParentId(agentId) {
     try {
       const collection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
       await collection.deleteMany({ agentId });
@@ -2460,12 +2384,26 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
       originType: doc.originType || "initial",
       generationCount: Number(doc.generationCount || 0),
       activeObservations: doc.activeObservations || "",
+      // Handle new chunk-based structure
+      bufferedObservationChunks: doc.bufferedObservationChunks || void 0,
+      // Deprecated fields (for backward compatibility)
       bufferedObservations: doc.activeObservationsPendingUpdate || void 0,
+      bufferedObservationTokens: doc.bufferedObservationTokens ? Number(doc.bufferedObservationTokens) : void 0,
+      bufferedMessageIds: void 0,
+      // Use bufferedObservationChunks instead
+      bufferedReflection: doc.bufferedReflection || void 0,
+      bufferedReflectionTokens: doc.bufferedReflectionTokens ? Number(doc.bufferedReflectionTokens) : void 0,
+      bufferedReflectionInputTokens: doc.bufferedReflectionInputTokens ? Number(doc.bufferedReflectionInputTokens) : void 0,
+      reflectedObservationLineCount: doc.reflectedObservationLineCount ? Number(doc.reflectedObservationLineCount) : void 0,
       totalTokensObserved: Number(doc.totalTokensObserved || 0),
       observationTokenCount: Number(doc.observationTokenCount || 0),
       pendingMessageTokens: Number(doc.pendingMessageTokens || 0),
       isReflecting: Boolean(doc.isReflecting),
       isObserving: Boolean(doc.isObserving),
+      isBufferingObservation: Boolean(doc.isBufferingObservation),
+      isBufferingReflection: Boolean(doc.isBufferingReflection),
+      lastBufferedAtTokens: typeof doc.lastBufferedAtTokens === "number" ? doc.lastBufferedAtTokens : parseInt(String(doc.lastBufferedAtTokens ?? "0"), 10) || 0,
+      lastBufferedAtTime: doc.lastBufferedAtTime ? new Date(doc.lastBufferedAtTime) : null,
       config: doc.config || {},
       metadata: doc.metadata || void 0,
       observedMessageIds: doc.observedMessageIds || void 0,
@@ -2530,6 +2468,10 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
         pendingMessageTokens: 0,
         isReflecting: false,
         isObserving: false,
+        isBufferingObservation: false,
+        isBufferingReflection: false,
+        lastBufferedAtTokens: 0,
+        lastBufferedAtTime: null,
         config: input.config,
         observedTimezone: input.observedTimezone
       };
@@ -2552,6 +2494,10 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
         observationTokenCount: 0,
         isObserving: false,
         isReflecting: false,
+        isBufferingObservation: false,
+        isBufferingReflection: false,
+        lastBufferedAtTokens: 0,
+        lastBufferedAtTime: null,
         observedTimezone: input.observedTimezone || null,
         createdAt: now,
         updatedAt: now
@@ -2634,6 +2580,10 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
         pendingMessageTokens: 0,
         isReflecting: false,
         isObserving: false,
+        isBufferingObservation: false,
+        isBufferingReflection: false,
+        lastBufferedAtTokens: 0,
+        lastBufferedAtTime: null,
         config: input.currentRecord.config,
         metadata: input.currentRecord.metadata,
         observedTimezone: input.currentRecord.observedTimezone
@@ -2657,6 +2607,10 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
         observationTokenCount: record.observationTokenCount,
         isObserving: false,
         isReflecting: false,
+        isBufferingObservation: false,
+        isBufferingReflection: false,
+        lastBufferedAtTokens: 0,
+        lastBufferedAtTime: null,
         observedTimezone: record.observedTimezone || null,
         createdAt: now,
         updatedAt: now,
@@ -2731,6 +2685,72 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
       );
     }
   }
+  async setBufferingObservationFlag(id, isBuffering, lastBufferedAtTokens) {
+    try {
+      const collection = await this.getCollection(OM_TABLE);
+      const updateDoc = {
+        isBufferingObservation: isBuffering,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (lastBufferedAtTokens !== void 0) {
+        updateDoc.lastBufferedAtTokens = lastBufferedAtTokens;
+      }
+      const result = await collection.updateOne({ id }, { $set: updateDoc });
+      if (result.matchedCount === 0) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "SET_BUFFERING_OBSERVATION_FLAG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id, isBuffering, lastBufferedAtTokens: lastBufferedAtTokens ?? null }
+        });
+      }
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "SET_BUFFERING_OBSERVATION_FLAG", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id, isBuffering, lastBufferedAtTokens: lastBufferedAtTokens ?? null }
+        },
+        error$1
+      );
+    }
+  }
+  async setBufferingReflectionFlag(id, isBuffering) {
+    try {
+      const collection = await this.getCollection(OM_TABLE);
+      const result = await collection.updateOne(
+        { id },
+        { $set: { isBufferingReflection: isBuffering, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      if (result.matchedCount === 0) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "SET_BUFFERING_REFLECTION_FLAG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id, isBuffering }
+        });
+      }
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "SET_BUFFERING_REFLECTION_FLAG", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id, isBuffering }
+        },
+        error$1
+      );
+    }
+  }
   async clearObservationalMemory(threadId, resourceId) {
     try {
       const lookupKey = this.getOMKey(threadId, resourceId);
@@ -2791,116 +2811,405 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
       );
     }
   }
-};
-var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.ObservabilityStorage {
-  #connector;
-  #skipDefaultIndexes;
-  #indexes;
-  /** Collections managed by this domain */
-  static MANAGED_COLLECTIONS = [storage.TABLE_SPANS];
-  constructor(config) {
-    super();
-    this.#connector = resolveMongoDBConfig(config);
-    this.#skipDefaultIndexes = config.skipDefaultIndexes;
-    this.#indexes = config.indexes?.filter(
-      (idx) => _ObservabilityMongoDB.MANAGED_COLLECTIONS.includes(idx.collection)
-    );
-  }
-  async getCollection(name) {
-    return this.#connector.getCollection(name);
-  }
-  /**
-   * Returns default index definitions for the observability domain collections.
-   * These indexes optimize common query patterns for span and trace lookups.
-   */
-  getDefaultIndexDefinitions() {
-    return [
-      { collection: storage.TABLE_SPANS, keys: { spanId: 1, traceId: 1 }, options: { unique: true } },
-      { collection: storage.TABLE_SPANS, keys: { traceId: 1 } },
-      { collection: storage.TABLE_SPANS, keys: { parentSpanId: 1 } },
-      { collection: storage.TABLE_SPANS, keys: { startedAt: -1 } },
-      { collection: storage.TABLE_SPANS, keys: { spanType: 1 } },
-      { collection: storage.TABLE_SPANS, keys: { name: 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);
-      }
-    }
-  }
-  /**
-   * Creates custom user-defined indexes for this domain's collections.
-   */
-  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 Buffering Methods
+  // ============================================
+  async updateBufferedObservations(input) {
+    try {
+      const collection = await this.getCollection(OM_TABLE);
+      const newChunk = {
+        id: `ombuf-${crypto.randomUUID()}`,
+        cycleId: input.chunk.cycleId,
+        observations: input.chunk.observations,
+        tokenCount: input.chunk.tokenCount,
+        messageIds: input.chunk.messageIds,
+        messageTokens: input.chunk.messageTokens,
+        lastObservedAt: input.chunk.lastObservedAt,
+        createdAt: /* @__PURE__ */ new Date(),
+        suggestedContinuation: input.chunk.suggestedContinuation,
+        currentTask: input.chunk.currentTask
+      };
+      const $set = { updatedAt: /* @__PURE__ */ new Date() };
+      if (input.lastBufferedAtTime) {
+        $set.lastBufferedAtTime = input.lastBufferedAtTime;
       }
-    }
-  }
-  async init() {
-    const uniqueIndexExists = await this.spansUniqueIndexExists();
-    if (!uniqueIndexExists) {
-      const duplicateInfo = await this.checkForDuplicateSpans();
-      if (duplicateInfo.hasDuplicates) {
-        const errorMessage = `
-===========================================================================
-MIGRATION REQUIRED: Duplicate spans detected in ${storage.TABLE_SPANS} collection
-===========================================================================
-
-Found ${duplicateInfo.duplicateCount} duplicate (traceId, spanId) combinations.
-
-The spans collection requires a unique index on (traceId, spanId), but your
-database contains duplicate entries that must be resolved first.
-
-To fix this, run the manual migration command:
-
-  npx mastra migrate
-
-This command will:
-  1. Remove duplicate spans (keeping the most complete/recent version)
-  2. Add the required unique index
-
-Note: This migration may take some time for large collections.
-===========================================================================
-`;
+      const result = await collection.updateOne(
+        { id: input.id },
+        {
+          $push: { bufferedObservationChunks: newChunk },
+          $set
+        }
+      );
+      if (result.matchedCount === 0) {
         throw new error.MastraError({
-          id: storage.createStorageErrorId("MONGODB", "MIGRATION_REQUIRED", "DUPLICATE_SPANS"),
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_BUFFERED_OBSERVATIONS", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          text: errorMessage
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
         });
       }
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_BUFFERED_OBSERVATIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        },
+        error$1
+      );
     }
-    await this.createDefaultIndexes();
-    await this.createCustomIndexes();
   }
-  /**
-   * Checks if the unique index on (spanId, traceId) already exists on the spans collection.
-   * Used to skip deduplication when the index already exists (migration already complete).
-   */
-  async spansUniqueIndexExists() {
+  async swapBufferedToActive(input) {
     try {
-      const collection = await this.getCollection(storage.TABLE_SPANS);
-      const indexes = await collection.indexes();
-      return indexes.some((idx) => idx.unique === true && idx.key?.spanId === 1 && idx.key?.traceId === 1);
-    } catch {
-      return false;
-    }
+      const collection = await this.getCollection(OM_TABLE);
+      const doc = await collection.findOne({ id: input.id });
+      if (!doc) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "SWAP_BUFFERED_TO_ACTIVE", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        });
+      }
+      const chunks = Array.isArray(doc.bufferedObservationChunks) ? doc.bufferedObservationChunks : [];
+      if (chunks.length === 0) {
+        return {
+          chunksActivated: 0,
+          messageTokensActivated: 0,
+          observationTokensActivated: 0,
+          messagesActivated: 0,
+          activatedCycleIds: [],
+          activatedMessageIds: []
+        };
+      }
+      const retentionFloor = input.messageTokensThreshold * (1 - input.activationRatio);
+      const targetMessageTokens = Math.max(0, input.currentPendingTokens - retentionFloor);
+      let cumulativeMessageTokens = 0;
+      let bestBoundary = 0;
+      let bestBoundaryMessageTokens = 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;
+          }
+        } else if (!isUnder && !bestIsUnder) {
+          if (cumulativeMessageTokens < bestBoundaryMessageTokens) {
+            bestBoundary = boundary;
+            bestBoundaryMessageTokens = cumulativeMessageTokens;
+          }
+        }
+      }
+      const chunksToActivate = bestBoundary === 0 ? 1 : bestBoundary;
+      const activatedChunks = chunks.slice(0, chunksToActivate);
+      const remainingChunks = chunks.slice(chunksToActivate);
+      const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
+      const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
+      const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+      const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + c.messageIds.length, 0);
+      const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((id) => !!id);
+      const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
+      const latestChunk = activatedChunks[activatedChunks.length - 1];
+      const lastObservedAt = input.lastObservedAt ?? (latestChunk?.lastObservedAt ? new Date(latestChunk.lastObservedAt) : /* @__PURE__ */ new Date());
+      const existingActive = doc.activeObservations || "";
+      const existingTokenCount = Number(doc.observationTokenCount || 0);
+      const newActive = existingActive ? `${existingActive}
+
+${activatedContent}` : activatedContent;
+      const newTokenCount = existingTokenCount + activatedTokens;
+      const existingPending = Number(doc.pendingMessageTokens || 0);
+      const newPending = Math.max(0, existingPending - activatedMessageTokens);
+      await collection.updateOne(
+        { id: input.id },
+        {
+          $set: {
+            activeObservations: newActive,
+            observationTokenCount: newTokenCount,
+            pendingMessageTokens: newPending,
+            bufferedObservationChunks: remainingChunks.length > 0 ? remainingChunks : null,
+            lastObservedAt,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      return {
+        chunksActivated: activatedChunks.length,
+        messageTokensActivated: activatedMessageTokens,
+        observationTokensActivated: activatedTokens,
+        messagesActivated: activatedMessageCount,
+        activatedCycleIds,
+        activatedMessageIds,
+        observations: activatedContent,
+        perChunk: activatedChunks.map((c) => ({
+          cycleId: c.cycleId ?? "",
+          messageTokens: c.messageTokens ?? 0,
+          observationTokens: c.tokenCount,
+          messageCount: c.messageIds.length,
+          observations: c.observations
+        }))
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "SWAP_BUFFERED_TO_ACTIVE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        },
+        error$1
+      );
+    }
+  }
+  async updateBufferedReflection(input) {
+    try {
+      const collection = await this.getCollection(OM_TABLE);
+      const doc = await collection.findOne({ id: input.id });
+      if (!doc) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_BUFFERED_REFLECTION", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        });
+      }
+      const existingContent = doc.bufferedReflection || "";
+      const existingTokens = Number(doc.bufferedReflectionTokens || 0);
+      const existingInputTokens = Number(doc.bufferedReflectionInputTokens || 0);
+      const newContent = existingContent ? `${existingContent}
+
+${input.reflection}` : input.reflection;
+      const newTokens = existingTokens + input.tokenCount;
+      const newInputTokens = existingInputTokens + input.inputTokenCount;
+      const result = await collection.updateOne(
+        { id: input.id },
+        {
+          $set: {
+            bufferedReflection: newContent,
+            bufferedReflectionTokens: newTokens,
+            bufferedReflectionInputTokens: newInputTokens,
+            reflectedObservationLineCount: input.reflectedObservationLineCount,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_BUFFERED_REFLECTION", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        });
+      }
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_BUFFERED_REFLECTION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        },
+        error$1
+      );
+    }
+  }
+  async swapBufferedReflectionToActive(input) {
+    try {
+      const collection = await this.getCollection(OM_TABLE);
+      const doc = await collection.findOne({ id: input.currentRecord.id });
+      if (!doc) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.currentRecord.id}`,
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.currentRecord.id }
+        });
+      }
+      const bufferedReflection = doc.bufferedReflection || "";
+      const reflectedLineCount = Number(doc.reflectedObservationLineCount || 0);
+      if (!bufferedReflection) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "NO_CONTENT"),
+          text: "No buffered reflection to swap",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id: input.currentRecord.id }
+        });
+      }
+      const currentObservations = doc.activeObservations || "";
+      const allLines = currentObservations.split("\n");
+      const unreflectedLines = allLines.slice(reflectedLineCount);
+      const unreflectedContent = unreflectedLines.join("\n").trim();
+      const newObservations = unreflectedContent ? `${bufferedReflection}
+
+${unreflectedContent}` : bufferedReflection;
+      const newRecord = await this.createReflectionGeneration({
+        currentRecord: input.currentRecord,
+        reflection: newObservations,
+        tokenCount: input.tokenCount
+      });
+      await collection.updateOne(
+        { id: input.currentRecord.id },
+        {
+          $set: {
+            bufferedReflection: null,
+            bufferedReflectionTokens: null,
+            bufferedReflectionInputTokens: null,
+            reflectedObservationLineCount: null,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      return newRecord;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "SWAP_BUFFERED_REFLECTION_TO_ACTIVE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: input.currentRecord.id }
+        },
+        error$1
+      );
+    }
+  }
+};
+var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.ObservabilityStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Collections managed by this domain */
+  static MANAGED_COLLECTIONS = [storage.TABLE_SPANS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _ObservabilityMongoDB.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  /**
+   * Returns default index definitions for the observability domain collections.
+   * These indexes optimize common query patterns for span and trace lookups.
+   */
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_SPANS, keys: { spanId: 1, traceId: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_SPANS, keys: { traceId: 1 } },
+      { collection: storage.TABLE_SPANS, keys: { parentSpanId: 1 } },
+      { collection: storage.TABLE_SPANS, keys: { startedAt: -1 } },
+      { collection: storage.TABLE_SPANS, keys: { spanType: 1 } },
+      { collection: storage.TABLE_SPANS, keys: { name: 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);
+      }
+    }
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's collections.
+   */
+  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() {
+    const uniqueIndexExists = await this.spansUniqueIndexExists();
+    if (!uniqueIndexExists) {
+      const duplicateInfo = await this.checkForDuplicateSpans();
+      if (duplicateInfo.hasDuplicates) {
+        const errorMessage = `
+===========================================================================
+MIGRATION REQUIRED: Duplicate spans detected in ${storage.TABLE_SPANS} collection
+===========================================================================
+
+Found ${duplicateInfo.duplicateCount} duplicate (traceId, spanId) combinations.
+
+The spans collection requires a unique index on (traceId, spanId), but your
+database contains duplicate entries that must be resolved first.
+
+To fix this, run the manual migration command:
+
+  npx mastra migrate
+
+This command will:
+  1. Remove duplicate spans (keeping the most complete/recent version)
+  2. Add the required unique index
+
+Note: This migration may take some time for large collections.
+===========================================================================
+`;
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "MIGRATION_REQUIRED", "DUPLICATE_SPANS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: errorMessage
+        });
+      }
+    }
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Checks if the unique index on (spanId, traceId) already exists on the spans collection.
+   * Used to skip deduplication when the index already exists (migration already complete).
+   */
+  async spansUniqueIndexExists() {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      const indexes = await collection.indexes();
+      return indexes.some((idx) => idx.unique === true && idx.key?.spanId === 1 && idx.key?.traceId === 1);
+    } catch {
+      return false;
+    }
   }
   /**
    * Checks for duplicate (traceId, spanId) combinations in the spans collection.
@@ -3551,6 +3860,1161 @@ Note: This migration may take some time for large collections.
     return span;
   }
 };
+var SNAPSHOT_FIELDS2 = ["name", "description", "content", "rules"];
+var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends storage.PromptBlocksStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_COLLECTIONS = [storage.TABLE_PROMPT_BLOCKS, storage.TABLE_PROMPT_BLOCK_VERSIONS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MongoDBPromptBlocksStorage.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_PROMPT_BLOCKS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_PROMPT_BLOCKS, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_PROMPT_BLOCKS, keys: { updatedAt: -1 } },
+      { collection: storage.TABLE_PROMPT_BLOCKS, keys: { authorId: 1 } },
+      { collection: storage.TABLE_PROMPT_BLOCK_VERSIONS, keys: { id: 1 }, options: { unique: true } },
+      {
+        collection: storage.TABLE_PROMPT_BLOCK_VERSIONS,
+        keys: { blockId: 1, versionNumber: -1 },
+        options: { unique: true }
+      },
+      { collection: storage.TABLE_PROMPT_BLOCK_VERSIONS, keys: { blockId: 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_PROMPT_BLOCK_VERSIONS);
+    await versionsCollection.deleteMany({});
+    const blocksCollection = await this.getCollection(storage.TABLE_PROMPT_BLOCKS);
+    await blocksCollection.deleteMany({});
+  }
+  // ==========================================================================
+  // Prompt Block CRUD
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCKS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformBlock(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_PROMPT_BLOCK_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async create(input) {
+    const { promptBlock } = input;
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCKS);
+      const existing = await collection.findOne({ id: promptBlock.id });
+      if (existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "CREATE_PROMPT_BLOCK", "ALREADY_EXISTS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id: promptBlock.id },
+          text: `Prompt block with id ${promptBlock.id} already exists`
+        });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const newBlock = {
+        id: promptBlock.id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: promptBlock.authorId,
+        metadata: promptBlock.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection.insertOne(this.serializeBlock(newBlock));
+      const snapshotConfig = {};
+      for (const field of SNAPSHOT_FIELDS2) {
+        if (promptBlock[field] !== void 0) {
+          snapshotConfig[field] = promptBlock[field];
+        }
+      }
+      const versionId = crypto.randomUUID();
+      await this.createVersion({
+        id: versionId,
+        blockId: promptBlock.id,
+        versionNumber: 1,
+        ...snapshotConfig,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version"
+      });
+      return newBlock;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_PROMPT_BLOCK", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: promptBlock.id }
+        },
+        error$1
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCKS);
+      const existingBlock = await collection.findOne({ id });
+      if (!existingBlock) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_PROMPT_BLOCK", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id },
+          text: `Prompt block 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_PROMPT_BLOCK", "NO_VERSION"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            text: `Cannot update config fields for prompt block ${id} - no versions exist`,
+            details: { id }
+          });
+        }
+        const existingSnapshot = this.extractSnapshotFields(latestVersion);
+        await this.createVersion({
+          id: crypto.randomUUID(),
+          blockId: 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 = existingBlock.metadata || {};
+        updateDoc.metadata = { ...existingMetadata, ...metadataFields.metadata };
+      }
+      await collection.updateOne({ id }, { $set: updateDoc });
+      const updatedBlock = await collection.findOne({ id });
+      if (!updatedBlock) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_PROMPT_BLOCK", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Prompt block with id ${id} was deleted during update`,
+          details: { id }
+        });
+      }
+      return this.transformBlock(updatedBlock);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_PROMPT_BLOCK", "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_PROMPT_BLOCKS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_PROMPT_BLOCK", "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_PROMPT_BLOCKS", "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_PROMPT_BLOCKS);
+      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 {
+          promptBlocks: [],
+          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 promptBlocks = results.map((doc) => this.transformBlock(doc));
+      return {
+        promptBlocks,
+        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_PROMPT_BLOCKS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Prompt Block Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCK_VERSIONS);
+      const now = /* @__PURE__ */ new Date();
+      const versionDoc = {
+        id: input.id,
+        blockId: input.blockId,
+        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_PROMPT_BLOCK_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, blockId: input.blockId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCK_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_PROMPT_BLOCK_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(blockId, versionNumber) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCK_VERSIONS);
+      const result = await collection.findOne({ blockId, versionNumber });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_PROMPT_BLOCK_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { blockId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(blockId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCK_VERSIONS);
+      const result = await collection.find({ blockId }).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_PROMPT_BLOCK_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { blockId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { blockId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_PROMPT_BLOCK_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_PROMPT_BLOCK_VERSIONS);
+      const total = await collection.countDocuments({ blockId });
+      if (total === 0 || perPage === 0) {
+        return {
+          versions: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find({ blockId }).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_PROMPT_BLOCK_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { blockId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCK_VERSIONS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_PROMPT_BLOCK_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByParentId(blockId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCK_VERSIONS);
+      await collection.deleteMany({ blockId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_VERSIONS_BY_BLOCK_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { blockId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(blockId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCK_VERSIONS);
+      return await collection.countDocuments({ blockId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "COUNT_PROMPT_BLOCK_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { blockId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  transformBlock(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)
+    };
+  }
+  serializeBlock(block) {
+    return {
+      id: block.id,
+      status: block.status,
+      activeVersionId: block.activeVersionId,
+      authorId: block.authorId,
+      metadata: block.metadata,
+      createdAt: block.createdAt,
+      updatedAt: block.updatedAt
+    };
+  }
+  transformVersion(doc) {
+    const { _id, ...version } = doc;
+    const result = {
+      id: version.id,
+      blockId: version.blockId,
+      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;
+  }
+};
+var SNAPSHOT_FIELDS3 = [
+  "name",
+  "description",
+  "type",
+  "model",
+  "instructions",
+  "scoreRange",
+  "presetConfig",
+  "defaultSampling"
+];
+var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage extends storage.ScorerDefinitionsStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_COLLECTIONS = [storage.TABLE_SCORER_DEFINITIONS, storage.TABLE_SCORER_DEFINITION_VERSIONS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MongoDBScorerDefinitionsStorage.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_SCORER_DEFINITIONS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_SCORER_DEFINITIONS, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_SCORER_DEFINITIONS, keys: { updatedAt: -1 } },
+      { collection: storage.TABLE_SCORER_DEFINITIONS, keys: { authorId: 1 } },
+      { collection: storage.TABLE_SCORER_DEFINITION_VERSIONS, keys: { id: 1 }, options: { unique: true } },
+      {
+        collection: storage.TABLE_SCORER_DEFINITION_VERSIONS,
+        keys: { scorerDefinitionId: 1, versionNumber: -1 },
+        options: { unique: true }
+      },
+      { collection: storage.TABLE_SCORER_DEFINITION_VERSIONS, keys: { scorerDefinitionId: 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_SCORER_DEFINITION_VERSIONS);
+    await versionsCollection.deleteMany({});
+    const scorerDefinitionsCollection = await this.getCollection(storage.TABLE_SCORER_DEFINITIONS);
+    await scorerDefinitionsCollection.deleteMany({});
+  }
+  // ==========================================================================
+  // Scorer Definition CRUD
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITIONS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformScorerDefinition(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_SCORER_DEFINITION_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async create(input) {
+    const { scorerDefinition } = input;
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITIONS);
+      const existing = await collection.findOne({ id: scorerDefinition.id });
+      if (existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "CREATE_SCORER_DEFINITION", "ALREADY_EXISTS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id: scorerDefinition.id },
+          text: `Scorer definition with id ${scorerDefinition.id} already exists`
+        });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const newScorerDefinition = {
+        id: scorerDefinition.id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: scorerDefinition.authorId,
+        metadata: scorerDefinition.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection.insertOne(this.serializeScorerDefinition(newScorerDefinition));
+      const snapshotConfig = {};
+      for (const field of SNAPSHOT_FIELDS3) {
+        if (scorerDefinition[field] !== void 0) {
+          snapshotConfig[field] = scorerDefinition[field];
+        }
+      }
+      const versionId = crypto.randomUUID();
+      await this.createVersion({
+        id: versionId,
+        scorerDefinitionId: scorerDefinition.id,
+        versionNumber: 1,
+        ...snapshotConfig,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version"
+      });
+      return newScorerDefinition;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_SCORER_DEFINITION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: scorerDefinition.id }
+        },
+        error$1
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITIONS);
+      const existingScorerDefinition = await collection.findOne({ id });
+      if (!existingScorerDefinition) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_SCORER_DEFINITION", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id },
+          text: `Scorer definition 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_FIELDS3) {
+        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_SCORER_DEFINITION", "NO_VERSION"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            text: `Cannot update config fields for scorer definition ${id} - no versions exist`,
+            details: { id }
+          });
+        }
+        const existingSnapshot = this.extractSnapshotFields(latestVersion);
+        await this.createVersion({
+          id: crypto.randomUUID(),
+          scorerDefinitionId: 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 = existingScorerDefinition.metadata || {};
+        updateDoc.metadata = { ...existingMetadata, ...metadataFields.metadata };
+      }
+      await collection.updateOne({ id }, { $set: updateDoc });
+      const updatedScorerDefinition = await collection.findOne({ id });
+      if (!updatedScorerDefinition) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_SCORER_DEFINITION", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Scorer definition with id ${id} was deleted during update`,
+          details: { id }
+        });
+      }
+      return this.transformScorerDefinition(updatedScorerDefinition);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_SCORER_DEFINITION", "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_SCORER_DEFINITIONS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_SCORER_DEFINITION", "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_SCORER_DEFINITIONS", "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_SCORER_DEFINITIONS);
+      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 {
+          scorerDefinitions: [],
+          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 scorerDefinitions = results.map((doc) => this.transformScorerDefinition(doc));
+      return {
+        scorerDefinitions,
+        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_SCORER_DEFINITIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Scorer Definition Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITION_VERSIONS);
+      const now = /* @__PURE__ */ new Date();
+      const versionDoc = {
+        id: input.id,
+        scorerDefinitionId: input.scorerDefinitionId,
+        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$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_SCORER_DEFINITION_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, scorerDefinitionId: input.scorerDefinitionId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITION_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_SCORER_DEFINITION_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(scorerDefinitionId, versionNumber) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITION_VERSIONS);
+      const result = await collection.findOne({ scorerDefinitionId, versionNumber });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_SCORER_DEFINITION_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerDefinitionId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(scorerDefinitionId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITION_VERSIONS);
+      const result = await collection.find({ scorerDefinitionId }).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_SCORER_DEFINITION_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerDefinitionId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { scorerDefinitionId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_SCORER_DEFINITION_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_SCORER_DEFINITION_VERSIONS);
+      const total = await collection.countDocuments({ scorerDefinitionId });
+      if (total === 0 || perPage === 0) {
+        return {
+          versions: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find({ scorerDefinitionId }).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_SCORER_DEFINITION_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerDefinitionId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITION_VERSIONS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_SCORER_DEFINITION_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByParentId(scorerDefinitionId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITION_VERSIONS);
+      await collection.deleteMany({ scorerDefinitionId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_VERSIONS_BY_SCORER_DEFINITION_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerDefinitionId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(scorerDefinitionId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITION_VERSIONS);
+      return await collection.countDocuments({ scorerDefinitionId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "COUNT_SCORER_DEFINITION_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerDefinitionId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  transformScorerDefinition(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)
+    };
+  }
+  serializeScorerDefinition(scorerDefinition) {
+    return {
+      id: scorerDefinition.id,
+      status: scorerDefinition.status,
+      activeVersionId: scorerDefinition.activeVersionId,
+      authorId: scorerDefinition.authorId,
+      metadata: scorerDefinition.metadata,
+      createdAt: scorerDefinition.createdAt,
+      updatedAt: scorerDefinition.updatedAt
+    };
+  }
+  transformVersion(doc) {
+    const { _id, ...version } = doc;
+    const result = {
+      id: version.id,
+      scorerDefinitionId: version.scorerDefinitionId,
+      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;
+  }
+  extractSnapshotFields(version) {
+    const result = {};
+    for (const field of SNAPSHOT_FIELDS3) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
+  }
+};
 function transformScoreRow(row) {
   return storage.transformScoreRow(row, {
     convertTimestamps: true
@@ -4215,12 +5679,16 @@ var MongoDBStore = class extends storage.MastraCompositeStore {
     const workflows = new WorkflowsStorageMongoDB(domainConfig);
     const observability = new ObservabilityMongoDB(domainConfig);
     const agents = new MongoDBAgentsStorage(domainConfig);
+    const promptBlocks = new MongoDBPromptBlocksStorage(domainConfig);
+    const scorerDefinitions = new MongoDBScorerDefinitionsStorage(domainConfig);
     this.stores = {
       memory,
       scores,
       workflows,
       observability,
-      agents
+      agents,
+      promptBlocks,
+      scorerDefinitions
     };
   }
   /**
@@ -4342,6 +5810,8 @@ Example Complex Query:
 exports.MONGODB_PROMPT = MONGODB_PROMPT;
 exports.MemoryStorageMongoDB = MemoryStorageMongoDB;
 exports.MongoDBAgentsStorage = MongoDBAgentsStorage;
+exports.MongoDBPromptBlocksStorage = MongoDBPromptBlocksStorage;
+exports.MongoDBScorerDefinitionsStorage = MongoDBScorerDefinitionsStorage;
 exports.MongoDBStore = MongoDBStore;
 exports.MongoDBVector = MongoDBVector;
 exports.ObservabilityMongoDB = ObservabilityMongoDB;