@mastra/memory 1.36.0-alpha.3 → 1.36.0-alpha.6

package/dist/{src-BBl5Qedz.cjs → src-DwfyRK9Q.cjs}

@@ -18805,8 +18805,38 @@ const TRANSIENT_MESSAGE_SUBSTRINGS = [
 	"request timed out",
 	"request timeout",
 	"connection reset",
-	"connection closed"
+	"connection closed",
+	"finished with finishreason \"other\""
 ];
+const INCOMPLETE_FINISH_REASONS = /* @__PURE__ */ new Set(["other", "unknown"]);
+/**
+* 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.
+*
+* @internal
+*/
+var OmIncompleteResponseError = class extends Error {
+	finishReason;
+	isRetryable = true;
+	constructor(label, finishReason) {
+		super(`${label} response ended early (finishReason: ${finishReason})`);
+		this.finishReason = finishReason;
+		this.name = "OmIncompleteResponseError";
+	}
+};
+/**
+* OM calls are single-step (`maxSteps: 1`). A step that ends with `other` or
+* `unknown` means the stream closed before the model finished, so its text is
+* partial. Throw a retryable error so `withRetry` re-runs the whole call
+* instead of saving it.
+*
+* @internal
+*/
+function assertCompleteModelResponse(output, label) {
+	if (output.finishReason && INCOMPLETE_FINISH_REASONS.has(output.finishReason)) throw new OmIncompleteResponseError(label, output.finishReason);
+	return output;
+}
 function isRecord$5(value) {
 	return typeof value === "object" && value !== null;
 }
