@mastra/memory 1.24.0 → 1.25.0-alpha.0

package/dist/{src-VD6qMn-H.cjs → src-naeQog_T.cjs}

@@ -20815,7 +20815,10 @@ var ObservationStrategy = class ObservationStrategy {
 				await this.persistMarkerToStorage(failedMarkerForStorage, threadId, this.opts.resourceId).catch(() => {});
 				if (abortSignal?.aborted) throw error;
 				omError("[OM] Observation failed", error);
-				return { observed: false };
+				return {
+					observed: false,
+					error: error instanceof Error ? error : new Error(String(error))
+				};
 			}
 			omError("[OM] Observation failed", error);
 			throw error;
@@ -21865,7 +21868,12 @@ var ObservationStep = class {
 				currentModel: this.turn.actorModelContext,
 				requestContext: this.turn.requestContext,
 				observabilityContext: this.turn.observabilityContext,
-				lastActivityAt: getLastActivityFromMessages(messageList.get.all.db())
+				lastActivityAt: getLastActivityFromMessages(messageList.get.all.db()),
+				reflectionHooks: om.composeHooks(void 0, {
+					threadId,
+					resourceId,
+					trigger: "turn-sync"
+				})
 			});
 			await this.turn.refreshRecord();
 			if (this.turn.record.generationCount > preReflectGeneration) reflected = true;
