@mastra/memory 1.13.1 → 1.14.0-alpha.1

package/dist/{chunk-HNVSYZRA.cjs → chunk-X7E3WPF2.cjs}

@@ -952,7 +952,7 @@ var ObservationStrategy = class _ObservationStrategy {
   static create;
   /**
    * Run the full observation lifecycle.
-   * @returns `true` if a full observation cycle completed; `false` if skipped (stale lock) or async-buffer failure was swallowed.
+   * @returns Result with `observed` flag and optional `usage` from the observer LLM call.
    * @throws On sync/resource-scoped observer failure after failed markers (same as pre–Option-A contract).
    */
   async run() {
@@ -962,7 +962,7 @@ var ObservationStrategy = class _ObservationStrategy {
       if (this.needsLock) {
         const fresh = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
         if (fresh?.lastObservedAt && record.lastObservedAt && fresh.lastObservedAt > record.lastObservedAt) {
-          return false;
+          return { observed: false };
         }
       }
       const { messages, existingObservations } = await this.prepare();
@@ -983,7 +983,7 @@ var ObservationStrategy = class _ObservationStrategy {
           observabilityContext: this.opts.observabilityContext
         });
       }
-      return true;
+      return { observed: true, usage: output.usage };
     } catch (error) {
       await this.emitFailedMarkers(cycleId, error);
       if (!this.rethrowOnFailure) {
@@ -1002,7 +1002,7 @@ var ObservationStrategy = class _ObservationStrategy {
         });
         if (abortSignal?.aborted) throw error;
         omError("[OM] Observation failed", error);
-        return false;
+        return { observed: false };
       }
       omError("[OM] Observation failed", error);
       throw error;
