@mastra/mongodb 0.14.9 → 1.0.0-beta.1

package/dist/index.cjs

@@ -7,13 +7,13 @@ var uuid = require('uuid');
 var filter = require('@mastra/core/vector/filter');
 var storage = require('@mastra/core/storage');
 var agent = require('@mastra/core/agent');
-var scores = require('@mastra/core/scores');
+var evals = require('@mastra/core/evals');
 
 // src/vector/index.ts
 
 // package.json
 var package_default = {
-  version: "0.14.9"};
+  version: "1.0.0-beta.1"};
 var MongoDBFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -116,8 +116,8 @@ var MongoDBVector = class extends vector.MastraVector {
     euclidean: "euclidean",
     dotproduct: "dotProduct"
   };
-  constructor({ uri, dbName, options }) {
-    super();
+  constructor({ id, uri, dbName, options }) {
+    super({ id });
     const client = new mongodb.MongoClient(uri, {
       ...options,
       driverInfo: {
@@ -695,155 +695,6 @@ var MongoDBConnector = class _MongoDBConnector {
     }
   }
 };
-function transformEvalRow(row) {
-  let testInfoValue = null;
-  if (row.test_info) {
-    try {
-      testInfoValue = typeof row.test_info === "string" ? storage.safelyParseJSON(row.test_info) : row.test_info;
-    } catch (e) {
-      console.warn("Failed to parse test_info:", e);
-    }
-  }
-  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 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 && 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 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.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_GET_EVALS_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            agentName: agentName || "all",
-            type: type || "all",
-            page,
-            perPage
-          }
-        },
-        error$1
-      );
-    }
-  }
-};
 
 // src/storage/domains/utils.ts
 function formatDateForMongoDB(date) {
@@ -878,10 +729,9 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
   }
   async _getIncludedMessages({
     threadId,
-    selectBy
+    include
   }) {
     if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    const include = selectBy?.include;
     if (!include) return null;
     const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
     const includedMessages = [];
@@ -905,151 +755,147 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
     });
     return dedupedMessages.map((row) => this.parseRow(row));
   }
-  async getMessages({
-    threadId,
-    resourceId,
-    selectBy,
-    format
-  }) {
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
     try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      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();
+      const rawMessages = await collection.find({ id: { $in: messageIds } }).sort({ createdAt: -1 }).toArray();
+      const list = new agent.MessageList().add(
+        rawMessages.map(this.parseRow),
+        "memory"
+      );
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_GET_MESSAGES_FAILED",
+          id: "MONGODB_STORE_LIST_MESSAGES_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId, resourceId: resourceId ?? "" }
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error$1
       );
     }
   }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    if (messageIds.length === 0) return [];
-    try {
-      const collection = await this.operations.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), "memory");
-      if (format === `v1`) return list.get.all.v1();
-      return list.get.all.v2();
-    } catch (error$1) {
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    if (!threadId.trim()) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_GET_MESSAGES_BY_ID_FAILED",
+          id: "STORAGE_MONGODB_LIST_MESSAGES_INVALID_THREAD_ID",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { messageIds: JSON.stringify(messageIds) }
+          details: { threadId }
         },
-        error$1
+        new Error("threadId must be a non-empty string")
       );
     }
-  }
-  async getMessagesPaginated(args) {
-    const { threadId, resourceId, 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, resourceId: resourceId ?? "" }
-          },
-          error$1
-        );
-      }
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_MONGODB_LIST_MESSAGES_INVALID_PAGE",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
     }
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      const currentOffset = page * perPage;
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const sortOrder = direction === "ASC" ? 1 : -1;
       const collection = await this.operations.getCollection(storage.TABLE_MESSAGES);
       const query = { thread_id: threadId };
