@mastra/memory 1.31.0-alpha.1 → 1.31.0-alpha.3

package/dist/{src-BCvV2aGL.cjs → src-QqTmOY5X.cjs}

@@ -52,7 +52,6 @@ let path = require("path");
 let _mastra_core_tools = require("@mastra/core/tools");
 let _mastra_core_request_context = require("@mastra/core/request-context");
 let _mastra_core_llm = require("@mastra/core/llm");
-let tokenx = require("tokenx");
 let async_hooks = require("async_hooks");
 let probe_image_size_sync_js = require("probe-image-size/sync.js");
 probe_image_size_sync_js = __toESM$1(probe_image_size_sync_js, 1);
@@ -18326,6 +18325,62 @@ function safeSlice(str, end) {
 	return str.slice(0, safeEnd);
 }
 //#endregion
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/tokenx/1.3.0/09093cdaeebfe25c39ba9052d6277b45fc99abf5e14e859f60f338f5c5160afd/node_modules/tokenx/dist/index.mjs
+const PATTERNS = {
+	whitespace: /^\s+$/,
+	cjk: /[\u4E00-\u9FFF\u3400-\u4DBF\u3000-\u303F\uFF00-\uFFEF\u30A0-\u30FF\u2E80-\u2EFF\u31C0-\u31EF\u3200-\u32FF\u3300-\u33FF\uAC00-\uD7AF\u1100-\u11FF\u3130-\u318F\uA960-\uA97F\uD7B0-\uD7FF]/,
+	numeric: /^\d+(?:[.,]\d+)*$/,
+	punctuation: /[.,!?;(){}[\]<>:/\\|@#$%^&*+=`~_-]/,
+	alphanumeric: /^[a-zA-Z0-9\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]+$/
+};
+const TOKEN_SPLIT_PATTERN = /* @__PURE__ */ new RegExp(`(\\s+|${PATTERNS.punctuation.source}+)`);
+const DEFAULT_CHARS_PER_TOKEN = 6;
+const SHORT_TOKEN_THRESHOLD = 3;
+const DEFAULT_LANGUAGE_CONFIGS = [
+	{
+		pattern: /[äöüßẞ]/i,
+		averageCharsPerToken: 3
+	},
+	{
+		pattern: /[éèêëàâîïôûùüÿçœæáíóúñ]/i,
+		averageCharsPerToken: 3
+	},
+	{
+		pattern: /[ąćęłńóśźżěščřžýůúďťň]/i,
+		averageCharsPerToken: 3.5
+	}
+];
+/**
+* Estimates the number of tokens in a text string using heuristic rules.
+*/
+function estimateTokenCount(text, options = {}) {
+	if (!text) return 0;
+	const { defaultCharsPerToken = DEFAULT_CHARS_PER_TOKEN, languageConfigs = DEFAULT_LANGUAGE_CONFIGS } = options;
+	const segments = text.split(TOKEN_SPLIT_PATTERN).filter(Boolean);
+	let tokenCount = 0;
+	for (const segment of segments) tokenCount += estimateSegmentTokens(segment, languageConfigs, defaultCharsPerToken);
+	return tokenCount;
+}
+function estimateSegmentTokens(segment, languageConfigs, defaultCharsPerToken) {
+	if (PATTERNS.whitespace.test(segment)) return 0;
+	if (PATTERNS.cjk.test(segment)) return getCharacterCount(segment);
+	if (PATTERNS.numeric.test(segment)) return 1;
+	if (segment.length <= SHORT_TOKEN_THRESHOLD) return 1;
+	if (PATTERNS.punctuation.test(segment)) return segment.length > 1 ? Math.ceil(segment.length / 2) : 1;
+	if (PATTERNS.alphanumeric.test(segment)) {
+		const charsPerToken$1 = getLanguageSpecificCharsPerToken(segment, languageConfigs) ?? defaultCharsPerToken;
+		return Math.ceil(segment.length / charsPerToken$1);
+	}
+	const charsPerToken = getLanguageSpecificCharsPerToken(segment, languageConfigs) ?? defaultCharsPerToken;
+	return Math.ceil(segment.length / charsPerToken);
+}
+function getLanguageSpecificCharsPerToken(segment, languageConfigs) {
+	for (const config of languageConfigs) if (config.pattern.test(segment)) return config.averageCharsPerToken;
+}
+function getCharacterCount(text) {
+	return Array.from(text).length;
+}
+//#endregion
 //#region src/processors/observational-memory/tool-argument-helpers.ts
 const DEFAULT_OBSERVER_TOOL_ARGUMENT_MAX_TOKENS = 2e3;
 const OBSERVER_TOOL_ARGUMENT_INLINE_STRING_MAX_CHARS = 160;
@@ -18459,7 +18514,7 @@ function readEntries(value) {
 	}
 }
 function fits(text, limits) {
-	return text.length <= limits.maxCharacters && (0, tokenx.estimateTokenCount)(text) <= limits.maxTokens;
+	return text.length <= limits.maxCharacters && estimateTokenCount(text) <= limits.maxTokens;
 }
 function joinEntries(entries, marker) {
 	const lines = [...entries].sort((a, b) => a.order - b.order).map((entry) => entry.text);
@@ -18473,7 +18528,7 @@ function selectOutlineEntries(entries, limits) {
 	const selected = [];
 	const candidates = [...entries].sort((a, b) => {
 		if (a.depth !== b.depth) return a.depth - b.depth;
-		return (0, tokenx.estimateTokenCount)(a.text) - (0, tokenx.estimateTokenCount)(b.text) || a.text.length - b.text.length || a.order - b.order;
+		return estimateTokenCount(a.text) - estimateTokenCount(b.text) || a.text.length - b.text.length || a.order - b.order;
 	});
 	for (const candidate of candidates) if (fits(joinEntries([...selected, candidate], marker), limits)) selected.push(candidate);
 	const rendered = joinEntries(selected, marker);
@@ -18651,10 +18706,10 @@ function formatToolArgumentsForObserver(value, options) {
 	let omittedPreviews = 0;
 	for (let index = 0; index < previews.length; index++) {
 		const remainingCount = previews.length - index;
-		const remainingTokens = Math.max(0, limits.maxTokens - (0, tokenx.estimateTokenCount)(rendered));
+		const remainingTokens = Math.max(0, limits.maxTokens - estimateTokenCount(rendered));
 		const remainingCharacters = Math.max(0, limits.maxCharacters - rendered.length - 1);
 		const previewLimits = {
-			maxTokens: (0, tokenx.estimateTokenCount)(rendered) + Math.floor(remainingTokens / remainingCount),
+			maxTokens: estimateTokenCount(rendered) + Math.floor(remainingTokens / remainingCount),
 			maxCharacters: rendered.length + 1 + Math.floor(remainingCharacters / remainingCount)
 		};
 		const preview = formatPreview(previews[index].path, previews[index].value, previewLimits, rendered);
@@ -18736,11 +18791,11 @@ function resolveToolResultValue(part, invocationResult) {
 }
 function truncateStringByTokens(text, maxTokens) {
 	if (!text || maxTokens <= 0) return "";
-	const totalTokens = (0, tokenx.estimateTokenCount)(text);
+	const totalTokens = estimateTokenCount(text);
 	if (totalTokens <= maxTokens) return text;
 	const buildCandidate = (sliceEnd) => {
 		const visible = safeSlice(text, sliceEnd);
-		return `${visible}\n... [truncated ~${totalTokens - (0, tokenx.estimateTokenCount)(visible)} tokens]`;
+		return `${visible}\n... [truncated ~${totalTokens - estimateTokenCount(visible)} tokens]`;
 	};
 	let low = 0;
 	let high = text.length;
@@ -18748,7 +18803,7 @@ function truncateStringByTokens(text, maxTokens) {
 	while (low <= high) {
 		const mid = Math.floor((low + high) / 2);
 		const candidate = buildCandidate(mid);
-		if ((0, tokenx.estimateTokenCount)(candidate) <= maxTokens) {
+		if (estimateTokenCount(candidate) <= maxTokens) {
 			best = candidate;
 			low = mid + 1;
 		} else high = mid - 1;
@@ -21616,7 +21671,7 @@ var TokenCounter = class TokenCounter {
 	*/
 	countString(text) {
 		if (!text) return 0;
-		return (0, tokenx.estimateTokenCount)(text);
+		return estimateTokenCount(text);
 	}
 	readOrPersistPartEstimate(part, kind, payload) {
 		const key = buildEstimateKey(kind, payload);
@@ -22544,7 +22599,7 @@ function formatTimestamp(date) {
 	return date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
 }
 function truncateByTokens(text, maxTokens, hint) {
-	if ((0, tokenx.estimateTokenCount)(text) <= maxTokens) return {
+	if (estimateTokenCount(text) <= maxTokens) return {
 		text,
 		wasTruncated: false
 	};
@@ -22558,7 +22613,7 @@ function chunkTextByTokens(text, maxTokens, charOffset = 0) {
 	const startCode = text.charCodeAt(startOffset);
 	if (startCode >= 56320 && startCode <= 57343) startOffset += 1;
 	const remaining = text.slice(startOffset);
-	if (!remaining || (0, tokenx.estimateTokenCount)(remaining) <= maxTokens) return {
+	if (!remaining || estimateTokenCount(remaining) <= maxTokens) return {
 		text: remaining,
 		charOffset: startOffset,
 		truncated: false
@@ -22569,7 +22624,7 @@ function chunkTextByTokens(text, maxTokens, charOffset = 0) {
 	while (low <= high) {
 		const mid = Math.floor((low + high) / 2);
 		const candidate = safeSlice(remaining, mid);
-		const candidateTokens = (0, tokenx.estimateTokenCount)(candidate);
+		const candidateTokens = estimateTokenCount(candidate);
 		if (candidate && candidateTokens <= maxTokens) {
 			best = candidate;
 			low = mid + 1;
@@ -22745,7 +22800,7 @@ function expandPriority(part) {
 }
 function renderFormattedParts(parts, timestamps, options) {
 	const text = buildRenderedText(parts, timestamps);
-	let totalTokens = (0, tokenx.estimateTokenCount)(text);
+	let totalTokens = estimateTokenCount(text);
 	if (totalTokens > options.maxTokens) return {
 		text: truncateStringByTokens(text, options.maxTokens),
 		truncated: true,
@@ -22764,8 +22819,8 @@ function renderFormattedParts(parts, timestamps, options) {
 	for (const { part, index } of truncatedIndices) {
 		if (remaining <= 0) break;
 		const maxTokens = expandLimit(part);
-		const fullTokens = (0, tokenx.estimateTokenCount)(part.fullText);
-		const currentTokens = (0, tokenx.estimateTokenCount)(part.text);
+		const fullTokens = estimateTokenCount(part.fullText);
+		const currentTokens = estimateTokenCount(part.text);
 		const targetTokens = Math.min(fullTokens, maxTokens);
 		const delta = targetTokens - currentTokens;
 		if (delta <= 0) continue;
@@ -22779,7 +22834,7 @@ function renderFormattedParts(parts, timestamps, options) {
 			const expandedLimit = Math.min(currentTokens + remaining, maxTokens);
 			const hint = `recall cursor="${part.messageId}" partIndex=${part.partIndex} detail="high"`;
 			const { text: expanded } = truncateByTokens(part.fullText, expandedLimit, hint);
-			const expandedDelta = (0, tokenx.estimateTokenCount)(expanded) - currentTokens;
+			const expandedDelta = estimateTokenCount(expanded) - currentTokens;
 			parts[index] = {
 				...part,
 				text: expanded
@@ -22788,7 +22843,7 @@ function renderFormattedParts(parts, timestamps, options) {
 		}
 	}
 	const expanded = buildRenderedText(parts, timestamps);
-	const expandedTokens = (0, tokenx.estimateTokenCount)(expanded);
+	const expandedTokens = estimateTokenCount(expanded);
 	if (expandedTokens <= options.maxTokens) return {
 		text: expanded,
 		truncated: false,
@@ -22800,13 +22855,13 @@ function renderFormattedParts(parts, timestamps, options) {
 		tokenOffset: expandedTokens - options.maxTokens
 	};
 }
-async function recallPart({ memory, threadId, resourceId, cursor, partIndex, charOffset, threadScope, maxTokens = DEFAULT_MAX_RESULT_TOKENS }) {
+async function recallPart({ memory, threadId, resourceId, cursor, partIndex, charOffset, threadScope, retrievalScope = "thread", maxTokens = DEFAULT_MAX_RESULT_TOKENS }) {
 	if (!memory || typeof memory.getMemoryStore !== "function") throw new Error("Memory instance is required for recall");
 	if (!threadId) throw new Error("Thread ID is required for recall");
 	const resolved = await resolveCursorMessage(memory, cursor, {
 		resourceId,
 		threadScope,
-		enforceThreadScope: false
+		enforceThreadScope: retrievalScope !== "resource"
 	});
 	if ("hint" in resolved) throw new Error(resolved.hint);
 	const allParts = formatMessageParts(resolved, "high");
@@ -22817,7 +22872,7 @@ async function recallPart({ memory, threadId, resourceId, cursor, partIndex, cha
 		if (partIndex > Math.max(...allParts.map((p) => p.partIndex))) {
 			const nextMessage = await getNextVisibleMessage({
 				memory,
-				threadId,
+				threadId: resolved.threadId ?? threadId,
 				resourceId,
 				after: resolved.createdAt
 			});
@@ -22856,7 +22911,7 @@ async function recallPart({ memory, threadId, resourceId, cursor, partIndex, cha
 		note
 	};
 }
-async function recallMessages({ memory, threadId, resourceId, cursor, page = 1, limit = 20, detail = "low", partType, toolName, threadScope, maxTokens = DEFAULT_MAX_RESULT_TOKENS }) {
+async function recallMessages({ memory, threadId, resourceId, cursor, page = 1, limit = 20, detail = "low", partType, toolName, threadScope, retrievalScope = "thread", maxTokens = DEFAULT_MAX_RESULT_TOKENS }) {
 	if (!memory) throw new Error("Memory instance is required for recall");
 	if (!threadId) throw new Error("Thread ID is required for recall");
 	if (typeof memory.getMemoryStore !== "function") throw new Error("recall requires a Memory instance with storage access");
@@ -22867,7 +22922,7 @@ async function recallMessages({ memory, threadId, resourceId, cursor, page = 1,
 	const resolved = await resolveCursorMessage(memory, cursor, {
 		resourceId,
 		threadScope,
-		enforceThreadScope: false
+		enforceThreadScope: retrievalScope === "thread"
 	});
 	if ("hint" in resolved) return {
 		messages: resolved.hint,
@@ -22884,7 +22939,7 @@ async function recallMessages({ memory, threadId, resourceId, cursor, page = 1,
 	const anchor = resolved;
 	const crossThreadId = anchor.threadId && anchor.threadId !== threadId ? anchor.threadId : void 0;
 	if (crossThreadId && threadScope) return {
-		messages: `Cursor does not belong to the active thread. Expected thread "${threadId}" but cursor "${cursor}" belongs to "${anchor.threadId}". Pass threadId="${anchor.threadId}" to browse that thread, or omit threadId and use this cursor directly in resource scope.`,
+		messages: `Cursor does not belong to the active thread. Expected thread "${threadId}" but cursor "${cursor}" belongs to "${anchor.threadId}". Pass threadId="${anchor.threadId}" to browse that thread.`,
 		count: 0,
 		cursor,
 		page: normalizedPage,
@@ -23043,7 +23098,8 @@ async function recallThreadFromStart({ memory, threadId, resourceId, page = 1, l
 	};
 }
 const recallTool = (_memoryConfig, options) => {
-	const isResourceScope = (options?.retrievalScope ?? "thread") === "resource";
+	const retrievalScope = options?.retrievalScope ?? "thread";
+	const isResourceScope = retrievalScope === "resource";
 	const searchEnabled = options?.searchEnabled ?? true;
 	const description = isResourceScope ? `Browse conversation history. Use mode="threads" to list all threads for the current user. Use mode="messages" (default) to browse messages in the current thread or pass threadId to browse another thread in the active resource. When mode="messages" has no cursor or threadId, it defaults to the current thread and says so at the top of the result. If you pass only a cursor, it must belong to the current thread.${searchEnabled ? " Use mode=\"search\" to find messages by content across all threads." : ""}` : `Browse conversation history in the current thread. Use mode="messages" (default) to page through messages near a cursor.${searchEnabled ? " Use mode=\"search\" to find messages by content in this thread." : ""} Use mode="threads" to get the current thread's ID and title.`;
 	const modeEnum = searchEnabled ? [
@@ -23254,23 +23310,25 @@ const recallTool = (_memoryConfig, options) => {
 			if (partIndex !== void 0 && partIndex !== null) return recallPart({
 				memory,
 				threadId: targetThreadId,
-				resourceId: isResourceScope ? resourceId : void 0,
+				resourceId,
 				cursor,
 				partIndex,
 				charOffset,
-				threadScope
+				threadScope,
+				retrievalScope
 			});
 			return recallMessages({
 				memory,
 				threadId: targetThreadId,
-				resourceId: isResourceScope ? resourceId : void 0,
+				resourceId,
 				cursor,
 				page,
 				limit,
 				detail: detail ?? "low",
 				partType,
 				toolName,
-				threadScope
+				threadScope,
+				retrievalScope
 			});
 		}
 	});
@@ -24376,7 +24434,8 @@ function stripThreadTags(observations) {
 }
 //#endregion
 //#region src/processors/observational-memory/observation-groups.ts
-const OBSERVATION_GROUP_PATTERN = /<observation-group\s([^>]*)>([\s\S]*?)<\/observation-group>/g;
+const OBSERVATION_GROUP_OPEN = "<observation-group";
+const OBSERVATION_GROUP_CLOSE = "</observation-group>";
 const ATTRIBUTE_PATTERN = /([\w][\w-]*)="([^"]*)"/g;
 const REFLECTION_GROUP_SPLIT_PATTERN = /^##\s+Group\s+/m;
 function parseObservationGroupAttributes(attributeString) {
@@ -24387,6 +24446,81 @@ function parseObservationGroupAttributes(attributeString) {
 	}
 	return attributes;
 }
+function isLineStart(observations, index) {
+	return index === 0 || observations[index - 1] === "\n";
+}
+function scanObservationGroupTags(observations) {
+	const tags = [];
+	const incompleteOpenings = [];
+	let cursor = 0;
+	let closeFloor = 0;
+	while (cursor < observations.length) {
+		const start = observations.indexOf(OBSERVATION_GROUP_OPEN, cursor);
+		if (start === -1) break;
+		const attributesStart = start + 18;
+		if (!/\s/.test(observations[attributesStart] ?? "")) {
+			cursor = attributesStart;
+			continue;
+		}
+		const openEnd = observations.indexOf(">", attributesStart);
+		if (openEnd === -1) break;
+		const closeStart = observations.indexOf(OBSERVATION_GROUP_CLOSE, Math.max(openEnd + 1, closeFloor));
+		if (closeStart === -1) {
+			if (isLineStart(observations, start)) incompleteOpenings.push({
+				start,
+				end: openEnd + 1
+			});
+			closeFloor = observations.length;
+			cursor = openEnd + 1;
+			continue;
+		}
+		const nestedStart = observations.indexOf(OBSERVATION_GROUP_OPEN, openEnd + 1);
+		if (nestedStart !== -1 && nestedStart < closeStart && isLineStart(observations, nestedStart)) {
+			incompleteOpenings.push({
+				start,
+				end: openEnd + 1
+			});
+			closeFloor = closeStart;
+			cursor = nestedStart;
+			continue;
+		}
+		tags.push({
+			start,
+			end: closeStart + 20,
+			attributeString: observations.slice(attributesStart, openEnd),
+			content: observations.slice(openEnd + 1, closeStart)
+		});
+		closeFloor = closeStart;
+		cursor = closeStart + 20;
+	}
+	return {
+		tags,
+		incompleteOpenings
+	};
+}
+function replaceObservationGroupTags(observations, replace) {
+	const { tags, incompleteOpenings } = scanObservationGroupTags(observations);
+	const parts = [];
+	let cursor = 0;
+	let openingIndex = 0;
+	const skipIncompleteOpeningsBefore = (limit) => {
+		while (openingIndex < incompleteOpenings.length && incompleteOpenings[openingIndex].start < limit) {
+			const opening = incompleteOpenings[openingIndex];
+			openingIndex++;
+			if (opening.start < cursor) continue;
+			parts.push(observations.slice(cursor, opening.start));
+			cursor = opening.end;
+		}
+	};
+	for (const tag of tags) {
+		skipIncompleteOpeningsBefore(tag.start);
+		parts.push(observations.slice(cursor, tag.start), replace(tag));
+		cursor = tag.end;
+	}
+	skipIncompleteOpeningsBefore(Number.POSITIVE_INFINITY);
+	parts.push(observations.slice(cursor));
+	return parts.join("");
+}
 function parseReflectionObservationGroupSections(content) {
 	const normalizedContent = content.trim();
 	if (!normalizedContent || !REFLECTION_GROUP_SPLIT_PATTERN.test(normalizedContent)) return [];
@@ -24411,9 +24545,8 @@ function wrapInObservationGroup(observations, range, id = generateAnchorId(), _s
 function parseObservationGroups(observations) {
 	if (!observations) return [];
 	const groups = [];
-	let match;
-	while ((match = OBSERVATION_GROUP_PATTERN.exec(observations)) !== null) {
-		const attributes = parseObservationGroupAttributes(match[1] ?? "");
+	for (const tag of scanObservationGroupTags(observations).tags) {
+		const attributes = parseObservationGroupAttributes(tag.attributeString);
 		const id = attributes.id;
 		const range = attributes.range;
 		if (!id || !range) continue;
@@ -24421,54 +24554,96 @@ function parseObservationGroups(observations) {
 			id,
 			range,
 			kind: attributes.kind,
-			content: match[2].trim()
+			content: tag.content.trim()
 		});
 	}
 	return groups;
 }
 function stripObservationGroups(observations) {
 	if (!observations) return observations;
-	return observations.replace(OBSERVATION_GROUP_PATTERN, (_match, _attributes, content) => content.trim()).replace(/\n{3,}/g, "\n\n").trim();
+	return replaceObservationGroupTags(observations, (tag) => tag.content.trim()).replace(/\n{3,}/g, "\n\n").trim();
 }
 function getRangeSegments(range) {
 	return range.split(",").map((segment) => segment.trim()).filter(Boolean);
 }
+function getRangeEndpoints(segment) {
+	const parts = segment.split(":").map((part) => part.trim());
+	if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+	return {
+		start: parts[0],
+		end: parts[1]
+	};
+}
+/**
+* `buildMessageRange` produces opaque UUID endpoints, so those segments cannot be ordered by value.
+* Spanning from the first start to the last end keeps reflected metadata bounded — the full segment
+* list is deliberately not preserved (#14791). Segments that are not `start:end` pairs are left as
+* they are rather than being joined into a fabricated span.
+*/
+function spanRangeSegments(segments) {
+	const endpoints = segments.map(getRangeEndpoints);
+	if (endpoints.some((endpoint) => endpoint === null)) return segments.join(",");
+	const first = endpoints[0];
+	const last = endpoints.at(-1);
+	return `${first.start}:${last.end}`;
+}
 function combineObservationGroupRanges(groups) {
-	const segments = groups.flatMap((group) => getRangeSegments(group.range));
+	const segments = Array.from(new Set(groups.flatMap((group) => getRangeSegments(group.range))));
 	if (segments.length === 0) return "";
-	const firstSegment = segments[0];
-	const lastSegment = segments[segments.length - 1];
-	const firstStart = firstSegment?.split(":")[0]?.trim();
-	const lastEnd = lastSegment?.split(":").at(-1)?.trim();
-	if (firstStart && lastEnd) return `${firstStart}:${lastEnd}`;
-	return Array.from(new Set(segments)).join(",");
+	const numericEndpoints = [];
+	if (!segments.every((segment) => {
+		const endpoints = getRangeEndpoints(segment);
+		if (!endpoints || !/^\d+$/.test(endpoints.start) || !/^\d+$/.test(endpoints.end)) return false;
+		const start = {
+			label: endpoints.start,
+			value: Number(endpoints.start)
+		};
+		const end = {
+			label: endpoints.end,
+			value: Number(endpoints.end)
+		};
+		if (!Number.isSafeInteger(start.value) || !Number.isSafeInteger(end.value)) return false;
+		numericEndpoints.push(start.value <= end.value ? {
+			start,
+			end
+		} : {
+			start: end,
+			end: start
+		});
+		return true;
+	})) return spanRangeSegments(segments);
+	const first = numericEndpoints.reduce((lowest, pair) => pair.start.value < lowest.start.value ? pair : lowest);
+	const last = numericEndpoints.reduce((highest, pair) => pair.end.value > highest.end.value ? pair : highest);
+	return `${first.start.label}:${last.end.label}`;
 }
 function renderObservationGroupsForReflection(observations) {
-	const groups = parseObservationGroups(observations);
-	if (groups.length === 0) return null;
-	const groupsByContent = new Map(groups.map((g) => [g.content.trim(), g]));
-	return observations.replace(OBSERVATION_GROUP_PATTERN, (_match, _attrs, content) => {
-		const group = groupsByContent.get(content.trim());
-		if (!group) return content.trim();
-		return `## Group \`${group.id}\`\n_range: \`${group.range}\`_\n\n${group.content}`;
+	if (parseObservationGroups(observations).length === 0) return null;
+	return replaceObservationGroupTags(observations, (tag) => {
+		const attributes = parseObservationGroupAttributes(tag.attributeString);
+		if (!attributes.id || !attributes.range) return tag.content.trim();
+		return `## Group \`${attributes.id}\`\n_range: \`${attributes.range}\`_\n\n${tag.content.trim()}`;
 	}).replace(/\n{3,}/g, "\n\n").trim();
 }
 function getCanonicalGroupId(sectionHeading, fallbackIndex) {
 	return sectionHeading.match(/`([^`]+)`/)?.[1]?.trim() || `derived-group-${fallbackIndex + 1}`;
 }
+function getContentLines(content) {
+	return content.split("\n").map((line) => line.trim()).filter(Boolean);
+}
 function deriveObservationGroupProvenance(content, groups) {
 	const sections = parseReflectionObservationGroupSections(content);
 	if (sections.length === 0 || groups.length === 0) return [];
 	return sections.map((section, index) => {
-		const bodyLines = new Set(section.body.split("\n").map((line) => line.trim()).filter(Boolean));
-		const matchingGroups = groups.filter((group) => {
-			return group.content.split("\n").map((line) => line.trim()).filter(Boolean).some((line) => bodyLines.has(line));
-		});
+		const canonicalGroupId = getCanonicalGroupId(section.heading, index);
+		const identifiedGroup = groups.find((group) => group.id === canonicalGroupId);
+		const bodyLines = new Set(getContentLines(section.body));
+		const matchingGroups = groups.filter((group) => getContentLines(group.content).some((line) => bodyLines.has(line)));
 		const fallbackGroup = groups[Math.min(index, groups.length - 1)];
-		const resolvedGroups = matchingGroups.length > 0 ? matchingGroups : fallbackGroup ? [fallbackGroup] : [];
+		const identifiedLines = new Set(getContentLines(identifiedGroup?.content ?? ""));
+		const contributingGroups = identifiedGroup ? matchingGroups.filter((group) => group.id !== identifiedGroup.id && getContentLines(group.content).some((line) => bodyLines.has(line) && !identifiedLines.has(line))) : [];
 		return {
-			id: getCanonicalGroupId(section.heading, index),
-			range: combineObservationGroupRanges(resolvedGroups),
+			id: canonicalGroupId,
+			range: combineObservationGroupRanges(identifiedGroup ? groups.filter((group) => group === identifiedGroup || contributingGroups.includes(group)) : matchingGroups.length > 0 ? matchingGroups : fallbackGroup ? [fallbackGroup] : []),
 			kind: "reflection",
 			content: section.body
 		};
@@ -25062,6 +25237,10 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 	async persist(processed) {
 		const { record, threadId, resourceId, messages } = this.opts;
 		const thread = await this.storage.getThreadById({ threadId });
+		if (!await this.storage.getObservationalMemory(record.threadId, record.resourceId)) {
+			omDebug(`[OM:sync-obs] skipping persist for thread ${threadId}: observational memory record is gone`);
+			return;
+		}
 		let threadUpdateMarker;
 		if (thread) {
 			const oldTitle = thread.title?.trim();
@@ -25243,6 +25422,10 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 	async persist(processed) {
 		if (!processed.observations) return;
 		const { record, threadId, resourceId, messages } = this.opts;
+		if (!await this.storage.getObservationalMemory(record.threadId, record.resourceId)) {
+			omDebug(`[OM:asyncBuffer] skipping persist for thread ${threadId}: observational memory record is gone`);
+			return;
+		}
 		const messageTokens = await this.tokenCounter.countMessagesAsync(messages);
 		await withRetry(() => this.storage.updateBufferedObservations({
 			id: record.id,
@@ -26236,6 +26419,10 @@ var ObservationTurn = class {
 		if (!this._context) throw new Error("Turn not started — call start() first");
 		return this._context;
 	}
+	/** Whether the turn has been ended and can no longer accept steps. */
+	get ended() {
+		return this._ended;
+	}
 	/** The current step, if one exists. */
 	get currentStep() {
 		return this._currentStep;
@@ -28063,11 +28250,19 @@ var ObservationalMemory = class ObservationalMemory {
 		const messageTokens = config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens;
 		const observationTokens = config.reflection?.observationTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.observationTokens;
 		const isSharedBudget = config.shareTokenBudget ?? false;
-		const isDefaultModelSelection = (model) => model === void 0 || model === "default" || model instanceof ModelByInputTokens;
+		const supportsDefaultTemperature = (model) => {
+			if (model instanceof ModelByInputTokens || typeof model === "function") return false;
+			if (typeof model === "string") return (0, _mastra_core_llm.modelSupportsTemperature)(model) === true;
+			if (model && typeof model === "object" && "provider" in model && "modelId" in model && typeof model.provider === "string" && typeof model.modelId === "string") return (0, _mastra_core_llm.modelSupportsTemperature)(`${model.provider.split(".")[0]}/${model.modelId}`) === true;
+			return false;
+		};
+		const usesDefaultOutputTokenBudget = (model) => model === void 0 || model === "default" || model instanceof ModelByInputTokens;
 		const observationSelectedModel = topLevelModel ?? observationConfigModel ?? reflectionConfigModel;
 		const reflectionSelectedModel = topLevelModel ?? reflectionConfigModel ?? observationConfigModel;
-		const observationDefaultMaxOutputTokens = config.observation?.modelSettings?.maxOutputTokens ?? (isDefaultModelSelection(observationSelectedModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.maxOutputTokens : void 0);
-		const reflectionDefaultMaxOutputTokens = config.reflection?.modelSettings?.maxOutputTokens ?? (isDefaultModelSelection(reflectionSelectedModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.maxOutputTokens : void 0);
+		const observationTemperature = config.observation?.modelSettings?.temperature ?? (supportsDefaultTemperature(observationModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.temperature : void 0);
+		const observationDefaultMaxOutputTokens = config.observation?.modelSettings?.maxOutputTokens ?? (usesDefaultOutputTokenBudget(observationSelectedModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.maxOutputTokens : void 0);
+		const reflectionTemperature = config.reflection?.modelSettings?.temperature ?? (supportsDefaultTemperature(reflectionModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.temperature : void 0);
+		const reflectionDefaultMaxOutputTokens = config.reflection?.modelSettings?.maxOutputTokens ?? (usesDefaultOutputTokenBudget(reflectionSelectedModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.maxOutputTokens : void 0);
 		const totalBudget = messageTokens + observationTokens;
 		const userExplicitlyConfiguredAsync = config.observation?.bufferTokens !== void 0 || config.observation?.bufferActivation !== void 0 || config.reflection?.bufferActivation !== void 0;
 		const asyncBufferingDisabled = config.observation?.bufferTokens === false || config.scope === "resource" && !userExplicitlyConfiguredAsync;
@@ -28083,7 +28278,7 @@ var ObservationalMemory = class ObservationalMemory {
 			} : messageTokens,
 			shareTokenBudget: isSharedBudget,
 			modelSettings: {
-				temperature: config.observation?.modelSettings?.temperature ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.temperature,
+				...observationTemperature !== void 0 ? { temperature: observationTemperature } : {},
 				...observationDefaultMaxOutputTokens !== void 0 ? { maxOutputTokens: observationDefaultMaxOutputTokens } : {}
 			},
 			providerOptions: config.observation?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.providerOptions,
@@ -28109,7 +28304,7 @@ var ObservationalMemory = class ObservationalMemory {
 			observationTokens,
 			shareTokenBudget: isSharedBudget,
 			modelSettings: {
-				temperature: config.reflection?.modelSettings?.temperature ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.modelSettings.temperature,
+				...reflectionTemperature !== void 0 ? { temperature: reflectionTemperature } : {},
 				...reflectionDefaultMaxOutputTokens !== void 0 ? { maxOutputTokens: reflectionDefaultMaxOutputTokens } : {}
 			},
 			providerOptions: config.reflection?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.providerOptions,
@@ -29964,9 +30159,11 @@ ${formattedMessages}
 		let lifecycleError;
 		let observationStarted = false;
 		let generationBefore = -1;
+		let recordInsideLock;
 		try {
 			await this.withLock(lockKey, async () => {
 				const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
+				recordInsideLock = freshRecord;
 				generationBefore = freshRecord.generationCount;
 				const unobservedMessages = messages ? this.getUnobservedMessages(messages, freshRecord) : await this.loadMessagesFromStorage(threadId, resourceId, freshRecord.lastObservedAt ? new Date(freshRecord.lastObservedAt) : void 0);
 				if (!this.meetsObservationThreshold({
@@ -30009,7 +30206,7 @@ ${formattedMessages}
 			omDebug(`[OM:hooks] onObservationEnd hook failed after cycle failure: ${endHookError instanceof Error ? endHookError.message : String(endHookError)}`);
 		}
 		if (lifecycleError !== void 0) throw lifecycleError;
-		const record = await this.getOrCreateRecord(threadId, resourceId);
+		const record = await this.getRecord(threadId, resourceId) ?? recordInsideLock;
 		const reflected = record.generationCount > generationBefore && generationBefore >= 0;
 		return {
 			observed,
@@ -30490,6 +30687,10 @@ var ObservationalMemoryProcessor = class {
 				if (this.turn === activeTurn) this.turn = void 0;
 				state.__omTurn = void 0;
 			}
+			if (activeTurn?.ended || this.turn?.ended) {
+				if (this.turn?.ended) this.turn = void 0;
+				state.__omTurn = void 0;
+			}
 			if (!this.turn || !state.__omTurn) {
 				if (this.turn && !state.__omTurn) await this.turn.end().catch(() => {});
 				this.turn = this.engine.beginTurn({
@@ -30590,11 +30791,11 @@ var ObservationalMemoryProcessor = class {
 		return this.engine.getTokenCounter().runWithModelContext(state.__omActorModelContext, async () => {
 			if ((0, _mastra_core_memory.parseMemoryRequestContext)(requestContext)?.memoryConfig?.readOnly) return messageList;
 			const turn = asLiveTurn(state.__omTurn) ?? this.turn;
-			if (turn) {
-				await turn.end();
-				this.turn = void 0;
-				state.__omTurn = void 0;
-			} else {
+			const liveTurn = turn && !turn.ended ? turn : void 0;
+			if (liveTurn) await liveTurn.end();
+			this.turn = void 0;
+			state.__omTurn = void 0;
+			if (!liveTurn) {
 				const newOutput = messageList.get.response.db();
 				const messagesToSave = [...messageList.get.input.db(), ...newOutput];
 				if (messagesToSave.length > 0 && context.threadId) await this.engine.persistMessages(messagesToSave, context.threadId, context.resourceId);
@@ -30804,6 +31005,7 @@ const DEFAULT_MESSAGE_RANGE = {
 };
 const DEFAULT_TOP_K = 4;
 const VECTOR_DELETE_BATCH_SIZE = 100;
+const OM_DELETE_DRAIN_TIMEOUT_MS = 1e4;
 const DEFAULT_EMBEDDING_CACHE_MAX_SIZE = 1e3;
 /**
 * Gives Mastra agents conversation history, with optional working memory,
@@ -31255,6 +31457,8 @@ var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 		await this.deleteStoredThread(memoryStore, threadId, thread?.resourceId);
 	}
 	async deleteStoredThread(memoryStore, threadId, resourceId) {
+		const engine = this._omEngine ? await this._omEngine : this._omEngineInstance;
+		if (engine && resourceId) await engine.waitForBuffering(threadId, resourceId, OM_DELETE_DRAIN_TIMEOUT_MS);
 		await memoryStore.deleteThread({ threadId });
 		if (resourceId && memoryStore.supportsObservationalMemory) await memoryStore.clearObservationalMemory(threadId, resourceId);
 		if (this.vector) this.trackVectorCleanup(this.deleteThreadVectors(threadId));
@@ -33269,4 +33473,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-BCvV2aGL.cjs.map
+//# sourceMappingURL=src-QqTmOY5X.cjs.map