@mastra/memory 1.27.0 → 1.28.0-alpha.3

package/dist/{src-CxkQ-ICG.cjs → src-D8byb8Ge.cjs}

@@ -3734,7 +3734,7 @@ function trimStartOfStream() {
 	};
 }
 //#endregion
-//#region ../_vendored/ai_v5/dist/dist-BuEMdYEn.js
+//#region ../_vendored/ai_v5/dist/dist-nVfjvSbw.js
 var marker$1$4 = "vercel.ai.error";
 var symbol$1$3 = Symbol.for(marker$1$4);
 var _a$1$3;
@@ -4287,6 +4287,7 @@ async function cancelResponseBody$1(response) {
 var initialGlobalFetch$1 = globalThis.fetch;
 isNodeDefaultFetch$1(initialGlobalFetch$1);
 function isNodeDefaultFetch$1(fetch) {
+	if (typeof fetch !== "function") return false;
 	const source = Function.prototype.toString.call(fetch);
 	return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
 }
@@ -8622,7 +8623,7 @@ var object$1 = ({ schema: inputSchema }) => {
 	};
 };
 //#endregion
-//#region ../_vendored/ai_v6/dist/dist-BTWHzT8H.js
+//#region ../_vendored/ai_v6/dist/dist-Gd4EIxPM.js
 var marker$1 = "vercel.ai.error";
 var symbol$1$1 = Symbol.for(marker$1);
 var _a$1$1;
@@ -9196,6 +9197,7 @@ var DownloadError = class extends (_b$2 = AISDKError, _a$2 = symbol$2, _b$2) {
 var initialGlobalFetch = globalThis.fetch;
 isNodeDefaultFetch(initialGlobalFetch);
 function isNodeDefaultFetch(fetch) {
+	if (typeof fetch !== "function") return false;
 	const source = Function.prototype.toString.call(fetch);
 	return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
 }
@@ -10774,7 +10776,7 @@ function withoutTrailingSlash(url) {
 	return url == null ? void 0 : url.replace(/\/$/, "");
 }
 //#endregion
-//#region ../_vendored/ai_v6/dist/dist-3jq9sPhA.js
+//#region ../_vendored/ai_v6/dist/dist-BoeKQsDe.js
 function getContext() {
 	return { headers: {} };
 }
@@ -18926,6 +18928,12 @@ function extractListItemsOnly(content) {
 */
 const MAX_OBSERVATION_LINE_CHARS = 1e4;
 /**
+* Minimum trimmed line length considered by the duplicate-line degenerate
+* check. Short lines (blank lines, separators, terse bullets) legitimately
+* repeat; long identical lines almost never do.
+*/
+const MIN_DUPLICATE_LINE_CHARS = 24;
+/**
 * Truncate individual observation lines that exceed the maximum length.
 */
 function sanitizeObservationLines(observations) {
@@ -18963,6 +18971,18 @@ function detectDegenerateRepetition(text) {
 	if (totalWindows > 5 && duplicateWindows / totalWindows > .4) return true;
 	const lines = text.split("\n");
 	for (const line of lines) if (line.length > 5e4) return true;
+	const seenLines = /* @__PURE__ */ new Map();
+	let duplicateLines = 0;
+	let totalCountedLines = 0;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.length < MIN_DUPLICATE_LINE_CHARS) continue;
+		totalCountedLines++;
+		const count = (seenLines.get(trimmed) ?? 0) + 1;
+		seenLines.set(trimmed, count);
+		if (count > 1) duplicateLines++;
+	}
+	if (totalCountedLines >= 20 && duplicateLines / totalCountedLines > .5) return true;
 	return false;
 }
 /**
@@ -18997,12 +19017,26 @@ function describeDegenerateOutput(text, snippetChars = 400) {
 		topWindow = window;
 	}
 	let longestLine = 0;
-	for (const line of text.split("\n")) if (line.length > longestLine) longestLine = line.length;
+	const seenLines = /* @__PURE__ */ new Map();
+	let duplicateLines = 0;
+	let totalCountedLines = 0;
+	for (const line of text.split("\n")) {
+		if (line.length > longestLine) longestLine = line.length;
+		const trimmed = line.trim();
+		if (trimmed.length < MIN_DUPLICATE_LINE_CHARS) continue;
+		totalCountedLines++;
+		const count = (seenLines.get(trimmed) ?? 0) + 1;
+		seenLines.set(trimmed, count);
+		if (count > 1) duplicateLines++;
+	}
 	const duplicateRatio = totalWindows > 0 ? (duplicateWindows / totalWindows).toFixed(2) : "n/a";
+	const duplicateLineRatio = totalCountedLines > 0 ? (duplicateLines / totalCountedLines).toFixed(2) : "n/a";
 	const parts = [
 		`length=${text.length}`,
 		`sampledWindows=${totalWindows}`,
 		`duplicateRatio=${duplicateRatio}`,
+		`duplicateLineRatio=${duplicateLineRatio}`,
+		`countedLines=${totalCountedLines}`,
 		`longestLine=${longestLine}`,
 		`topWindowCount=${topCount}`
 	];
@@ -19276,7 +19310,19 @@ async function withOmTracingSpan({ phase, model, inputTokens, requestContext, ob
 	});
 	const childObservabilityContext = (0, _mastra_core_observability.createObservabilityContext)({ currentSpan: span });
 	if (!span) return callback(childObservabilityContext);
-	return span.executeInContext(() => callback(childObservabilityContext));
+	return span.executeInContext(async () => {
+		try {
+			const result = await callback(childObservabilityContext);
+			span.end();
+			return result;
+		} catch (error) {
+			span.error({
+				error,
+				endSpan: true
+			});
+			throw error;
+		}
+	});
 }
 //#endregion
 //#region src/processors/observational-memory/observer-runner.ts
