@mastra/server 1.60.0-alpha.7 → 1.60.0-alpha.9

package/dist/{dist-Bpz9F_9G.js → dist-DNaReo7-.js}

@@ -13,9 +13,9 @@ import { MastraMemory, getThreadOMMetadata, parseMemoryRequestContext, setThread
 import { Agent, MessageList, isSupportedLanguageModel, tryGenerateWithJsonFallback, tryStreamWithJsonFallback } from "@mastra/core/agent";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
 import { ModelRouterLanguageModel, modelSupportsAttachments, resolveModelConfig } from "@mastra/core/llm";
+import { createTool } from "@mastra/core/tools";
 import { inspect, promisify } from "util";
 import { createHash, randomBytes, randomUUID } from "crypto";
-import { createTool } from "@mastra/core/tools";
 import { generateEmptyFromSchema } from "@mastra/core/utils";
 import { InMemoryStore } from "@mastra/core/storage";
 import { coreFeatures } from "@mastra/core/features";
@@ -4693,7 +4693,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-BUlG9vaB.js
+//#region ../memory/dist/src-C-nmWgoF.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -24465,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;
@@ -26822,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,
@@ -26833,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;
@@ -27199,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,
@@ -27213,7 +27214,7 @@ var ObservationTurn = class {
 				skipMinimumTokenCheck: true
 			}).catch((err) => {
 				omDebug(`[OM:turn.end] idle buffer failed: ${err?.message}`);
-			});
+			}));
 		}
 		return { record: this._record };
 	}
@@ -27693,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;
@@ -27766,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,
@@ -28740,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.
 	*/
@@ -29740,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) {
@@ -30053,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(() => {});
 		}
 	}
 	/**
@@ -31540,6 +31584,25 @@ var Memory = class extends 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) => {
@@ -43683,4 +43746,4 @@ const agentBuilderWorkflows = {
 //#endregion
 export { agentBuilderWorkflows };
 
-//# sourceMappingURL=dist-Bpz9F_9G.js.map
+//# sourceMappingURL=dist-DNaReo7-.js.map