@mastra/mongodb 1.11.0 → 1.11.1-alpha.0

package/dist/index.cjs

@@ -15,7 +15,7 @@ var skills = require('@mastra/core/storage/domains/skills');
 
 // package.json
 var package_default = {
-  version: "1.11.0"};
+  version: "1.11.1-alpha.0"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -112,7 +112,6 @@ var MongoDBVector = class extends vector.MastraVector {
   embeddingFieldName;
   metadataFieldName = "metadata";
   documentFieldName = "document";
-  collectionForValidation = null;
   mongoMetricMap = {
     cosine: "cosine",
     euclidean: "euclidean",
@@ -164,6 +163,17 @@ var MongoDBVector = class extends vector.MastraVector {
       );
     }
   }
+  /**
+   * Creates a MongoDB collection and the Atlas Search indexes that back a
+   * Mastra index with the given name.
+   *
+   * **Async index lifecycle:** Atlas Search indexes transition through
+   * PENDING → BUILDING → READY after this method returns. If you need to
+   * `upsert` or `query` immediately after calling `createIndex`, call
+   * `waitForIndexReady({ indexName })` first to block until the index is
+   * queryable. Skipping that step on a real Atlas cluster may cause
+   * "index not found" or "index not ready" errors on subsequent operations.
+   */
   async createIndex({ indexName, dimension, metric = "cosine" }) {
     let mongoMetric;
     try {
@@ -211,6 +221,10 @@ var MongoDBVector = class extends vector.MastraVector {
             {
               type: "filter",
               path: "_id"
+            },
+            {
+              type: "filter",
+              path: "document"
             }
           ]
         },
@@ -238,21 +252,6 @@ var MongoDBVector = class extends vector.MastraVector {
         );
       }
     }
-    try {
-      await collection?.updateOne({ _id: "__index_metadata__" }, { $set: { dimension, metric } }, { upsert: true });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("MONGODB", "CREATE_INDEX", "STORE_METADATA_FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName
-          }
-        },
-        error$1
-      );
-    }
   }
   /**
    * Waits for the index to be ready.
@@ -281,12 +280,25 @@ var MongoDBVector = class extends vector.MastraVector {
     }
     throw new Error(`Index "${indexNameInternal}" did not become ready within timeout`);
   }
+  /**
+   * Inserts or updates vectors in the specified index.
+   *
+   * @param indexName - Name of the index (MongoDB collection) to write into.
+   * @param vectors - Array of embedding vectors. Each must have the same
+   *   dimension as declared when the index was created.
+   * @param metadata - Optional array of metadata objects, one per vector,
+   *   stored in a nested `metadata` field alongside the embedding.
+   * @param ids - Optional string IDs for each vector, used as the MongoDB
+   *   document `_id`. Auto-generated UUIDs are used when omitted.
+   * @param documents - Optional text strings associated with each vector,
+   *   stored in a `document` field.
+   * @returns The IDs of the upserted vectors in input order.
+   */
   async upsert({ indexName, vectors, metadata, ids, documents }) {
     vector.validateUpsertInput("MONGODB", vectors, metadata, ids);
     vector.validateVectorValues("MONGODB", vectors);
     try {
       const collection = await this.getCollection(indexName);
-      this.collectionForValidation = collection;
       const stats = await this.describeIndex({ indexName });
       await this.validateVectorDimensions(vectors, stats.dimension);
       const generatedIds = ids || vectors.map(() => uuid.v4());
@@ -333,13 +345,30 @@ var MongoDBVector = class extends vector.MastraVector {
       );
     }
   }
+  /**
+   * Runs an approximate nearest-neighbor search against the specified index.
+   *
+   * @param indexName - Name of the index (MongoDB collection) to search.
+   * @param queryVector - The query embedding. Must match the index dimension.
+   * @param topK - Maximum number of results to return (default: 10).
+   * @param filter - Optional metadata filter. Fields are matched against the
+   *   nested `metadata` subdocument; no `metadata.` prefix is needed.
+   * @param includeVector - When true, each result includes the stored embedding
+   *   in a `vector` field (default: false).
+   * @param documentFilter - Optional filter applied to the `document` text
+   *   field, independent of `filter`.
+   * @param numCandidates - HNSW candidate pool size. Higher values improve
+   *   recall at the cost of latency. Defaults to 20 * topK, capped at 10000.
+   * @returns Array of results ordered by descending similarity score.
+   */
   async query({
     indexName,
     queryVector,
     topK = 10,
     filter,
     includeVector = false,
-    documentFilter
+    documentFilter,
+    numCandidates
   }) {
     if (!queryVector) {
       throw new error.MastraError({
@@ -353,36 +382,21 @@ var MongoDBVector = class extends vector.MastraVector {
     try {
       const collection = await this.getCollection(indexName, true);
       const indexNameInternal = `${indexName}_vector_index`;
-      const mongoFilter = this.transformFilter(filter);
-      const documentMongoFilter = documentFilter ? { [this.documentFieldName]: documentFilter } : {};
-      const transformedMongoFilter = this.transformMetadataFilter(mongoFilter);
-      let combinedFilter = {};
-      if (Object.keys(transformedMongoFilter).length > 0 && Object.keys(documentMongoFilter).length > 0) {
-        combinedFilter = { $and: [transformedMongoFilter, documentMongoFilter] };
-      } else if (Object.keys(transformedMongoFilter).length > 0) {
-        combinedFilter = transformedMongoFilter;
-      } else if (Object.keys(documentMongoFilter).length > 0) {
-        combinedFilter = documentMongoFilter;
-      }
+      const metadataFilter = this.transformMetadataFilter(this.transformFilter(filter));
+      const hasMetadataFilter = Object.keys(metadataFilter).length > 0;
       const vectorSearch = {
         index: indexNameInternal,
         queryVector,
         path: this.embeddingFieldName,
-        numCandidates: Math.min(1e4, Math.max(100, topK)),
+        numCandidates: Math.min(1e4, Math.max(topK, numCandidates ?? topK * 20)),
         limit: Math.min(1e4, topK)
       };
-      if (Object.keys(combinedFilter).length > 0) {
-        const filterWithExclusion = {
-          $and: [{ _id: { $ne: "__index_metadata__" } }, combinedFilter]
-        };
-        const candidateIds = await collection.aggregate([{ $match: filterWithExclusion }, { $project: { _id: 1 } }]).map((doc) => doc._id).toArray();
-        if (candidateIds.length > 0) {
-          vectorSearch.filter = { _id: { $in: candidateIds } };
-        } else {
-          return [];
-        }
-      } else {
-        vectorSearch.filter = { _id: { $ne: "__index_metadata__" } };
+      if (hasMetadataFilter) {
+        const candidateIds = await collection.aggregate([{ $match: metadataFilter }, { $project: { _id: 1 } }]).map((doc) => doc._id).toArray();
+        if (candidateIds.length === 0) return [];
+        vectorSearch.filter = documentFilter ? { $and: [{ _id: { $in: candidateIds } }, { [this.documentFieldName]: documentFilter }] } : { _id: { $in: candidateIds } };
+      } else if (documentFilter) {
+        vectorSearch.filter = { [this.documentFieldName]: documentFilter };
       }
       const pipeline = [
         {
@@ -448,23 +462,44 @@ var MongoDBVector = class extends vector.MastraVector {
     try {
       const collection = await this.getCollection(indexName, true);
       const count = await collection.countDocuments({ _id: { $ne: "__index_metadata__" } });
-      const metadataDoc = await collection.findOne({ _id: "__index_metadata__" });
-      const dimension = metadataDoc?.dimension || 0;
-      const metric = metadataDoc?.metric || "cosine";
-      return {
-        dimension,
-        count,
-        metric
+      const indexNameInternal = `${indexName}_vector_index`;
+      const indexInfo = await collection.listSearchIndexes().toArray();
+      const indexData = indexInfo.find((idx) => idx.name === indexNameInternal);
+      if (!indexData) {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("MONGODB", "DESCRIBE_INDEX", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName },
+          text: `Atlas Search index "${indexNameInternal}" does not exist on collection "${indexName}". The collection may predate Mastra or the index may have been dropped externally.`
+        });
+      }
+      const vectorField = indexData.latestDefinition?.fields?.find((f) => f.type === "vector");
+      if (!vectorField) {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("MONGODB", "DESCRIBE_INDEX", "INVALID"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName },
+          text: `Atlas Search index "${indexNameInternal}" exists but has no vector field. The index may have been created outside of Mastra or without vector configuration.`
+        });
+      }
+      const dimension = vectorField.numDimensions;
+      const reverseMetricMap = {
+        cosine: "cosine",
+        euclidean: "euclidean",
+        dotProduct: "dotproduct"
       };
+      const metric = reverseMetricMap[vectorField.similarity] ?? "cosine";
+      return { dimension, count, metric };
     } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
           id: storage.createVectorErrorId("MONGODB", "DESCRIBE_INDEX", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName
-          }
+          details: { indexName }
         },
         error$1
       );
@@ -671,10 +706,7 @@ var MongoDBVector = class extends vector.MastraVector {
             text: "Filter produced empty query"
           });
         }
-        const finalFilter = {
-          $and: [{ _id: { $ne: "__index_metadata__" } }, transformedFilter]
-        };
-        await collection.deleteMany(finalFilter);
+        await collection.deleteMany(transformedFilter);
       }
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) {
@@ -695,7 +727,26 @@ var MongoDBVector = class extends vector.MastraVector {
       );
     }
   }
