@mastra/mongodb 1.0.0-beta.9 → 1.1.0-alpha.0

package/dist/index.cjs

@@ -13,7 +13,7 @@ var evals = require('@mastra/core/evals');
 
 // package.json
 var package_default = {
-  version: "1.0.0-beta.9"};
+  version: "1.1.0-alpha.0"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -107,7 +107,7 @@ var MongoDBVector = class extends vector.MastraVector {
   client;
   db;
   collections;
-  embeddingFieldName = "embedding";
+  embeddingFieldName;
   metadataFieldName = "metadata";
   documentFieldName = "document";
   collectionForValidation = null;
@@ -116,8 +116,11 @@ var MongoDBVector = class extends vector.MastraVector {
     euclidean: "euclidean",
     dotproduct: "dotProduct"
   };
-  constructor({ id, uri, dbName, options }) {
+  constructor({ id, uri, dbName, options, embeddingFieldPath }) {
     super({ id });
+    if (!uri) {
+      throw new Error('MongoDBVector requires a connection string. Provide "uri" in the constructor options.');
+    }
     const client = new mongodb.MongoClient(uri, {
       ...options,
       driverInfo: {
@@ -128,6 +131,7 @@ var MongoDBVector = class extends vector.MastraVector {
     this.client = client;
     this.db = this.client.db(dbName);
     this.collections = /* @__PURE__ */ new Map();
+    this.embeddingFieldName = embeddingFieldPath ?? "embedding";
   }
   // Public methods
   async connect() {
@@ -276,6 +280,8 @@ var MongoDBVector = class extends vector.MastraVector {
     throw new Error(`Index "${indexNameInternal}" did not become ready within timeout`);
   }
   async upsert({ indexName, vectors, metadata, ids, documents }) {
+    vector.validateUpsertInput("MONGODB", vectors, metadata, ids);
+    vector.validateVectorValues("MONGODB", vectors);
     try {
       const collection = await this.getCollection(indexName);
       this.collectionForValidation = collection;
@@ -351,8 +357,8 @@ var MongoDBVector = class extends vector.MastraVector {
         index: indexNameInternal,
         queryVector,
         path: this.embeddingFieldName,
-        numCandidates: 100,
-        limit: topK
+        numCandidates: Math.min(1e4, Math.max(100, topK)),
+        limit: Math.min(1e4, topK)
       };
       if (Object.keys(combinedFilter).length > 0) {
         const filterWithExclusion = {
@@ -859,11 +865,21 @@ function resolveMongoDBConfig(config) {
       );
     }
   }
+  const connectionString = config.uri ?? config.url;
+  if (!connectionString) {
+    throw new error.MastraError({
+      id: storage.createStorageErrorId("MONGODB", "CONSTRUCTOR", "MISSING_URI"),
+      domain: error.ErrorDomain.STORAGE,
+      category: error.ErrorCategory.USER,
+      details: { dbName: config?.dbName },
+      text: 'MongoDBStore requires a connection string. Provide "uri" (recommended) or "url" in the constructor options.'
+    });
+  }
   try {
     return MongoDBConnector.fromDatabaseConfig({
       id: "id" in config ? config.id : "domain",
       options: config.options,
-      url: config.url,
+      url: connectionString,
       dbName: config.dbName
     });
   } catch (error$1) {
@@ -872,7 +888,7 @@ function resolveMongoDBConfig(config) {
         id: storage.createStorageErrorId("MONGODB", "CONSTRUCTOR", "FAILED"),
         domain: error.ErrorDomain.STORAGE,
         category: error.ErrorCategory.USER,
-        details: { url: config?.url, dbName: config?.dbName }
+        details: { uri: config?.uri ?? "", url: config?.url ?? "", dbName: config?.dbName ?? "" }
       },
       error$1
     );
@@ -883,7 +899,7 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
   #skipDefaultIndexes;
   #indexes;
   /** Collections managed by this domain */
-  static MANAGED_COLLECTIONS = [storage.TABLE_AGENTS];
+  static MANAGED_COLLECTIONS = [storage.TABLE_AGENTS, storage.TABLE_AGENT_VERSIONS];
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -903,7 +919,10 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
     return [
       { collection: storage.TABLE_AGENTS, keys: { id: 1 }, options: { unique: true } },
       { collection: storage.TABLE_AGENTS, keys: { createdAt: -1 } },
-      { collection: storage.TABLE_AGENTS, keys: { updatedAt: -1 } }
+      { collection: storage.TABLE_AGENTS, keys: { updatedAt: -1 } },
+      { collection: storage.TABLE_AGENT_VERSIONS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_AGENT_VERSIONS, keys: { agentId: 1, versionNumber: -1 }, options: { unique: true } },
+      { collection: storage.TABLE_AGENT_VERSIONS, keys: { agentId: 1, createdAt: -1 } }
     ];
   }
   async createDefaultIndexes() {
@@ -940,8 +959,10 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
     await this.createCustomIndexes();
   }
   async dangerouslyClearAll() {
-    const collection = await this.getCollection(storage.TABLE_AGENTS);
-    await collection.deleteMany({});
+    const versionsCollection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+    await versionsCollection.deleteMany({});
+    const agentsCollection = await this.getCollection(storage.TABLE_AGENTS);
+    await agentsCollection.deleteMany({});
   }
   async getAgentById({ id }) {
     try {
@@ -1027,6 +1048,9 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       if (updates.outputProcessors !== void 0) updateDoc.outputProcessors = updates.outputProcessors;
       if (updates.memory !== void 0) updateDoc.memory = updates.memory;
       if (updates.scorers !== void 0) updateDoc.scorers = updates.scorers;
+      if (updates.integrationTools !== void 0) updateDoc.integrationTools = updates.integrationTools;
+      if (updates.ownerId !== void 0) updateDoc.ownerId = updates.ownerId;
+      if (updates.activeVersionId !== void 0) updateDoc.activeVersionId = updates.activeVersionId;
       if (updates.metadata !== void 0) {
         const existingMetadata = existingAgent.metadata || {};
         updateDoc.metadata = { ...existingMetadata, ...updates.metadata };
@@ -1060,6 +1084,7 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
   }
   async deleteAgent({ id }) {
     try {
+      await this.deleteVersionsByAgentId(id);
       const collection = await this.getCollection(storage.TABLE_AGENTS);
       await collection.deleteOne({ id });
     } catch (error$1) {
@@ -1143,6 +1168,212 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsSto
       ...agent
     };
   }
+  // ==========================================================================
+  // Agent Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+      const now = /* @__PURE__ */ new Date();
+      const versionDoc = {
+        id: input.id,
+        agentId: input.agentId,
+        versionNumber: input.versionNumber,
+        name: input.name ?? void 0,
+        snapshot: input.snapshot,
+        changedFields: input.changedFields ?? void 0,
+        changeMessage: input.changeMessage ?? void 0,
+        createdAt: now
+      };
+      await collection.insertOne(versionDoc);
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, agentId: input.agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENT_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_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(agentId, versionNumber) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+      const result = await collection.findOne({ agentId, versionNumber });
+      if (!result) {
+        return null;
+      }
+      return this.transformVersion(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(agentId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+      const result = await collection.find({ agentId }).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_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { agentId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_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_AGENT_VERSIONS);
+      const total = await collection.countDocuments({ agentId });
+      if (total === 0 || perPage === 0) {
+        return {
+          versions: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find({ agentId }).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_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByAgentId(agentId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+      await collection.deleteMany({ agentId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_VERSIONS_BY_AGENT_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(agentId) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENT_VERSIONS);
+      return await collection.countDocuments({ agentId });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "COUNT_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  transformVersion(doc) {
+    const { _id, ...version } = doc;
+    return {
+      ...version,
+      createdAt: version.createdAt instanceof Date ? version.createdAt : new Date(version.createdAt)
+    };
+  }
 };
 function formatDateForMongoDB(date) {
   return typeof date === "string" ? new Date(date) : date;
@@ -1337,10 +1568,12 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
         query.resourceId = resourceId;
       }
       if (filter?.dateRange?.start) {
-        query.createdAt = { ...query.createdAt, $gte: filter.dateRange.start };
+        const startOp = filter.dateRange.startExclusive ? "$gt" : "$gte";
+        query.createdAt = { ...query.createdAt, [startOp]: formatDateForMongoDB(filter.dateRange.start) };
       }
       if (filter?.dateRange?.end) {
-        query.createdAt = { ...query.createdAt, $lte: filter.dateRange.end };
+        const endOp = filter.dateRange.endExclusive ? "$lt" : "$lte";
+        query.createdAt = { ...query.createdAt, [endOp]: formatDateForMongoDB(filter.dateRange.end) };
       }
       const total = await collection.countDocuments(query);
       const messages = [];
@@ -1671,25 +1904,48 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
       );
     }
   }
-  async listThreadsByResourceId(args) {
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+    try {
+      this.validatePaginationInput(page, perPageInput ?? 100);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_THREADS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
+        },
+        error$1 instanceof Error ? error$1 : new Error("Invalid pagination parameters")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    try {
+      this.validateMetadataKeys(filter?.metadata);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "LIST_THREADS", "INVALID_METADATA_KEY"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
+        },
+        error$1 instanceof Error ? error$1 : new Error("Invalid metadata key")
+      );
+    }
     try {
-      const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
-      if (page < 0) {
-        throw new error.MastraError(
-          {
-            id: storage.createStorageErrorId("MONGODB", "LIST_THREADS_BY_RESOURCE_ID", "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 { field, direction } = this.parseOrderBy(orderBy);
       const collection = await this.getCollection(storage.TABLE_THREADS);
-      const query = { resourceId };
+      const query = {};
+      if (filter?.resourceId) {
+        query.resourceId = filter.resourceId;
+      }
+      if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+        for (const [key, value] of Object.entries(filter.metadata)) {
+          query[`metadata.${key}`] = value;
+        }
+      }
       const total = await collection.countDocuments(query);
       if (perPage === 0) {
         return {
@@ -1723,10 +1979,13 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemorySto
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("MONGODB", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
+          id: storage.createStorageErrorId("MONGODB", "LIST_THREADS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId: args.resourceId }
+          details: {
+            ...filter?.resourceId && { resourceId: filter.resourceId },
+            hasMetadataFilter: !!filter?.metadata
+          }
         },
         error$1
       );
@@ -1908,8 +2167,220 @@ var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.Observabi
     }
   }
   async init() {
+    const uniqueIndexExists = await this.spansUniqueIndexExists();
+    if (!uniqueIndexExists) {
+      const duplicateInfo = await this.checkForDuplicateSpans();
+      if (duplicateInfo.hasDuplicates) {
+        const errorMessage = `
+===========================================================================
+MIGRATION REQUIRED: Duplicate spans detected in ${storage.TABLE_SPANS} collection
+===========================================================================
+
+Found ${duplicateInfo.duplicateCount} duplicate (traceId, spanId) combinations.
+
+The spans collection requires a unique index on (traceId, spanId), but your
+database contains duplicate entries that must be resolved first.
+
+To fix this, run the manual migration command:
+
+  npx mastra migrate
+
+This command will:
+  1. Remove duplicate spans (keeping the most complete/recent version)
+  2. Add the required unique index
+
+Note: This migration may take some time for large collections.
+===========================================================================
+`;
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "MIGRATION_REQUIRED", "DUPLICATE_SPANS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: errorMessage
+        });
+      }
+    }
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Checks if the unique index on (spanId, traceId) already exists on the spans collection.
+   * Used to skip deduplication when the index already exists (migration already complete).
+   */
+  async spansUniqueIndexExists() {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      const indexes = await collection.indexes();
+      return indexes.some((idx) => idx.unique === true && idx.key?.spanId === 1 && idx.key?.traceId === 1);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Checks for duplicate (traceId, spanId) combinations in the spans collection.
+   * Returns information about duplicates for logging/CLI purposes.
+   */
+  async checkForDuplicateSpans() {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      const result = await collection.aggregate([
+        {
+          $group: {
+            _id: { traceId: "$traceId", spanId: "$spanId" },
+            count: { $sum: 1 }
+          }
+        },
+        { $match: { count: { $gt: 1 } } },
+        { $count: "duplicateCount" }
+      ]).toArray();
+      const duplicateCount = result[0]?.duplicateCount ?? 0;
+      return {
+        hasDuplicates: duplicateCount > 0,
+        duplicateCount
+      };
+    } catch (error) {
+      this.logger?.debug?.(`Could not check for duplicates: ${error}`);
+      return { hasDuplicates: false, duplicateCount: 0 };
+    }
+  }
+  /**
+   * Manually run the spans migration to deduplicate and add the unique index.
+   * This is intended to be called from the CLI when duplicates are detected.
+   *
+   * @returns Migration result with status and details
+   */
+  async migrateSpans() {
+    const indexExists = await this.spansUniqueIndexExists();
+    if (indexExists) {
+      return {
+        success: true,
+        alreadyMigrated: true,
+        duplicatesRemoved: 0,
+        message: `Migration already complete. Unique index exists on ${storage.TABLE_SPANS} collection.`
+      };
+    }
+    const duplicateInfo = await this.checkForDuplicateSpans();
+    if (duplicateInfo.hasDuplicates) {
+      this.logger?.info?.(
+        `Found ${duplicateInfo.duplicateCount} duplicate (traceId, spanId) combinations. Starting deduplication...`
+      );
+      await this.deduplicateSpans();
+    } else {
+      this.logger?.info?.(`No duplicate spans found.`);
+    }
     await this.createDefaultIndexes();
     await this.createCustomIndexes();
+    return {
+      success: true,
+      alreadyMigrated: false,
+      duplicatesRemoved: duplicateInfo.duplicateCount,
+      message: duplicateInfo.hasDuplicates ? `Migration complete. Removed duplicates and added unique index to ${storage.TABLE_SPANS} collection.` : `Migration complete. Added unique index to ${storage.TABLE_SPANS} collection.`
+    };
+  }
+  /**
+   * Check migration status for the spans collection.
+   * Returns information about whether migration is needed.
+   */
+  async checkSpansMigrationStatus() {
+    const indexExists = await this.spansUniqueIndexExists();
+    if (indexExists) {
+      return {
+        needsMigration: false,
+        hasDuplicates: false,
+        duplicateCount: 0,
+        constraintExists: true,
+        tableName: storage.TABLE_SPANS
+      };
+    }
+    const duplicateInfo = await this.checkForDuplicateSpans();
+    return {
+      needsMigration: true,
+      hasDuplicates: duplicateInfo.hasDuplicates,
+      duplicateCount: duplicateInfo.duplicateCount,
+      constraintExists: false,
+      tableName: storage.TABLE_SPANS
+    };
+  }
+  /**
+   * Deduplicates spans with the same (traceId, spanId) combination.
+   * This is needed for databases that existed before the unique constraint was added.
+   *
+   * Priority for keeping spans:
+   * 1. Completed spans (endedAt IS NOT NULL) over incomplete spans
+   * 2. Most recent updatedAt
+   * 3. Most recent createdAt (as tiebreaker)
+   *
+   * Note: This prioritizes migration completion over perfect data preservation.
+   * Old trace data may be lost, which is acceptable for this use case.
+   */
+  async deduplicateSpans() {
+    try {
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      const duplicateCheck = await collection.aggregate([
+        {
+          $group: {
+            _id: { traceId: "$traceId", spanId: "$spanId" },
+            count: { $sum: 1 }
+          }
+        },
+        { $match: { count: { $gt: 1 } } },
+        { $limit: 1 }
+      ]).toArray();
+      if (duplicateCheck.length === 0) {
+        this.logger?.debug?.("No duplicate spans found");
+        return;
+      }
+      this.logger?.info?.("Duplicate spans detected, starting deduplication...");
+      const idsToDelete = await collection.aggregate([
+        // Sort by priority (affects which document $first picks within each group)
+        {
+          $sort: {
+            // Completed spans first (endedAt exists and is not null)
+            endedAt: -1,
+            updatedAt: -1,
+            createdAt: -1
+          }
+        },
+        // Group by (traceId, spanId), keeping the first (best) _id and all _ids
+        {
+          $group: {
+            _id: { traceId: "$traceId", spanId: "$spanId" },
+            keepId: { $first: "$_id" },
+            // The best one to keep (after sort)
+            allIds: { $push: "$_id" },
+            // All ObjectIds (just 12 bytes each, not full docs)
+            count: { $sum: 1 }
+          }
+        },
+        // Only consider groups with duplicates
+        { $match: { count: { $gt: 1 } } },
+        // Get IDs to delete (allIds minus keepId)
+        {
+          $project: {
+            idsToDelete: {
+              $filter: {
+                input: "$allIds",
+                cond: { $ne: ["$$this", "$keepId"] }
+              }
+            }
+          }
+        },
+        // Unwind to get flat list of IDs
+        { $unwind: "$idsToDelete" },
+        // Just output the ID
+        { $project: { _id: "$idsToDelete" } }
+      ]).toArray();
+      if (idsToDelete.length === 0) {
+        this.logger?.debug?.("No duplicates to delete after aggregation");
+        return;
+      }
+      const deleteResult = await collection.deleteMany({
+        _id: { $in: idsToDelete.map((d) => d._id) }
+      });
+      this.logger?.info?.(`Deduplication complete: removed ${deleteResult.deletedCount} duplicate spans`);
+    } catch (error) {
+      this.logger?.warn?.("Failed to deduplicate spans:", error);
+    }
   }
   async dangerouslyClearAll() {
     const collection = await this.getCollection(storage.TABLE_SPANS);
@@ -2191,7 +2662,7 @@ var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.Observabi
             // No children with errors
           }
         ];
-        const countResult = await collection.aggregate([...pipeline, { $count: "total" }]).toArray();
+        const countResult = await collection.aggregate([...pipeline, { $count: "total" }], { allowDiskUse: true }).toArray();
         const count2 = countResult[0]?.total || 0;
         if (count2 === 0) {
           return {
@@ -2228,7 +2699,7 @@ var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.Observabi
             { $project: { _errorSpans: 0 } }
           ];
         }
-        const spans2 = await collection.aggregate(aggregationPipeline).toArray();
+        const spans2 = await collection.aggregate(aggregationPipeline, { allowDiskUse: true }).toArray();
         return {
           pagination: {
             total: count2,
@@ -2236,7 +2707,7 @@ var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.Observabi
             perPage,
             hasMore: (page + 1) * perPage < count2
           },
-          spans: spans2.map((span) => this.transformSpanFromMongo(span))
+          spans: storage.toTraceSpans(spans2.map((span) => this.transformSpanFromMongo(span)))
         };
       }
       const count = await collection.countDocuments(mongoFilter);
@@ -2254,18 +2725,21 @@ var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.Observabi
       let spans;
       if (sortField === "endedAt") {
         const nullSortValue = sortDirection === -1 ? 0 : 1;
-        spans = await collection.aggregate([
-          { $match: mongoFilter },
-          {
-            $addFields: {
-              _endedAtNull: { $cond: [{ $eq: ["$endedAt", null] }, nullSortValue, sortDirection === -1 ? 1 : 0] }
-            }
-          },
-          { $sort: { _endedAtNull: 1, [sortField]: sortDirection } },
-          { $skip: page * perPage },
-          { $limit: perPage },
-          { $project: { _endedAtNull: 0 } }
-        ]).toArray();
+        spans = await collection.aggregate(
+          [
+            { $match: mongoFilter },
+            {
+              $addFields: {
+                _endedAtNull: { $cond: [{ $eq: ["$endedAt", null] }, nullSortValue, sortDirection === -1 ? 1 : 0] }
+              }
+            },
+            { $sort: { _endedAtNull: 1, [sortField]: sortDirection } },
+            { $skip: page * perPage },
+            { $limit: perPage },
+            { $project: { _endedAtNull: 0 } }
+          ],
+          { allowDiskUse: true }
+        ).toArray();
       } else {
         spans = await collection.find(mongoFilter).sort({ [sortField]: sortDirection }).skip(page * perPage).limit(perPage).toArray();
       }
@@ -2276,7 +2750,7 @@ var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.Observabi
           perPage,
           hasMore: (page + 1) * perPage < count
         },
-        spans: spans.map((span) => this.transformSpanFromMongo(span))
+        spans: storage.toTraceSpans(spans.map((span) => this.transformSpanFromMongo(span)))
       };
     } catch (error$1) {
       throw new error.MastraError(
@@ -2581,7 +3055,7 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends storage.ScoresSto
         };
       }
       const end = perPageInput === false ? total : start + perPage;
-      let cursor = collection.find(query).sort({ createdAt: "desc" }).skip(start);
+      let cursor = collection.find(query).sort({ createdAt: -1 }).skip(start);
       if (perPageInput !== false) {
         cursor = cursor.limit(perPage);
       }
@@ -2630,7 +3104,7 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends storage.ScoresSto
         };
       }
       const end = perPageInput === false ? total : start + perPage;
-      let cursor = collection.find({ runId }).sort({ createdAt: "desc" }).skip(start);
+      let cursor = collection.find({ runId }).sort({ createdAt: -1 }).skip(start);
       if (perPageInput !== false) {
         cursor = cursor.limit(perPage);
       }
@@ -2680,7 +3154,7 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends storage.ScoresSto
         };
       }
       const end = perPageInput === false ? total : start + perPage;
-      let cursor = collection.find({ entityId, entityType }).sort({ createdAt: "desc" }).skip(start);
+      let cursor = collection.find({ entityId, entityType }).sort({ createdAt: -1 }).skip(start);
       if (perPageInput !== false) {
         cursor = cursor.limit(perPage);
       }
@@ -2731,7 +3205,7 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends storage.ScoresSto
         };
       }
       const end = perPageInput === false ? total : start + perPage;
-      let cursor = collection.find(query).sort({ createdAt: "desc" }).skip(start);
+      let cursor = collection.find(query).sort({ createdAt: -1 }).skip(start);
       if (perPageInput !== false) {
         cursor = cursor.limit(perPage);
       }
@@ -3024,7 +3498,7 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.Wor
       try {
         parsedSnapshot = typeof row.snapshot === "string" ? storage.safelyParseJSON(row.snapshot) : row.snapshot;
       } catch (e) {
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
       }
     }
     return {
@@ -3039,7 +3513,7 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends storage.Wor
 };
 
 // src/storage/index.ts
-var MongoDBStore = class extends storage.MastraStorage {
+var MongoDBStore = class extends storage.MastraCompositeStore {
   #connector;
   stores;
   constructor(config) {