@mastra/memory 1.5.2 → 1.6.0

package/dist/{chunk-HNPAIFCZ.js → chunk-A62BQK35.js}

@@ -1615,6 +1615,11 @@ See https://mastra.ai/docs/memory/observational-memory#models for model recommen
     const messageTokens = config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens;
     const observationTokens = config.reflection?.observationTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.observationTokens;
     const isSharedBudget = config.shareTokenBudget ?? false;
+    const isDefaultModelSelection = (model) => model === void 0 || model === "default";
+    const observationSelectedModel = config.model ?? config.observation?.model ?? config.reflection?.model;
+    const reflectionSelectedModel = config.model ?? config.reflection?.model ?? config.observation?.model;
+    const observationDefaultMaxOutputTokens = config.observation?.modelSettings?.maxOutputTokens ?? (isDefaultModelSelection(observationSelectedModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.maxOutputTokens : void 0);
+    const reflectionDefaultMaxOutputTokens = config.reflection?.modelSettings?.maxOutputTokens ?? (isDefaultModelSelection(reflectionSelectedModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.maxOutputTokens : void 0);
     const totalBudget = messageTokens + observationTokens;
     const userExplicitlyConfiguredAsync = config.observation?.bufferTokens !== void 0 || config.observation?.bufferActivation !== void 0 || config.reflection?.bufferActivation !== void 0;
     const asyncBufferingDisabled = config.observation?.bufferTokens === false || config.scope === "resource" && !userExplicitlyConfiguredAsync;
@@ -1646,7 +1651,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       shareTokenBudget: isSharedBudget,
       modelSettings: {
         temperature: config.observation?.modelSettings?.temperature ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.temperature,
-        maxOutputTokens: config.observation?.modelSettings?.maxOutputTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.maxOutputTokens
+        ...observationDefaultMaxOutputTokens !== void 0 ? { maxOutputTokens: observationDefaultMaxOutputTokens } : {}
       },
       providerOptions: config.observation?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.providerOptions,
       maxTokensPerBatch: config.observation?.maxTokensPerBatch ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.maxTokensPerBatch,
@@ -1667,7 +1672,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       shareTokenBudget: isSharedBudget,
       modelSettings: {
         temperature: config.reflection?.modelSettings?.temperature ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.temperature,
-        maxOutputTokens: config.reflection?.modelSettings?.maxOutputTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.maxOutputTokens
+        ...reflectionDefaultMaxOutputTokens !== void 0 ? { maxOutputTokens: reflectionDefaultMaxOutputTokens } : {}
       },
       providerOptions: config.reflection?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.providerOptions,
       bufferActivation: asyncBufferingDisabled ? void 0 : config?.reflection?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.bufferActivation,
@@ -2409,18 +2414,17 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     const agent = this.getObserverAgent();
     const prompt = buildObserverPrompt(existingObservations, messagesToObserve, options);
     const doGenerate = async () => {
-      const result2 = await this.withAbortCheck(
-        () => agent.generate(prompt, {
+      return this.withAbortCheck(async () => {
+        const streamResult = await agent.stream(prompt, {
           modelSettings: {
             ...this.observationConfig.modelSettings
           },
           providerOptions: this.observationConfig.providerOptions,
           ...abortSignal ? { abortSignal } : {},
           ...options?.requestContext ? { requestContext: options.requestContext } : {}
-        }),
-        abortSignal
-      );
-      return result2;
+        });
+        return streamResult.getFullOutput();
+      }, abortSignal);
     };
     let result = await doGenerate();
     let parsed = parseObserverOutput(result.text);
@@ -2467,17 +2471,17 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       this.observedMessageIds.add(msg.id);
     }
     const doGenerate = async () => {
-      return this.withAbortCheck(
-        () => agent.generate(prompt, {
+      return this.withAbortCheck(async () => {
+        const streamResult = await agent.stream(prompt, {
           modelSettings: {
             ...this.observationConfig.modelSettings
           },
           providerOptions: this.observationConfig.providerOptions,
           ...abortSignal ? { abortSignal } : {},
           ...requestContext ? { requestContext } : {}
-        }),
-        abortSignal
-      );
+        });
+        return streamResult.getFullOutput();
+      }, abortSignal);
     };
     let result = await doGenerate();
     let parsed = parseMultiThreadObserverOutput(result.text);
@@ -2535,8 +2539,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         `[OM:callReflector] ${isRetry ? `retry #${attemptNumber - 1}` : "first attempt"}: level=${currentLevel}, originalTokens=${originalTokens}, targetThreshold=${targetThreshold}, promptLen=${prompt.length}, skipContinuationHints=${skipContinuationHints}`
       );
       let chunkCount = 0;