-  // Private methods
+  /**
+   * Returns the MongoDB Collection that backs the given Mastra index.
+   *
+   * **Index vs. collection:** In this driver, each Mastra index is stored as a
+   * MongoDB collection whose name equals the index name. The Atlas Vector Search
+   * index (named `${indexName}_vector_index`) lives on that collection. The two
+   * terms are distinct: "index" is the Mastra concept; "collection" is the
+   * MongoDB storage primitive that implements it.
+   *
+   * **Caching:** Collection handles are cached on first successful lookup to
+   * avoid redundant `listCollections` round-trips. Only handles for collections
+   * that actually exist are cached; a handle for a missing collection is returned
+   * without being cached so the next call re-checks existence rather than
+   * returning a stale phantom.
+   *
+   * @param indexName - Mastra index name, which is also the MongoDB collection name.
+   * @param throwIfNotExists - When `true` (default), throws if no MongoDB
+   *   collection exists for this index name. Pass `false` when absence is not an
+   *   error (e.g., inside `deleteIndex`).
+   */
   async getCollection(indexName, throwIfNotExists = true) {
     if (this.collections.has(indexName)) {
       return this.collections.get(indexName);
@@ -703,9 +754,13 @@ var MongoDBVector = class extends vector.MastraVector {
     const collection = this.db.collection(indexName);
     const collectionExists = await this.db.listCollections({ name: indexName }).hasNext();
     if (!collectionExists && throwIfNotExists) {
-      throw new Error(`Index (Collection) "${indexName}" does not exist`);
+      throw new Error(
+        `Mastra index "${indexName}" has no backing MongoDB collection. Call createIndex first, or verify the collection was not dropped externally.`
+      );
+    }
+    if (collectionExists) {
+      this.collections.set(indexName, collection);
     }
-    this.collections.set(indexName, collection);
     return collection;
   }
   async validateVectorDimensions(vectors, dimension) {
@@ -714,7 +769,6 @@ var MongoDBVector = class extends vector.MastraVector {
     }
     if (dimension === 0) {
       dimension = vectors[0] ? vectors[0].length : 0;
-      await this.setIndexDimension(dimension);
     }
     for (let i = 0; i < vectors.length; i++) {
       let v = vectors[i]?.length;
@@ -723,10 +777,6 @@ var MongoDBVector = class extends vector.MastraVector {
       }
     }
   }
-  async setIndexDimension(dimension) {
-    const collection = this.collectionForValidation;
-    await collection.updateOne({ _id: "__index_metadata__" }, { $set: { dimension } }, { upsert: true });
-  }
   transformFilter(filter) {
     const translator = new MongoDBFilterTranslator();
     if (!filter) return {};
@@ -756,12 +806,7 @@ var MongoDBVector = class extends vector.MastraVector {
           transformed[key] = value;
         }
       } else if (key.startsWith("metadata.")) {
-        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-          const hasOperator = Object.keys(value).some((k) => k.startsWith("$"));
-          transformed[key] = hasOperator ? value : value;
-        } else {
-          transformed[key] = value;
-        }
+        transformed[key] = value;
       } else if (this.isMetadataField(key)) {
         transformed[`metadata.${key}`] = value;
       } else {
@@ -788,6 +833,7 @@ var MongoDBConnector = class _MongoDBConnector {
   #handler;
   #isConnected;
   #db;
+  #supportsTransactions;
   constructor(options) {
     this.#client = options.client;
     this.#dbName = options.dbName;
@@ -844,6 +890,50 @@ var MongoDBConnector = class _MongoDBConnector {
     const db = await this.getConnection();
     return db.collection(collectionName);
   }
+  /**
+   * Returns true when the deployment supports multi-document transactions
+   * (replica set or sharded cluster). Standalone servers and custom connector
+   * handlers return false. Probed once and cached.
+   */
+  async supportsTransactions() {
+    if (this.#supportsTransactions !== void 0) {
+      return this.#supportsTransactions;
+    }
+    if (!this.#client) {
+      this.#supportsTransactions = false;
+      return false;
+    }
+    try {
+      const db = await this.getConnection();
+      const hello = await db.admin().command({ hello: 1 });
+      this.#supportsTransactions = Boolean(hello.setName) || hello.msg === "isdbgrid";
+      return this.#supportsTransactions;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Runs `fn` inside a transaction when the deployment supports it, passing the
+   * session so callers can scope each operation with `{ session }`. On a
+   * standalone server (or custom handler) it degrades to running `fn` directly
+   * with an undefined session — best-effort sequential, no atomicity.
+   */
+  async withTransaction(fn) {
+    const supported = await this.supportsTransactions();
+    if (!supported || !this.#client) {
+      return fn(void 0);
+    }
+    const session = this.#client.startSession();
+    try {
+      let result;
+      await session.withTransaction(async () => {
+        result = await fn(session);
+      });
+      return result;
+    } finally {
+      await session.endSession();
+    }
+  }
   async close() {
     if (this.#client) {
       await this.#client.close();
@@ -1079,16 +1169,23 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
         createdAt: now,
         updatedAt: now
       };
-      await collection.insertOne(this.serializeAgent(newAgent));
       const { id: _id, authorId: _authorId, visibility: _visibility, metadata: _metadata, ...snapshotConfig } = agent;
       const versionId = crypto$1.randomUUID();
-      await this.createVersion({
+      const versionDoc = {
         id: versionId,
         agentId: agent.id,
         versionNumber: 1,
-        ...snapshotConfig,
         changedFields: Object.keys(snapshotConfig),
-        changeMessage: "Initial version"
+        changeMessage: "Initial version",
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      for (const field of SNAPSHOT_FIELDS) {
+        if (snapshotConfig[field] !== void 0) versionDoc[field] = snapshotConfig[field];
+      }
+      await this.#connector.withTransaction(async (session) => {
+        await collection.insertOne(this.serializeAgent(newAgent), { session });
+        const versionsCol = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+        await versionsCol.insertOne(versionDoc, { session });
       });
       return newAgent;
     } catch (error$1) {
@@ -1173,9 +1270,12 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
   }
   async delete(id) {
     try {
-      await this.deleteVersionsByParentId(id);
-      const collection = await this.getCollection(storage.TABLE_AGENTS);
-      await collection.deleteOne({ id });
+      await this.#connector.withTransaction(async (session) => {
+        const versionsCol = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+        await versionsCol.deleteMany({ agentId: id }, { session });
+        const col = await this.getCollection(storage.TABLE_AGENTS);
+        await col.deleteOne({ id }, { session });
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -2241,45 +2341,56 @@ var MongoDBDatasetsStorage = class extends storage.DatasetsStorage {
       const datasetsCollection = await this.getCollection(storage.TABLE_DATASETS);
       const itemsCollection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
       const versionsCollection = await this.getCollection(storage.TABLE_DATASET_VERSIONS);
-      const result = await datasetsCollection.findOneAndUpdate(
-        { id: args.datasetId },
-        { $inc: { version: 1 } },
-        { returnDocument: "after" }
-      );
-      if (!result) {
-        throw new error.MastraError({
-          id: storage.createStorageErrorId("MONGODB", "ADD_ITEM", "DATASET_NOT_FOUND"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { datasetId: args.datasetId }
-        });
-      }
-      const newVersion = result.version;
-      const organizationId = result.organizationId ?? null;
-      const projectId = result.projectId ?? null;
-      await itemsCollection.insertOne({
-        id,
-        datasetId: args.datasetId,
-        datasetVersion: newVersion,
-        organizationId,
-        projectId,
-        validTo: null,
-        isDeleted: false,
-        input: args.input,
-        groundTruth: args.groundTruth ?? null,
-        expectedTrajectory: args.expectedTrajectory ?? null,
-        toolMocks: args.toolMocks ?? null,
-        requestContext: args.requestContext ?? null,
-        metadata: args.metadata ?? null,
-        source: args.source ?? null,
-        createdAt: now,
-        updatedAt: now
-      });
-      await versionsCollection.insertOne({
-        id: versionId,
-        datasetId: args.datasetId,
-        version: newVersion,
-        createdAt: now
+      let newVersion = 0;
+      let organizationId = null;
+      let projectId = null;
+      await this.#connector.withTransaction(async (session) => {
+        const result = await datasetsCollection.findOneAndUpdate(
+          { id: args.datasetId },
+          { $inc: { version: 1 } },
+          { session, returnDocument: "after" }
+        );
+        if (!result) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "ADD_ITEM", "DATASET_NOT_FOUND"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { datasetId: args.datasetId }
+          });
+        }
+        newVersion = result.version;
+        organizationId = result.organizationId ?? null;
+        projectId = result.projectId ?? null;
+        await itemsCollection.insertOne(
+          {
+            id,
+            datasetId: args.datasetId,
+            datasetVersion: newVersion,
+            organizationId,
+            projectId,
+            validTo: null,
+            isDeleted: false,
+            input: args.input,
+            groundTruth: args.groundTruth ?? null,
+            expectedTrajectory: args.expectedTrajectory ?? null,
+            toolMocks: args.toolMocks ?? null,
+            requestContext: args.requestContext ?? null,
+            metadata: args.metadata ?? null,
+            source: args.source ?? null,
+            createdAt: now,
+            updatedAt: now
+          },
+          { session }
+        );
+        await versionsCollection.insertOne(
+          {
+            id: versionId,
+            datasetId: args.datasetId,
+            version: newVersion,
+            createdAt: now
+          },
+          { session }
+        );
       });
       return {
         id,
@@ -2344,49 +2455,61 @@ var MongoDBDatasetsStorage = class extends storage.DatasetsStorage {
       const datasetsCollection = await this.getCollection(storage.TABLE_DATASETS);
       const itemsCollection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
       const versionsCollection = await this.getCollection(storage.TABLE_DATASET_VERSIONS);
-      const result = await datasetsCollection.findOneAndUpdate(
-        { id: args.datasetId },
-        { $inc: { version: 1 } },
-        { returnDocument: "after" }
-      );
-      if (!result) {
-        throw new error.MastraError({
-          id: storage.createStorageErrorId("MONGODB", "UPDATE_ITEM", "DATASET_NOT_FOUND"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { datasetId: args.datasetId }
-        });
-      }
-      const newVersion = result.version;
-      const parentOrganizationId = result.organizationId ?? null;
-      const parentProjectId = result.projectId ?? null;
-      await itemsCollection.updateOne(
-        { id: args.id, validTo: null, isDeleted: false },
-        { $set: { validTo: newVersion } }
-      );
-      await itemsCollection.insertOne({
-        id: args.id,
-        datasetId: args.datasetId,
-        datasetVersion: newVersion,
-        organizationId: parentOrganizationId,
-        projectId: parentProjectId,
-        validTo: null,
-        isDeleted: false,
-        input: mergedInput,
-        groundTruth: mergedGroundTruth,
-        expectedTrajectory: mergedExpectedTrajectory ?? null,
-        toolMocks: mergedToolMocks ?? null,
-        requestContext: mergedRequestContext,
-        metadata: mergedMetadata,
-        source: mergedSource,
-        createdAt: existing.createdAt,
-        updatedAt: now
-      });
-      await versionsCollection.insertOne({
-        id: versionId,
-        datasetId: args.datasetId,
-        version: newVersion,
-        createdAt: now
+      let newVersion = 0;
+      let parentOrganizationId = null;
+      let parentProjectId = null;
+      await this.#connector.withTransaction(async (session) => {
+        const result = await datasetsCollection.findOneAndUpdate(
+          { id: args.datasetId },
+          { $inc: { version: 1 } },
+          { session, returnDocument: "after" }
+        );
+        if (!result) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "UPDATE_ITEM", "DATASET_NOT_FOUND"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { datasetId: args.datasetId }
+          });
+        }
+        newVersion = result.version;
+        parentOrganizationId = result.organizationId ?? null;
+        parentProjectId = result.projectId ?? null;
+        await itemsCollection.updateOne(
+          { id: args.id, validTo: null, isDeleted: false },
+          { $set: { validTo: newVersion } },
+          { session }
+        );
+        await itemsCollection.insertOne(
+          {
+            id: args.id,
+            datasetId: args.datasetId,
+            datasetVersion: newVersion,
+            organizationId: parentOrganizationId,
+            projectId: parentProjectId,
+            validTo: null,
+            isDeleted: false,
+            input: mergedInput,
+            groundTruth: mergedGroundTruth,
+            expectedTrajectory: mergedExpectedTrajectory ?? null,
+            toolMocks: mergedToolMocks ?? null,
+            requestContext: mergedRequestContext,
+            metadata: mergedMetadata,
+            source: mergedSource,
+            createdAt: existing.createdAt,
+            updatedAt: now
+          },
+          { session }
+        );
+        await versionsCollection.insertOne(
+          {
+            id: versionId,
+            datasetId: args.datasetId,
+            version: newVersion,
+            createdAt: now
+          },
+          { session }
+        );
       });
       return {
         ...existing,
@@ -2431,46 +2554,58 @@ var MongoDBDatasetsStorage = class extends storage.DatasetsStorage {
       const datasetsCollection = await this.getCollection(storage.TABLE_DATASETS);
       const itemsCollection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
       const versionsCollection = await this.getCollection(storage.TABLE_DATASET_VERSIONS);
-      const result = await datasetsCollection.findOneAndUpdate(
-        { id: datasetId },
-        { $inc: { version: 1 } },
-        { returnDocument: "after" }
-      );
-      if (!result) {
-        throw new error.MastraError({
-          id: storage.createStorageErrorId("MONGODB", "DELETE_ITEM", "DATASET_NOT_FOUND"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { datasetId }
-        });
-      }
-      const newVersion = result.version;
-      const parentOrganizationId = result.organizationId ?? null;
-      const parentProjectId = result.projectId ?? null;
-      await itemsCollection.updateOne({ id, validTo: null, isDeleted: false }, { $set: { validTo: newVersion } });
-      await itemsCollection.insertOne({
-        id,
-        datasetId,
-        datasetVersion: newVersion,
-        organizationId: parentOrganizationId,
-        projectId: parentProjectId,
-        validTo: null,
-        isDeleted: true,
-        input: existing.input,
-        groundTruth: existing.groundTruth,
-        expectedTrajectory: existing.expectedTrajectory ?? null,
-        toolMocks: existing.toolMocks ?? null,
-        requestContext: existing.requestContext,
-        metadata: existing.metadata,
-        source: existing.source,
-        createdAt: existing.createdAt,
-        updatedAt: now
-      });
-      await versionsCollection.insertOne({
-        id: versionId,
-        datasetId,
-        version: newVersion,
-        createdAt: now
+      await this.#connector.withTransaction(async (session) => {
+        const result = await datasetsCollection.findOneAndUpdate(
+          { id: datasetId },
+          { $inc: { version: 1 } },
+          { session, returnDocument: "after" }
+        );
+        if (!result) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "DELETE_ITEM", "DATASET_NOT_FOUND"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { datasetId }
+          });
+        }
+        const newVersion = result.version;
+        const parentOrganizationId = result.organizationId ?? null;
+        const parentProjectId = result.projectId ?? null;
+        await itemsCollection.updateOne(
+          { id, validTo: null, isDeleted: false },
+          { $set: { validTo: newVersion } },
+          { session }
+        );
+        await itemsCollection.insertOne(
+          {
+            id,
+            datasetId,
+            datasetVersion: newVersion,
+            organizationId: parentOrganizationId,
+            projectId: parentProjectId,
+            validTo: null,
+            isDeleted: true,
+            input: existing.input,
+            groundTruth: existing.groundTruth,
+            expectedTrajectory: existing.expectedTrajectory ?? null,
+            toolMocks: existing.toolMocks ?? null,
+            requestContext: existing.requestContext,
+            metadata: existing.metadata,
+            source: existing.source,
+            createdAt: existing.createdAt,
+            updatedAt: now
+          },
+          { session }
+        );
+        await versionsCollection.insertOne(
+          {
+            id: versionId,
+            datasetId,
+            version: newVersion,
+            createdAt: now
+          },
+          { session }
+        );
       });
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
@@ -2508,23 +2643,26 @@ var MongoDBDatasetsStorage = class extends storage.DatasetsStorage {
       const datasetsCollection = await this.getCollection(storage.TABLE_DATASETS);
       const itemsCollection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
       const versionsCollection = await this.getCollection(storage.TABLE_DATASET_VERSIONS);
-      const result = await datasetsCollection.findOneAndUpdate(
-        { id: input.datasetId },
-        { $inc: { version: 1 } },
-        { returnDocument: "after" }
-      );
-      if (!result) {
-        throw new error.MastraError({
-          id: storage.createStorageErrorId("MONGODB", "BULK_ADD_ITEMS", "DATASET_NOT_FOUND"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { datasetId: input.datasetId }
-        });
-      }
-      const newVersion = result.version;
-      const organizationId = result.organizationId ?? null;
-      const projectId = result.projectId ?? null;
-      if (itemsWithIds.length > 0) {
+      let newVersion = 0;
+      let organizationId = null;
+      let projectId = null;
+      await this.#connector.withTransaction(async (session) => {
+        const result = await datasetsCollection.findOneAndUpdate(
+          { id: input.datasetId },
+          { $inc: { version: 1 } },
+          { session, returnDocument: "after" }
+        );
+        if (!result) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "BULK_ADD_ITEMS", "DATASET_NOT_FOUND"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { datasetId: input.datasetId }
+          });
+        }
+        newVersion = result.version;
+        organizationId = result.organizationId ?? null;
+        projectId = result.projectId ?? null;
         const docs = itemsWithIds.map(({ generatedId, itemInput }) => ({
           id: generatedId,
           datasetId: input.datasetId,
@@ -2543,13 +2681,16 @@ var MongoDBDatasetsStorage = class extends storage.DatasetsStorage {
           createdAt: now,
           updatedAt: now
         }));
-        await itemsCollection.insertMany(docs);
-      }
-      await versionsCollection.insertOne({
-        id: versionId,
-        datasetId: input.datasetId,
-        version: newVersion,
-        createdAt: now
+        await itemsCollection.insertMany(docs, { session });
+        await versionsCollection.insertOne(
+          {
+            id: versionId,
+            datasetId: input.datasetId,
+            version: newVersion,
+            createdAt: now
+          },
+          { session }
+        );
       });
       return itemsWithIds.map(({ generatedId, itemInput }) => ({
         id: generatedId,
@@ -2603,51 +2744,57 @@ var MongoDBDatasetsStorage = class extends storage.DatasetsStorage {
       const versionId = crypto$1.randomUUID();
       const datasetsCollection = await this.getCollection(storage.TABLE_DATASETS);
       const versionsCollection = await this.getCollection(storage.TABLE_DATASET_VERSIONS);
-      const result = await datasetsCollection.findOneAndUpdate(
-        { id: input.datasetId },
-        { $inc: { version: 1 } },
-        { returnDocument: "after" }
-      );
-      if (!result) {
-        throw new error.MastraError({
-          id: storage.createStorageErrorId("MONGODB", "BULK_DELETE_ITEMS", "DATASET_NOT_FOUND"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { datasetId: input.datasetId }
-        });
-      }
-      const newVersion = result.version;
-      const parentOrganizationId = result.organizationId ?? null;
-      const parentProjectId = result.projectId ?? null;
       const currentIds = currentItems.map((i) => i.id);
-      await itemsCollection.updateMany(
-        { id: { $in: currentIds }, validTo: null, isDeleted: false },
-        { $set: { validTo: newVersion } }
-      );
-      const tombstones = currentItems.map((item) => ({
-        id: item.id,
-        datasetId: input.datasetId,
-        datasetVersion: newVersion,
-        organizationId: parentOrganizationId,
-        projectId: parentProjectId,
-        validTo: null,
-        isDeleted: true,
-        input: item.input,
-        groundTruth: item.groundTruth,
-        expectedTrajectory: item.expectedTrajectory ?? null,
-        toolMocks: item.toolMocks ?? null,
-        requestContext: item.requestContext,
-        metadata: item.metadata,
-        source: item.source,
-        createdAt: item.createdAt,
-        updatedAt: now
-      }));
-      await itemsCollection.insertMany(tombstones);
-      await versionsCollection.insertOne({
-        id: versionId,
-        datasetId: input.datasetId,
-        version: newVersion,
-        createdAt: now
+      await this.#connector.withTransaction(async (session) => {
+        const result = await datasetsCollection.findOneAndUpdate(
+          { id: input.datasetId },
+          { $inc: { version: 1 } },
+          { session, returnDocument: "after" }
+        );
+        if (!result) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "BULK_DELETE_ITEMS", "DATASET_NOT_FOUND"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { datasetId: input.datasetId }
+          });
+        }
+        const newVersion = result.version;
+        const parentOrganizationId = result.organizationId ?? null;
+        const parentProjectId = result.projectId ?? null;
+        const tombstones = currentItems.map((item) => ({
+          id: item.id,
+          datasetId: input.datasetId,
+          datasetVersion: newVersion,
+          organizationId: parentOrganizationId,
+          projectId: parentProjectId,
+          validTo: null,
+          isDeleted: true,
+          input: item.input,
+          groundTruth: item.groundTruth,
+          expectedTrajectory: item.expectedTrajectory ?? null,
+          toolMocks: item.toolMocks ?? null,
+          requestContext: item.requestContext,
+          metadata: item.metadata,
+          source: item.source,
+          createdAt: item.createdAt,
+          updatedAt: now
+        }));
+        await itemsCollection.updateMany(
+          { id: { $in: currentIds }, validTo: null, isDeleted: false },
+          { $set: { validTo: newVersion } },
+          { session }
+        );
+        await itemsCollection.insertMany(tombstones, { session });
+        await versionsCollection.insertOne(
+          {
+            id: versionId,
+            datasetId: input.datasetId,
+            version: newVersion,
+            createdAt: now
+          },
+          { session }
+        );
       });
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
@@ -3546,27 +3693,27 @@ var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.M
         createdAt: now,
         updatedAt: now
       };
-      await collection.insertOne(this.serializeMCPClient(newMCPClient));
       const snapshotConfig = {};
       for (const field of SNAPSHOT_FIELDS2) {
-        if (mcpClient[field] !== void 0) {
-          snapshotConfig[field] = mcpClient[field];
-        }
+        if (mcpClient[field] !== void 0) snapshotConfig[field] = mcpClient[field];
       }
       const versionId = crypto$1.randomUUID();
-      try {
-        await this.createVersion({
-          id: versionId,
-          mcpClientId: mcpClient.id,
-          versionNumber: 1,
-          ...snapshotConfig,
-          changedFields: Object.keys(snapshotConfig),
-          changeMessage: "Initial version"
-        });
-      } catch (versionError) {
-        await collection.deleteOne({ id: mcpClient.id });
-        throw versionError;
+      const versionDoc = {
+        id: versionId,
+        mcpClientId: mcpClient.id,
+        versionNumber: 1,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version",
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      for (const field of SNAPSHOT_FIELDS2) {
+        if (snapshotConfig[field] !== void 0) versionDoc[field] = snapshotConfig[field];
       }
+      await this.#connector.withTransaction(async (session) => {
+        await collection.insertOne(this.serializeMCPClient(newMCPClient), { session });
+        const versionsCol = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+        await versionsCol.insertOne(versionDoc, { session });
+      });
       return newMCPClient;
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) {
@@ -3646,9 +3793,12 @@ var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.M
   }
   async delete(id) {
     try {
-      await this.deleteVersionsByParentId(id);
-      const collection = await this.getCollection(storage.TABLE_MCP_CLIENTS);
-      await collection.deleteOne({ id });
+      await this.#connector.withTransaction(async (session) => {
+        const versionsCol = await this.getCollection(storage.TABLE_MCP_CLIENT_VERSIONS);
+        await versionsCol.deleteMany({ mcpClientId: id }, { session });
+        const col = await this.getCollection(storage.TABLE_MCP_CLIENTS);
+        await col.deleteOne({ id }, { session });
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -4098,7 +4248,6 @@ var MongoDBMCPServersStorage = class _MongoDBMCPServersStorage extends storage.M
         createdAt: now,
         updatedAt: now
       };
-      await collection.insertOne(this.serializeMCPServer(newMCPServer));
       const snapshotConfig = {};
       for (const field of SNAPSHOT_FIELDS3) {
         if (mcpServer[field] !== void 0) {
@@ -4106,19 +4255,22 @@ var MongoDBMCPServersStorage = class _MongoDBMCPServersStorage extends storage.M
         }
       }
       const versionId = crypto$1.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;
+      const versionDoc = {
+        id: versionId,
+        mcpServerId: mcpServer.id,
+        versionNumber: 1,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version",
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      for (const field of SNAPSHOT_FIELDS3) {
+        if (snapshotConfig[field] !== void 0) versionDoc[field] = snapshotConfig[field];
       }
+      await this.#connector.withTransaction(async (session) => {
+        await collection.insertOne(this.serializeMCPServer(newMCPServer), { session });
+        const versionsCol = await this.getCollection(storage.TABLE_MCP_SERVER_VERSIONS);
+        await versionsCol.insertOne(versionDoc, { session });
+      });
       return newMCPServer;
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) {
@@ -4198,9 +4350,12 @@ var MongoDBMCPServersStorage = class _MongoDBMCPServersStorage extends storage.M
   }
   async delete(id) {
     try {
-      await this.deleteVersionsByParentId(id);
-      const collection = await this.getCollection(storage.TABLE_MCP_SERVERS);
-      await collection.deleteOne({ id });
+      await this.#connector.withTransaction(async (session) => {
+        const versionsCol = await this.getCollection(storage.TABLE_MCP_SERVER_VERSIONS);
+        await versionsCol.deleteMany({ mcpServerId: id }, { session });
+        const col = await this.getCollection(storage.TABLE_MCP_SERVERS);
+        await col.deleteOne({ id }, { session });
+      });
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
@@ -4556,24 +4711,24 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
    */
   getDefaultIndexDefinitions() {
     return [
-      // Threads collection indexes
+      // Threads: point lookups (id) + resource-scoped listing sorted by createdAt or updatedAt.
+      // A single descending compound serves both ASC and DESC sorts, and its resourceId prefix
+      // covers resourceId-only filters. Unfiltered (no resourceId) listing is a rare admin path
+      // left to an in-memory sort rather than carrying standalone single-field sort indexes.
       { collection: storage.TABLE_THREADS, keys: { id: 1 }, options: { unique: true } },
-      { collection: storage.TABLE_THREADS, keys: { resourceId: 1 } },
-      { collection: storage.TABLE_THREADS, keys: { createdAt: -1 } },
-      { collection: storage.TABLE_THREADS, keys: { updatedAt: -1 } },
-      // Messages collection indexes
+      { collection: storage.TABLE_THREADS, keys: { resourceId: 1, createdAt: -1 } },
+      { collection: storage.TABLE_THREADS, keys: { resourceId: 1, updatedAt: -1 } },
+      // Messages: point lookups (id) + per-thread retrieval (listMessages) and per-resource
+      // retrieval (listMessagesByResourceId), both sorted by createdAt. The compound prefixes
+      // cover thread_id-only and resourceId-only filters.
       { collection: storage.TABLE_MESSAGES, keys: { id: 1 }, options: { unique: true } },
-      { collection: storage.TABLE_MESSAGES, keys: { thread_id: 1 } },
-      { collection: storage.TABLE_MESSAGES, keys: { resourceId: 1 } },
-      { collection: storage.TABLE_MESSAGES, keys: { createdAt: -1 } },
       { collection: storage.TABLE_MESSAGES, keys: { thread_id: 1, createdAt: 1 } },
-      // Resources collection indexes
+      { collection: storage.TABLE_MESSAGES, keys: { resourceId: 1, createdAt: 1 } },
+      // Resources: only ever fetched by id.
       { collection: storage.TABLE_RESOURCES, keys: { id: 1 }, options: { unique: true } },
-      { collection: storage.TABLE_RESOURCES, keys: { createdAt: -1 } },
-      { collection: storage.TABLE_RESOURCES, keys: { updatedAt: -1 } },
-      // Observational Memory collection indexes
+      // Observational Memory: point lookups (id) + latest-generation-per-lookupKey. The compound
+      // prefix covers lookupKey-only filters.
       { collection: OM_TABLE, keys: { id: 1 }, options: { unique: true } },
-      { collection: OM_TABLE, keys: { lookupKey: 1 } },
       { collection: OM_TABLE, keys: { lookupKey: 1, generationCount: -1 } }
     ];
   }
@@ -4588,8 +4743,17 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
       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);
+      } catch (error$1) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("MONGODB", "CREATE_DEFAULT_INDEXES", "FAILED"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            text: `Failed to create default index on collection "${indexDef.collection}". Set skipDefaultIndexes to manage indexes yourself.`,
+            details: { collection: indexDef.collection }
+          },
+          error$1
+        );
       }
     }
   }
@@ -4610,13 +4774,17 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
     }
   }
   async dangerouslyClearAll() {
-    const threadsCollection = await this.getCollection(storage.TABLE_THREADS);
-    const messagesCollection = await this.getCollection(storage.TABLE_MESSAGES);
-    const resourcesCollection = await this.getCollection(storage.TABLE_RESOURCES);
+    const [threadsCollection, messagesCollection, resourcesCollection, omCollection] = await Promise.all([
+      this.getCollection(storage.TABLE_THREADS),
+      this.getCollection(storage.TABLE_MESSAGES),
+      this.getCollection(storage.TABLE_RESOURCES),
+      this.getCollection(OM_TABLE)
+    ]);
     await Promise.all([
       threadsCollection.deleteMany({}),
       messagesCollection.deleteMany({}),
-      resourcesCollection.deleteMany({})
+      resourcesCollection.deleteMany({}),
+      omCollection.deleteMany({})
     ]);
   }
   parseRow(row) {
@@ -4990,10 +5158,14 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
           }
         };
       });
