@mastra/mongodb 1.11.1 → 1.12.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @mastra/mongodb
 
+## 1.12.0-alpha.1
+
+### Patch Changes
+
+- Fixed `createExperiment` in the MongoDB store persisting `agentVersion` as `null` regardless of the input. `listExperiments` already accepts an `agentVersion` filter, but rows created by this backend would never match it. New experiments now round-trip `agentVersion` end-to-end. ([#18769](https://github.com/mastra-ai/mastra/pull/18769))
+
+- Updated dependencies [[`6a61846`](https://github.com/mastra-ai/mastra/commit/6a61846eeda29fb714549b70f1bee2bf6b141c44)]:
+  - @mastra/core@1.49.0-alpha.4
+
+## 1.12.0-alpha.0
+
+### Minor Changes
+
+- Added storage retention support to MongoDB. When you set a `retention` config, `MongoDBStore` can prune old documents from every growth domain it implements: `memory` (threads, messages, resources by `createdAt`), `observability` (spans by `startedAt`), `scores` (by `createdAt`), `workflows` (run snapshots by `updatedAt`), `backgroundTasks` (by `completedAt`, so in-flight tasks are never pruned), `experiments` (whole runs by `completedAt`, results cascade with their parent — transactional on replica sets), `notifications` (by `createdAt`), and `schedules` fire history (by `actual_fire_at`). ([#18798](https://github.com/mastra-ai/mastra/pull/18798))
+
+  Deletes run in batches via bounded `find(_id)` + `deleteMany` pairs (bounded, resumable, and cancellable) so they stay safe on large collections. Anchor-field indexes are created lazily on the first `prune()` call — never at init — so deployments that don't configure retention pay no extra index overhead. `prune()` only deletes documents; WiredTiger reuses the freed space for subsequent writes.
+
+  ```typescript
+  const storage = new MongoDBStore({
+    id: 'mastra-storage',
+    uri: process.env.MONGODB_URI,
+    dbName: 'mastra',
+    retention: {
+      memory: { messages: { maxAge: '30d' } },
+      observability: { spans: { maxAge: '7d' } },
+    },
+  });
+
+  await storage.prune();
+  ```
+
+### Patch Changes
+
+- Updated dependencies [[`700619b`](https://github.com/mastra-ai/mastra/commit/700619b61d572e592cbaaf758121d168844ca4d2), [`0c3d4bc`](https://github.com/mastra-ai/mastra/commit/0c3d4bcae13ea3699d379403e6f350d5cf4efe9f), [`17369b2`](https://github.com/mastra-ai/mastra/commit/17369b25250561e9ed994ae509be1d15bfb33bcb), [`bcae929`](https://github.com/mastra-ai/mastra/commit/bcae929945cbf265bd9f327cc715ecafa072b5b9), [`b33822e`](https://github.com/mastra-ai/mastra/commit/b33822e8d470884954b02f7b0745407ee4ef74b1), [`d5c11e3`](https://github.com/mastra-ai/mastra/commit/d5c11e3ba5045969caa7272a7bd1fd141c93ab6c), [`ff80671`](https://github.com/mastra-ai/mastra/commit/ff8067185e208b27198b4e5b71803013175c3643), [`dab1257`](https://github.com/mastra-ai/mastra/commit/dab1257b64e4ed576dc5038bb7a3f7072338bc9f), [`705ff39`](https://github.com/mastra-ai/mastra/commit/705ff3969e57214ff2fdaf3815d751dd558886ed), [`e6fbd5b`](https://github.com/mastra-ai/mastra/commit/e6fbd5bfdc28e92c0c0433f29aa1bc152d3430f6), [`6f2026c`](https://github.com/mastra-ai/mastra/commit/6f2026cdf114ff1e21e49133ca774ec7d5085059), [`f890eda`](https://github.com/mastra-ai/mastra/commit/f890eda2c8a2ae83d9b30bc6d85842f93b6c266b)]:
+  - @mastra/core@1.49.0-alpha.3
+
 ## 1.11.1
 
 ### Patch Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-mongodb
 description: Documentation for @mastra/mongodb. Use when working with @mastra/mongodb APIs, configuration, or implementation.
 metadata:
   package: "@mastra/mongodb"
-  version: "1.11.1"
+  version: "1.12.0-alpha.1"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.11.1",
+  "version": "1.12.0-alpha.1",
   "package": "@mastra/mongodb",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-memory-working-memory.md

@@ -1,3 +1,5 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
 # Working Memory
 
 While [message history](https://mastra.ai/docs/memory/message-history) and [semantic recall](https://mastra.ai/docs/memory/semantic-recall) help agents remember conversations, working memory allows them to maintain persistent information about users across interactions.

package/dist/docs/references/docs-rag-retrieval.md

@@ -1,3 +1,5 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
 # Retrieval in RAG systems
 
 After storing embeddings, you need to retrieve relevant chunks to answer user queries.

package/dist/docs/references/docs-rag-vector-databases.md

@@ -1,3 +1,5 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
 # Storing embeddings in a vector database
 
 After generating embeddings, you need to store them in a database that supports vector similarity search. Mastra provides a consistent interface for storing and querying embeddings across various vector databases.

package/dist/docs/references/reference-storage-mongodb.md

@@ -1,3 +1,5 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
 # MongoDB storage
 
 The MongoDB storage implementation provides a scalable storage solution using MongoDB databases with support for both document storage and vector operations.

package/dist/docs/references/reference-vectors-mongodb.md

@@ -1,3 +1,5 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
 # MongoDB vector store
 
 The `MongoDBVector` class provides vector search using [MongoDB Atlas Vector Search](https://www.mongodb.com/docs/atlas/atlas-vector-search/). It enables efficient similarity search and metadata filtering within your MongoDB collections.

package/dist/index.cjs

@@ -15,7 +15,7 @@ var skills = require('@mastra/core/storage/domains/skills');
 
 // package.json
 var package_default = {
-  version: "1.11.1"};
+  version: "1.12.0-alpha.1"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -1621,6 +1621,126 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
     return result;
   }
 };
+var DEFAULT_PRUNE_BATCH_SIZE = 1e3;
+async function ensureAnchorIndex(connector, target, logger) {
+  if (!target.indexed) return;
+  try {
+    const collection = await connector.getCollection(target.table);
+    await collection.createIndex({ [target.column]: -1 });
+  } catch (error) {
+    logger?.warn?.(`Failed to ensure retention index on ${target.table}(${target.column}):`, error);
+  }
+}
+async function sleep(ms, signal) {
+  if (ms <= 0 || signal?.aborted) return;
+  await new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function cutoffFor(policy, encoding, now = Date.now()) {
+  const cutoffMs = now - storage.parseDuration(policy.maxAge);
+  if (encoding === "epoch-ms") return cutoffMs;
+  if (encoding === "iso") return new Date(cutoffMs).toISOString();
+  return new Date(cutoffMs);
+}
+async function pruneCollectionBatch({
+  connector,
+  table,
+  column,
+  cutoff,
+  limit
+}) {
+  const collection = await connector.getCollection(table);
+  const docs = await collection.find({ [column]: { $lt: cutoff } }).project({ _id: 1 }).limit(limit).toArray();
+  if (docs.length === 0) return 0;
+  const result = await collection.deleteMany({ _id: { $in: docs.map((doc) => doc._id) } });
+  return result.deletedCount;
+}
+async function runBatchedDelete({
+  deleteBatch,
+  batchSize,
+  options
+}) {
+  if (!Number.isSafeInteger(batchSize) || batchSize <= 0) {
+    throw new Error(`retention batchSize must be a positive integer; received ${batchSize}`);
+  }
+  let deleted = 0;
+  let batches = 0;
+  while (true) {
+    if (options?.signal?.aborted) return { deleted, done: false };
+    if (options?.maxBatches !== void 0 && batches >= options.maxBatches) return { deleted, done: false };
+    let limit = batchSize;
+    if (options?.maxRows !== void 0) {
+      const remaining = options.maxRows - deleted;
+      if (remaining <= 0) return { deleted, done: false };
+      limit = Math.min(limit, remaining);
+    }
+    const affected = await deleteBatch(limit);
+    deleted += affected;
+    batches += 1;
+    if (affected < limit) return { deleted, done: true };
+    if (options?.pauseMs) {
+      await sleep(options.pauseMs, options.signal);
+    }
+  }
+}
+async function runPrune({
+  connector,
+  domain,
+  targets,
+  options,
+  logger
+}) {
+  const results = [];
+  const now = Date.now();
+  for (const target of targets) {
+    if (options?.signal?.aborted) {
+      results.push({ domain, table: target.table, deleted: 0, done: false });
+      continue;
+    }
+    await ensureAnchorIndex(connector, target, logger);
+    const cutoff = cutoffFor(target.policy, target.encoding, now);
+    const batchSize = target.policy.batchSize ?? DEFAULT_PRUNE_BATCH_SIZE;
+    const { deleted, done } = await runBatchedDelete({
+      deleteBatch: (limit) => pruneCollectionBatch({ connector, table: target.table, column: target.column, cutoff, limit }),
+      batchSize,
+      options
+    });
+    results.push({ domain, table: target.table, deleted, done });
+  }
+  return results;
+}
+function resolveTargets({
+  policies,
+  descriptor,
+  order,
+  encodings
+}) {
+  const targets = [];
+  for (const key of order) {
+    const policy = policies[key];
+    const entry = descriptor[key];
+    if (!policy || !entry) continue;
+    targets.push({
+      table: entry.table,
+      column: entry.column,
+      encoding: encodings?.[key] ?? (entry.anchorType === "epoch-ms" ? "epoch-ms" : "date"),
+      indexed: entry.indexed ?? true,
+      policy
+    });
+  }
+  return targets;
+}
+
+// src/storage/domains/background-tasks/index.ts
 function toDoc(task) {
   return {
     id: task.id,
@@ -1672,6 +1792,14 @@ var BackgroundTasksStorageMongoDB = class _BackgroundTasksStorageMongoDB extends
   #skipDefaultIndexes;
   #indexes;
   static MANAGED_COLLECTIONS = [storage.TABLE_BACKGROUND_TASKS];
+  /**
+   * Anchor is `completedAt`, so age is measured from task completion; it stays
+   * `null` while a task is in-flight, and `null $lt cutoff` never matches, so
+   * pending/running tasks are never pruned regardless of age.
+   */
+  static retentionTables = {
+    backgroundTasks: { table: storage.TABLE_BACKGROUND_TASKS, column: "completedAt", indexed: true }
+  };
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -1683,6 +1811,20 @@ var BackgroundTasksStorageMongoDB = class _BackgroundTasksStorageMongoDB extends
   async getCollection() {
     return this.#connector.getCollection(storage.TABLE_BACKGROUND_TASKS);
   }
+  /**
+   * Delete tasks completed longer ago than the policy's `maxAge`, batched.
+   * `completedAt` is stored as an ISO-8601 string (see `toDoc`), so the cutoff
+   * uses the `iso` encoding — lexicographic `$lt` on ISO strings is time-ordered.
+   */
+  async prune(policies, options) {
+    const targets = resolveTargets({
+      policies,
+      descriptor: _BackgroundTasksStorageMongoDB.retentionTables,
+      order: ["backgroundTasks"],
+      encodings: { backgroundTasks: "iso" }
+    });
+    return runPrune({ connector: this.#connector, domain: "backgroundTasks", targets, options, logger: this.logger });
+  }
   getDefaultIndexDefinitions() {
     return [
       { collection: storage.TABLE_BACKGROUND_TASKS, keys: { id: 1 }, options: { unique: true } },
@@ -3083,6 +3225,15 @@ var MongoDBExperimentsStorage = class _MongoDBExperimentsStorage extends storage
   #skipDefaultIndexes;
   #indexes;
   static MANAGED_COLLECTIONS = [storage.TABLE_EXPERIMENTS, storage.TABLE_EXPERIMENT_RESULTS];
+  /**
+   * Experiments prune as whole units: an experiment and its results are only
+   * deleted together, once the experiment itself is old (anchored on the
+   * parent's `completedAt`, a BSON date that stays `null` while running).
+   * `results` is intentionally not an independent retention key.
+   */
+  static retentionTables = {
+    experiments: { table: storage.TABLE_EXPERIMENTS, column: "completedAt", indexed: true }
+  };
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -3094,6 +3245,57 @@ var MongoDBExperimentsStorage = class _MongoDBExperimentsStorage extends storage
   async getCollection(name) {
     return this.#connector.getCollection(name);
   }
+  /**
+   * Prune whole experiments older than the `experiments` policy's `maxAge`.
+   *
+   * Each batch collects up to `batchSize` aged experiment ids
+   * (`completedAt < cutoff`; BSON type bracketing means `null` — still
+   * running — never matches), then deletes their `experiment_results` rows and
+   * the experiment rows for exactly that id set inside
+   * `connector.withTransaction()` — atomic on replica sets, sequential
+   * children-first on standalone — mirroring `deleteExperiment`. Hitting
+   * `maxBatches`/`maxRows` or the abort signal between batches therefore never
+   * leaves a run hollow (parent kept, results gone). Bounds count whole
+   * experiments, not rows.
+   */
+  async prune(policies, options) {
+    const policy = policies["experiments"];
+    if (!policy || options?.signal?.aborted) {
+      return policy ? [
+        { domain: "experiments", table: storage.TABLE_EXPERIMENT_RESULTS, deleted: 0, done: false },
+        { domain: "experiments", table: storage.TABLE_EXPERIMENTS, deleted: 0, done: false }
+      ] : [];
+    }
+    await ensureAnchorIndex(
+      this.#connector,
+      { table: storage.TABLE_EXPERIMENTS, column: "completedAt", indexed: true },
+      this.logger
+    );
+    const cutoff = cutoffFor(policy, "date");
+    const batchSize = policy.batchSize ?? DEFAULT_PRUNE_BATCH_SIZE;
+    const experimentsCollection = await this.getCollection(storage.TABLE_EXPERIMENTS);
+    const resultsCollection = await this.getCollection(storage.TABLE_EXPERIMENT_RESULTS);
+    let childDeleted = 0;
+    const parent = await runBatchedDelete({
+      deleteBatch: async (limit) => {
+        const docs = await experimentsCollection.find({ completedAt: { $lt: cutoff } }).project({ id: 1 }).limit(limit).toArray();
+        if (docs.length === 0) return 0;
+        const ids = docs.map((doc) => doc.id);
+        return this.#connector.withTransaction(async (session) => {
+          const children = await resultsCollection.deleteMany({ experimentId: { $in: ids } }, { session });
+          childDeleted += children.deletedCount;
+          const parents = await experimentsCollection.deleteMany({ id: { $in: ids } }, { session });
+          return parents.deletedCount;
+        });
+      },
+      batchSize,
+      options
+    });
+    return [
+      { domain: "experiments", table: storage.TABLE_EXPERIMENT_RESULTS, deleted: childDeleted, done: parent.done },
+      { domain: "experiments", table: storage.TABLE_EXPERIMENTS, deleted: parent.deleted, done: parent.done }
+    ];
+  }
   // -------------------------------------------------------------------------
   // Index Management
   // -------------------------------------------------------------------------
@@ -3160,7 +3362,7 @@ var MongoDBExperimentsStorage = class _MongoDBExperimentsStorage extends storage
       succeededCount: 0,
       failedCount: 0,
       skippedCount: 0,
-      agentVersion: null,
+      agentVersion: input.agentVersion ?? null,
       startedAt: null,
       completedAt: null,
       createdAt: now,
@@ -3185,7 +3387,7 @@ var MongoDBExperimentsStorage = class _MongoDBExperimentsStorage extends storage
         succeededCount: 0,
         failedCount: 0,
         skippedCount: 0,
-        agentVersion: null,
+        agentVersion: input.agentVersion ?? null,
         startedAt: null,
         completedAt: null,
         createdAt: now,
@@ -4691,6 +4893,15 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
   #indexes;
   /** Collections managed by this domain */
   static MANAGED_COLLECTIONS = [storage.TABLE_THREADS, storage.TABLE_MESSAGES, storage.TABLE_RESOURCES, OM_TABLE];
+  /**
+   * Retention-eligible collections. The observational-memory collection is
+   * excluded: it has no timestamp anchor to age on. All anchors are BSON dates.
+   */
+  static retentionTables = {
+    messages: { table: storage.TABLE_MESSAGES, column: "createdAt", indexed: true },
+    resources: { table: storage.TABLE_RESOURCES, column: "createdAt", indexed: true },
+    threads: { table: storage.TABLE_THREADS, column: "createdAt", indexed: true }
+  };
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -4706,6 +4917,21 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
     await this.createDefaultIndexes();
     await this.createCustomIndexes();
   }
+  /**
+   * Delete memory rows older than each table's `maxAge`, batched. Order is
+   * messages → resources → threads so child rows never outlive the delete of
+   * their thread. Like `deleteThread()`, this does not sweep vector-store
+   * embeddings — semantic-recall vectors live in a separate vector store the
+   * memory domain cannot reach; cleaning those up is the operator's concern.
+   */
+  async prune(policies, options) {
+    const targets = resolveTargets({
+      policies,
+      descriptor: _MemoryStorageMongoDB.retentionTables,
+      order: ["messages", "resources", "threads"]
+    });
+    return runPrune({ connector: this.#connector, domain: "memory", targets, options, logger: this.logger });
+  }
   /**
    * Returns default index definitions for the memory domain collections.
    */
@@ -6659,6 +6885,10 @@ var NotificationsMongoDB = class _NotificationsMongoDB extends storage.Notificat
   #skipDefaultIndexes;
   #indexes;
   static MANAGED_COLLECTIONS = [storage.TABLE_NOTIFICATIONS];
+  /** Anchor is the notification's creation time, stored as a BSON date. */
+  static retentionTables = {
+    notifications: { table: storage.TABLE_NOTIFICATIONS, column: "createdAt", indexed: true }
+  };
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -6670,6 +6900,15 @@ var NotificationsMongoDB = class _NotificationsMongoDB extends storage.Notificat
   async getCollection() {
     return this.#connector.getCollection(storage.TABLE_NOTIFICATIONS);
   }
+  /** Delete notifications older than the policy's `maxAge`, batched. */
+  async prune(policies, options) {
+    const targets = resolveTargets({
+      policies,
+      descriptor: _NotificationsMongoDB.retentionTables,
+      order: ["notifications"]
+    });
+    return runPrune({ connector: this.#connector, domain: "notifications", targets, options, logger: this.logger });
+  }
   async init() {
     await this.createDefaultIndexes();
     await this.createCustomIndexes();
@@ -6862,6 +7101,10 @@ var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.Observabi
   #indexes;
   /** Collections managed by this domain */
   static MANAGED_COLLECTIONS = [storage.TABLE_SPANS];
+  /** Anchor is the span's start time, stored as a BSON date. */
+  static retentionTables = {
+    spans: { table: storage.TABLE_SPANS, column: "startedAt", indexed: true }
+  };
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -6873,6 +7116,15 @@ var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.Observabi
   async getCollection(name) {
     return this.#connector.getCollection(name);
   }
+  /** Delete spans older than the `spans` policy's `maxAge`, batched. */
+  async prune(policies, options) {
+    const targets = resolveTargets({
+      policies,
+      descriptor: _ObservabilityMongoDB.retentionTables,
+      order: ["spans"]
+    });
+    return runPrune({ connector: this.#connector, domain: "observability", targets, options, logger: this.logger });
+  }
   /**
    * Returns default index definitions for the observability domain collections.
    * These indexes optimize common query patterns for span and trace lookups.
@@ -8287,6 +8539,16 @@ var SchedulesMongoDB = class _SchedulesMongoDB extends storage.SchedulesStorage
   #skipDefaultIndexes;
   #indexes;
   static MANAGED_COLLECTIONS = [storage.TABLE_SCHEDULES, storage.TABLE_SCHEDULE_TRIGGERS];
+  /**
+   * Only trigger (fire-history) rows are retention-eligible — schedule
+   * definitions are config, not growth. Anchor `actual_fire_at` is stored as a
+   * raw epoch-ms number, so `anchorType: 'epoch-ms'` keeps the cutoff numeric.
+   * The default composite index `(schedule_id, actual_fire_at)` can't serve a
+   * bare `actual_fire_at` range scan, hence the lazy single-field anchor index.
+   */
+  static retentionTables = {
+    triggers: { table: storage.TABLE_SCHEDULE_TRIGGERS, column: "actual_fire_at", anchorType: "epoch-ms", indexed: true }
+  };
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -8301,6 +8563,15 @@ var SchedulesMongoDB = class _SchedulesMongoDB extends storage.SchedulesStorage
   getTriggersCollection() {
     return this.#connector.getCollection(storage.TABLE_SCHEDULE_TRIGGERS);
   }
+  /** Delete trigger (fire-history) rows older than the `triggers` policy's `maxAge`, batched. */
+  async prune(policies, options) {
+    const targets = resolveTargets({
+      policies,
+      descriptor: _SchedulesMongoDB.retentionTables,
+      order: ["triggers"]
+    });
+    return runPrune({ connector: this.#connector, domain: "schedules", targets, options, logger: this.logger });
+  }
   getDefaultIndexDefinitions() {
     return [
       { collection: storage.TABLE_SCHEDULES, keys: { id: 1 }, options: { unique: true } },
@@ -9004,6 +9275,10 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends storage.ScoresSto
   #indexes;
   /** Collections managed by this domain */
   static MANAGED_COLLECTIONS = [storage.TABLE_SCORERS];
+  /** Anchor is the score row's creation time, stored as a BSON date. */
+  static retentionTables = {
+    scorers: { table: storage.TABLE_SCORERS, column: "createdAt", indexed: true }
+  };
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -9015,6 +9290,15 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends storage.ScoresSto
   async getCollection(name) {
     return this.#connector.getCollection(name);
   }
+  /** Delete scorer results older than the `scorers` policy's `maxAge`, batched. */
+  async prune(policies, options) {
+    const targets = resolveTargets({
+      policies,
+      descriptor: _ScoresStorageMongoDB.retentionTables,
+      order: ["scorers"]
+    });
+    return runPrune({ connector: this.#connector, domain: "scores", targets, options, logger: this.logger });
+  }
   /**
    * Returns default index definitions for the scores domain collections.
    * These indexes optimize common query patterns for score lookups.
@@ -9982,6 +10266,13 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.Wor
   #indexes;
   /** Collections managed by this domain */
   static MANAGED_COLLECTIONS = [storage.TABLE_WORKFLOW_SNAPSHOT];
+  /**
+   * Anchor is `updatedAt` (BSON date), so the policy reads as inactivity:
+   * a run is pruned only after its snapshot has not been touched for `maxAge`.
+   */
+  static retentionTables = {
+    workflowSnapshot: { table: storage.TABLE_WORKFLOW_SNAPSHOT, column: "updatedAt", indexed: true }
+  };
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -9990,6 +10281,15 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.Wor
       (idx) => _WorkflowsStorageMongoDB.MANAGED_COLLECTIONS.includes(idx.collection)
     );
   }
+  /** Delete workflow snapshots idle for longer than the policy's `maxAge`, batched. */
+  async prune(policies, options) {
+    const targets = resolveTargets({
+      policies,
+      descriptor: _WorkflowsStorageMongoDB.retentionTables,
+      order: ["workflowSnapshot"]
+    });
+    return runPrune({ connector: this.#connector, domain: "workflows", targets, options, logger: this.logger });
+  }
   supportsConcurrentUpdates() {
     return true;
   }
@@ -10997,7 +11297,7 @@ var MongoDBStore = class extends storage.MastraCompositeStore {
   #connector;
   stores;
   constructor(config) {
-    super({ id: config.id, name: "MongoDBStore", disableInit: config.disableInit });
+    super({ id: config.id, name: "MongoDBStore", disableInit: config.disableInit, retention: config.retention });
     this.#connector = resolveMongoDBConfig(config);
     const domainConfig = {
       connector: this.#connector,