@mastra/memory 1.39.0-alpha.2 → 1.39.0-alpha.4

package/dist/{src-CJiR-m2F.cjs → src-BGgY5kgl.cjs}

@@ -18685,7 +18685,15 @@ const RETRY_CONFIG = {
 	/** Cap on per-attempt delay (ms). */
 	maxDelayMs: 12e4,
 	/** Random jitter as a fraction of the computed delay (e.g. 0.2 = ±20%). */
-	jitter: .2
+	jitter: .2,
+	/**
+	* How long one observer, reflector, or extraction model call may go without streaming any
+	* output before it is aborted and retried. Without it a provider that accepts the request but
+	* never answers stalls the call forever, and the retry schedule above never gets a chance to run.
+	* It measures inactivity, not total duration, so a long reply that keeps streaming is never cut
+	* off. It is generous because reasoning models can think silently before their first token.
+	*/
+	modelCallIdleTimeoutMs: 3e5
 };
 const TRANSIENT_MESSAGE_SUBSTRINGS = [
 	"terminated",
@@ -18704,6 +18712,19 @@ const TRANSIENT_MESSAGE_SUBSTRINGS = [
 ];
 const INCOMPLETE_FINISH_REASONS = /* @__PURE__ */ new Set(["other", "unknown"]);
 /**
+* A model call that streamed nothing for `RETRY_CONFIG.modelCallIdleTimeoutMs`. Retryable, and
+* deliberately not an AbortError so `withRetry` doesn't treat it as cancellation.
+*
+* @internal
+*/
+var OmModelCallTimeoutError = class extends Error {
+	isRetryable = true;
+	constructor(label, idleTimeoutMs) {
+		super(`${label} call produced no output for ${idleTimeoutMs}ms`);
+		this.name = "OmModelCallTimeoutError";
+	}
+};
+/**
 * A model reply that ended before the model finished. Carries the AI SDK's
 * `isRetryable` flag, which `isTransientLLMError` and core's error processors
 * already recognize.
@@ -18846,6 +18867,51 @@ function sleep(ms, abortSignal) {
 	});
 }
 /**
+* Run one attempt, failing with a retryable `OmModelCallTimeoutError` if it
+* goes `idleTimeoutMs` without calling `onActivity`. `fn` gets a signal that
+* aborts on timeout or on the caller's signal, so the underlying request is
+* cancelled too.
+*/
+async function attemptWithIdleTimeout(fn, label, idleTimeoutMs, abortSignal) {
+	const controller = new AbortController();
+	let rejectOnAbort;
+	const callerAborted = new Promise((_, reject) => {
+		rejectOnAbort = reject;
+	});
+	const onAbort = () => {
+		controller.abort(abortSignal?.reason);
+		rejectOnAbort(abortSignal?.reason ?? /* @__PURE__ */ new Error("The operation was aborted."));
+	};
+	abortSignal?.addEventListener("abort", onAbort, { once: true });
+	let timer;
+	let rejectOnIdle;
+	const idle = new Promise((_, reject) => {
+		rejectOnIdle = reject;
+	});
+	const armIdleTimer = () => {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			const error = new OmModelCallTimeoutError(label, idleTimeoutMs);
+			rejectOnIdle(error);
+			controller.abort(error);
+		}, idleTimeoutMs);
+	};
+	const onActivity = () => {
+		if (!controller.signal.aborted) armIdleTimer();
+	};
+	armIdleTimer();
+	try {
+		return await Promise.race([
+			fn(controller.signal, onActivity),
+			idle,
+			callerAborted
+		]);
+	} finally {
+		clearTimeout(timer);
+		abortSignal?.removeEventListener("abort", onAbort);
+	}
+}
+/**
 * Run `fn` with retries on transient transport-class errors.
 *
 * Non-transient errors (auth, validation, schema, etc.) are rethrown
@@ -18854,14 +18920,16 @@ function sleep(ms, abortSignal) {
 * @internal
 */
 async function withRetry(fn, opts) {
-	const { label, abortSignal, maxRetries = RETRY_CONFIG.maxRetries } = opts;
+	const { label, abortSignal, maxRetries = RETRY_CONFIG.maxRetries, idleTimeoutMs } = opts;
 	let attempt = 0;
 	while (true) {
 		if (abortSignal?.aborted) throw new Error("The operation was aborted.");
 		try {
-			return await fn();
+			if (idleTimeoutMs === void 0) return await fn(abortSignal ?? new AbortController().signal, () => {});
+			return await attemptWithIdleTimeout(fn, label, idleTimeoutMs, abortSignal);
 		} catch (error) {
-			if (hasAbortInChain(error) || abortSignal?.aborted) throw error;
+			if (abortSignal?.aborted) throw error;
+			if (!(error instanceof OmModelCallTimeoutError) && hasAbortInChain(error)) throw error;
 			if (attempt >= maxRetries || !isTransientLLMError(error)) {
 				if (attempt > 0) omDebug(`[OM:retry:${label}] giving up after ${attempt} retry/retries: ${error instanceof Error ? error.message : String(error)}`);
 				throw error;
@@ -18981,19 +19049,21 @@ If a prior value is still applicable and carry-forward is enabled, return that p
 ${extractorInstructions}${priorLines.length > 0 ? `\n\n## Prior Extracted Values\n\n${priorLines.join("\n\n")}` : ""}`;
 	const values = {};
 	const failures = [];
-	const streamWithStructuredOutput = async (jsonPromptInjection) => withRetry(() => streamOnce(jsonPromptInjection), {
+	const streamWithStructuredOutput = async (jsonPromptInjection) => withRetry((attemptSignal, onActivity) => streamOnce(jsonPromptInjection, attemptSignal, onActivity), {
 		label: `om-${opts.source}-structured-extraction`,
 		abortSignal: opts.abortSignal,
-		maxRetries: 1
+		maxRetries: 1,
+		idleTimeoutMs: RETRY_CONFIG.modelCallIdleTimeoutMs
 	});
-	const streamOnce = async (jsonPromptInjection) => {
+	const streamOnce = async (jsonPromptInjection, abortSignal, onActivity) => {
 		const object = await (await opts.agent.stream(prompt, {
 			structuredOutput: {
 				schema,
 				...jsonPromptInjection ? { jsonPromptInjection } : {}
 			},
 			...opts.memory ? { memory: opts.memory } : {},
-			...opts.abortSignal ? { abortSignal: opts.abortSignal } : {},
+			abortSignal,
+			onChunk: onActivity,
 			...opts.requestContext ? { requestContext: opts.requestContext } : {},
 			...opts.observabilityContext
 		})).object;
@@ -21761,7 +21831,7 @@ var ObserverRunner = class {
 			timeZone: options?.timeZone
 		})];
 		const doGenerate = async () => {
-			return withRetry(() => withOmTracingSpan({
+			return withRetry((attemptSignal, onActivity) => withOmTracingSpan({
 				phase: "observer",
 				model: resolvedModel.model,
 				inputTokens,
@@ -21784,7 +21854,8 @@ var ObserverRunner = class {
 							modelSettings: { ...this.observationConfig.modelSettings },
 							providerOptions: this.observationConfig.providerOptions,
 							...attemptMemory ? { memory: attemptMemory } : {},
-							...abortSignal ? { abortSignal } : {},
+							abortSignal: attemptSignal,
+							onChunk: onActivity,
 							...internalRequestContext ? { requestContext: internalRequestContext } : {},
 							...childObservabilityContext
 						})).getFullOutput(), "OM observer");
@@ -21806,6 +21877,7 @@ var ObserverRunner = class {
 			}), {
 				label: "observer",
 				abortSignal,
+				idleTimeoutMs: RETRY_CONFIG.modelCallIdleTimeoutMs,
 				maxRetries: this.observationConfig.maxRetries
 			});
 		};
@@ -21974,7 +22046,7 @@ var ObserverRunner = class {
 			timeZone
 		})];
 		const doGenerate = async () => {
-			return withRetry(() => withOmTracingSpan({
+			return withRetry((attemptSignal, onActivity) => withOmTracingSpan({
 				phase: "observer-multi-thread",
 				model: resolvedModel.model,
 				inputTokens,
@@ -21995,7 +22067,8 @@ var ObserverRunner = class {
 							maxSteps: 1,
 							modelSettings: { ...this.observationConfig.modelSettings },
 							providerOptions: this.observationConfig.providerOptions,
-							...abortSignal ? { abortSignal } : {},
+							abortSignal: attemptSignal,
+							onChunk: onActivity,
 							...internalRequestContext ? { requestContext: internalRequestContext } : {},
 							...childObservabilityContext
 						})).getFullOutput(), "OM multi-thread observer");
@@ -22019,6 +22092,7 @@ var ObserverRunner = class {
 			}), {
 				label: "observer-multi-thread",
 				abortSignal,
+				idleTimeoutMs: RETRY_CONFIG.modelCallIdleTimeoutMs,
 				maxRetries: this.observationConfig.maxRetries
 			});
 		};
@@ -28598,6 +28672,7 @@ var ObservationStep = class {
 		let observerExchange;
 		const step0Messages = this.stepNumber === 0 ? getObservableMessages(messageList) : [];
 		if (this.stepNumber === 0) {
+			this.turn.inputMessageIds = messageList.get.input.db().map((msg) => msg.id);
 			const activation = await om.activate({
 				threadId,
 				resourceId,
@@ -28699,19 +28774,36 @@ var ObservationStep = class {
 					observabilityContext: this.turn.observabilityContext
 				}).catch((err) => {
 					omDebug(`[OM:buffer] fire-and-forget buffer failed: ${err?.message}`);
-				}));
+				}), {
+					threadId,
+					resourceId
+				});
 				buffered = true;
 			}
 		}
 		const bandDefersObservation = statusSnapshot.inAsyncObservationBand && !statusSnapshot.canActivate;
 		const willObserveNow = statusSnapshot.shouldObserve && !hasIncompleteToolCalls && !bandDefersObservation;
-		/** In-flight message ids the step-0 cleanup must never remove from live context. */
-		let step0PreserveIds;
+		/**
+		* In-flight message ids cleanup must never remove from live context: the turn's own
+		* request, plus whatever the model has not read yet (the pending messages at step 0, the
+		* previous step's output — e.g. a tool result — at step > 0).
+		*/
+		let inFlightIds;
 		if (this.stepNumber > 0 || willObserveNow) {
 			if (this.stepNumber > 0) {
 				const newInput = messageList.clear.input.db();
 				const newOutput = messageList.clear.response.db();
 				const messagesToSave = [...newInput, ...newOutput];
+				const drainedIds = new Set(messagesToSave.map((msg) => msg.id));
+				const updatedEarlier = messageList.get.all.db().filter((msg) => !drainedIds.has(msg.id) && this.turn.drainedPartKeys.has(msg.id));
+				const drainedKeys = /* @__PURE__ */ new Map();
+				const unreadIds = [...messagesToSave, ...updatedEarlier].filter((msg) => {
+					const keys = getPartKeys(msg);
+					const seen = this.turn.drainedPartKeys.get(msg.id);
+					drainedKeys.set(msg.id, /* @__PURE__ */ new Set([...seen ?? [], ...keys]));
+					return !seen || keys.some((key) => !seen.has(key));
+				}).map((msg) => msg.id);
+				inFlightIds = [.../* @__PURE__ */ new Set([...this.turn.inputMessageIds, ...unreadIds])];
 				if (messagesToSave.length > 0) {
 					for (const msg of messagesToSave) messageList.add(msg, "memory");
 					try {
@@ -28722,10 +28814,11 @@ var ObservationStep = class {
 						throw error;
 					}
 				}
+				for (const [id, keys] of drainedKeys) this.turn.drainedPartKeys.set(id, keys);
 			} else {
 				const pending = [...messageList.get.input.db(), ...messageList.get.response.db()];
 				if (pending.length > 0) await om.persistMessages(pending, threadId, resourceId);
-				step0PreserveIds = pending.map((msg) => msg.id);
+				inFlightIds = pending.map((msg) => msg.id);
 			}
 			if (this.stepNumber === 0 && willObserveNow && this.turn.responseMessageId) {
 				const seed = {
@@ -28759,7 +28852,7 @@ var ObservationStep = class {
 						messages: messageList,
 						observedMessageIds: observedIds,
 						retentionFloor: minRemaining,
-						preserveMessageIds: step0PreserveIds
+						preserveMessageIds: [...inFlightIds ?? [], ...this.changedSinceDrain(messageList)]
 					});
 					if (statusSnapshot.asyncObservationEnabled) await om.resetBufferingState({
 						threadId,
@@ -28787,7 +28880,7 @@ var ObservationStep = class {
 		});
 		if (!didThresholdCleanup) {
 			const fallbackCursor = this.turn.record.threadId ? (0, _mastra_core_memory.getThreadOMMetadata)((await om.getStorage().getThreadById({ threadId: this.turn.record.threadId }))?.metadata)?.lastObservedMessageCursor : void 0;
-			const pendingMessageIds = new Set([...messageList.get.input.db(), ...messageList.get.response.db()].map((msg) => msg.id).filter(Boolean));
+			const pendingMessageIds = new Set([...messageList.get.input.db(), ...messageList.get.response.db()].map((msg) => msg.id).concat(inFlightIds ?? [], this.turn.inputMessageIds, this.changedSinceDrain(messageList)).filter(Boolean));
 			filterObservedMessages({
 				messageList,
 				record: this.turn.record,
@@ -28816,6 +28909,13 @@ var ObservationStep = class {
 		this._prepared = true;
 		return this._context;
 	}
+	/** Ids of already-drained messages that now hold parts the model has not been sent. */
+	changedSinceDrain(messageList) {
+		return messageList.get.all.db().filter((msg) => {
+			const seen = this.turn.drainedPartKeys.get(msg.id);
+			return seen !== void 0 && getPartKeys(msg).some((key) => !seen.has(key));
+		}).map((msg) => msg.id);
+	}
 	/**
 	* Run the full threshold observation pipeline:
 	* waitForBuffering → re-check → activate buffered chunks → reflect → observe
@@ -28988,6 +29088,49 @@ function restoreDrainedMessages(messageList, drained, source) {
 	const ids = drained.map((msg) => msg.id).filter((id) => !stillQueued.has(id));
 	for (const msg of messageList.removeByIds(ids)) messageList.add(msg, source, { merge: false });
 }
+/**
+* Identity keys of a message's non-marker parts. Tool parts are keyed by call id, state and result,
+* so a result merged in place into an existing tool-invocation part yields a new key. Bookkeeping
+* fields that change when a part is re-stamped are not part of the identity.
+*/
+function getPartKeys(msg) {
+	const seen = /* @__PURE__ */ new Map();
+	return (msg.content.parts ?? []).flatMap((part) => {
+		if (part.type.startsWith("data-om-")) return [];
+		let identity;
+		if (part.type === "tool-invocation") identity = toolPartIdentity(part.toolInvocation);
+		else {
+			const { providerMetadata: _providerMetadata, createdAt: _createdAt, updatedAt: _updatedAt, ...rest } = part;
+			identity = JSON.stringify(rest);
+		}
+		const ordinal = seen.get(identity) ?? 0;
+		seen.set(identity, ordinal + 1);
+		return [`${identity}#${ordinal}`];
+	});
+}
+/**
+* Serializing a tool result on every step is quadratic in turn length (each step rescans every drained
+* message), so the identity is cached per invocation object and reused while its state and result
+* reference are unchanged. A result merged in place replaces that reference and is re-serialized.
+*/
+const toolPartIdentityCache = /* @__PURE__ */ new WeakMap();
+function toolPartIdentity(invocation) {
+	const result = invocation.state === "result" ? invocation.result : null;
+	const cached = toolPartIdentityCache.get(invocation);
+	if (cached && cached.state === invocation.state && cached.result === result) return cached.identity;
+	const identity = JSON.stringify([
+		"tool-invocation",
+		invocation.toolCallId,
+		invocation.state,
+		result
+	]);
+	toolPartIdentityCache.set(invocation, {
+		state: invocation.state,
+		result,
+		identity
+	});
+	return identity;
+}
 //#endregion
 //#region src/processors/observational-memory/observation-turn/turn.ts
 /**
@@ -29021,6 +29164,19 @@ var ObservationTurn = class {
 	_ended = false;
 	/** Generation count at turn start — used to detect if reflection happened during the turn. */
 	_generationCountAtStart = -1;
+	/**
+	* Ids of the messages this turn was started with (the user's request). Mid-turn
+	* observation may record them, but they stay in the live prompt until the turn ends.
+	* @internal Set by step 0.
+	*/
+	inputMessageIds = [];
+	/**
+	* Fingerprints of the non-marker parts each message had when a step last drained it. A message
+	* is unread step output only if it gained a part the model has not seen — including a tool result
+	* merged in place into an existing tool-invocation part — not when it only gained OM markers.
+	* @internal
+	*/
+	drainedPartKeys = /* @__PURE__ */ new Map();
 	/** Memory context provider — set via start(). Used by steps for beforeBuffer persistence. */
 	memory;
 	/** Optional stream writer for emitting markers. */
@@ -29174,7 +29330,10 @@ var ObservationTurn = class {
 				skipMinimumTokenCheck: true
 			}).catch((err) => {
 				omDebug(`[OM:turn.end] idle buffer failed: ${err?.message}`);
-			}));
+			}), {
+				threadId: this.threadId,
+				resourceId: this.resourceId
+			});
 		}
 		return { record: this._record };
 	}