-      await Promise.all([
-        collection.bulkWrite(messagesToInsert),
-        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
-      ]);
+      const allThreadIds = new Set(messages.map((m) => m.threadId));
+      const now = /* @__PURE__ */ new Date();
+      await this.#connector.withTransaction(async (session) => {
+        await collection.bulkWrite(messagesToInsert, { session });
+        for (const tid of allThreadIds) {
+          await threadsCollection.updateOne({ id: tid }, { $set: { updatedAt: now } }, { session });
+        }
+      });
       const list = new agent.MessageList().add(messages, "memory");
       return { messages: list.get.all.db() };
     } catch (error$1) {
@@ -5112,10 +5284,7 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
       await collection.updateOne(
         { id: resource.id },
         {
-          $set: {
-            ...resource,
-            metadata: JSON.stringify(resource.metadata)
-          }
+          $set: { ...resource }
         },
         { upsert: true }
       );
@@ -5161,7 +5330,7 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
         updateDoc.workingMemory = workingMemory;
       }
       if (metadata) {
-        updateDoc.metadata = JSON.stringify(updatedResource.metadata);
+        updateDoc.metadata = updatedResource.metadata;
       }
       await collection.updateOne({ id: resourceId }, { $set: updateDoc });
       return updatedResource;
@@ -7406,9 +7575,13 @@ Note: This migration may take some time for large collections.
       });
       if (records.length > 0) {
         const collection = await this.getCollection(storage.TABLE_SPANS);
-        await collection.insertMany(records);
+        await collection.insertMany(records, { ordered: false });
       }
     } catch (error$1) {
+      if (error$1 instanceof mongodb.MongoBulkWriteError) {
+        const writeErrors = Array.isArray(error$1.writeErrors) ? error$1.writeErrors : [error$1.writeErrors];
+        if (writeErrors.length > 0 && writeErrors.every((e) => e.code === 11e3)) return;
+      }
       throw new error.MastraError(
         {
           id: storage.createStorageErrorId("MONGODB", "BATCH_CREATE_SPANS", "FAILED"),
@@ -7608,7 +7781,6 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
         createdAt: now,
         updatedAt: now
       };
-      await collection.insertOne(this.serializeBlock(newBlock));
       const snapshotConfig = {};
       for (const field of SNAPSHOT_FIELDS4) {
         if (promptBlock[field] !== void 0) {
@@ -7616,13 +7788,21 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
         }
       }
       const versionId = crypto$1.randomUUID();
-      await this.createVersion({
+      const versionDoc = {
         id: versionId,
         blockId: promptBlock.id,
         versionNumber: 1,
-        ...snapshotConfig,
         changedFields: Object.keys(snapshotConfig),
-        changeMessage: "Initial version"
+        changeMessage: "Initial version",
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      for (const field of SNAPSHOT_FIELDS4) {
+        if (snapshotConfig[field] !== void 0) versionDoc[field] = snapshotConfig[field];
+      }
+      await this.#connector.withTransaction(async (session) => {
+        await collection.insertOne(this.serializeBlock(newBlock), { session });
+        const versionsCol = await this.getCollection(storage.TABLE_PROMPT_BLOCK_VERSIONS);
+        await versionsCol.insertOne(versionDoc, { session });
       });
       return newBlock;
     } catch (error$1) {
@@ -7703,9 +7883,12 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
   }
   async delete(id) {
     try {
-      await this.deleteVersionsByParentId(id);
-      const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCKS);
-      await collection.deleteOne({ id });
+      await this.#connector.withTransaction(async (session) => {
+        const versionsCol = await this.getCollection(storage.TABLE_PROMPT_BLOCK_VERSIONS);
+        await versionsCol.deleteMany({ blockId: id }, { session });
+        const col = await this.getCollection(storage.TABLE_PROMPT_BLOCKS);
+        await col.deleteOne({ id }, { session });
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -8225,10 +8408,12 @@ var SchedulesMongoDB = class _SchedulesMongoDB extends storage.SchedulesStorage
     return result.matchedCount > 0;
   }
   async deleteSchedule(id) {
-    const triggers = await this.getTriggersCollection();
-    await triggers.deleteMany({ schedule_id: id });
-    const schedules = await this.getSchedulesCollection();
-    await schedules.deleteOne({ id });
+    await this.#connector.withTransaction(async (session) => {
+      const triggers = await this.getTriggersCollection();
+      await triggers.deleteMany({ schedule_id: id }, { session });
+      const schedules = await this.getSchedulesCollection();
+      await schedules.deleteOne({ id }, { session });
+    });
   }
   async recordTrigger(trigger) {
     const collection = await this.getTriggersCollection();
@@ -8375,7 +8560,6 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
         createdAt: now,
         updatedAt: now
       };
