@mastra/memory 1.30.0 → 1.31.0-alpha.1

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

@@ -39,6 +39,7 @@ let _mastra_core_agent = require("@mastra/core/agent");
 let _mastra_core_features = require("@mastra/core/features");
 let _mastra_core_memory = require("@mastra/core/memory");
 let _mastra_core_observability = require("@mastra/core/observability");
+let _mastra_core_processors = require("@mastra/core/processors");
 let _mastra_core_utils = require("@mastra/core/utils");
 let _mastra_schema_compat_schema = require("@mastra/schema-compat/schema");
 let async_mutex = require("async-mutex");
@@ -57,7 +58,6 @@ 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);
 let _mastra_core_schema = require("@mastra/core/schema");
 let _mastra_core_error = require("@mastra/core/error");
-let _mastra_core_processors = require("@mastra/core/processors");
 let diff = require("diff");
 let util = require("util");
 //#region ../_vendored/ai_v4/dist/dist-Cm5DZgxA.js
@@ -3735,7 +3735,7 @@ function trimStartOfStream() {
 	};
 }
 //#endregion
-//#region ../_vendored/ai_v5/dist/dist-Dqv4QeJJ.js
+//#region ../_vendored/ai_v5/dist/dist-DCHMJHX3.js
 var marker$1$4 = "vercel.ai.error";
 var symbol$1$3 = Symbol.for(marker$1$4);
 var _a$1$3;
@@ -18326,6 +18326,358 @@ function safeSlice(str, end) {
 	return str.slice(0, safeEnd);
 }
 //#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;
+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) {
+	if (path.length <= OBSERVER_TOOL_ARGUMENT_MAX_PATH_CHARS) return path;
+	const headLength = 50;
+	const tailLength = 60;
+	const omitted = path.length - headLength - tailLength;
+	return `${safeSlice(path, headLength)}…[${omitted} chars; ${stablePathDigest(path)}]…${safeTail(path, 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 && (0, tokenx.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 (0, tokenx.estimateTokenCount)(a.text) - (0, tokenx.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, value, limits, prefix = "") {
+	const sanitizedValue = sanitizeSurrogates(value);
+	const marker = (visible) => {
+		const omitted = sanitizedValue.length - visible.length;
+		return `${path}:\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 = formatPath(current.path, entry.key, Array.isArray(current.value));
+			outlineEntries++;
+			if (entry.unavailable) {
+				outline.push({
+					text: `${path}: [${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}: <string, ${entryValue.length} characters; preview size-limited>`,
+					depth: current.depth,
+					order: order++
+				});
+				previews.push({
+					path,
+					value: entryValue
+				});
+				continue;
+			}
+			if (!isObjectLike$1(entryValue)) {
+				outline.push({
+					text: `${path}: ${formatPrimitive(entryValue)}`,
+					depth: current.depth,
+					order: order++
+				});
+				continue;
+			}
+			if (current.ancestors.has(entryValue)) {
+				outline.push({
+					text: `${path}: [circular]`,
+					depth: current.depth,
+					order: order++
+				});
+				continue;
+			}
+			const summary = containerSummary(entryValue);
+			if (current.depth >= OBSERVER_TOOL_ARGUMENT_MAX_DEPTH) {
+				outline.push({
+					text: `${path}: ${summary} [max depth reached]`,
+					depth: current.depth,
+					order: order++
+				});
+				continue;
+			}
+			outline.push({
+				text: `${path}: ${summary}`,
+				depth: current.depth,
+				order: order++
+			});
+			pending.push({
+				path,
+				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 - (0, tokenx.estimateTokenCount)(rendered));
+		const remainingCharacters = Math.max(0, limits.maxCharacters - rendered.length - 1);
+		const previewLimits = {
+			maxTokens: (0, tokenx.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;
+}
+//#endregion
 //#region src/processors/observational-memory/tool-result-helpers.ts
 const ENCRYPTED_CONTENT_KEY = "encryptedContent";
 const ENCRYPTED_CONTENT_REDACTION_THRESHOLD = 256;
@@ -18404,7 +18756,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);
 }
 //#endregion
 //#region src/processors/observational-memory/observer-agent.ts
@@ -19091,9 +19443,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 = [];
@@ -19120,14 +19515,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;
 			}
-			pushLine(`Tool Call ${inv.toolName}`, maybeTruncate(JSON.stringify(inv.args, null, 2), maxLen), partCreatedAt);
+			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;
+			}
+			if (!exchange) pushLine(`Tool Call ${inv.toolName}`, formatObserverToolArguments(inv.args, maxLen), partCreatedAt);
 			return;
 		}
 		const partType = part.type;
@@ -19161,10 +19573,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;
@@ -19187,13 +19600,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);
 	});
@@ -19221,10 +19635,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;
@@ -19920,15 +20335,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.
@@ -21574,7 +21988,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);
@@ -21620,8 +22034,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 {
@@ -21629,6 +22046,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,
@@ -21638,7 +22058,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,
@@ -21648,7 +22071,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,
@@ -21675,7 +22101,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);
@@ -24465,6 +24896,23 @@ var ObservationStrategy = class ObservationStrategy {
 	}
 };
 //#endregion
+//#region src/processors/observational-memory/observation-strategies/thread-title.ts
+/**
+* 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;
+}
+//#endregion
 //#region src/processors/observational-memory/observation-strategies/sync.ts
 var SyncObservationStrategy = class extends ObservationStrategy {
 	startedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -24617,8 +25065,8 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 		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, {
@@ -24817,13 +25265,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, {
@@ -25180,8 +25629,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, {
@@ -26331,15 +26780,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 {
@@ -29385,9 +29833,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 } : {},
@@ -30390,6 +30837,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;
@@ -30560,6 +31010,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;
@@ -30580,6 +31031,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,
@@ -30589,9 +31043,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",
@@ -30620,21 +31088,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;
@@ -30656,28 +31109,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,
@@ -30730,6 +31226,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,
@@ -31298,16 +31801,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();
 		}
@@ -32730,4 +33269,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-oL_dDHN9.cjs.map
+//# sourceMappingURL=src-BCvV2aGL.cjs.map