@mastra/mongodb 0.12.0 → 0.12.1-alpha.0

package/dist/index.cjs

@@ -5,8 +5,8 @@ var vector = require('@mastra/core/vector');
 var mongodb = require('mongodb');
 var uuid = require('uuid');
 var filter = require('@mastra/core/vector/filter');
-var agent = require('@mastra/core/agent');
 var storage = require('@mastra/core/storage');
+var agent = require('@mastra/core/agent');
 
 // src/vector/index.ts
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
@@ -189,12 +189,25 @@ var MongoDBVector = class extends vector.MastraVector {
               path: embeddingField,
               numDimensions,
               similarity: mongoMetric
+            },
+            {
+              type: "filter",
+              path: "_id"
             }
           ]
         },
         name: indexNameInternal,
         type: "vectorSearch"
       });
+      await collection.createSearchIndex({
+        definition: {
+          mappings: {
+            dynamic: true
+          }
+        },
+        name: `${indexName}_search_index`,
+        type: "search"
+      });
     } catch (error$1) {
       if (error$1.codeName !== "IndexAlreadyExists") {
         throw new error.MastraError(
@@ -321,18 +334,21 @@ var MongoDBVector = class extends vector.MastraVector {
       } else if (Object.keys(documentMongoFilter).length > 0) {
         combinedFilter = documentMongoFilter;
       }
+      const vectorSearch = {
+        index: indexNameInternal,
+        queryVector,
+        path: this.embeddingFieldName,
+        numCandidates: 100,
+        limit: topK
+      };
+      if (Object.keys(combinedFilter).length > 0) {
+        const candidateIds = await collection.aggregate([{ $match: combinedFilter }, { $project: { _id: 1 } }]).map((doc) => doc._id).toArray();
+        vectorSearch.filter = { _id: { $in: candidateIds } };
+      }
       const pipeline = [
         {
-          $vectorSearch: {
-            index: indexNameInternal,
-            queryVector,
-            path: this.embeddingFieldName,
-            numCandidates: 100,
-            limit: topK
-          }
+          $vectorSearch: vectorSearch
         },
-        // Apply the filter using $match stage
-        ...Object.keys(combinedFilter).length > 0 ? [{ $match: combinedFilter }] : [],
         {
           $set: { score: { $meta: "vectorSearchScore" } }
         },
@@ -550,200 +566,713 @@ var MongoDBVector = class extends vector.MastraVector {
     return translator.translate(filter);
   }
 };
-function safelyParseJSON(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
-  }
-}
-var MongoDBStore = class extends storage.MastraStorage {
-  #isConnected = false;
+var MongoDBConnector = class _MongoDBConnector {
   #client;
-  #db;
   #dbName;
-  constructor(config) {
-    super({ name: "MongoDBStore" });
+  #handler;
+  #isConnected;
+  #db;
+  constructor(options) {
+    this.#client = options.client;
+    this.#dbName = options.dbName;
+    this.#handler = options.handler;
     this.#isConnected = false;
-    try {
-      if (!config.url?.trim().length) {
-        throw new Error(
-          "MongoDBStore: url must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
-        );
-      }
-      if (!config.dbName?.trim().length) {
-        throw new Error(
-          "MongoDBStore: dbName must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
-        );
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_MONGODB_STORE_CONSTRUCTOR_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { url: config.url, dbName: config.dbName }
-        },
-        error$1
+  }
+  static fromDatabaseConfig(config) {
+    if (!config.url?.trim().length) {
+      throw new Error(
+        "MongoDBStore: url must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
+      );
+    }
+    if (!config.dbName?.trim().length) {
+      throw new Error(
+        "MongoDBStore: dbName must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults."
       );
     }
-    this.#dbName = config.dbName;
-    this.#client = new mongodb.MongoClient(config.url, config.options);
+    return new _MongoDBConnector({
+      client: new mongodb.MongoClient(config.url, config.options),
+      dbName: config.dbName,
+      handler: void 0
+    });
+  }
+  static fromConnectionHandler(handler) {
+    return new _MongoDBConnector({
+      client: void 0,
+      dbName: void 0,
+      handler
+    });
   }
   async getConnection() {
-    if (this.#isConnected) {
+    if (this.#client) {
+      if (this.#isConnected && this.#db) {
+        return this.#db;
+      }
+      await this.#client.connect();
+      this.#db = this.#client.db(this.#dbName);
+      this.#isConnected = true;
       return this.#db;
     }
-    await this.#client.connect();
-    this.#db = this.#client.db(this.#dbName);
-    this.#isConnected = true;
-    return this.#db;
+    throw new Error("MongoDBStore: client cannot be empty. Check your MongoDBConnector configuration.");
   }
   async getCollection(collectionName) {
+    if (this.#handler) {
+      return this.#handler.getCollection(collectionName);
+    }
     const db = await this.getConnection();
     return db.collection(collectionName);
   }
-  async createTable() {
-  }
-  /**
-   * No-op: This backend is schemaless and does not require schema changes.
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
-  async alterTable(_args) {
+  async close() {
+    if (this.#client) {
+      await this.#client.close();
+      this.#isConnected = false;
+      return;
+    }
+    if (this.#handler) {
+      await this.#handler.close();
+    }
   }
-  async clearTable({ tableName }) {
+};
+function transformEvalRow(row) {
+  let testInfoValue = null;
+  if (row.test_info) {
     try {
-      const collection = await this.getCollection(tableName);
-      await collection.deleteMany({});
-    } catch (error$1) {
-      if (error$1 instanceof Error) {
-        const matstraError = new error.MastraError(
-          {
-            id: "STORAGE_MONGODB_STORE_CLEAR_TABLE_FAILED",
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.THIRD_PARTY,
-            details: { tableName }
-          },
-          error$1
-        );
-        this.logger.error(matstraError.message);
-        this.logger?.trackException(matstraError);
-      }
+      testInfoValue = typeof row.test_info === "string" ? storage.safelyParseJSON(row.test_info) : row.test_info;
+    } catch (e) {
+      console.warn("Failed to parse test_info:", e);
     }
   }
-  async insert({ tableName, record }) {
+  let resultValue;
+  try {
+    resultValue = typeof row.result === "string" ? storage.safelyParseJSON(row.result) : row.result;
+  } catch (e) {
+    console.warn("Failed to parse result:", e);
+    throw new Error("Invalid result format");
+  }
+  return {
+    agentName: row.agent_name,
+    input: row.input,
+    output: row.output,
+    result: resultValue,
+    metricName: row.metric_name,
+    instructions: row.instructions,
+    testInfo: testInfoValue,
+    globalRunId: row.global_run_id,
+    runId: row.run_id,
+    createdAt: row.createdAt
+  };
+}
+var LegacyEvalsMongoDB = class extends storage.LegacyEvalsStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  /** @deprecated use getEvals instead */
+  async getEvalsByAgentName(agentName, type) {
     try {
-      const collection = await this.getCollection(tableName);
-      await collection.insertOne(record);
+      const query = {
+        agent_name: agentName
+      };
+      if (type === "test") {
+        query["test_info"] = { $ne: null };
+      }
+      if (type === "live") {
+        query["test_info"] = null;
+      }
+      const collection = await this.operations.getCollection(storage.TABLE_EVALS);
+      const documents = await collection.find(query).sort({ created_at: "desc" }).toArray();
+      const result = documents.map((row) => transformEvalRow(row));
+      return result.filter((row) => {
+        if (type === "live") {
+          return !Boolean(row.testInfo?.testPath);
+        }
+        if (type === "test") {
+          return row.testInfo?.testPath !== null;
+        }
+        return true;
+      });
     } catch (error$1) {
-      if (error$1 instanceof Error) {
-        const matstraError = new error.MastraError(
-          {
-            id: "STORAGE_MONGODB_STORE_INSERT_FAILED",
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.THIRD_PARTY,
-            details: { tableName }
-          },
-          error$1
-        );
-        this.logger.error(matstraError.message);
-        this.logger?.trackException(matstraError);
+      if (error$1 instanceof Error && error$1.message.includes("no such table")) {
+        return [];
       }
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error$1
+      );
     }
   }
-  async batchInsert({ tableName, records }) {
-    if (!records.length) {
-      return;
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const currentOffset = page * perPage;
+    const query = {};
+    if (agentName) {
+      query["agent_name"] = agentName;
+    }
+    if (type === "test") {
+      query["test_info"] = { $ne: null };
+    } else if (type === "live") {
+      query["test_info"] = null;
+    }
+    if (fromDate || toDate) {
+      query["createdAt"] = {};
+      if (fromDate) {
+        query["createdAt"]["$gte"] = fromDate;
+      }
+      if (toDate) {
+        query["createdAt"]["$lte"] = toDate;
+      }
     }
     try {
-      const collection = await this.getCollection(tableName);
-      await collection.insertMany(records);
+      const collection = await this.operations.getCollection(storage.TABLE_EVALS);
+      let total = 0;
+      if (page === 0 || perPage < 1e3) {
+        total = await collection.countDocuments(query);
+      }
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const documents = await collection.find(query).sort({ created_at: "desc" }).skip(currentOffset).limit(perPage).toArray();
+      const evals = documents.map((row) => transformEvalRow(row));
+      const filteredEvals = evals.filter((row) => {
+        if (type === "live") {
+          return !Boolean(row.testInfo?.testPath);
+        }
+        if (type === "test") {
+          return row.testInfo?.testPath !== null;
+        }
+        return true;
+      });
+      const hasMore = currentOffset + filteredEvals.length < total;
+      return {
+        evals: filteredEvals,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_MONGODB_STORE_BATCH_INSERT_FAILED",
+          id: "STORAGE_MONGODB_STORE_GET_EVALS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          details: {
+            agentName: agentName || "all",
+            type: type || "all",
+            page,
+            perPage
+          }
         },
         error$1
       );
     }
   }
-  async load({ tableName, keys }) {
-    this.logger.info(`Loading ${tableName} with keys ${JSON.stringify(keys)}`);
+};
+
+// src/storage/domains/utils.ts
+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 }) {
+    super();
+    this.operations = operations;
+  }
+  parseRow(row) {
+    let content = row.content;
+    if (typeof content === "string") {
+      try {
+        content = JSON.parse(content);
+      } catch {
+      }
+    }
+    const result = {
+      id: row.id,
+      content,
+      role: row.role,
+      createdAt: formatDateForMongoDB(row.createdAt),
+      threadId: row.thread_id,
+      resourceId: row.resourceId
+    };
+    if (row.type && row.type !== "v2") result.type = row.type;
+    return result;
+  }
+  async _getIncludedMessages({
+    threadId,
+    selectBy
+  }) {
+    const include = selectBy?.include;
+    if (!include) return null;
+    const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+    const includedMessages = [];
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      const searchThreadId = inc.threadId || threadId;
+      const allMessages = await collection.find({ thread_id: searchThreadId }).sort({ createdAt: 1 }).toArray();
+      const targetIndex = allMessages.findIndex((msg) => msg.id === id);
+      if (targetIndex === -1) continue;
+      const startIndex = Math.max(0, targetIndex - withPreviousMessages);
+      const endIndex = Math.min(allMessages.length - 1, targetIndex + withNextMessages);
+      for (let i = startIndex; i <= endIndex; i++) {
+        includedMessages.push(allMessages[i]);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const dedupedMessages = includedMessages.filter((msg) => {
+      if (seen.has(msg.id)) return false;
+      seen.add(msg.id);
+      return true;
+    });
+    return dedupedMessages.map((row) => this.parseRow(row));
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
     try {
-      const collection = await this.getCollection(tableName);
-      return await collection.find(keys).toArray();
+      const messages = [];
+      const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      }
+      const excludeIds = messages.map((m) => m.id);
+      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const query = { thread_id: threadId };
+      if (excludeIds.length > 0) {
+        query.id = { $nin: excludeIds };
+      }
+      if (limit > 0) {
+        const remainingMessages = await collection.find(query).sort({ createdAt: -1 }).limit(limit).toArray();
+        messages.push(...remainingMessages.map((row) => this.parseRow(row)));
+      }
+      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === "v2") return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_MONGODB_STORE_LOAD_FAILED",
+          id: "MONGODB_STORE_GET_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          details: { threadId }
         },
         error$1
       );
     }
   }
-  async getThreadById({ threadId }) {
+  async getMessagesPaginated(args) {
+    const { threadId, format, selectBy } = args;
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
+    const perPage = perPageInput !== void 0 ? perPageInput : storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const messages = [];
+    if (selectBy?.include?.length) {
+      try {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      } catch (error$1) {
+        throw new error.MastraError(
+          {
+            id: "MONGODB_STORE_GET_MESSAGES_PAGINATED_GET_INCLUDE_MESSAGES_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: { threadId }
+          },
+          error$1
+        );
+      }
+    }
     try {
-      const collection = await this.getCollection(storage.TABLE_THREADS);
-      const result = await collection.findOne({ id: threadId });
-      if (!result) {
-        return null;
+      const currentOffset = page * perPage;
+      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const query = { thread_id: threadId };
+      if (fromDate) {
+        query.createdAt = { ...query.createdAt, $gte: fromDate };
+      }
+      if (toDate) {
+        query.createdAt = { ...query.createdAt, $lte: toDate };
       }
+      const total = await collection.countDocuments(query);
+      if (total === 0 && messages.length === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const excludeIds = messages.map((m) => m.id);
+      if (excludeIds.length > 0) {
+        query.id = { $nin: excludeIds };
+      }
+      const dataResult = await collection.find(query).sort({ createdAt: -1 }).skip(currentOffset).limit(perPage).toArray();
+      messages.push(...dataResult.map((row) => this.parseRow(row)));
+      const messagesToReturn = format === "v1" ? new agent.MessageList().add(messages, "memory").get.all.v1() : new agent.MessageList().add(messages, "memory").get.all.v2();
       return {
-        ...result,
-        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
+        messages: messagesToReturn,
+        total,
+        page,
+        perPage,
+        hasMore: (page + 1) * perPage < total
       };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "STORAGE_MONGODB_STORE_GET_THREAD_BY_ID_FAILED",
+          id: "MONGODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { threadId }
         },
         error$1
       );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      return { messages: [], total: 0, page, perPage, hasMore: false };
     }
   }
-  async getThreadsByResourceId({ resourceId }) {
+  async saveMessages({
+    messages,
+    format
+  }) {
+    if (messages.length === 0) return messages;
     try {
-      const collection = await this.getCollection(storage.TABLE_THREADS);
-      const results = await collection.find({ resourceId }).toArray();
-      if (!results.length) {
-        return [];
+      const threadId = messages[0]?.threadId;
+      if (!threadId) {
+        throw new Error("Thread ID is required");
       }
-      return results.map((result) => ({
-        ...result,
-        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
-      }));
+      const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
+      const threadsCollection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const messagesToInsert = messages.map((message) => {
+        const time = message.createdAt || /* @__PURE__ */ new Date();
+        if (!message.threadId) {
+          throw new Error(
+            "Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred."
+          );
+        }
+        if (!message.resourceId) {
+          throw new Error(
+            "Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred."
+          );
+        }
+        return {
+          updateOne: {
+            filter: { id: message.id },
+            update: {
+              $set: {
+                id: message.id,
+                thread_id: message.threadId,
+                content: typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
+                role: message.role,
+                type: message.type || "v2",
+                createdAt: formatDateForMongoDB(time),
+                resourceId: message.resourceId
+              }
+            },
+            upsert: true
+          }
+        };
+      });
+      await Promise.all([
+        collection.bulkWrite(messagesToInsert),
+        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
+      ]);
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === "v2") return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          id: "MONGODB_STORE_SAVE_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async saveThread({ thread }) {
-    try {
-      const collection = await this.getCollection(storage.TABLE_THREADS);
-      await collection.updateOne(
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const collection = await this.operations.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) {
+      return [];
+    }
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    const bulkOps = [];
+    for (const existingMessage of existingMessagesParsed) {
+      const updatePayload = messages.find((m) => m.id === existingMessage.id);
+      if (!updatePayload) continue;
+      const { id, ...fieldsToUpdate } = updatePayload;
+      if (Object.keys(fieldsToUpdate).length === 0) continue;
+      threadIdsToUpdate.add(existingMessage.threadId);
+      if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+        threadIdsToUpdate.add(updatePayload.threadId);
+      }
+      const updateDoc = {};
+      const updatableFields = { ...fieldsToUpdate };
+      if (updatableFields.content) {
+        const newContent = {
+          ...existingMessage.content,
+          ...updatableFields.content,
+          // Deep merge metadata if it exists on both
+          ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
+            metadata: {
+              ...existingMessage.content.metadata,
+              ...updatableFields.content.metadata
+            }
+          } : {}
+        };
+        updateDoc.content = JSON.stringify(newContent);
+        delete updatableFields.content;
+      }
+      for (const key in updatableFields) {
+        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+          const dbKey = key === "threadId" ? "thread_id" : key;
+          let value = updatableFields[key];
+          if (typeof value === "object" && value !== null) {
+            value = JSON.stringify(value);
+          }
+          updateDoc[dbKey] = value;
+        }
+      }
+      if (Object.keys(updateDoc).length > 0) {
+        bulkOps.push({
+          updateOne: {
+            filter: { id },
+            update: { $set: updateDoc }
+          }
+        });
+      }
+    }
+    if (bulkOps.length > 0) {
+      await collection.bulkWrite(bulkOps);
+    }
+    if (threadIdsToUpdate.size > 0) {
+      const threadsCollection = await this.operations.getCollection(storage.TABLE_THREADS);
+      await threadsCollection.updateMany(
+        { id: { $in: Array.from(threadIdsToUpdate) } },
+        { $set: { updatedAt: /* @__PURE__ */ new Date() } }
+      );
+    }
+    const updatedMessages = await collection.find({ id: { $in: messageIds } }).toArray();
+    return updatedMessages.map((row) => this.parseRow(row));
+  }
+  async getResourceById({ resourceId }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      const result = await collection.findOne({ id: resourceId });
+      if (!result) {
+        return null;
+      }
+      return {
+        id: result.id,
+        workingMemory: result.workingMemory || "",
+        metadata: typeof result.metadata === "string" ? storage.safelyParseJSON(result.metadata) : result.metadata,
+        createdAt: formatDateForMongoDB(result.createdAt),
+        updatedAt: formatDateForMongoDB(result.updatedAt)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_RESOURCE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveResource({ resource }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      await collection.updateOne(
+        { id: resource.id },
+        {
+          $set: {
+            ...resource,
+            metadata: JSON.stringify(resource.metadata)
+          }
+        },
+        { upsert: true }
+      );
+      return resource;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_SAVE_RESOURCE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId: resource.id }
+        },
+        error$1
+      );
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    try {
+      const existingResource = await this.getResourceById({ resourceId });
+      if (!existingResource) {
+        const newResource = {
+          id: resourceId,
+          workingMemory: workingMemory || "",
+          metadata: metadata || {},
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        return this.saveResource({ resource: newResource });
+      }
+      const updatedResource = {
+        ...existingResource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+        metadata: metadata ? { ...existingResource.metadata, ...metadata } : existingResource.metadata,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const collection = await this.operations.getCollection(storage.TABLE_RESOURCES);
+      const updateDoc = { updatedAt: updatedResource.updatedAt };
+      if (workingMemory !== void 0) {
+        updateDoc.workingMemory = workingMemory;
+      }
+      if (metadata) {
+        updateDoc.metadata = JSON.stringify(updatedResource.metadata);
+      }
+      await collection.updateOne({ id: resourceId }, { $set: updateDoc });
+      return updatedResource;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_UPDATE_RESOURCE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadById({ threadId }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const result = await collection.findOne({ id: threadId });
+      if (!result) {
+        return null;
+      }
+      return {
+        ...result,
+        metadata: typeof result.metadata === "string" ? storage.safelyParseJSON(result.metadata) : result.metadata
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_THREAD_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const results = await collection.find({ resourceId }).toArray();
+      if (!results.length) {
+        return [];
+      }
+      return results.map((result) => ({
+        ...result,
+        metadata: typeof result.metadata === "string" ? storage.safelyParseJSON(result.metadata) : result.metadata
+      }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    try {
+      const { resourceId, page, perPage } = args;
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      const query = { resourceId };
+      const total = await collection.countDocuments(query);
+      const threads = await collection.find(query).sort({ updatedAt: -1 }).skip(page * perPage).limit(perPage).toArray();
+      return {
+        threads: threads.map((thread) => ({
+          id: thread.id,
+          title: thread.title,
+          resourceId: thread.resourceId,
+          createdAt: formatDateForMongoDB(thread.createdAt),
+          updatedAt: formatDateForMongoDB(thread.updatedAt),
+          metadata: thread.metadata || {}
+        })),
+        total,
+        page,
+        perPage,
+        hasMore: (page + 1) * perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId: args.resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveThread({ thread }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
+      await collection.updateOne(
         { id: thread.id },
         {
           $set: {
             ...thread,
-            metadata: JSON.stringify(thread.metadata)
+            metadata: thread.metadata
           }
         },
         { upsert: true }
@@ -772,7 +1301,7 @@ var MongoDBStore = class extends storage.MastraStorage {
         id: "STORAGE_MONGODB_STORE_UPDATE_THREAD_NOT_FOUND",
         domain: error.ErrorDomain.STORAGE,
         category: error.ErrorCategory.THIRD_PARTY,
-        details: { threadId: id },
+        details: { threadId: id, status: 404 },
         text: `Thread ${id} not found`
       });
     }
@@ -785,13 +1314,13 @@ var MongoDBStore = class extends storage.MastraStorage {
       }
     };
     try {
-      const collection = await this.getCollection(storage.TABLE_THREADS);
+      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
       await collection.updateOne(
         { id },
         {
           $set: {
             title,
-            metadata: JSON.stringify(updatedThread.metadata)
+            metadata: updatedThread.metadata
           }
         }
       );
@@ -810,9 +1339,9 @@ var MongoDBStore = class extends storage.MastraStorage {
   }
   async deleteThread({ threadId }) {
     try {
-      const collectionMessages = await this.getCollection(storage.TABLE_MESSAGES);
+      const collectionMessages = await this.operations.getCollection(storage.TABLE_MESSAGES);
       await collectionMessages.deleteMany({ thread_id: threadId });
-      const collectionThreads = await this.getCollection(storage.TABLE_THREADS);
+      const collectionThreads = await this.operations.getCollection(storage.TABLE_THREADS);
       await collectionThreads.deleteOne({ id: threadId });
     } catch (error$1) {
       throw new error.MastraError(
@@ -826,124 +1355,461 @@ var MongoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  async getMessages({
-    threadId,
-    selectBy,
-    format
-  }) {
+};
+var StoreOperationsMongoDB = class extends storage.StoreOperations {
+  #connector;
+  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) {
+      if (error$1 instanceof Error) {
+        const matstraError = new error.MastraError(
+          {
+            id: "STORAGE_MONGODB_STORE_CLEAR_TABLE_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: { tableName }
+          },
+          error$1
+        );
+        this.logger.error(matstraError.message);
+        this.logger?.trackException(matstraError);
+      }
+    }
+  }
+  async dropTable({ tableName }) {
     try {
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-      const include = selectBy?.include || [];
-      let messages = [];
-      let allMessages = [];
-      const collection = await this.getCollection(storage.TABLE_MESSAGES);
-      allMessages = (await collection.find({ thread_id: threadId }).sort({ createdAt: -1 }).toArray()).map(
-        (row) => this.parseRow(row)
+      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: "MONGODB_STORE_DROP_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
       );
-      if (include.length) {
-        const idToIndex = /* @__PURE__ */ new Map();
-        allMessages.forEach((msg, idx) => {
-          idToIndex.set(msg.id, idx);
-        });
-        const selectedIndexes = /* @__PURE__ */ new Set();
-        for (const inc of include) {
-          const idx = idToIndex.get(inc.id);
-          if (idx === void 0) continue;
-          for (let i = 1; i <= (inc.withPreviousMessages || 0); i++) {
-            if (idx + i < allMessages.length) selectedIndexes.add(idx + i);
-          }
-          selectedIndexes.add(idx);
-          for (let i = 1; i <= (inc.withNextMessages || 0); i++) {
-            if (idx - i >= 0) selectedIndexes.add(idx - i);
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      const collection = await this.getCollection(tableName);
+      const schema = storage.TABLE_SCHEMAS[tableName];
+      const recordToInsert = Object.fromEntries(
+        Object.entries(schema).map(([key, value]) => {
+          if (value.type === "jsonb" && record[key] && typeof record[key] === "string") {
+            return [key, storage.safelyParseJSON(record[key])];
           }
-        }
-        messages.push(
-          ...Array.from(selectedIndexes).map((i) => allMessages[i]).filter((m) => !!m)
+          return [key, record[key]];
+        })
+      );
+      await collection.insertOne(recordToInsert);
+    } catch (error$1) {
+      if (error$1 instanceof Error) {
+        const matstraError = new error.MastraError(
+          {
+            id: "STORAGE_MONGODB_STORE_INSERT_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: { tableName }
+          },
+          error$1
         );
+        this.logger.error(matstraError.message);
+        this.logger?.trackException(matstraError);
+      }
+    }
+  }
+  async batchInsert({ tableName, records }) {
+    if (!records.length) {
+      return;
+    }
+    try {
+      const collection = await this.getCollection(tableName);
+      await collection.insertMany(records);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_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_MONGODB_STORE_LOAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+};
+function transformScoreRow(row) {
+  let scorerValue = null;
+  if (row.scorer) {
+    try {
+      scorerValue = typeof row.scorer === "string" ? storage.safelyParseJSON(row.scorer) : row.scorer;
+    } catch (e) {
+      console.warn("Failed to parse scorer:", e);
+    }
+  }
+  let extractStepResultValue = null;
+  if (row.extractStepResult) {
+    try {
+      extractStepResultValue = typeof row.extractStepResult === "string" ? storage.safelyParseJSON(row.extractStepResult) : row.extractStepResult;
+    } catch (e) {
+      console.warn("Failed to parse extractStepResult:", e);
+    }
+  }
+  let analyzeStepResultValue = null;
+  if (row.analyzeStepResult) {
+    try {
+      analyzeStepResultValue = typeof row.analyzeStepResult === "string" ? storage.safelyParseJSON(row.analyzeStepResult) : row.analyzeStepResult;
+    } catch (e) {
+      console.warn("Failed to parse analyzeStepResult:", e);
+    }
+  }
+  let inputValue = null;
+  if (row.input) {
+    try {
+      inputValue = typeof row.input === "string" ? storage.safelyParseJSON(row.input) : row.input;
+    } catch (e) {
+      console.warn("Failed to parse input:", e);
+    }
+  }
+  let outputValue = null;
+  if (row.output) {
+    try {
+      outputValue = typeof row.output === "string" ? storage.safelyParseJSON(row.output) : row.output;
+    } catch (e) {
+      console.warn("Failed to parse output:", e);
+    }
+  }
+  let entityValue = null;
+  if (row.entity) {
+    try {
+      entityValue = typeof row.entity === "string" ? storage.safelyParseJSON(row.entity) : row.entity;
+    } catch (e) {
+      console.warn("Failed to parse entity:", e);
+    }
+  }
+  let runtimeContextValue = null;
+  if (row.runtimeContext) {
+    try {
+      runtimeContextValue = typeof row.runtimeContext === "string" ? storage.safelyParseJSON(row.runtimeContext) : row.runtimeContext;
+    } catch (e) {
+      console.warn("Failed to parse runtimeContext:", e);
+    }
+  }
+  return {
+    id: row.id,
+    entityId: row.entityId,
+    entityType: row.entityType,
+    scorerId: row.scorerId,
+    traceId: row.traceId,
+    runId: row.runId,
+    scorer: scorerValue,
+    extractStepResult: extractStepResultValue,
+    analyzeStepResult: analyzeStepResultValue,
+    score: row.score,
+    reason: row.reason,
+    extractPrompt: row.extractPrompt,
+    analyzePrompt: row.analyzePrompt,
+    reasonPrompt: row.reasonPrompt,
+    input: inputValue,
+    output: outputValue,
+    additionalContext: row.additionalContext,
+    runtimeContext: runtimeContextValue,
+    entity: entityValue,
+    source: row.source,
+    resourceId: row.resourceId,
+    threadId: row.threadId,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+var ScoresStorageMongoDB = class extends storage.ScoresStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  async getScoreById({ id }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const document = await collection.findOne({ id });
+      if (!document) {
+        return null;
       }
-      const excludeIds = new Set(messages.map((m) => m.id));
-      for (const msg of allMessages) {
-        if (messages.length >= limit) break;
-        if (!excludeIds.has(msg.id)) {
-          messages.push(msg);
+      return transformScoreRow(document);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_SCORE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async saveScore(score) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const scoreId = `score-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const scoreData = {
+        id: scoreId,
+        entityId: score.entityId,
+        entityType: score.entityType,
+        scorerId: score.scorerId,
+        traceId: score.traceId || "",
+        runId: score.runId,
+        scorer: typeof score.scorer === "string" ? score.scorer : JSON.stringify(score.scorer),
+        extractStepResult: typeof score.extractStepResult === "string" ? score.extractStepResult : JSON.stringify(score.extractStepResult),
+        analyzeStepResult: typeof score.analyzeStepResult === "string" ? score.analyzeStepResult : JSON.stringify(score.analyzeStepResult),
+        score: score.score,
+        reason: score.reason,
+        extractPrompt: score.extractPrompt,
+        analyzePrompt: score.analyzePrompt,
+        reasonPrompt: score.reasonPrompt,
+        input: typeof score.input === "string" ? score.input : JSON.stringify(score.input),
+        output: typeof score.output === "string" ? score.output : JSON.stringify(score.output),
+        additionalContext: score.additionalContext,
+        runtimeContext: typeof score.runtimeContext === "string" ? score.runtimeContext : JSON.stringify(score.runtimeContext),
+        entity: typeof score.entity === "string" ? score.entity : JSON.stringify(score.entity),
+        source: score.source,
+        resourceId: score.resourceId || "",
+        threadId: score.threadId || "",
+        createdAt: now,
+        updatedAt: now
+      };
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      await collection.insertOne(scoreData);
+      const savedScore = {
+        ...score,
+        id: scoreId,
+        createdAt: now,
+        updatedAt: now
+      };
+      return { score: savedScore };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_SAVE_SCORE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerId: score.scorerId, runId: score.runId }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType
+  }) {
+    try {
+      const query = { scorerId };
+      if (entityId) {
+        query.entityId = entityId;
+      }
+      if (entityType) {
+        query.entityType = entityType;
+      }
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments(query);
+      const currentOffset = pagination.page * pagination.perPage;
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          }
+        };
+      }
+      const documents = await collection.find(query).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      const hasMore = currentOffset + scores.length < total;
+      return {
+        scores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
         }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerId, page: pagination.page, perPage: pagination.perPage }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments({ runId });
+      const currentOffset = pagination.page * pagination.perPage;
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          }
+        };
       }
-      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      const list = new agent.MessageList().add(messages.slice(0, limit), "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
+      const documents = await collection.find({ runId }).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      const hasMore = currentOffset + scores.length < total;
+      return {
+        scores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
+        }
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_MONGODB_STORE_GET_MESSAGES_FAILED",
+          id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_RUN_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { runId, page: pagination.page, perPage: pagination.perPage }
         },
         error$1
       );
     }
   }
-  async saveMessages({
-    messages,
-    format
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
   }) {
-    if (!messages.length) {
-      return messages;
+    try {
+      const collection = await this.operations.getCollection(storage.TABLE_SCORERS);
+      const total = await collection.countDocuments({ entityId, entityType });
+      const currentOffset = pagination.page * pagination.perPage;
+      if (total === 0) {
+        return {
+          scores: [],
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          }
+        };
+      }
+      const documents = await collection.find({ entityId, entityType }).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const scores = documents.map((row) => transformScoreRow(row));
+      const hasMore = currentOffset + scores.length < total;
+      return {
+        scores,
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { entityId, entityType, page: pagination.page, perPage: pagination.perPage }
+        },
+        error$1
+      );
+    }
+  }
+};
+var TracesStorageMongoDB = class extends storage.TracesStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  async getTraces(args) {
+    if (args.fromDate || args.toDate) {
+      args.dateRange = {
+        start: args.fromDate,
+        end: args.toDate
+      };
     }
-    const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      this.logger.error("Thread ID is required to save messages");
-      throw new Error("Thread ID is required");
+    try {
+      const result = await this.getTracesPaginated(args);
+      return result.traces;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
-    try {
-      const messagesToInsert = messages.map((message) => {
-        const time = message.createdAt || /* @__PURE__ */ new Date();
-        return {
-          id: message.id,
-          thread_id: threadId,
-          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
-          role: message.role,
-          type: message.type,
-          resourceId: message.resourceId,
-          createdAt: time instanceof Date ? time.toISOString() : time
-        };
-      });
-      const collection = await this.getCollection(storage.TABLE_MESSAGES);
-      const threadsCollection = await this.getCollection(storage.TABLE_THREADS);
-      await Promise.all([
-        collection.bulkWrite(
-          messagesToInsert.map((msg) => ({
-            updateOne: {
-              filter: { id: msg.id },
-              update: { $set: msg },
-              upsert: true
-            }
-          }))
-        ),
-        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
-      ]);
-      const list = new agent.MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      this.logger.error("Failed to save messages in database: " + error?.message);
-      throw error;
-    }
-  }
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-    filters
-  } = {
-    page: 0,
-    perPage: 100
-  }) {
-    const limit = perPage;
-    const offset = page * perPage;
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const currentOffset = page * perPage;
     const query = {};
     if (name) {
       query["name"] = new RegExp(name);
@@ -953,7 +1819,7 @@ var MongoDBStore = class extends storage.MastraStorage {
     }
     if (attributes) {
       query["$and"] = Object.entries(attributes).map(([key, value]) => ({
-        attributes: new RegExp(`"${key}":"${value}"`)
+        [`attributes.${key}`]: value
       }));
     }
     if (filters) {
@@ -961,31 +1827,57 @@ var MongoDBStore = class extends storage.MastraStorage {
         query[key] = value;
       });
     }
+    if (fromDate || toDate) {
+      query["createdAt"] = {};
+      if (fromDate) {
+        query["createdAt"]["$gte"] = fromDate;
+      }
+      if (toDate) {
+        query["createdAt"]["$lte"] = toDate;
+      }
+    }
     try {
-      const collection = await this.getCollection(storage.TABLE_TRACES);
+      const collection = await this.operations.getCollection(storage.TABLE_TRACES);
+      const total = await collection.countDocuments(query);
+      if (total === 0) {
+        return {
+          traces: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
       const result = await collection.find(query, {
         sort: { startTime: -1 }
-      }).limit(limit).skip(offset).toArray();
-      return result.map((row) => ({
+      }).limit(perPage).skip(currentOffset).toArray();
+      const traces = result.map((row) => ({
         id: row.id,
         parentSpanId: row.parentSpanId,
         traceId: row.traceId,
         name: row.name,
         scope: row.scope,
         kind: row.kind,
-        status: safelyParseJSON(row.status),
-        events: safelyParseJSON(row.events),
-        links: safelyParseJSON(row.links),
-        attributes: safelyParseJSON(row.attributes),
+        status: storage.safelyParseJSON(row.status),
+        events: storage.safelyParseJSON(row.events),
+        links: storage.safelyParseJSON(row.links),
+        attributes: storage.safelyParseJSON(row.attributes),
         startTime: row.startTime,
         endTime: row.endTime,
-        other: safelyParseJSON(row.other),
+        other: storage.safelyParseJSON(row.other),
         createdAt: row.createdAt
       }));
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + traces.length < total
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_MONGODB_STORE_GET_TRACES_FAILED",
+          id: "STORAGE_MONGODB_STORE_GET_TRACES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -993,106 +1885,19 @@ var MongoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  async getWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    limit,
-    offset
-  } = {}) {
-    const query = {};
-    if (workflowName) {
-      query["workflow_name"] = workflowName;
-    }
-    if (fromDate || toDate) {
-      query["createdAt"] = {};
-      if (fromDate) {
-        query["createdAt"]["$gte"] = fromDate;
-      }
-      if (toDate) {
-        query["createdAt"]["$lte"] = toDate;
-      }
-    }
-    try {
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
-      let total = 0;
-      if (limit !== void 0 && offset !== void 0) {
-        total = await collection.countDocuments(query);
-      }
-      const request = collection.find(query).sort({ createdAt: "desc" });
-      if (limit) {
-        request.limit(limit);
-      }
-      if (offset) {
-        request.skip(offset);
-      }
-      const result = await request.toArray();
-      const runs = result.map((row) => {
-        let parsedSnapshot = row.snapshot;
-        if (typeof parsedSnapshot === "string") {
-          try {
-            parsedSnapshot = JSON.parse(row.snapshot);
-          } catch (e) {
-            console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-          }
-        }
-        return {
-          workflowName: row.workflow_name,
-          runId: row.run_id,
-          snapshot: parsedSnapshot,
-          createdAt: new Date(row.createdAt),
-          updatedAt: new Date(row.updatedAt)
-        };
-      });
-      return { runs, total: total || runs.length };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_MONGODB_STORE_GET_WORKFLOW_RUNS_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: storage.TABLE_TRACES,
+      records
+    });
   }
-  async getEvalsByAgentName(agentName, type) {
-    try {
-      const query = {
-        agent_name: agentName
-      };
-      if (type === "test") {
-        query["test_info"] = { $ne: null };
-      }
-      if (type === "live") {
-        query["test_info"] = null;
-      }
-      const collection = await this.getCollection(storage.TABLE_EVALS);
-      const documents = await collection.find(query).sort({ created_at: "desc" }).toArray();
-      const result = documents.map((row) => this.transformEvalRow(row));
-      return result.filter((row) => {
-        if (type === "live") {
-          return !Boolean(row.testInfo?.testPath);
-        }
-        if (type === "test") {
-          return row.testInfo?.testPath !== null;
-        }
-        return true;
-      });
-    } catch (error$1) {
-      if (error$1 instanceof Error && error$1.message.includes("no such table")) {
-        return [];
-      }
-      throw new error.MastraError(
-        {
-          id: "STORAGE_MONGODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentName }
-        },
-        error$1
-      );
-    }
+};
+var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
   }
   async persistWorkflowSnapshot({
     workflowName,
@@ -1100,17 +1905,16 @@ var MongoDBStore = class extends storage.MastraStorage {
     snapshot
   }) {
     try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
       await collection.updateOne(
         { workflow_name: workflowName, run_id: runId },
         {
           $set: {
-            snapshot: JSON.stringify(snapshot),
-            updatedAt: now
-          },
-          $setOnInsert: {
-            createdAt: now
+            workflow_name: workflowName,
+            run_id: runId,
+            snapshot,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
           }
         },
         { upsert: true }
@@ -1132,7 +1936,7 @@ var MongoDBStore = class extends storage.MastraStorage {
     runId
   }) {
     try {
-      const result = await this.load({
+      const result = await this.operations.load({
         tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
         keys: {
           workflow_name: workflowName,
@@ -1142,7 +1946,7 @@ var MongoDBStore = class extends storage.MastraStorage {
       if (!result?.length) {
         return null;
       }
-      return JSON.parse(result[0].snapshot);
+      return typeof result[0].snapshot === "string" ? storage.safelyParseJSON(result[0].snapshot) : result[0].snapshot;
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1155,19 +1959,63 @@ var MongoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
+  async getWorkflowRuns(args) {
+    const options = args || {};
+    try {
+      const query = {};
+      if (options.workflowName) {
+        query["workflow_name"] = options.workflowName;
+      }
+      if (options.fromDate) {
+        query["createdAt"] = { $gte: options.fromDate };
+      }
+      if (options.toDate) {
+        if (query["createdAt"]) {
+          query["createdAt"].$lte = options.toDate;
+        } else {
+          query["createdAt"] = { $lte: options.toDate };
+        }
+      }
+      if (options.resourceId) {
+        query["resourceId"] = options.resourceId;
+      }
+      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const total = await collection.countDocuments(query);
+      let cursor = collection.find(query).sort({ createdAt: -1 });
+      if (options.offset) {
+        cursor = cursor.skip(options.offset);
+      }
+      if (options.limit) {
+        cursor = cursor.limit(options.limit);
+      }
+      const results = await cursor.toArray();
+      const runs = results.map((row) => this.parseWorkflowRun(row));
+      return {
+        runs,
+        total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_GET_WORKFLOW_RUNS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName: options.workflowName || "unknown" }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById(args) {
     try {
       const query = {};
-      if (runId) {
-        query["run_id"] = runId;
+      if (args.runId) {
+        query["run_id"] = args.runId;
       }
-      if (workflowName) {
-        query["workflow_name"] = workflowName;
+      if (args.workflowName) {
+        query["workflow_name"] = args.workflowName;
       }
-      const collection = await this.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
       const result = await collection.findOne(query);
       if (!result) {
         return null;
@@ -1179,7 +2027,7 @@ var MongoDBStore = class extends storage.MastraStorage {
           id: "STORAGE_MONGODB_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { runId }
+          details: { runId: args.runId }
         },
         error$1
       );
@@ -1189,7 +2037,7 @@ var MongoDBStore = class extends storage.MastraStorage {
     let parsedSnapshot = row.snapshot;
     if (typeof parsedSnapshot === "string") {
       try {
-        parsedSnapshot = JSON.parse(row.snapshot);
+        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}`);
       }
@@ -1198,85 +2046,187 @@ var MongoDBStore = class extends storage.MastraStorage {
       workflowName: row.workflow_name,
       runId: row.run_id,
       snapshot: parsedSnapshot,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt),
       resourceId: row.resourceId
     };
   }
-  parseRow(row) {
-    let content = row.content;
-    try {
-      content = JSON.parse(row.content);
-    } catch {
-    }
+};
+
+// src/storage/index.ts
+var MongoDBStore = class extends storage.MastraStorage {
+  #connector;
+  stores;
+  get supports() {
     return {
-      id: row.id,
-      content,
-      role: row.role,
-      type: row.type,
-      createdAt: new Date(row.createdAt),
-      threadId: row.thread_id,
-      resourceId: row.resourceId
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: false,
+      createTable: false
     };
   }
-  transformEvalRow(row) {
-    let testInfoValue = null;
-    if (row.test_info) {
-      try {
-        testInfoValue = typeof row.test_info === "string" ? JSON.parse(row.test_info) : row.test_info;
-      } catch (e) {
-        console.warn("Failed to parse test_info:", e);
+  constructor(config) {
+    super({ name: "MongoDBStore" });
+    this.stores = {};
+    try {
+      if ("connectorHandler" in config) {
+        this.#connector = MongoDBConnector.fromConnectionHandler(config.connectorHandler);
+        return;
       }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_CONSTRUCTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { connectionHandler: true }
+        },
+        error$1
+      );
     }
-    const resultValue = JSON.parse(row.result);
-    if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
-      throw new error.MastraError({
-        id: "STORAGE_MONGODB_STORE_INVALID_METRIC_FORMAT",
-        text: `Invalid MetricResult format: ${JSON.stringify(resultValue)}`,
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER
+    try {
+      this.#connector = MongoDBConnector.fromDatabaseConfig({
+        options: config.options,
+        url: config.url,
+        dbName: config.dbName
       });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_STORE_CONSTRUCTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { url: config?.url, dbName: config?.dbName }
+        },
+        error$1
+      );
     }
-    return {
-      input: row.input,
-      output: row.output,
-      result: resultValue,
-      agentName: row.agent_name,
-      metricName: row.metric_name,
-      instructions: row.instructions,
-      testInfo: testInfoValue,
-      globalRunId: row.global_run_id,
-      runId: row.run_id,
-      createdAt: row.created_at
+    const operations = new StoreOperationsMongoDB({
+      connector: this.#connector
+    });
+    const memory = new MemoryStorageMongoDB({
+      operations
+    });
+    const traces = new TracesStorageMongoDB({
+      operations
+    });
+    const legacyEvals = new LegacyEvalsMongoDB({
+      operations
+    });
+    const scores = new ScoresStorageMongoDB({
+      operations
+    });
+    const workflows = new WorkflowsStorageMongoDB({
+      operations
+    });
+    this.stores = {
+      operations,
+      memory,
+      traces,
+      legacyEvals,
+      scores,
+      workflows
     };
   }
-  async getTracesPaginated(_args) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_GET_TRACES_PAGINATED_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      text: "Method not implemented."
-    });
+  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 getThreadsByResourceId({ resourceId }) {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
+  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 getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, selectBy, format });
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
   }
   async getThreadsByResourceIdPaginated(_args) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      text: "Method not implemented."
-    });
+    return this.stores.memory.getThreadsByResourceIdPaginated(_args);
   }
   async getMessagesPaginated(_args) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      text: "Method not implemented."
-    });
+    return this.stores.memory.getMessagesPaginated(_args);
+  }
+  async updateMessages(_args) {
+    return this.stores.memory.updateMessages(_args);
+  }
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async getWorkflowRuns(args) {
+    return this.stores.workflows.getWorkflowRuns(args);
+  }
+  async getEvals(options = {}) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
   }
   async close() {
     try {
-      await this.#client.close();
+      await this.#connector.close();
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1288,9 +2238,55 @@ var MongoDBStore = class extends storage.MastraStorage {
       );
     }
   }
-  async updateMessages(_args) {
-    this.logger.error("updateMessages is not yet implemented in MongoDBStore");
-    throw new Error("Method not implemented");
+  /**
+   * SCORERS
+   */
+  async getScoreById({ id }) {
+    return this.stores.scores.getScoreById({ id });
+  }
+  async saveScore(score) {
+    return this.stores.scores.saveScore(score);
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType });
+  }
+  /**
+   * 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
+    });
   }
 };