-      await collection.insertOne(this.serializeScorerDefinition(newScorerDefinition));
       const snapshotConfig = {};
       for (const field of SNAPSHOT_FIELDS5) {
         if (scorerDefinition[field] !== void 0) {
@@ -8383,13 +8567,21 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
         }
       }
       const versionId = crypto$1.randomUUID();
-      await this.createVersion({
+      const versionDoc = {
         id: versionId,
         scorerDefinitionId: scorerDefinition.id,
         versionNumber: 1,
-        ...snapshotConfig,
         changedFields: Object.keys(snapshotConfig),
-        changeMessage: "Initial version"
+        changeMessage: "Initial version",
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      for (const field of SNAPSHOT_FIELDS5) {
+        if (snapshotConfig[field] !== void 0) versionDoc[field] = snapshotConfig[field];
+      }
+      await this.#connector.withTransaction(async (session) => {
+        await collection.insertOne(this.serializeScorerDefinition(newScorerDefinition), { session });
+        const versionsCol = await this.getCollection(storage.TABLE_SCORER_DEFINITION_VERSIONS);
+        await versionsCol.insertOne(versionDoc, { session });
       });
       return newScorerDefinition;
     } catch (error$1) {
@@ -8470,9 +8662,12 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
   }
   async delete(id) {
     try {
-      await this.deleteVersionsByParentId(id);
-      const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITIONS);
-      await collection.deleteOne({ id });
+      await this.#connector.withTransaction(async (session) => {
+        const versionsCol = await this.getCollection(storage.TABLE_SCORER_DEFINITION_VERSIONS);
+        await versionsCol.deleteMany({ scorerDefinitionId: id }, { session });
+        const col = await this.getCollection(storage.TABLE_SCORER_DEFINITIONS);
+        await col.deleteOne({ id }, { session });
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -9294,27 +9489,27 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends storage.SkillsSto
         createdAt: now,
         updatedAt: now
       };
