@mastra/server 1.68.0-alpha.0 → 1.68.0-alpha.11

package/dist/{dist-BKxbtiJd.cjs → dist-CF1rK7oZ.cjs}

@@ -1,8 +1,8 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Bd6kNlEP.cjs");
-const require_schema_D_ikovK6 = require("./schema-D_ikovK6-DQrOVw5N.cjs");
-require("./schema-C7CvwM1d.cjs");
+const require_schema_BwlBcZRB = require("./schema-BwlBcZRB-BLwYP0BY.cjs");
+require("./schema-DM4T8wfR.cjs");
 const require_sync$1 = require("./sync-C4LbbSKR.cjs");
-const require_dist = require("./dist-CLQt62Pi.cjs");
+const require_dist = require("./dist-DO5NHh-t.cjs");
 let zod_v4 = require("zod/v4");
 zod_v4 = require_rolldown_runtime.__toESM(zod_v4, 1);
 let _mastra_core_schema = require("@mastra/core/schema");
@@ -4029,62 +4029,6 @@ async function e() {
 	}((await WebAssembly.instantiate(t)).instance);
 }
 //#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 ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/diff/8.0.4/6781cdda9837821c30a1f4c4db1d9286b838fe139b78d9658b2471e961b45953/node_modules/diff/libesm/diff/base.js
 var import_sync = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_sync$1.require_sync(), 1);
 var Diff = class {
@@ -4694,7 +4638,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-Dt8oPiQN.js
+//#region ../memory/dist/src-zTE4189S.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -22877,6 +22821,410 @@ function safeSlice(str, end) {
 	const safeEnd = code >= 55296 && code <= 56319 ? end - 1 : end;
 	return str.slice(0, safeEnd);
 }
