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

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

@@ -28598,6 +28598,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,
@@ -28705,13 +28706,27 @@ var ObservationStep = class {
 		}
 		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 +28737,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 +28775,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 +28803,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 +28832,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 +29011,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 +29087,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. */
@@ -29618,6 +29697,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 +29714,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;
@@ -29891,10 +29972,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 +30017,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);
 	}
 	/**
 	* Perform async buffered reflection — reflects observations and stores to bufferedReflection.
@@ -31149,7 +31232,8 @@ var ObservationalMemory = class ObservationalMemory {
 			mastra: config.mastra,
 			memory: this.memory,
 			onReflectionCommitted: config.onReflectionCommitted,
-			hooks: this.hooks
+			hooks: this.hooks,
+			trackBackgroundWork: (work) => this.trackBackgroundWork(work)
 		});
 		this.validateBufferConfig();
 		if (this.scope === "resource" && !hasWarnedResourceScopeDeprecation) {
@@ -36757,4 +36841,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-CJiR-m2F.cjs.map
+//# sourceMappingURL=src-GHUZVCL8.cjs.map