@mastra/memory 1.5.1 → 1.5.2

package/dist/{chunk-6XVTMLW4.cjs → chunk-PVFLHAZX.cjs}

@@ -986,7 +986,7 @@ var TokenCounter = class _TokenCounter {
                 `Unhandled tool-invocation state '${part.toolInvocation?.state}' in token counting for part type '${part.type}'`
               );
             }
-          } else if (typeof part.type === "string" && part.type.startsWith("data-")) ; else {
+          } else if (typeof part.type === "string" && part.type.startsWith("data-")) ; else if (part.type === "reasoning") ; else {
             tokenString += JSON.stringify(part);
           }
         }
@@ -1482,10 +1482,12 @@ var ObservationalMemory = class _ObservationalMemory {
     const maxOvershoot = retentionFloor * 0.95;
     const overshoot = bestOverTokens - targetMessageTokens;
     const remainingAfterOver = currentPendingTokens - bestOverTokens;
+    const remainingAfterUnder = currentPendingTokens - bestUnderTokens;
+    const minRemaining = Math.min(1e3, retentionFloor);
     let bestBoundaryMessageTokens;
-    if (bestOverBoundary > 0 && overshoot <= maxOvershoot && (remainingAfterOver >= 1e3 || retentionFloor === 0)) {
+    if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) {
       bestBoundaryMessageTokens = bestOverTokens;
-    } else if (bestUnderBoundary > 0) {
+    } else if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) {
       bestBoundaryMessageTokens = bestUnderTokens;
     } else if (bestOverBoundary > 0) {
       bestBoundaryMessageTokens = bestOverTokens;
@@ -1845,14 +1847,14 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
   }
   /**
    * Resolve blockAfter config value.
-   * Values between 1 and 2 (exclusive) are treated as multipliers of the threshold.
+   * Values in [1, 100) are treated as multipliers of the threshold.
    * e.g. blockAfter: 1.5 with messageTokens: 20_000 → 30_000
-   * Values >= 2 are treated as absolute token counts.
+   * Values >= 100 are treated as absolute token counts.
    * Defaults to 1.2 (120% of threshold) when async buffering is enabled but blockAfter is omitted.
    */
   resolveBlockAfter(blockAfter, messageTokens) {
     if (blockAfter === void 0) return void 0;
-    if (blockAfter >= 1 && blockAfter < 2) {
+    if (blockAfter >= 1 && blockAfter < 100) {
       const threshold = typeof messageTokens === "number" ? messageTokens : messageTokens.max;
       return Math.round(threshold * blockAfter);
     }
@@ -2986,7 +2988,7 @@ ${suggestedResponse}
    * Remove observed messages from message list after successful observation.
    * Accepts optional observedMessageIds for activation-based cleanup (when no markers are present).
    */
-  async cleanupAfterObservation(messageList, sealedIds, threadId, resourceId, state, observedMessageIds) {
+  async cleanupAfterObservation(messageList, sealedIds, threadId, resourceId, state, observedMessageIds, minRemaining) {
     const allMsgs = messageList.get.all.db();
     let markerIdx = -1;
     let markerMsg = null;
@@ -3030,13 +3032,25 @@ ${suggestedResponse}
     } else if (observedMessageIds && observedMessageIds.length > 0) {
       const observedSet = new Set(observedMessageIds);
       const idsToRemove = [];
+      const totalTokens = typeof minRemaining === "number" ? this.tokenCounter.countMessages(allMsgs) : void 0;
+      let removedTokens = 0;
+      let skipped = 0;
       for (const msg of allMsgs) {
         if (msg?.id && msg.id !== "om-continuation" && observedSet.has(msg.id)) {
+          if (typeof minRemaining === "number") {
+            const msgTokens = this.tokenCounter.countMessage(msg);
+            const remainingIfRemoved = (totalTokens ?? 0) - removedTokens - msgTokens;
+            if (remainingIfRemoved < minRemaining) {
+              skipped += 1;
+              continue;
+            }
+            removedTokens += msgTokens;
+          }
           idsToRemove.push(msg.id);
         }
       }
       omDebug(
-        `[OM:cleanupActivation] observedSet=${[...observedSet].map((id) => id.slice(0, 8)).join(",")}, matched=${idsToRemove.length}, idsToRemove=${idsToRemove.map((id) => id.slice(0, 8)).join(",")}`
+        `[OM:cleanupActivation] observedSet=${[...observedSet].map((id) => id.slice(0, 8)).join(",")}, matched=${idsToRemove.length}, skipped=${skipped}, idsToRemove=${idsToRemove.map((id) => id.slice(0, 8)).join(",")}`
       );
       if (idsToRemove.length > 0) {
         messageList.removeByIds(idsToRemove);
@@ -3185,8 +3199,12 @@ ${suggestedResponse}
   async processInputStep(args) {
     const { messageList, requestContext, stepNumber, state: _state, writer, abortSignal, abort } = args;
     const state = _state ?? {};
+    omDebug(
+      `[OM:processInputStep:ENTER] step=${stepNumber}, hasMastraMemory=${!!requestContext?.get("MastraMemory")}, hasMemoryInfo=${!!messageList?.serialize()?.memoryInfo?.threadId}`
+    );
     const context = this.getThreadContext(requestContext, messageList);
     if (!context) {
+      omDebug(`[OM:processInputStep:NO-CONTEXT] getThreadContext returned null \u2014 returning early`);
       return messageList;
     }
     const { threadId, resourceId } = context;
@@ -3325,7 +3343,7 @@ ${suggestedResponse}
         record
       );
       const { totalPendingTokens, threshold } = thresholds;
-      const bufferedChunkTokens = this.getBufferedChunks(record).reduce((sum, c) => sum + (c.tokenCount ?? 0), 0);
+      const bufferedChunkTokens = this.getBufferedChunks(record).reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
       const unbufferedPendingTokens = Math.max(0, totalPendingTokens - bufferedChunkTokens);
       const stateSealedIds = state.sealedIds ?? /* @__PURE__ */ new Set();
       const staticSealedIds = _ObservationalMemory.sealedMessageIds.get(threadId) ?? /* @__PURE__ */ new Set();
@@ -3333,7 +3351,7 @@ ${suggestedResponse}
       state.sealedIds = sealedIds;
       const lockKey = this.getLockKey(threadId, resourceId);
       if (this.isAsyncObservationEnabled() && totalPendingTokens < threshold) {
-        const shouldTrigger = this.shouldTriggerAsyncObservation(unbufferedPendingTokens, lockKey, record, threshold);
+        const shouldTrigger = this.shouldTriggerAsyncObservation(totalPendingTokens, lockKey, record, threshold);
         omDebug(
           `[OM:async-obs] belowThreshold: pending=${totalPendingTokens}, unbuffered=${unbufferedPendingTokens}, threshold=${threshold}, shouldTrigger=${shouldTrigger}, isBufferingObs=${record.isBufferingObservation}, lastBufferedAt=${record.lastBufferedAtTokens}`
         );
@@ -3349,7 +3367,7 @@ ${suggestedResponse}
           );
         }
       } else if (this.isAsyncObservationEnabled()) {
-        const shouldTrigger = this.shouldTriggerAsyncObservation(unbufferedPendingTokens, lockKey, record, threshold);
+        const shouldTrigger = this.shouldTriggerAsyncObservation(totalPendingTokens, lockKey, record, threshold);
         omDebug(
           `[OM:async-obs] atOrAboveThreshold: pending=${totalPendingTokens}, unbuffered=${unbufferedPendingTokens}, threshold=${threshold}, step=${stepNumber}, shouldTrigger=${shouldTrigger}`
         );
@@ -3383,10 +3401,19 @@ ${suggestedResponse}
         );
         if (observationSucceeded) {
           const observedIds = activatedMessageIds?.length ? activatedMessageIds : Array.isArray(updatedRecord.observedMessageIds) ? updatedRecord.observedMessageIds : void 0;
+          const minRemaining = typeof this.observationConfig.bufferActivation === "number" ? Math.min(1e3, this.resolveRetentionFloor(this.observationConfig.bufferActivation, threshold)) : void 0;
           omDebug(
-            `[OM:cleanup] observedIds=${observedIds?.length ?? "undefined"}, ids=${observedIds?.join(",") ?? "none"}, updatedRecord.observedMessageIds=${JSON.stringify(updatedRecord.observedMessageIds)}`
+            `[OM:cleanup] observedIds=${observedIds?.length ?? "undefined"}, ids=${observedIds?.join(",") ?? "none"}, updatedRecord.observedMessageIds=${JSON.stringify(updatedRecord.observedMessageIds)}, minRemaining=${minRemaining ?? "n/a"}`
+          );
+          await this.cleanupAfterObservation(
+            messageList,
+            sealedIds,
+            threadId,
+            resourceId,
+            state,
+            observedIds,
+            minRemaining
           );
-          await this.cleanupAfterObservation(messageList, sealedIds, threadId, resourceId, state, observedIds);
           if (activatedMessageIds?.length) {
             this.cleanupStaticMaps(threadId, resourceId, activatedMessageIds);
           }
@@ -3983,7 +4010,7 @@ ${result.observations}` : result.observations;
     }
     try {
       omDebug(
-        `[OM:bufferInput] cycleId=${cycleId}, msgCount=${messagesToBuffer.length}, msgTokens=${this.tokenCounter.countMessages(messagesToBuffer)}, ids=${messagesToBuffer.map((m) => `${m.id?.slice(0, 8)}@${m.createdAt ? new Date(m.createdAt).toISOString() : "none"}`).join(",")}`
+        `[OM:bufferInput] cycleId=${cycleId}, msgCount=${messagesToBuffer.length}, msgTokens=${tokensToBuffer}, ids=${messagesToBuffer.map((m) => `${m.id?.slice(0, 8)}@${m.createdAt ? new Date(m.createdAt).toISOString() : "none"}`).join(",")}`
       );
       await this.doAsyncBufferedObservation(
         freshRecord,
@@ -4150,6 +4177,22 @@ ${bufferedObservations}`;
     const bufferActivation = this.observationConfig.bufferActivation ?? 0.7;
     const activationRatio = this.resolveActivationRatio(bufferActivation, messageTokensThreshold);
     const forceMaxActivation = !!(this.observationConfig.blockAfter && effectivePendingTokens >= this.observationConfig.blockAfter);
+    const bufferTokens = this.observationConfig.bufferTokens ?? 0;
+    const retentionFloor = this.resolveRetentionFloor(bufferActivation, messageTokensThreshold);
+    const projectedMessageRemoval = this.calculateProjectedMessageRemoval(
+      freshChunks,
+      bufferActivation,
+      messageTokensThreshold,
+      effectivePendingTokens
+    );
+    const projectedRemaining = Math.max(0, effectivePendingTokens - projectedMessageRemoval);
+    const maxRemaining = retentionFloor + bufferTokens;
+    if (!forceMaxActivation && bufferTokens > 0 && projectedRemaining > maxRemaining) {
+      omDebug(
+        `[OM:tryActivate] skipping activation: projectedRemaining=${projectedRemaining} > maxRemaining=${maxRemaining} (retentionFloor=${retentionFloor}, bufferTokens=${bufferTokens})`
+      );
+      return { success: false };
+    }
     omDebug(
       `[OM:tryActivate] swapping: freshChunks=${freshChunks.length}, bufferActivation=${bufferActivation}, activationRatio=${activationRatio}, forceMax=${forceMaxActivation}, totalChunkTokens=${freshChunks.reduce((s, c) => s + (c.tokenCount ?? 0), 0)}`
     );
@@ -5085,5 +5128,5 @@ exports.formatMessagesForObserver = formatMessagesForObserver;
 exports.hasCurrentTaskSection = hasCurrentTaskSection;
 exports.optimizeObservationsForContext = optimizeObservationsForContext;
 exports.parseObserverOutput = parseObserverOutput;
-//# sourceMappingURL=chunk-6XVTMLW4.cjs.map
-//# sourceMappingURL=chunk-6XVTMLW4.cjs.map
+//# sourceMappingURL=chunk-PVFLHAZX.cjs.map
+//# sourceMappingURL=chunk-PVFLHAZX.cjs.map