@mastra/mongodb 1.5.2 → 1.5.3

package/dist/index.js

@@ -12,7 +12,7 @@ import { saveScorePayloadSchema } from '@mastra/core/evals';
 
 // package.json
 var package_default = {
-  version: "1.5.2"};
+  version: "1.5.3"};
 var MongoDBFilterTranslator = class extends BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -3640,6 +3640,141 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends MemoryStorage {
       );
     }
   }
+  async cloneThread(args) {
+    const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
+    const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
+    if (!sourceThread) {
+      throw new MastraError({
+        id: createStorageErrorId("MONGODB", "CLONE_THREAD", "SOURCE_NOT_FOUND"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Source thread with id ${sourceThreadId} not found`,
+        details: { sourceThreadId }
+      });
+    }
+    const newThreadId = providedThreadId || randomUUID();
+    const existingThread = await this.getThreadById({ threadId: newThreadId });
+    if (existingThread) {
+      throw new MastraError({
+        id: createStorageErrorId("MONGODB", "CLONE_THREAD", "THREAD_EXISTS"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Thread with id ${newThreadId} already exists`,
+        details: { newThreadId }
+      });
+    }
+    try {
+      const messagesCollection = await this.getCollection(TABLE_MESSAGES);
+      const filter = { thread_id: sourceThreadId };
+      if (options?.messageFilter?.startDate) {
+        filter.createdAt = filter.createdAt || {};
+        filter.createdAt.$gte = options.messageFilter.startDate instanceof Date ? options.messageFilter.startDate : new Date(options.messageFilter.startDate);
+      }
+      if (options?.messageFilter?.endDate) {
+        filter.createdAt = filter.createdAt || {};
+        filter.createdAt.$lte = options.messageFilter.endDate instanceof Date ? options.messageFilter.endDate : new Date(options.messageFilter.endDate);
+      }
+      if (options?.messageFilter?.messageIds && options.messageFilter.messageIds.length > 0) {
+        filter.id = { $in: options.messageFilter.messageIds };
+      }
+      let query = messagesCollection.find(filter).sort({ createdAt: 1 });
+      let sourceMessages;
+      if (options?.messageLimit && options.messageLimit > 0) {
+        const limited = await messagesCollection.find(filter).sort({ createdAt: -1 }).limit(options.messageLimit).toArray();
+        sourceMessages = limited.reverse();
+      } else {
+        sourceMessages = await query.toArray();
+      }
+      const now = /* @__PURE__ */ new Date();
+      const targetResourceId = resourceId || sourceThread.resourceId;
+      const lastMessageId = sourceMessages.length > 0 ? sourceMessages[sourceMessages.length - 1].id : void 0;
+      const cloneMetadata = {
+        sourceThreadId,
+        clonedAt: now,
+        ...lastMessageId && { lastMessageId }
+      };
+      const newThread = {
+        id: newThreadId,
+        resourceId: targetResourceId,
+        title: title || (sourceThread.title ? `Clone of ${sourceThread.title}` : ""),
+        metadata: {
+          ...metadata,
+          clone: cloneMetadata
+        },
+        createdAt: now,
+        updatedAt: now
+      };
+      const threadsCollection = await this.getCollection(TABLE_THREADS);
+      await threadsCollection.insertOne({ ...newThread });
+      const clonedMessages = [];
+      const messageIdMap = {};
+      if (sourceMessages.length > 0) {
+        const messageDocs = [];
+        for (const sourceMsg of sourceMessages) {
+          const newMessageId = randomUUID();
+          messageIdMap[sourceMsg.id] = newMessageId;
+          let parsedContent = sourceMsg.content;
+          if (typeof parsedContent === "string") {
+            try {
+              parsedContent = JSON.parse(parsedContent);
+            } catch {
+              parsedContent = { format: 2, parts: [{ type: "text", text: parsedContent }] };
+            }
+          }
+          const newDoc = {
+            id: newMessageId,
+            thread_id: newThreadId,
+            content: sourceMsg.content,
+            role: sourceMsg.role,
+            type: sourceMsg.type || "v2",
+            createdAt: sourceMsg.createdAt,
+            resourceId: targetResourceId
+          };
+          messageDocs.push(newDoc);
+          clonedMessages.push({
+            id: newMessageId,
+            threadId: newThreadId,
+            content: parsedContent,
+            role: sourceMsg.role,
+            type: sourceMsg.type || "v2",
+            createdAt: formatDateForMongoDB(sourceMsg.createdAt),
+            resourceId: targetResourceId
+          });
+        }
+        try {
+          await messagesCollection.insertMany(messageDocs);
+        } catch (msgError) {
+          try {
+            await messagesCollection.deleteMany({ thread_id: newThreadId });
+          } catch {
+          }
+          try {
+            await threadsCollection.deleteOne({ id: newThreadId });
+          } catch {
+          }
+          throw msgError;
+        }
+      }
+      return {
+        thread: newThread,
+        clonedMessages,
+        messageIdMap
+      };
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "CLONE_THREAD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { sourceThreadId, newThreadId }
+        },
+        error
+      );
+    }
+  }
   // ============================================
   // Observational Memory Methods
   // ============================================
@@ -3789,6 +3924,55 @@ var MemoryStorageMongoDB = class _MemoryStorageMongoDB extends MemoryStorage {
       );
     }
   }