+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;
+}
+const DEFAULT_OBSERVER_TOOL_ARGUMENT_MAX_TOKENS = 2e3;
+const OBSERVER_TOOL_ARGUMENT_INLINE_STRING_MAX_CHARS = 160;
+const OBSERVER_TOOL_ARGUMENT_MAX_DEPTH = 5;
+const OBSERVER_TOOL_ARGUMENT_MAX_ENTRIES_PER_CONTAINER = 20;
+const OBSERVER_TOOL_ARGUMENT_MAX_OUTLINE_ENTRIES = 100;
+const OBSERVER_TOOL_ARGUMENT_MAX_PATH_CHARS = 160;
+function isObjectLike$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function sanitizeSurrogates(value) {
+	let sanitized = "";
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code >= 55296 && code <= 56319) {
+			const next = value.charCodeAt(index + 1);
+			if (next >= 56320 && next <= 57343) {
+				sanitized += value.charAt(index) + value.charAt(index + 1);
+				index++;
+			} else sanitized += "�";
+			continue;
+		}
+		sanitized += code >= 56320 && code <= 57343 ? "�" : value[index];
+	}
+	return sanitized;
+}
+function stablePathDigest(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index++) hash = Math.imul(hash ^ value.charCodeAt(index), 16777619);
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function safeTail(value, length) {
+	let start = Math.max(0, value.length - length);
+	if (start > 0) {
+		const code = value.charCodeAt(start);
+		if (code >= 56320 && code <= 57343) start++;
+	}
+	return value.slice(start);
+}
+function truncatePath(path$3) {
+	if (path$3.length <= OBSERVER_TOOL_ARGUMENT_MAX_PATH_CHARS) return path$3;
+	const headLength = 50;
+	const tailLength = 60;
+	const omitted = path$3.length - headLength - tailLength;
+	return `${safeSlice(path$3, headLength)}…[${omitted} chars; ${stablePathDigest(path$3)}]…${safeTail(path$3, tailLength)}`;
+}
+function formatPath(parent, key, isArray) {
+	if (isArray) return truncatePath(`${parent}[${key}]`);
+	const stringKey = String(key);
+	const segment = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(stringKey) ? stringKey : `[${JSON.stringify(stringKey)}]`;
+	return truncatePath(parent ? `${parent}.${segment}` : segment);
+}
+function formatPrimitive(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "bigint") return `<bigint> ${value}`;
+	if (typeof value === "symbol" || typeof value === "function") return JSON.stringify(String(value));
+	if (value === void 0) return "<undefined>";
+	if (typeof value === "number" && Object.is(value, -0)) return "-0";
+	return String(value);
+}
+function containerSummary(value) {
+	if (!Array.isArray(value)) return "<object>";
+	try {
+		return `<array, ${value.length} ${value.length === 1 ? "item" : "items"}>`;
+	} catch {
+		return "<array, unknown length>";
+	}
+}
+function readEntries(value) {
+	const entries = [];
+	try {
+		if (Array.isArray(value)) {
+			const length = value.length;
+			const visibleLength = Math.min(length, OBSERVER_TOOL_ARGUMENT_MAX_ENTRIES_PER_CONTAINER);
+			for (let index = 0; index < visibleLength; index++) {
+				if (!(index in value)) {
+					entries.push({
+						key: index,
+						unavailable: "hole"
+					});
+					continue;
+				}
+				try {
+					entries.push({
+						key: index,
+						value: value[index]
+					});
+				} catch {
+					entries.push({
+						key: index,
+						unavailable: "unreadable"
+					});
+				}
+			}
+			return {
+				entries,
+				hasMore: length > visibleLength,
+				unavailable: false
+			};
+		}
+		let hasMore = false;
+		for (const key in value) {
+			if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+			if (entries.length >= OBSERVER_TOOL_ARGUMENT_MAX_ENTRIES_PER_CONTAINER) {
+				hasMore = true;
+				break;
+			}
+			try {
+				entries.push({
+					key,
+					value: value[key]
+				});
+			} catch {
+				entries.push({
+					key,
+					unavailable: "unreadable"
+				});
+			}
+		}
+		return {
+			entries,
+			hasMore,
+			unavailable: false
+		};
+	} catch {
+		return {
+			entries,
+			hasMore: false,
+			unavailable: true
+		};
+	}
+}
+function fits(text, limits) {
+	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);
+	if (marker) lines.push(marker);
+	return lines.join("\n");
+}
+function selectOutlineEntries(entries, limits) {
+	const all = joinEntries(entries);
+	if (fits(all, limits)) return all;
+	const marker = "... [additional argument fields omitted by size limit]";
+	const selected = [];
+	const candidates = [...entries].sort((a, b) => {
+		if (a.depth !== b.depth) return a.depth - b.depth;
+		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);
+	if (fits(rendered, limits)) return rendered;
+	if (fits(marker, limits)) return marker;
+	return fits("…", limits) ? "…" : "";
+}
+function indentPreview(value) {
+	return value.split("\n").map((line) => `  | ${line}`).join("\n");
+}
+function formatPreview(path$4, value, limits, prefix = "") {
+	const sanitizedValue = sanitizeSurrogates(value);
+	const marker = (visible) => {
+		const omitted = sanitizedValue.length - visible.length;
+		return `${path$4}:\n${indentPreview(visible)}${omitted > 0 ? `\n  | ... [${omitted} characters omitted]` : ""}`;
+	};
+	let low = 0;
+	let high = sanitizedValue.length;
+	let best = "";
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const candidate = marker(safeSlice(sanitizedValue, mid));
+		if (fits(prefix ? `${prefix}\n${candidate}` : candidate, limits)) {
+			best = candidate;
+			low = mid + 1;
+		} else high = mid - 1;
+	}
+	return best;
+}
+function appendWithinBudget(base, addition, limits) {
+	if (!addition) return;
+	const candidate = base ? `${base}\n${addition}` : addition;
+	return fits(candidate, limits) ? candidate : void 0;
+}
+/**
+* Formats tool arguments for the Observer without allowing a large early value
+* to hide concise sibling fields. A breadth-first structural outline is selected
+* before bounded previews of large strings are added.
+*/
+function formatToolArgumentsForObserver(value, options) {
+	const limits = {
+		maxTokens: options?.maxTokens ?? DEFAULT_OBSERVER_TOOL_ARGUMENT_MAX_TOKENS,
+		maxCharacters: options?.maxCharacters ?? Number.POSITIVE_INFINITY
+	};
+	if (limits.maxTokens <= 0 || limits.maxCharacters <= 0) return "";
+	if (!isObjectLike$1(value)) {
+		if (typeof value !== "string" || value.length <= OBSERVER_TOOL_ARGUMENT_INLINE_STRING_MAX_CHARS) {
+			const primitive = formatPrimitive(value);
+			return fits(primitive, limits) ? primitive : fits("…", limits) ? "…" : "";
+		}
+		const summary = `<string, ${value.length} characters; preview size-limited>`;
+		const rendered = appendWithinBudget(summary, formatPreview("preview", value, limits, summary), limits);
+		if (rendered) return rendered;
+		if (fits(summary, limits)) return summary;
+		return fits("…", limits) ? "…" : "";
+	}
+	const outline = [];
+	const previews = [];
+	const pending = [{
+		path: "",
+		value,
+		depth: 0,
+		ancestors: /* @__PURE__ */ new Set([value])
+	}];
+	let outlineEntries = 0;
+	let order = 0;
+	let structuralLimitReached = false;
+	while (pending.length > 0 && outlineEntries < OBSERVER_TOOL_ARGUMENT_MAX_OUTLINE_ENTRIES) {
+		const current = pending.shift();
+		const read = readEntries(current.value);
+		if (read.unavailable) {
+			outline.push({
+				text: `${current.path || "arguments"}: [unavailable container]`,
+				depth: current.depth,
+				order: order++
+			});
+			outlineEntries++;
+			continue;
+		}
+		if (read.entries.length === 0 && !read.hasMore) {
+			outline.push({
+				text: `${current.path || "arguments"}: [empty ${Array.isArray(current.value) ? "array" : "object"}]`,
+				depth: current.depth,
+				order: order++
+			});
+			outlineEntries++;
+			continue;
+		}
+		if (read.hasMore) {
+			outline.push({
+				text: `${current.path || (Array.isArray(current.value) ? "items" : "fields")}: ... [additional entries omitted]`,
+				depth: current.depth,
+				order: order++
+			});
+			outlineEntries++;
+		}
+		for (const entry of read.entries) {
+			if (outlineEntries >= OBSERVER_TOOL_ARGUMENT_MAX_OUTLINE_ENTRIES) {
+				structuralLimitReached = true;
+				break;
+			}
+			const path$5 = formatPath(current.path, entry.key, Array.isArray(current.value));
+			outlineEntries++;
+			if (entry.unavailable) {
+				outline.push({
+					text: `${path$5}: [${entry.unavailable}]`,
+					depth: current.depth,
+					order: order++
+				});
+				continue;
+			}
+			const entryValue = entry.value;
+			if (typeof entryValue === "string" && entryValue.length > OBSERVER_TOOL_ARGUMENT_INLINE_STRING_MAX_CHARS) {
+				outline.push({
+					text: `${path$5}: <string, ${entryValue.length} characters; preview size-limited>`,
+					depth: current.depth,
+					order: order++
+				});
+				previews.push({
+					path: path$5,
+					value: entryValue
+				});
+				continue;
+			}
+			if (!isObjectLike$1(entryValue)) {
+				outline.push({
+					text: `${path$5}: ${formatPrimitive(entryValue)}`,
+					depth: current.depth,
+					order: order++
+				});
+				continue;
+			}
+			if (current.ancestors.has(entryValue)) {
+				outline.push({
+					text: `${path$5}: [circular]`,
+					depth: current.depth,
+					order: order++
+				});
+				continue;
+			}
+			const summary = containerSummary(entryValue);
+			if (current.depth >= OBSERVER_TOOL_ARGUMENT_MAX_DEPTH) {
+				outline.push({
+					text: `${path$5}: ${summary} [max depth reached]`,
+					depth: current.depth,
+					order: order++
+				});
+				continue;
+			}
+			outline.push({
+				text: `${path$5}: ${summary}`,
+				depth: current.depth,
+				order: order++
+			});
+			pending.push({
+				path: path$5,
+				value: entryValue,
+				depth: current.depth + 1,
+				ancestors: /* @__PURE__ */ new Set([...current.ancestors, entryValue])
+			});
+		}
+	}
+	if (pending.length > 0 || structuralLimitReached) outline.push({
+		text: "... [additional nested entries omitted by structure limit]",
+		depth: Number.POSITIVE_INFINITY,
+		order: order++
+	});
+	if (previews.length === 0) return selectOutlineEntries(outline, limits);
+	const previewHeader = "Large string previews (size-limited):";
+	const renderedOutline = selectOutlineEntries(outline, limits);
+	const withPreviewHeader = appendWithinBudget(renderedOutline, previewHeader, limits);
+	if (!withPreviewHeader) return renderedOutline;
+	let rendered = withPreviewHeader;
+	let renderedPreviews = 0;
+	let omittedPreviews = 0;
+	for (let index = 0; index < previews.length; index++) {
+		const remainingCount = previews.length - index;
+		const remainingTokens = Math.max(0, limits.maxTokens - estimateTokenCount(rendered));
+		const remainingCharacters = Math.max(0, limits.maxCharacters - rendered.length - 1);
+		const previewLimits = {
+			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);
+		if (!preview) {
+			omittedPreviews++;
+			continue;
+		}
+		const withPreview = appendWithinBudget(rendered, preview, limits);
+		if (!withPreview) {
+			omittedPreviews++;
+			continue;
+		}
+		rendered = withPreview;
+		renderedPreviews++;
+	}
+	if (renderedPreviews === 0) return renderedOutline;
+	if (omittedPreviews > 0) {
+		const marker = `... [${omittedPreviews} large string ${omittedPreviews === 1 ? "preview" : "previews"} omitted]`;
+		rendered = appendWithinBudget(rendered, marker, limits) ?? rendered;
+	}
+	return rendered;
+}
 const ENCRYPTED_CONTENT_KEY = "encryptedContent";
 const ENCRYPTED_CONTENT_REDACTION_THRESHOLD = 256;
 function isObjectLike(value) {
@@ -22954,7 +23302,7 @@ function truncateStringByTokens(text, maxTokens) {
 	return best;
 }
 function formatToolResultForObserver(value, options) {
-	return truncateStringByTokens(stringifyToolResult(value), options?.maxTokens ?? 1e4);
+	return truncateStringByTokens(stringifyToolResult(value), options?.maxTokens ?? 5e3);
 }
 /**
 * The core extraction instructions for the Observer.
@@ -23639,9 +23987,52 @@ function getTemporalGapMarkerText(msg) {
 	if (metadata?.reminderType === "temporal-gap" && typeof metadata.gapText === "string") return metadata.gapText;
 	if (typeof metadata?.systemReminder === "object" && metadata.systemReminder && "type" in metadata.systemReminder && metadata.systemReminder.type === "temporal-gap" && "gapText" in metadata.systemReminder && typeof metadata.systemReminder.gapText === "string") return metadata.systemReminder.gapText;
 }
-function formatObserverMessage(msg, counter, options) {
+function isCallLikeToolInvocation(invocation) {
+	return invocation.state === "call" || invocation.state === "partial-call" || invocation.state === "approval-requested" || invocation.state === "approval-responded";
+}
+function isTerminalToolInvocation(invocation) {
+	return invocation.state === "result" || invocation.state === "output-error" || invocation.state === "output-denied";
+}
+function createObserverToolFormattingState(messages) {
+	const exchanges = /* @__PURE__ */ new Map();
+	const occurrences = /* @__PURE__ */ new Map();
+	let occurrence = 0;
+	for (const message of messages) {
+		if (typeof message.content === "string" || !Array.isArray(message.content?.parts)) continue;
+		for (const part of message.content.parts) {
+			if (part.type !== "tool-invocation") continue;
+			const invocation = part.toolInvocation;
+			occurrences.set(part, occurrence);
+			if (!isCallLikeToolInvocation(invocation) && !isTerminalToolInvocation(invocation)) {
+				occurrence++;
+				continue;
+			}
+			const exchange = exchanges.get(invocation.toolCallId) ?? { firstOccurrence: occurrence };
+			if (isCallLikeToolInvocation(invocation) && (invocation.args !== void 0 || exchange.signature === void 0)) exchange.signature = invocation;
+			if (isTerminalToolInvocation(invocation)) exchange.terminal = {
+				...invocation,
+				occurrence
+			};
+			exchanges.set(invocation.toolCallId, exchange);
+			occurrence++;
+		}
+	}
+	for (const exchange of exchanges.values()) if (exchange.terminal?.args !== void 0) exchange.signature = exchange.terminal;
+	else if (!exchange.signature && exchange.terminal) exchange.signature = exchange.terminal;
+	return {
+		exchanges,
+		occurrences,
+		emittedCalls: /* @__PURE__ */ new Set(),
+		emittedOutcomes: /* @__PURE__ */ new Set()
+	};
+}
+function formatObserverToolArguments(args, maxCharacters) {
+	if (args === void 0) return maybeTruncate("[arguments unavailable]", maxCharacters);
+	return formatToolArgumentsForObserver(args, { maxCharacters: maxCharacters || void 0 });
+}
+function formatObserverMessage(msg, counter, toolFormatting, options) {
 	const maxLen = options?.maxPartLength;
-	const maxToolResultTokens = options?.maxToolResultTokens ?? 1e4;
+	const maxToolResultTokens = options?.maxToolResultTokens ?? 5e3;
 	const attachmentFilter = options?.attachmentFilter;
 	const role = msg.role.charAt(0).toUpperCase() + msg.role.slice(1);
 	const attachments = [];
@@ -23668,14 +24059,31 @@ function formatObserverMessage(msg, counter, options) {
 		}
 		if (part.type === "tool-invocation") {
 			const inv = part.toolInvocation;
+			const occurrence = toolFormatting.occurrences.get(part);
+			const exchange = toolFormatting.exchanges.get(inv.toolCallId);
+			if (exchange && occurrence === exchange.firstOccurrence && exchange.signature && !toolFormatting.emittedCalls.has(inv.toolCallId)) {
+				toolFormatting.emittedCalls.add(inv.toolCallId);
+				pushLine(`Tool Call ${exchange.signature.toolName}`, formatObserverToolArguments(exchange.signature.args, maxLen), partCreatedAt);
+			}
 			if (inv.state === "result") {
 				const { value: resultForObserver } = resolveToolResultValue(part, inv.result);
 				const { resultWithoutAttachments, attachments: extractedAttachments } = extractToolResultAttachments(resultForObserver, counter, attachmentFilter);
 				if (extractedAttachments.length > 0) attachments.push(...extractedAttachments);
-				pushLine(`Tool Result ${inv.toolName}`, maybeTruncate(formatToolResultForObserver(resultWithoutAttachments, { maxTokens: maxToolResultTokens }), maxLen), partCreatedAt);
+				if (exchange?.terminal?.occurrence === occurrence && !toolFormatting.emittedOutcomes.has(inv.toolCallId)) {
+					toolFormatting.emittedOutcomes.add(inv.toolCallId);
+					const hasResult = resultWithoutAttachments !== void 0 && (typeof resultWithoutAttachments !== "string" || resultWithoutAttachments.trim().length > 0);
+					const body = inv.isError ? hasResult ? formatToolResultForObserver(resultWithoutAttachments, { maxTokens: maxToolResultTokens }) : inv.errorText?.trim() ? inv.errorText : "Tool execution failed" : hasResult ? formatToolResultForObserver(resultWithoutAttachments, { maxTokens: maxToolResultTokens }) : "[empty result]";
+					pushLine(`${inv.isError ? "Tool Error" : "Tool Result"} ${inv.toolName}`, maybeTruncate(body, maxLen), partCreatedAt);
+				}
+				return;
+			}
+			if (exchange?.terminal?.occurrence === occurrence && !toolFormatting.emittedOutcomes.has(inv.toolCallId)) {
+				toolFormatting.emittedOutcomes.add(inv.toolCallId);
+				if (inv.state === "output-error") pushLine(`Tool Error ${inv.toolName}`, maybeTruncate(inv.errorText?.trim() ? inv.errorText : "Tool execution failed", maxLen), partCreatedAt);
+				else if (inv.state === "output-denied") pushLine(`Tool Denied ${inv.toolName}`, maybeTruncate(inv.approval?.reason?.trim() ? inv.approval.reason : "Tool call was not approved by the user", maxLen), partCreatedAt);
 				return;
 			}
-			pushLine(`Tool Call ${inv.toolName}`, maybeTruncate(JSON.stringify(inv.args, null, 2), maxLen), partCreatedAt);
+			if (!exchange) pushLine(`Tool Call ${inv.toolName}`, formatObserverToolArguments(inv.args, maxLen), partCreatedAt);
 			return;
 		}
 		const partType = part.type;
@@ -23709,10 +24117,11 @@ function formatMessagesForObserver(messages, options) {
 		nextImageId: 1,
 		nextFileId: 1
 	};
+	const toolFormatting = createObserverToolFormattingState(messages);
 	const sections = [];
 	let context = {};
 	for (const message of messages) {
-		const formatted = formatObserverMessage(message, counter, options);
+		const formatted = formatObserverMessage(message, counter, toolFormatting, options);
 		if (formatted.lines.length === 0) continue;
 		const rendered = formatObserverLines(formatted.lines, context);
 		if (!rendered.text) continue;
@@ -23735,13 +24144,14 @@ function buildObserverHistoryMessage(messages, options) {
 		nextImageId: 1,
 		nextFileId: 1
 	};
+	const toolFormatting = createObserverToolFormattingState(messages);
 	const content = [{
 		type: "text",
 		text: "## New Message History to Observe\n\n"
 	}];
 	let context = {};
 	messages.forEach((message) => {
-		const formatted = formatObserverMessage(message, counter, options);
+		const formatted = formatObserverMessage(message, counter, toolFormatting, options);
 		if (formatted.lines.length === 0 && formatted.attachments.length === 0) return;
 		context = appendFormattedObserverMessage(content, formatted, context);
 	});
@@ -23769,10 +24179,11 @@ function buildMultiThreadObserverHistoryMessage(messagesByThread, threadOrder, o
 		const messages = messagesByThread.get(threadId);
 		if (!messages || messages.length === 0) return;
 		const threadContent = [];
+		const toolFormatting = createObserverToolFormattingState(messages);
 		let context = {};
 		let hasVisibleContent = false;
 		messages.forEach((message) => {
-			const formatted = formatObserverMessage(message, counter, options);
+			const formatted = formatObserverMessage(message, counter, toolFormatting, options);
 			if (formatted.lines.length === 0 && formatted.attachments.length === 0) return;
 			context = appendFormattedObserverMessage(threadContent, formatted, context);
 			hasVisibleContent = true;
@@ -24458,15 +24869,14 @@ var ObserverRunner = class {
 		this.mastra = mastra;
 	}
 	createAgent(model, isMultiThread = false, memory, extractors = this.observationConfig.extractors ?? []) {
-		const agent = new _mastra_core_agent.Agent({
+		return new _mastra_core_agent.Agent({
 			id: isMultiThread ? "multi-thread-observer" : "observational-memory-observer",
 			name: isMultiThread ? "multi-thread-observer" : "Observer",
 			instructions: buildObserverSystemPrompt(isMultiThread, this.observationConfig.instruction, this.observationConfig.threadTitle, extractors),
 			model,
-			...memory ? { memory } : {}
+			...memory ? { memory } : {},
+			...this.mastra ? { mastra: this.mastra } : {}
 		});
-		if (this.mastra) agent.__registerMastra(this.mastra);
-		return agent;
 	}
 	/**
 	* Extract a router-style model ID (`provider/model`) from a model config.
@@ -25524,9 +25934,9 @@ function createTimeoutSignal(timeoutMs) {
 	};
 }
 function getNumericResponseField(value, paths) {
-	for (const path$3 of paths) {
+	for (const path$6 of paths) {
 		let current = value;
-		for (const segment of path$3) {
+		for (const segment of path$6) {
 			current = getObjectValue(current, segment);
 			if (current === void 0) break;
 		}
@@ -26108,7 +26518,7 @@ var TokenCounter = class TokenCounter {
 		let tokens = 0;
 		let overheadDelta = 0;
 		if (invocation.toolName) tokens += this.readOrPersistPartEstimate(part, "tool-call-name", invocation.toolName);
-		if (invocation.args) if (typeof invocation.args === "string") tokens += this.readOrPersistPartEstimate(part, "tool-call-args", invocation.args);
+		if (invocation.args !== void 0) if (typeof invocation.args === "string") tokens += this.readOrPersistPartEstimate(part, "tool-call-args", invocation.args);
 		else {
 			const argsJson = JSON.stringify(invocation.args);
 			tokens += this.readOrPersistPartEstimate(part, "tool-call-args-json", argsJson);
@@ -26154,8 +26564,11 @@ var TokenCounter = class TokenCounter {
 			}
 			if (state === "result") {
 				extraMessageDelta++;
+				const signature = this.countToolCallSignature(part, invocation);
+				tokens += signature.tokens;
+				overheadDelta += signature.overheadDelta;
 				const { value: resultForCounting, usingStoredModelOutput } = this.resolveToolResultForTokenCounting(part, invocation.result);
-				if (resultForCounting !== void 0) {
+				if (resultForCounting !== void 0 && (typeof resultForCounting !== "string" || resultForCounting.trim().length > 0)) {
 					const contentTokens = this.countMultimodalToolResultContent(part, resultForCounting);
 					if (contentTokens !== void 0) tokens += contentTokens;
 					else {
@@ -26163,6 +26576,9 @@ var TokenCounter = class TokenCounter {
 						tokens += this.readOrPersistPartEstimate(part, usingStoredModelOutput ? "tool-result-model-output-json" : "tool-result-json", formattedResult);
 					}
 					if (typeof resultForCounting !== "string") overheadDelta -= 12;
+				} else {
+					const fallback = invocation.isError ? invocation.errorText?.trim() ? invocation.errorText : "Tool execution failed" : "[empty result]";
+					tokens += this.readOrPersistPartEstimate(part, invocation.isError ? "tool-result-error" : "tool-result-json", fallback);
 				}
 				return {
 					tokens,
@@ -26172,7 +26588,10 @@ var TokenCounter = class TokenCounter {
 			}
 			if (state === "output-denied") {
 				extraMessageDelta++;
-				const reason = invocation.approval?.reason ?? "Tool call was not approved by the user";
+				const signature = this.countToolCallSignature(part, invocation);
+				tokens += signature.tokens;
+				overheadDelta += signature.overheadDelta;
+				const reason = invocation.approval?.reason?.trim() ? invocation.approval.reason : "Tool call was not approved by the user";
 				tokens += this.readOrPersistPartEstimate(part, "tool-result-denied", reason);
 				return {
 					tokens,
@@ -26182,7 +26601,10 @@ var TokenCounter = class TokenCounter {
 			}
 			if (state === "output-error") {
 				extraMessageDelta++;
-				const errorMessage = typeof invocation.errorText === "string" ? invocation.errorText : "Tool execution failed";
+				const signature = this.countToolCallSignature(part, invocation);
+				tokens += signature.tokens;
+				overheadDelta += signature.overheadDelta;
+				const errorMessage = invocation.errorText?.trim() ? invocation.errorText : "Tool execution failed";
 				tokens += this.readOrPersistPartEstimate(part, "tool-result-error", errorMessage);
 				return {
 					tokens,
@@ -26209,7 +26631,12 @@ var TokenCounter = class TokenCounter {
 		};
 	}
 	/**
-	* Count tokens in a single message
+	* Count tokens in a single message.
+	*
+	* Canonical terminal invocations carry their call signature and outcome in one part. Legacy or
+	* foreign histories may instead repeat the same signature across separate call and result
+	* messages; those signatures are intentionally counted once per message because this API has no
+	* sequence context. The conservative overcount can activate observation earlier, never later.
 	*/
 	countMessage(message) {
 		let payloadTokens = this.countString(message.role);
@@ -26897,13 +27324,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");
@@ -26914,7 +27341,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
 			});
@@ -26953,7 +27380,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");
@@ -26964,7 +27391,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,
@@ -26981,7 +27408,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,
@@ -27140,7 +27567,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 ? [
@@ -27351,23 +27779,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
 			});
 		}
 	});
@@ -27427,7 +27857,7 @@ const updateWorkingMemoryTool = (memoryConfig) => {
 	};
 	if (schema) {
 		const standardSchema = (0, _mastra_core_schema.isStandardSchemaWithJSON)(schema) ? schema : (0, _mastra_core_schema.toStandardSchema)(schema);
-		const jsonSchema = require_schema_D_ikovK6.standardSchemaToJSONSchema(standardSchema, { io: "input" });
+		const jsonSchema = require_schema_BwlBcZRB.standardSchemaToJSONSchema(standardSchema, { io: "input" });
 		delete jsonSchema.$schema;
 		const wrappedJsonSchema = {
 			$schema: "http://json-schema.org/draft-07/schema#",
@@ -28453,7 +28883,8 @@ function sortThreadsByOldestMessage(messagesByThread) {
 function stripThreadTags(observations) {
 	return observations.replace(/<\/?thread\b[^>]{0,1024}>/gi, "").trim();
 }
-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) {
@@ -28464,6 +28895,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 [];
@@ -28488,9 +28994,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;
@@ -28498,54 +29003,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
 		};
@@ -28968,6 +29515,21 @@ var ObservationStrategy = class ObservationStrategy {
 		return false;
 	}
 };
+/**
+* Resolve the thread title an Observational Memory cycle should persist.
+*
+* Returns the trimmed candidate when it is a new, long-enough title, or
+* `undefined` when the current title must stay — including when the user
+* pinned it via `session.thread.rename()`, which sets the
+* `titlePinned` thread metadata flag.
+*/
+function resolveThreadTitleUpdate(thread, generatedTitle) {
+	const candidate = generatedTitle?.trim();
+	if (!candidate || candidate.length < 3) return void 0;
+	if ((0, _mastra_core_memory.isThreadTitlePinned)(thread?.metadata)) return void 0;
+	if (candidate === thread?.title?.trim()) return void 0;
+	return candidate;
+}
 var SyncObservationStrategy = class extends ObservationStrategy {
 	startedAt = (/* @__PURE__ */ new Date()).toISOString();
 	lastMessage;
@@ -29116,11 +29678,15 @@ 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();
-			const newTitle = processed.threadTitle?.trim();
-			const shouldUpdateThreadTitle = !!newTitle && newTitle.length >= 3 && newTitle !== oldTitle;
+			const newTitle = resolveThreadTitleUpdate(thread, processed.threadTitle);
+			const shouldUpdateThreadTitle = newTitle !== void 0;
 			const previousOmMetadata = (0, _mastra_core_memory.getThreadOMMetadata)(thread.metadata);
 			const metadataUpdate = buildThreadMetadataFromExtractedValues(processed.extractors ?? this.observationConfig.extractors, processed.extractedValues);
 			const newMetadata = (0, _mastra_core_memory.setThreadOMMetadata)(thread.metadata, {
@@ -29295,6 +29861,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,
@@ -29317,13 +29887,14 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			abortSignal: this.opts.abortSignal
 		});
 		await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt);
-		const newTitle = processed.threadTitle?.trim();
-		const hasValidThreadTitle = !!newTitle && newTitle.length >= 3;
+		const candidateTitle = processed.threadTitle?.trim();
+		const hasValidThreadTitle = !!candidateTitle && candidateTitle.length >= 3;
 		if (hasValidThreadTitle || processed.extractedValues) {
 			const thread = await this.storage.getThreadById({ threadId });
 			if (thread) {
 				const oldTitle = thread.title?.trim();
-				const shouldUpdateThreadTitle = hasValidThreadTitle && newTitle !== oldTitle;
+				const newTitle = resolveThreadTitleUpdate(thread, candidateTitle);
+				const shouldUpdateThreadTitle = newTitle !== void 0;
 				const previousOmMetadata = (0, _mastra_core_memory.getThreadOMMetadata)(thread.metadata);
 				const metadataUpdate = buildThreadMetadataFromExtractedValues(processed.extractors ?? this.observationConfig.extractors, processed.extractedValues);
 				const newMetadata = (0, _mastra_core_memory.setThreadOMMetadata)(thread.metadata, {
@@ -29678,8 +30249,8 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 			const thread = await this.storage.getThreadById({ threadId: update.threadId });
 			if (thread) {
 				const oldTitle = thread.title?.trim();
-				const newTitle = update.threadTitle?.trim();
-				const shouldUpdateThreadTitle = !!newTitle && newTitle.length >= 3 && newTitle !== oldTitle;
+				const newTitle = resolveThreadTitleUpdate(thread, update.threadTitle);
+				const shouldUpdateThreadTitle = newTitle !== void 0;
 				const previousOmMetadata = (0, _mastra_core_memory.getThreadOMMetadata)(thread.metadata);
 				const metadataUpdate = buildThreadMetadataFromExtractedValues(update.extractors ?? this.observationConfig.extractors, update.extracted);
 				const newMetadata = (0, _mastra_core_memory.setThreadOMMetadata)(thread.metadata, {
@@ -30275,6 +30846,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;
@@ -30815,15 +31390,14 @@ var ReflectorRunner = class {
 		this.mastra = mastra;
 	}
 	createAgent(model, memory, extractors = this.reflectionConfig.extractors) {
-		const agent = new _mastra_core_agent.Agent({
+		return new _mastra_core_agent.Agent({
 			id: "observational-memory-reflector",
 			name: "Reflector",
 			instructions: buildReflectorSystemPrompt(this.reflectionConfig.instruction, extractors),
 			model,
-			...memory ? { memory } : {}
+			...memory ? { memory } : {},
+			...this.mastra ? { mastra: this.mastra } : {}
 		});
-		if (this.mastra) agent.__registerMastra(this.mastra);
-		return agent;
 	}
 	getObservationMarkerConfig(record) {
 		return {
@@ -32095,11 +32669,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;
@@ -32115,7 +32697,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,
@@ -32141,7 +32723,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,
@@ -33865,9 +34447,8 @@ ${formattedMessages}
 					currentTask: lastActivated.currentTask,
 					threadTitle: chunkThreadTitle
 				});
-				const oldTitle = thread.title?.trim();
-				const newTitle = chunkThreadTitle?.trim();
-				const shouldUpdateThreadTitle = !!newTitle && newTitle.length >= 3 && newTitle !== oldTitle;
+				const newTitle = resolveThreadTitleUpdate(thread, chunkThreadTitle);
+				const shouldUpdateThreadTitle = newTitle !== void 0;
 				await this.storage.patchThread({
 					id: threadId,
 					...shouldUpdateThreadTitle ? { title: newTitle } : {},
@@ -33997,9 +34578,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({
@@ -34042,7 +34625,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,
@@ -34519,6 +35102,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({
@@ -34619,11 +35206,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);
@@ -34812,6 +35399,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,
@@ -34845,6 +35433,9 @@ const DEFAULT_EMBEDDING_CACHE_MAX_SIZE = 1e3;
 * if packaged docs are unavailable.
 */
 var Memory = class Memory extends _mastra_core_memory.MastraMemory {
+	createMemoryTokenCounter() {
+		return new TokenCounter();
+	}
 	_omEngine;
 	_omEngineInstance;
 	_mastraInstance;
@@ -35015,6 +35606,7 @@ var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 		const thread = await this.getThreadById({ threadId });
 		if (!thread && !resourceScope) throw new Error(`No thread found with id ${threadId}`);
 		if (thread && thread.resourceId !== resourceId) throw new Error(`Thread with id ${threadId} is for resource with id ${thread.resourceId} but resource ${resourceId} was queried.`);
+		return thread;
 	}
 	createMemorySpan(operationType, observabilityContext, input, attributes) {
 		const currentSpan = observabilityContext?.tracingContext?.currentSpan;
@@ -35035,6 +35627,9 @@ var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 		const { threadId, resourceId, perPage: perPageArg, page, orderBy, threadConfig, vectorSearchString, includeSystemReminders, hideSignals, filter, includeTotal } = args;
 		const config = this.getMergedThreadConfig(threadConfig || {});
 		const semanticRecallEnabled = Boolean(config.semanticRecall);
+		const history = (0, _mastra_core_memory.normalizeMessageHistoryConfig)(config.lastMessages, config.messageHistory);
+		const historyDisabledByConfig = !history.enabled && perPageArg === void 0;
+		const shouldUseTokenLoader = perPageArg === void 0 && history.enabled && history.maxTokens !== void 0;
 		const span = this.createMemorySpan("recall", args.observabilityContext, {
 			threadId,
 			resourceId,
@@ -35044,9 +35639,23 @@ var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 			lastMessages: config.lastMessages
 		});
 		try {
-			if (resourceId) await this.validateThreadIsOwnedByResource(threadId, resourceId, config);
-			const perPage = perPageArg !== void 0 ? perPageArg : config.lastMessages;
-			const historyDisabledByConfig = config.lastMessages === false && perPageArg === void 0;
+			if (historyDisabledByConfig && (!config.semanticRecall || !vectorSearchString || !this.vector)) {
+				const result = {
+					messages: [],
+					usage: void 0,
+					total: 0,
+					page: page ?? 0,
+					perPage: 0,
+					hasMore: false
+				};
+				span?.end({
+					output: { success: true },
+					attributes: { messageCount: 0 }
+				});
+				return result;
+			}
+			const validatedThread = resourceId ? await this.validateThreadIsOwnedByResource(threadId, resourceId, config) : void 0;
+			const perPage = perPageArg !== void 0 ? perPageArg : history.maxMessages ?? 0;
 			const shouldGetNewestAndReverse = !orderBy && perPage !== false;
 			const effectiveOrderBy = shouldGetNewestAndReverse ? {
 				field: "createdAt",
@@ -35075,21 +35684,6 @@ var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 			const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope !== `thread` || config.semanticRecall === true;
 			if (resourceScope && !resourceId && config?.semanticRecall && vectorSearchString) throw new Error("Memory error: Resource-scoped semantic recall is enabled but no resourceId was provided. Either provide a resourceId or explicitly set semanticRecall.scope to 'thread'.");
 			let usage;
-			if (historyDisabledByConfig && (!config.semanticRecall || !vectorSearchString || !this.vector)) {
-				const result = {
-					messages: [],
-					usage: void 0,
-					total: 0,
-					page: page ?? 0,
-					perPage: 0,
-					hasMore: false
-				};
-				span?.end({
-					output: { success: true },
-					attributes: { messageCount: 0 }
-				});
-				return result;
-			}
 			if (config?.semanticRecall && vectorSearchString && this.vector) {
 				const result = await this.embedMessageContent(vectorSearchString);
 				usage = result.usage;
@@ -35111,28 +35705,71 @@ var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 			const threshold = (typeof config.semanticRecall === "object" ? config.semanticRecall : void 0)?.threshold;
 			const filteredVectorResults = threshold !== void 0 ? vectorResults.filter((r) => r.score >= threshold) : vectorResults;
 			const memoryStore = await this.getMemoryStore();
-			const effectivePerPage = historyDisabledByConfig ? 0 : perPage;
-			const paginatedResult = await memoryStore.listMessages({
-				threadId,
-				resourceId,
-				perPage: effectivePerPage,
-				page,
-				orderBy: effectiveOrderBy,
-				filter,
-				...includeTotal !== void 0 ? { includeTotal } : {},
-				...filteredVectorResults?.length ? { include: filteredVectorResults.map((r) => ({
-					id: r.metadata?.message_id,
-					threadId: r.metadata?.thread_id,
-					withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
-					withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
-				})) } : {}
-			});
-			const rawMessages = shouldGetNewestAndReverse ? paginatedResult.messages.reverse() : paginatedResult.messages;
+			const include = filteredVectorResults.map((r) => ({
+				id: r.metadata?.message_id,
+				threadId: r.metadata?.thread_id,
+				withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
+				withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
+			}));
+			let rawMessages;
+			let resultPage;
+			let resultPerPage;
+			let total;
+			let hasMore;
+			if (shouldUseTokenLoader) {
+				const storedBoundary = (0, _mastra_core_memory.getMemoryTokenBoundary)(validatedThread ?? await memoryStore.getThreadById({
+					threadId,
+					resourceId
+				}));
+				const boundary = storedBoundary !== void 0 && storedBoundary.maxTokens === history.maxTokens && storedBoundary.atMaxRemoveTokens === history.atMaxRemoveTokens ? storedBoundary : void 0;
+				rawMessages = (await (0, _mastra_core_memory.loadMessageHistory)({
+					storage: memoryStore,
+					threadId,
+					resourceId,
+					boundary,
+					filter,
+					maxMessages: history.maxMessages,
+					maxTokens: history.maxTokens,
+					atMaxRemoveTokens: history.atMaxRemoveTokens,
+					tokenCounter: new TokenCounter(),
+					initialTokens: 24
+				})).messages;
+				if (include.length) {
+					const semanticMessages = await memoryStore.listMessages({
+						threadId,
+						resourceId,
+						perPage: 0,
+						include,
+						includeTotal: false
+					});
+					rawMessages = new _mastra_core_agent.MessageList({
+						threadId,
+						resourceId
+					}).add(rawMessages, "memory").add(semanticMessages.messages.filter((message) => !boundary || (0, _mastra_core_memory.isAfterMemoryTokenBoundary)(message, boundary)), "memory").get.all.db();
+				}
+				resultPage = 0;
+				resultPerPage = history.maxMessages ?? false;
+				total = rawMessages.length;
+				hasMore = false;
+			} else {
+				const effectivePerPage = historyDisabledByConfig ? 0 : perPage;
+				const paginatedResult = await memoryStore.listMessages({
+					threadId,
+					resourceId,
+					perPage: effectivePerPage,
+					page,
+					orderBy: effectiveOrderBy,
+					filter,
+					...includeTotal !== void 0 ? { includeTotal } : {},
+					...include.length ? { include } : {}
+				});
+				rawMessages = shouldGetNewestAndReverse ? paginatedResult.messages.reverse() : paginatedResult.messages;
+				({total, page: resultPage, perPage: resultPerPage, hasMore} = paginatedResult);
+			}
 			const messages = filterSystemReminderMessages(new _mastra_core_agent.MessageList({
 				threadId,
 				resourceId
 			}).add(rawMessages, "memory").get.all.db(), includeSystemReminders, hideSignals);
-			const { total, page: resultPage, perPage: resultPerPage, hasMore } = paginatedResult;
 			const recallResult = {
 				messages,
 				usage,
@@ -35185,6 +35822,13 @@ var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 		});
 		return savedThread;
 	}
+	/**
+	* Update a thread's title or metadata.
+	*
+	* Unlike `session.thread.rename()`, this does not pin the title, so
+	* Observational Memory may still replace it with an extracted title. To
+	* protect a manual rename, set `metadata.titlePinned` to `true`.
+	*/
 	async updateThread({ id, title, metadata, memoryConfig }) {
 		const updatedThread = await (await this.getMemoryStore()).patchThread({
 			id,
@@ -35207,6 +35851,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));
@@ -35611,8 +36257,8 @@ ${workingMemory}`;
 		if (config.workingMemory?.schema) try {
 			const schema = config.workingMemory.schema;
 			let convertedSchema;
-			if (require_schema_D_ikovK6.isStandardSchemaWithJSON(schema)) convertedSchema = schema["~standard"].jsonSchema.output({ target: "draft-07" });
-			else convertedSchema = require_schema_D_ikovK6.toStandardSchema(schema)["~standard"].jsonSchema.output({ target: "draft-07" });
+			if (require_schema_BwlBcZRB.isStandardSchemaWithJSON(schema)) convertedSchema = schema["~standard"].jsonSchema.output({ target: "draft-07" });
+			else convertedSchema = require_schema_BwlBcZRB.toStandardSchema(schema)["~standard"].jsonSchema.output({ target: "draft-07" });
 			return {
 				format: "json",
 				content: JSON.stringify(convertedSchema)
@@ -35753,16 +36399,52 @@ ${workingMemory}`;
 				messages = runState ? await runState.load(`observational-memory:messages:thread:${threadId}:${boundary}`, loadMessages) : await loadMessages();
 			}
 		} else {
-			const lastMessages = config.lastMessages;
-			if (lastMessages === false) messages = [];
-			else messages = (await memoryStore.listMessages({
+			const lastMessages = (0, _mastra_core_memory.normalizeMessageHistoryConfig)(config.lastMessages, config.messageHistory);
+			if (!lastMessages.enabled) messages = [];
+			else if (lastMessages.maxTokens !== void 0) {
+				const storedBoundary = (0, _mastra_core_memory.getMemoryTokenBoundary)(await memoryStore.getThreadById({
+					threadId,
+					resourceId
+				}));
+				const boundary = storedBoundary?.maxTokens === lastMessages.maxTokens && storedBoundary.atMaxRemoveTokens === lastMessages.atMaxRemoveTokens ? storedBoundary : void 0;
+				const tokenCounter = this.createMemoryTokenCounter();
+				const loaded = await (0, _mastra_core_memory.loadMessageHistory)({
+					storage: memoryStore,
+					threadId,
+					resourceId,
+					boundary,
+					maxMessages: lastMessages.maxMessages,
+					maxTokens: lastMessages.maxTokens,
+					tokenCounter,
+					initialTokens: 24
+				});
+				const messageList = new _mastra_core_agent.MessageList();
+				messageList.add(loaded.messages, "memory");
+				if (systemParts.length) messageList.addSystem(systemParts.join("\n\n"));
+				await new _mastra_core_processors.TokenLimiterProcessor({
+					limit: lastMessages.maxTokens,
+					atMaxRemoveTokens: lastMessages.atMaxRemoveTokens,
+					trimMode: "memory-only",
+					tokenCounter
+				}).processInput({
+					messageList,
+					messages: messageList.get.all.db(),
+					systemMessages: messageList.getAllSystemMessages(),
+					state: {},
+					retryCount: 0,
+					abort: (reason) => {
+						throw new Error(reason);
+					}
+				});
+				messages = messageList.get.all.db();
+			} else messages = (await memoryStore.listMessages({
 				threadId,
 				resourceId,
 				orderBy: {
 					field: "createdAt",
 					direction: "DESC"
 				},
-				perPage: typeof lastMessages === "number" ? lastMessages : void 0,
+				perPage: lastMessages.maxMessages,
 				includeTotal: false
 			})).messages.reverse();
 		}
@@ -37692,23 +38374,23 @@ const createModelInstance = async (provider, modelId, version = "v2") => {
 	try {
 		const providerFn = version === `v1` ? { v1: {
 			openai: async () => {
-				const { openai } = await Promise.resolve().then(() => require("./dist-CLQt62Pi.cjs"));
+				const { openai } = await Promise.resolve().then(() => require("./dist-DO5NHh-t.cjs"));
 				return openai(modelId);
 			},
 			anthropic: async () => {
-				const { anthropic } = await Promise.resolve().then(() => require("./dist-DpM-6UBk.cjs"));
+				const { anthropic } = await Promise.resolve().then(() => require("./dist-vM0zJcP5.cjs"));
 				return anthropic(modelId);
 			},
 			groq: async () => {
-				const { groq } = await Promise.resolve().then(() => require("./dist-C76EmJsT.cjs"));
+				const { groq } = await Promise.resolve().then(() => require("./dist-CkFmsB2E.cjs"));
 				return groq(modelId);
 			},
 			xai: async () => {
-				const { xai } = await Promise.resolve().then(() => require("./dist-D6F_HzDS.cjs"));
+				const { xai } = await Promise.resolve().then(() => require("./dist-B0uCWZUF.cjs"));
 				return xai(modelId);
 			},
 			google: async () => {
-				const { google } = await Promise.resolve().then(() => require("./dist-C9yKk16g.cjs"));
+				const { google } = await Promise.resolve().then(() => require("./dist-BQ0VOLA9.cjs"));
 				return google(modelId);
 			}
 		} }[version][provider] : () => new _mastra_core_llm.ModelRouterLanguageModel(`${provider}/${modelId}`);
@@ -40379,7 +41061,7 @@ Return the actual exported names of the units, as well as the file names.`,
 				maxSteps: 100
 			});
 			else {
-				const jsonSchema = require_schema_D_ikovK6.standardSchemaToJSONSchema((0, _mastra_core_schema.toStandardSchema)(output));
+				const jsonSchema = require_schema_BwlBcZRB.standardSchemaToJSONSchema((0, _mastra_core_schema.toStandardSchema)(output));
 				result = await agent.generateLegacy(prompt, {
 					experimental_output: jsonSchema,
 					maxSteps: 100
@@ -47287,4 +47969,4 @@ const agentBuilderWorkflows = {
 //#endregion
 exports.agentBuilderWorkflows = agentBuilderWorkflows;
 
-//# sourceMappingURL=dist-BKxbtiJd.cjs.map
+//# sourceMappingURL=dist-CF1rK7oZ.cjs.map