@mastra/mongodb 1.3.1 → 1.4.0-alpha.0

package/dist/index.cjs

@@ -14,7 +14,7 @@ var evals = require('@mastra/core/evals');
 
 // package.json
 var package_default = {
-  version: "1.3.1"};
+  version: "1.4.0-alpha.0"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -910,7 +910,10 @@ var SNAPSHOT_FIELDS = [
   "memory",
   "scorers",
   "mcpClients",
-  "requestContextSchema"
+  "requestContextSchema",
+  "workspace",
+  "skills",
+  "skillsFormat"
 ];
 var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsStorage {
   #connector;
@@ -1109,46 +1112,16 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       const metadataFields = {
         authorId: updates.authorId,
         activeVersionId: updates.activeVersionId,
-        metadata: updates.metadata
+        metadata: updates.metadata,
+        status: updates.status
       };
-      const configFields = {};
-      for (const field of SNAPSHOT_FIELDS) {
-        if (updates[field] !== void 0) {
-          configFields[field] = updates[field];
-        }
-      }
-      if (Object.keys(configFields).length > 0) {
-        const latestVersion = await this.getLatestVersion(id);
-        const nextVersionNumber = latestVersion ? latestVersion.versionNumber + 1 : 1;
-        if (!latestVersion) {
-          throw new error.MastraError({
-            id: storage.createStorageErrorId("MONGODB", "UPDATE_AGENT", "NO_VERSION"),
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            text: `Cannot update config fields for agent ${id} - no versions exist`,
-            details: { id }
-          });
-        }
-        const sanitizedConfigFields = Object.fromEntries(
-          Object.entries(configFields).map(([key, value]) => [key, value === null ? void 0 : value])
-        );
-        const versionInput = {
-          id: crypto.randomUUID(),
-          agentId: id,
-          versionNumber: nextVersionNumber,
-          ...this.extractSnapshotFields(latestVersion),
-          // Start from latest version
-          ...sanitizedConfigFields,
-          // Apply updates (null values converted to undefined)
-          changedFields: Object.keys(configFields),
-          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
-        };
-        await this.createVersion(versionInput);
-      }
       if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
       if (metadataFields.activeVersionId !== void 0) {
         updateDoc.activeVersionId = metadataFields.activeVersionId;
       }
+      if (metadataFields.status !== void 0) {
+        updateDoc.status = metadataFields.status;
+      }
       if (metadataFields.metadata !== void 0) {
         const existingMetadata = existingAgent.metadata || {};
         updateDoc.metadata = { ...existingMetadata, ...metadataFields.metadata };
@@ -1199,7 +1172,7 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
   }
   async list(args) {
     try {
-      const { page = 0, perPage: perPageInput, orderBy } = args || {};
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status } = args || {};
       const { field, direction } = this.parseOrderBy(orderBy);
       if (page < 0) {
         throw new error.MastraError(
@@ -1215,7 +1188,19 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const collection = await this.getCollection(storage.TABLE_AGENTS);
-      const total = await collection.countDocuments({});
+      const filter = {};
+      if (status) {
+        filter.status = status;
+      }
+      if (authorId) {
+        filter.authorId = authorId;
+      }
+      if (metadata) {
+        for (const [key, value] of Object.entries(metadata)) {
+          filter[`metadata.${key}`] = value;
+        }
+      }
+      const total = await collection.countDocuments(filter);
       if (total === 0 || perPage === 0) {
         return {
           agents: [],
@@ -1226,7 +1211,7 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
         };
       }
       const sortOrder = direction === "ASC" ? 1 : -1;
-      let cursor = collection.find({}).sort({ [field]: sortOrder }).skip(offset);
+      let cursor = collection.find(filter).sort({ [field]: sortOrder }).skip(offset);
       if (perPageInput !== false) {
         cursor = cursor.limit(perPage);
       }
@@ -1489,15 +1474,6 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
   /**
    * Extracts just the snapshot config fields from a version.
    */
-  extractSnapshotFields(version) {
-    const result = {};
-    for (const field of SNAPSHOT_FIELDS) {
-      if (version[field] !== void 0) {
-        result[field] = version[field];
-      }
-    }
-    return result;
-  }
   /**
    * Transforms a raw MongoDB version document into an AgentVersion.
    * Config fields are returned directly (no nested snapshot object).
@@ -1520,6 +1496,201 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
     return result;
   }
 };
+var MongoDBBlobStore = class _MongoDBBlobStore extends storage.BlobStore {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_COLLECTIONS = [storage.TABLE_SKILL_BLOBS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MongoDBBlobStore.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  getDefaultIndexDefinitions() {
+    return [{ collection: storage.TABLE_SKILL_BLOBS, keys: { hash: 1 }, options: { 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() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        const collection = await this.getCollection(indexDef.collection);
+        await collection.createIndex(indexDef.keys, indexDef.options);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index on ${indexDef.collection}:`, error);
+      }
+    }
+  }
+  async init() {
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  async put(entry) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_BLOBS);
+      const doc = {
+        hash: entry.hash,
+        content: entry.content,
+        size: entry.size,
+        mimeType: entry.mimeType ?? null,
+        createdAt: entry.createdAt ?? /* @__PURE__ */ new Date()
+      };
+      await collection.updateOne({ hash: entry.hash }, { $setOnInsert: doc }, { upsert: true });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "PUT_BLOB", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { hash: entry.hash }
+        },
+        error$1
+      );
+    }
+  }
+  async get(hash) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_BLOBS);
+      const result = await collection.findOne({ hash });
+      if (!result) {
+        return null;
+      }
+      return this.#parseDoc(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_BLOB", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { hash }
+        },
+        error$1
+      );
+    }
+  }
+  async has(hash) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_BLOBS);
+      const result = await collection.findOne({ hash }, { projection: { _id: 1 } });
+      return result !== null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "HAS_BLOB", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { hash }
+        },
+        error$1
+      );
+    }
+  }
+  async delete(hash) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_BLOBS);
+      const result = await collection.deleteOne({ hash });
+      return result.deletedCount > 0;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_BLOB", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { hash }
+        },
+        error$1
+      );
+    }
+  }
+  async putMany(entries) {
+    if (entries.length === 0) return;
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_BLOBS);
+      const operations = entries.map((entry) => ({
+        updateOne: {
+          filter: { hash: entry.hash },
+          update: {
+            $setOnInsert: {
+              hash: entry.hash,
+              content: entry.content,
+              size: entry.size,
+              mimeType: entry.mimeType ?? null,
+              createdAt: entry.createdAt ?? /* @__PURE__ */ new Date()
+            }
+          },
+          upsert: true
+        }
+      }));
+      await collection.bulkWrite(operations);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "PUT_MANY_BLOBS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: entries.length }
+        },
+        error$1
+      );
+    }
+  }
+  async getMany(hashes) {
+    const result = /* @__PURE__ */ new Map();
+    if (hashes.length === 0) return result;
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_BLOBS);
+      const docs = await collection.find({ hash: { $in: hashes } }).toArray();
+      for (const doc of docs) {
+        const entry = this.#parseDoc(doc);
+        result.set(entry.hash, entry);
+      }
+      return result;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_MANY_BLOBS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: hashes.length }
+        },
+        error$1
+      );
+    }
+  }
+  async dangerouslyClearAll() {
+    const collection = await this.getCollection(storage.TABLE_SKILL_BLOBS);
+    await collection.deleteMany({});
+  }
+  #parseDoc(doc) {
+    return {
+      hash: doc.hash,
+      content: doc.content,
+      size: Number(doc.size),
+      mimeType: doc.mimeType || void 0,
+      createdAt: doc.createdAt instanceof Date ? doc.createdAt : new Date(doc.createdAt)
+    };
+  }
+};
 var SNAPSHOT_FIELDS2 = ["name", "description", "servers"];
 var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.MCPClientsStorage {
   #connector;
@@ -1695,40 +1866,9 @@ var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.M
         metadata: updates.metadata,
         status: updates.status
       };