-      if (fromDate) {
-        query.createdAt = { ...query.createdAt, $gte: fromDate };
+      if (resourceId) {
+        query.resourceId = resourceId;
+      }
+      if (filter?.dateRange?.start) {
+        query.createdAt = { ...query.createdAt, $gte: filter.dateRange.start };
       }
-      if (toDate) {
-        query.createdAt = { ...query.createdAt, $lte: toDate };
+      if (filter?.dateRange?.end) {
+        query.createdAt = { ...query.createdAt, $lte: filter.dateRange.end };
       }
       const total = await collection.countDocuments(query);
-      if (total === 0 && messages.length === 0) {
+      const messages = [];
+      if (perPage !== 0) {
+        const sortObj = { [field]: sortOrder };
+        let cursor = collection.find(query).sort(sortObj).skip(offset);
+        if (perPageInput !== false) {
+          cursor = cursor.limit(perPage);
+        }
+        const dataResult = await cursor.toArray();
+        messages.push(...dataResult.map((row) => this.parseRow(row)));
+      }
+      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
         return {
           messages: [],
           total: 0,
           page,
-          perPage,
+          perPage: perPageForResponse,
           hasMore: false
         };
       }
-      const excludeIds = messages.map((m) => m.id);
-      if (excludeIds.length > 0) {
-        query.id = { $nin: excludeIds };
+      const messageIds = new Set(messages.map((m) => m.id));
+      if (include && include.length > 0) {
+        const includeMessages = await this._getIncludedMessages({ threadId, include });
+        if (includeMessages) {
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              messages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
       }
-      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();
+      const list = new agent.MessageList().add(messages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const isDateField = field === "createdAt" || field === "updatedAt";
+        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total;
       return {
-        messages: messagesToReturn,
+        messages: finalMessages,
         total,
         page,
-        perPage,
-        hasMore: (page + 1) * perPage < total
+        perPage: perPageForResponse,
+        hasMore
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "MONGODB_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          id: "MONGODB_STORE_LIST_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId, resourceId: resourceId ?? "" }
+          details: {
+            threadId,
+            resourceId: resourceId ?? ""
+          }
         },
         error$1
       );
-      this.logger?.trackException?.(mastraError);
       this.logger?.error?.(mastraError.toString());
-      return { messages: [], total: 0, page, perPage, hasMore: false };
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async saveMessages({
-    messages,
-    format
-  }) {
-    if (messages.length === 0) return messages;
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return { messages: [] };
     try {
       const threadId = messages[0]?.threadId;
       if (!threadId) {
@@ -1092,8 +938,7 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
         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();
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1298,36 +1143,41 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
       );
     }
   }
-  async getThreadsByResourceId({ resourceId }) {
+  async listThreadsByResourceId(args) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_THREADS);
-      const results = await collection.find({ resourceId }).sort({ updatedAt: -1 }).toArray();
-      if (!results.length) {
-        return [];
+      const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+      if (page < 0) {
+        throw new error.MastraError(
+          {
+            id: "STORAGE_MONGODB_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
       }
-      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 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 query = { resourceId };
       const total = await collection.countDocuments(query);
-      const threads = await collection.find(query).sort({ updatedAt: -1 }).skip(page * perPage).limit(perPage).toArray();
+      if (perPage === 0) {
+        return {
+          threads: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: offset < total
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      let cursor = collection.find(query).sort({ [field]: sortOrder }).skip(offset);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const threads = await cursor.toArray();
       return {
         threads: threads.map((thread) => ({
           id: thread.id,
@@ -1339,13 +1189,13 @@ var MemoryStorageMongoDB = class extends storage.MemoryStorage {
         })),
         total,
         page,
-        perPage,
-        hasMore: (page + 1) * perPage < total
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
       };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          id: "MONGODB_STORE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { resourceId: args.resourceId }
@@ -1452,13 +1302,13 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
     super();
     this.operations = operations;
   }
-  get aiTracingStrategy() {
+  get tracingStrategy() {
     return {
       preferred: "batch-with-updates",
       supported: ["batch-with-updates", "insert-only"]
     };
   }
-  async createAISpan(span) {
+  async createSpan(span) {
     try {
       const startedAt = span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt;
       const endedAt = span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt;
@@ -1469,11 +1319,11 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      return this.operations.insert({ tableName: storage.TABLE_AI_SPANS, record });
+      return this.operations.insert({ tableName: storage.TABLE_SPANS, record });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_CREATE_AI_SPAN_FAILED",
+          id: "MONGODB_STORE_CREATE_SPAN_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
@@ -1487,9 +1337,9 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async getAITrace(traceId) {
+  async getTrace(traceId) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_AI_SPANS);
+      const collection = await this.operations.getCollection(storage.TABLE_SPANS);
       const spans = await collection.find({ traceId }).sort({ startedAt: -1 }).toArray();
       if (!spans || spans.length === 0) {
         return null;
@@ -1501,7 +1351,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_GET_AI_TRACE_FAILED",
+          id: "MONGODB_STORE_GET_TRACE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
@@ -1512,7 +1362,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async updateAISpan({
+  async updateSpan({
     spanId,
     traceId,
     updates
@@ -1530,14 +1380,14 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       await this.operations.update({
-        tableName: storage.TABLE_AI_SPANS,
+        tableName: storage.TABLE_SPANS,
         keys: { spanId, traceId },
         data: updateData
       });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_UPDATE_AI_SPAN_FAILED",
+          id: "MONGODB_STORE_UPDATE_SPAN_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
@@ -1549,7 +1399,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async getAITracesPaginated({
+  async getTracesPaginated({
     filters,
     pagination
   }) {
@@ -1557,7 +1407,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
     const perPage = pagination?.perPage ?? 10;
     const { entityId, entityType, ...actualFilters } = filters || {};
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_AI_SPANS);
+      const collection = await this.operations.getCollection(storage.TABLE_SPANS);
       const mongoFilter = {
         parentSpanId: null,
         // Only get root spans for traces
@@ -1583,7 +1433,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
           name = `agent run: '${entityId}'`;
         } else {
           const error$1 = new error.MastraError({
-            id: "MONGODB_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+            id: "MONGODB_STORE_GET_TRACES_PAGINATED_FAILED",
             domain: error.ErrorDomain.STORAGE,
             category: error.ErrorCategory.USER,
             details: {
@@ -1620,7 +1470,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+          id: "MONGODB_STORE_GET_TRACES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -1628,7 +1478,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async batchCreateAISpans(args) {
+  async batchCreateSpans(args) {
     try {
       const records = args.records.map((record) => {
         const startedAt = record.startedAt instanceof Date ? record.startedAt.toISOString() : record.startedAt;
@@ -1642,13 +1492,13 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
         };
       });
       return this.operations.batchInsert({
-        tableName: storage.TABLE_AI_SPANS,
+        tableName: storage.TABLE_SPANS,
         records
       });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_BATCH_CREATE_AI_SPANS_FAILED",
+          id: "MONGODB_STORE_BATCH_CREATE_SPANS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -1656,10 +1506,10 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async batchUpdateAISpans(args) {
+  async batchUpdateSpans(args) {
     try {
       return this.operations.batchUpdate({
-        tableName: storage.TABLE_AI_SPANS,
+        tableName: storage.TABLE_SPANS,
         updates: args.records.map((record) => {
           const data = { ...record.updates };
           if (data.endedAt instanceof Date) {
@@ -1681,7 +1531,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_BATCH_UPDATE_AI_SPANS_FAILED",
+          id: "MONGODB_STORE_BATCH_UPDATE_SPANS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -1689,16 +1539,16 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async batchDeleteAITraces(args) {
+  async batchDeleteTraces(args) {
     try {
-      const collection = await this.operations.getCollection(storage.TABLE_AI_SPANS);
+      const collection = await this.operations.getCollection(storage.TABLE_SPANS);
       await collection.deleteMany({
         traceId: { $in: args.traceIds }
       });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MONGODB_STORE_BATCH_DELETE_AI_TRACES_FAILED",
+          id: "MONGODB_STORE_BATCH_DELETE_TRACES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -1707,7 +1557,7 @@ var ObservabilityMongoDB = class extends storage.ObservabilityStorage {
     }
   }
   /**
-   * Transform MongoDB document to AISpanRecord format
+   * Transform MongoDB document to SpanRecord format
    */
   transformSpanFromMongo(doc) {
     const { _id, ...span } = doc;
@@ -1955,12 +1805,12 @@ function transformScoreRow(row) {
       console.warn("Failed to parse entity:", e);
     }
   }
-  let runtimeContextValue = null;
-  if (row.runtimeContext) {
+  let requestContextValue = null;
+  if (row.requestContext) {
     try {
-      runtimeContextValue = typeof row.runtimeContext === "string" ? storage.safelyParseJSON(row.runtimeContext) : row.runtimeContext;
+      requestContextValue = typeof row.requestContext === "string" ? storage.safelyParseJSON(row.requestContext) : row.requestContext;
     } catch (e) {
-      console.warn("Failed to parse runtimeContext:", e);
+      console.warn("Failed to parse requestContext:", e);
     }
   }
   let metadataValue = null;
@@ -1991,7 +1841,7 @@ function transformScoreRow(row) {
     input: inputValue,
     output: outputValue,
     additionalContext: row.additionalContext,
-    runtimeContext: runtimeContextValue,
+    requestContext: requestContextValue,
     entity: entityValue,
     source: row.source,
     resourceId: row.resourceId,
@@ -2029,7 +1879,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
   async saveScore(score) {
     let validatedScore;
     try {
-      validatedScore = scores.saveScorePayloadSchema.parse(score);
+      validatedScore = evals.saveScorePayloadSchema.parse(score);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -2063,7 +1913,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
         input: typeof validatedScore.input === "string" ? storage.safelyParseJSON(validatedScore.input) : validatedScore.input,
         output: typeof validatedScore.output === "string" ? storage.safelyParseJSON(validatedScore.output) : validatedScore.output,
         additionalContext: validatedScore.additionalContext,
-        runtimeContext: typeof validatedScore.runtimeContext === "string" ? storage.safelyParseJSON(validatedScore.runtimeContext) : validatedScore.runtimeContext,
+        requestContext: typeof validatedScore.requestContext === "string" ? storage.safelyParseJSON(validatedScore.requestContext) : validatedScore.requestContext,
         entity: typeof validatedScore.entity === "string" ? storage.safelyParseJSON(validatedScore.entity) : validatedScore.entity,
         source: validatedScore.source,
         resourceId: validatedScore.resourceId || "",
@@ -2092,7 +1942,7 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresByScorerId({
+  async listScoresByScorerId({
     scorerId,
     pagination,
     entityId,
@@ -2100,6 +1950,9 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
     source
   }) {
     try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const query = { scorerId };
       if (entityId) {
         query.entityId = entityId;
@@ -2112,28 +1965,31 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       }
       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,
+            page,
+            perPage: perPageInput,
             hasMore: false
           }
         };
       }
-      const documents = await collection.find(query).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const end = perPageInput === false ? total : start + perPage;
+      let cursor = collection.find(query).sort({ createdAt: "desc" }).skip(start);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const documents = await cursor.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
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         }
       };
     } catch (error$1) {
@@ -2148,35 +2004,41 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresByRunId({
+  async listScoresByRunId({
     runId,
     pagination
   }) {
     try {
+      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 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,
+            page,
+            perPage: perPageInput,
             hasMore: false
           }
         };
       }
-      const documents = await collection.find({ runId }).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const end = perPageInput === false ? total : start + perPage;
+      let cursor = collection.find({ runId }).sort({ createdAt: "desc" }).skip(start);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const documents = await cursor.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
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         }
       };
     } catch (error$1) {
@@ -2191,36 +2053,42 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresByEntityId({
+  async listScoresByEntityId({
     entityId,
     entityType,
     pagination
   }) {
     try {
+      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 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,
+            page,
+            perPage: perPageInput,
             hasMore: false
           }
         };
       }
-      const documents = await collection.find({ entityId, entityType }).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const end = perPageInput === false ? total : start + perPage;
+      let cursor = collection.find({ entityId, entityType }).sort({ createdAt: "desc" }).skip(start);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const documents = await cursor.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
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         }
       };
     } catch (error$1) {
@@ -2235,37 +2103,43 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresBySpan({
+  async listScoresBySpan({
     traceId,
     spanId,
     pagination
   }) {
     try {
+      const { page, perPage: perPageInput } = pagination;
+      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 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,
+            page,
+            perPage: perPageInput,
             hasMore: false
           }
         };
       }
-      const documents = await collection.find(query).sort({ createdAt: "desc" }).skip(currentOffset).limit(pagination.perPage).toArray();
+      const end = perPageInput === false ? total : start + perPage;
+      let cursor = collection.find(query).sort({ createdAt: "desc" }).skip(start);
+      if (perPageInput !== false) {
+        cursor = cursor.limit(perPage);
+      }
+      const documents = await cursor.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
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         }
       };
     } catch (error$1) {
@@ -2281,121 +2155,6 @@ var ScoresStorageMongoDB = class extends storage.ScoresStorage {
     }
   }
 };
-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
-      };
-    }
-    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
-      );
-    }
-  }
-  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);
-    }
-    if (scope) {
-      query["scope"] = scope;
-    }
-    if (attributes) {
-      query["$and"] = Object.entries(attributes).map(([key, value]) => ({
-        [`attributes.${key}`]: value
-      }));
-    }
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        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.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(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: 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: 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_PAGINATED_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
-    });
-  }
-};
 var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
   operations;
   constructor({ operations }) {
@@ -2407,7 +2166,7 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
     // runId,
     // stepId,
     // result,
-    // runtimeContext,
+    // requestContext,
   }) {
     throw new Error("Method not implemented.");
   }
@@ -2480,13 +2239,16 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
       );
     }
   }
-  async getWorkflowRuns(args) {
+  async listWorkflowRuns(args) {
     const options = args || {};
     try {
       const query = {};
       if (options.workflowName) {
         query["workflow_name"] = options.workflowName;
       }
+      if (options.status) {
+        query["snapshot.status"] = options.status;
+      }
       if (options.fromDate) {
         query["createdAt"] = { $gte: options.fromDate };
       }
@@ -2501,24 +2263,39 @@ var WorkflowsStorageMongoDB = class extends storage.WorkflowsStorage {
         query["resourceId"] = options.resourceId;
       }
       const collection = await this.operations.getCollection(storage.TABLE_WORKFLOW_SNAPSHOT);
-      const total = await collection.countDocuments(query);
+      let total = 0;
       let cursor = collection.find(query).sort({ createdAt: -1 });
-      if (options.offset) {
-        cursor = cursor.skip(options.offset);
-      }
-      if (options.limit) {
-        cursor = cursor.limit(options.limit);
+      if (options.page !== void 0 && typeof options.perPage === "number") {
+        if (options.page < 0) {
+          throw new error.MastraError(
+            {
+              id: "STORAGE_MONGODB_INVALID_PAGE",
+              domain: error.ErrorDomain.STORAGE,
+              category: error.ErrorCategory.USER,
+              details: { page: options.page }
+            },
+            new Error("page must be >= 0")
+          );
+        }
+        total = await collection.countDocuments(query);
+        const normalizedPerPage = storage.normalizePerPage(options.perPage, Number.MAX_SAFE_INTEGER);
+        if (normalizedPerPage === 0) {
+          return { runs: [], total };
+        }
+        const offset = options.page * normalizedPerPage;
+        cursor = cursor.skip(offset);
+        cursor = cursor.limit(Math.min(normalizedPerPage, 2147483647));
       }
       const results = await cursor.toArray();
       const runs = results.map((row) => this.parseWorkflowRun(row));
       return {
         runs,
-        total
+        total: total || runs.length
       };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "STORAGE_MONGODB_STORE_GET_WORKFLOW_RUNS_FAILED",
+          id: "STORAGE_MONGODB_STORE_LIST_WORKFLOW_RUNS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { workflowName: options.workflowName || "unknown" }
@@ -2593,6 +2370,7 @@ var loadConnector = (config) => {
   }
   try {
     return MongoDBConnector.fromDatabaseConfig({
+      id: config.id,
       options: config.options,
       url: config.url,
       dbName: config.dbName
@@ -2619,11 +2397,11 @@ var MongoDBStore = class extends storage.MastraStorage {
       hasColumn: false,
       createTable: false,
       deleteMessages: false,
-      getScoresBySpan: true
+      listScoresBySpan: true
     };
   }
   constructor(config) {
-    super({ name: "MongoDBStore" });
+    super({ id: config.id, name: "MongoDBStore" });
     this.stores = {};
     this.#connector = loadConnector(config);
     const operations = new StoreOperationsMongoDB({
@@ -2632,12 +2410,6 @@ var MongoDBStore = class extends storage.MastraStorage {
     const memory = new MemoryStorageMongoDB({
       operations
     });
-    const traces = new TracesStorageMongoDB({
-      operations
-    });
-    const legacyEvals = new LegacyEvalsMongoDB({
-      operations
-    });
     const scores = new ScoresStorageMongoDB({
       operations
     });
@@ -2650,8 +2422,6 @@ var MongoDBStore = class extends storage.MastraStorage {
     this.stores = {
       operations,
       memory,
-      traces,
-      legacyEvals,
       scores,
       workflows,
       observability
@@ -2684,12 +2454,6 @@ var MongoDBStore = class extends storage.MastraStorage {
   async getThreadById({ threadId }) {
     return this.stores.memory.getThreadById({ threadId });
   }
-  async getThreadsByResourceId({ resourceId }) {
-    return this.stores.memory.getThreadsByResourceId({ resourceId });
-  }
-  async getThreadsByResourceIdPaginated(_args) {
-    return this.stores.memory.getThreadsByResourceIdPaginated(_args);
-  }
   async saveThread({ thread }) {
     return this.stores.memory.saveThread({ thread });
   }
@@ -2703,21 +2467,8 @@ var MongoDBStore = class extends storage.MastraStorage {
   async deleteThread({ threadId }) {
     return this.stores.memory.deleteThread({ threadId });
   }
-  async getMessages({
-    threadId,
-    selectBy,
-    format
-  }) {
-    return this.stores.memory.getMessages({ threadId, selectBy, format });
-  }
-  async getMessagesPaginated(_args) {
-    return this.stores.memory.getMessagesPaginated(_args);
-  }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    return this.stores.memory.getMessagesById({ messageIds, format });
+  async listMessagesById({ messageIds }) {
+    return this.stores.memory.listMessagesById({ messageIds });
   }
   async saveMessages(args) {
     return this.stores.memory.saveMessages(args);
@@ -2725,32 +2476,17 @@ var MongoDBStore = class extends storage.MastraStorage {
   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 batchTraceInsert({ records }) {
-    return this.stores.traces.batchTraceInsert({ records });
-  }
-  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 listWorkflowRuns(args) {
+    return this.stores.workflows.listWorkflowRuns(args);
   }
   async updateWorkflowResults({
     workflowName,
     runId,
     stepId,
     result,
-    runtimeContext
+    requestContext
   }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
   }
   async updateWorkflowState({
     workflowName,
@@ -2802,34 +2538,34 @@ var MongoDBStore = class extends storage.MastraStorage {
   async saveScore(score) {
     return this.stores.scores.saveScore(score);
   }
-  async getScoresByRunId({
+  async listScoresByRunId({
     runId,
     pagination
   }) {
-    return this.stores.scores.getScoresByRunId({ runId, pagination });
+    return this.stores.scores.listScoresByRunId({ runId, pagination });
   }
-  async getScoresByEntityId({
+  async listScoresByEntityId({
     entityId,
     entityType,
     pagination
   }) {
-    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
+    return this.stores.scores.listScoresByEntityId({ entityId, entityType, pagination });
   }
-  async getScoresByScorerId({
+  async listScoresByScorerId({
     scorerId,
     pagination,
     entityId,
     entityType,
     source
   }) {
-    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
+    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
   }
-  async getScoresBySpan({
+  async listScoresBySpan({
     traceId,
     spanId,
     pagination
   }) {
-    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination });
+    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
   }
   /**
    * RESOURCES
@@ -2852,9 +2588,9 @@ var MongoDBStore = class extends storage.MastraStorage {
     });
   }
   /**
-   * AI Tracing/Observability
+   * Tracing/Observability
    */
-  async createAISpan(span) {
+  async createSpan(span) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -2863,9 +2599,9 @@ var MongoDBStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.createAISpan(span);
+    return this.stores.observability.createSpan(span);
   }
-  async updateAISpan({
+  async updateSpan({
     spanId,
     traceId,
     updates
@@ -2878,9 +2614,9 @@ var MongoDBStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.updateAISpan({ spanId, traceId, updates });
+    return this.stores.observability.updateSpan({ spanId, traceId, updates });
   }
-  async getAITrace(traceId) {
+  async getTrace(traceId) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -2889,9 +2625,9 @@ var MongoDBStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.getAITrace(traceId);
+    return this.stores.observability.getTrace(traceId);
   }
-  async getAITracesPaginated(args) {
+  async getTracesPaginated(args) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -2900,9 +2636,9 @@ var MongoDBStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.getAITracesPaginated(args);
+    return this.stores.observability.getTracesPaginated(args);
   }
-  async batchCreateAISpans(args) {
+  async batchCreateSpans(args) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -2911,9 +2647,9 @@ var MongoDBStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.batchCreateAISpans(args);
+    return this.stores.observability.batchCreateSpans(args);
   }
-  async batchUpdateAISpans(args) {
+  async batchUpdateSpans(args) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -2922,9 +2658,9 @@ var MongoDBStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.batchUpdateAISpans(args);
+    return this.stores.observability.batchUpdateSpans(args);
   }
-  async batchDeleteAITraces(args) {
+  async batchDeleteTraces(args) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "MONGODB_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -2933,7 +2669,7 @@ var MongoDBStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.batchDeleteAITraces(args);
+    return this.stores.observability.batchDeleteTraces(args);
   }
 };