@mastra/server 1.62.0-alpha.12 → 1.62.0-alpha.3

package/dist/{dist-L0EogwX_.js → dist-HzWDFjPH.js}

@@ -4693,7 +4693,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-BATJenuZ.js
+//#region ../memory/dist/src-BlQjkJzk.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -8927,7 +8927,6 @@ 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");
 }
@@ -13819,7 +13818,6 @@ var DownloadError$2 = class extends (_b$2$1 = AISDKError$3, _a$2$1 = symbol$2$1,
 var initialGlobalFetch$2 = globalThis.fetch;
 isNodeDefaultFetch$2(initialGlobalFetch$2);
 function isNodeDefaultFetch$2(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");
 }
@@ -23482,12 +23480,6 @@ 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) {
@@ -23525,18 +23517,6 @@ 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;
 }
 /**
@@ -23571,26 +23551,12 @@ function describeDegenerateOutput(text, snippetChars = 400) {
 		topWindow = window;
 	}
 	let longestLine = 0;
-	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++;
-	}
+	for (const line of text.split("\n")) if (line.length > longestLine) longestLine = line.length;
 	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}`
 	];
@@ -26969,149 +26935,6 @@ function createWorkingMemoryTool(config, options = {}) {
 		tool
 	};
 }
-/**
-* WorkingMemoryStateProcessor
-*
-* Experimental: delivers working memory to the model as a state signal instead
-* of folding it into the system message. Storage and the `setWorkingMemory`
-* tool are unchanged — this processor only changes the delivery path.
-*
-* Pattern matches `BrowserContextProcessor` in `@mastra/core/browser`:
-* - `stateId` namespaces the state lane on the thread.
-* - `cacheKey` is derived from the rendered payload so dedup is automatic.
-* - `contextWindow.hasSnapshot` re-injection ensures the model still sees the
-*   current snapshot after older messages drop out of the window.
-*
-* Delta emission (markdown mode only): when a prior snapshot exists in the
-* context window, the processor emits a unified-diff delta against that
-* snapshot's contents. Schema mode and the snapshot fallback always emit a
-* full snapshot.
-*
-* @example
-* ```ts
-* new Memory({
-*   options: {
-*     workingMemory: {
-*       enabled: true,
-*       template: '...',
-*       useStateSignals: true, // auto-attaches this processor
-*     },
-*   },
-* });
-* ```
-*/
-const WORKING_MEMORY_STATE_ID = "working-memory";
-const WORKING_MEMORY_STATE_PROCESSOR_ID = "working-memory-state";
-var WorkingMemoryStateProcessor = class {
-	memory;
-	memoryConfig;
-	id = WORKING_MEMORY_STATE_PROCESSOR_ID;
-	stateId = WORKING_MEMORY_STATE_ID;
-	constructor(memory, memoryConfig) {
-		this.memory = memory;
-		this.memoryConfig = memoryConfig;
-	}
-	async computeStateSignal(args) {
-		const template = await this.memory.getWorkingMemoryTemplate({ memoryConfig: this.memoryConfig });
-		if (!template) return;
-		const contents = (await this.memory.getWorkingMemory({
-			threadId: args.threadId,
-			resourceId: args.resourceId,
-			memoryConfig: this.memoryConfig
-		}))?.trim();
-		if (!contents) return;
-		const cacheKey = stableWorkingMemoryCacheKey({
-			format: template.format,
-			data: contents
-		});
-		const shouldMakeSnapshot = !args.contextWindow.hasSnapshot;
-		if (args.tracking?.currentCacheKey === cacheKey && !shouldMakeSnapshot) return;
-		const scope = this.memory.getMergedThreadConfig(this.memoryConfig).workingMemory?.scope ?? "resource";
-		const deltaCandidate = template.format === "markdown" && !shouldMakeSnapshot ? buildMarkdownDelta({
-			lastSnapshot: args.lastSnapshot,
-			deltasSinceSnapshot: args.deltasSinceSnapshot,
-			nextContents: contents
-		}) : void 0;
-		if (deltaCandidate) return {
-			id: WORKING_MEMORY_STATE_ID,
-			mode: "delta",
-			cacheKey,
-			tagName: "working-memory",
-			contents: deltaCandidate.contents,
-			delta: deltaCandidate.contents,
-			value: contents,
-			attributes: {
-				format: template.format,
-				scope,
-				patch: "unified-diff"
-			}
-		};
-		return {
-			id: WORKING_MEMORY_STATE_ID,
-			mode: "snapshot",
-			cacheKey,
-			tagName: "working-memory",
-			contents,
-			value: contents,
-			attributes: {
-				format: template.format,
-				scope
-			}
-		};
-	}
-};
-/**
-* Stable cache key for the rendered working memory payload. Returns a SHA-256
-* digest so dedup metadata stays compact regardless of payload size (working
-* memory blobs can grow arbitrarily long).
-*/
-function stableWorkingMemoryCacheKey(input) {
-	const hash = createHash("sha256");
-	hash.update(input.format);
-	hash.update("\0");
-	hash.update(input.data ?? "");
-	return `sha256:${hash.digest("hex")}`;
-}
-/**
-* Build a unified-diff delta against the most recently emitted state. Prefers
-* the latest delta's `value` (the post-edit full text) when available, falling
-* back to the snapshot's `value` and finally the snapshot's `contents`. This
-* keeps deltas incremental (B→C) instead of cumulative against a stale
-* snapshot (A→C), which matters when many small edits land between snapshots.
-*
-* Returns undefined when:
-* - there's no prior state to diff against
-* - the prior state isn't a plain string (multimodal signal)
-*
-* In either case the caller falls back to emitting a full snapshot.
-*/
-function buildMarkdownDelta(args) {
-	const { lastSnapshot, deltasSinceSnapshot, nextContents } = args;
-	const prior = pickStringValue(readSignalValue(deltasSinceSnapshot.at(-1))) ?? pickStringValue(readSignalValue(lastSnapshot)) ?? (typeof lastSnapshot?.contents === "string" ? lastSnapshot.contents : void 0);
-	if (!prior) return;
-	return { contents: renderHunksOnly(prior, nextContents) };
-}
-function pickStringValue(value) {
-	return typeof value === "string" ? value : void 0;
-}
-function readSignalValue(signal) {
-	return (signal?.metadata)?.value;
-}
-/**
-* Render a unified-diff-style patch body containing only `@@` hunks and their
-* lines — dropping the filename preamble (`Index:` / `===` / `---` / `+++`)
-* that `createPatch` emits and the `` trailer.
-* The preamble exists for tooling like `patch -p1` to know which file to
-* apply to; we only ever diff a single working-memory blob. The newline
-* trailer is semantically meaningless to the model and adds noise to the
-* state signal.
-*/
-function renderHunksOnly(prior, next) {
-	const { hunks } = structuredPatch("", "", prior, next, "", "", { context: 0 });
-	return hunks.map((hunk) => {
-		return [`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`, ...hunk.lines.filter((line) => !line.startsWith("\"))].join("\n");
-	}).join("\n");
-}
 const MINUTE = 6e4;
 const HOUR = 60 * MINUTE;
 const SHORT_TTL = 5 * MINUTE;
@@ -30053,21 +29876,6 @@ 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;
@@ -30150,8 +29958,8 @@ var ReflectorRunner = class {
 		};
 		let reflectedTokens = 0;
 		let attemptNumber = 0;
-		/** True when the latest attempt returned an empty block for non-empty input. */
-		let emptyOutput = false;
+		/** Observations from the previous attempt, used to detect a no-progress ladder. */
+		let previousObservations;
 		while (currentLevel <= maxLevel) {
 			attemptNumber++;
 			const isRetry = attemptNumber > 1;
@@ -30215,20 +30023,21 @@ 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 && !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`);
+			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`);
 				break;
 			}
+			previousObservations = parsed.observations;
 			if (streamContext?.writer) {
 				const failedMarker = createObservationFailedMarker({
 					cycleId: streamContext.cycleId,
@@ -30264,7 +30073,6 @@ 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",
@@ -30313,51 +30121,52 @@ var ReflectorRunner = class {
 		this.storage.setBufferingReflectionFlag(record.id, true).catch((err) => {
 			omError("[OM] Failed to set buffering reflection flag", err);
 		});
-		const asyncOp = (async () => {
-			let outcome;
-			let reflectionError;
+		reflectionHooks?.onReflectionStart?.();
+		const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext, priorExtractedValues, mainAgent, sendSignal).then((outcome) => {
 			try {
-				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);
+				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))
+				});
+			} 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);
 	}
 	/**
@@ -30618,13 +30427,6 @@ 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();
@@ -30665,15 +30467,8 @@ var ReflectorRunner = class {
 		let reflectionUsage;
 		let reflectionProviderMetadata;
 		let reflectionError;
-		let lifecycleError;
+		reflectionHooks?.onReflectionStart?.();
 		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;
@@ -30685,8 +30480,6 @@ 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 ?? "",
@@ -30745,28 +30538,18 @@ var ReflectorRunner = class {
 				await this.persistMarkerToStorage(failedMarker, threadId, record.resourceId ?? void 0);
 			}
 			reflectionError = error instanceof Error ? error : new Error(String(error));
-			if (lifecycleError !== void 0 || abortSignal?.aborted) throw error;
-			this.syncReflectionSuppression.set(lockKey, observationTokens);
+			if (abortSignal?.aborted) throw error;
 			omError("[OM] Reflection failed", error);
 		} finally {
+			await this.storage.setReflectingFlag(record.id, false);
 			try {
-				await this.storage.setReflectingFlag(record.id, false);
-			} finally {
-				unregisterOp(record.id, "reflecting");
-			}
-			let endHookError;
-			try {
-				await reflectionHooks?.onReflectionEnd?.({
+				reflectionHooks?.onReflectionEnd?.({
 					usage: reflectionUsage,
 					error: reflectionError,
 					...reflectionProviderMetadata ? { providerMetadata: reflectionProviderMetadata } : {}
 				});
-			} 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)}`);
+			} finally {
+				unregisterOp(record.id, "reflecting");
 			}
 		}
 	}
@@ -31089,24 +30872,10 @@ function getLatestStepParts(parts) {
 	return parts;
 }
 /**
-* Returns true for persisted Working Memory state signals (`role: 'signal'`,
-* `signal.type: 'state'`, `state.id: 'working-memory'`). OM must not observe these:
-* they mirror memory OM itself manages, and re-observing them creates a self-feedback
-* loop that can overwrite stored working memory (#21961). Only the working-memory lane
-* is filtered — other state lanes are outside OM's write path, so re-observing them
-* cannot corrupt OM-managed state; excluding them broadly is a separate decision.
+* Returns true when a message contains at least one part with visible user/assistant
+* content (text, tool-invocation, reasoning, image, file).  Messages that only carry
+* internal `data-*` parts (buffering markers, observation markers, etc.) return false.
 */
-function isWorkingMemoryStateSignal(message) {
-	if (message.role !== "signal") return false;
-	const signal = message.content.metadata?.signal;
-	if (!signal || typeof signal !== "object" || Array.isArray(signal)) return false;
-	const signalRecord = signal;
-	if ((signalRecord.type ?? message.type) !== "state") return false;
-	const metadata = signalRecord.metadata;
-	if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return false;
-	const state = metadata.state;
-	return !!state && typeof state === "object" && !Array.isArray(state) && state.id === "working-memory";
-}
 function messageHasVisibleContent(msg) {
 	const content = msg.content;
 	if (content?.parts && Array.isArray(content.parts)) return content.parts.some((p) => {
@@ -31237,8 +31006,6 @@ 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. */
@@ -31345,7 +31112,6 @@ 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;
@@ -31877,7 +31643,7 @@ var ObservationalMemory = class ObservationalMemory {
 		}
 		const result = [];
 		for (const msg of allMessages) {
-			if (msg.role === "system" || isWorkingMemoryStateSignal(msg)) continue;
+			if (msg.role === "system") continue;
 			if (observedMessageIds?.has(msg.id)) continue;
 			const endMarkerIndex = findLastCompletedObservationBoundary(msg);
 			if (this.hasInProgressObservation(msg)) result.push(msg);
@@ -32099,7 +31865,7 @@ var ObservationalMemory = class ObservationalMemory {
 			},
 			filter: startDate ? { dateRange: { start: startDate } } : void 0
 		});
-		return result.messages.filter((msg) => msg.role !== "system" && !isWorkingMemoryStateSignal(msg));
+		return result.messages.filter((msg) => msg.role !== "system");
 	}
 	/**
 	* Format unobserved messages from other threads as <unobserved-context> blocks.
@@ -32558,7 +32324,7 @@ ${formattedMessages}
 					direction: "ASC"
 				},
 				filter: startDate ? { dateRange: { start: startDate } } : void 0
-			})).messages.filter((message) => !this.observedMessageIds.has(message.id) && !isWorkingMemoryStateSignal(message));
+			})).messages.filter((m) => !this.observedMessageIds.has(m.id));
 			if (filtered.length > 0) messagesByThread.set(thread.id, filtered);
 		}
 		if (messagesByThread.size === 0) return void 0;
@@ -33138,54 +32904,57 @@ ${formattedMessages}
 		};
 	}
 	/**
-	* 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.
+	* 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, execution = "configured") {
+	composeHooks(callHooks, context) {
 		const configHooks = this.hooks;
 		if (!configHooks) return callHooks;
 		if (!callHooks && !Object.keys(configHooks).length) return void 0;
-		const shouldAwaitConfig = execution === "configured" && this.hookExecution === "await";
-		const invokeConfigHook = async (name, arg) => {
+		const fireConfigHook = (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 result = hook(arg);
-				if (result && typeof result.then === "function") result.then(void 0, logHookFailure);
+				const out = hook(arg);
+				if (out && typeof out.then === "function") out.then(void 0, logHookFailure);
 			} catch (error) {
 				logHookFailure(error);
 			}
 		};
 		return {
-			onObservationStart: async () => {
-				await invokeConfigHook("onObservationStart", context);
-				await callHooks?.onObservationStart?.();
+			onObservationStart: () => {
+				fireConfigHook("onObservationStart", context);
+				callHooks?.onObservationStart?.();
 			},
-			onObservationEnd: async (result) => {
-				await invokeConfigHook("onObservationEnd", {
+			onObservationEnd: (result) => {
+				fireConfigHook("onObservationEnd", {
 					...context,
 					...result
 				});
-				await callHooks?.onObservationEnd?.(result);
+				callHooks?.onObservationEnd?.(result);
 			},
-			onReflectionStart: async () => {
-				await invokeConfigHook("onReflectionStart", context);
-				await callHooks?.onReflectionStart?.();
+			onReflectionStart: () => {
+				fireConfigHook("onReflectionStart", context);
+				callHooks?.onReflectionStart?.();
 			},
-			onReflectionEnd: async (result) => {
-				await invokeConfigHook("onReflectionEnd", {
+			onReflectionEnd: (result) => {
+				fireConfigHook("onReflectionEnd", {
 					...context,
 					...result
 				});
-				await callHooks?.onReflectionEnd?.(result);
+				callHooks?.onReflectionEnd?.(result);
 			}
 		};
 	}
@@ -33198,29 +32967,22 @@ ${formattedMessages}
 	* end hook reports `error` for failed cycles even though nothing throws.
 	*/
 	async runBufferedObservationCycle(context, run) {
-		const hooks = this.composeHooks(void 0, context, "non-blocking");
+		const hooks = this.composeHooks(void 0, context);
+		hooks?.onObservationStart?.();
 		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 {
-			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)}`);
-			}
+			hooks?.onObservationEnd?.({
+				usage: runResult?.usage,
+				error: runError ?? runResult?.error,
+				...runResult?.providerMetadata ? { providerMetadata: runResult.providerMetadata } : {}
+			});
 		}
 	}
 	/**
@@ -33248,21 +33010,18 @@ ${formattedMessages}
 		let observed = false;
 		let observationUsage;
 		let observationProviderMetadata;
-		let observationError;
-		let lifecycleError;
-		let observationStarted = false;
 		let generationBefore = -1;
-		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?.();
+		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 {
 				const result = await ObservationStrategy.create(this, {
 					record: freshRecord,
 					threadId,
@@ -33280,22 +33039,17 @@ ${formattedMessages}
 				observed = result.observed;
 				observationUsage = result.usage;
 				observationProviderMetadata = result.providerMetadata;
-			});
-		} 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;
+			} catch (error) {
+				observationError = error instanceof Error ? error : new Error(String(error));
+				throw error;
+			} finally {
+				hooks?.onObservationEnd?.({
+					usage: observationUsage,
+					error: observationError,
+					...observationProviderMetadata ? { providerMetadata: observationProviderMetadata } : {}
+				});
+			}
+		});
 		const record = await this.getOrCreateRecord(threadId, resourceId);
 		const reflected = record.generationCount > generationBefore && generationBefore >= 0;
 		if (observed) this.maybeTriggerCadenceCuration(threadId, resourceId, record, requestContext).catch((error) => {
@@ -33369,18 +33123,11 @@ ${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 = getThreadOMMetadata(thread?.metadata);
 			const priorExtractedValues = getPriorExtractedValues(previousOmMetadata, this.reflectionConfig.extractors);
@@ -33418,7 +33165,6 @@ ${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,
@@ -33426,25 +33172,13 @@ ${formattedMessages}
 				usage: void 0
 			};
 		} finally {
-			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)}`);
-			}
+			hooks?.onReflectionEnd?.({
+				usage: reflectionUsage,
+				error: reflectionError,
+				...reflectionProviderMetadata ? { providerMetadata: reflectionProviderMetadata } : {}
+			});
+			await this.storage.setReflectingFlag(record.id, false);
+			unregisterOp(record.id, "reflecting");
 		}
 	}
 	/**
@@ -33975,6 +33709,149 @@ var observational_memory_exports = /* @__PURE__ */ __exportAll({
 	summarizeConversation: () => summarizeConversation,
 	wrapInObservationGroup: () => wrapInObservationGroup
 });
