@mastra/server 1.60.0-alpha.1 → 1.60.0-alpha.10

package/dist/{dist-DhGJtn6J.cjs → dist-C2O8fRb-.cjs}

@@ -12,17 +12,17 @@ let _mastra_core_memory = require("@mastra/core/memory");
 let _mastra_core_agent = require("@mastra/core/agent");
 let _mastra_core_error = require("@mastra/core/error");
 let _mastra_core_llm = require("@mastra/core/llm");
+let _mastra_core_tools = require("@mastra/core/tools");
 let util = require("util");
 let crypto$1 = require("crypto");
-let _mastra_core_tools = require("@mastra/core/tools");
 let _mastra_core_utils = require("@mastra/core/utils");
 let _mastra_core_storage = require("@mastra/core/storage");
 let _mastra_core_features = require("@mastra/core/features");
 let _mastra_core_observability = require("@mastra/core/observability");
 let _mastra_core_request_context = require("@mastra/core/request-context");
 let _mastra_core_processors = require("@mastra/core/processors");
-let fs = require("fs");
 let _mastra_core_workflows = require("@mastra/core/workflows");
+let fs = require("fs");
 let path = require("path");
 let module$1 = require("module");
 let diagnostics_channel = require("diagnostics_channel");
@@ -4693,7 +4693,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-BYD6Wp5m.js
+//#region ../memory/dist/src-C-nmWgoF.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -20528,21 +20528,17 @@ Or as a standalone observation when closing out a broader task:
 Completion observations should be terse but specific about WHAT was completed.
 Prefer concrete resolved outcomes over abstract workflow status so the assistant remembers what is already done.`;
 buildObserverOutputFormat();
-function buildObserverOutputFormat(extractors = []) {
-	const extractorSections = buildExtractorOutputSections(extractors);
-	const legacyContinuationSections = extractors.length === 0 ? `
-<current-task>
-State the current task(s) explicitly:
-- Primary: What the agent is currently working on
-- Secondary: Other pending tasks (mark as "waiting for user" if appropriate)
-</current-task>
-
-<suggested-response>
-Hint for the agent's immediate next message. Examples:
-- "I've updated the navigation model. Let me walk you through the changes..."
-- "The assistant should wait for the user to respond before continuing."
-- Call the view tool on src/example.ts to continue debugging.
-</suggested-response>` : "";
+/**
+* Build the Observer's output format.
+*
+* `extractors` distinguishes two cases that both look empty:
+* - `undefined` — the no-arg call behind the exported defaults (OBSERVER_OUTPUT_FORMAT_BASE,
+*   OBSERVER_SYSTEM_PROMPT, REFLECTOR_SYSTEM_PROMPT), which keep describing both built-in
+*   sections with their historical text. Runtime callers always pass the composed list.
+* - `[]` — the caller composed extractors and every section was disabled, so no continuation
+*   sections are described at all.
+*/
+function buildObserverOutputFormat(extractors) {
 	return `Use priority levels:
 - 🔴 High: explicit user facts, preferences, unresolved goals, critical context
 - 🟡 Medium: project details, learned information, tool results
@@ -20568,7 +20564,19 @@ Date: Dec 5, 2025
 * 🔴 (09:15) Continued work on feature X
 </observations>
 
-${extractorSections || legacyContinuationSections}`;
+${buildExtractorOutputSections(extractors ?? []) || (extractors === void 0 ? `
+<current-task>
+State the current task(s) explicitly:
+- Primary: What the agent is currently working on
+- Secondary: Other pending tasks (mark as "waiting for user" if appropriate)
+</current-task>
+
+<suggested-response>
+Hint for the agent's immediate next message. Examples:
+- "I've updated the navigation model. Let me walk you through the changes..."
+- "The assistant should wait for the user to respond before continuing."
+- Call the view tool on src/example.ts to continue debugging.
+</suggested-response>` : "")}`;
 }
 /**
 * The guidelines for the Observer.
@@ -20595,10 +20603,22 @@ const OBSERVER_GUIDELINES = `- Be specific enough for the assistant to act on
 * Build the complete observer system prompt.
 * @param multiThread - Whether this is for multi-thread batched observation (default: false)
 * @param instruction - Optional custom instructions to append to the prompt
+* @param includeThreadTitle - Whether the Observer should also produce a thread title
+* @param extractors - Active extractors, used to decide which sections the prompt describes.
+*   Omitted only by the exported no-arg defaults; pass `[]` to describe no continuation sections at all.
 */
