@mastra/mongodb 1.5.6 → 1.6.0-alpha.0

package/dist/index.cjs

@@ -14,7 +14,7 @@ var evals = require('@mastra/core/evals');
 
 // package.json
 var package_default = {
-  version: "1.5.6"};
+  version: "1.6.0-alpha.0"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -1700,6 +1700,1357 @@ var MongoDBBlobStore = class _MongoDBBlobStore extends storage.BlobStore {
     };
   }
 };
+var MANAGED_COLLECTIONS = [storage.TABLE_DATASETS, storage.TABLE_DATASET_ITEMS, storage.TABLE_DATASET_VERSIONS];
+var MongoDBDatasetsStorage = class extends storage.DatasetsStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes ?? false;
+    this.#indexes = (config.indexes ?? []).filter(
+      (i) => MANAGED_COLLECTIONS.includes(i.collection)
+    );
+  }
+  getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  // --- Index management ---
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_DATASETS, keys: { id: 1 }, options: { name: "idx_datasets_id", unique: true } },
+      { collection: storage.TABLE_DATASETS, keys: { createdAt: -1, id: 1 }, options: { name: "idx_datasets_createdat_id" } },
+      { collection: storage.TABLE_DATASET_ITEMS, keys: { datasetId: 1 }, options: { name: "idx_dataset_items_datasetid" } },
+      {
+        collection: storage.TABLE_DATASET_ITEMS,
+        keys: { datasetId: 1, validTo: 1 },
+        options: { name: "idx_dataset_items_datasetid_validto" }
+      },
+      {
+        collection: storage.TABLE_DATASET_ITEMS,
+        keys: { datasetId: 1, isDeleted: 1 },
+        options: { name: "idx_dataset_items_datasetid_isdeleted" }
+      },
+      {
+        collection: storage.TABLE_DATASET_ITEMS,
+        keys: { id: 1, validTo: 1 },
+        options: { name: "idx_dataset_items_id_validto" }
+      },
+      {
+        collection: storage.TABLE_DATASET_ITEMS,
+        keys: { datasetId: 1, datasetVersion: 1 },
+        options: { name: "idx_dataset_items_datasetid_version" }
+      },
+      {
+        collection: storage.TABLE_DATASET_ITEMS,
+        keys: { datasetId: 1, validTo: 1, isDeleted: 1, createdAt: -1, id: 1 },
+        options: { name: "idx_dataset_items_list" }
+      },
+      {
+        collection: storage.TABLE_DATASET_VERSIONS,
+        keys: { datasetId: 1 },
+        options: { name: "idx_dataset_versions_datasetid" }
+      },
+      {
+        collection: storage.TABLE_DATASET_VERSIONS,
+        keys: { datasetId: 1, version: 1 },
+        options: { name: "idx_dataset_versions_datasetid_version", unique: true }
+      }
+    ];
+  }
+  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() {
+    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();
+  }
+  // --- Row transformations ---
+  transformDatasetRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description ?? void 0,
+      metadata: typeof row.metadata === "string" ? storage.safelyParseJSON(row.metadata) : row.metadata ?? void 0,
+      inputSchema: typeof row.inputSchema === "string" ? storage.safelyParseJSON(row.inputSchema) : row.inputSchema,
+      groundTruthSchema: typeof row.groundTruthSchema === "string" ? storage.safelyParseJSON(row.groundTruthSchema) : row.groundTruthSchema,
+      requestContextSchema: typeof row.requestContextSchema === "string" ? storage.safelyParseJSON(row.requestContextSchema) : row.requestContextSchema,
+      tags: typeof row.tags === "string" ? storage.safelyParseJSON(row.tags) : row.tags ?? void 0,
+      targetType: row.targetType ?? void 0,
+      targetIds: typeof row.targetIds === "string" ? storage.safelyParseJSON(row.targetIds) : row.targetIds ?? void 0,
+      version: row.version ?? 0,
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt)
+    };
+  }
+  transformItemRow(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId,
+      datasetVersion: row.datasetVersion,
+      input: typeof row.input === "string" ? storage.safelyParseJSON(row.input) : row.input,
+      groundTruth: typeof row.groundTruth === "string" ? storage.safelyParseJSON(row.groundTruth) : row.groundTruth,
+      requestContext: typeof row.requestContext === "string" ? storage.safelyParseJSON(row.requestContext) : row.requestContext,
+      metadata: typeof row.metadata === "string" ? storage.safelyParseJSON(row.metadata) : row.metadata,
+      source: typeof row.source === "string" ? storage.safelyParseJSON(row.source) : row.source,
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt)
+    };
+  }
+  transformItemRowFull(row) {
+    return {
+      ...this.transformItemRow(row),
+      validTo: row.validTo ?? null,
+      isDeleted: row.isDeleted ?? false
+    };
+  }
+  transformDatasetVersionRow(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId,
+      version: row.version,
+      createdAt: storage.ensureDate(row.createdAt)
+    };
+  }
+  // --- Dataset CRUD ---
+  async createDataset(input) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const collection = await this.getCollection(storage.TABLE_DATASETS);
+      const record = {
+        id,
+        name: input.name,
+        description: input.description ?? null,
+        metadata: input.metadata ?? null,
+        inputSchema: input.inputSchema ?? null,
+        groundTruthSchema: input.groundTruthSchema ?? null,
+        requestContextSchema: input.requestContextSchema ?? null,
+        targetType: input.targetType ?? null,
+        targetIds: input.targetIds ?? null,
+        version: 0,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection.insertOne(record);
+      return this.transformDatasetRow(record);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getDatasetById({ id }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_DATASETS);
+      const row = await collection.findOne({ id });
+      return row ? this.transformDatasetRow(row) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doUpdateDataset(args) {
+    try {
+      const existing = await this.getDatasetById({ id: args.id });
+      if (!existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_DATASET", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { datasetId: args.id }
+        });
+      }
+      const collection = await this.getCollection(storage.TABLE_DATASETS);
+      const now = /* @__PURE__ */ new Date();
+      const updateDoc = { updatedAt: now };
+      if (args.name !== void 0) updateDoc.name = args.name;
+      if (args.description !== void 0) updateDoc.description = args.description;
+      if (args.metadata !== void 0) updateDoc.metadata = args.metadata;
+      if (args.inputSchema !== void 0) updateDoc.inputSchema = args.inputSchema;
+      if (args.groundTruthSchema !== void 0) updateDoc.groundTruthSchema = args.groundTruthSchema;
+      if (args.requestContextSchema !== void 0) updateDoc.requestContextSchema = args.requestContextSchema;
+      if (args.tags !== void 0) updateDoc.tags = args.tags;
+      if (args.targetType !== void 0) updateDoc.targetType = args.targetType;
+      if (args.targetIds !== void 0) updateDoc.targetIds = args.targetIds;
+      await collection.updateOne({ id: args.id }, { $set: updateDoc });
+      const updated = await this.getDatasetById({ id: args.id });
+      return updated;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async deleteDataset({ id }) {
+    try {
+      try {
+        const experimentsCollection = await this.getCollection(storage.TABLE_EXPERIMENTS);
+        const experimentIds = await experimentsCollection.find({ datasetId: id }, { projection: { id: 1 } }).toArray();
+        if (experimentIds.length > 0) {
+          const resultsCollection = await this.getCollection(storage.TABLE_EXPERIMENT_RESULTS);
+          await resultsCollection.deleteMany({
+            experimentId: { $in: experimentIds.map((e) => e.id) }
+          });
+        }
+        await experimentsCollection.updateMany({ datasetId: id }, { $set: { datasetId: null, datasetVersion: null } });
+      } catch (e) {
+        const isNamespaceNotFound = e instanceof Error && "code" in e && e.code === 26;
+        if (!isNamespaceNotFound) throw e;
+      }
+      const versionsCollection = await this.getCollection(storage.TABLE_DATASET_VERSIONS);
+      const itemsCollection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
+      const datasetsCollection = await this.getCollection(storage.TABLE_DATASETS);
+      await versionsCollection.deleteMany({ datasetId: id });
+      await itemsCollection.deleteMany({ datasetId: id });
+      await datasetsCollection.deleteOne({ id });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listDatasets(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const collection = await this.getCollection(storage.TABLE_DATASETS);
+      const total = await collection.countDocuments({});
+      if (total === 0) {
+        return { datasets: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      if (perPage === 0) {
+        return { datasets: [], pagination: { total, page, perPage: perPageForResponse, hasMore: total > 0 } };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await collection.find({}).sort({ createdAt: -1, id: 1 }).skip(offset).limit(limitValue).toArray();
+      return {
+        datasets: rows.map((row) => this.transformDatasetRow(row)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + perPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_DATASETS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Item mutations (SCD-2) ---
+  async _doAddItem(args) {
+    try {
+      const id = crypto.randomUUID();
+      const versionId = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      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;
+      await itemsCollection.insertOne({
+        id,
+        datasetId: args.datasetId,
+        datasetVersion: newVersion,
+        validTo: null,
+        isDeleted: false,
+        input: args.input,
+        groundTruth: args.groundTruth ?? 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
+      });
+      return {
+        id,
+        datasetId: args.datasetId,
+        datasetVersion: newVersion,
+        input: args.input,
+        groundTruth: args.groundTruth,
+        requestContext: args.requestContext,
+        metadata: args.metadata,
+        source: args.source,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "ADD_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doUpdateItem(args) {
+    try {
+      const existing = await this.getItemById({ id: args.id });
+      if (!existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_ITEM", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: args.id }
+        });
+      }
+      if (existing.datasetId !== args.datasetId) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_ITEM", "DATASET_MISMATCH"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: args.id, expectedDatasetId: args.datasetId, actualDatasetId: existing.datasetId }
+        });
+      }
+      const hasChanges = args.input !== void 0 || args.groundTruth !== void 0 || args.requestContext !== void 0 || args.metadata !== void 0 || args.source !== void 0;
+      if (!hasChanges) {
+        return existing;
+      }
+      const now = /* @__PURE__ */ new Date();
+      const versionId = crypto.randomUUID();
+      const mergedInput = args.input !== void 0 ? args.input : existing.input;
+      const mergedGroundTruth = args.groundTruth !== void 0 ? args.groundTruth : existing.groundTruth;
+      const mergedRequestContext = args.requestContext !== void 0 ? args.requestContext : existing.requestContext;
+      const mergedMetadata = args.metadata !== void 0 ? args.metadata : existing.metadata;
+      const mergedSource = args.source !== void 0 ? args.source : existing.source;
+      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;
+      await itemsCollection.updateOne(
+        { id: args.id, validTo: null, isDeleted: false },
+        { $set: { validTo: newVersion } }
+      );
+      await itemsCollection.insertOne({
+        id: args.id,
+        datasetId: args.datasetId,
+        datasetVersion: newVersion,
+        validTo: null,
+        isDeleted: false,
+        input: mergedInput,
+        groundTruth: mergedGroundTruth,
+        requestContext: mergedRequestContext,
+        metadata: mergedMetadata,
+        source: mergedSource,
+        createdAt: existing.createdAt,
+        updatedAt: now
+      });
+      await versionsCollection.insertOne({
+        id: versionId,
+        datasetId: args.datasetId,
+        version: newVersion,
+        createdAt: now
+      });
+      return {
+        ...existing,
+        datasetVersion: newVersion,
+        input: mergedInput,
+        groundTruth: mergedGroundTruth,
+        requestContext: mergedRequestContext,
+        metadata: mergedMetadata,
+        source: mergedSource,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doDeleteItem({ id, datasetId }) {
+    try {
+      const existing = await this.getItemById({ id });
+      if (!existing) return;
+      if (existing.datasetId !== datasetId) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "DELETE_ITEM", "DATASET_MISMATCH"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: id, expectedDatasetId: datasetId, actualDatasetId: existing.datasetId }
+        });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const versionId = crypto.randomUUID();
+      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;
+      await itemsCollection.updateOne({ id, validTo: null, isDeleted: false }, { $set: { validTo: newVersion } });
+      await itemsCollection.insertOne({
+        id,
+        datasetId,
+        datasetVersion: newVersion,
+        validTo: null,
+        isDeleted: true,
+        input: existing.input,
+        groundTruth: existing.groundTruth,
+        requestContext: existing.requestContext,
+        metadata: existing.metadata,
+        source: existing.source,
+        createdAt: existing.createdAt,
+        updatedAt: now
+      });
+      await versionsCollection.insertOne({
+        id: versionId,
+        datasetId,
+        version: newVersion,
+        createdAt: now
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Batch operations ---
+  async _doBatchInsertItems(input) {
+    try {
+      const dataset = await this.getDatasetById({ id: input.datasetId });
+      if (!dataset) {
+        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 }
+        });
+      }
+      if (!input.items || input.items.length === 0) {
+        return [];
+      }
+      const now = /* @__PURE__ */ new Date();
+      const versionId = crypto.randomUUID();
+      const itemsWithIds = input.items.map((itemInput) => ({
+        generatedId: crypto.randomUUID(),
+        itemInput
+      }));
+      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;
+      if (itemsWithIds.length > 0) {
+        const docs = itemsWithIds.map(({ generatedId, itemInput }) => ({
+          id: generatedId,
+          datasetId: input.datasetId,
+          datasetVersion: newVersion,
+          validTo: null,
+          isDeleted: false,
+          input: itemInput.input,
+          groundTruth: itemInput.groundTruth ?? null,
+          requestContext: itemInput.requestContext ?? null,
+          metadata: itemInput.metadata ?? null,
+          source: itemInput.source ?? null,
+          createdAt: now,
+          updatedAt: now
+        }));
+        await itemsCollection.insertMany(docs);
+      }
+      await versionsCollection.insertOne({
+        id: versionId,
+        datasetId: input.datasetId,
+        version: newVersion,
+        createdAt: now
+      });
+      return itemsWithIds.map(({ generatedId, itemInput }) => ({
+        id: generatedId,
+        datasetId: input.datasetId,
+        datasetVersion: newVersion,
+        input: itemInput.input,
+        groundTruth: itemInput.groundTruth,
+        requestContext: itemInput.requestContext,
+        metadata: itemInput.metadata,
+        source: itemInput.source,
+        createdAt: now,
+        updatedAt: now
+      }));
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "BULK_ADD_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doBatchDeleteItems(input) {
+    try {
+      const dataset = await this.getDatasetById({ id: input.datasetId });
+      if (!dataset) {
+        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 itemsCollection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
+      const currentRows = await itemsCollection.find({
+        id: { $in: input.itemIds },
+        datasetId: input.datasetId,
+        validTo: null,
+        isDeleted: false
+      }).toArray();
+      const currentItems = currentRows.map((row) => this.transformItemRow(row));
+      if (currentItems.length === 0) return;
+      const now = /* @__PURE__ */ new Date();
+      const versionId = crypto.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 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,
+        validTo: null,
+        isDeleted: true,
+        input: item.input,
+        groundTruth: item.groundTruth,
+        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
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "BULK_DELETE_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- SCD-2 queries ---
+  async getItemById(args) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
+      let row;
+      if (args.datasetVersion !== void 0) {
+        row = await collection.findOne(
+          {
+            id: args.id,
+            datasetVersion: { $lte: args.datasetVersion },
+            $or: [{ validTo: null }, { validTo: { $gt: args.datasetVersion } }],
+            isDeleted: false
+          },
+          { sort: { datasetVersion: -1 } }
+        );
+      } else {
+        row = await collection.findOne({
+          id: args.id,
+          validTo: null,
+          isDeleted: false
+        });
+      }
+      return row ? this.transformItemRow(row) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getItemsByVersion({ datasetId, version }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
+      const rows = await collection.find({
+        datasetId,
+        datasetVersion: { $lte: version },
+        $or: [{ validTo: null }, { validTo: { $gt: version } }],
+        isDeleted: false
+      }).sort({ createdAt: -1, id: 1 }).toArray();
+      return rows.map((row) => this.transformItemRow(row));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_ITEMS_BY_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getItemHistory(itemId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
+      const rows = await collection.find({ id: itemId }).sort({ datasetVersion: -1 }).toArray();
+      return rows.map((row) => this.transformItemRowFull(row));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_ITEM_HISTORY", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listItems(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const collection = await this.getCollection(storage.TABLE_DATASET_ITEMS);
+      const filter = { datasetId: args.datasetId };
+      if (args.version !== void 0) {
+        filter.datasetVersion = { $lte: args.version };
+        filter.$or = [{ validTo: null }, { validTo: { $gt: args.version } }];
+        filter.isDeleted = false;
+      } else {
+        filter.validTo = null;
+        filter.isDeleted = false;
+      }
+      if (args.search) {
+        const escaped = args.search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(escaped, "i");
+        const safeStr = (field) => ({
+          $convert: { input: field, to: "string", onError: "", onNull: "" }
+        });
+        const searchCondition = [{ $expr: { $regexMatch: { input: safeStr("$input"), regex } } }];
+        if (filter.$or) {
+          filter.$and = [{ $or: filter.$or }, { $or: searchCondition }];
+          delete filter.$or;
+        } else {
+          filter.$or = searchCondition;
+        }
+      }
+      const total = await collection.countDocuments(filter);
+      if (total === 0) {
+        return { items: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      if (perPage === 0) {
+        return { items: [], pagination: { total, page, perPage: perPageForResponse, hasMore: total > 0 } };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await collection.find(filter).sort({ createdAt: -1, id: 1 }).skip(offset).limit(limitValue).toArray();
+      return {
+        items: rows.map((row) => this.transformItemRow(row)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + perPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Dataset versions ---
+  async createDatasetVersion(datasetId, version) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const collection = await this.getCollection(storage.TABLE_DATASET_VERSIONS);
+      await collection.insertOne({ id, datasetId, version, createdAt: now });
+      return { id, datasetId, version, createdAt: now };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_DATASET_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listDatasetVersions(input) {
+    try {
+      const { page, perPage: perPageInput } = input.pagination;
+      const collection = await this.getCollection(storage.TABLE_DATASET_VERSIONS);
+      const filter = { datasetId: input.datasetId };
+      const total = await collection.countDocuments(filter);
+      if (total === 0) {
+        return { versions: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      if (perPage === 0) {
+        return { versions: [], pagination: { total, page, perPage: perPageForResponse, hasMore: total > 0 } };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await collection.find(filter).sort({ version: -1 }).skip(offset).limit(limitValue).toArray();
+      return {
+        versions: rows.map((row) => this.transformDatasetVersionRow(row)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + perPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_DATASET_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Clear all ---
+  async dangerouslyClearAll() {
+    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 results = await Promise.allSettled([
+      datasetsCollection.deleteMany({}),
+      itemsCollection.deleteMany({}),
+      versionsCollection.deleteMany({})
+    ]);
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CLEAR_ALL", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { failedCollections: failures.length }
+        },
+        failures[0].reason
+      );
+    }
+  }
+};
+function toDate(value) {
+  if (value instanceof Date) return value;
+  if (typeof value === "string" || typeof value === "number") return new Date(value);
+  return /* @__PURE__ */ new Date();
+}
+function toDateOrNull(value) {
+  if (value === null || value === void 0) return null;
+  return toDate(value);
+}
+function parseJsonField(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") return storage.safelyParseJSON(value);
+  return value;
+}
+function transformExperimentRow(row) {
+  return {
+    id: row.id,
+    name: row.name ?? void 0,
+    description: row.description ?? void 0,
+    metadata: parseJsonField(row.metadata) ?? void 0,
+    datasetId: row.datasetId ?? null,
+    datasetVersion: row.datasetVersion != null ? Number(row.datasetVersion) : null,
+    targetType: row.targetType,
+    targetId: row.targetId,
+    status: row.status,
+    totalItems: Number(row.totalItems ?? 0),
+    succeededCount: Number(row.succeededCount ?? 0),
+    failedCount: Number(row.failedCount ?? 0),
+    skippedCount: Number(row.skippedCount ?? 0),
+    agentVersion: row.agentVersion ?? null,
+    startedAt: toDateOrNull(row.startedAt),
+    completedAt: toDateOrNull(row.completedAt),
+    createdAt: toDate(row.createdAt),
+    updatedAt: toDate(row.updatedAt)
+  };
+}
+function transformExperimentResultRow(row) {
+  return {
+    id: row.id,
+    experimentId: row.experimentId,
+    itemId: row.itemId,
+    itemDatasetVersion: row.itemDatasetVersion != null ? Number(row.itemDatasetVersion) : null,
+    input: parseJsonField(row.input),
+    output: parseJsonField(row.output) ?? null,
+    groundTruth: parseJsonField(row.groundTruth) ?? null,
+    error: parseJsonField(row.error) ?? null,
+    startedAt: toDate(row.startedAt),
+    completedAt: toDate(row.completedAt),
+    retryCount: Number(row.retryCount ?? 0),
+    traceId: row.traceId ?? null,
+    status: row.status ?? null,
+    tags: Array.isArray(row.tags) ? row.tags : parseJsonField(row.tags) ?? null,
+    createdAt: toDate(row.createdAt)
+  };
+}
+var MongoDBExperimentsStorage = class _MongoDBExperimentsStorage extends storage.ExperimentsStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_COLLECTIONS = [storage.TABLE_EXPERIMENTS, storage.TABLE_EXPERIMENT_RESULTS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MongoDBExperimentsStorage.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  // -------------------------------------------------------------------------
+  // Index Management
+  // -------------------------------------------------------------------------
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_EXPERIMENTS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_EXPERIMENTS, keys: { datasetId: 1 } },
+      { collection: storage.TABLE_EXPERIMENTS, keys: { createdAt: -1, id: 1 } },
+      { collection: storage.TABLE_EXPERIMENT_RESULTS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_EXPERIMENT_RESULTS, keys: { experimentId: 1 } },
+      { collection: storage.TABLE_EXPERIMENT_RESULTS, keys: { experimentId: 1, itemId: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_EXPERIMENT_RESULTS, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_EXPERIMENT_RESULTS, keys: { experimentId: 1, startedAt: 1, id: 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();
+  }
+  // -------------------------------------------------------------------------
+  // Experiment CRUD
+  // -------------------------------------------------------------------------
+  async createExperiment(input) {
+    const id = input.id ?? crypto.randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const doc = {
+      id,
+      name: input.name ?? null,
+      description: input.description ?? null,
+      metadata: input.metadata ?? null,
+      datasetId: input.datasetId ?? null,
+      datasetVersion: input.datasetVersion ?? null,
+      targetType: input.targetType,
+      targetId: input.targetId,
+      status: "pending",
+      totalItems: input.totalItems,
+      succeededCount: 0,
+      failedCount: 0,
+      skippedCount: 0,
+      agentVersion: null,
+      startedAt: null,
+      completedAt: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENTS);
+      await collection.insertOne(doc);
+      return {
+        id,
+        name: input.name,
+        description: input.description,
+        metadata: input.metadata,
+        datasetId: input.datasetId ?? null,
+        datasetVersion: input.datasetVersion ?? null,
+        targetType: input.targetType,
+        targetId: input.targetId,
+        status: "pending",
+        totalItems: input.totalItems,
+        succeededCount: 0,
+        failedCount: 0,
+        skippedCount: 0,
+        agentVersion: null,
+        startedAt: null,
+        completedAt: null,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { name: input.name ?? "unnamed" }
+        },
+        error$1
+      );
+    }
+  }
+  async updateExperiment(input) {
+    const updateFields = { updatedAt: /* @__PURE__ */ new Date() };
+    if (input.name !== void 0) updateFields.name = input.name;
+    if (input.description !== void 0) updateFields.description = input.description;
+    if (input.metadata !== void 0) updateFields.metadata = input.metadata;
+    if (input.status !== void 0) updateFields.status = input.status;
+    if (input.totalItems !== void 0) updateFields.totalItems = input.totalItems;
+    if (input.succeededCount !== void 0) updateFields.succeededCount = input.succeededCount;
+    if (input.failedCount !== void 0) updateFields.failedCount = input.failedCount;
+    if (input.skippedCount !== void 0) updateFields.skippedCount = input.skippedCount;
+    if (input.startedAt !== void 0) updateFields.startedAt = input.startedAt;
+    if (input.completedAt !== void 0) updateFields.completedAt = input.completedAt;
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENTS);
+      const result = await collection.updateOne({ id: input.id }, { $set: updateFields });
+      if (result.matchedCount === 0) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_EXPERIMENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { experimentId: input.id }
+        });
+      }
+      const updated = await this.getExperimentById({ id: input.id });
+      return updated;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { experimentId: input.id }
+        },
+        error$1
+      );
+    }
+  }
+  async getExperimentById({ id }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENTS);
+      const doc = await collection.findOne({ id });
+      if (!doc) return null;
+      return transformExperimentRow(doc);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async listExperiments(args) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENTS);
+      const { page, perPage: perPageInput } = args.pagination;
+      const filter = {};
+      if (args.datasetId) {
+        filter.datasetId = args.datasetId;
+      }
+      const total = await collection.countDocuments(filter);
+      if (total === 0) {
+        return { experiments: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const normalizedPerPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, normalizedPerPage);
+      if (normalizedPerPage === 0) {
+        return { experiments: [], pagination: { total, page, perPage: perPageForResponse, hasMore: total > 0 } };
+      }
+      const limitValue = perPageInput === false ? total : normalizedPerPage;
+      const docs = await collection.find(filter).sort({ createdAt: -1, id: 1 }).skip(offset).limit(limitValue).toArray();
+      return {
+        experiments: docs.map((d) => transformExperimentRow(d)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + normalizedPerPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_EXPERIMENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async deleteExperiment({ id }) {
+    try {
+      const resultsCollection = await this.getCollection(storage.TABLE_EXPERIMENT_RESULTS);
+      await resultsCollection.deleteMany({ experimentId: id });
+      const experimentsCollection = await this.getCollection(storage.TABLE_EXPERIMENTS);
+      await experimentsCollection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Experiment Results
+  // -------------------------------------------------------------------------
+  async addExperimentResult(input) {
+    const id = input.id ?? crypto.randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const doc = {
+      id,
+      experimentId: input.experimentId,
+      itemId: input.itemId,
+      itemDatasetVersion: input.itemDatasetVersion ?? null,
+      input: input.input,
+      output: input.output ?? null,
+      groundTruth: input.groundTruth ?? null,
+      error: input.error ?? null,
+      startedAt: input.startedAt,
+      completedAt: input.completedAt,
+      retryCount: input.retryCount,
+      traceId: input.traceId ?? null,
+      status: input.status ?? null,
+      tags: input.tags ?? null,
+      createdAt: now
+    };
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENT_RESULTS);
+      await collection.insertOne(doc);
+      return {
+        id,
+        experimentId: input.experimentId,
+        itemId: input.itemId,
+        itemDatasetVersion: input.itemDatasetVersion ?? null,
+        input: input.input,
+        output: input.output ?? null,
+        groundTruth: input.groundTruth ?? null,
+        error: input.error ?? null,
+        startedAt: input.startedAt,
+        completedAt: input.completedAt,
+        retryCount: input.retryCount,
+        traceId: input.traceId ?? null,
+        status: input.status ?? null,
+        tags: input.tags ?? null,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "ADD_EXPERIMENT_RESULT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { experimentId: input.experimentId }
+        },
+        error$1
+      );
+    }
+  }
+  async updateExperimentResult(input) {
+    const updateFields = {};
+    if (input.status !== void 0) updateFields.status = input.status;
+    if (input.tags !== void 0) updateFields.tags = input.tags;
+    if (Object.keys(updateFields).length === 0) {
+      const existing = await this.getExperimentResultById({ id: input.id });
+      if (!existing || input.experimentId && existing.experimentId !== input.experimentId) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_EXPERIMENT_RESULT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { resultId: input.id }
+        });
+      }
+      return existing;
+    }
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENT_RESULTS);
+      const filter = { id: input.id };
+      if (input.experimentId) {
+        filter.experimentId = input.experimentId;
+      }
+      const result = await collection.findOneAndUpdate(filter, { $set: updateFields }, { returnDocument: "after" });
+      if (!result) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_EXPERIMENT_RESULT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { resultId: input.id }
+        });
+      }
+      return transformExperimentResultRow(result);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_EXPERIMENT_RESULT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resultId: input.id }
+        },
+        error$1
+      );
+    }
+  }
+  async getExperimentResultById({ id }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENT_RESULTS);
+      const doc = await collection.findOne({ id });
+      if (!doc) return null;
+      return transformExperimentResultRow(doc);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_EXPERIMENT_RESULT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async listExperimentResults(args) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENT_RESULTS);
+      const { page, perPage: perPageInput } = args.pagination;
+      const filter = { experimentId: args.experimentId };
+      const total = await collection.countDocuments(filter);
+      if (total === 0) {
+        return { results: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const normalizedPerPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, normalizedPerPage);
+      if (normalizedPerPage === 0) {
+        return { results: [], pagination: { total, page, perPage: perPageForResponse, hasMore: total > 0 } };
+      }
+      const limitValue = perPageInput === false ? total : normalizedPerPage;
+      const docs = await collection.find(filter).sort({ startedAt: 1, id: 1 }).skip(offset).limit(limitValue).toArray();
+      return {
+        results: docs.map((d) => transformExperimentResultRow(d)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + normalizedPerPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_EXPERIMENT_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { experimentId: args.experimentId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteExperimentResults({ experimentId }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_EXPERIMENT_RESULTS);
+      await collection.deleteMany({ experimentId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_EXPERIMENT_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { experimentId }
+        },
+        error$1
+      );
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Cleanup
+  // -------------------------------------------------------------------------
+  async dangerouslyClearAll() {
+    for (const collectionName of _MongoDBExperimentsStorage.MANAGED_COLLECTIONS) {
+      try {
+        const collection = await this.getCollection(collectionName);
+        await collection.deleteMany({});
+      } catch {
+      }
+    }
+  }
+};
 var SNAPSHOT_FIELDS2 = ["name", "description", "servers"];
 var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.MCPClientsStorage {
   #connector;
@@ -8409,6 +9760,8 @@ var MongoDBStore = class extends storage.MastraCompositeStore {
     const workspaces = new MongoDBWorkspacesStorage(domainConfig);
     const skills = new MongoDBSkillsStorage(domainConfig);
     const blobs = new MongoDBBlobStore(domainConfig);
+    const datasets = new MongoDBDatasetsStorage(domainConfig);
+    const experiments = new MongoDBExperimentsStorage(domainConfig);
     this.stores = {
       memory,
       scores,
@@ -8421,7 +9774,9 @@ var MongoDBStore = class extends storage.MastraCompositeStore {
       mcpServers,
       workspaces,
       skills,
-      blobs
+      blobs,
+      datasets,
+      experiments
     };
   }
   /**
@@ -8544,6 +9899,8 @@ exports.MONGODB_PROMPT = MONGODB_PROMPT;
 exports.MemoryStorageMongoDB = MemoryStorageMongoDB;
 exports.MongoDBAgentsStorage = MongoDBAgentsStorage;
 exports.MongoDBBlobStore = MongoDBBlobStore;
+exports.MongoDBDatasetsStorage = MongoDBDatasetsStorage;
+exports.MongoDBExperimentsStorage = MongoDBExperimentsStorage;
 exports.MongoDBMCPClientsStorage = MongoDBMCPClientsStorage;
 exports.MongoDBMCPServersStorage = MongoDBMCPServersStorage;
 exports.MongoDBPromptBlocksStorage = MongoDBPromptBlocksStorage;