-      const configFields = {};
-      for (const field of SNAPSHOT_FIELDS2) {
-        if (updates[field] !== void 0) {
-          configFields[field] = updates[field];
-        }
-      }
-      if (Object.keys(configFields).length > 0) {
-        const latestVersion = await this.getLatestVersion(id);
-        if (!latestVersion) {
-          throw new error.MastraError({
-            id: storage.createStorageErrorId("MONGODB", "UPDATE_MCP_CLIENT", "NO_VERSION"),
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            text: `Cannot update config fields for MCP client ${id} - no versions exist`,
-            details: { id }
-          });
-        }
-        const existingSnapshot = this.extractSnapshotFields(latestVersion);
-        await this.createVersion({
-          id: crypto.randomUUID(),
-          mcpClientId: id,
-          versionNumber: latestVersion.versionNumber + 1,
-          ...existingSnapshot,
-          ...configFields,
-          changedFields: Object.keys(configFields),
-          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
-        });
-      }
       if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
       if (metadataFields.activeVersionId !== void 0) {
         updateDoc.activeVersionId = metadataFields.activeVersionId;
-        if (metadataFields.status === void 0) {
-          updateDoc.status = "published";
-        }
       }
       if (metadataFields.status !== void 0) {
         updateDoc.status = metadataFields.status;
@@ -1783,7 +1923,7 @@ var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.M
   }
   async list(args) {
     try {
-      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status = "published" } = args || {};
       const { field, direction } = this.parseOrderBy(orderBy);
       if (page < 0) {
         throw new error.MastraError(
@@ -1800,6 +1940,7 @@ var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.M
       const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const collection = await this.getCollection(storage.TABLE_MCP_CLIENTS);
       const filter = {};
+      filter.status = status;
       if (authorId) {
         filter.authorId = authorId;
       }
@@ -2088,15 +2229,6 @@ var MongoDBMCPClientsStorage = class _MongoDBMCPClientsStorage extends storage.M
     }
     return result;
   }
-  extractSnapshotFields(version) {
-    const result = {};
-    for (const field of SNAPSHOT_FIELDS2) {
-      if (version[field] !== void 0) {
-        result[field] = version[field];
-      }
-    }
-    return result;
-  }
 };
 function formatDateForMongoDB(date) {
   return typeof date === "string" ? new Date(date) : date;
@@ -2527,8 +2659,10 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
                 content: typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
                 role: message.role,
                 type: message.type || "v2",
-                createdAt: formatDateForMongoDB(time),
                 resourceId: message.resourceId
+              },
+              $setOnInsert: {
+                createdAt: formatDateForMongoDB(time)
               }
             },
             upsert: true
@@ -4609,40 +4743,9 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
         metadata: updates.metadata,
         status: updates.status
       };