-      await collection.insertOne(this.serializeSkill(newSkill));
       const snapshotConfig = {};
       for (const field of SNAPSHOT_FIELDS6) {
-        if (skill[field] !== void 0) {
-          snapshotConfig[field] = skill[field];
-        }
+        if (skill[field] !== void 0) snapshotConfig[field] = skill[field];
       }
       const versionId = crypto$1.randomUUID();
-      try {
-        await this.createVersion({
-          id: versionId,
-          skillId: id,
-          versionNumber: 1,
-          ...snapshotConfig,
-          changedFields: Object.keys(snapshotConfig),
-          changeMessage: "Initial version"
-        });
-      } catch (versionError) {
-        await collection.deleteOne({ id });
-        throw versionError;
+      const versionDoc = {
+        id: versionId,
+        skillId: id,
+        versionNumber: 1,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version",
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      for (const field of SNAPSHOT_FIELDS6) {
+        if (snapshotConfig[field] !== void 0) versionDoc[field] = snapshotConfig[field];
       }
+      await this.#connector.withTransaction(async (session) => {
+        await collection.insertOne(this.serializeSkill(newSkill), { session });
+        const versionsCol = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+        await versionsCol.insertOne(versionDoc, { session });
+      });
       return newSkill;
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) {
@@ -9360,6 +9555,18 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends storage.SkillsSto
           configFields[field] = updates[field];
         }
       }