@@ -24413,10 +24459,11 @@ ObservationStrategy.create = ((om, opts) => {
 });
 //#endregion
 //#region src/processors/observational-memory/observation-turn/load-memory-context.ts
-async function loadMemoryContextMessages({ memory, messageList, threadId, resourceId }) {
+async function loadMemoryContextMessages({ memory, messageList, threadId, resourceId, runState }) {
 	const ctx = await memory.getContext({
 		threadId,
-		resourceId
+		resourceId,
+		runState
 	});
 	for (const msg of ctx.messages) if (msg.role !== "system") messageList.add(msg, "memory");
 	return ctx;
@@ -24874,10 +24921,11 @@ var ObservationTurn = class {
 	* If a MemoryContextProvider is passed, loads historical messages and adds
 	* them to the MessageList. Without a provider, only fetches/caches the record.
 	*/
-	async start(memory) {
+	async start(memory, runState) {
 		if (this._started) throw new Error("Turn already started");
 		this._started = true;
 		this._record = await this.om.getOrCreateRecord(this.threadId, this.resourceId);
+		runState?.set(`observational-memory:record:${this.threadId}:${this.resourceId ?? ""}`, this._record);
 		this._generationCountAtStart = this._record.generationCount;
 		this.memory = memory;
 		if (memory) {
@@ -24885,7 +24933,8 @@ var ObservationTurn = class {
 				memory,
 				messageList: this.messageList,
 				threadId: this.threadId,
-				resourceId: this.resourceId
+				resourceId: this.resourceId,
+				runState
 			});
 			this._context = {
 				messages: ctx.messages,
@@ -25365,6 +25414,21 @@ var ReflectorRunner = class {
 	memory;
 	onReflectionCommitted;
 	mastra;
+	/**
+	* Per-lock-key observation-token count of the last unproductive synchronous
+	* reflection (failed, or committed while still over the reflection
+	* threshold). `call()` already runs the full bounded compression ladder for
+	* a given input, so re-running it against unchanged observations cannot
+	* succeed — threshold-triggered sync reflection is skipped while the count
+	* is unchanged and retried as soon as the input differs.
+	* Keyed by lock key (thread/resource), which is stable across generations —
+	* record ids change every time a generation is created.
+	*
+	* Lifecycle: an entry is deleted when a sync reflection finishes under
+	* threshold and replaced on each unproductive attempt. Entries are one
+	* number per active thread/resource key and live for the runner's lifetime.
+	*/
+	syncReflectionSuppression = /* @__PURE__ */ new Map();
 	constructor(opts) {
 		this.reflectionConfig = opts.reflectionConfig;
 		this.observationConfig = opts.observationConfig;
@@ -25447,8 +25511,8 @@ var ReflectorRunner = class {
 		};
 		let reflectedTokens = 0;
 		let attemptNumber = 0;
-		/** Observations from the previous attempt, used to detect a no-progress ladder. */
-		let previousObservations;
+		/** True when the latest attempt returned an empty block for non-empty input. */
+		let emptyOutput = false;
 		while (currentLevel <= maxLevel) {
 			attemptNumber++;
 			const isRetry = attemptNumber > 1;
@@ -25512,21 +25576,20 @@ var ReflectorRunner = class {
 			}
 			finalProviderMetadata = result.providerMetadata ?? finalProviderMetadata;
 			parsed = parseReflectorOutput(result.text, observations, activeExtractors);
+			emptyOutput = !parsed.degenerate && observations.trim().length > 0 && parsed.observations.trim().length === 0;
 			if (parsed.degenerate) {
 				omDebug(`[OM:callReflector] attempt #${attemptNumber}: degenerate repetition detected, treating as compression failure. ${describeDegenerateOutput(result.text, 2e3)}`);
 				reflectedTokens = originalTokens;
+			} else if (emptyOutput) {
+				omDebug(`[OM:callReflector] attempt #${attemptNumber}: empty observations block for non-empty input, treating as compression failure`);
+				reflectedTokens = originalTokens;
 			} else reflectedTokens = this.tokenCounter.countObservations(parsed.observations);
 			omDebug(`[OM:callReflector] attempt #${attemptNumber} parsed: reflectedTokens=${reflectedTokens}, targetThreshold=${targetThreshold}, compressionValid=${validateCompression(reflectedTokens, targetThreshold)}, parsedObsLen=${parsed.observations?.length}, degenerate=${parsed.degenerate ?? false}`);
-			if (!parsed.degenerate && (validateCompression(reflectedTokens, targetThreshold) || currentLevel >= maxLevel)) break;
-			if (parsed.degenerate && currentLevel >= maxLevel) {
-				omDebug(`[OM:callReflector] degenerate output persists at maxLevel=${maxLevel}, breaking`);
-				break;
-			}
-			if (!parsed.degenerate && previousObservations !== void 0 && parsed.observations === previousObservations) {
-				omDebug(`[OM:callReflector] attempt #${attemptNumber} returned output identical to the previous attempt; escalating cannot help, stopping the ladder`);
+			if (!parsed.degenerate && !emptyOutput && (validateCompression(reflectedTokens, targetThreshold) || currentLevel >= maxLevel)) break;
+			if ((parsed.degenerate || emptyOutput) && currentLevel >= maxLevel) {
+				omDebug(`[OM:callReflector] ${parsed.degenerate ? "degenerate" : "empty"} output persists at maxLevel=${maxLevel}, breaking`);
 				break;
 			}
-			previousObservations = parsed.observations;
 			if (streamContext?.writer) {
 				const failedMarker = createObservationFailedMarker({
 					cycleId: streamContext.cycleId,
@@ -25562,6 +25625,7 @@ var ReflectorRunner = class {
 			}
 			currentLevel = Math.min(currentLevel + 1, maxLevel);
 		}
+		if (observations.trim().length > 0 && parsed.observations.trim().length === 0) throw new Error(`Reflector produced empty output after ${attemptNumber} attempt(s)${parsed.degenerate ? " (degenerate repetition)" : ""} — refusing to commit an empty reflection over ${originalTokens} observation tokens`);
 		const structuredExtraction = await extractStructuredValues({
 			agent,
 			source: "reflector",
@@ -25610,52 +25674,51 @@ var ReflectorRunner = class {
 		this.storage.setBufferingReflectionFlag(record.id, true).catch((err) => {
 			omError("[OM] Failed to set buffering reflection flag", err);
 		});
-		reflectionHooks?.onReflectionStart?.();
-		const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext, priorExtractedValues, mainAgent, sendSignal).then((outcome) => {
+		const asyncOp = (async () => {
+			let outcome;
+			let reflectionError;
 			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",
-					startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					tokensAttempted: observationTokens,
-					error: error instanceof Error ? error.message : String(error),
-					recordId: record.id,
-					threadId: record.threadId ?? ""
-				});
-				writer.custom({
-					...failedMarker,
-					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);
-			try {
-				reflectionHooks?.onReflectionEnd?.({
-					usage: void 0,
-					error: error instanceof Error ? error : new Error(String(error))
+				await reflectionHooks?.onReflectionStart?.();
+				outcome = await this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext, priorExtractedValues, mainAgent, sendSignal);
+			} catch (error) {
+				reflectionError = error instanceof Error ? error : new Error(String(error));
+				if (writer) try {
+					const failedMarker = createBufferingFailedMarker({
+						cycleId: `reflect-buf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+						operationType: "reflection",
+						startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+						tokensAttempted: observationTokens,
+						error: reflectionError.message,
+						recordId: record.id,
+						threadId: record.threadId ?? ""
+					});
+					writer.custom({
+						...failedMarker,
+						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);
+				BufferingCoordinator.lastBufferedBoundary.delete(bufferKey);
+			} finally {
+				try {
+					await reflectionHooks?.onReflectionEnd?.({
+						usage: outcome?.usage,
+						error: reflectionError,
+						...outcome?.providerMetadata ? { providerMetadata: outcome.providerMetadata } : {}
+					});
+				} catch (hookError) {
+					omError("[OM] onReflectionEnd hook failed after async buffered reflection", hookError);
+				}
+				BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
+				unregisterOp(record.id, "bufferingReflection");
+				this.storage.setBufferingReflectionFlag(record.id, false).catch((err) => {
+					omError("[OM] Failed to clear buffering reflection flag", err);
 				});
-			} catch (hookError) {
-				omError("[OM] onReflectionEnd hook failed after async buffered reflection failure", hookError);
 			}
-			BufferingCoordinator.lastBufferedBoundary.delete(bufferKey);
-		}).finally(() => {
-			BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
-			unregisterOp(record.id, "bufferingReflection");
-			this.storage.setBufferingReflectionFlag(record.id, false).catch((err) => {
-				omError("[OM] Failed to clear buffering reflection flag", err);
-			});
-		});
+		})();
 		BufferingCoordinator.asyncBufferingOps.set(bufferKey, asyncOp);
 	}
 	/**
@@ -25916,6 +25979,13 @@ var ReflectorRunner = class {
 				return;
 			}
 		}
+		if (activationTriggeredBy === "threshold") {
+			const suppressedAtTokens = this.syncReflectionSuppression.get(lockKey);
+			if (suppressedAtTokens !== void 0 && observationTokens === suppressedAtTokens) {
+				omDebug(`[OM:reflect] skipping sync reflection — observations unchanged at ${observationTokens} tokens since the last unproductive attempt; retrying once they change`);
+				return;
+			}
+		}
 		await this.storage.setReflectingFlag(record.id, true);
 		registerOp(record.id, "reflecting");
 		const cycleId = crypto.randomUUID();
@@ -25956,8 +26026,15 @@ var ReflectorRunner = class {
 		let reflectionUsage;
 		let reflectionProviderMetadata;
 		let reflectionError;
-		reflectionHooks?.onReflectionStart?.();
+		let lifecycleError;
 		try {
+			try {
+				await reflectionHooks?.onReflectionStart?.();
+			} catch (error) {
+				lifecycleError = error;
+				reflectionError = error instanceof Error ? error : new Error(String(error));
+				throw error;
+			}
 			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);
 			reflectionUsage = reflectResult.usage;
@@ -25969,6 +26046,8 @@ var ReflectorRunner = class {
 				reflection: reflectResult.observations,
 				tokenCount: reflectionTokenCount
 			});
+			if (reflectionTokenCount >= reflectThreshold) this.syncReflectionSuppression.set(lockKey, reflectionTokenCount);
+			else this.syncReflectionSuppression.delete(lockKey);
 			await this.notifyReflectionCommitted({
 				parentThreadId: requestedThreadId ?? record.threadId ?? "",
 				resourceId: record.resourceId ?? "",
@@ -26027,18 +26106,28 @@ var ReflectorRunner = class {
 				await this.persistMarkerToStorage(failedMarker, threadId, record.resourceId ?? void 0);
 			}
 			reflectionError = error instanceof Error ? error : new Error(String(error));
-			if (abortSignal?.aborted) throw error;
+			if (lifecycleError !== void 0 || abortSignal?.aborted) throw error;
+			this.syncReflectionSuppression.set(lockKey, observationTokens);
 			omError("[OM] Reflection failed", error);
 		} finally {
-			await this.storage.setReflectingFlag(record.id, false);
 			try {
-				reflectionHooks?.onReflectionEnd?.({
+				await this.storage.setReflectingFlag(record.id, false);
+			} finally {
+				unregisterOp(record.id, "reflecting");
+			}
+			let endHookError;
+			try {
+				await reflectionHooks?.onReflectionEnd?.({
 					usage: reflectionUsage,
 					error: reflectionError,
 					...reflectionProviderMetadata ? { providerMetadata: reflectionProviderMetadata } : {}
 				});
-			} finally {
-				unregisterOp(record.id, "reflecting");
+			} catch (error) {
+				endHookError = error;
+			}
+			if (endHookError !== void 0) {
+				if (lifecycleError === void 0 && !abortSignal?.aborted) throw endHookError;
+				omDebug(`[OM:hooks] onReflectionEnd hook failed after cycle failure: ${endHookError instanceof Error ? endHookError.message : String(endHookError)}`);
 			}
 		}
 	}
@@ -26499,6 +26588,8 @@ var ObservationalMemory = class ObservationalMemory {
 	onIndexObservations;
 	/** Config-level lifecycle hooks fired for every observation/reflection cycle. */
 	hooks;
+	/** Execution policy for config-level hooks on manual and turn-synchronous cycles. */
+	hookExecution;
 	/** Observer agent runner — handles LLM calls for extracting observations. */
 	observer;
 	/** Reflector agent runner — handles LLM calls for compressing observations. */
@@ -26605,6 +26696,7 @@ var ObservationalMemory = class ObservationalMemory {
 		this.retrievalSearch = typeof config.retrieval === "object" && Boolean(config.retrieval.vector);
 		this.onIndexObservations = config.onIndexObservations;
 		this.hooks = config.hooks;
+		this.hookExecution = config.hookExecution ?? "non-blocking";
 		this.mastra = config.mastra;
 		this.memory = config.memory;
 		this.curationCadence = config.curationCadence;
@@ -28397,57 +28489,54 @@ ${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.
+	* Compose config-level hooks with optional per-call hooks and bind context to
+	* config-level callbacks. The configured policy applies unless a background
+	* path explicitly requests non-blocking invocation.
 	*
 	* @internal
 	*/
-	composeHooks(callHooks, context) {
+	composeHooks(callHooks, context, execution = "configured") {
 		const configHooks = this.hooks;
 		if (!configHooks) return callHooks;
 		if (!callHooks && !Object.keys(configHooks).length) return void 0;
-		const fireConfigHook = (name, arg) => {
+		const shouldAwaitConfig = execution === "configured" && this.hookExecution === "await";
+		const invokeConfigHook = async (name, arg) => {
 			const hook = configHooks[name];
 			if (!hook) return;
+			if (shouldAwaitConfig) {
+				await hook(arg);
+				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);
+				const result = hook(arg);
+				if (result && typeof result.then === "function") result.then(void 0, logHookFailure);
 			} catch (error) {
 				logHookFailure(error);
 			}
 		};
 		return {
-			onObservationStart: () => {
-				fireConfigHook("onObservationStart", context);
-				callHooks?.onObservationStart?.();
+			onObservationStart: async () => {
+				await invokeConfigHook("onObservationStart", context);
+				await callHooks?.onObservationStart?.();
 			},
-			onObservationEnd: (result) => {
-				fireConfigHook("onObservationEnd", {
+			onObservationEnd: async (result) => {
+				await invokeConfigHook("onObservationEnd", {
 					...context,
 					...result
 				});
-				callHooks?.onObservationEnd?.(result);
+				await callHooks?.onObservationEnd?.(result);
 			},
-			onReflectionStart: () => {
-				fireConfigHook("onReflectionStart", context);
-				callHooks?.onReflectionStart?.();
+			onReflectionStart: async () => {
+				await invokeConfigHook("onReflectionStart", context);
+				await callHooks?.onReflectionStart?.();
 			},
-			onReflectionEnd: (result) => {
-				fireConfigHook("onReflectionEnd", {
+			onReflectionEnd: async (result) => {
+				await invokeConfigHook("onReflectionEnd", {
 					...context,
 					...result
 				});
-				callHooks?.onReflectionEnd?.(result);
+				await callHooks?.onReflectionEnd?.(result);
 			}
 		};
 	}
@@ -28460,22 +28549,29 @@ ${formattedMessages}
 	* end hook reports `error` for failed cycles even though nothing throws.
 	*/
 	async runBufferedObservationCycle(context, run) {
-		const hooks = this.composeHooks(void 0, context);
-		hooks?.onObservationStart?.();
+		const hooks = this.composeHooks(void 0, context, "non-blocking");
 		let runResult;
 		let runError;
+		let lifecycleError;
 		try {
+			await hooks?.onObservationStart?.();
 			runResult = await run();
 			return runResult;
 		} catch (error) {
+			lifecycleError = 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 } : {}
-			});
+			try {
+				await hooks?.onObservationEnd?.({
+					usage: runResult?.usage,
+					error: runError ?? runResult?.error,
+					...runResult?.providerMetadata ? { providerMetadata: runResult.providerMetadata } : {}
+				});
+			} catch (endHookError) {
+				if (lifecycleError === void 0) throw endHookError;
+				omDebug(`[OM:hooks] async-buffer onObservationEnd hook failed after cycle failure: ${endHookError instanceof Error ? endHookError.message : String(endHookError)}`);
+			}
 		}
 	}
 	/**
@@ -28503,18 +28599,21 @@ ${formattedMessages}
 		let observed = false;
 		let observationUsage;
 		let observationProviderMetadata;
+		let observationError;
+		let lifecycleError;
+		let observationStarted = false;
 		let generationBefore = -1;
-		await this.withLock(lockKey, async () => {
-			const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
-			generationBefore = freshRecord.generationCount;
-			const unobservedMessages = messages ? this.getUnobservedMessages(messages, freshRecord) : await this.loadMessagesFromStorage(threadId, resourceId, freshRecord.lastObservedAt ? new Date(freshRecord.lastObservedAt) : void 0);
-			if (!this.meetsObservationThreshold({
-				record: freshRecord,
-				unobservedTokens: await this.tokenCounter.countMessagesAsync(unobservedMessages)
-			})) return;
-			hooks?.onObservationStart?.();
-			let observationError;
-			try {
+		try {
+			await this.withLock(lockKey, async () => {
+				const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
+				generationBefore = freshRecord.generationCount;
+				const unobservedMessages = messages ? this.getUnobservedMessages(messages, freshRecord) : await this.loadMessagesFromStorage(threadId, resourceId, freshRecord.lastObservedAt ? new Date(freshRecord.lastObservedAt) : void 0);
+				if (!this.meetsObservationThreshold({
+					record: freshRecord,
+					unobservedTokens: await this.tokenCounter.countMessagesAsync(unobservedMessages)
+				})) return;
+				observationStarted = true;
+				await hooks?.onObservationStart?.();
 				const result = await ObservationStrategy.create(this, {
 					record: freshRecord,
 					threadId,
@@ -28532,17 +28631,22 @@ ${formattedMessages}
 				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,
-					...observationProviderMetadata ? { providerMetadata: observationProviderMetadata } : {}
-				});
-			}
-		});
+			});
+		} catch (error) {
+			lifecycleError = error;
+			observationError = error instanceof Error ? error : new Error(String(error));
+		}
+		if (observationStarted) try {
+			await hooks?.onObservationEnd?.({
+				usage: observationUsage,
+				error: observationError,
+				...observationProviderMetadata ? { providerMetadata: observationProviderMetadata } : {}
+			});
+		} catch (endHookError) {
+			if (lifecycleError === void 0) throw endHookError;
+			omDebug(`[OM:hooks] onObservationEnd hook failed after cycle failure: ${endHookError instanceof Error ? endHookError.message : String(endHookError)}`);
+		}
+		if (lifecycleError !== void 0) throw lifecycleError;
 		const record = await this.getOrCreateRecord(threadId, resourceId);
 		const reflected = record.generationCount > generationBefore && generationBefore >= 0;
 		if (observed) this.maybeTriggerCadenceCuration(threadId, resourceId, record, requestContext).catch((error) => {
@@ -28616,11 +28720,18 @@ ${formattedMessages}
 			resourceId,
 			trigger: "manual"
 		});
-		hooks?.onReflectionStart?.();
 		let reflectionUsage;
 		let reflectionProviderMetadata;
 		let reflectionError;
+		let lifecycleError;
 		try {
+			try {
+				await hooks?.onReflectionStart?.();
+			} catch (error) {
+				lifecycleError = error;
+				reflectionError = error instanceof Error ? error : new Error(String(error));
+				throw error;
+			}
 			const thread = await this.storage.getThreadById({ threadId });
 			const previousOmMetadata = (0, _mastra_core_memory.getThreadOMMetadata)(thread?.metadata);
 			const priorExtractedValues = getPriorExtractedValues(previousOmMetadata, this.reflectionConfig.extractors);
@@ -28658,6 +28769,7 @@ ${formattedMessages}
 			};
 		} catch (error) {
 			reflectionError = error instanceof Error ? error : new Error(String(error));
+			if (lifecycleError !== void 0) throw error;
 			omError("[OM] reflect() failed", error);
 			return {
 				reflected: false,
@@ -28665,13 +28777,25 @@ ${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");
+			try {
+				await this.storage.setReflectingFlag(record.id, false);
+			} finally {
+				unregisterOp(record.id, "reflecting");
+			}
+			let endHookError;
+			try {
+				await hooks?.onReflectionEnd?.({
+					usage: reflectionUsage,
+					error: reflectionError,
+					...reflectionProviderMetadata ? { providerMetadata: reflectionProviderMetadata } : {}
+				});
+			} catch (error) {
+				endHookError = error;
+			}
+			if (endHookError !== void 0) {
+				if (lifecycleError === void 0) throw endHookError;
+				omDebug(`[OM:hooks] onReflectionEnd hook failed after cycle failure: ${endHookError instanceof Error ? endHookError.message : String(endHookError)}`);
+			}
 		}
 	}
 	/**
@@ -28967,7 +29091,9 @@ var ObservationalMemoryProcessor = class {
 			return messageList;
 		}
 		const { threadId, resourceId } = context;
-		const readOnly = (0, _mastra_core_memory.parseMemoryRequestContext)(requestContext)?.memoryConfig?.readOnly;
+		const memoryContext = (0, _mastra_core_memory.parseMemoryRequestContext)(requestContext);
+		const runState = memoryContext?.runState?.();
+		const readOnly = memoryContext?.memoryConfig?.readOnly;
 		const actorModelContext = model?.modelId ? {
 			provider: model.provider,
 			modelId: model.modelId,
@@ -28984,7 +29110,8 @@ var ObservationalMemoryProcessor = class {
 					memory: this.memory,
 					messageList,
 					threadId,
-					resourceId
+					resourceId,
+					runState
 				});
 				const systemMessages = ctx.omRecord ? await this.engine.buildContextSystemMessages({
 					threadId,
@@ -29025,7 +29152,7 @@ var ObservationalMemoryProcessor = class {
 				this.turn.sendStateSignal = args.sendStateSignal;
 				this.turn.agent = args.agent;
 				this.turn.requestContext = requestContext;
-				await this.turn.start(this.memory);
+				await this.turn.start(this.memory, runState);
 				if (stepNumber === 0 && this.temporalMarkers) await insertTemporalGapMarkers({
 					messageList,
 					sendSignal: args.sendSignal
@@ -30195,14 +30322,18 @@ ${workingMemory}`;
 		if (!this.threadConfig.workingMemory?.enabled) return null;
 		return extractWorkingMemoryContent(text)?.trim() ?? null;
 	}
-	async getWorkingMemory({ threadId, resourceId, memoryConfig }) {
+	async getWorkingMemory({ threadId, resourceId, memoryConfig, runState }) {
 		const config = this.getMergedThreadConfig(memoryConfig || {});
 		if (!config.workingMemory?.enabled) return null;
 		const scope = config.workingMemory.scope || "resource";
 		let workingMemoryData = null;
 		if (scope === "resource" && !resourceId) throw new Error("Memory error: Resource-scoped working memory is enabled but no resourceId was provided. Either provide a resourceId or explicitly set workingMemory.scope to 'thread'.");
-		if (scope === "resource" && resourceId) workingMemoryData = (await (await this.getMemoryStore()).getResourceById({ resourceId }))?.workingMemory || null;
-		else workingMemoryData = (await this.getThreadById({ threadId }))?.metadata?.workingMemory;
+		if (scope === "resource" && resourceId) {
+			const loadWorkingMemory = async () => {
+				return (await (await this.getMemoryStore()).getResourceById({ resourceId }))?.workingMemory || null;
+			};
+			workingMemoryData = runState ? await runState.load(`working-memory:resource:${resourceId}`, loadWorkingMemory) : await loadWorkingMemory();
+		} else workingMemoryData = (runState?.threadLoaded ? runState.thread : await this.getThreadById({ threadId }))?.metadata?.workingMemory;
 		if (!workingMemoryData) return null;
 		return workingMemoryData;
 	}
@@ -30234,16 +30365,18 @@ ${workingMemory}`;
 			content: (config.workingMemory.template || this.defaultWorkingMemoryTemplate).trim()
 		};
 	}
-	async getSystemMessage({ threadId, resourceId, memoryConfig }) {
+	async getSystemMessage({ threadId, resourceId, memoryConfig, runState }) {
 		const config = this.getMergedThreadConfig(memoryConfig);
 		this.assertWorkingMemoryStateSignalsCompatibility(config);
 		if (!config.workingMemory?.enabled) return null;
 		if (config.workingMemory?.useStateSignals) return null;
-		const workingMemoryTemplate = await this.getWorkingMemoryTemplate({ memoryConfig });
+		const loadTemplate = () => this.getWorkingMemoryTemplate({ memoryConfig });
+		const workingMemoryTemplate = runState ? await runState.load("working-memory:template", loadTemplate) : await loadTemplate();
 		const workingMemoryData = await this.getWorkingMemory({
 			threadId,
 			resourceId,
-			memoryConfig: config
+			memoryConfig: config,
+			runState
 		});
 		if (!workingMemoryTemplate) return null;
 		const workingMemoryConfig = config.workingMemory;
@@ -30276,7 +30409,7 @@ ${workingMemory}`;
 	* ```
 	*/
 	async getContext(opts) {
-		const { threadId, resourceId, memoryConfig } = opts;
+		const { threadId, resourceId, memoryConfig, runState } = opts;
 		const config = this.getMergedThreadConfig(memoryConfig);
 		const memoryStore = await this.getMemoryStore();
 		const systemParts = [];
@@ -30286,10 +30419,14 @@ ${workingMemory}`;
 		let otherThreadsContext;
 		const omEngine = await this.omEngine;
 		if (omEngine) {
-			omRecord = await omEngine.getRecord(threadId, resourceId);
+			const loadOmRecord = () => omEngine.getRecord(threadId, resourceId);
+			omRecord = runState ? await runState.load(`observational-memory:record:${threadId}:${resourceId ?? ""}`, loadOmRecord) : await loadOmRecord();
 			if (omRecord?.activeObservations) {
 				hasObservations = true;
-				if (omEngine.scope === "resource" && resourceId) otherThreadsContext = await omEngine.getOtherThreadsContext(resourceId, threadId);
+				if (omEngine.scope === "resource" && resourceId) {
+					const loadOtherThreadsContext = () => omEngine.getOtherThreadsContext(resourceId, threadId);
+					otherThreadsContext = runState ? await runState.load(`observational-memory:other-threads:${resourceId}:${threadId}:${omRecord.lastObservedAt ?? ""}`, loadOtherThreadsContext) : await loadOtherThreadsContext();
+				}
 				const obsSystemMessage = await omEngine.buildContextSystemMessage({
 					threadId,
 					resourceId,
@@ -30317,30 +30454,41 @@ ${workingMemory}`;
 		const workingMemoryMessage = await this.getSystemMessage({
 			threadId,
 			resourceId,
-			memoryConfig: config
+			memoryConfig: config,
+			runState
 		});
 		if (workingMemoryMessage) systemParts.push(workingMemoryMessage);
 		let messages;
 		if (omEngine && omRecord) {
 			const dateFilter = omRecord.lastObservedAt ? { dateRange: { start: new Date(new Date(omRecord.lastObservedAt).getTime() + 1) } } : void 0;
-			if (omEngine.scope === "resource" && resourceId) messages = (await memoryStore.listMessagesByResourceId({
-				resourceId,
-				orderBy: {
-					field: "createdAt",
-					direction: "ASC"
-				},
-				perPage: false,
-				filter: dateFilter
-			})).messages;
-			else messages = (await memoryStore.listMessages({
-				threadId,
-				orderBy: {
-					field: "createdAt",
-					direction: "ASC"
-				},
-				perPage: false,
-				filter: dateFilter
-			})).messages;
+			const boundary = omRecord.lastObservedAt ? new Date(omRecord.lastObservedAt).toISOString() : "";
+			if (omEngine.scope === "resource" && resourceId) {
+				const loadMessages = async () => {
+					return (await memoryStore.listMessagesByResourceId({
+						resourceId,
+						orderBy: {
+							field: "createdAt",
+							direction: "ASC"
+						},
+						perPage: false,
+						filter: dateFilter
+					})).messages;
+				};
+				messages = runState ? await runState.load(`observational-memory:messages:resource:${resourceId}:${boundary}`, loadMessages) : await loadMessages();
+			} else {
+				const loadMessages = async () => {
+					return (await memoryStore.listMessages({
+						threadId,
+						orderBy: {
+							field: "createdAt",
+							direction: "ASC"
+						},
+						perPage: false,
+						filter: dateFilter
+					})).messages;
+				};
+				messages = runState ? await runState.load(`observational-memory:messages:thread:${threadId}:${boundary}`, loadMessages) : await loadMessages();
+			}
 		} else {
 			const lastMessages = config.lastMessages;
 			if (lastMessages === false) messages = [];
@@ -30428,6 +30576,7 @@ ${workingMemory}`;
 				instruction: omConfig.observation.instruction,
 				threadTitle: omConfig.observation.threadTitle,
 				observeAttachments: omConfig.observation.observeAttachments,
+				continuationHints: omConfig.observation.continuationHints,
 				extract: omConfig.observation.extract
 			} : void 0,
 			reflection: omConfig.reflection ? {
@@ -30438,6 +30587,7 @@ ${workingMemory}`;
 				bufferActivation: omConfig.reflection.bufferActivation,
 				blockAfter: omConfig.reflection.blockAfter,
 				instruction: omConfig.reflection.instruction,
+				continuationHints: omConfig.reflection.continuationHints,
 				extract: omConfig.reflection.extract
 			} : void 0
 		});
@@ -31645,4 +31795,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-CxkQ-ICG.cjs.map
+//# sourceMappingURL=src-D8byb8Ge.cjs.map