@@ -22025,7 +22033,12 @@ var ObservationStep = class {
 					currentModel: this.turn.actorModelContext,
 					requestContext: this.turn.requestContext,
 					observabilityContext: this.turn.observabilityContext,
-					lastActivityAt: getLastActivityFromMessages(messageList.get.all.db())
+					lastActivityAt: getLastActivityFromMessages(messageList.get.all.db()),
+					reflectionHooks: om.composeHooks(void 0, {
+						threadId,
+						resourceId,
+						trigger: "turn-sync"
+					})
 				});
 				return {
 					succeeded: true,
@@ -22038,6 +22051,7 @@ var ObservationStep = class {
 			threadId,
 			resourceId,
 			messages: messageList.get.all.db(),
+			trigger: "turn-sync",
 			requestContext: this.turn.requestContext,
 			writer: this.turn.writer,
 			observabilityContext: this.turn.observabilityContext
@@ -22869,12 +22883,16 @@ var ReflectorRunner = class {
 		});
 		reflectionHooks?.onReflectionStart?.();
 		const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext, priorExtractedValues, mainAgent, sendSignal).then((outcome) => {
-			reflectionHooks?.onReflectionEnd?.({
-				usage: outcome?.usage,
-				...outcome?.providerMetadata ? { providerMetadata: outcome.providerMetadata } : {}
-			});
-		}).catch(async (error) => {
-			if (writer) {
+			try {
+				reflectionHooks?.onReflectionEnd?.({
+					usage: outcome?.usage,
+					...outcome?.providerMetadata ? { providerMetadata: outcome.providerMetadata } : {}
+				});
+			} catch (hookError) {
+				omError("[OM] onReflectionEnd hook failed after async buffered reflection", hookError);
+			}
+		}, async (error) => {
+			if (writer) try {
 				const failedMarker = createBufferingFailedMarker({
 					cycleId: `reflect-buf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
 					operationType: "reflection",
@@ -22889,12 +22907,18 @@ var ReflectorRunner = class {
 					transient: true
 				}).catch(() => {});
 				await this.persistMarkerToStorage(failedMarker, record.threadId ?? "", record.resourceId ?? void 0);
+			} catch (markerError) {
+				omError("[OM] Failed to persist buffering-failed marker after async buffered reflection failure", markerError);
 			}
 			omError("[OM] Async buffered reflection failed", error);
-			reflectionHooks?.onReflectionEnd?.({
-				usage: void 0,
-				error: error instanceof Error ? error : new Error(String(error))
-			});
+			try {
+				reflectionHooks?.onReflectionEnd?.({
+					usage: void 0,
+					error: error instanceof Error ? error : new Error(String(error))
+				});
+			} catch (hookError) {
+				omError("[OM] onReflectionEnd hook failed after async buffered reflection failure", hookError);
+			}
 			BufferingCoordinator.lastBufferedBoundary.delete(bufferKey);
 		}).finally(() => {
 			BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
@@ -23141,7 +23165,6 @@ var ReflectorRunner = class {
 				return;
 			}
 		}
-		reflectionHooks?.onReflectionStart?.();
 		await this.storage.setReflectingFlag(record.id, true);
 		registerOp(record.id, "reflecting");
 		const cycleId = crypto.randomUUID();
@@ -23182,6 +23205,7 @@ var ReflectorRunner = class {
 		let reflectionUsage;
 		let reflectionProviderMetadata;
 		let reflectionError;
+		reflectionHooks?.onReflectionStart?.();
 		try {
 			const compressionStartLevel = await this.getCompressionStartLevel(requestContext);
 			const reflectResult = await this.call(record.activeObservations, void 0, streamContext, reflectThreshold, abortSignal, void 0, compressionStartLevel, requestContext, priorExtractedValues, observabilityContext, void 0, mainAgent, sendSignal);
@@ -23245,12 +23269,15 @@ var ReflectorRunner = class {
 			omError("[OM] Reflection failed", error);
 		} finally {
 			await this.storage.setReflectingFlag(record.id, false);
-			reflectionHooks?.onReflectionEnd?.({
-				usage: reflectionUsage,
-				error: reflectionError,
-				...reflectionProviderMetadata ? { providerMetadata: reflectionProviderMetadata } : {}
-			});
-			unregisterOp(record.id, "reflecting");
+			try {
+				reflectionHooks?.onReflectionEnd?.({
+					usage: reflectionUsage,
+					error: reflectionError,
+					...reflectionProviderMetadata ? { providerMetadata: reflectionProviderMetadata } : {}
+				});
+			} finally {
+				unregisterOp(record.id, "reflecting");
+			}
 		}
 	}
 };
@@ -23703,6 +23730,8 @@ var ObservationalMemory = class ObservationalMemory {
 	reflectionConfig;
 	onDebugEvent;
 	onIndexObservations;
+	/** Config-level lifecycle hooks fired for every observation/reflection cycle. */
+	hooks;
 	/** Observer agent runner — handles LLM calls for extracting observations. */
 	observer;
 	/** Reflector agent runner — handles LLM calls for compressing observations. */
@@ -23763,6 +23792,7 @@ var ObservationalMemory = class ObservationalMemory {
 		this.scope = config.scope ?? "thread";
 		this.retrieval = Boolean(config.retrieval);
 		this.onIndexObservations = config.onIndexObservations;
+		this.hooks = config.hooks;
 		this.mastra = config.mastra;
 		this.memory = config.memory;
 		const resolveModel = (model, defaultModel) => model === "default" ? defaultModel : model;
@@ -24684,7 +24714,11 @@ ${formattedMessages}
 			transient: true
 		}).catch(() => {});
 		omDebug(`[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 ObservationStrategy.create(this, {
+		await this.runBufferedObservationCycle({
+			threadId,
+			resourceId: freshRecord.resourceId ?? void 0,
+			trigger: "async-buffer"
+		}, () => ObservationStrategy.create(this, {
 			record: freshRecord,
 			threadId,
 			resourceId: freshRecord.resourceId ?? void 0,
@@ -24694,7 +24728,7 @@ ${formattedMessages}
 			writer,
 			requestContext,
 			observabilityContext
-		}).run();
+		}).run());
 		const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
 		const cursor = new Date(maxTs.getTime() + 1);
 		BufferingCoordinator.lastBufferedAtTime.set(bufferKey, cursor);
@@ -25267,7 +25301,11 @@ ${formattedMessages}
 				...startMarker,
 				transient: true
 			}).catch(() => {});
-			await ObservationStrategy.create(this, {
+			await this.runBufferedObservationCycle({
+				threadId,
+				resourceId: record.resourceId ?? resourceId,
+				trigger: "async-buffer"
+			}, () => ObservationStrategy.create(this, {
 				record,
 				threadId,
 				resourceId: record.resourceId ?? void 0,
@@ -25280,7 +25318,7 @@ ${formattedMessages}
 				requestContext,
 				currentModel: opts.currentModel,
 				observabilityContext
-			}).run();
+			}).run());
 			if (isOmReproCaptureEnabled()) writeObserverExchangeReproCapture({
 				threadId,
 				resourceId: record.resourceId ?? void 0,
@@ -25490,6 +25528,88 @@ ${formattedMessages}
 		};
 	}
 	/**
+	* Compose the config-level hooks with optional per-call hooks into a single
+	* `ObserveHooks` object, binding call context onto the config-level
+	* callbacks. Config-level hooks are guarded so a throwing consumer hook can
+	* never fail an observation/reflection cycle; per-call hooks keep their
+	* existing payloads and propagation semantics. Returns undefined when
+	* neither is configured, so call sites stay zero-cost.
+	*
+	* Used internally by every pipeline path (manual observe/reflect,
+	* turn-engine sync observation, async buffering); public only so the
+	* observation turn engine can thread config-level reflection hooks into
+	* reflector calls.
+	*
+	* @internal
+	*/
+	composeHooks(callHooks, context) {
+		const configHooks = this.hooks;
+		if (!configHooks) return callHooks;
+		if (!callHooks && !Object.keys(configHooks).length) return void 0;
+		const fireConfigHook = (name, arg) => {
+			const hook = configHooks[name];
+			if (!hook) return;
+			const logHookFailure = (error) => omDebug(`[OM:hooks] config-level ${name} hook failed: ${error instanceof Error ? error.message : String(error)}`);
+			try {
+				const out = hook(arg);
+				if (out && typeof out.then === "function") out.then(void 0, logHookFailure);
+			} catch (error) {
+				logHookFailure(error);
+			}
+		};
+		return {
+			onObservationStart: () => {
+				fireConfigHook("onObservationStart", context);
+				callHooks?.onObservationStart?.();
+			},
+			onObservationEnd: (result) => {
+				fireConfigHook("onObservationEnd", {
+					...context,
+					...result
+				});
+				callHooks?.onObservationEnd?.(result);
+			},
+			onReflectionStart: () => {
+				fireConfigHook("onReflectionStart", context);
+				callHooks?.onReflectionStart?.();
+			},
+			onReflectionEnd: (result) => {
+				fireConfigHook("onReflectionEnd", {
+					...context,
+					...result
+				});
+				callHooks?.onReflectionEnd?.(result);
+			}
+		};
+	}
+	/**
+	* Run one buffered observation cycle, firing config-level hooks around it.
+	* Shared by both async-buffer lanes — buffer() and
+	* runAsyncBufferedObservation() — whose fire-and-forget callers never see
+	* the strategy result. The async-buffer strategy swallows failures
+	* (rethrowOnFailure=false) and surfaces them on the result instead, so the
+	* end hook reports `error` for failed cycles even though nothing throws.
+	*/
+	async runBufferedObservationCycle(context, run) {
+		const hooks = this.composeHooks(void 0, context);
+		hooks?.onObservationStart?.();
+		let runResult;
+		let runError;
+		try {
+			runResult = await run();
+			return runResult;
+		} catch (error) {
+			runError = error instanceof Error ? error : new Error(String(error));
+			throw error;
+		} finally {
+			hooks?.onObservationEnd?.({
+				usage: runResult?.usage,
+				error: runError ?? runResult?.error,
+				...runResult?.providerMetadata ? { providerMetadata: runResult.providerMetadata } : {}
+			});
+		}
+	}
+	/**
 	* Manually trigger observation.
 	*
 	* When `messages` is provided, those are used directly (filtered for unobserved)
@@ -25500,8 +25620,13 @@ ${formattedMessages}
 	* along with the updated record.
 	*/
 	async observe(opts) {
-		const { threadId, resourceId, messages, hooks, requestContext } = opts;
+		const { threadId, resourceId, messages, requestContext } = opts;
 		const lockKey = this.buffering.getLockKey(threadId, resourceId);
+		const hooks = this.composeHooks(opts.hooks, {
+			threadId,
+			resourceId,
+			trigger: opts.trigger ?? "manual"
+		});
 		const reflectionHooks = hooks ? {
 			onReflectionStart: hooks.onReflectionStart,
 			onReflectionEnd: hooks.onReflectionEnd
@@ -25574,6 +25699,15 @@ ${formattedMessages}
 		};
 		await this.storage.setReflectingFlag(record.id, true);
 		registerOp(record.id, "reflecting");
+		const hooks = this.composeHooks(void 0, {
+			threadId,
+			resourceId,
+			trigger: "manual"
+		});
+		hooks?.onReflectionStart?.();
+		let reflectionUsage;
+		let reflectionProviderMetadata;
+		let reflectionError;
 		try {
 			const thread = await this.storage.getThreadById({ threadId });
 			const previousOmMetadata = (0, _mastra_core_memory.getThreadOMMetadata)(thread?.metadata);
@@ -25603,12 +25737,16 @@ ${formattedMessages}
 					metadata: newMetadata
 				});
 			}
+			const updatedRecord = await this.getOrCreateRecord(threadId, resourceId);
+			reflectionUsage = reflectResult.usage;
+			reflectionProviderMetadata = reflectResult.providerMetadata;
 			return {
 				reflected: true,
-				record: await this.getOrCreateRecord(threadId, resourceId),
+				record: updatedRecord,
 				usage: reflectResult.usage
 			};
 		} catch (error) {
+			reflectionError = error instanceof Error ? error : new Error(String(error));
 			omError("[OM] reflect() failed", error);
 			return {
 				reflected: false,
@@ -25616,6 +25754,11 @@ ${formattedMessages}
 				usage: void 0
 			};
 		} finally {
+			hooks?.onReflectionEnd?.({
+				usage: reflectionUsage,
+				error: reflectionError,
+				...reflectionProviderMetadata ? { providerMetadata: reflectionProviderMetadata } : {}
+			});
 			await this.storage.setReflectingFlag(record.id, false);
 			unregisterOp(record.id, "reflecting");
 		}
@@ -27209,6 +27352,7 @@ ${workingMemory}`;
 			model: omConfig.model,
 			mastra: this._mastraInstance,
 			onIndexObservations,
+			hooks: omConfig.hooks,
 			observation: omConfig.observation ? {
 				model: omConfig.observation.model,
 				messageTokens: omConfig.observation.messageTokens,
@@ -28357,4 +28501,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-VD6qMn-H.cjs.map
+//# sourceMappingURL=src-naeQog_T.cjs.map