@mastra/memory 1.21.3-alpha.0 → 1.21.3-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @mastra/memory
 
+## 1.21.3-alpha.1
+
+### Patch Changes
+
+- Expose `providerMetadata` on Observational Memory `ObserveHooks` results ([#18563](https://github.com/mastra-ai/mastra/pull/18563))
+
+  `onObservationEnd` and `onReflectionEnd` now receive the OM model call's `providerMetadata` alongside `usage`, so you can read per-call provider details — for example the AI Gateway's cost and generation id — straight from the hook instead of wrapping the observer/reflector models in a model-stream middleware:
+
+  ```ts
+  const hooks: ObserveHooks = {
+    onObservationEnd: ({ usage, providerMetadata }) => {
+      const gateway = providerMetadata?.gateway;
+      recordCost({ tokens: usage?.totalTokens, cost: gateway?.cost, generationId: gateway?.generationId });
+    },
+    onReflectionEnd: ({ usage, providerMetadata }) => {
+      recordCost({ tokens: usage?.totalTokens, cost: providerMetadata?.gateway?.cost });
+    },
+  };
+  ```
+
+  The field is additive and optional, and is omitted entirely when the provider emits no metadata, so existing hook consumers are unaffected. For batched observations and multi-attempt reflections it reflects the last batch/attempt that emitted provider metadata.
+
+- Updated dependencies [[`1917c53`](https://github.com/mastra-ai/mastra/commit/1917c53b19dac43926f29c496893b0686462dca4), [`58e287b`](https://github.com/mastra-ai/mastra/commit/58e287b1edaf978b13745a1795989cad3826e82b)]:
+  - @mastra/core@1.48.0-alpha.5
+
 ## 1.21.3-alpha.0
 
 ### Patch Changes

package/dist/{chunk-LEAP5DKB.cjs → chunk-FQLQMPJY.cjs}

@@ -1114,7 +1114,7 @@ var ObservationStrategy = class _ObservationStrategy {
           observabilityContext: this.opts.observabilityContext
         });
       }
-      return { observed: true, usage: output.usage };
+      return { observed: true, usage: output.usage, providerMetadata: output.providerMetadata };
     } catch (error) {
       await this.emitFailedMarkers(cycleId, error);
       if (!this.rethrowOnFailure) {
@@ -1707,6 +1707,7 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
   messagesByThread = /* @__PURE__ */ new Map();
   multiThreadResults = /* @__PURE__ */ new Map();
   totalBatchUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  lastBatchProviderMetadata;
   observationResults = [];
   priorMetadataByThread = /* @__PURE__ */ new Map();
   constructor(deps, opts) {
@@ -1888,10 +1889,14 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
         this.totalBatchUsage.outputTokens += batchResult.usage.outputTokens ?? 0;
         this.totalBatchUsage.totalTokens += batchResult.usage.totalTokens ?? 0;
       }
+      if (batchResult.providerMetadata) {
+        this.lastBatchProviderMetadata = batchResult.providerMetadata;
+      }
     }
     return {
       observations: "",
-      usage: this.totalBatchUsage.totalTokens > 0 ? this.totalBatchUsage : void 0
+      usage: this.totalBatchUsage.totalTokens > 0 ? this.totalBatchUsage : void 0,
+      providerMetadata: this.lastBatchProviderMetadata
     };
   }
   async process(_output, existingObservations) {
@@ -4275,7 +4280,8 @@ var ObserverRunner = class {
       currentTask: parsed.currentTask,
       suggestedContinuation: parsed.suggestedContinuation,
       threadTitle: parsed.threadTitle,
-      usage: usage ? { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens, totalTokens: usage.totalTokens } : void 0
+      usage: usage ? { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens, totalTokens: usage.totalTokens } : void 0,
+      providerMetadata: result.providerMetadata
     };
   }
   /**
@@ -4389,7 +4395,8 @@ var ObserverRunner = class {
     const usage = result.totalUsage ?? result.usage;
     return {
       results,
-      usage: usage ? { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens, totalTokens: usage.totalTokens } : void 0
+      usage: usage ? { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens, totalTokens: usage.totalTokens } : void 0,
+      providerMetadata: result.providerMetadata
     };
   }
 };
@@ -4769,6 +4776,7 @@ var ReflectorRunner = class {
     const internalRequestContext = withOmInternalThreadId(requestContext, agent.id);
     const targetThreshold = observationTokensThreshold ?? getMaxThreshold(this.reflectionConfig.observationTokens);
     let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    let finalProviderMetadata;
     const startLevel = compressionStartLevel ?? 0;
     let currentLevel = startLevel;
     const maxLevel = Math.min(MAX_COMPRESSION_LEVEL, startLevel + 3);
@@ -4846,6 +4854,7 @@ var ReflectorRunner = class {
         totalUsage.outputTokens += usage.outputTokens ?? 0;
         totalUsage.totalTokens += usage.totalTokens ?? 0;
       }
+      finalProviderMetadata = result.providerMetadata ?? finalProviderMetadata;
       parsed = parseReflectorOutput(result.text, observations);
       if (parsed.degenerate) {
         omDebug(
@@ -4899,7 +4908,8 @@ var ReflectorRunner = class {
     return {
       observations: parsed.observations,
       suggestedContinuation: parsed.suggestedContinuation,
-      usage: totalUsage.totalTokens > 0 ? totalUsage : void 0
+      usage: totalUsage.totalTokens > 0 ? totalUsage : void 0,
+      providerMetadata: finalProviderMetadata
     };
   }
   /**
@@ -4916,8 +4926,11 @@ var ReflectorRunner = class {
       omError("[OM] Failed to set buffering reflection flag", err);
     });
     reflectionHooks?.onReflectionStart?.();
-    const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext).then((usage) => {
-      reflectionHooks?.onReflectionEnd?.({ usage });
+    const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext).then((outcome) => {
+      reflectionHooks?.onReflectionEnd?.({
+        usage: outcome?.usage,
+        ...outcome?.providerMetadata ? { providerMetadata: outcome.providerMetadata } : {}
+      });
     }).catch(async (error) => {
       if (writer) {
         const failedMarker = createBufferingFailedMarker({
@@ -5036,7 +5049,7 @@ var ReflectorRunner = class {
       });
       await this.persistMarkerToStorage(endMarker, currentRecord.threadId ?? "", currentRecord.resourceId ?? void 0);
     }
-    return reflectResult.usage;
+    return { usage: reflectResult.usage, providerMetadata: reflectResult.providerMetadata };
   }
   /**
    * Try to activate buffered reflection when threshold is reached.
@@ -5308,6 +5321,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       resourceId: record.resourceId ?? void 0
     } : void 0;
     let reflectionUsage;
+    let reflectionProviderMetadata;
     let reflectionError;
     try {
       const compressionStartLevel = await this.getCompressionStartLevel(requestContext);
@@ -5323,6 +5337,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         observabilityContext
       );
       reflectionUsage = reflectResult.usage;
+      reflectionProviderMetadata = reflectResult.providerMetadata;
       const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
       await this.storage.createReflectionGeneration({
         currentRecord: record,
@@ -5376,7 +5391,11 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       omError("[OM] Reflection failed", error);
     } finally {
       await this.storage.setReflectingFlag(record.id, false);
-      reflectionHooks?.onReflectionEnd?.({ usage: reflectionUsage, error: reflectionError });
+      reflectionHooks?.onReflectionEnd?.({
+        usage: reflectionUsage,
+        error: reflectionError,
+        ...reflectionProviderMetadata ? { providerMetadata: reflectionProviderMetadata } : {}
+      });
       unregisterOp(record.id, "reflecting");
     }
   }
@@ -9431,6 +9450,7 @@ ${grouped}` : grouped;
     const reflectionHooks = hooks ? { onReflectionStart: hooks.onReflectionStart, onReflectionEnd: hooks.onReflectionEnd } : void 0;
     let observed = false;
     let observationUsage;
+    let observationProviderMetadata;
     let generationBefore = -1;
     await this.withLock(lockKey, async () => {
       const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
@@ -9461,11 +9481,16 @@ ${grouped}` : grouped;
         }).run();
         observed = result.observed;
         observationUsage = result.usage;
+        observationProviderMetadata = result.providerMetadata;
       } catch (error) {
         observationError = error instanceof Error ? error : new Error(String(error));
         throw error;
       } finally {
-        hooks?.onObservationEnd?.({ usage: observationUsage, error: observationError });
+        hooks?.onObservationEnd?.({
+          usage: observationUsage,
+          error: observationError,
+          ...observationProviderMetadata ? { providerMetadata: observationProviderMetadata } : {}
+        });
       }
     });
     const record = await this.getOrCreateRecord(threadId, resourceId);
@@ -10045,5 +10070,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.truncateStringByTokens = truncateStringByTokens;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-LEAP5DKB.cjs.map
-//# sourceMappingURL=chunk-LEAP5DKB.cjs.map
+//# sourceMappingURL=chunk-FQLQMPJY.cjs.map
+//# sourceMappingURL=chunk-FQLQMPJY.cjs.map