+  async insertObservationalMemoryRecord(record) {
+    try {
+      const lookupKey = this.getOMKey(record.threadId, record.resourceId);
+      const collection = await this.getCollection(OM_TABLE);
+      await collection.insertOne({
+        id: record.id,
+        lookupKey,
+        scope: record.scope,
+        resourceId: record.resourceId,
+        threadId: record.threadId || null,
+        activeObservations: record.activeObservations || "",
+        activeObservationsPendingUpdate: null,
+        originType: record.originType || "initial",
+        config: record.config || null,
+        generationCount: record.generationCount || 0,
+        lastObservedAt: record.lastObservedAt || null,
+        lastReflectionAt: null,
+        pendingMessageTokens: record.pendingMessageTokens || 0,
+        totalTokensObserved: record.totalTokensObserved || 0,
+        observationTokenCount: record.observationTokenCount || 0,
+        observedMessageIds: record.observedMessageIds || null,
+        bufferedObservationChunks: record.bufferedObservationChunks || null,
+        bufferedReflection: record.bufferedReflection || null,
+        bufferedReflectionTokens: record.bufferedReflectionTokens ?? null,
+        bufferedReflectionInputTokens: record.bufferedReflectionInputTokens ?? null,
+        reflectedObservationLineCount: record.reflectedObservationLineCount ?? null,
+        isObserving: record.isObserving || false,
+        isReflecting: record.isReflecting || false,
+        isBufferingObservation: record.isBufferingObservation || false,
+        isBufferingReflection: record.isBufferingReflection || false,
+        lastBufferedAtTokens: record.lastBufferedAtTokens || 0,
+        lastBufferedAtTime: record.lastBufferedAtTime || null,
+        observedTimezone: record.observedTimezone || null,
+        metadata: record.metadata || null,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "INSERT_OBSERVATIONAL_MEMORY_RECORD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: record.id, threadId: record.threadId, resourceId: record.resourceId }
+        },
+        error
+      );
+    }
+  }
   async updateActiveObservations(input) {
     try {
       const now = /* @__PURE__ */ new Date();
@@ -7192,6 +7376,9 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends WorkflowsSt
       (idx) => _WorkflowsStorageMongoDB.MANAGED_COLLECTIONS.includes(idx.collection)
     );
   }
+  supportsConcurrentUpdates() {
+    return true;
+  }
   async getCollection(name) {
     return this.#connector.getCollection(name);
   }
@@ -7248,21 +7435,128 @@ var WorkflowsStorageMongoDB = class _WorkflowsStorageMongoDB extends WorkflowsSt
     const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
     await collection.deleteMany({});
   }
-  updateWorkflowResults({
-    // workflowName,
-    // runId,
-    // stepId,
-    // result,
-    // requestContext,
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
   }) {
-    throw new Error("Method not implemented.");
+    try {
+      const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
+      const now = /* @__PURE__ */ new Date();
+      const defaultSnapshot = {
+        context: {},
+        activePaths: [],
+        timestamp: Date.now(),
+        suspendedPaths: {},
+        activeStepsPath: {},
+        resumeLabels: {},
+        serializedStepGraph: [],
+        status: "pending",
+        value: {},
+        waitingPaths: {},
+        runId,
+        requestContext: {}
+      };
+      const updatedDoc = await collection.findOneAndUpdate(
+        { workflow_name: workflowName, run_id: runId },
+        [
+          {
+            $set: {
+              workflow_name: workflowName,
+              run_id: runId,
+              // If snapshot doesn't exist, use default; otherwise merge
+              snapshot: {
+                $mergeObjects: [
+                  // Start with default snapshot if document is new
+                  { $ifNull: ["$snapshot", defaultSnapshot] },
+                  // Merge the new context entry
+                  {
+                    context: {
+                      $mergeObjects: [{ $ifNull: [{ $ifNull: ["$snapshot.context", {}] }, {}] }, { [stepId]: result }]
+                    }
+                  },
+                  // Merge the new request context
+                  {
+                    requestContext: {
+                      $mergeObjects: [{ $ifNull: [{ $ifNull: ["$snapshot.requestContext", {}] }, {}] }, requestContext]
+                    }
+                  }
+                ]
+              },
+              updatedAt: now,
+              // Only set createdAt if it doesn't exist
+              createdAt: { $ifNull: ["$createdAt", now] }
+            }
+          }
+        ],
+        { upsert: true, returnDocument: "after" }
+      );
+      const snapshot = typeof updatedDoc?.snapshot === "string" ? JSON.parse(updatedDoc.snapshot) : updatedDoc?.snapshot;
+      return snapshot?.context || {};
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId,
+            stepId
+          }
+        },
+        error
+      );
+    }
   }
-  updateWorkflowState({
-    // workflowName,
-    // runId,
-    // opts,
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
   }) {
-    throw new Error("Method not implemented.");
+    try {
+      const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
+      const updatedDoc = await collection.findOneAndUpdate(
+        {
+          workflow_name: workflowName,
+          run_id: runId,
+          // Only update if snapshot exists and has context
+          "snapshot.context": { $exists: true }
+        },
+        [
+          {
+            $set: {
+              // Merge the new options into the existing snapshot
+              snapshot: {
+                $mergeObjects: ["$snapshot", opts]
+              },
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          }
+        ],
+        { returnDocument: "after" }
+      );
+      if (!updatedDoc) {
+        return void 0;
+      }
+      const snapshot = typeof updatedDoc.snapshot === "string" ? JSON.parse(updatedDoc.snapshot) : updatedDoc.snapshot;
+      return snapshot;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MONGODB", "UPDATE_WORKFLOW_STATE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error
+      );
+    }
   }
   async persistWorkflowSnapshot({
     workflowName,