+      if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
+      if (metadataFields.visibility !== void 0) updateDoc.visibility = metadataFields.visibility;
+      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;
+      }
+      let newVersionDoc = null;
       if (Object.keys(configFields).length > 0) {
         const latestVersion = await this.getLatestVersion(id);
         if (!latestVersion) {
@@ -9379,29 +9586,28 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends storage.SkillsSto
           )
         );
         if (changedFields.length > 0) {
-          await this.createVersion({
+          const mergedSnapshot = { ...existingSnapshot, ...configFields };
+          newVersionDoc = {
             id: crypto$1.randomUUID(),
             skillId: id,
             versionNumber: latestVersion.versionNumber + 1,
-            ...existingSnapshot,
-            ...configFields,
             changedFields,
-            changeMessage: `Updated: ${changedFields.join(", ")}`
-          });
+            changeMessage: `Updated: ${changedFields.join(", ")}`,
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          for (const field of SNAPSHOT_FIELDS6) {
+            if (mergedSnapshot[field] !== void 0) newVersionDoc[field] = mergedSnapshot[field];
+          }
         }
       }
-      if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
-      if (metadataFields.visibility !== void 0) updateDoc.visibility = metadataFields.visibility;
-      if (metadataFields.activeVersionId !== void 0) {
-        updateDoc.activeVersionId = metadataFields.activeVersionId;
-        if (metadataFields.status === void 0) {
-          updateDoc.status = "published";
+      await this.#connector.withTransaction(async (session) => {
+        if (newVersionDoc) {
+          const versionsCol = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+          await versionsCol.insertOne(newVersionDoc, { session });
         }
-      }
-      if (metadataFields.status !== void 0) {
-        updateDoc.status = metadataFields.status;
-      }
-      await collection.updateOne({ id }, { $set: updateDoc });
+        const col = await this.getCollection(storage.TABLE_SKILLS);
+        await col.updateOne({ id }, { $set: updateDoc }, { session });
+      });
       const updatedSkill = await collection.findOne({ id });
       if (!updatedSkill) {
         throw new error.MastraError({
@@ -9430,9 +9636,12 @@ var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends storage.SkillsSto
   }
   async delete(id) {
     try {
-      await this.deleteVersionsByParentId(id);
-      const collection = await this.getCollection(storage.TABLE_SKILLS);
-      await collection.deleteOne({ id });
+      await this.#connector.withTransaction(async (session) => {
+        const versionsCol = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+        await versionsCol.deleteMany({ skillId: id }, { session });
+        const col = await this.getCollection(storage.TABLE_SKILLS);
+        await col.deleteOne({ id }, { session });
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -9922,16 +10131,10 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.Wor
     try {
       const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
       const updatedDoc = await collection.findOneAndUpdate(
-        {
-          workflow_name: workflowName,
-          run_id: runId,
-          // Only update if snapshot exists and has context
-          "snapshot.context": { $exists: true }
-        },
+        { workflow_name: workflowName, run_id: runId },
         [
           {
             $set: {
-              // Merge the new options into the existing snapshot
               snapshot: {
                 $mergeObjects: ["$snapshot", opts]
               },
@@ -9945,8 +10148,18 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.Wor
         return void 0;
       }
       const snapshot = typeof updatedDoc.snapshot === "string" ? JSON.parse(updatedDoc.snapshot) : updatedDoc.snapshot;
+      if (!snapshot?.context) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_WORKFLOW_STATE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `Snapshot not found for runId ${runId}`,
+          details: { workflowName, runId }
+        });
+      }
       return snapshot;
     } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
           id: storage.createStorageErrorId("MONGODB", "UPDATE_WORKFLOW_STATE", "FAILED"),
@@ -10290,27 +10503,27 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends storage.W
         createdAt: now,
         updatedAt: now
       };
-      await collection.insertOne(this.serializeWorkspace(newWorkspace));
       const snapshotConfig = {};
       for (const field of SNAPSHOT_FIELDS7) {
-        if (workspace[field] !== void 0) {
-          snapshotConfig[field] = workspace[field];
-        }
+        if (workspace[field] !== void 0) snapshotConfig[field] = workspace[field];
       }
       const versionId = crypto$1.randomUUID();
-      try {
-        await this.createVersion({
-          id: versionId,
-          workspaceId: id,
-          versionNumber: 1,
-          ...snapshotConfig,
-          changedFields: Object.keys(snapshotConfig),
-          changeMessage: "Initial version"
-        });
-      } catch (versionError) {
-        await collection.deleteOne({ id });
-        throw versionError;
+      const versionDoc = {
+        id: versionId,
+        workspaceId: id,
+        versionNumber: 1,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version",
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      for (const field of SNAPSHOT_FIELDS7) {
+        if (snapshotConfig[field] !== void 0) versionDoc[field] = snapshotConfig[field];
       }
+      await this.#connector.withTransaction(async (session) => {
+        await collection.insertOne(this.serializeWorkspace(newWorkspace), { session });
+        const versionsCol = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+        await versionsCol.insertOne(versionDoc, { session });
+      });
       return newWorkspace;
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) {
@@ -10356,6 +10569,7 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends storage.W
           configFields[field] = updates[field];
         }
       }
+      let newVersionDoc = null;
       if (Object.keys(configFields).length > 0) {
         const latestVersion = await this.getLatestVersion(id);
         if (!latestVersion) {
@@ -10368,15 +10582,18 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends storage.W
           });
         }
         const existingSnapshot = this.extractSnapshotFields(latestVersion);