@@ -20043,8 +20073,9 @@ function stringifyToolResult(value) {
 }
 function resolveToolResultValue(part, invocationResult) {
 	const mastraMetadata = part?.providerMetadata?.mastra;
-	if (mastraMetadata && typeof mastraMetadata === "object" && "modelOutput" in mastraMetadata) return {
-		value: mastraMetadata.modelOutput,
+	const modelOutput = mastraMetadata && typeof mastraMetadata === "object" ? mastraMetadata.modelOutput : void 0;
+	if (modelOutput != null) return {
+		value: modelOutput,
 		usingStoredModelOutput: true
 	};
 	return {
@@ -21087,7 +21118,7 @@ function buildMultiThreadObserverContextPrompt(existingObservations, threadOrder
 */
 function parseMultiThreadObserverOutput(output, extractors = []) {
 	const threads = /* @__PURE__ */ new Map();
-	if (detectDegenerateRepetition(output)) return {
+	if (detectDegenerateRepetition(sanitizeObservationLines(output))) return {
 		threads,
 		rawOutput: output,
 		degenerate: true
@@ -21193,7 +21224,7 @@ function getStringExtractedValue$1(values, slug) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function parseObserverOutput(output, extractors = []) {
-	if (detectDegenerateRepetition(output)) return {
+	if (detectDegenerateRepetition(sanitizeObservationLines(output))) return {
 		observations: "",
 		rawOutput: output,
 		degenerate: true
@@ -21256,6 +21287,34 @@ const MAX_OBSERVATION_LINE_CHARS = 1e4;
 */
 const MIN_DUPLICATE_LINE_CHARS = 24;
 /**
+* Collapse a run of back-to-back identical lines to a single line when that
+* run is the line's only occurrence and is no bigger than one maximum-length
+* observation line. A faithful summary of a repetitive tool loop (e.g. 30×
+* "pnpm --filter … build → ok") produces exactly that shape at any line
+* length. Loops are left intact: a model stuck on one line runs far past the
+* size bound, and a line that keeps recurring between other lines has more
+* than one run.
+*/
+function collapseBoundedLineRuns(lines) {
+	const runs = [];
+	for (const line of lines) {
+		const last = runs[runs.length - 1];
+		if (last && last.line === line) last.count++;
+		else runs.push({
+			line,
+			count: 1
+		});
+	}
+	const runsPerLine = /* @__PURE__ */ new Map();
+	for (const run of runs) runsPerLine.set(run.line, (runsPerLine.get(run.line) ?? 0) + 1);
+	const result = [];
+	for (const run of runs) {
+		const collapse = runsPerLine.get(run.line) === 1 && run.count * (run.line.length + 1) <= MAX_OBSERVATION_LINE_CHARS;
+		for (let j = 0; j < (collapse ? 1 : run.count); j++) result.push(run.line);
+	}
+	return result;
+}
+/**
 * Truncate individual observation lines that exceed the maximum length.
 */
 function sanitizeObservationLines(observations) {
@@ -21268,31 +21327,28 @@ function sanitizeObservationLines(observations) {
 	}
 	return changed ? lines.join("\n") : observations;
 }
-/**
-* Detect degenerate repetition in observer/reflector output.
-* Returns true if the text contains suspicious levels of repeated content,
-* which indicates an LLM repeat-penalty bug (e.g., Gemini Flash looping).
-*
-* Strategy: sample sequential chunks of the text and check if a high
-* proportion are near-identical to previous chunks.
-*/
-function detectDegenerateRepetition(text) {
-	if (!text || text.length < 2e3) return false;
+function analyzeDegenerateRepetition(text) {
+	const lines = collapseBoundedLineRuns(text.split("\n"));
+	const windowText = lines.filter((line) => line.trim().length >= MIN_DUPLICATE_LINE_CHARS && line.length <= MAX_OBSERVATION_LINE_CHARS).join("\n");
 	const windowSize = 200;
-	const step = Math.max(1, Math.floor(text.length / 50));
+	const step = Math.max(1, Math.floor(windowText.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);
+	let topWindow = "";
+	let topWindowCount = 0;
+	for (let i = 0; i + windowSize <= windowText.length; i += step) {
+		const window = windowText.slice(i, i + windowSize);
 		totalWindows++;
 		const count = (seen.get(window) ?? 0) + 1;
 		seen.set(window, count);
 		if (count > 1) duplicateWindows++;
+		if (count > topWindowCount) {
+			topWindowCount = count;
+			topWindow = window;
+		}
 	}
-	if (totalWindows > 5 && duplicateWindows / totalWindows > .4) return true;
-	const lines = text.split("\n");
-	for (const line of lines) if (line.length > 5e4) return true;
+	const windowFired = windowText.length >= 2e3 && totalWindows > 5 && duplicateWindows / totalWindows > .4;
 	const seenLines = /* @__PURE__ */ new Map();
 	let duplicateLines = 0;
 	let totalCountedLines = 0;
@@ -21304,8 +21360,50 @@ function detectDegenerateRepetition(text) {
 		seenLines.set(trimmed, count);
 		if (count > 1) duplicateLines++;
 	}
-	if (totalCountedLines >= 20 && duplicateLines / totalCountedLines > .5) return true;
-	return false;
+	const lineFired = totalCountedLines >= 20 && duplicateLines / totalCountedLines > .5;
+	let shortLineFired = false;
+	let shortLineCounts = /* @__PURE__ */ new Map();
+	const runExceedsBudget = () => {
+		let repeatedShortChars = 0;
+		for (const { count, chars } of shortLineCounts.values()) if (count > 1) repeatedShortChars += chars;
+		return repeatedShortChars - 1 > MAX_OBSERVATION_LINE_CHARS;
+	};
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		if (trimmed.length >= MIN_DUPLICATE_LINE_CHARS) {
+			if (runExceedsBudget()) shortLineFired = true;
+			shortLineCounts = /* @__PURE__ */ new Map();
+			continue;
+		}
+		if (/^<\/?[A-Za-z][\w-]*(?:\s[^<>]*)?>$/.test(trimmed) || trimmed.startsWith("Date:")) continue;
+		const entry = shortLineCounts.get(trimmed) ?? {
+			count: 0,
+			chars: 0
+		};
+		entry.count++;
+		entry.chars += line.length + 1;
+		shortLineCounts.set(trimmed, entry);
+	}
+	if (runExceedsBudget()) shortLineFired = true;
+	const eligible = text.length >= 2e3;
+	return {
+		windowText,
+		totalWindows,
+		duplicateWindows,
+		topWindow,
+		topWindowCount,
+		totalCountedLines,
+		duplicateLines,
+		windowFired: eligible && windowFired,
+		lineFired: eligible && lineFired,
+		shortLineFired: eligible && shortLineFired
+	};
+}
+function detectDegenerateRepetition(text) {
+	if (!text || text.length < 2e3) return false;
+	const analysis = analyzeDegenerateRepetition(text);
+	return analysis.windowFired || analysis.lineFired || analysis.shortLineFired;
 }
 /**
 * Build a single-line diagnostic description of output flagged by
@@ -21314,55 +21412,35 @@ function detectDegenerateRepetition(text) {
 * 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.
+* Runs the detector's analysis on the same sanitized text the detector judges
+* (giant lines truncated), so `strategy=` names what triggered the rejection.
+* For a short-line loop the window and line ratios read n/a or low, because
+* short lines are excluded from both. `length` and `longestLine` describe the
+* raw output. 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;
-	}
+	const a = analyzeDegenerateRepetition(sanitizeObservationLines(text));
 	let longestLine = 0;
-	const seenLines = /* @__PURE__ */ new Map();
-	let duplicateLines = 0;
-	let totalCountedLines = 0;
-	for (const line of text.split("\n")) {
-		if (line.length > longestLine) longestLine = line.length;
-		const trimmed = line.trim();
-		if (trimmed.length < MIN_DUPLICATE_LINE_CHARS) continue;
-		totalCountedLines++;
-		const count = (seenLines.get(trimmed) ?? 0) + 1;
-		seenLines.set(trimmed, count);
-		if (count > 1) duplicateLines++;
-	}
-	const duplicateRatio = totalWindows > 0 ? (duplicateWindows / totalWindows).toFixed(2) : "n/a";
-	const duplicateLineRatio = totalCountedLines > 0 ? (duplicateLines / totalCountedLines).toFixed(2) : "n/a";
+	for (const line of text.split("\n")) if (line.length > longestLine) longestLine = line.length;
+	const fired = [
+		a.windowFired && "window",
+		a.lineFired && "duplicateLines",
+		a.shortLineFired && "shortLineLoop"
+	].filter(Boolean).join("+") || "none";
+	const duplicateRatio = a.totalWindows > 0 ? (a.duplicateWindows / a.totalWindows).toFixed(2) : "n/a";
+	const duplicateLineRatio = a.totalCountedLines > 0 ? (a.duplicateLines / a.totalCountedLines).toFixed(2) : "n/a";
 	const parts = [
+		`strategy=${fired}`,
 		`length=${text.length}`,
-		`sampledWindows=${totalWindows}`,
+		`windowTextLength=${a.windowText.length}`,
+		`sampledWindows=${a.totalWindows}`,
 		`duplicateRatio=${duplicateRatio}`,
 		`duplicateLineRatio=${duplicateLineRatio}`,
-		`countedLines=${totalCountedLines}`,
+		`countedLines=${a.totalCountedLines}`,
 		`longestLine=${longestLine}`,
-		`topWindowCount=${topCount}`
+		`topWindowCount=${a.topWindowCount}`
 	];
-	if (topCount > 1) parts.push(`topWindow=${JSON.stringify(topWindow)}`);
+	if (a.topWindowCount > 1) parts.push(`topWindow=${JSON.stringify(a.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(" ");
@@ -21417,20 +21495,20 @@ function optimizeObservationsForContext(observations) {
 //#endregion
 //#region src/processors/observational-memory/temporary-memory.ts
 function createTemporaryOmMemoryContext(prefix) {
-	const options = {
-		thread: `${prefix}-${globalThis.crypto.randomUUID()}`,
-		resource: prefix,
-		options: {
-			lastMessages: 10,
-			generateTitle: false
-		}
+	const memoryOptions = {
+		lastMessages: 10,
+		generateTitle: false
 	};
 	return {
 		memory: new Memory({
 			storage: new _mastra_core_storage.InMemoryStore(),
-			options: options.options
+			options: memoryOptions
 		}),
-		options
+		newThread: () => ({
+			thread: `${prefix}-${globalThis.crypto.randomUUID()}`,
+			resource: prefix,
+			options: memoryOptions
+		})
 	};
 }
 //#endregion
@@ -21575,6 +21653,7 @@ var ObserverRunner = class {
 			id: isMultiThread ? "multi-thread-observer" : "observational-memory-observer",
 			name: isMultiThread ? "multi-thread-observer" : "Observer",
 			maxRetries: 0,
+			errorProcessorDefaults: false,
 			instructions: buildObserverSystemPrompt(isMultiThread, this.observationConfig.instruction, this.observationConfig.threadTitle, extractors),
 			model: agentModel,
 			...memory ? { memory } : {},
@@ -21663,6 +21742,7 @@ var ObserverRunner = class {
 		const temporaryMemory = activeExtractors.filter((extractor) => extractor.mode === "structured").length > 0 ? await createTemporaryOmMemoryContext("structured-observer") : void 0;
 		const agent = temporaryMemory ? this.createAgent(resolvedModel.model, false, temporaryMemory.memory, activeExtractors) : this.createAgent(resolvedModel.model, false, void 0, activeExtractors);
 		const internalRequestContext = withOmInternalThreadId(options?.requestContext, agent.id);
+		let attemptMemory;
 		const attachmentFilter = this.resolveAttachmentFilter(resolvedModel.model, options?.requestContext);
 		const observerMessages = [buildObserverRequestMessage(existingObservations, messagesToObserve, {
 			...options,
@@ -21690,14 +21770,16 @@ var ObserverRunner = class {
 				},
 				callback: (childObservabilityContext) => this.withAbortCheck(async () => {
 					try {
-						return await (await agent.stream(observerMessages, {
+						attemptMemory = temporaryMemory?.newThread();
+						return assertCompleteModelResponse(await (await agent.stream(observerMessages, {
+							maxSteps: 1,
 							modelSettings: { ...this.observationConfig.modelSettings },
 							providerOptions: this.observationConfig.providerOptions,
-							...temporaryMemory ? { memory: temporaryMemory.options } : {},
+							...attemptMemory ? { memory: attemptMemory } : {},
 							...abortSignal ? { abortSignal } : {},
 							...internalRequestContext ? { requestContext: internalRequestContext } : {},
 							...childObservabilityContext
-						})).getFullOutput();
+						})).getFullOutput(), "OM observer");
 					} catch (error) {
 						this.mastra?.getLogger?.().error("OM observer provider call failed", {
 							diagnostic: formatOmError(error),
@@ -21736,7 +21818,7 @@ var ObserverRunner = class {
 			agent,
 			source: "observer",
 			extractors: activeExtractors,
-			memory: temporaryMemory?.options,
+			memory: attemptMemory,
 			priorExtractedValues: options?.priorExtractedValues,
 			requestContext: internalRequestContext,
 			observabilityContext: options?.observabilityContext,
@@ -21896,13 +21978,14 @@ var ObserverRunner = class {
 				},
 				callback: (childObservabilityContext) => this.withAbortCheck(async () => {
 					try {
-						return await (await agent.stream(observerMessages, {
+						return assertCompleteModelResponse(await (await agent.stream(observerMessages, {
+							maxSteps: 1,
 							modelSettings: { ...this.observationConfig.modelSettings },
 							providerOptions: this.observationConfig.providerOptions,
 							...abortSignal ? { abortSignal } : {},
 							...internalRequestContext ? { requestContext: internalRequestContext } : {},
 							...childObservabilityContext
-						})).getFullOutput();
+						})).getFullOutput(), "OM multi-thread observer");
 					} catch (error) {
 						this.mastra?.getLogger?.().error("OM multi-thread observer provider call failed", {
 							diagnostic: formatOmError(error),
@@ -26417,6 +26500,7 @@ function createObservationFailedMarker(params) {
 			tokensAttempted: params.tokensAttempted,
 			error: formatOmError(params.error),
 			...getOmFailureMetadata(params.error, params.failurePolicy ?? "abort"),
+			...params.retrying ? { retrying: true } : {},
 			recordId: params.recordId,
 			threadId: params.threadId
 		}
@@ -28713,7 +28797,7 @@ function getStringExtractedValue(values, slug) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function parseReflectorOutput(output, sourceObservations, extractors = []) {
-	if (detectDegenerateRepetition(output)) return {
+	if (detectDegenerateRepetition(sanitizeObservationLines(output))) return {
 		observations: "",
 		degenerate: true
 	};
@@ -28906,6 +28990,7 @@ var ReflectorRunner = class {
 			instructions: buildReflectorSystemPrompt(this.reflectionConfig.instruction, extractors),
 			model: agentModel,
 			maxRetries: 0,
+			errorProcessorDefaults: false,
 			...memory ? { memory } : {},
 			...this.mastra ? { mastra: this.mastra } : {}
 		});
@@ -28946,6 +29031,7 @@ var ReflectorRunner = class {
 		const temporaryMemory = activeExtractors.filter((extractor) => extractor.mode === "structured").length > 0 ? await createTemporaryOmMemoryContext("structured-reflector") : void 0;
 		const agent = temporaryMemory ? this.createAgent(resolvedModel.model, temporaryMemory.memory, activeExtractors) : this.createAgent(resolvedModel.model, void 0, activeExtractors);
 		const internalRequestContext = withOmInternalThreadId(requestContext, agent.id);
+		let attemptMemory;
 		const targetThreshold = observationTokensThreshold ?? getMaxThreshold(this.reflectionConfig.observationTokens);
 		let totalUsage = {
 			inputTokens: 0,
@@ -28988,10 +29074,12 @@ var ReflectorRunner = class {
 				callback: (childObservabilityContext) => withAbortCheck(async () => {
 					chunkCount = 0;
 					try {
-						return await (await agent.stream(prompt, {
+						attemptMemory = temporaryMemory?.newThread();
+						return assertCompleteModelResponse(await (await agent.stream(prompt, {
+							maxSteps: 1,
 							modelSettings: { ...this.reflectionConfig.modelSettings },
 							providerOptions: this.reflectionConfig.providerOptions,
-							...temporaryMemory ? { memory: temporaryMemory.options } : {},
+							...attemptMemory ? { memory: attemptMemory } : {},
 							...abortSignal ? { abortSignal } : {},
 							...internalRequestContext ? { requestContext: internalRequestContext } : {},
 							...childObservabilityContext,
@@ -29013,7 +29101,7 @@ var ReflectorRunner = class {
 									omError(`[OM:callReflector] onError after ${chunkCount} chunks`, error);
 								}
 							} : {}
-						})).getFullOutput();
+						})).getFullOutput(), "OM reflector");
 					} catch (error) {
 						if (abortSignal?.aborted || !isOmModelExecutionFailure(error)) throw error;
 						throw new OmModelExecutionError("reflector-model", error);
@@ -29054,6 +29142,7 @@ var ReflectorRunner = class {
 					startedAt: streamContext.startedAt,
 					tokensAttempted: originalTokens,
 					error: `Did not compress below threshold (${originalTokens} → ${reflectedTokens}, target: ${targetThreshold}), retrying at level ${currentLevel + 1}`,
+					retrying: true,
 					recordId: streamContext.recordId,
 					threadId: streamContext.threadId
 				});
@@ -29087,7 +29176,7 @@ var ReflectorRunner = class {
 			agent,
 			source: "reflector",
 			extractors: activeExtractors,
-			memory: temporaryMemory?.options,
+			memory: attemptMemory,
 			priorExtractedValues,
 			requestContext: internalRequestContext,
 			observabilityContext,
@@ -35611,4 +35700,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-BBl5Qedz.cjs.map
+//# sourceMappingURL=src-DwfyRK9Q.cjs.map