-      const configFields = {};
-      for (const field of SNAPSHOT_FIELDS3) {
-        if (updates[field] !== void 0) {
-          configFields[field] = updates[field];
-        }
-      }
-      if (Object.keys(configFields).length > 0) {
-        const latestVersion = await this.getLatestVersion(id);
-        if (!latestVersion) {
-          throw new error.MastraError({
-            id: storage.createStorageErrorId("MONGODB", "UPDATE_PROMPT_BLOCK", "NO_VERSION"),
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            text: `Cannot update config fields for prompt block ${id} - no versions exist`,
-            details: { id }
-          });
-        }
-        const existingSnapshot = this.extractSnapshotFields(latestVersion);
-        await this.createVersion({
-          id: crypto.randomUUID(),
-          blockId: id,
-          versionNumber: latestVersion.versionNumber + 1,
-          ...existingSnapshot,
-          ...configFields,
-          changedFields: Object.keys(configFields),
-          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
-        });
-      }
       if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
       if (metadataFields.activeVersionId !== void 0) {
         updateDoc.activeVersionId = metadataFields.activeVersionId;
-        if (metadataFields.status === void 0) {
-          updateDoc.status = "published";
-        }
       }
       if (metadataFields.status !== void 0) {
         updateDoc.status = metadataFields.status;
@@ -4697,7 +4800,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
   }
   async list(args) {
     try {
-      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status = "published" } = args || {};
       const { field, direction } = this.parseOrderBy(orderBy);
       if (page < 0) {
         throw new error.MastraError(
@@ -4714,6 +4817,7 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
       const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const collection = await this.getCollection(storage.TABLE_PROMPT_BLOCKS);
       const filter = {};
+      filter.status = status;
       if (authorId) {
         filter.authorId = authorId;
       }
@@ -5002,15 +5106,6 @@ var MongoDBPromptBlocksStorage = class _MongoDBPromptBlocksStorage extends stora
     }
     return result;
   }
-  extractSnapshotFields(version) {
-    const result = {};
-    for (const field of SNAPSHOT_FIELDS3) {
-      if (version[field] !== void 0) {
-        result[field] = version[field];
-      }
-    }
-    return result;
-  }
 };
 var SNAPSHOT_FIELDS4 = [
   "name",
@@ -5191,40 +5286,9 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
         metadata: updates.metadata,
         status: updates.status
       };
-      const configFields = {};
-      for (const field of SNAPSHOT_FIELDS4) {
-        if (updates[field] !== void 0) {
-          configFields[field] = updates[field];
-        }
-      }
-      if (Object.keys(configFields).length > 0) {
-        const latestVersion = await this.getLatestVersion(id);
-        if (!latestVersion) {
-          throw new error.MastraError({
-            id: storage.createStorageErrorId("MONGODB", "UPDATE_SCORER_DEFINITION", "NO_VERSION"),
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            text: `Cannot update config fields for scorer definition ${id} - no versions exist`,
-            details: { id }
-          });
-        }
-        const existingSnapshot = this.extractSnapshotFields(latestVersion);
-        await this.createVersion({
-          id: crypto.randomUUID(),
-          scorerDefinitionId: id,
-          versionNumber: latestVersion.versionNumber + 1,
-          ...existingSnapshot,
-          ...configFields,
-          changedFields: Object.keys(configFields),
-          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
-        });
-      }
       if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
       if (metadataFields.activeVersionId !== void 0) {
         updateDoc.activeVersionId = metadataFields.activeVersionId;
-        if (metadataFields.status === void 0) {
-          updateDoc.status = "published";
-        }
       }
       if (metadataFields.status !== void 0) {
         updateDoc.status = metadataFields.status;
@@ -5279,7 +5343,7 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
   }
   async list(args) {
     try {
-      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status } = args || {};
       const { field, direction } = this.parseOrderBy(orderBy);
       if (page < 0) {
         throw new error.MastraError(
@@ -5296,6 +5360,9 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
       const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const collection = await this.getCollection(storage.TABLE_SCORER_DEFINITIONS);
       const filter = {};
+      if (status) {
+        filter.status = status;
+      }
       if (authorId) {
         filter.authorId = authorId;
       }
@@ -5584,15 +5651,6 @@ var MongoDBScorerDefinitionsStorage = class _MongoDBScorerDefinitionsStorage ext
     }
     return result;
   }
-  extractSnapshotFields(version) {
-    const result = {};
-    for (const field of SNAPSHOT_FIELDS4) {
-      if (version[field] !== void 0) {
-        result[field] = version[field];
-      }
-    }
-    return result;
-  }
 };
 function transformScoreRow(row) {
   return storage.transformScoreRow(row, {
@@ -5962,43 +6020,50 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends storage.ScoresSto
     }
   }
 };
-var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.WorkflowsStorage {
+var SNAPSHOT_FIELDS5 = [
+  "name",
+  "description",
+  "instructions",
+  "license",
+  "compatibility",
+  "source",
+  "references",
+  "scripts",
+  "assets",
+  "metadata",
+  "tree"
+];
+var MongoDBSkillsStorage = class _MongoDBSkillsStorage extends storage.SkillsStorage {
   #connector;
   #skipDefaultIndexes;
   #indexes;
-  /** Collections managed by this domain */
-  static MANAGED_COLLECTIONS = [storage.TABLE_WORKFLOW_SNAPSHOT];
+  static MANAGED_COLLECTIONS = [storage.TABLE_SKILLS, storage.TABLE_SKILL_VERSIONS];
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
     this.#skipDefaultIndexes = config.skipDefaultIndexes;
     this.#indexes = config.indexes?.filter(
-      (idx) => _WorkflowsStorageMongoDB.MANAGED_COLLECTIONS.includes(idx.collection)
+      (idx) => _MongoDBSkillsStorage.MANAGED_COLLECTIONS.includes(idx.collection)
     );
   }
   async getCollection(name) {
     return this.#connector.getCollection(name);
   }
-  async init() {
-    await this.createDefaultIndexes();
-    await this.createCustomIndexes();
-  }
-  /**
-   * Returns default index definitions for the workflows domain collections.
-   */
   getDefaultIndexDefinitions() {
     return [
-      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { workflow_name: 1, run_id: 1 }, options: { unique: true } },
-      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { run_id: 1 } },
-      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { workflow_name: 1 } },
-      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { resourceId: 1 } },
-      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { createdAt: -1 } },
-      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { "snapshot.status": 1 } }
+      { collection: storage.TABLE_SKILLS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_SKILLS, keys: { status: 1 } },
+      { collection: storage.TABLE_SKILLS, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_SKILLS, keys: { authorId: 1 } },
+      { collection: storage.TABLE_SKILL_VERSIONS, keys: { id: 1 }, options: { unique: true } },
+      {
+        collection: storage.TABLE_SKILL_VERSIONS,
+        keys: { skillId: 1, versionNumber: -1 },
+        options: { unique: true }
+      },
+      { collection: storage.TABLE_SKILL_VERSIONS, keys: { skillId: 1 } }
     ];
   }