-        await this.createVersion({
+        const mergedSnapshot = { ...existingSnapshot, ...configFields };
+        newVersionDoc = {
           id: crypto$1.randomUUID(),
           workspaceId: id,
           versionNumber: latestVersion.versionNumber + 1,
-          ...existingSnapshot,
-          ...configFields,
           changedFields: Object.keys(configFields),
-          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
-        });
+          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        for (const field of SNAPSHOT_FIELDS7) {
+          if (mergedSnapshot[field] !== void 0) newVersionDoc[field] = mergedSnapshot[field];
+        }
       }
       if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
       if (metadataFields.activeVersionId !== void 0) {
@@ -10392,7 +10609,23 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends storage.W
         const existingMetadata = existingWorkspace.metadata || {};
         updateDoc.metadata = { ...existingMetadata, ...metadataFields.metadata };
       }
-      await collection.updateOne({ id }, { $set: updateDoc });
+      await this.#connector.withTransaction(async (session) => {
+        if (newVersionDoc) {
+          const versionsCol = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+          await versionsCol.insertOne(newVersionDoc, { session });
+        }
+        const col = await this.getCollection(storage.TABLE_WORKSPACES);
+        const updateResult = await col.updateOne({ id }, { $set: updateDoc }, { session });
+        if (updateResult.matchedCount === 0) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "UPDATE_WORKSPACE", "NOT_FOUND_AFTER_UPDATE"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.SYSTEM,
+            text: `Workspace with id ${id} was deleted during update`,
+            details: { id }
+          });
+        }
+      });
       const updatedWorkspace = await collection.findOne({ id });
       if (!updatedWorkspace) {
         throw new error.MastraError({
@@ -10421,9 +10654,12 @@ var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends storage.W
   }
   async delete(id) {
     try {
-      await this.deleteVersionsByParentId(id);
-      const collection = await this.getCollection(storage.TABLE_WORKSPACES);
-      await collection.deleteOne({ id });
+      await this.#connector.withTransaction(async (session) => {
+        const versionsCol = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+        await versionsCol.deleteMany({ workspaceId: id }, { session });
+        const col = await this.getCollection(storage.TABLE_WORKSPACES);
+        await col.deleteOne({ id }, { session });
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {