@mastra/memory 1.27.0-alpha.3 → 1.27.1-alpha.0

package/dist/{src-Ik0ksTOt.cjs → src-bE5dqCVp.cjs}

@@ -18966,6 +18966,52 @@ function detectDegenerateRepetition(text) {
 	return false;
 }
 /**
+* Build a single-line diagnostic description of output flagged by
+* {@link detectDegenerateRepetition}. Used when logging or surfacing a
+* degenerate-output failure so the discarded model output can be inspected —
+* without it there is no way to tell a real repetition loop apart from a
+* detector false-positive on legitimately repetitive content.
+*
+* Reuses the detector's sampling parameters (200-char windows, ~50 samples)
+* so the reported duplicate ratio and most-repeated window match what
+* triggered the detection. Snippets are JSON-escaped so the result stays on
+* one line.
+*/
+function describeDegenerateOutput(text, snippetChars = 400) {
+	const windowSize = 200;
+	const step = Math.max(1, Math.floor(text.length / 50));
+	const seen = /* @__PURE__ */ new Map();
+	let duplicateWindows = 0;
+	let totalWindows = 0;
+	for (let i = 0; i + windowSize <= text.length; i += step) {
+		const window = text.slice(i, i + windowSize);
+		totalWindows++;
+		const count = (seen.get(window) ?? 0) + 1;
+		seen.set(window, count);
+		if (count > 1) duplicateWindows++;
+	}
+	let topWindow = "";
+	let topCount = 0;
+	for (const [window, count] of seen) if (count > topCount) {
+		topCount = count;
+		topWindow = window;
+	}
+	let longestLine = 0;
+	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 parts = [
+		`length=${text.length}`,
+		`sampledWindows=${totalWindows}`,
+		`duplicateRatio=${duplicateRatio}`,
+		`longestLine=${longestLine}`,
+		`topWindowCount=${topCount}`
+	];
+	if (topCount > 1) parts.push(`topWindow=${JSON.stringify(topWindow)}`);
+	parts.push(`head=${JSON.stringify(text.slice(0, snippetChars))}`);
+	if (text.length > snippetChars * 2) parts.push(`tail=${JSON.stringify(text.slice(-snippetChars))}`);
+	return parts.join(" ");
+}
+/**
 * Check if observations contain a Current Task section.
 * Supports both XML format and legacy markdown format.
 */
@@ -19230,7 +19276,19 @@ async function withOmTracingSpan({ phase, model, inputTokens, requestContext, ob
 	});
 	const childObservabilityContext = (0, _mastra_core_observability.createObservabilityContext)({ currentSpan: span });
 	if (!span) return callback(childObservabilityContext);
-	return span.executeInContext(() => callback(childObservabilityContext));
+	return span.executeInContext(async () => {
+		try {
+			const result = await callback(childObservabilityContext);
+			span.end();
+			return result;
+		} catch (error) {
+			span.error({
+				error,
+				endSpan: true
+			});
+			throw error;
+		}
+	});
 }
 //#endregion
 //#region src/processors/observational-memory/observer-runner.ts