+/**
+* WorkingMemoryStateProcessor
+*
+* Experimental: delivers working memory to the model as a state signal instead
+* of folding it into the system message. Storage and the `setWorkingMemory`
+* tool are unchanged — this processor only changes the delivery path.
+*
+* Pattern matches `BrowserContextProcessor` in `@mastra/core/browser`:
+* - `stateId` namespaces the state lane on the thread.
+* - `cacheKey` is derived from the rendered payload so dedup is automatic.
+* - `contextWindow.hasSnapshot` re-injection ensures the model still sees the
+*   current snapshot after older messages drop out of the window.
+*
+* Delta emission (markdown mode only): when a prior snapshot exists in the
+* context window, the processor emits a unified-diff delta against that
+* snapshot's contents. Schema mode and the snapshot fallback always emit a
+* full snapshot.
+*
+* @example
+* ```ts
+* new Memory({
+*   options: {
+*     workingMemory: {
+*       enabled: true,
+*       template: '...',
+*       useStateSignals: true, // auto-attaches this processor
+*     },
+*   },
+* });
+* ```
+*/
+const WORKING_MEMORY_STATE_ID = "working-memory";
+const WORKING_MEMORY_STATE_PROCESSOR_ID = "working-memory-state";
+var WorkingMemoryStateProcessor = class {
+	memory;
+	memoryConfig;
+	id = WORKING_MEMORY_STATE_PROCESSOR_ID;
+	stateId = WORKING_MEMORY_STATE_ID;
+	constructor(memory, memoryConfig) {
+		this.memory = memory;
+		this.memoryConfig = memoryConfig;
+	}
+	async computeStateSignal(args) {
+		const template = await this.memory.getWorkingMemoryTemplate({ memoryConfig: this.memoryConfig });
+		if (!template) return;
+		const contents = (await this.memory.getWorkingMemory({
+			threadId: args.threadId,
+			resourceId: args.resourceId,
+			memoryConfig: this.memoryConfig
+		}))?.trim();
+		if (!contents) return;
+		const cacheKey = stableWorkingMemoryCacheKey({
+			format: template.format,
+			data: contents
+		});
+		const shouldMakeSnapshot = !args.contextWindow.hasSnapshot;
+		if (args.tracking?.currentCacheKey === cacheKey && !shouldMakeSnapshot) return;
+		const scope = this.memory.getMergedThreadConfig(this.memoryConfig).workingMemory?.scope ?? "resource";
+		const deltaCandidate = template.format === "markdown" && !shouldMakeSnapshot ? buildMarkdownDelta({
+			lastSnapshot: args.lastSnapshot,
+			deltasSinceSnapshot: args.deltasSinceSnapshot,
+			nextContents: contents
+		}) : void 0;
+		if (deltaCandidate) return {
+			id: WORKING_MEMORY_STATE_ID,
+			mode: "delta",
+			cacheKey,
+			tagName: "working-memory",
+			contents: deltaCandidate.contents,
+			delta: deltaCandidate.contents,
+			value: contents,
+			attributes: {
+				format: template.format,
+				scope,
+				patch: "unified-diff"
+			}
+		};
+		return {
+			id: WORKING_MEMORY_STATE_ID,
+			mode: "snapshot",
+			cacheKey,
+			tagName: "working-memory",
+			contents,
+			value: contents,
+			attributes: {
+				format: template.format,
+				scope
+			}
+		};
+	}
+};
+/**
+* Stable cache key for the rendered working memory payload. Returns a SHA-256
+* digest so dedup metadata stays compact regardless of payload size (working
+* memory blobs can grow arbitrarily long).
+*/
+function stableWorkingMemoryCacheKey(input) {
+	const hash = createHash("sha256");
+	hash.update(input.format);
+	hash.update("\0");
+	hash.update(input.data ?? "");
+	return `sha256:${hash.digest("hex")}`;
+}
+/**
+* Build a unified-diff delta against the most recently emitted state. Prefers
+* the latest delta's `value` (the post-edit full text) when available, falling
+* back to the snapshot's `value` and finally the snapshot's `contents`. This
+* keeps deltas incremental (B→C) instead of cumulative against a stale
+* snapshot (A→C), which matters when many small edits land between snapshots.
+*
+* Returns undefined when:
+* - there's no prior state to diff against
+* - the prior state isn't a plain string (multimodal signal)
+*
+* In either case the caller falls back to emitting a full snapshot.
+*/
+function buildMarkdownDelta(args) {
+	const { lastSnapshot, deltasSinceSnapshot, nextContents } = args;
+	const prior = pickStringValue(readSignalValue(deltasSinceSnapshot.at(-1))) ?? pickStringValue(readSignalValue(lastSnapshot)) ?? (typeof lastSnapshot?.contents === "string" ? lastSnapshot.contents : void 0);
+	if (!prior) return;
+	return { contents: renderHunksOnly(prior, nextContents) };
+}
+function pickStringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function readSignalValue(signal) {
+	return (signal?.metadata)?.value;
+}
+/**
+* Render a unified-diff-style patch body containing only `@@` hunks and their
+* lines — dropping the filename preamble (`Index:` / `===` / `---` / `+++`)
+* that `createPatch` emits and the `` trailer.
+* The preamble exists for tooling like `patch -p1` to know which file to
+* apply to; we only ever diff a single working-memory blob. The newline
+* trailer is semantically meaningless to the model and adds noise to the
+* state signal.
+*/
+function renderHunksOnly(prior, next) {
+	const { hunks } = structuredPatch("", "", prior, next, "", "", { context: 0 });
+	return hunks.map((hunk) => {
+		return [`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`, ...hunk.lines.filter((line) => !line.startsWith("\"))].join("\n");
+	}).join("\n");
+}
 var working_memory_state_exports = /* @__PURE__ */ __exportAll({
 	WORKING_MEMORY_STATE_ID: () => WORKING_MEMORY_STATE_ID,
 	WORKING_MEMORY_STATE_PROCESSOR_ID: () => WORKING_MEMORY_STATE_PROCESSOR_ID,
@@ -35055,7 +34932,6 @@ ${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 ? {
@@ -35066,7 +34942,6 @@ ${workingMemory}`;
 				bufferActivation: omConfig.reflection.bufferActivation,
 				blockAfter: omConfig.reflection.blockAfter,
 				instruction: omConfig.reflection.instruction,
-				continuationHints: omConfig.reflection.continuationHints,
 				extract: omConfig.reflection.extract
 			} : void 0
 		});
@@ -41234,7 +41109,6 @@ async function cancelResponseBody(response) {
 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");
 }
@@ -46361,4 +46235,4 @@ const agentBuilderWorkflows = {
 //#endregion
 export { agentBuilderWorkflows };
 
-//# sourceMappingURL=dist-L0EogwX_.js.map
+//# sourceMappingURL=dist-HzWDFjPH.js.map