-function buildObserverSystemPrompt(multiThread = false, instruction, includeThreadTitle = false, extractors = []) {
+function buildObserverSystemPrompt(multiThread = false, instruction, includeThreadTitle = false, extractors) {
 	const outputFormat = buildObserverOutputFormat(extractors);
-	const multiThreadTitleInstruction = includeThreadTitle ? ` Each thread's observations, current-task, suggested-response, and thread-title should be nested inside a <thread id="..."> block within <observations>.` : ` Each thread's observations, current-task, and suggested-response should be nested inside a <thread id="..."> block within <observations>.`;
+	const customInstructions = instruction ? `\n\n=== CUSTOM INSTRUCTIONS ===\n\n${instruction}` : "";
+	const currentTaskEnabled = extractors === void 0 || extractors.some((extractor) => extractor.slug === "current-task");
+	const suggestedResponseEnabled = extractors === void 0 || extractors.some((extractor) => extractor.slug === "suggested-response");
+	const multiThreadSections = [
+		"observations",
+		...currentTaskEnabled ? ["current-task"] : [],
+		...suggestedResponseEnabled ? ["suggested-response"] : [],
+		...includeThreadTitle ? ["thread-title"] : []
+	];
+	const multiThreadTitleInstruction = ` Each thread's ${multiThreadSections.length <= 2 ? multiThreadSections.join(" and ") : `${multiThreadSections.slice(0, -1).join(", ")}, and ${multiThreadSections[multiThreadSections.length - 1]}`} should be nested inside a <thread id="..."> block within <observations>.`;
 	const multiThreadTitleExample = includeThreadTitle ? `
 <thread-title>Feature X implementation</thread-title>` : "";
 	const multiThreadSecondTitleExample = includeThreadTitle ? `
@@ -20628,28 +20648,28 @@ For multi-thread output, wrap each thread's observations like this:
 <thread id="thread_id_1">
 Date: Dec 4, 2025
 * 🔴 (14:30) User prefers direct answers
-* 🔴 (14:31) Working on feature X
+* 🔴 (14:31) Working on feature X${currentTaskEnabled ? `
 
 <current-task>
 What the agent is currently working on in this thread
-</current-task>
+</current-task>` : ""}${suggestedResponseEnabled ? `
 
 <suggested-response>
 Hint for the agent's next message in this thread
-</suggested-response>${multiThreadTitleExample}
+</suggested-response>` : ""}${multiThreadTitleExample}
 </thread>
 
 <thread id="thread_id_2">
 Date: Dec 5, 2025
-* 🔴 (09:15) User asked about deployment
+* 🔴 (09:15) User asked about deployment${currentTaskEnabled ? `
 
 <current-task>
 Current task for this thread
-</current-task>
+</current-task>` : ""}${suggestedResponseEnabled ? `
 
 <suggested-response>
 Suggested response for this thread
-</suggested-response>${multiThreadSecondTitleExample}
+</suggested-response>` : ""}${multiThreadSecondTitleExample}
 </thread>
 </observations>
 
@@ -20659,7 +20679,7 @@ ${OBSERVER_GUIDELINES}
 
 Remember: These observations are the assistant's ONLY memory. Make them count.
 
-User messages are extremely important. If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority.${instruction ? `\n\n=== CUSTOM INSTRUCTIONS ===\n\n${instruction}` : ""}`;
+User messages are extremely important.${currentTaskEnabled ? " If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority." : ""}${customInstructions}`;
 	return `You are the memory consciousness of an AI assistant. Your observations will be the ONLY information the assistant has about past interactions with this user.
 
 Extract observations that will help the assistant remember:
@@ -20684,7 +20704,7 @@ Simply output your observations without any thread-related markup.
 
 Remember: These observations are the assistant's ONLY memory. Make them count.
 
-User messages are extremely important. If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority. If the assistant needs to respond to the user, indicate in <suggested-response> that it should pause for user reply before continuing other tasks.${instruction ? `\n\n=== CUSTOM INSTRUCTIONS ===\n\n${instruction}` : ""}`;
+User messages are extremely important.${currentTaskEnabled ? " If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority." : ""}${suggestedResponseEnabled ? " If the assistant needs to respond to the user, indicate in <suggested-response> that it should pause for user reply before continuing other tasks." : ""}${customInstructions}`;
 }
 /**
 * Observer Agent System Prompt (default - for backwards compatibility)
@@ -21376,7 +21396,7 @@ function optimizeObservationsForContext(observations) {
 	let optimized = stripEphemeralAnchorIds(observations);
 	optimized = optimized.replace(/🟡\s*/g, "");
 	optimized = optimized.replace(/🟢\s*/g, "");