@@ -19368,13 +19426,13 @@ var ObserverRunner = class {
 		let parsed = parseObserverOutput(result.text, activeExtractors);
 		let retriedDueToDegenerate = false;
 		if (parsed.degenerate) {
-			omDebug(`[OM:callObserver] degenerate repetition detected, retrying once`);
+			omDebug(`[OM:callObserver] degenerate repetition detected, retrying once. ${describeDegenerateOutput(result.text, 2e3)}`);
 			result = await doGenerate();
 			parsed = parseObserverOutput(result.text, activeExtractors);
 			retriedDueToDegenerate = true;
 			if (parsed.degenerate) {
-				omDebug(`[OM:callObserver] degenerate repetition on retry, failing`);
-				throw new Error("Observer produced degenerate output after retry");
+				omDebug(`[OM:callObserver] degenerate repetition on retry, failing. ${describeDegenerateOutput(result.text, 2e3)}`);
+				throw new Error(`Observer produced degenerate output after retry. ${describeDegenerateOutput(result.text)}`);
 			}
 		}
 		const structuredExtraction = await extractStructuredValues({
@@ -19518,13 +19576,13 @@ var ObserverRunner = class {
 		let parsed = parseMultiThreadObserverOutput(result.text, activeExtractors);
 		let retriedDueToDegenerate = false;
 		if (parsed.degenerate) {
-			omDebug(`[OM:callMultiThreadObserver] degenerate repetition detected, retrying once`);
+			omDebug(`[OM:callMultiThreadObserver] degenerate repetition detected, retrying once. ${describeDegenerateOutput(result.text, 2e3)}`);
 			result = await doGenerate();
 			parsed = parseMultiThreadObserverOutput(result.text, activeExtractors);
 			retriedDueToDegenerate = true;
 			if (parsed.degenerate) {
-				omDebug(`[OM:callMultiThreadObserver] degenerate repetition on retry, failing`);
-				throw new Error("Multi-thread observer produced degenerate output after retry");
+				omDebug(`[OM:callMultiThreadObserver] degenerate repetition on retry, failing. ${describeDegenerateOutput(result.text, 2e3)}`);
+				throw new Error(`Multi-thread observer produced degenerate output after retry. ${describeDegenerateOutput(result.text)}`);
 			}
 		}
 		const structuredExtractionByThread = /* @__PURE__ */ new Map();
@@ -24367,10 +24425,11 @@ ObservationStrategy.create = ((om, opts) => {
 });
 //#endregion
 //#region src/processors/observational-memory/observation-turn/load-memory-context.ts
-async function loadMemoryContextMessages({ memory, messageList, threadId, resourceId }) {
+async function loadMemoryContextMessages({ memory, messageList, threadId, resourceId, runState }) {
 	const ctx = await memory.getContext({
 		threadId,
-		resourceId
+		resourceId,
+		runState
 	});
 	for (const msg of ctx.messages) if (msg.role !== "system") messageList.add(msg, "memory");
 	return ctx;
@@ -24828,10 +24887,11 @@ var ObservationTurn = class {
 	* If a MemoryContextProvider is passed, loads historical messages and adds
 	* them to the MessageList. Without a provider, only fetches/caches the record.
 	*/
-	async start(memory) {
+	async start(memory, runState) {
 		if (this._started) throw new Error("Turn already started");
 		this._started = true;
 		this._record = await this.om.getOrCreateRecord(this.threadId, this.resourceId);
+		runState?.set(`observational-memory:record:${this.threadId}:${this.resourceId ?? ""}`, this._record);
 		this._generationCountAtStart = this._record.generationCount;
 		this.memory = memory;
 		if (memory) {
@@ -24839,7 +24899,8 @@ var ObservationTurn = class {
 				memory,
 				messageList: this.messageList,
 				threadId: this.threadId,
-				resourceId: this.resourceId
+				resourceId: this.resourceId,
+				runState
 			});
 			this._context = {
 				messages: ctx.messages,
@@ -25467,7 +25528,7 @@ var ReflectorRunner = class {
 			finalProviderMetadata = result.providerMetadata ?? finalProviderMetadata;
 			parsed = parseReflectorOutput(result.text, observations, activeExtractors);
 			if (parsed.degenerate) {
-				omDebug(`[OM:callReflector] attempt #${attemptNumber}: degenerate repetition detected, treating as compression failure`);
+				omDebug(`[OM:callReflector] attempt #${attemptNumber}: degenerate repetition detected, treating as compression failure. ${describeDegenerateOutput(result.text, 2e3)}`);
 				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}`);
@@ -28921,7 +28982,9 @@ var ObservationalMemoryProcessor = class {
 			return messageList;
 		}
 		const { threadId, resourceId } = context;
-		const readOnly = (0, _mastra_core_memory.parseMemoryRequestContext)(requestContext)?.memoryConfig?.readOnly;
+		const memoryContext = (0, _mastra_core_memory.parseMemoryRequestContext)(requestContext);
+		const runState = memoryContext?.runState?.();
+		const readOnly = memoryContext?.memoryConfig?.readOnly;
 		const actorModelContext = model?.modelId ? {
 			provider: model.provider,
 			modelId: model.modelId,
@@ -28938,7 +29001,8 @@ var ObservationalMemoryProcessor = class {
 					memory: this.memory,
 					messageList,
 					threadId,
-					resourceId
+					resourceId,
+					runState
 				});
 				const systemMessages = ctx.omRecord ? await this.engine.buildContextSystemMessages({
 					threadId,
@@ -28979,7 +29043,7 @@ var ObservationalMemoryProcessor = class {
 				this.turn.sendStateSignal = args.sendStateSignal;
 				this.turn.agent = args.agent;
 				this.turn.requestContext = requestContext;
-				await this.turn.start(this.memory);
+				await this.turn.start(this.memory, runState);
 				if (stepNumber === 0 && this.temporalMarkers) await insertTemporalGapMarkers({
 					messageList,
 					sendSignal: args.sendSignal
@@ -30149,14 +30213,18 @@ ${workingMemory}`;
 		if (!this.threadConfig.workingMemory?.enabled) return null;
 		return extractWorkingMemoryContent(text)?.trim() ?? null;
 	}
-	async getWorkingMemory({ threadId, resourceId, memoryConfig }) {
+	async getWorkingMemory({ threadId, resourceId, memoryConfig, runState }) {
 		const config = this.getMergedThreadConfig(memoryConfig || {});
 		if (!config.workingMemory?.enabled) return null;
 		const scope = config.workingMemory.scope || "resource";
 		let workingMemoryData = null;
 		if (scope === "resource" && !resourceId) throw new Error("Memory error: Resource-scoped working memory is enabled but no resourceId was provided. Either provide a resourceId or explicitly set workingMemory.scope to 'thread'.");
-		if (scope === "resource" && resourceId) workingMemoryData = (await (await this.getMemoryStore()).getResourceById({ resourceId }))?.workingMemory || null;
-		else workingMemoryData = (await this.getThreadById({ threadId }))?.metadata?.workingMemory;
+		if (scope === "resource" && resourceId) {
+			const loadWorkingMemory = async () => {
+				return (await (await this.getMemoryStore()).getResourceById({ resourceId }))?.workingMemory || null;
+			};
+			workingMemoryData = runState ? await runState.load(`working-memory:resource:${resourceId}`, loadWorkingMemory) : await loadWorkingMemory();
+		} else workingMemoryData = (runState?.threadLoaded ? runState.thread : await this.getThreadById({ threadId }))?.metadata?.workingMemory;
 		if (!workingMemoryData) return null;
 		return workingMemoryData;
 	}
@@ -30188,16 +30256,18 @@ ${workingMemory}`;
 			content: (config.workingMemory.template || this.defaultWorkingMemoryTemplate).trim()
 		};
 	}
-	async getSystemMessage({ threadId, resourceId, memoryConfig }) {
+	async getSystemMessage({ threadId, resourceId, memoryConfig, runState }) {
 		const config = this.getMergedThreadConfig(memoryConfig);
 		this.assertWorkingMemoryStateSignalsCompatibility(config);
 		if (!config.workingMemory?.enabled) return null;
 		if (config.workingMemory?.useStateSignals) return null;
-		const workingMemoryTemplate = await this.getWorkingMemoryTemplate({ memoryConfig });
+		const loadTemplate = () => this.getWorkingMemoryTemplate({ memoryConfig });
+		const workingMemoryTemplate = runState ? await runState.load("working-memory:template", loadTemplate) : await loadTemplate();
 		const workingMemoryData = await this.getWorkingMemory({
 			threadId,
 			resourceId,
-			memoryConfig: config
+			memoryConfig: config,
+			runState
 		});
 		if (!workingMemoryTemplate) return null;
 		const workingMemoryConfig = config.workingMemory;
@@ -30230,7 +30300,7 @@ ${workingMemory}`;
 	* ```
 	*/
 	async getContext(opts) {
-		const { threadId, resourceId, memoryConfig } = opts;
+		const { threadId, resourceId, memoryConfig, runState } = opts;
 		const config = this.getMergedThreadConfig(memoryConfig);
 		const memoryStore = await this.getMemoryStore();
 		const systemParts = [];
@@ -30240,10 +30310,14 @@ ${workingMemory}`;
 		let otherThreadsContext;
 		const omEngine = await this.omEngine;
 		if (omEngine) {
-			omRecord = await omEngine.getRecord(threadId, resourceId);
+			const loadOmRecord = () => omEngine.getRecord(threadId, resourceId);
+			omRecord = runState ? await runState.load(`observational-memory:record:${threadId}:${resourceId ?? ""}`, loadOmRecord) : await loadOmRecord();
 			if (omRecord?.activeObservations) {
 				hasObservations = true;
-				if (omEngine.scope === "resource" && resourceId) otherThreadsContext = await omEngine.getOtherThreadsContext(resourceId, threadId);
+				if (omEngine.scope === "resource" && resourceId) {
+					const loadOtherThreadsContext = () => omEngine.getOtherThreadsContext(resourceId, threadId);
+					otherThreadsContext = runState ? await runState.load(`observational-memory:other-threads:${resourceId}:${threadId}:${omRecord.lastObservedAt ?? ""}`, loadOtherThreadsContext) : await loadOtherThreadsContext();
+				}
 				const obsSystemMessage = await omEngine.buildContextSystemMessage({
 					threadId,
 					resourceId,
@@ -30271,30 +30345,41 @@ ${workingMemory}`;
 		const workingMemoryMessage = await this.getSystemMessage({
 			threadId,
 			resourceId,
-			memoryConfig: config
+			memoryConfig: config,
+			runState
 		});
 		if (workingMemoryMessage) systemParts.push(workingMemoryMessage);
 		let messages;
 		if (omEngine && omRecord) {
 			const dateFilter = omRecord.lastObservedAt ? { dateRange: { start: new Date(new Date(omRecord.lastObservedAt).getTime() + 1) } } : void 0;
-			if (omEngine.scope === "resource" && resourceId) messages = (await memoryStore.listMessagesByResourceId({
-				resourceId,
-				orderBy: {
-					field: "createdAt",
-					direction: "ASC"
-				},
-				perPage: false,
-				filter: dateFilter
-			})).messages;
-			else messages = (await memoryStore.listMessages({
-				threadId,
-				orderBy: {
-					field: "createdAt",
-					direction: "ASC"
-				},
-				perPage: false,
-				filter: dateFilter
-			})).messages;
+			const boundary = omRecord.lastObservedAt ? new Date(omRecord.lastObservedAt).toISOString() : "";
+			if (omEngine.scope === "resource" && resourceId) {
+				const loadMessages = async () => {
+					return (await memoryStore.listMessagesByResourceId({
+						resourceId,
+						orderBy: {
+							field: "createdAt",
+							direction: "ASC"
+						},
+						perPage: false,
+						filter: dateFilter
+					})).messages;
+				};
+				messages = runState ? await runState.load(`observational-memory:messages:resource:${resourceId}:${boundary}`, loadMessages) : await loadMessages();
+			} else {
+				const loadMessages = async () => {
+					return (await memoryStore.listMessages({
+						threadId,
+						orderBy: {
+							field: "createdAt",
+							direction: "ASC"
+						},
+						perPage: false,
+						filter: dateFilter
+					})).messages;
+				};
+				messages = runState ? await runState.load(`observational-memory:messages:thread:${threadId}:${boundary}`, loadMessages) : await loadMessages();
+			}
 		} else {
 			const lastMessages = config.lastMessages;
 			if (lastMessages === false) messages = [];
@@ -31599,4 +31684,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-Ik0ksTOt.cjs.map
+//# sourceMappingURL=src-bE5dqCVp.cjs.map