@mastra/mongodb 1.0.0-beta.7 → 1.0.0-beta.8

package/dist/index.cjs

@@ -13,7 +13,7 @@ var evals = require('@mastra/core/evals');
 
 // package.json
 var package_default = {
-  version: "1.0.0-beta.7"};
+  version: "1.0.0-beta.8"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -838,16 +838,401 @@ var MongoDBConnector = class _MongoDBConnector {
     }
   }
 };
+
+// src/storage/db/index.ts
+function resolveMongoDBConfig(config) {
+  if ("connector" in config) {
+    return config.connector;
+  }
+  if ("connectorHandler" in config) {
+    try {
+      return MongoDBConnector.fromConnectionHandler(config.connectorHandler);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CONSTRUCTOR", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { connectionHandler: true }
+        },
+        error$1
+      );
+    }
+  }
+  try {
+    return MongoDBConnector.fromDatabaseConfig({
+      id: "id" in config ? config.id : "domain",
+      options: config.options,
+      url: config.url,
+      dbName: config.dbName
+    });
+  } catch (error$1) {
+    throw new error.MastraError(
+      {
+        id: storage.createStorageErrorId("MONGODB", "CONSTRUCTOR", "FAILED"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { url: config?.url, dbName: config?.dbName }
+      },
+      error$1
+    );
+  }
+}
+var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends storage.AgentsStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Collections managed by this domain */
+  static MANAGED_COLLECTIONS = [storage.TABLE_AGENTS];
+  constructor(config) {
+    super();
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MongoDBAgentsStorage.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  /**
+   * Returns default index definitions for the agents domain collections.
+   * These indexes optimize common query patterns for agent lookups.
+   */
+  getDefaultIndexDefinitions() {
+    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 } }
+    ];
+  }
+  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 init() {
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  async dangerouslyClearAll() {
+    const collection = await this.getCollection(storage.TABLE_AGENTS);
+    await collection.deleteMany({});
+  }
+  async getAgentById({ id }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENTS);
+      const result = await collection.findOne({ id });
+      if (!result) {
+        return null;
+      }
+      return this.transformAgent(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_AGENT_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async createAgent({ agent }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENTS);
+      const existing = await collection.findOne({ id: agent.id });
+      if (existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "CREATE_AGENT", "ALREADY_EXISTS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id: agent.id },
+          text: `Agent with id ${agent.id} already exists`
+        });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const newAgent = {
+        ...agent,
+        createdAt: now,
+        updatedAt: now
+      };
+      await collection.insertOne(this.serializeAgent(newAgent));
+      return newAgent;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "CREATE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id: agent.id }
+        },
+        error$1
+      );
+    }
+  }
+  async updateAgent({ id, ...updates }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENTS);
+      const existingAgent = await collection.findOne({ id });
+      if (!existingAgent) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_AGENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { id },
+          text: `Agent with id ${id} not found`
+        });
+      }
+      const updateDoc = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (updates.name !== void 0) updateDoc.name = updates.name;
+      if (updates.description !== void 0) updateDoc.description = updates.description;
+      if (updates.instructions !== void 0) updateDoc.instructions = updates.instructions;
+      if (updates.model !== void 0) updateDoc.model = updates.model;
+      if (updates.tools !== void 0) updateDoc.tools = updates.tools;
+      if (updates.defaultOptions !== void 0) updateDoc.defaultOptions = updates.defaultOptions;
+      if (updates.workflows !== void 0) updateDoc.workflows = updates.workflows;
+      if (updates.agents !== void 0) updateDoc.agents = updates.agents;
+      if (updates.inputProcessors !== void 0) updateDoc.inputProcessors = updates.inputProcessors;
+      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.metadata !== void 0) {
+        const existingMetadata = existingAgent.metadata || {};
+        updateDoc.metadata = { ...existingMetadata, ...updates.metadata };
+      }
+      await collection.updateOne({ id }, { $set: updateDoc });
+      const updatedAgent = await collection.findOne({ id });
+      if (!updatedAgent) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_AGENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Agent with id ${id} was deleted during update`,
+          details: { id }
+        });
+      }
+      return this.transformAgent(updatedAgent);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "UPDATE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteAgent({ id }) {
+    try {
+      const collection = await this.getCollection(storage.TABLE_AGENTS);
+      await collection.deleteOne({ id });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async listAgents(args) {
+    try {
+      const { page = 0, perPage: perPageInput, orderBy } = args || {};
+      const { field, direction } = this.parseOrderBy(orderBy);
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("MONGODB", "LIST_AGENTS", "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_AGENTS);
+      const total = await collection.countDocuments({});
+      if (total === 0 || perPage === 0) {
+        return {
+          agents: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find({}).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const results = await cursor.toArray();
+      const agents = results.map((doc) => this.transformAgent(doc));
+      return {
+        agents,
+        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_AGENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  transformAgent(doc) {
+    const { _id, ...agent } = doc;
+    return {
+      ...agent,
+      createdAt: agent.createdAt instanceof Date ? agent.createdAt : new Date(agent.createdAt),
+      updatedAt: agent.updatedAt instanceof Date ? agent.updatedAt : new Date(agent.updatedAt)
+    };
+  }
+  serializeAgent(agent) {
+    return {
+      ...agent
+    };
+  }
+};
 function formatDateForMongoDB(date) {
   return typeof date === "string" ? new Date(date) : date;
 }
 
 // src/storage/domains/memory/index.ts
-var MemoryStorageMongoDB = class extends storage.MemoryStorage {
-  operations;
-  constructor({ operations }) {
+var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends storage.MemoryStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Collections managed by this domain */
+  static MANAGED_COLLECTIONS = [storage.TABLE_THREADS, storage.TABLE_MESSAGES, storage.TABLE_RESOURCES];
+  constructor(config) {
     super();
-    this.operations = operations;
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _MemoryStorageMongoDB.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 memory domain collections.
+   */
+  getDefaultIndexDefinitions() {
+    return [
+      // Threads collection indexes
+      { collection: storage.TABLE_THREADS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_THREADS, keys: { resourceId: 1 } },
+      { collection: storage.TABLE_THREADS, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_THREADS, keys: { updatedAt: -1 } },
+      // Messages collection indexes
+      { collection: storage.TABLE_MESSAGES, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_MESSAGES, keys: { thread_id: 1 } },
+      { collection: storage.TABLE_MESSAGES, keys: { resourceId: 1 } },
+      { collection: storage.TABLE_MESSAGES, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_MESSAGES, keys: { thread_id: 1, createdAt: 1 } },
+      // Resources collection indexes
+      { collection: storage.TABLE_RESOURCES, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_RESOURCES, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_RESOURCES, keys: { updatedAt: -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 threadsCollection = await this.getCollection(storage.TABLE_THREADS);
+    const messagesCollection = await this.getCollection(storage.TABLE_MESSAGES);
+    const resourcesCollection = await this.getCollection(storage.TABLE_RESOURCES);
+    await Promise.all([
+      threadsCollection.deleteMany({}),
+      messagesCollection.deleteMany({}),
+      resourcesCollection.deleteMany({})
+    ]);
   }
   parseRow(row) {
     let content = row.content;
@@ -870,7 +1255,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
   }
   async _getIncludedMessages({ include }) {
     if (!include || include.length === 0) return null;
-    const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+    const collection = await this.getCollection(storage.TABLE_MESSAGES);
     const includedMessages = [];
     for (const inc of include) {
       const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
@@ -897,7 +1282,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
   async listMessagesById({ messageIds }) {
     if (messageIds.length === 0) return { messages: [] };
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const collection = await this.getCollection(storage.TABLE_MESSAGES);
       const rawMessages = await collection.find({ id: { $in: messageIds } }).sort({ createdAt: -1 }).toArray();
       const list = new agent.MessageList().add(
         rawMessages.map(this.parseRow),
@@ -946,7 +1331,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
     try {
       const { field, direction } = this.parseOrderBy(orderBy, "ASC");
       const sortOrder = direction === "ASC" ? 1 : -1;
-      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const collection = await this.getCollection(storage.TABLE_MESSAGES);
       const query = { thread_id: threadIds.length === 1 ? threadIds[0] : { $in: threadIds } };
       if (resourceId) {
         query.resourceId = resourceId;
@@ -1044,8 +1429,8 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
       if (!threadId) {
         throw new Error("Thread ID is required");
       }
-      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
-      const threadsCollection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const collection = await this.getCollection(storage.TABLE_MESSAGES);
+      const threadsCollection = await this.getCollection(storage.TABLE_THREADS);
       const messagesToInsert = messages.map((message) => {
         const time = message.createdAt || /* @__PURE__ */ new Date();
         if (!message.threadId) {
@@ -1100,7 +1485,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
       return [];
     }
     const messageIds = messages.map((m) => m.id);
-    const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+    const collection = await this.getCollection(storage.TABLE_MESSAGES);
     const existingMessages = await collection.find({ id: { $in: messageIds } }).toArray();
     const existingMessagesParsed = existingMessages.map((msg) => this.parseRow(msg));
     if (existingMessagesParsed.length === 0) {
@@ -1157,7 +1542,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
       await collection.bulkWrite(bulkOps);
     }
     if (threadIdsToUpdate.size > 0) {
-      const threadsCollection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const threadsCollection = await this.getCollection(storage.TABLE_THREADS);
       await threadsCollection.updateMany(
         { id: { $in: Array.from(threadIdsToUpdate) } },
         { $set: { updatedAt: /* @__PURE__ */ new Date() } }
@@ -1168,7 +1553,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
   }
   async getResourceById({ resourceId }) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      const collection = await this.getCollection(storage.TABLE_RESOURCES);
       const result = await collection.findOne({ id: resourceId });
       if (!result) {
         return null;
@@ -1194,7 +1579,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
   }
   async saveResource({ resource }) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      const collection = await this.getCollection(storage.TABLE_RESOURCES);
       await collection.updateOne(
         { id: resource.id },
         {
@@ -1241,7 +1626,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
         metadata: metadata ? { ...existingResource.metadata, ...metadata } : existingResource.metadata,
         updatedAt: /* @__PURE__ */ new Date()
       };
-      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      const collection = await this.getCollection(storage.TABLE_RESOURCES);
       const updateDoc = { updatedAt: updatedResource.updatedAt };
       if (workingMemory !== void 0) {
         updateDoc.workingMemory = workingMemory;
@@ -1265,7 +1650,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
   }
   async getThreadById({ threadId }) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const collection = await this.getCollection(storage.TABLE_THREADS);
       const result = await collection.findOne({ id: threadId });
       if (!result) {
         return null;
@@ -1303,7 +1688,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
       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.operations.getCollection(storage.TABLE_THREADS);
+      const collection = await this.getCollection(storage.TABLE_THREADS);
       const query = { resourceId };
       const total = await collection.countDocuments(query);
       if (perPage === 0) {
@@ -1349,7 +1734,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
   }
   async saveThread({ thread }) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const collection = await this.getCollection(storage.TABLE_THREADS);
       await collection.updateOne(
         { id: thread.id },
         {
@@ -1397,7 +1782,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
       }
     };
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const collection = await this.getCollection(storage.TABLE_THREADS);
       await collection.updateOne(
         { id },
         {
@@ -1422,9 +1807,9 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
   }
   async deleteThread({ threadId }) {
     try {
-      const collectionMessages = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const collectionMessages = await this.getCollection(storage.TABLE_MESSAGES);
       await collectionMessages.deleteMany({ thread_id: threadId });
-      const collectionThreads = await this.operations.getCollection(storage.TABLE_THREADS);
+      const collectionThreads = await this.getCollection(storage.TABLE_THREADS);
       await collectionThreads.deleteOne({ id: threadId });
     } catch (error$1) {
       throw new error.MastraError(
@@ -1438,12 +1823,97 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
       );
     }
   }
+  async deleteMessages(messageIds) {
+    if (messageIds.length === 0) return;
+    try {
+      const messagesCollection = await this.getCollection(storage.TABLE_MESSAGES);
+      const threadsCollection = await this.getCollection(storage.TABLE_THREADS);
+      const messagesToDelete = await messagesCollection.find({ id: { $in: messageIds } }).toArray();
+      const threadIds = [...new Set(messagesToDelete.map((m) => m.thread_id))];
+      await messagesCollection.deleteMany({ id: { $in: messageIds } });
+      if (threadIds.length > 0) {
+        await threadsCollection.updateMany({ id: { $in: threadIds } }, { $set: { updatedAt: /* @__PURE__ */ new Date() } });
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "DELETE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error$1
+      );
+    }
+  }
 };
-var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
-  operations;
-  constructor({ operations }) {
+var ObservabilityMongoDB = class _ObservabilityMongoDB extends storage.ObservabilityStorage {
+  #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Collections managed by this domain */
+  static MANAGED_COLLECTIONS = [storage.TABLE_SPANS];
+  constructor(config) {
     super();
-    this.operations = operations;
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _ObservabilityMongoDB.MANAGED_COLLECTIONS.includes(idx.collection)
+    );
+  }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
+  }
+  /**
+   * Returns default index definitions for the observability domain collections.
+   * These indexes optimize common query patterns for span and trace lookups.
+   */
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_SPANS, keys: { spanId: 1, traceId: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_SPANS, keys: { traceId: 1 } },
+      { collection: storage.TABLE_SPANS, keys: { parentSpanId: 1 } },
+      { collection: storage.TABLE_SPANS, keys: { startedAt: -1 } },
+      { collection: storage.TABLE_SPANS, keys: { spanType: 1 } },
+      { collection: storage.TABLE_SPANS, keys: { name: 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);
+      }
+    }
+  }
+  /**
+   * 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 init() {
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  async dangerouslyClearAll() {
+    const collection = await this.getCollection(storage.TABLE_SPANS);
+    await collection.deleteMany({});
   }
   get tracingStrategy() {
     return {
@@ -1451,7 +1921,8 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
       supported: ["batch-with-updates", "insert-only"]
     };
   }
-  async createSpan(span) {
+  async createSpan(args) {
+    const { span } = args;
     try {
       const startedAt = span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt;
       const endedAt = span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt;
@@ -1462,7 +1933,8 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      return this.operations.insert({ tableName: storage.TABLE_SPANS, record });
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      await collection.insertOne(record);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1473,60 +1945,101 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
             spanId: span.spanId,
             traceId: span.traceId,
             spanType: span.spanType,
-            spanName: span.name
+            name: span.name
           }
         },
         error$1
       );
     }
   }
-  async getTrace(traceId) {
+  async getSpan(args) {
+    const { traceId, spanId } = args;
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_SPANS);
-      const spans = await collection.find({ traceId }).sort({ startedAt: -1 }).toArray();
-      if (!spans || spans.length === 0) {
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      const span = await collection.findOne({ traceId, spanId });
+      if (!span) {
         return null;
       }
       return {
-        traceId,
-        spans: spans.map((span) => this.transformSpanFromMongo(span))
+        span: this.transformSpanFromMongo(span)
       };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("MONGODB", "GET_TRACE", "FAILED"),
+          id: storage.createStorageErrorId("MONGODB", "GET_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
-          details: {
-            traceId
-          }
+          details: { traceId, spanId }
         },
         error$1
       );
     }
   }
-  async updateSpan({
-    spanId,
-    traceId,
-    updates
-  }) {
+  async getRootSpan(args) {
+    const { traceId } = args;
     try {
-      const data = { ...updates };
-      if (data.endedAt instanceof Date) {
-        data.endedAt = data.endedAt.toISOString();
-      }
-      if (data.startedAt instanceof Date) {
-        data.startedAt = data.startedAt.toISOString();
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      const span = await collection.findOne({ traceId, parentSpanId: null });
+      if (!span) {
+        return null;
+      }
+      return {
+        span: this.transformSpanFromMongo(span)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_ROOT_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { traceId }
+        },
+        error$1
+      );
+    }
+  }
+  async getTrace(args) {
+    const { traceId } = args;
+    try {
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      const spans = await collection.find({ traceId }).sort({ startedAt: 1 }).toArray();
+      if (!spans || spans.length === 0) {
+        return null;
+      }
+      return {
+        traceId,
+        spans: spans.map((span) => this.transformSpanFromMongo(span))
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MONGODB", "GET_TRACE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async updateSpan(args) {
+    const { traceId, spanId, updates } = args;
+    try {
+      const data = { ...updates };
+      if (data.endedAt instanceof Date) {
+        data.endedAt = data.endedAt.toISOString();
+      }
+      if (data.startedAt instanceof Date) {
+        data.startedAt = data.startedAt.toISOString();
       }
       const updateData = {
         ...data,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await this.operations.update({
-        tableName: storage.TABLE_SPANS,
-        keys: { spanId, traceId },
-        data: updateData
-      });
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      await collection.updateOne({ spanId, traceId }, { $set: updateData });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1542,51 +2055,189 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async getTracesPaginated({
-    filters,
-    pagination
-  }) {
-    const page = pagination?.page ?? 0;
-    const perPage = pagination?.perPage ?? 10;
-    const { entityId, entityType, ...actualFilters } = filters || {};
+  async listTraces(args) {
+    const { filters, pagination, orderBy } = storage.listTracesArgsSchema.parse(args);
+    const { page, perPage } = pagination;
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_SPANS);
+      const collection = await this.getCollection(storage.TABLE_SPANS);
       const mongoFilter = {
-        parentSpanId: null,
+        parentSpanId: null
         // Only get root spans for traces
-        ...actualFilters
       };
-      if (pagination?.dateRange) {
-        const dateFilter = {};
-        if (pagination.dateRange.start) {
-          dateFilter.$gte = pagination.dateRange.start instanceof Date ? pagination.dateRange.start.toISOString() : pagination.dateRange.start;
+      const andConditions = [];
+      if (filters) {
+        if (filters.startedAt) {
+          const startedAtFilter = {};
+          if (filters.startedAt.start) {
+            startedAtFilter.$gte = filters.startedAt.start.toISOString();
+          }
+          if (filters.startedAt.end) {
+            startedAtFilter.$lte = filters.startedAt.end.toISOString();
+          }
+          if (Object.keys(startedAtFilter).length > 0) {
+            mongoFilter.startedAt = startedAtFilter;
+          }
+        }
+        if (filters.endedAt) {
+          const endedAtFilter = {};
+          if (filters.endedAt.start) {
+            endedAtFilter.$gte = filters.endedAt.start.toISOString();
+          }
+          if (filters.endedAt.end) {
+            endedAtFilter.$lte = filters.endedAt.end.toISOString();
+          }
+          if (Object.keys(endedAtFilter).length > 0) {
+            andConditions.push({ endedAt: endedAtFilter });
+          }
+        }
+        if (filters.spanType !== void 0) {
+          mongoFilter.spanType = filters.spanType;
+        }
+        if (filters.entityType !== void 0) {
+          mongoFilter.entityType = filters.entityType;
+        }
+        if (filters.entityId !== void 0) {
+          mongoFilter.entityId = filters.entityId;
+        }
+        if (filters.entityName !== void 0) {
+          mongoFilter.entityName = filters.entityName;
         }
-        if (pagination.dateRange.end) {
-          dateFilter.$lte = pagination.dateRange.end instanceof Date ? pagination.dateRange.end.toISOString() : pagination.dateRange.end;
+        if (filters.userId !== void 0) {
+          mongoFilter.userId = filters.userId;
         }
-        if (Object.keys(dateFilter).length > 0) {
-          mongoFilter.startedAt = dateFilter;
+        if (filters.organizationId !== void 0) {
+          mongoFilter.organizationId = filters.organizationId;
+        }
+        if (filters.resourceId !== void 0) {
+          mongoFilter.resourceId = filters.resourceId;
+        }
+        if (filters.runId !== void 0) {
+          mongoFilter.runId = filters.runId;
+        }
+        if (filters.sessionId !== void 0) {
+          mongoFilter.sessionId = filters.sessionId;
+        }
+        if (filters.threadId !== void 0) {
+          mongoFilter.threadId = filters.threadId;
+        }
+        if (filters.requestId !== void 0) {
+          mongoFilter.requestId = filters.requestId;
+        }
+        if (filters.environment !== void 0) {
+          mongoFilter.environment = filters.environment;
+        }
+        if (filters.source !== void 0) {
+          mongoFilter.source = filters.source;
+        }
+        if (filters.serviceName !== void 0) {
+          mongoFilter.serviceName = filters.serviceName;
+        }
+        if (filters.scope != null) {
+          for (const [key, value] of Object.entries(filters.scope)) {
+            mongoFilter[`scope.${key}`] = value;
+          }
+        }
+        if (filters.metadata != null) {
+          for (const [key, value] of Object.entries(filters.metadata)) {
+            mongoFilter[`metadata.${key}`] = value;
+          }
+        }
+        if (filters.tags != null && filters.tags.length > 0) {
+          mongoFilter.tags = { $all: filters.tags };
+        }
+        if (filters.status !== void 0) {
+          switch (filters.status) {
+            case storage.TraceStatus.ERROR:
+              andConditions.push({ error: { $exists: true, $ne: null } });
+              break;
+            case storage.TraceStatus.RUNNING:
+              andConditions.push({ endedAt: null, error: null });
+              break;
+            case storage.TraceStatus.SUCCESS:
+              andConditions.push({ endedAt: { $exists: true, $ne: null }, error: null });
+              break;
+          }
         }
       }
-      if (entityId && entityType) {
-        let name = "";
-        if (entityType === "workflow") {
-          name = `workflow run: '${entityId}'`;
-        } else if (entityType === "agent") {
-          name = `agent run: '${entityId}'`;
-        } else {
-          const error$1 = new error.MastraError({
-            id: storage.createStorageErrorId("MONGODB", "GET_TRACES_PAGINATED", "INVALID_ENTITY_TYPE"),
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            details: {
-              entityType
+      if (andConditions.length) {
+        mongoFilter.$and = andConditions;
+      }
+      const sortField = orderBy.field;
+      const sortDirection = orderBy.direction === "ASC" ? 1 : -1;
+      if (filters?.hasChildError !== void 0) {
+        const pipeline = [
+          { $match: mongoFilter },
+          // Lookup child spans with errors for this trace
+          {
+            $lookup: {
+              from: storage.TABLE_SPANS,
+              let: { traceId: "$traceId" },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: { $eq: ["$traceId", "$$traceId"] },
+                    error: { $exists: true, $ne: null }
+                  }
+                },
+                { $limit: 1 }
+                // Only need to know if at least one exists
+              ],
+              as: "_errorSpans"
+            }
+          },
+          // Filter based on whether error spans exist
+          {
+            $match: filters.hasChildError ? { _errorSpans: { $ne: [] } } : { _errorSpans: { $eq: [] } }
+            // No children with errors
+          }
+        ];
+        const countResult = await collection.aggregate([...pipeline, { $count: "total" }]).toArray();
+        const count2 = countResult[0]?.total || 0;
+        if (count2 === 0) {
+          return {
+            pagination: {
+              total: 0,
+              page,
+              perPage,
+              hasMore: false
             },
-            text: `Cannot filter by entity type: ${entityType}`
-          });
-          throw error$1;
+            spans: []
+          };
         }
-        mongoFilter.name = name;
+        let aggregationPipeline;
+        if (sortField === "endedAt") {
+          const nullSortValue = sortDirection === -1 ? 0 : 1;
+          aggregationPipeline = [
+            ...pipeline,
+            {
+              $addFields: {
+                _endedAtNull: { $cond: [{ $eq: ["$endedAt", null] }, nullSortValue, sortDirection === -1 ? 1 : 0] }
+              }
+            },
+            { $sort: { _endedAtNull: 1, [sortField]: sortDirection } },
+            { $skip: page * perPage },
+            { $limit: perPage },
+            { $project: { _errorSpans: 0, _endedAtNull: 0 } }
+          ];
+        } else {
+          aggregationPipeline = [
+            ...pipeline,
+            { $sort: { [sortField]: sortDirection } },
+            { $skip: page * perPage },
+            { $limit: perPage },
+            { $project: { _errorSpans: 0 } }
+          ];
+        }
+        const spans2 = await collection.aggregate(aggregationPipeline).toArray();
+        return {
+          pagination: {
+            total: count2,
+            page,
+            perPage,
+            hasMore: (page + 1) * perPage < count2
+          },
+          spans: spans2.map((span) => this.transformSpanFromMongo(span))
+        };
       }
       const count = await collection.countDocuments(mongoFilter);
       if (count === 0) {
@@ -1600,20 +2251,37 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
           spans: []
         };
       }
-      const spans = await collection.find(mongoFilter).sort({ startedAt: -1 }).skip(page * perPage).limit(perPage).toArray();
+      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();
+      } else {
+        spans = await collection.find(mongoFilter).sort({ [sortField]: sortDirection }).skip(page * perPage).limit(perPage).toArray();
+      }
       return {
         pagination: {
           total: count,
           page,
           perPage,
-          hasMore: spans.length === perPage
+          hasMore: (page + 1) * perPage < count
         },
         spans: spans.map((span) => this.transformSpanFromMongo(span))
       };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("MONGODB", "GET_TRACES_PAGINATED", "FAILED"),
+          id: storage.createStorageErrorId("MONGODB", "LIST_TRACES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -1634,10 +2302,10 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
       });
-      return this.operations.batchInsert({
-        tableName: storage.TABLE_SPANS,
-        records
-      });
+      if (records.length > 0) {
+        const collection = await this.getCollection(storage.TABLE_SPANS);
+        await collection.insertMany(records);
+      }
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1651,26 +2319,30 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
   }
   async batchUpdateSpans(args) {
     try {
-      return this.operations.batchUpdate({
-        tableName: storage.TABLE_SPANS,
-        updates: args.records.map((record) => {
-          const data = { ...record.updates };
-          if (data.endedAt instanceof Date) {
-            data.endedAt = data.endedAt.toISOString();
-          }
-          if (data.startedAt instanceof Date) {
-            data.startedAt = data.startedAt.toISOString();
+      if (args.records.length === 0) {
+        return;
+      }
+      const bulkOps = args.records.map((record) => {
+        const data = { ...record.updates };
+        if (data.endedAt instanceof Date) {
+          data.endedAt = data.endedAt.toISOString();
+        }
+        if (data.startedAt instanceof Date) {
+          data.startedAt = data.startedAt.toISOString();
+        }
+        const updateData = {
+          ...data,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return {
+          updateOne: {
+            filter: { spanId: record.spanId, traceId: record.traceId },
+            update: { $set: updateData }
           }
-          const updateData = {
-            ...data,
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          return {
-            keys: { spanId: record.spanId, traceId: record.traceId },
-            data: updateData
-          };
-        })
+        };
       });
+      const collection = await this.getCollection(storage.TABLE_SPANS);
+      await collection.bulkWrite(bulkOps);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1684,7 +2356,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
   }
   async batchDeleteTraces(args) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_SPANS);
+      const collection = await this.getCollection(storage.TABLE_SPANS);
       await collection.deleteMany({
         traceId: { $in: args.traceIds }
       });
@@ -1704,215 +2376,98 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
    */
   transformSpanFromMongo(doc) {
     const { _id, ...span } = doc;
-    if (span.startedAt && typeof span.startedAt === "string") {
-      span.startedAt = span.startedAt;
-    }
-    if (span.endedAt && typeof span.endedAt === "string") {
-      span.endedAt = span.endedAt;
-    }
     if (span.createdAt && typeof span.createdAt === "string") {
       span.createdAt = new Date(span.createdAt);
     }
     if (span.updatedAt && typeof span.updatedAt === "string") {
       span.updatedAt = new Date(span.updatedAt);
     }
+    if (span.startedAt && typeof span.startedAt === "string") {
+      span.startedAt = new Date(span.startedAt);
+    }
+    if (span.endedAt && typeof span.endedAt === "string") {
+      span.endedAt = new Date(span.endedAt);
+    }
     return span;
   }
 };
-var StoreOperationsMongoDB = class extends storage.StoreOperations {
+function transformScoreRow(row) {
+  return storage.transformScoreRow(row, {
+    convertTimestamps: true
+  });
+}
+var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends storage.ScoresStorage {
   #connector;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Collections managed by this domain */
+  static MANAGED_COLLECTIONS = [storage.TABLE_SCORERS];
   constructor(config) {
     super();
-    this.#connector = config.connector;
-  }
-  async getCollection(collectionName) {
-    return this.#connector.getCollection(collectionName);
-  }
-  async hasColumn(_table, _column) {
-    return true;
-  }
-  async createTable() {
-  }
-  async alterTable(_args) {
-  }
-  async clearTable({ tableName }) {
-    try {
-      const collection = await this.getCollection(tableName);
-      await collection.deleteMany({});
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("MONGODB", "CLEAR_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-      this.logger.error(mastraError.message);
-      this.logger?.trackException(mastraError);
-      throw mastraError;
-    }
-  }
-  async dropTable({ tableName }) {
-    try {
-      const collection = await this.getCollection(tableName);
-      await collection.drop();
-    } catch (error$1) {
-      if (error$1 instanceof Error && error$1.message.includes("ns not found")) {
-        return;
-      }
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("MONGODB", "DROP_TABLE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  processJsonbFields(tableName, record) {
-    const schema = storage.TABLE_SCHEMAS[tableName];
-    if (!schema) {
-      return record;
-    }
-    return Object.fromEntries(
-      Object.entries(schema).map(([key, value]) => {
-        if (value.type === "jsonb" && record[key] && typeof record[key] === "string") {
-          return [key, storage.safelyParseJSON(record[key])];
-        }
-        return [key, record[key]];
-      })
+    this.#connector = resolveMongoDBConfig(config);
+    this.#skipDefaultIndexes = config.skipDefaultIndexes;
+    this.#indexes = config.indexes?.filter(
+      (idx) => _ScoresStorageMongoDB.MANAGED_COLLECTIONS.includes(idx.collection)
     );
   }
-  async insert({ tableName, record }) {
-    try {
-      const collection = await this.getCollection(tableName);
-      const recordToInsert = this.processJsonbFields(tableName, record);
-      await collection.insertOne(recordToInsert);
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createStorageErrorId("MONGODB", "INSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-      this.logger.error(mastraError.message);
-      this.logger?.trackException(mastraError);
-      throw mastraError;
-    }
+  async getCollection(name) {
+    return this.#connector.getCollection(name);
   }
-  async batchInsert({ tableName, records }) {
-    if (!records.length) {
+  /**
+   * Returns default index definitions for the scores domain collections.
+   * These indexes optimize common query patterns for score lookups.
+   */
+  getDefaultIndexDefinitions() {
+    return [
+      { collection: storage.TABLE_SCORERS, keys: { id: 1 }, options: { unique: true } },
+      { collection: storage.TABLE_SCORERS, keys: { scorerId: 1 } },
+      { collection: storage.TABLE_SCORERS, keys: { runId: 1 } },
+      { collection: storage.TABLE_SCORERS, keys: { entityId: 1, entityType: 1 } },
+      { collection: storage.TABLE_SCORERS, keys: { traceId: 1, spanId: 1 } },
+      { collection: storage.TABLE_SCORERS, keys: { createdAt: -1 } },
+      { collection: storage.TABLE_SCORERS, keys: { source: 1 } }
+    ];
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
       return;
     }
-    try {
-      const collection = await this.getCollection(tableName);
-      const processedRecords = records.map((record) => this.processJsonbFields(tableName, record));
-      await collection.insertMany(processedRecords);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("MONGODB", "BATCH_INSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async load({ tableName, keys }) {
-    this.logger.info(`Loading ${tableName} with keys ${JSON.stringify(keys)}`);
-    try {
-      const collection = await this.getCollection(tableName);
-      return await collection.find(keys).toArray();
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("MONGODB", "LOAD", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async update({
-    tableName,
-    keys,
-    data
-  }) {
-    try {
-      const collection = await this.getCollection(tableName);
-      const processedData = this.processJsonbFields(tableName, data);
-      const cleanData = Object.fromEntries(Object.entries(processedData).filter(([_, value]) => value !== void 0));
-      await collection.updateOne(keys, { $set: cleanData });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("MONGODB", "UPDATE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
+    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 batchUpdate({
-    tableName,
-    updates
-  }) {
-    if (!updates.length) {
+  /**
+   * Creates custom user-defined indexes for this domain's collections.
+   */
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
       return;
     }
-    try {
-      const collection = await this.getCollection(tableName);
-      const bulkOps = updates.map(({ keys, data }) => {
-        const processedData = this.processJsonbFields(tableName, data);
-        const cleanData = Object.fromEntries(Object.entries(processedData).filter(([_, value]) => value !== void 0));
-        return {
-          updateOne: {
-            filter: keys,
-            update: { $set: cleanData }
-          }
-        };
-      });
-      await collection.bulkWrite(bulkOps);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createStorageErrorId("MONGODB", "BATCH_UPDATE", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error$1
-      );
+    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);
+      }
     }
   }
-};
-function transformScoreRow(row) {
-  return storage.transformScoreRow(row, {
-    convertTimestamps: true
-  });
-}
-var ScoresStorageMongoDB = class extends storage.ScoresStorage {
-  operations;
-  constructor({ operations }) {
-    super();
-    this.operations = operations;
+  async init() {
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  async dangerouslyClearAll() {
+    const collection = await this.getCollection(storage.TABLE_SCORERS);
+    await collection.deleteMany({});
   }
   async getScoreById({ id }) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const collection = await this.getCollection(storage.TABLE_SCORERS);
       const document = await collection.findOne({ id });
       if (!document) {
         return null;
@@ -1941,7 +2496,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
-            scorer: score.scorer?.id ?? "unknown",
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
             entityId: score.entityId ?? "unknown",
             entityType: score.entityType ?? "unknown",
             traceId: score.traceId ?? "",
@@ -1976,7 +2531,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
         createdAt,
         updatedAt
       };
-      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const collection = await this.getCollection(storage.TABLE_SCORERS);
       await collection.insertOne(dataToSave);
       return { score: dataToSave };
     } catch (error$1) {
@@ -2012,7 +2567,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       if (source) {
         query.source = source;
       }
-      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const collection = await this.getCollection(storage.TABLE_SCORERS);
       const total = await collection.countDocuments(query);
       if (total === 0) {
         return {
@@ -2061,7 +2616,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       const { page, perPage: perPageInput } = pagination;
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const collection = await this.getCollection(storage.TABLE_SCORERS);
       const total = await collection.countDocuments({ runId });
       if (total === 0) {
         return {
@@ -2111,7 +2666,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       const { page, perPage: perPageInput } = pagination;
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const collection = await this.getCollection(storage.TABLE_SCORERS);
       const total = await collection.countDocuments({ entityId, entityType });
       if (total === 0) {
         return {
@@ -2162,7 +2717,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const query = { traceId, spanId };
-      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const collection = await this.getCollection(storage.TABLE_SCORERS);
       const total = await collection.countDocuments(query);
       if (total === 0) {
         return {
@@ -2204,11 +2759,75 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
     }
   }
 };
-var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
-  operations;
-  constructor({ operations }) {
+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.operations = operations;
+    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,
@@ -2230,10 +2849,13 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
     workflowName,
     runId,
     resourceId,
-    snapshot
+    snapshot,
+    createdAt,
+    updatedAt
   }) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const now = /* @__PURE__ */ new Date();
+      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
       await collection.updateOne(
         { workflow_name: workflowName, run_id: runId },
         {
@@ -2242,8 +2864,10 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
             run_id: runId,
             resourceId,
             snapshot,
-            createdAt: /* @__PURE__ */ new Date(),
-            updatedAt: /* @__PURE__ */ new Date()
+            updatedAt: updatedAt ?? now
+          },
+          $setOnInsert: {
+            createdAt: createdAt ?? now
           }
         },
         { upsert: true }
@@ -2265,17 +2889,15 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
     runId
   }) {
     try {
-      const result = await this.operations.load({
-        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId
-        }
+      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const result = await collection.findOne({
+        workflow_name: workflowName,
+        run_id: runId
       });
-      if (!result?.length) {
+      if (!result) {
         return null;
       }
-      return typeof result[0].snapshot === "string" ? storage.safelyParseJSON(result[0].snapshot) : result[0].snapshot;
+      return typeof result.snapshot === "string" ? storage.safelyParseJSON(result.snapshot) : result.snapshot;
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -2311,7 +2933,7 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
       if (options.resourceId) {
         query["resourceId"] = options.resourceId;
       }
-      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      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") {
@@ -2362,7 +2984,7 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
       if (args.workflowName) {
         query["workflow_name"] = args.workflowName;
       }
-      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
       const result = await collection.findOne(query);
       if (!result) {
         return null;
@@ -2382,7 +3004,7 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
   }
   async deleteWorkflowRunById({ runId, workflowName }) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      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(
@@ -2409,49 +3031,14 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
       workflowName: row.workflow_name,
       runId: row.run_id,
       snapshot: parsedSnapshot,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
+      createdAt: row.createdAt ? new Date(row.createdAt) : /* @__PURE__ */ new Date(),
+      updatedAt: row.updatedAt ? new Date(row.updatedAt) : /* @__PURE__ */ new Date(),
       resourceId: row.resourceId
     };
   }
 };
 
 // src/storage/index.ts
-var loadConnector = (config) => {
-  try {
-    if ("connectorHandler" in config) {
-      return MongoDBConnector.fromConnectionHandler(config.connectorHandler);
-    }
-  } catch (error$1) {
-    throw new error.MastraError(
-      {
-        id: storage.createStorageErrorId("MONGODB", "CONSTRUCTOR", "FAILED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { connectionHandler: true }
-      },
-      error$1
-    );
-  }
-  try {
-    return MongoDBConnector.fromDatabaseConfig({
-      id: config.id,
-      options: config.options,
-      url: config.url,
-      dbName: config.dbName
-    });
-  } catch (error$1) {
-    throw new error.MastraError(
-      {
-        id: storage.createStorageErrorId("MONGODB", "CONSTRUCTOR", "FAILED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { url: config?.url, dbName: config?.dbName }
-      },
-      error$1
-    );
-  }
-};
 var MongoDBStore = class extends storage.MastraStorage {
   #connector;
   stores;
@@ -2461,128 +3048,39 @@ var MongoDBStore = class extends storage.MastraStorage {
       resourceWorkingMemory: true,
       hasColumn: false,
       createTable: false,
-      deleteMessages: false,
-      listScoresBySpan: true
+      deleteMessages: true,
+      observability: true,
+      indexManagement: false,
+      listScoresBySpan: true,
+      agents: true
     };
   }
   constructor(config) {
     super({ id: config.id, name: "MongoDBStore", disableInit: config.disableInit });
-    this.stores = {};
-    this.#connector = loadConnector(config);
-    const operations = new StoreOperationsMongoDB({
-      connector: this.#connector
-    });
-    const memory = new MemoryStorageMongoDB({
-      operations
-    });
-    const scores = new ScoresStorageMongoDB({
-      operations
-    });
-    const workflows = new WorkflowsStorageMongoDB({
-      operations
-    });
-    const observability = new ObservabilityMongoDB({
-      operations
-    });
+    this.#connector = resolveMongoDBConfig(config);
+    const domainConfig = {
+      connector: this.#connector,
+      skipDefaultIndexes: config.skipDefaultIndexes,
+      indexes: config.indexes
+    };
+    const memory = new MemoryStorageMongoDB(domainConfig);
+    const scores = new ScoresStorageMongoDB(domainConfig);
+    const workflows = new WorkflowsStorageMongoDB(domainConfig);
+    const observability = new ObservabilityMongoDB(domainConfig);
+    const agents = new MongoDBAgentsStorage(domainConfig);
     this.stores = {
-      operations,
       memory,
       scores,
       workflows,
-      observability
+      observability,
+      agents
     };
   }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-  async alterTable(_args) {
-    return this.stores.operations.alterTable(_args);
-  }
-  async dropTable({ tableName }) {
-    return this.stores.operations.dropTable({ tableName });
-  }
-  async clearTable({ tableName }) {
-    return this.stores.operations.clearTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    return this.stores.operations.insert({ tableName, record });
-  }
-  async batchInsert({ tableName, records }) {
-    return this.stores.operations.batchInsert({ tableName, records });
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
-  async getThreadById({ threadId }) {
-    return this.stores.memory.getThreadById({ threadId });
-  }
-  async saveThread({ thread }) {
-    return this.stores.memory.saveThread({ thread });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.stores.memory.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    return this.stores.memory.deleteThread({ threadId });
-  }
-  async listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
-  }
-  async saveMessages(args) {
-    return this.stores.memory.saveMessages(args);
-  }
-  async updateMessages(_args) {
-    return this.stores.memory.updateMessages(_args);
-  }
-  async listWorkflowRuns(args) {
-    return this.stores.workflows.listWorkflowRuns(args);
-  }
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-  async deleteWorkflowRunById({ runId, workflowName }) {
-    return this.stores.workflows.deleteWorkflowRunById({ runId, workflowName });
-  }
+  /**
+   * Closes the MongoDB client connection.
+   *
+   * This will close the MongoDB client, including pre-configured clients.
+   */
   async close() {
     try {
       await this.#connector.close();
@@ -2591,154 +3089,12 @@ var MongoDBStore = class extends storage.MastraStorage {
         {
           id: storage.createStorageErrorId("MONGODB", "CLOSE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  /**
-   * SCORERS
-   */
-  async getScoreById({ id }) {
-    return this.stores.scores.getScoreById({ id });
-  }
-  async saveScore(score) {
-    return this.stores.scores.saveScore(score);
-  }
-  async listScoresByRunId({
-    runId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByRunId({ runId, pagination });
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({ entityId, entityType, pagination });
-  }
-  async listScoresByScorerId({
-    scorerId,
-    pagination,
-    entityId,
-    entityType,
-    source
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
-  }
-  /**
-   * RESOURCES
-   */
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.stores.memory.updateResource({
-      resourceId,
-      workingMemory,
-      metadata
-    });
-  }
-  /**
-   * Tracing/Observability
-   */
-  async createSpan(span) {
-    if (!this.stores.observability) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("MONGODB", "OBSERVABILITY", "NOT_INITIALIZED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Observability storage is not initialized"
-      });
-    }
-    return this.stores.observability.createSpan(span);
-  }
-  async updateSpan({
-    spanId,
-    traceId,
-    updates
-  }) {
-    if (!this.stores.observability) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("MONGODB", "OBSERVABILITY", "NOT_INITIALIZED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Observability storage is not initialized"
-      });
-    }
-    return this.stores.observability.updateSpan({ spanId, traceId, updates });
-  }
-  async getTrace(traceId) {
-    if (!this.stores.observability) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("MONGODB", "OBSERVABILITY", "NOT_INITIALIZED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Observability storage is not initialized"
-      });
-    }
-    return this.stores.observability.getTrace(traceId);
-  }
-  async getTracesPaginated(args) {
-    if (!this.stores.observability) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("MONGODB", "OBSERVABILITY", "NOT_INITIALIZED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Observability storage is not initialized"
-      });
-    }
-    return this.stores.observability.getTracesPaginated(args);
-  }
-  async batchCreateSpans(args) {
-    if (!this.stores.observability) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("MONGODB", "OBSERVABILITY", "NOT_INITIALIZED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Observability storage is not initialized"
-      });
-    }
-    return this.stores.observability.batchCreateSpans(args);
-  }
-  async batchUpdateSpans(args) {
-    if (!this.stores.observability) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("MONGODB", "OBSERVABILITY", "NOT_INITIALIZED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Observability storage is not initialized"
-      });
-    }
-    return this.stores.observability.batchUpdateSpans(args);
-  }
-  async batchDeleteTraces(args) {
-    if (!this.stores.observability) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("MONGODB", "OBSERVABILITY", "NOT_INITIALIZED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Observability storage is not initialized"
-      });
-    }
-    return this.stores.observability.batchDeleteTraces(args);
-  }
 };
 
 // src/vector/prompt.ts