@@ -2030,6 +2030,26 @@ var ObservationStep = class {
     if (statusSnapshot.shouldBuffer && !hasIncompleteToolCalls) {
       const allMessages = messageList.get.all.db();
       const unobservedMessages = om.getUnobservedMessages(allMessages, statusSnapshot.record);
+      const candidates = om.getUnobservedMessages(unobservedMessages, statusSnapshot.record, {
+        excludeBuffered: true
+      });
+      if (candidates.length > 0) {
+        om.sealMessagesForBuffering(candidates);
+        try {
+          await this.turn.hooks?.onBufferChunkSealed?.();
+        } catch (error) {
+          omDebug(
+            `[OM:buffer] onBufferChunkSealed hook failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        if (this.turn.memory) {
+          await this.turn.memory.persistMessages(candidates);
+        }
+        messageList.removeByIds(candidates.map((msg) => msg.id));
+        for (const msg of candidates) {
+          messageList.add(msg, "memory");
+        }
+      }
       void om.buffer({
         threadId,
         resourceId,
@@ -2038,23 +2058,7 @@ var ObservationStep = class {
         record: statusSnapshot.record,
         writer: this.turn.writer,
         requestContext: this.turn.requestContext,
-        observabilityContext: this.turn.observabilityContext,
-        beforeBuffer: async (candidates) => {
-          if (candidates.length === 0) {
-            return;
-          }
-          om.sealMessagesForBuffering(candidates);
-          try {
-            await this.turn.hooks?.onBufferChunkSealed?.();
-          } catch (error) {
-            omDebug(
-              `[OM:buffer] onBufferChunkSealed hook failed: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-          if (this.turn.memory) {
-            await this.turn.memory.persistMessages(candidates);
-          }
-        }
+        observabilityContext: this.turn.observabilityContext
       }).catch((err) => {
         omDebug(`[OM:buffer] fire-and-forget buffer failed: ${err?.message}`);
       });
@@ -4196,7 +4200,7 @@ var ReflectorRunner = class {
   /**
    * Start an async buffered reflection in the background.
    */
-  startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext, observabilityContext) {
+  startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext, observabilityContext, reflectionHooks) {
     const bufferKey = this.buffering.getReflectionBufferKey(lockKey);
     if (this.buffering.isAsyncBufferingInProgress(bufferKey)) {
       return;
@@ -4206,7 +4210,10 @@ var ReflectorRunner = class {
     this.storage.setBufferingReflectionFlag(record.id, true).catch((err) => {
       omError("[OM] Failed to set buffering reflection flag", err);
     });
-    const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext).catch(async (error) => {
+    reflectionHooks?.onReflectionStart?.();
+    const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext).then((usage) => {
+      reflectionHooks?.onReflectionEnd?.({ usage });
+    }).catch(async (error) => {
       if (writer) {
         const failedMarker = createBufferingFailedMarker({
           cycleId: `reflect-buf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
@@ -4222,6 +4229,10 @@ var ReflectorRunner = class {
         await this.persistMarkerToStorage(failedMarker, record.threadId ?? "", record.resourceId ?? void 0);
       }
       omError("[OM] Async buffered reflection failed", error);
+      reflectionHooks?.onReflectionEnd?.({
+        usage: void 0,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
       BufferingCoordinator.lastBufferedBoundary.delete(bufferKey);
     }).finally(() => {
       BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
@@ -4315,6 +4326,7 @@ var ReflectorRunner = class {
       });
       await this.persistMarkerToStorage(endMarker, currentRecord.threadId ?? "", currentRecord.resourceId ?? void 0);
     }
+    return reflectResult.usage;
   }
   /**
    * Try to activate buffered reflection when threshold is reached.
@@ -4435,7 +4447,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           lockKey,
           writer,
           requestContext,
-          observabilityContext
+          observabilityContext,
+          reflectionHooks
         );
       }
     }
@@ -4469,7 +4482,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           lockKey,
           writer,
           requestContext,
-          observabilityContext
+          observabilityContext,
+          reflectionHooks
         );
         return;
       }
@@ -4508,6 +4522,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       recordId: record.id,
       threadId
     } : void 0;
+    let reflectionUsage;
+    let reflectionError;
     try {
       const compressionStartLevel = await this.getCompressionStartLevel(requestContext);
       const reflectResult = await this.call(
@@ -4521,6 +4537,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         requestContext,
         observabilityContext
       );
+      reflectionUsage = reflectResult.usage;
       const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
       await this.storage.createReflectionGeneration({
         currentRecord: record,
@@ -4565,13 +4582,14 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         await writer.custom(failedMarker).catch(() => {
         });
       }
+      reflectionError = error instanceof Error ? error : new Error(String(error));
       if (abortSignal?.aborted) {
         throw error;
       }
       omError("[OM] Reflection failed", error);
     } finally {
       await this.storage.setReflectingFlag(record.id, false);
-      reflectionHooks?.onReflectionEnd?.();
+      reflectionHooks?.onReflectionEnd?.({ usage: reflectionUsage, error: reflectionError });
       unregisterOp(record.id, "reflecting");
     }
   }
@@ -7916,6 +7934,7 @@ ${grouped}` : grouped;
     const lockKey = this.buffering.getLockKey(threadId, resourceId);
     const reflectionHooks = hooks ? { onReflectionStart: hooks.onReflectionStart, onReflectionEnd: hooks.onReflectionEnd } : void 0;
     let observed = false;
+    let observationUsage;
     let generationBefore = -1;
     await this.withLock(lockKey, async () => {
       const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
@@ -7932,8 +7951,9 @@ ${grouped}` : grouped;
         return;
       }
       hooks?.onObservationStart?.();
+      let observationError;
       try {
-        observed = await ObservationStrategy.create(this, {
+        const result = await ObservationStrategy.create(this, {
           record: freshRecord,
           threadId,
           resourceId,
@@ -7943,8 +7963,13 @@ ${grouped}` : grouped;
           writer: opts.writer,
           observabilityContext: opts.observabilityContext
         }).run();
+        observed = result.observed;
+        observationUsage = result.usage;
+      } catch (error) {
+        observationError = error instanceof Error ? error : new Error(String(error));
+        throw error;
       } finally {
-        hooks?.onObservationEnd?.();
+        hooks?.onObservationEnd?.({ usage: observationUsage, error: observationError });
       }
     });
     const record = await this.getOrCreateRecord(threadId, resourceId);
@@ -7965,7 +7990,7 @@ ${grouped}` : grouped;
   async reflect(threadId, resourceId, prompt, requestContext, observabilityContext) {
     const record = await this.getOrCreateRecord(threadId, resourceId);
     if (!record.activeObservations) {
-      return { reflected: false, record };
+      return { reflected: false, record, usage: void 0 };
     }
     await this.storage.setReflectingFlag(record.id, true);
     registerOp(record.id, "reflecting");
@@ -7990,11 +8015,11 @@ ${grouped}` : grouped;
         tokenCount: reflectionTokenCount
       });
       const updatedRecord = await this.getOrCreateRecord(threadId, resourceId);
-      return { reflected: true, record: updatedRecord };
+      return { reflected: true, record: updatedRecord, usage: reflectResult.usage };
     } catch (error) {
       omError("[OM] reflect() failed", error);
       const latestRecord = await this.getOrCreateRecord(threadId, resourceId);
-      return { reflected: false, record: latestRecord };
+      return { reflected: false, record: latestRecord, usage: void 0 };
     } finally {
       await this.storage.setReflectingFlag(record.id, false);
       unregisterOp(record.id, "reflecting");
@@ -8018,9 +8043,9 @@ ${grouped}` : grouped;
   /**
    * Get observation history (previous generations)
    */
-  async getHistory(threadId, resourceId, limit) {
+  async getHistory(threadId, resourceId, limit, options) {
     const ids = this.getStorageIds(threadId, resourceId);
-    return this.storage.getObservationalMemoryHistory(ids.threadId, ids.resourceId, limit);
+    return this.storage.getObservationalMemoryHistory(ids.threadId, ids.resourceId, limit, options);
   }
   /**
    * Clear all memory for a specific thread/resource
@@ -8591,5 +8616,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.truncateStringByTokens = truncateStringByTokens;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-HNVSYZRA.cjs.map
-//# sourceMappingURL=chunk-HNVSYZRA.cjs.map
+//# sourceMappingURL=chunk-X7E3WPF2.cjs.map
+//# sourceMappingURL=chunk-X7E3WPF2.cjs.map