-  /**
-   * Creates default indexes for optimal query performance.
-   */
   async createDefaultIndexes() {
     if (this.#skipDefaultIndexes) {
       return;
@@ -6012,9 +6077,6 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.Wor
       }
     }
   }
-  /**
-   * Creates custom user-defined indexes for this domain's collections.
-   */
   async createCustomIndexes() {
     if (!this.#indexes || this.#indexes.length === 0) {
       return;
@@ -6028,216 +6090,1395 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.Wor
       }
     }
   }
-  async dangerouslyClearAll() {
-    const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
-    await collection.deleteMany({});
-  }
-  updateWorkflowResults({
-    // workflowName,
-    // runId,
-    // stepId,
-    // result,
-    // requestContext,
-  }) {
-    throw new Error("Method not implemented.");
-  }
-  updateWorkflowState({
-    // workflowName,
-    // runId,
-    // opts,
-  }) {
-    throw new Error("Method not implemented.");
+  async init() {
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
   }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot,
-    createdAt,
-    updatedAt
-  }) {
-    try {
-      const now = /* @__PURE__ */ new Date();
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
-      await collection.updateOne(
-        { workflow_name: workflowName, run_id: runId },
-        {
-          $set: {
-            workflow_name: workflowName,
-            run_id: runId,
-            resourceId,
-            snapshot,
-            updatedAt: updatedAt ?? now
-          },
-          $setOnInsert: {
-            createdAt: createdAt ?? now
-          }
-        },
-        { upsert: true }
-      );
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("MONGODB", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { workflowName, runId }
-        },
-        error$1
-      );
-    }
+  async dangerouslyClearAll() {
+    const versionsCollection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+    await versionsCollection.deleteMany({});
+    const skillsCollection = await this.getCollection(storage.TABLE_SKILLS);
+    await skillsCollection.deleteMany({});
   }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
+  // ==========================================================================
+  // Skill CRUD
+  // ==========================================================================
+  async getById(id) {
     try {
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
-      const result = await collection.findOne({
-        workflow_name: workflowName,
-        run_id: runId
-      });
+      const collection = await this.getCollection(storage.TABLE_SKILLS);
+      const result = await collection.findOne({ id });
       if (!result) {
         return null;
       }
-      return typeof result.snapshot === "string" ? storage.safelyParseJSON(result.snapshot) : result.snapshot;
+      return this.transformSkill(result);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("MONGODB", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
+          id: storage.createStorageErrorId("MONGODB", "GET_SKILL_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { workflowName, runId }
+          details: { id }
         },
         error$1
       );
     }
   }
