@mastra/mongodb 1.1.0 → 1.2.0

package/dist/index.js

@@ -4,6 +4,7 @@ import { MastraVector, validateUpsertInput, validateVectorValues } from '@mastra
 import { MongoClient } from 'mongodb';
 import { v4 } from 'uuid';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import { randomUUID } from 'crypto';
 import { MessageList } from '@mastra/core/agent';
 import { saveScorePayloadSchema } from '@mastra/core/evals';
 
@@ -11,7 +12,7 @@ import { saveScorePayloadSchema } from '@mastra/core/evals';
 
 // package.json
 var package_default = {
-  version: "1.1.0"};
+  version: "1.2.0"};
 var MongoDBFilterTranslator = class extends BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -1022,7 +1023,7 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends AgentsStorage {
       };
       await collection.insertOne(this.serializeAgent(newAgent));
       const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = agent;
-      const versionId = crypto.randomUUID();
+      const versionId = randomUUID();
       await this.createVersion({
         id: versionId,
         agentId: agent.id,
@@ -1031,9 +1032,6 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends AgentsStorage {
         changedFields: Object.keys(snapshotConfig),
         changeMessage: "Initial version"
       });
-      newAgent.activeVersionId = versionId;
-      newAgent.status = "published";
-      await collection.updateOne({ id: agent.id }, { $set: { activeVersionId: versionId, status: "published" } });
       return newAgent;
     } catch (error) {
       if (error instanceof MastraError) {
@@ -1066,14 +1064,49 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends AgentsStorage {
       const updateDoc = {
         updatedAt: /* @__PURE__ */ new Date()
       };
-      if (updates.authorId !== void 0) updateDoc.authorId = updates.authorId;
-      if (updates.activeVersionId !== void 0) {
-        updateDoc.activeVersionId = updates.activeVersionId;
-        updateDoc.status = "published";
+      const metadataFields = {
+        authorId: updates.authorId,
+        activeVersionId: updates.activeVersionId,
+        metadata: updates.metadata
+      };
+      const configFields = {};
+      for (const field of SNAPSHOT_FIELDS) {
+        if (updates[field] !== void 0) {
+          configFields[field] = updates[field];
+        }
+      }
+      if (Object.keys(configFields).length > 0) {
+        const latestVersion = await this.getLatestVersion(id);
+        const nextVersionNumber = latestVersion ? latestVersion.versionNumber + 1 : 1;
+        if (!latestVersion) {
+          throw new MastraError({
+            id: createStorageErrorId("MONGODB", "UPDATE_AGENT", "NO_VERSION"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            text: `Cannot update config fields for agent ${id} - no versions exist`,
+            details: { id }
+          });
+        }
+        const versionInput = {
+          id: randomUUID(),
+          agentId: id,
+          versionNumber: nextVersionNumber,
+          ...this.extractSnapshotFields(latestVersion),
+          // Start from latest version
+          ...configFields,
+          // Apply updates
+          changedFields: Object.keys(configFields),
+          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
+        };
+        await this.createVersion(versionInput);
+      }
+      if (metadataFields.authorId !== void 0) updateDoc.authorId = metadataFields.authorId;
+      if (metadataFields.activeVersionId !== void 0) {
+        updateDoc.activeVersionId = metadataFields.activeVersionId;
       }
-      if (updates.metadata !== void 0) {
+      if (metadataFields.metadata !== void 0) {
         const existingMetadata = existingAgent.metadata || {};
-        updateDoc.metadata = { ...existingMetadata, ...updates.metadata };
+        updateDoc.metadata = { ...existingMetadata, ...metadataFields.metadata };
       }
       await collection.updateOne({ id }, { $set: updateDoc });
       const updatedAgent = await collection.findOne({ id });
@@ -1175,6 +1208,123 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends AgentsStorage {
       );
     }
   }
+  async listAgentsResolved(args) {
+    try {
+      const { page = 0, perPage: perPageInput, orderBy } = args || {};
+      const { field, direction } = this.parseOrderBy(orderBy);
+      if (page < 0) {
+        throw new MastraError(
+          {
+            id: createStorageErrorId("MONGODB", "LIST_AGENTS_RESOLVED", "INVALID_PAGE"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
+      }
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const agentsCollection = await this.getCollection(TABLE_AGENTS);
+      const total = await agentsCollection.countDocuments({});
+      if (total === 0 || perPage === 0) {
+        return {
+          agents: [],
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      const pipeline = [
+        // Sort agents
+        { $sort: { [field]: sortOrder } },
+        // Paginate
+        { $skip: offset }
+      ];
+      if (perPageInput !== false) {
+        pipeline.push({ $limit: perPage });
+      }
+      pipeline.push({
+        $lookup: {
+          from: TABLE_AGENT_VERSIONS,
+          localField: "activeVersionId",
+          foreignField: "id",
+          as: "activeVersion"
+        }
+      });
+      pipeline.push({
+        $lookup: {
+          from: TABLE_AGENT_VERSIONS,
+          let: { agentId: "$id" },
+          pipeline: [
+            { $match: { $expr: { $eq: ["$agentId", "$$agentId"] } } },
+            { $sort: { versionNumber: -1 } },
+            { $limit: 1 }
+          ],
+          as: "latestVersion"
+        }
+      });
+      pipeline.push({
+        $addFields: {
+          version: {
+            $cond: {
+              if: { $gt: [{ $size: "$activeVersion" }, 0] },
+              then: { $arrayElemAt: ["$activeVersion", 0] },
+              else: { $arrayElemAt: ["$latestVersion", 0] }
+            }
+          }
+        }
+      });
+      pipeline.push({
+        $project: {
+          activeVersion: 0,
+          latestVersion: 0
+        }
+      });
+      const results = await agentsCollection.aggregate(pipeline).toArray();
+      const resolvedAgents = results.map((doc) => {
+        const agent = this.transformAgent(doc);
+        if (doc.version) {
+          const version = this.transformVersion(doc.version);
+          const {
+            id: _versionId,
+            agentId: _agentId,
+            versionNumber: _versionNumber,
+            changedFields: _changedFields,
+            changeMessage: _changeMessage,
+            createdAt: _createdAt,
+            ...snapshotConfig
+          } = version;
+          return {
+            ...agent,
+            ...snapshotConfig
+          };
+        }
+        return agent;
+      });
+      return {
+        agents: resolvedAgents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput !== false && offset + perPage < total
+      };
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "LIST_AGENTS_RESOLVED", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
   /**
    * Transforms a raw MongoDB document into a thin StorageAgentType record.
    * Only returns metadata-level fields (no config/snapshot fields).
@@ -1408,6 +1558,18 @@ var MongoDBAgentsStorage = class _MongoDBAgentsStorage extends AgentsStorage {
   // ==========================================================================
   // Private Helper Methods
   // ==========================================================================
+  /**
+   * Extracts just the snapshot config fields from a version.
+   */
+  extractSnapshotFields(version) {
+    const result = {};
+    for (const field of SNAPSHOT_FIELDS) {
+      if (version[field] !== void 0) {
+        result[field] = version[field];
+      }
+    }
+    return result;
+  }
   /**
    * Transforms a raw MongoDB version document into an AgentVersion.
    * Config fields are returned directly (no nested snapshot object).
@@ -1435,12 +1597,14 @@ function formatDateForMongoDB(date) {
 }
 
 // src/storage/domains/memory/index.ts
+var OM_TABLE = "mastra_observational_memory";
 var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends MemoryStorage {
+  supportsObservationalMemory = true;
   #connector;
   #skipDefaultIndexes;
   #indexes;
   /** Collections managed by this domain */
-  static MANAGED_COLLECTIONS = [TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES];
+  static MANAGED_COLLECTIONS = [TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, OM_TABLE];
   constructor(config) {
     super();
     this.#connector = resolveMongoDBConfig(config);
@@ -1475,7 +1639,11 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends MemoryStorage {
       // Resources collection indexes
       { collection: TABLE_RESOURCES, keys: { id: 1 }, options: { unique: true } },
       { collection: TABLE_RESOURCES, keys: { createdAt: -1 } },
-      { collection: TABLE_RESOURCES, keys: { updatedAt: -1 } }
+      { collection: TABLE_RESOURCES, keys: { updatedAt: -1 } },
+      // Observational Memory collection indexes
+      { collection: OM_TABLE, keys: { id: 1 }, options: { unique: true } },
+      { collection: OM_TABLE, keys: { lookupKey: 1 } },
+      { collection: OM_TABLE, keys: { lookupKey: 1, generationCount: -1 } }
     ];
   }
   /**
@@ -1710,6 +1878,118 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends MemoryStorage {
       };
     }
   }
+  async listMessagesByResourceId(args) {
+    const { resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    if (!resourceId || typeof resourceId !== "string" || resourceId.trim().length === 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "LIST_MESSAGES", "INVALID_QUERY"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { resourceId: resourceId ?? "" }
+        },
+        new Error("resourceId is required")
+      );
+    }
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "LIST_MESSAGES", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const sortOrder = direction === "ASC" ? 1 : -1;
+      const collection = await this.getCollection(TABLE_MESSAGES);
+      const query = {};
+      query.resourceId = resourceId;
+      if (filter?.dateRange?.start) {
+        const startOp = filter.dateRange.startExclusive ? "$gt" : "$gte";
+        query.createdAt = { ...query.createdAt, [startOp]: formatDateForMongoDB(filter.dateRange.start) };
+      }
+      if (filter?.dateRange?.end) {
+        const endOp = filter.dateRange.endExclusive ? "$lt" : "$lte";
+        query.createdAt = { ...query.createdAt, [endOp]: formatDateForMongoDB(filter.dateRange.end) };
+      }
+      const total = await collection.countDocuments(query);
+      const messages = [];
+      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: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(messages.map((m) => m.id));
+      if (include && include.length > 0) {
+        const includeMessages = await this._getIncludedMessages({ include });
+        if (includeMessages) {
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              messages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
+      }
+      const list = new 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 hasMore = perPageInput !== false && offset + perPage < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "LIST_MESSAGES_BY_RESOURCE_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
   async saveMessages({ messages }) {
     if (messages.length === 0) return { messages: [] };
     try {
@@ -2160,6 +2440,355 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends MemoryStorage {
       );
     }
   }
+  // ============================================
+  // Observational Memory Methods
+  // ============================================
+  getOMKey(threadId, resourceId) {
+    return threadId ? `thread:${threadId}` : `resource:${resourceId}`;
+  }
+  parseOMDocument(doc) {
+    return {
+      id: doc.id,
+      scope: doc.scope,
+      threadId: doc.threadId || null,
+      resourceId: doc.resourceId,
+      createdAt: doc.createdAt instanceof Date ? doc.createdAt : new Date(doc.createdAt),
+      updatedAt: doc.updatedAt instanceof Date ? doc.updatedAt : new Date(doc.updatedAt),
+      lastObservedAt: doc.lastObservedAt ? doc.lastObservedAt instanceof Date ? doc.lastObservedAt : new Date(doc.lastObservedAt) : void 0,
+      originType: doc.originType || "initial",
+      generationCount: Number(doc.generationCount || 0),
+      activeObservations: doc.activeObservations || "",
+      bufferedObservations: doc.activeObservationsPendingUpdate || void 0,
+      totalTokensObserved: Number(doc.totalTokensObserved || 0),
+      observationTokenCount: Number(doc.observationTokenCount || 0),
+      pendingMessageTokens: Number(doc.pendingMessageTokens || 0),
+      isReflecting: Boolean(doc.isReflecting),
+      isObserving: Boolean(doc.isObserving),
+      config: doc.config || {},
+      metadata: doc.metadata || void 0,
+      observedMessageIds: doc.observedMessageIds || void 0,
+      observedTimezone: doc.observedTimezone || void 0
+    };
+  }
+  async getObservationalMemory(threadId, resourceId) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      const collection = await this.getCollection(OM_TABLE);
+      const doc = await collection.findOne({ lookupKey }, { sort: { generationCount: -1 } });
+      if (!doc) return null;
+      return this.parseOMDocument(doc);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "GET_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId }
+        },
+        error
+      );
+    }
+  }
+  async getObservationalMemoryHistory(threadId, resourceId, limit = 10) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      const collection = await this.getCollection(OM_TABLE);
+      const docs = await collection.find({ lookupKey }).sort({ generationCount: -1 }).limit(limit).toArray();
+      return docs.map((doc) => this.parseOMDocument(doc));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "GET_OBSERVATIONAL_MEMORY_HISTORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId, limit }
+        },
+        error
+      );
+    }
+  }
+  async initializeObservationalMemory(input) {
+    try {
+      const id = randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const lookupKey = this.getOMKey(input.threadId, input.resourceId);
+      const record = {
+        id,
+        scope: input.scope,
+        threadId: input.threadId,
+        resourceId: input.resourceId,
+        createdAt: now,
+        updatedAt: now,
+        lastObservedAt: void 0,
+        originType: "initial",
+        generationCount: 0,
+        activeObservations: "",
+        totalTokensObserved: 0,
+        observationTokenCount: 0,
+        pendingMessageTokens: 0,
+        isReflecting: false,
+        isObserving: false,
+        config: input.config,
+        observedTimezone: input.observedTimezone
+      };
+      const collection = await this.getCollection(OM_TABLE);
+      await collection.insertOne({
+        id,
+        lookupKey,
+        scope: input.scope,
+        resourceId: input.resourceId,
+        threadId: input.threadId || null,
+        activeObservations: "",
+        activeObservationsPendingUpdate: null,
+        originType: "initial",
+        config: input.config,
+        generationCount: 0,
+        lastObservedAt: null,
+        lastReflectionAt: null,
+        pendingMessageTokens: 0,
+        totalTokensObserved: 0,
+        observationTokenCount: 0,
+        isObserving: false,
+        isReflecting: false,
+        observedTimezone: input.observedTimezone || null,
+        createdAt: now,
+        updatedAt: now
+      });
+      return record;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "INITIALIZE_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: input.threadId, resourceId: input.resourceId }
+        },
+        error
+      );
+    }
+  }
+  async updateActiveObservations(input) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const collection = await this.getCollection(OM_TABLE);
+      const safeTokenCount = Number.isFinite(input.tokenCount) && input.tokenCount >= 0 ? input.tokenCount : 0;
+      const updateDoc = {
+        activeObservations: input.observations,
+        lastObservedAt: input.lastObservedAt,
+        pendingMessageTokens: 0,
+        observationTokenCount: safeTokenCount,
+        observedMessageIds: input.observedMessageIds ?? null,
+        updatedAt: now
+      };
+      const result = await collection.updateOne(
+        { id: input.id },
+        {
+          $set: updateDoc,
+          $inc: { totalTokensObserved: safeTokenCount }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("MONGODB", "UPDATE_ACTIVE_OBSERVATIONS", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "UPDATE_ACTIVE_OBSERVATIONS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        },
+        error
+      );
+    }
+  }
+  async createReflectionGeneration(input) {
+    try {
+      const id = randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const lookupKey = this.getOMKey(input.currentRecord.threadId, input.currentRecord.resourceId);
+      const record = {
+        id,
+        scope: input.currentRecord.scope,
+        threadId: input.currentRecord.threadId,
+        resourceId: input.currentRecord.resourceId,
+        createdAt: now,
+        updatedAt: now,
+        lastObservedAt: input.currentRecord.lastObservedAt,
+        originType: "reflection",
+        generationCount: input.currentRecord.generationCount + 1,
+        activeObservations: input.reflection,
+        totalTokensObserved: input.currentRecord.totalTokensObserved,
+        observationTokenCount: input.tokenCount,
+        pendingMessageTokens: 0,
+        isReflecting: false,
+        isObserving: false,
+        config: input.currentRecord.config,
+        metadata: input.currentRecord.metadata,
+        observedTimezone: input.currentRecord.observedTimezone
+      };
+      const collection = await this.getCollection(OM_TABLE);
+      await collection.insertOne({
+        id,
+        lookupKey,
+        scope: record.scope,
+        resourceId: record.resourceId,
+        threadId: record.threadId || null,
+        activeObservations: input.reflection,
+        activeObservationsPendingUpdate: null,
+        originType: "reflection",
+        config: record.config,
+        generationCount: input.currentRecord.generationCount + 1,
+        lastObservedAt: record.lastObservedAt || null,
+        lastReflectionAt: now,
+        pendingMessageTokens: record.pendingMessageTokens,
+        totalTokensObserved: record.totalTokensObserved,
+        observationTokenCount: record.observationTokenCount,
+        isObserving: false,
+        isReflecting: false,
+        observedTimezone: record.observedTimezone || null,
+        createdAt: now,
+        updatedAt: now,
+        metadata: record.metadata || null
+      });
+      return record;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "CREATE_REFLECTION_GENERATION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { currentRecordId: input.currentRecord.id }
+        },
+        error
+      );
+    }
+  }
+  async setReflectingFlag(id, isReflecting) {
+    try {
+      const collection = await this.getCollection(OM_TABLE);
+      const result = await collection.updateOne({ id }, { $set: { isReflecting, updatedAt: /* @__PURE__ */ new Date() } });
+      if (result.matchedCount === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("MONGODB", "SET_REFLECTING_FLAG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isReflecting }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "SET_REFLECTING_FLAG", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isReflecting }
+        },
+        error
+      );
+    }
+  }
+  async setObservingFlag(id, isObserving) {
+    try {
+      const collection = await this.getCollection(OM_TABLE);
+      const result = await collection.updateOne({ id }, { $set: { isObserving, updatedAt: /* @__PURE__ */ new Date() } });
+      if (result.matchedCount === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("MONGODB", "SET_OBSERVING_FLAG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isObserving }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "SET_OBSERVING_FLAG", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isObserving }
+        },
+        error
+      );
+    }
+  }
+  async clearObservationalMemory(threadId, resourceId) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      const collection = await this.getCollection(OM_TABLE);
+      await collection.deleteMany({ lookupKey });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "CLEAR_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId }
+        },
+        error
+      );
+    }
+  }
+  async addPendingMessageTokens(id, tokenCount) {
+    if (typeof tokenCount !== "number" || !Number.isFinite(tokenCount) || tokenCount < 0) {
+      throw new MastraError({
+        id: createStorageErrorId("MONGODB", "ADD_PENDING_MESSAGE_TOKENS", "INVALID_INPUT"),
+        text: `Invalid tokenCount: must be a finite non-negative number, got ${tokenCount}`,
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { id, tokenCount }
+      });
+    }
+    try {
+      const collection = await this.getCollection(OM_TABLE);
+      const result = await collection.updateOne(
+        { id },
+        {
+          $inc: { pendingMessageTokens: tokenCount },
+          $set: { updatedAt: /* @__PURE__ */ new Date() }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("MONGODB", "ADD_PENDING_MESSAGE_TOKENS", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, tokenCount }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "ADD_PENDING_MESSAGE_TOKENS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, tokenCount }
+        },
+        error
+      );
+    }
+  }
 };
 var ObservabilityMongoDB = class _ObservabilityMongoDB extends ObservabilityStorage {
   #connector;
@@ -3037,7 +3666,7 @@ var ScoresStorageMongoDB = class _ScoresStorageMongoDB extends ScoresStorage {
     }
     try {
       const now = /* @__PURE__ */ new Date();
-      const scoreId = crypto.randomUUID();
+      const scoreId = randomUUID();
       const scorer = typeof validatedScore.scorer === "string" ? safelyParseJSON(validatedScore.scorer) : validatedScore.scorer;
       const preprocessStepResult = typeof validatedScore.preprocessStepResult === "string" ? safelyParseJSON(validatedScore.preprocessStepResult) : validatedScore.preprocessStepResult;
       const analyzeStepResult = typeof validatedScore.analyzeStepResult === "string" ? safelyParseJSON(validatedScore.analyzeStepResult) : validatedScore.analyzeStepResult;