@@ -29618,6 +29777,7 @@ var ReflectorRunner = class {
 	* number per active thread/resource key and live for the runner's lifetime.
 	*/
 	syncReflectionSuppression = /* @__PURE__ */ new Map();
+	trackBackgroundWork;
 	constructor(opts) {
 		this.reflectionConfig = opts.reflectionConfig;
 		this.observationConfig = opts.observationConfig;
@@ -29634,6 +29794,7 @@ var ReflectorRunner = class {
 		this.memory = opts.memory;
 		this.onReflectionCommitted = opts.onReflectionCommitted;
 		this.hooks = opts.hooks;
+		this.trackBackgroundWork = opts.trackBackgroundWork;
 	}
 	__registerMastra(mastra) {
 		this.mastra = mastra;
@@ -29730,7 +29891,7 @@ var ReflectorRunner = class {
 			const prompt = buildReflectorPrompt(observations, manualPrompt, currentLevel, skipContinuationHints, activeExtractors, priorExtractedValues);
 			omDebug(`[OM:callReflector] ${isRetry ? `retry #${attemptNumber - 1}` : "first attempt"}: level=${currentLevel}, originalTokens=${originalTokens}, targetThreshold=${targetThreshold}, promptLen=${prompt.length}, skipContinuationHints=${skipContinuationHints}`);
 			let chunkCount = 0;
-			const result = await withRetry(() => withOmTracingSpan({
+			const result = await withRetry((attemptSignal, onActivity) => withOmTracingSpan({
 				phase: "reflector",
 				model: resolvedModel.model,
 				inputTokens: originalTokens,
@@ -29754,17 +29915,19 @@ var ReflectorRunner = class {
 							modelSettings: { ...this.reflectionConfig.modelSettings },
 							providerOptions: this.reflectionConfig.providerOptions,
 							...attemptMemory ? { memory: attemptMemory } : {},
-							...abortSignal ? { abortSignal } : {},
+							abortSignal: attemptSignal,
 							...internalRequestContext ? { requestContext: internalRequestContext } : {},
 							...childObservabilityContext,
+							onChunk(chunk) {
+								onActivity();
+								if (attemptNumber !== 1) return;
+								chunkCount++;
+								if (chunkCount === 1 || chunkCount % 50 === 0) {
+									const preview = chunk.type === "text-delta" ? ` text="${chunk.textDelta?.slice(0, 80)}..."` : chunk.type === "tool-call" ? ` tool=${chunk.toolName}` : "";
+									omDebug(`[OM:callReflector] chunk#${chunkCount}: type=${chunk.type}${preview}`);
+								}
+							},
 							...attemptNumber === 1 ? {
-								onChunk(chunk) {
-									chunkCount++;
-									if (chunkCount === 1 || chunkCount % 50 === 0) {
-										const preview = chunk.type === "text-delta" ? ` text="${chunk.textDelta?.slice(0, 80)}..."` : chunk.type === "tool-call" ? ` tool=${chunk.toolName}` : "";
-										omDebug(`[OM:callReflector] chunk#${chunkCount}: type=${chunk.type}${preview}`);
-									}
-								},
 								onFinish(event) {
 									omDebug(`[OM:callReflector] onFinish: chunks=${chunkCount}, finishReason=${event.finishReason}, inputTokens=${event.usage?.inputTokens}, outputTokens=${event.usage?.outputTokens}, textLen=${event.text?.length}`);
 								},
@@ -29784,6 +29947,7 @@ var ReflectorRunner = class {
 			}), {
 				label: "reflector",
 				abortSignal,
+				idleTimeoutMs: RETRY_CONFIG.modelCallIdleTimeoutMs,
 				maxRetries: this.reflectionConfig.maxRetries
 			});
 			omDebug(`[OM:callReflector] attempt #${attemptNumber} returned: textLen=${result.text?.length}, textPreview="${result.text?.slice(0, 120)}...", inputTokens=${result.usage?.inputTokens ?? result.totalUsage?.inputTokens}, outputTokens=${result.usage?.outputTokens ?? result.totalUsage?.outputTokens}`);
@@ -29891,10 +30055,11 @@ var ReflectorRunner = class {
 		if (this.buffering.isAsyncBufferingInProgress(bufferKey)) return;
 		BufferingCoordinator.lastBufferedBoundary.set(bufferKey, observationTokens);
 		registerOp(record.id, "bufferingReflection");
-		this.storage.setBufferingReflectionFlag(record.id, true).catch((err) => {
+		const flagSet = this.storage.setBufferingReflectionFlag(record.id, true).catch((err) => {
 			omError("[OM] Failed to set buffering reflection flag", err);
 		});
 		const asyncOp = (async () => {
+			await flagSet;
 			let outcome;
 			let reflectionError;
 			try {
@@ -29935,12 +30100,13 @@ var ReflectorRunner = class {
 				}
 				BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
 				unregisterOp(record.id, "bufferingReflection");
-				this.storage.setBufferingReflectionFlag(record.id, false).catch((err) => {
+				await this.storage.setBufferingReflectionFlag(record.id, false).catch((err) => {
 					omError("[OM] Failed to clear buffering reflection flag", err);
 				});
 			}
 		})();
 		BufferingCoordinator.asyncBufferingOps.set(bufferKey, asyncOp);
+		this.trackBackgroundWork?.(asyncOp, lockKey);
 	}
 	/**
 	* Perform async buffered reflection — reflects observations and stores to bufferedReflection.
@@ -30968,32 +31134,44 @@ var ObservationalMemory = class ObservationalMemory {
 	* 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();
+	pendingBackgroundWork = /* @__PURE__ */ new Map();
 	/**
 	* Register fire-and-forget background work so `settled()` can join it.
+	* `scope` is the conversation the work belongs to (thread/resource ids, or a lock key from
+	* `buffering.getLockKey`),
+	* so a scoped `settled()` can wait for one conversation without waiting for every other.
 	* Returns the original promise so callers keep their own rejection handling.
 	*/
-	trackBackgroundWork(work) {
+	trackBackgroundWork(work, scope) {
+		const lockKey = typeof scope === "string" ? scope : this.buffering.getLockKey(scope.threadId, scope.resourceId);
 		const tracked = work.catch(() => {}).finally(() => {
 			this.pendingBackgroundWork.delete(tracked);
 		});
-		this.pendingBackgroundWork.add(tracked);
+		this.pendingBackgroundWork.set(tracked, lockKey);
 		return work;
 	}
 	/**
-	* Resolve once all background observational-memory work started so far has finished.
+	* Resolve once background observational-memory work started so far has finished.
+	*
+	* Pass `threadId`/`resourceId` to wait only for that conversation's work. An engine shared by
+	* many busy threads may never be fully idle, so an unscoped wait can last indefinitely there.
+	* A scope without the id this engine keys work on (`resourceId` for resource scope, `threadId`
+	* for thread scope) can't be matched to its work, so it falls back to waiting for all work.
 	*
 	* 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() {
+	async settled(scope) {
+		const lockKey = (this.scope === "resource" ? scope?.resourceId : scope?.threadId) ? this.buffering.getLockKey(scope.threadId, scope.resourceId) : void 0;
+		const pending = () => [...this.pendingBackgroundWork].filter(([, key]) => lockKey === void 0 || key === lockKey).map(([w]) => w);
 		const maxDrainRounds = 100;
 		for (let round = 0; round < maxDrainRounds; round++) {
-			if (this.pendingBackgroundWork.size === 0) return;
-			await Promise.allSettled([...this.pendingBackgroundWork]);
+			const work = pending();
+			if (work.length === 0) return;
+			await Promise.allSettled(work);
 		}
-		if (this.pendingBackgroundWork.size === 0) return;
+		if (pending().length === 0) return;
 		omError(`[OM:settled] background work still pending after ${maxDrainRounds} drain rounds; giving up waiting`);
 	}
 	/**
@@ -31149,7 +31327,8 @@ var ObservationalMemory = class ObservationalMemory {
 			mastra: config.mastra,
 			memory: this.memory,
 			onReflectionCommitted: config.onReflectionCommitted,
-			hooks: this.hooks
+			hooks: this.hooks,
+			trackBackgroundWork: (work, lockKey) => this.trackBackgroundWork(work, lockKey)
 		});
 		this.validateBufferConfig();
 		if (this.scope === "resource" && !hasWarnedResourceScopeDeprecation) {
@@ -32005,11 +32184,12 @@ ${formattedMessages}
 		}).finally(() => {
 			if (BufferingCoordinator.asyncBufferingOps.get(bufferKey) === asyncOp) BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
 			unregisterOp(record.id, "bufferingObservation");
-			runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, false)).catch((err) => {
+			return runOMCommit(lockKey, () => this.storage.setBufferingObservationFlag(record.id, false)).catch((err) => {
 				omError("[OM] Failed to clear buffering observation flag", err);
 			});
 		});
 		BufferingCoordinator.asyncBufferingOps.set(bufferKey, asyncOp);
+		return { op: asyncOp };
 	}
 	/**
 	* Internal method that waits for existing buffering operation and then runs new buffering.
@@ -32109,7 +32289,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.trackBackgroundWork(this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext, opts.observabilityContext));
+		if (shouldTrigger) this.trackBackgroundWork(this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext, opts.observabilityContext).then(({ op }) => op), lockKey);
 		return shouldTrigger;
 	}
 	isMessageList(value) {
@@ -34161,9 +34341,9 @@ var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 	* await store.close();
 	* ```
 	*/
-	async settled() {
+	async settled(scope) {
 		await this.pendingVectorCleanup;
-		await (this._omEngine ? await this._omEngine : this._omEngineInstance)?.settled();
+		await (this._omEngine ? await this._omEngine : this._omEngineInstance)?.settled(scope);
 		await this.pendingVectorCleanup;
 	}
 	/** The shared ObservationalMemory engine. Lazily created on first access. */
@@ -36757,4 +36937,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-CJiR-m2F.cjs.map
+//# sourceMappingURL=src-BGgY5kgl.cjs.map