-      const result = await this.withAbortCheck(
-        () => agent.generate(prompt, {
+      const result = await this.withAbortCheck(async () => {
+        const streamResult = await agent.stream(prompt, {
           modelSettings: {
             ...this.reflectionConfig.modelSettings
           },
@@ -2563,9 +2567,9 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
               omError(`[OM:callReflector] onError after ${chunkCount} chunks`, error);
             }
           } : {}
-        }),
-        abortSignal
-      );
+        });
+        return streamResult.getFullOutput();
+      }, abortSignal);
       omDebug(
         `[OM:callReflector] attempt #${attemptNumber} returned: textLen=${result.text?.length}, textPreview="${result.text?.slice(0, 120)}...", inputTokens=${result.usage?.inputTokens ?? result.totalUsage?.inputTokens}, outputTokens=${result.usage?.outputTokens ?? result.totalUsage?.outputTokens}`
       );
@@ -2904,19 +2908,17 @@ ${suggestedResponse}
           omDebug(
             `[OM:threshold] activation succeeded, obsTokens=${updatedRecord.observationTokenCount}, activeObsLen=${updatedRecord.activeObservations?.length}`
           );
-          if (activationResult.suggestedContinuation || activationResult.currentTask) {
-            const thread = await this.storage.getThreadById({ threadId });
-            if (thread) {
-              const newMetadata = setThreadOMMetadata(thread.metadata, {
-                suggestedResponse: activationResult.suggestedContinuation,
-                currentTask: activationResult.currentTask
-              });
-              await this.storage.updateThread({
-                id: threadId,
-                title: thread.title ?? "",
-                metadata: newMetadata
-              });
-            }
+          const thread = await this.storage.getThreadById({ threadId });
+          if (thread) {
+            const newMetadata = setThreadOMMetadata(thread.metadata, {
+              suggestedResponse: activationResult.suggestedContinuation,
+              currentTask: activationResult.currentTask
+            });
+            await this.storage.updateThread({
+              id: threadId,
+              title: thread.title ?? "",
+              metadata: newMetadata
+            });
           }
           await this.maybeAsyncReflect(
             updatedRecord,
@@ -3272,19 +3274,17 @@ ${suggestedResponse}
             _ObservationalMemory.lastBufferedBoundary.set(bufKey, 0);
             this.storage.setBufferingObservationFlag(record.id, false, 0).catch(() => {
             });
-            if (activationResult.suggestedContinuation || activationResult.currentTask) {
-              const thread = await this.storage.getThreadById({ threadId });
-              if (thread) {
-                const newMetadata = setThreadOMMetadata(thread.metadata, {
-                  suggestedResponse: activationResult.suggestedContinuation,
-                  currentTask: activationResult.currentTask
-                });
-                await this.storage.updateThread({
-                  id: threadId,
-                  title: thread.title ?? "",
-                  metadata: newMetadata
-                });
-              }
+            const thread = await this.storage.getThreadById({ threadId });
+            if (thread) {
+              const newMetadata = setThreadOMMetadata(thread.metadata, {
+                suggestedResponse: activationResult.suggestedContinuation,
+                currentTask: activationResult.currentTask
+              });
+              await this.storage.updateThread({
+                id: threadId,
+                title: thread.title ?? "",
+                metadata: newMetadata
+              });
             }
             await this.maybeReflect({
               record,
@@ -3503,24 +3503,30 @@ ${suggestedResponse}
     return messageList;
   }
   /**
-   * Save messages to storage, regenerating IDs for any messages that were
-   * previously saved with observation markers (sealed).
+   * Save messages to storage while preventing duplicate inserts for sealed messages.
    *
-   * After saving, tracks which messages now have observation markers
-   * so their IDs won't be reused in future save cycles.
+   * Sealed messages that do not yet contain a completed observation boundary are
+   * skipped because async buffering already persisted them.
    */
   async saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state) {
+    const filteredMessages = [];
     for (const msg of messagesToSave) {
       if (sealedIds.has(msg.id)) {
-        msg.id = crypto.randomUUID();
+        if (this.findLastCompletedObservationBoundary(msg) !== -1) {
+          filteredMessages.push(msg);
+        }
+      } else {
+        filteredMessages.push(msg);
       }
     }
-    await this.messageHistory.persistMessages({
-      messages: messagesToSave,
-      threadId,
-      resourceId
-    });
-    for (const msg of messagesToSave) {
+    if (filteredMessages.length > 0) {
+      await this.messageHistory.persistMessages({
+        messages: filteredMessages,
+        threadId,
+        resourceId
+      });
+    }
+    for (const msg of filteredMessages) {
       if (this.findLastCompletedObservationBoundary(msg) !== -1) {
         sealedIds.add(msg.id);
       }
@@ -3803,19 +3809,17 @@ ${result.observations}` : result.observations;
       const newMessageIds = messagesToObserve.map((m) => m.id);
       const existingIds = freshRecord?.observedMessageIds ?? record.observedMessageIds ?? [];
       const allObservedIds = [.../* @__PURE__ */ new Set([...Array.isArray(existingIds) ? existingIds : [], ...newMessageIds])];
-      if (result.suggestedContinuation || result.currentTask) {
-        const thread = await this.storage.getThreadById({ threadId });
-        if (thread) {
-          const newMetadata = setThreadOMMetadata(thread.metadata, {
-            suggestedResponse: result.suggestedContinuation,
-            currentTask: result.currentTask
-          });
-          await this.storage.updateThread({
-            id: threadId,
-            title: thread.title ?? "",
-            metadata: newMetadata
-          });
-        }
+      const thread = await this.storage.getThreadById({ threadId });
+      if (thread) {
+        const newMetadata = setThreadOMMetadata(thread.metadata, {
+          suggestedResponse: result.suggestedContinuation,
+          currentTask: result.currentTask
+        });
+        await this.storage.updateThread({
+          id: threadId,
+          title: thread.title ?? "",
+          metadata: newMetadata
+        });
       }
       await this.storage.updateActiveObservations({
         id: record.id,
@@ -4051,7 +4055,7 @@ ${result.observations}` : result.observations;
       messagesToBuffer,
       void 0,
       // No abort signal for background ops
-      { requestContext }
+      { skipContinuationHints: true, requestContext }
     );
     if (!result.observations) {
       omDebug(`[OM:doAsyncBufferedObservation] empty observations returned, skipping buffer storage`);
@@ -4669,8 +4673,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         if (thread) {
           const newMetadata = setThreadOMMetadata(thread.metadata, {
             lastObservedAt: threadLastObservedAt.toISOString(),
-            ...result.suggestedContinuation && { suggestedResponse: result.suggestedContinuation },
-            ...result.currentTask && { currentTask: result.currentTask }
+            suggestedResponse: result.suggestedContinuation,
+            currentTask: result.currentTask
           });
           await this.storage.updateThread({
             id: threadId,
@@ -5108,5 +5112,5 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
 };
 
 export { OBSERVATIONAL_MEMORY_DEFAULTS, OBSERVATION_CONTEXT_INSTRUCTIONS, OBSERVATION_CONTEXT_PROMPT, OBSERVATION_CONTINUATION_HINT, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, TokenCounter, buildObserverPrompt, buildObserverSystemPrompt, extractCurrentTask, formatMessagesForObserver, hasCurrentTaskSection, optimizeObservationsForContext, parseObserverOutput };
-//# sourceMappingURL=chunk-HNPAIFCZ.js.map
-//# sourceMappingURL=chunk-HNPAIFCZ.js.map
+//# sourceMappingURL=chunk-A62BQK35.js.map
+//# sourceMappingURL=chunk-A62BQK35.js.map