-  async listWorkflowRuns(args) {
-    const options = args || {};
+  async create(input) {
+    const { skill } = input;
     try {
-      const query = {};
-      if (options.workflowName) {
-        query["workflow_name"] = options.workflowName;
-      }
-      if (options.status) {
-        query["snapshot.status"] = options.status;
-      }
-      if (options.fromDate) {
-        query["createdAt"] = { $gte: options.fromDate };
+      const collection = await this.getCollection(storage.TABLE_SKILLS);
+      const id = skill.id;
+      const existing = await collection.findOne({ id });
+      if (existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "CREATE_SKILL", "ALREADY_EXISTS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id },
+          text: `Skill with id ${id} already exists`
+        });
       }
-      if (options.toDate) {
-        if (query["createdAt"]) {
-          query["createdAt"].$lte = options.toDate;
-        } else {
-          query["createdAt"] = { $lte: options.toDate };
+      const now = /* @__PURE__ */ new Date();
+      const newSkill = {
+        id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: skill.authorId,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection.insertOne(this.serializeSkill(newSkill));
+      const snapshotConfig = {};
+      for (const field of SNAPSHOT_FIELDS5) {
+        if (skill[field] !== void 0) {
+          snapshotConfig[field] = skill[field];
         }
       }
-      if (options.resourceId) {
-        query["resourceId"] = options.resourceId;
-      }
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
-      let total = 0;
-      let cursor = collection.find(query).sort({ createdAt: -1 });
-      if (options.page !== void 0 && typeof options.perPage === "number") {
-        if (options.page < 0) {
-          throw new error.MastraError(
-            {
-              id: storage.createStorageErrorId("MONGODB", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
-              domain: error.ErrorDomain.STORAGE,
-              category: error.ErrorCategory.USER,
-              details: { page: options.page }
-            },
-            new Error("page must be >= 0")
-          );
-        }
-        total = await collection.countDocuments(query);
-        const normalizedPerPage = storage.normalizePerPage(options.perPage, Number.MAX_SAFE_INTEGER);
-        if (normalizedPerPage === 0) {
-          return { runs: [], total };
-        }
-        const offset = options.page * normalizedPerPage;
-        cursor = cursor.skip(offset);
-        cursor = cursor.limit(Math.min(normalizedPerPage, 2147483647));
+      const versionId = crypto.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 results = await cursor.toArray();
-      const runs = results.map((row) => this.parseWorkflowRun(row));
-      return {
-        runs,
-        total: total || runs.length
-      };
+      return newSkill;
     } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("MONGODB", "LIST_WORKFLOW_RUNS", "FAILED"),
+          id: storage.createStorageErrorId("MONGODB", "CREATE_SKILL", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { workflowName: options.workflowName || "unknown" }
+          details: { name: skill.name }
         },
         error$1
       );
     }
   }
-  async getWorkflowRunById(args) {
+  async update(input) {
+    const { id, ...updates } = input;
     try {
-      const query = {};
-      if (args.runId) {
-        query["run_id"] = args.runId;
-      }
-      if (args.workflowName) {
-        query["workflow_name"] = args.workflowName;
+      const collection = await this.getCollection(storage.TABLE_SKILLS);
+      const existingSkill = await collection.findOne({ id });
+      if (!existingSkill) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_SKILL", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id },
+          text: `Skill with id ${id} not found`
+        });
       }
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
-      const result = await collection.findOne(query);
-      if (!result) {
-        return null;
+      const updateDoc = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const metadataFields = {
+        authorId: updates.authorId,
+        activeVersionId: updates.activeVersionId,
+        status: updates.status
+      };
+      const configFields = {};
+      for (const field of SNAPSHOT_FIELDS5) {
+        if (updates[field] !== void 0) {
+          configFields[field] = updates[field];
+        }
       }
-      return this.parseWorkflowRun(result);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
+      if (Object.keys(configFields).length > 0) {
+        const latestVersion = await this.getLatestVersion(id);
+        if (!latestVersion) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "UPDATE_SKILL", "NO_VERSION"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            text: `Cannot update config fields for skill ${id} - no versions exist`,
+            details: { id }
+          });
+        }
+        const existingSnapshot = this.extractSnapshotFields(latestVersion);
+        await this.createVersion({
+          id: crypto.randomUUID(),
+          skillId: id,
+          versionNumber: latestVersion.versionNumber + 1,
+          ...existingSnapshot,
+          ...configFields,
+          changedFields: Object.keys(configFields),
+          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
+        });
+      }
+      if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
+      if (metadataFields.activeVersionId !== void 0) {
+        updateDoc.activeVersionId = metadataFields.activeVersionId;
+        if (metadataFields.status === void 0) {
+          updateDoc.status = "published";
+        }
+      }
+      if (metadataFields.status !== void 0) {
+        updateDoc.status = metadataFields.status;
+      }
+      await collection.updateOne({ id }, { $set: updateDoc });
+      const updatedSkill = await collection.findOne({ id });
+      if (!updatedSkill) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_SKILL", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Skill with id ${id} was deleted during update`,
+          details: { id }
+        });
+      }
+      return this.transformSkill(updatedSkill);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_SKILL", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      await this.deleteVersionsByParentId(id);
+      const collection = await this.getCollection(storage.TABLE_SKILLS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_SKILL", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async list(args) {
+    try {
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+      const { field, direction } = this.parseOrderBy(orderBy);
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("MONGODB", "LIST_SKILLS", "INVALID_PAGE"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const collection = await this.getCollection(storage.TABLE_SKILLS);
+      const filter = {};
+      if (authorId) {
+        filter.authorId = authorId;
+      }
+      if (metadata) {
+        for (const [key, value] of Object.entries(metadata)) {
+          filter[`metadata.${key}`] = value;
+        }
+      }
+      const total = await collection.countDocuments(filter);
+      if (total === 0 || perPage === 0) {
+        return {
+          skills: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find(filter).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const results = await cursor.toArray();
+      const skills = results.map((doc) => this.transformSkill(doc));
+      return {
+        skills,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput !== false && offset + perPage < total
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_SKILLS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Skill Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+      const now = /* @__PURE__ */ new Date();
+      const versionDoc = {
+        id: input.id,
+        skillId: input.skillId,
+        versionNumber: input.versionNumber,
+        changedFields: input.changedFields ?? void 0,
+        changeMessage: input.changeMessage ?? void 0,
+        createdAt: now
+      };
+      for (const field of SNAPSHOT_FIELDS5) {
+        if (input[field] !== void 0) {
+          versionDoc[field] = input[field];
+        }
+      }
+      await collection.insertOne(versionDoc);
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_SKILL_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, skillId: input.skillId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_SKILL_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(skillId, versionNumber) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+      const result = await collection.findOne({ skillId, versionNumber });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_SKILL_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { skillId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(skillId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+      const result = await collection.find({ skillId }).sort({ versionNumber: -1 }).limit(1).toArray();
+      if (!result || result.length === 0) {
+        return null;
+      }
+      return this.transformVersion(result[0]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_LATEST_SKILL_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { skillId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { skillId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_SKILL_VERSIONS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 20);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseVersionOrderBy(orderBy);
+      const collection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+      const total = await collection.countDocuments({ skillId });
+      if (total === 0 || perPage === 0) {
+        return {
+          versions: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find({ skillId }).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const results = await cursor.toArray();
+      const versions = results.map((doc) => this.transformVersion(doc));
+      return {
+        versions,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput !== false && offset + perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_SKILL_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { skillId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_SKILL_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByParentId(skillId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+      await collection.deleteMany({ skillId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_VERSIONS_BY_SKILL_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { skillId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(skillId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SKILL_VERSIONS);
+      return await collection.countDocuments({ skillId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "COUNT_SKILL_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { skillId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  transformSkill(doc) {
+    const { _id, ...rest } = doc;
+    return {
+      id: rest.id,
+      status: rest.status,
+      activeVersionId: rest.activeVersionId,
+      authorId: rest.authorId,
+      createdAt: rest.createdAt instanceof Date ? rest.createdAt : new Date(rest.createdAt),
+      updatedAt: rest.updatedAt instanceof Date ? rest.updatedAt : new Date(rest.updatedAt)
+    };
+  }
+  serializeSkill(skill) {
+    return {
+      id: skill.id,
+      status: skill.status,
+      activeVersionId: skill.activeVersionId,
+      authorId: skill.authorId,
+      createdAt: skill.createdAt,
+      updatedAt: skill.updatedAt
+    };
+  }
+  transformVersion(doc) {
+    const { _id, ...version } = doc;
+    const result = {
+      id: version.id,
+      skillId: version.skillId,
+      versionNumber: version.versionNumber,
+      changedFields: version.changedFields,
+      changeMessage: version.changeMessage,
+      createdAt: version.createdAt instanceof Date ? version.createdAt : new Date(version.createdAt)
+    };
+    for (const field of SNAPSHOT_FIELDS5) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
+  }
+  extractSnapshotFields(version) {
+    const result = {};
+    for (const field of SNAPSHOT_FIELDS5) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
+  }
+};
+var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.WorkflowsStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Collections managed by this domain */
+  static MANAGED_COLLECTIONS = [storage.TABLE_WORKFLOW_SNAPSHOT];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _WorkflowsStorageMongoDB.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  async init() {
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Returns default index definitions for the workflows domain collections.
+   */
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { workflow_name: 1, run_id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { run_id: 1 } },
+      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { workflow_name: 1 } },
+      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { resourceId: 1 } },
+      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_WORKFLOW_SNAPSHOT, keys: { "snapshot.status": 1 } }
+    ];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   */
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        const collection = await this.getCollection(indexDef.collection);
+        await collection.createIndex(indexDef.keys, indexDef.options);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index on ${indexDef.collection}:`, error);
+      }
+    }
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's collections.
+   */
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        const collection = await this.getCollection(indexDef.collection);
+        await collection.createIndex(indexDef.keys, indexDef.options);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index on ${indexDef.collection}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+    await collection.deleteMany({});
+  }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // requestContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot,
+    createdAt,
+    updatedAt
+  }) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      await collection.updateOne(
+        { workflow_name: workflowName, run_id: runId },
+        {
+          $set: {
+            workflow_name: workflowName,
+            run_id: runId,
+            resourceId,
+            snapshot,
+            updatedAt: updatedAt ?? now
+          },
+          $setOnInsert: {
+            createdAt: createdAt ?? now
+          }
+        },
+        { upsert: true }
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
+    }
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const result = await collection.findOne({
+        workflow_name: workflowName,
+        run_id: runId
+      });
+      if (!result) {
+        return null;
+      }
+      return typeof result.snapshot === "string" ? storage.safelyParseJSON(result.snapshot) : result.snapshot;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
+    }
+  }
+  async listWorkflowRuns(args) {
+    const options = args || {};
+    try {
+      const query = {};
+      if (options.workflowName) {
+        query["workflow_name"] = options.workflowName;
+      }
+      if (options.status) {
+        query["snapshot.status"] = options.status;
+      }
+      if (options.fromDate) {
+        query["createdAt"] = { $gte: options.fromDate };
+      }
+      if (options.toDate) {
+        if (query["createdAt"]) {
+          query["createdAt"].$lte = options.toDate;
+        } else {
+          query["createdAt"] = { $lte: options.toDate };
+        }
+      }
+      if (options.resourceId) {
+        query["resourceId"] = options.resourceId;
+      }
+      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      let total = 0;
+      let cursor = collection.find(query).sort({ createdAt: -1 });
+      if (options.page !== void 0 && typeof options.perPage === "number") {
+        if (options.page < 0) {
+          throw new error.MastraError(
+            {
+              id: storage.createStorageErrorId("MONGODB", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
+              domain: error.ErrorDomain.STORAGE,
+              category: error.ErrorCategory.USER,
+              details: { page: options.page }
+            },
+            new Error("page must be >= 0")
+          );
+        }
+        total = await collection.countDocuments(query);
+        const normalizedPerPage = storage.normalizePerPage(options.perPage, Number.MAX_SAFE_INTEGER);
+        if (normalizedPerPage === 0) {
+          return { runs: [], total };
+        }
+        const offset = options.page * normalizedPerPage;
+        cursor = cursor.skip(offset);
+        cursor = cursor.limit(Math.min(normalizedPerPage, 2147483647));
+      }
+      const results = await cursor.toArray();
+      const runs = results.map((row) => this.parseWorkflowRun(row));
+      return {
+        runs,
+        total: total || runs.length
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_WORKFLOW_RUNS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName: options.workflowName || "unknown" }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById(args) {
+    try {
+      const query = {};
+      if (args.runId) {
+        query["run_id"] = args.runId;
+      }
+      if (args.workflowName) {
+        query["workflow_name"] = args.workflowName;
+      }
+      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const result = await collection.findOne(query);
+      if (!result) {
+        return null;
+      }
+      return this.parseWorkflowRun(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
           id: storage.createStorageErrorId("MONGODB", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { runId: args.runId }
+          details: { runId: args.runId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      await collection.deleteOne({ workflow_name: workflowName, run_id: runId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { runId, workflowName }
+        },
+        error$1
+      );
+    }
+  }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = typeof row.snapshot === "string" ? storage.safelyParseJSON(row.snapshot) : row.snapshot;
+      } catch (e) {
+        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: row.createdAt ? new Date(row.createdAt) : /* @__PURE__ */ new Date(),
+      updatedAt: row.updatedAt ? new Date(row.updatedAt) : /* @__PURE__ */ new Date(),
+      resourceId: row.resourceId
+    };
+  }
+};
+var SNAPSHOT_FIELDS6 = [
+  "name",
+  "description",
+  "filesystem",
+  "sandbox",
+  "mounts",
+  "search",
+  "skills",
+  "tools",
+  "autoSync",
+  "operationTimeout"
+];
+var MongoDBWorkspacesStorage = class _MongoDBWorkspacesStorage extends storage.WorkspacesStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_COLLECTIONS = [storage.TABLE_WORKSPACES, storage.TABLE_WORKSPACE_VERSIONS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MongoDBWorkspacesStorage.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_WORKSPACES, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_WORKSPACES, keys: { status: 1 } },
+      { collection: storage.TABLE_WORKSPACES, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_WORKSPACES, keys: { authorId: 1 } },
+      { collection: storage.TABLE_WORKSPACE_VERSIONS, keys: { id: 1 }, options: { unique: true } },
+      {
+        collection: storage.TABLE_WORKSPACE_VERSIONS,
+        keys: { workspaceId: 1, versionNumber: -1 },
+        options: { unique: true }
+      },
+      { collection: storage.TABLE_WORKSPACE_VERSIONS, keys: { workspaceId: 1 } }
+    ];
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        const collection = await this.getCollection(indexDef.collection);
+        await collection.createIndex(indexDef.keys, indexDef.options);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index on ${indexDef.collection}:`, error);
+      }
+    }
+  }
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        const collection = await this.getCollection(indexDef.collection);
+        await collection.createIndex(indexDef.keys, indexDef.options);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index on ${indexDef.collection}:`, error);
+      }
+    }
+  }
+  async init() {
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  async dangerouslyClearAll() {
+    const versionsCollection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+    await versionsCollection.deleteMany({});
+    const workspacesCollection = await this.getCollection(storage.TABLE_WORKSPACES);
+    await workspacesCollection.deleteMany({});
+  }
+  // ==========================================================================
+  // Workspace CRUD
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACES);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformWorkspace(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_WORKSPACE_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async create(input) {
+    const { workspace } = input;
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACES);
+      const slug = workspace.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      const id = slug || workspace.id;
+      if (!id) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "CREATE_WORKSPACE", "INVALID_NAME"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `Cannot derive a valid ID from workspace name "${workspace.name}"`,
+          details: { name: workspace.name }
+        });
+      }
+      const existing = await collection.findOne({ id });
+      if (existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "CREATE_WORKSPACE", "ALREADY_EXISTS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id },
+          text: `Workspace with id ${id} already exists`
+        });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const newWorkspace = {
+        id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: workspace.authorId,
+        metadata: workspace.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection.insertOne(this.serializeWorkspace(newWorkspace));
+      const snapshotConfig = {};
+      for (const field of SNAPSHOT_FIELDS6) {
+        if (workspace[field] !== void 0) {
+          snapshotConfig[field] = workspace[field];
+        }
+      }
+      const versionId = crypto.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;
+      }
+      return newWorkspace;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_WORKSPACE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { name: workspace.name }
+        },
+        error$1
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACES);
+      const existingWorkspace = await collection.findOne({ id });
+      if (!existingWorkspace) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_WORKSPACE", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id },
+          text: `Workspace with id ${id} not found`
+        });
+      }
+      const updateDoc = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const metadataFields = {
+        authorId: updates.authorId,
+        activeVersionId: updates.activeVersionId,
+        metadata: updates.metadata,
+        status: updates.status
+      };
+      const configFields = {};
+      for (const field of SNAPSHOT_FIELDS6) {
+        if (updates[field] !== void 0) {
+          configFields[field] = updates[field];
+        }
+      }
+      if (Object.keys(configFields).length > 0) {
+        const latestVersion = await this.getLatestVersion(id);
+        if (!latestVersion) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("MONGODB", "UPDATE_WORKSPACE", "NO_VERSION"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            text: `Cannot update config fields for workspace ${id} - no versions exist`,
+            details: { id }
+          });
+        }
+        const existingSnapshot = this.extractSnapshotFields(latestVersion);
+        await this.createVersion({
+          id: crypto.randomUUID(),
+          workspaceId: id,
+          versionNumber: latestVersion.versionNumber + 1,
+          ...existingSnapshot,
+          ...configFields,
+          changedFields: Object.keys(configFields),
+          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
+        });
+      }
+      if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
+      if (metadataFields.activeVersionId !== void 0) {
+        updateDoc.activeVersionId = metadataFields.activeVersionId;
+        if (metadataFields.status === void 0) {
+          updateDoc.status = "published";
+        }
+      }
+      if (metadataFields.status !== void 0) {
+        updateDoc.status = metadataFields.status;
+      }
+      if (metadataFields.metadata !== void 0) {
+        const existingMetadata = existingWorkspace.metadata || {};
+        updateDoc.metadata = { ...existingMetadata, ...metadataFields.metadata };
+      }
+      await collection.updateOne({ id }, { $set: updateDoc });
+      const updatedWorkspace = await collection.findOne({ id });
+      if (!updatedWorkspace) {
+        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 }
+        });
+      }
+      return this.transformWorkspace(updatedWorkspace);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_WORKSPACE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      await this.deleteVersionsByParentId(id);
+      const collection = await this.getCollection(storage.TABLE_WORKSPACES);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_WORKSPACE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async list(args) {
+    try {
+      const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+      const { field, direction } = this.parseOrderBy(orderBy);
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("MONGODB", "LIST_WORKSPACES", "INVALID_PAGE"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const collection = await this.getCollection(storage.TABLE_WORKSPACES);
+      const filter = {};
+      if (authorId) {
+        filter.authorId = authorId;
+      }
+      if (metadata) {
+        for (const [key, value] of Object.entries(metadata)) {
+          filter[`metadata.${key}`] = value;
+        }
+      }
+      const total = await collection.countDocuments(filter);
+      if (total === 0 || perPage === 0) {
+        return {
+          workspaces: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find(filter).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const results = await cursor.toArray();
+      const workspaces = results.map((doc) => this.transformWorkspace(doc));
+      return {
+        workspaces,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput !== false && offset + perPage < total
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_WORKSPACES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Workspace Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+      const now = /* @__PURE__ */ new Date();
+      const versionDoc = {
+        id: input.id,
+        workspaceId: input.workspaceId,
+        versionNumber: input.versionNumber,
+        changedFields: input.changedFields ?? void 0,
+        changeMessage: input.changeMessage ?? void 0,
+        createdAt: now
+      };
+      for (const field of SNAPSHOT_FIELDS6) {
+        if (input[field] !== void 0) {
+          versionDoc[field] = input[field];
+        }
+      }
+      await collection.insertOne(versionDoc);
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_WORKSPACE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, workspaceId: input.workspaceId }
         },
         error$1
       );
     }
   }
-  async deleteWorkflowRunById({ runId, workflowName }) {
+  async getVersion(id) {
     try {
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
-      await collection.deleteOne({ workflow_name: workflowName, run_id: runId });
+      const collection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("MONGODB", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          id: storage.createStorageErrorId("MONGODB", "GET_WORKSPACE_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { runId, workflowName }
+          details: { versionId: id }
         },
         error$1
       );
     }
   }
-  parseWorkflowRun(row) {
-    let parsedSnapshot = row.snapshot;
-    if (typeof parsedSnapshot === "string") {
-      try {
-        parsedSnapshot = typeof row.snapshot === "string" ? storage.safelyParseJSON(row.snapshot) : row.snapshot;
-      } catch (e) {
-        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+  async getVersionByNumber(workspaceId, versionNumber) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+      const result = await collection.findOne({ workspaceId, versionNumber });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_WORKSPACE_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workspaceId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(workspaceId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+      const result = await collection.find({ workspaceId }).sort({ versionNumber: -1 }).limit(1).toArray();
+      if (!result || result.length === 0) {
+        return null;
+      }
+      return this.transformVersion(result[0]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_LATEST_WORKSPACE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workspaceId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { workspaceId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_WORKSPACE_VERSIONS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 20);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseVersionOrderBy(orderBy);
+      const collection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+      const total = await collection.countDocuments({ workspaceId });
+      if (total === 0 || perPage === 0) {
+        return {
+          versions: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find({ workspaceId }).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
       }
+      const results = await cursor.toArray();
+      const versions = results.map((doc) => this.transformVersion(doc));
+      return {
+        versions,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput !== false && offset + perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_WORKSPACE_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workspaceId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_WORKSPACE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByParentId(workspaceId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+      await collection.deleteMany({ workspaceId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_VERSIONS_BY_WORKSPACE_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workspaceId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(workspaceId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_WORKSPACE_VERSIONS);
+      return await collection.countDocuments({ workspaceId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "COUNT_WORKSPACE_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workspaceId }
+        },
+        error$1
+      );
     }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  transformWorkspace(doc) {
+    const { _id, ...rest } = doc;
     return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: row.createdAt ? new Date(row.createdAt) : /* @__PURE__ */ new Date(),
-      updatedAt: row.updatedAt ? new Date(row.updatedAt) : /* @__PURE__ */ new Date(),
-      resourceId: row.resourceId
+      id: rest.id,
+      status: rest.status,
+      activeVersionId: rest.activeVersionId,
+      authorId: rest.authorId,
+      metadata: rest.metadata,
+      createdAt: rest.createdAt instanceof Date ? rest.createdAt : new Date(rest.createdAt),
+      updatedAt: rest.updatedAt instanceof Date ? rest.updatedAt : new Date(rest.updatedAt)
+    };
+  }
+  serializeWorkspace(workspace) {
+    return {
+      id: workspace.id,
+      status: workspace.status,
+      activeVersionId: workspace.activeVersionId,
+      authorId: workspace.authorId,
+      metadata: workspace.metadata,
+      createdAt: workspace.createdAt,
+      updatedAt: workspace.updatedAt
+    };
+  }
+  transformVersion(doc) {
+    const { _id, ...version } = doc;
+    const result = {
+      id: version.id,
+      workspaceId: version.workspaceId,
+      versionNumber: version.versionNumber,
+      changedFields: version.changedFields,
+      changeMessage: version.changeMessage,
+      createdAt: version.createdAt instanceof Date ? version.createdAt : new Date(version.createdAt)
     };
+    for (const field of SNAPSHOT_FIELDS6) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
+  }
+  extractSnapshotFields(version) {
+    const result = {};
+    for (const field of SNAPSHOT_FIELDS6) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
   }
 };
 
@@ -6261,6 +7502,9 @@ var MongoDBStore = class extends storage.MastraCompositeStore {
     const promptBlocks = new MongoDBPromptBlocksStorage(domainConfig);
     const scorerDefinitions = new MongoDBScorerDefinitionsStorage(domainConfig);
     const mcpClients = new MongoDBMCPClientsStorage(domainConfig);
+    const workspaces = new MongoDBWorkspacesStorage(domainConfig);
+    const skills = new MongoDBSkillsStorage(domainConfig);
+    const blobs = new MongoDBBlobStore(domainConfig);
     this.stores = {
       memory,
       scores,
@@ -6269,7 +7513,10 @@ var MongoDBStore = class extends storage.MastraCompositeStore {
       agents,
       promptBlocks,
       scorerDefinitions,
-      mcpClients
+      mcpClients,
+      workspaces,
+      skills,
+      blobs
     };
   }
   /**
@@ -6391,11 +7638,14 @@ Example Complex Query:
 exports.MONGODB_PROMPT = MONGODB_PROMPT;
 exports.MemoryStorageMongoDB = MemoryStorageMongoDB;
 exports.MongoDBAgentsStorage = MongoDBAgentsStorage;
+exports.MongoDBBlobStore = MongoDBBlobStore;
 exports.MongoDBMCPClientsStorage = MongoDBMCPClientsStorage;
 exports.MongoDBPromptBlocksStorage = MongoDBPromptBlocksStorage;
 exports.MongoDBScorerDefinitionsStorage = MongoDBScorerDefinitionsStorage;
+exports.MongoDBSkillsStorage = MongoDBSkillsStorage;
 exports.MongoDBStore = MongoDBStore;
 exports.MongoDBVector = MongoDBVector;
+exports.MongoDBWorkspacesStorage = MongoDBWorkspacesStorage;
 exports.ObservabilityMongoDB = ObservabilityMongoDB;
 exports.ScoresStorageMongoDB = ScoresStorageMongoDB;
 exports.WorkflowsStorageMongoDB = WorkflowsStorageMongoDB;