-	optimized = optimized.replace(/\[(?![\d\s]*items collapsed)[^\]]+\]/g, "");
+	optimized = optimized.replace(/\[(?![\d\s]*items collapsed)[^\]]+\](?!\()/g, "");
 	optimized = optimized.replace(/\s*->\s*/g, " ");
 	optimized = optimized.replace(/  +/g, " ");
 	optimized = optimized.replace(/\n{3,}/g, "\n\n");
@@ -22786,6 +22806,7 @@ var TokenCounter = class TokenCounter {
 	defaultModelContext;
 	modelContextStorage = new async_hooks.AsyncLocalStorage();
 	inFlightAttachmentCounts = /* @__PURE__ */ new Map();
+	multimodalToolResultCounts = /* @__PURE__ */ new WeakMap();
 	static TOKENS_PER_MESSAGE = 3.8;
 	static TOKENS_PER_CONVERSATION = 24;
 	constructor(options) {
@@ -22848,6 +22869,9 @@ var TokenCounter = class TokenCounter {
 	}
 	countMultimodalToolResultContent(part, toolResult) {
 		if (!toolResult || typeof toolResult !== "object") return;
+		const resultKey = buildEstimateKey("tool-result-multimodal-content-source", JSON.stringify(toolResult));
+		const cached = this.multimodalToolResultCounts.get(part);
+		if (cached?.resultKey === resultKey) return cached.tokens;
 		const output = toolResult;
 		const content = output.type === "content" && Array.isArray(output.value) ? output.value : output.content;
 		if (!Array.isArray(content)) return;
@@ -22959,10 +22983,15 @@ var TokenCounter = class TokenCounter {
 			countJsonContentPart(contentPart);
 		}
 		if (!hasAttachment) return;
-		return this.readOrPersistFixedPartEstimate(part, "tool-result-multimodal-content", JSON.stringify({
+		const estimate = this.readOrPersistFixedPartEstimate(part, "tool-result-multimodal-content", JSON.stringify({
 			type: "content",
 			value: cacheParts
 		}), tokens);
+		this.multimodalToolResultCounts.set(part, {
+			resultKey,
+			tokens: estimate
+		});
+		return estimate;
 	}
 	estimateImageAssetTokens(part, asset, kind) {
 		const modelContext = this.getModelContext();
@@ -24436,21 +24465,22 @@ const SET_WORKING_MEMORY_TOOL_NAME = "setWorkingMemory";
 /**
 * Deep merges two objects, with special handling for null values (delete) and arrays (replace).
 * - Object properties are recursively merged
-* - null values in the update will delete the corresponding property
+* - null values in the update will delete the corresponding property, even when the property
+*   or its parent object does not exist yet (so padded nulls never get stored literally)
 * - Arrays are replaced entirely (not merged element-by-element)
 * - Primitive values are overwritten
+* - The returned object is always newly constructed and never aliases `update`
 */
 function deepMergeWorkingMemory(existing, update) {
 	if (!update || typeof update !== "object" || Object.keys(update).length === 0) return existing && typeof existing === "object" ? { ...existing } : {};
-	if (!existing || typeof existing !== "object") return update;
-	const result = { ...existing };
+	const result = { ...existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {} };
 	for (const key of Object.keys(update)) {
 		const updateValue = update[key];
 		const existingValue = result[key];
 		if (updateValue === void 0) continue;
 		if (updateValue === null) delete result[key];
 		else if (Array.isArray(updateValue)) result[key] = updateValue;
-		else if (typeof updateValue === "object" && updateValue !== null && typeof existingValue === "object" && existingValue !== null && !Array.isArray(existingValue)) result[key] = deepMergeWorkingMemory(existingValue, updateValue);
+		else if (typeof updateValue === "object") result[key] = deepMergeWorkingMemory(existingValue && typeof existingValue === "object" && !Array.isArray(existingValue) ? existingValue : void 0, updateValue);
 		else result[key] = updateValue;
 	}
 	return result;
@@ -24931,23 +24961,43 @@ function createThreadTitleExtractor() {
 		metadataKeyPath: "threadTitle"
 	}, true);
 }
+/**
+* Normalize the user-facing `continuationHints` config into explicit per-section flags.
+* Both sections stay enabled unless the caller opts out, so omitting the config is a no-op.
+*/
+function resolveContinuationHints(config) {
+	if (config === void 0 || config === true) return {
+		currentTask: true,
+		suggestedResponse: true
+	};
+	if (config === false) return {
+		currentTask: false,
+		suggestedResponse: false
+	};
+	return {
+		currentTask: config.currentTask ?? true,
+		suggestedResponse: config.suggestedResponse ?? true
+	};
+}
 function composeExtractors(options) {
+	const continuationHints = resolveContinuationHints(options.continuationHints);
 	const extractors = [];
-	if (options.includeContinuationHints) extractors.push(createCurrentTaskExtractor(), createSuggestedResponseExtractor());
+	if (continuationHints.currentTask) extractors.push(createCurrentTaskExtractor());
+	if (continuationHints.suggestedResponse) extractors.push(createSuggestedResponseExtractor());
 	if (options.includeThreadTitle) extractors.push(createThreadTitleExtractor());
 	extractors.push(...options.userExtractors ?? []);
 	return validateExtractorList(extractors);
 }
 function composeObservationExtractors(config) {
 	return composeExtractors({
-		includeContinuationHints: true,
+		continuationHints: config.continuationHints,
 		includeThreadTitle: config.threadTitle,
 		userExtractors: config.extract
 	});
 }
 function composeReflectionExtractors(config) {
 	return composeExtractors({
-		includeContinuationHints: true,
+		continuationHints: config.continuationHints,
 		userExtractors: config.extract
 	});
 }
@@ -26708,10 +26758,12 @@ var ObservationStep = class {
 				resourceId,
 				checkThreshold: true,
 				messages: step0Messages,
+				record: this.turn.record,
 				currentModel: this.turn.actorModelContext,
 				writer: this.turn.writer,
 				messageList
 			});
+			this.turn.setRecord(activation.record);
 			if (activation.activated) {
 				activated = true;
 				if (activation.activatedMessageIds?.length) messageList.removeByIds(activation.activatedMessageIds);
@@ -26753,6 +26805,7 @@ var ObservationStep = class {
 		let statusSnapshot = await om.getStatus({
 			threadId,
 			resourceId,
+			record: this.turn.record,
 			messages: getObservableMessages(messageList)
 		});
 		if (statusSnapshot.shouldBuffer && !hasIncompleteToolCalls) {
@@ -26770,7 +26823,7 @@ var ObservationStep = class {
 				messageList.removeByIds(candidates.map((msg) => msg.id));
 				for (const msg of candidates) messageList.add(msg, "memory");
 			}
-			om.buffer({
+			om.trackBackgroundWork(om.buffer({
 				threadId,
 				resourceId,
 				messages: unobservedMessages,
@@ -26781,7 +26834,7 @@ var ObservationStep = class {
 				observabilityContext: this.turn.observabilityContext
 			}).catch((err) => {
 				omDebug(`[OM:buffer] fire-and-forget buffer failed: ${err?.message}`);
-			});
+			}));
 			buffered = true;
 		}
 		const willObserveNow = statusSnapshot.shouldObserve && !hasIncompleteToolCalls;
@@ -26848,6 +26901,7 @@ var ObservationStep = class {
 			statusSnapshot = await om.getStatus({
 				threadId,
 				resourceId,
+				record: this.turn.record,
 				messages: getObservableMessages(messageList)
 			});
 		}
@@ -26898,10 +26952,12 @@ var ObservationStep = class {
 		const { threadId, resourceId, messageList } = this.turn;
 		const om = this.turn.om;
 		await om.waitForBuffering(threadId, resourceId);
+		await this.turn.refreshRecord();
 		const observableMessages = this.seededResponseMessage ? getObservableMessages(messageList).filter((msg) => msg.id !== this.turn.responseMessageId) : getObservableMessages(messageList);
 		const freshStatus = await om.getStatus({
 			threadId,
 			resourceId,
+			record: this.turn.record,
 			messages: observableMessages
 		});
 		if (!freshStatus.shouldObserve) return {
@@ -26912,11 +26968,13 @@ var ObservationStep = class {
 			const activation = await om.activate({
 				threadId,
 				resourceId,
+				record: this.turn.record,
 				messages: observableMessages,
 				currentModel: this.turn.actorModelContext,
 				writer: this.turn.writer,
 				messageList
 			});
+			this.turn.setRecord(activation.record);
 			if (activation.activated) {
 				const postActivationRecord = activation.record;
 				await om.reflector.maybeReflect({
@@ -27099,6 +27157,18 @@ var ObservationTurn = class {
 		};
 		return this._context;
 	}
+	/** Replace the cached turn record with a specific instance. */
+	setRecord(record) {
+		this._record = record;
+		if (this._context) this._context.record = record;
+	}
+	/** Patch the cached turn record with merged fields. */
+	patchRecord(patch) {
+		this.setRecord({
+			...this.record,
+			...patch
+		});
+	}
 	/**
 	* Create a step handle. If a previous step exists, it is finalized
 	* (its output messages will be saved at the start of the new step's prepare()).
@@ -27130,7 +27200,7 @@ var ObservationTurn = class {
 			const allMessages = getObservableMessages(this.messageList);
 			const record = this._record;
 			const unobservedMessages = this.om.getUnobservedMessages(allMessages, record);
-			if (unobservedMessages.length > 0) this.om.buffer({
+			if (unobservedMessages.length > 0) this.om.trackBackgroundWork(this.om.buffer({
 				threadId: this.threadId,
 				resourceId: this.resourceId,
 				messages: unobservedMessages,
@@ -27144,7 +27214,7 @@ var ObservationTurn = class {
 				skipMinimumTokenCheck: true
 			}).catch((err) => {
 				omDebug(`[OM:turn.end] idle buffer failed: ${err?.message}`);
-			});
+			}));
 		}
 		return { record: this._record };
 	}
@@ -27153,7 +27223,7 @@ var ObservationTurn = class {
 	* @internal
 	*/
 	async refreshRecord() {
-		this._record = await this.om.getOrCreateRecord(this.threadId, this.resourceId);
+		this.setRecord(await this.om.getOrCreateRecord(this.threadId, this.resourceId));
 	}
 	/**
 	* Refresh cross-thread context for resource scope. Called per-step.
@@ -27206,9 +27276,13 @@ var ObservationTurn = class {
 * - Preserving ALL important information (reflections become the ENTIRE memory)
 *
 * @param instruction - Optional custom instructions to append to the prompt
+* @param extractors - Active extractors, used to decide which sections the prompt describes
 */
-function buildReflectorSystemPrompt(instruction, extractors = []) {
+function buildReflectorSystemPrompt(instruction, extractors) {
 	const outputFormat = buildObserverOutputFormat(extractors);
+	const customInstructions = instruction ? `\n\n=== CUSTOM INSTRUCTIONS ===\n\n${instruction}` : "";
+	const currentTaskEnabled = extractors === void 0 || extractors.some((extractor) => extractor.slug === "current-task");
+	const suggestedResponseEnabled = extractors === void 0 || extractors.some((extractor) => extractor.slug === "suggested-response");
 	return `You are the memory consciousness of an AI assistant. Your memory observation reflections will be the ONLY information the assistant has about past interactions with this user.
 
 The following instructions were given to another part of your psyche (the observer) to create memories.
@@ -27285,7 +27359,7 @@ Date: Dec 4, 2025
 
 ${outputFormat}
 
-User messages are extremely important. If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority. If the assistant needs to respond to the user, indicate in <suggested-response> that it should pause for user reply before continuing other tasks.${instruction ? `\n\n=== CUSTOM INSTRUCTIONS ===\n\n${instruction}` : ""}`;
+User messages are extremely important.${currentTaskEnabled ? " If the user asks a question or gives a new task, make it clear in <current-task> that this is the priority." : ""}${suggestedResponseEnabled ? " If the assistant needs to respond to the user, indicate in <suggested-response> that it should pause for user reply before continuing other tasks." : ""}${customInstructions}`;
 }
 buildReflectorSystemPrompt();
 /**
@@ -27620,6 +27694,8 @@ var ReflectorRunner = class {
 		};
 		let reflectedTokens = 0;
 		let attemptNumber = 0;
+		/** Observations from the previous attempt, used to detect a no-progress ladder. */
+		let previousObservations;
 		while (currentLevel <= maxLevel) {
 			attemptNumber++;
 			const isRetry = attemptNumber > 1;
@@ -27693,6 +27769,11 @@ var ReflectorRunner = class {
 				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,
@@ -28667,6 +28748,39 @@ var ObservationalMemory = class ObservationalMemory {
 	*/
 	recordInitializations = /* @__PURE__ */ new Map();
 	/**
+	* In-flight fire-and-forget background cycles (buffered observation, reflection).
+	* Tracked so callers can join them via `settled()` before closing a storage
+	* connection they own — otherwise a background cycle's tail statements race the close.
+	*/
+	pendingBackgroundWork = /* @__PURE__ */ new Set();
+	/**
+	* Register fire-and-forget background work so `settled()` can join it.
+	* Returns the original promise so callers keep their own rejection handling.
+	*/
+	trackBackgroundWork(work) {
+		const tracked = work.catch(() => {}).finally(() => {
+			this.pendingBackgroundWork.delete(tracked);
+		});
+		this.pendingBackgroundWork.add(tracked);
+		return work;
+	}
+	/**
+	* Resolve once all background observational-memory work started so far has finished.
+	*
+	* Background cycles enqueue further background work (a buffered observation can
+	* trigger a reflection, which runs nested agent streams), so this drains repeatedly
+	* until nothing is left rather than joining a single snapshot.
+	*/
+	async settled() {
+		const maxDrainRounds = 100;
+		for (let round = 0; round < maxDrainRounds; round++) {
+			if (this.pendingBackgroundWork.size === 0) return;
+			await Promise.allSettled([...this.pendingBackgroundWork]);
+		}
+		if (this.pendingBackgroundWork.size === 0) return;
+		omError(`[OM:settled] background work still pending after ${maxDrainRounds} drain rounds; giving up waiting`);
+	}
+	/**
 	* Acquire a lock for the given key, execute the callback, then release.
 	* If a lock is already held, waits for it to be released before acquiring.
 	*/
@@ -28743,7 +28857,8 @@ var ObservationalMemory = class ObservationalMemory {
 			observeAttachments: config.observation?.observeAttachments ?? true,
 			extractors: composeObservationExtractors({
 				threadTitle: config.observation?.threadTitle ?? false,
-				extract: config.observation?.extract
+				extract: config.observation?.extract,
+				continuationHints: config.observation?.continuationHints
 			})
 		};
 		this.reflectionConfig = {
@@ -28760,7 +28875,10 @@ var ObservationalMemory = class ObservationalMemory {
 			activateOnProviderChange: config.reflection?.activateOnProviderChange ?? false,
 			blockAfter: asyncBufferingDisabled ? void 0 : resolveBlockAfter(config.reflection?.blockAfter ?? (config.reflection?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.bufferActivation ? 1.2 : void 0), config.reflection?.observationTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.observationTokens),
 			instruction: config.reflection?.instruction,
-			extractors: composeReflectionExtractors({ extract: config.reflection?.extract })
+			extractors: composeReflectionExtractors({
+				extract: config.reflection?.extract,
+				continuationHints: config.reflection?.continuationHints
+			})
 		};
 		this.tokenCounter = new TokenCounter({ model: typeof observationModel === "string" ? observationModel : void 0 });
 		this.onDebugEvent = config.onDebugEvent;
@@ -29663,7 +29781,7 @@ ${formattedMessages}
 		if (!this.buffering.isAsyncObservationEnabled()) return false;
 		const lockKey = this.buffering.getLockKey(opts.threadId, opts.resourceId);
 		const shouldTrigger = this.buffering.shouldTriggerAsyncObservation(opts.pendingTokens, lockKey, opts.record, this.storage, opts.threshold);
-		if (shouldTrigger) this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext);
+		if (shouldTrigger) this.trackBackgroundWork(this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext));
 		return shouldTrigger;
 	}
 	isMessageList(value) {
@@ -29875,8 +29993,9 @@ ${formattedMessages}
 			return;
 		}
 		const omMetadata = (0, _mastra_core_memory.getThreadOMMetadata)((await this.storage.getThreadById({ threadId }))?.metadata);
-		const currentTask = omMetadata?.currentTask;
-		const suggestedResponse = omMetadata?.suggestedResponse;
+		const activeExtractors = [...this.observationConfig.extractors, ...this.reflectionConfig.extractors];
+		const currentTask = activeExtractors.some((extractor) => extractor.slug === "current-task") ? omMetadata?.currentTask : void 0;
+		const suggestedResponse = activeExtractors.some((extractor) => extractor.slug === "suggested-response") ? omMetadata?.suggestedResponse : void 0;
 		const currentDate = opts.currentDate ?? /* @__PURE__ */ new Date();
 		return this.formatObservationsForContext(record.activeObservations, currentTask, suggestedResponse, omMetadata?.extracted, unobservedContextBlocks, currentDate, this.retrieval);
 	}
@@ -29975,7 +30094,10 @@ ${formattedMessages}
 				}
 			};
 			omDebug(`[OM:status] step=${stepNumber} msgs=${pendingTokens}/${threshold} obs=${currentObservationTokens}/${effectiveObservationTokensThreshold} gen=${record.generationCount}`);
-			await writer.custom(statusPart).catch(() => {});
+			await writer.custom({
+				...statusPart,
+				transient: true
+			}).catch(() => {});
 		}
 	}
 	/**
@@ -30001,11 +30123,11 @@ ${formattedMessages}
 	* ```
 	*/
 	async getStatus(opts) {
-		const { threadId, resourceId } = opts;
-		const record = await this.getOrCreateRecord(threadId, resourceId);
+		const { threadId, resourceId, record: providedRecord, messages } = opts;
+		const record = providedRecord ?? await this.getOrCreateRecord(threadId, resourceId);
 		const currentObservationTokens = record.observationTokenCount ?? 0;
 		let unobservedMessages;
-		if (opts.messages) unobservedMessages = this.getUnobservedMessages(opts.messages, record);
+		if (messages) unobservedMessages = this.getUnobservedMessages(messages, record);
 		else {
 			const rawMessages = await this.loadMessagesFromStorage(threadId, resourceId, record.lastObservedAt ? new Date(record.lastObservedAt) : void 0);
 			unobservedMessages = this.getUnobservedMessages(rawMessages, record);
@@ -30162,6 +30284,7 @@ ${formattedMessages}
 	async buffer(opts) {
 		const { threadId, resourceId, requestContext, observabilityContext } = opts;
 		let record = opts.record ?? await this.getOrCreateRecord(threadId, resourceId);
+		const inMemoryRecord = record;
 		if (!this.buffering.isAsyncObservationEnabled()) return {
 			buffered: false,
 			record
@@ -30180,6 +30303,8 @@ ${formattedMessages}
 			await existingOp;
 		} catch {}
 		registerOp(record.id, "bufferingObservation");
+		inMemoryRecord.isBufferingObservation = true;
+		inMemoryRecord.lastBufferedAtTokens = currentTokens;
 		this.storage.setBufferingObservationFlag(record.id, true, currentTokens).catch((err) => {
 			omError("[OM] Failed to set buffering observation flag", err);
 		});
@@ -30189,6 +30314,14 @@ ${formattedMessages}
 		});
 		BufferingCoordinator.asyncBufferingOps.set(bufferKey, opPromise);
 		record = await this.storage.getObservationalMemory(record.threadId, record.resourceId) ?? record;
+		const setBufferingState = (isBufferingObservation, lastBufferedAtTokens) => {
+			inMemoryRecord.isBufferingObservation = isBufferingObservation;
+			record.isBufferingObservation = isBufferingObservation;
+			if (lastBufferedAtTokens !== void 0) {
+				inMemoryRecord.lastBufferedAtTokens = lastBufferedAtTokens;
+				record.lastBufferedAtTokens = lastBufferedAtTokens;
+			}
+		};
 		let flagCleared = false;
 		try {
 			let candidateMessages;
@@ -30210,10 +30343,13 @@ ${formattedMessages}
 			}
 			const minNewTokens = (this.observationConfig.bufferTokens ?? 5e3) / 2;
 			const newTokens = await this.tokenCounter.countMessagesAsync(candidateMessages);
-			if (candidateMessages.length === 0 || !opts.skipMinimumTokenCheck && newTokens < minNewTokens) return {
-				buffered: false,
-				record
-			};
+			if (candidateMessages.length === 0 || !opts.skipMinimumTokenCheck && newTokens < minNewTokens) {
+				setBufferingState(false);
+				return {
+					buffered: false,
+					record
+				};
+			}
 			if (opts.beforeBuffer) await opts.beforeBuffer(candidateMessages);
 			else if (opts.messages) this.sealMessagesForBuffering(candidateMessages);
 			const cycleId = `buffer-obs-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
@@ -30268,13 +30404,14 @@ ${formattedMessages}
 			});
 			await this.storage.setBufferingObservationFlag(record.id, false, newTokens).catch(() => {});
 			flagCleared = true;
+			setBufferingState(false, newTokens);
 			BufferingCoordinator.lastBufferedBoundary.set(bufferKey, newTokens);
 			const maxTimestamp = this.getMaxMessageTimestamp(candidateMessages);
 			const cursor = new Date(maxTimestamp.getTime() + 1);
 			BufferingCoordinator.lastBufferedAtTime.set(bufferKey, cursor);
 			return {
 				buffered: true,
-				record: await this.getOrCreateRecord(threadId, resourceId)
+				record: await this.storage.getObservationalMemory(record.threadId, record.resourceId) ?? record
 			};
 		} catch (error) {
 			omError("[OM] buffer() failed", error);
@@ -30286,7 +30423,10 @@ ${formattedMessages}
 			unregisterOp(record.id, "bufferingObservation");
 			BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
 			resolveOp();
-			if (!flagCleared) await this.storage.setBufferingObservationFlag(record.id, false).catch(() => {});
+			if (!flagCleared) {
+				setBufferingState(false);
+				await this.storage.setBufferingObservationFlag(record.id, false).catch(() => {});
+			}
 		}
 	}
 	/**
@@ -30312,7 +30452,7 @@ ${formattedMessages}
 	/** @internal Used by ObservationStep. */
 	async activate(opts) {
 		const { threadId, resourceId } = opts;
-		const record = await this.getOrCreateRecord(threadId, resourceId);
+		const record = opts.record ?? await this.getOrCreateRecord(threadId, resourceId);
 		if (this.buffering.isAsyncObservationEnabled()) {
 			const lockKey = this.buffering.getLockKey(threadId, resourceId);
 			const bufKey = this.buffering.getObservationBufferKey(lockKey);
@@ -30358,6 +30498,7 @@ ${formattedMessages}
 				const status = await this.getStatus({
 					threadId,
 					resourceId,
+					record,
 					messages: thresholdMessages
 				});
 				if (status.pendingTokens < status.threshold) return {
@@ -31073,31 +31214,30 @@ var ObservationalMemoryProcessor = class {
 					threadId,
 					resourceId
 				});
-				const freshRecord = await this.engine.getOrCreateRecord(threadId, resourceId);
+				const turnRecord = this.turn.record;
 				await this.engine.emitProgress({
-					record: freshRecord,
+					record: turnRecord,
 					stepNumber,
 					pendingTokens: ctx.status.pendingTokens,
 					threshold: ctx.status.threshold,
 					effectiveObservationTokensThreshold: ctx.status.effectiveObservationTokensThreshold,
-					currentObservationTokens: freshRecord.observationTokenCount ?? 0,
+					currentObservationTokens: turnRecord.observationTokenCount ?? 0,
 					writer,
 					threadId,
 					resourceId
 				});
-				const allDbMsgs = getObservableMessages(messageList);
-				const tokenCounter = this.engine.getTokenCounter();
-				const contextTokens = await tokenCounter.countMessagesAsync(allDbMsgs);
-				const otherThreadsContext = this.turn.context.otherThreadsContext;
-				const finalTotalPending = contextTokens + (otherThreadsContext ? tokenCounter.countString(otherThreadsContext) : 0);
-				await this.engine.getStorage().setPendingMessageTokens(freshRecord.id, finalTotalPending).catch(() => {});
+				const finalTotalPending = ctx.status.pendingTokens;
+				try {
+					await this.engine.getStorage().setPendingMessageTokens(turnRecord.id, finalTotalPending);
+					this.turn.patchRecord({ pendingMessageTokens: finalTotalPending });
+				} catch {}
 				if (reproCaptureEnabled) writeProcessInputStepReproCapture({
 					threadId,
 					resourceId,
 					stepNumber,
 					args,
 					preRecord: preRecordSnapshot,
-					postRecord: safeCaptureJson(freshRecord),
+					postRecord: safeCaptureJson(turnRecord),
 					preMessages: preMessagesSnapshot,
 					preBufferedChunks: [],
 					preContextTokenCount: 0,
@@ -31444,6 +31584,25 @@ var Memory = class extends _mastra_core_memory.MastraMemory {
 	trackVectorCleanup(cleanup) {
 		this.pendingVectorCleanup = Promise.allSettled([this.pendingVectorCleanup, cleanup]).then(() => void 0);
 	}
+	/**
+	* Resolve once all background work this Memory started has finished: observational-memory
+	* cycles (buffered observation and reflection, including the nested agent runs they spawn)
+	* and vector cleanup from `deleteThread` / `deleteMessages`.
+	*
+	* Callers that own the storage connection should await this before closing it, otherwise
+	* background statements can race the close.
+	*
+	* ```ts
+	* await agent.generate('hello', { memory: { thread, resource } });
+	* await memory.settled();
+	* await store.close();
+	* ```
+	*/
+	async settled() {
+		await this.pendingVectorCleanup;
+		await (this._omEngine ? await this._omEngine : this._omEngineInstance)?.settled();
+		await this.pendingVectorCleanup;
+	}
 	/** The shared ObservationalMemory engine. Lazily created on first access. */
 	get omEngine() {
 		if (!this._omEngine) this._omEngine = this._initOMEngine().then((engine) => {
@@ -43590,4 +43749,4 @@ const agentBuilderWorkflows = {
 //#endregion
 exports.agentBuilderWorkflows = agentBuilderWorkflows;
 
-//# sourceMappingURL=dist-DhGJtn6J.cjs.map
+//# sourceMappingURL=dist-C2O8fRb-.cjs.map