@mastra/server 1.56.0-alpha.2 → 1.56.0-alpha.4

package/dist/{dist-3OAfymQm.cjs → dist-D9hQEsv9.cjs}

@@ -5961,7 +5961,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-Ci_GvBVm.js
+//#region ../memory/dist/src-DoNjfXNm.js
 var __defProp$4 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -21098,13 +21098,19 @@ ${extractorInstructions}${priorLines.length > 0 ? `\n\n## Prior Extracted Values
 * auth, versions, routing hints, and resource id, but they must not present as
 * another run on the parent thread or core's cross-agent thread wait can block
 * on the parent run that is waiting for OM to complete.
+*
+* A fresh RequestContext clone is always returned so that memory-scoped writes
+* made by the internal agent run (e.g. the `MastraMemory` entry that agent.generate
+* sets from the observer's temporary `structured-observer` memory) cannot leak back
+* into the parent's RequestContext. Without this isolation the parent's OM turn later
+* reads the temporary observer's resourceId and injects a continuation message that
+* fails MessageList's resourceId validation.
 */
 function withOmInternalThreadId(requestContext, omAgentId) {
 	if (!requestContext) return void 0;
-	const parentThreadId = requestContext.get(_mastra_core_request_context.MASTRA_THREAD_ID_KEY);
-	if (typeof parentThreadId !== "string" || !parentThreadId) return requestContext;
 	const internalRequestContext = new _mastra_core_request_context.RequestContext(requestContext.entries());
-	internalRequestContext.set(_mastra_core_request_context.MASTRA_THREAD_ID_KEY, `${parentThreadId}-${omAgentId}`);
+	const parentThreadId = requestContext.get(_mastra_core_request_context.MASTRA_THREAD_ID_KEY);
+	if (typeof parentThreadId === "string" && parentThreadId) internalRequestContext.set(_mastra_core_request_context.MASTRA_THREAD_ID_KEY, `${parentThreadId}-${omAgentId}`);
 	return internalRequestContext;
 }
 const ANCHOR_ID_PATTERN = /^\[(O\d+(?:-N\d+)?)\]\s*/;
@@ -22920,7 +22926,7 @@ var ObserverRunner = class {
 			extractors: activeExtractors,
 			memory: temporaryMemory?.options,
 			priorExtractedValues: options?.priorExtractedValues,
-			requestContext: options?.requestContext,
+			requestContext: internalRequestContext,
 			observabilityContext: options?.observabilityContext,
 			abortSignal
 		});
@@ -26652,7 +26658,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;
@@ -27690,7 +27699,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;
@@ -27850,7 +27864,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,
@@ -27863,6 +27882,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
@@ -28646,7 +28666,7 @@ var ReflectorRunner = class {
 			extractors: activeExtractors,
 			memory: temporaryMemory?.options,
 			priorExtractedValues,
-			requestContext,
+			requestContext: internalRequestContext,
 			observabilityContext,
 			abortSignal
 		});
@@ -28688,12 +28708,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",
@@ -28708,12 +28732,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);
@@ -28960,7 +28990,6 @@ var ReflectorRunner = class {
 				return;
 			}
 		}
-		reflectionHooks?.onReflectionStart?.();
 		await this.storage.setReflectingFlag(record.id, true);
 		registerOp(record.id, "reflecting");
 		const cycleId = crypto.randomUUID();
@@ -29001,6 +29030,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);
@@ -29064,12 +29094,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");
+			}
 		}
 	}
 };
@@ -29518,6 +29551,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. */
@@ -29578,6 +29613,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;
@@ -30499,7 +30535,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,
@@ -30509,7 +30549,7 @@ ${formattedMessages}
 			writer,
 			requestContext,
 			observabilityContext
-		}).run();
+		}).run());
 		const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
 		const cursor = new Date(maxTs.getTime() + 1);
 		BufferingCoordinator.lastBufferedAtTime.set(bufferKey, cursor);
@@ -31082,7 +31122,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,
@@ -31095,7 +31139,7 @@ ${formattedMessages}
 				requestContext,
 				currentModel: opts.currentModel,
 				observabilityContext
-			}).run();
+			}).run());
 			if (isOmReproCaptureEnabled()) writeObserverExchangeReproCapture({
 				threadId,
 				resourceId: record.resourceId ?? void 0,
@@ -31305,6 +31349,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)
@@ -31315,8 +31441,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
@@ -31389,6 +31520,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);
@@ -31418,12 +31558,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,
@@ -31431,6 +31575,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");
 		}
@@ -32997,6 +33146,7 @@ ${workingMemory}`;
 			model: omConfig.model,
 			mastra: this._mastraInstance,
 			onIndexObservations,
+			hooks: omConfig.hooks,
 			observation: omConfig.observation ? {
 				model: omConfig.observation.model,
 				messageTokens: omConfig.observation.messageTokens,
@@ -44288,4 +44438,4 @@ const agentBuilderWorkflows = {
 //#endregion
 exports.agentBuilderWorkflows = agentBuilderWorkflows;
 
-//# sourceMappingURL=dist-3OAfymQm.cjs.map
+//# sourceMappingURL=dist-D9hQEsv9.cjs.map