@mastra/memory 1.13.1 → 1.14.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @mastra/memory
 
+## 1.14.0-alpha.1
+
+### Minor Changes
+
+- Added usage data to ObserveHooks callbacks and standalone reflect() return. ([#15047](https://github.com/mastra-ai/mastra/pull/15047))
+
+  **ObserveHooks:** `onObservationEnd` and `onReflectionEnd` now receive a result object containing token usage from the underlying LLM call. This enables reliable usage tracking across all observation and reflection paths (sync, async buffered, and resource-scoped).
+
+  **Standalone reflect():** `reflect()` now returns `{ reflected, record, usage? }` so callers can capture token usage without hooks.
+
+  **Examples**
+
+  ```ts
+  // Via hooks
+  await memory.observe({
+    threadId,
+    messages,
+    hooks: {
+      onObservationEnd: ({ usage }) => {
+        // usage: { inputTokens, outputTokens, totalTokens }
+      },
+      onReflectionEnd: ({ usage }) => {
+        // usage: { inputTokens, outputTokens, totalTokens }
+      },
+    },
+  });
+
+  // Via standalone reflect()
+  const { reflected, usage } = await memory.reflect(threadId, resourceId);
+  ```
+
+  Existing callbacks that accept no arguments continue to work without changes.
+
+### Patch Changes
+
+- Updated dependencies [[`fff91cf`](https://github.com/mastra-ai/mastra/commit/fff91cf914de0e731578aacebffdeebef82f0440)]:
+  - @mastra/core@1.23.0-alpha.4
+
+## 1.13.2-alpha.0
+
+### Patch Changes
+
+- Fixed observational memory buffering so sealed assistant chunks stay split instead of being merged back into one persisted message during long tool runs. ([#14995](https://github.com/mastra-ai/mastra/pull/14995))
+
+- Updated dependencies [[`ed425d7`](https://github.com/mastra-ai/mastra/commit/ed425d78e7c66cbda8209fee910856f98c6c6b82), [`ba6f7e9`](https://github.com/mastra-ai/mastra/commit/ba6f7e9086d8281393f2acae60fda61de3bff1f9), [`7eb2596`](https://github.com/mastra-ai/mastra/commit/7eb25960d607e07468c9a10c5437abd2deaf1e9a)]:
+  - @mastra/core@1.23.0-alpha.0
+
 ## 1.13.1
 
 ### Patch Changes

package/dist/{chunk-SWCWXIDJ.js → chunk-FQGF36BE.js}

@@ -945,7 +945,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() {
@@ -955,7 +955,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();
@@ -976,7 +976,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) {
@@ -995,7 +995,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;
@@ -2023,6 +2023,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,
@@ -2031,23 +2051,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}`);
       });
@@ -4189,7 +4193,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;
@@ -4199,7 +4203,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)}`,
@@ -4215,6 +4222,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);
@@ -4308,6 +4319,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.
@@ -4428,7 +4440,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           lockKey,
           writer,
           requestContext,
-          observabilityContext
+          observabilityContext,
+          reflectionHooks
         );
       }
     }
@@ -4462,7 +4475,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           lockKey,
           writer,
           requestContext,
-          observabilityContext
+          observabilityContext,
+          reflectionHooks
         );
         return;
       }
@@ -4501,6 +4515,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(
@@ -4514,6 +4530,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         requestContext,
         observabilityContext
       );
+      reflectionUsage = reflectResult.usage;
       const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
       await this.storage.createReflectionGeneration({
         currentRecord: record,
@@ -4558,13 +4575,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");
     }
   }
@@ -7909,6 +7927,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);
@@ -7925,8 +7944,9 @@ ${grouped}` : grouped;
         return;
       }
       hooks?.onObservationStart?.();
+      let observationError;
       try {
-        observed = await ObservationStrategy.create(this, {
+        const result = await ObservationStrategy.create(this, {
           record: freshRecord,
           threadId,
           resourceId,
@@ -7936,8 +7956,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);
@@ -7958,7 +7983,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");
@@ -7983,11 +8008,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");
@@ -8011,9 +8036,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
@@ -8559,5 +8584,5 @@ function getObservationsAsOf(activeObservations, asOf) {
 }
 
 export { ModelByInputTokens, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, ObservationalMemoryProcessor, TokenCounter, buildObserverPrompt, buildObserverSystemPrompt, combineObservationGroupRanges, deriveObservationGroupProvenance, extractCurrentTask, formatMessagesForObserver, formatToolResultForObserver, getObservationsAsOf, hasCurrentTaskSection, injectAnchorIds, optimizeObservationsForContext, parseAnchorId, parseObservationGroups, parseObserverOutput, reconcileObservationGroupsFromReflection, renderObservationGroupsForReflection, resolveToolResultValue, stripEphemeralAnchorIds, stripObservationGroups, truncateStringByTokens, wrapInObservationGroup };
-//# sourceMappingURL=chunk-SWCWXIDJ.js.map
-//# sourceMappingURL=chunk-SWCWXIDJ.js.map
+//# sourceMappingURL=chunk-FQGF36BE.js.map
+//# sourceMappingURL=chunk-FQGF36BE.js.map