@mastra/memory 1.30.0 → 1.31.0-alpha.0

package/dist/{src-Dt8oPiQN.js → src-DqLGJfSb.js}

@@ -5,8 +5,9 @@ import * as z4 from "zod/v4";
 import { z as z$1 } from "zod/v4";
 import { Agent, MessageList } from "@mastra/core/agent";
 import { coreFeatures } from "@mastra/core/features";
-import { MastraMemory, getThreadOMMetadata, parseMemoryRequestContext, setThreadOMMetadata } from "@mastra/core/memory";
+import { MastraMemory, getMemoryTokenBoundary, getThreadOMMetadata, isAfterMemoryTokenBoundary, loadMessageHistory, normalizeMessageHistoryConfig, parseMemoryRequestContext, setThreadOMMetadata } from "@mastra/core/memory";
 import { EntityType, SpanType, createObservabilityContext, getOrCreateSpan } from "@mastra/core/observability";
+import { MessageHistory, MessageHistory as MessageHistory$1, SemanticRecall, TokenLimiterProcessor, WorkingMemory } from "@mastra/core/processors";
 import { generateEmptyFromSchema } from "@mastra/core/utils";
 import { isStandardSchemaWithJSON, standardSchemaToJSONSchema, toStandardSchema } from "@mastra/schema-compat/schema";
 import { Mutex } from "async-mutex";
@@ -23,7 +24,6 @@ import { AsyncLocalStorage } from "async_hooks";
 import probeImageSizeSync from "probe-image-size/sync.js";
 import { isStandardSchemaWithJSON as isStandardSchemaWithJSON$1, toStandardSchema as toStandardSchema$1 } from "@mastra/core/schema";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
-import { MessageHistory, MessageHistory as MessageHistory$1, SemanticRecall, WorkingMemory } from "@mastra/core/processors";
 import { structuredPatch } from "diff";
 import { inspect } from "util";
 //#region \0rolldown/runtime.js
@@ -3713,7 +3713,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;
@@ -18304,6 +18304,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 && 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, 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 - 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;
+}
+//#endregion
 //#region src/processors/observational-memory/tool-result-helpers.ts
 const ENCRYPTED_CONTENT_KEY = "encryptedContent";
 const ENCRYPTED_CONTENT_REDACTION_THRESHOLD = 256;
@@ -18382,7 +18734,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
@@ -19069,9 +19421,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 = [];
@@ -19098,14 +19493,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;
@@ -19139,10 +19551,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;
@@ -19165,13 +19578,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);
 	});
@@ -19199,10 +19613,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;
@@ -19898,15 +20313,14 @@ var ObserverRunner = class {
 		this.mastra = mastra;
 	}
 	createAgent(model, isMultiThread = false, memory, extractors = this.observationConfig.extractors ?? []) {
-		const agent = new Agent({
+		return new 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.
@@ -21552,7 +21966,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);
@@ -21598,8 +22012,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 {
@@ -21607,6 +22024,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,
@@ -21616,7 +22036,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,
@@ -21626,7 +22049,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,
@@ -21653,7 +22079,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);
@@ -26309,15 +26740,14 @@ var ReflectorRunner = class {
 		this.mastra = mastra;
 	}
 	createAgent(model, memory, extractors = this.reflectionConfig.extractors) {
-		const agent = new Agent({
+		return new 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 {
@@ -30368,6 +30798,9 @@ const DEFAULT_EMBEDDING_CACHE_MAX_SIZE = 1e3;
 * if packaged docs are unavailable.
 */
 var Memory = class Memory extends MastraMemory {
+	createMemoryTokenCounter() {
+		return new TokenCounter();
+	}
 	_omEngine;
 	_omEngineInstance;
 	_mastraInstance;
@@ -30538,6 +30971,7 @@ var Memory = class Memory extends 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;
@@ -30558,6 +30992,9 @@ var Memory = class Memory extends 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 = 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,
@@ -30567,9 +31004,23 @@ var Memory = class Memory extends 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",
@@ -30598,21 +31049,6 @@ var Memory = class Memory extends 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;
@@ -30634,28 +31070,71 @@ var Memory = class Memory extends 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 = 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 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 MessageList({
+						threadId,
+						resourceId
+					}).add(rawMessages, "memory").add(semanticMessages.messages.filter((message) => !boundary || 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 MessageList({
 				threadId,
 				resourceId
 			}).add(rawMessages, "memory").get.all.db(), includeSystemReminders, hideSignals);
-			const { total, page: resultPage, perPage: resultPerPage, hasMore } = paginatedResult;
 			const recallResult = {
 				messages,
 				usage,
@@ -31276,16 +31755,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 = normalizeMessageHistoryConfig(config.lastMessages, config.messageHistory);
+			if (!lastMessages.enabled) messages = [];
+			else if (lastMessages.maxTokens !== void 0) {
+				const storedBoundary = 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 loadMessageHistory({
+					storage: memoryStore,
+					threadId,
+					resourceId,
+					boundary,
+					maxMessages: lastMessages.maxMessages,
+					maxTokens: lastMessages.maxTokens,
+					tokenCounter,
+					initialTokens: 24
+				});
+				const messageList = new MessageList();
+				messageList.add(loaded.messages, "memory");
+				if (systemParts.length) messageList.addSystem(systemParts.join("\n\n"));
+				await new 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();
 		}
@@ -32427,4 +32942,4 @@ Notes:
 //#endregion
 export { formatMessagesForObserver as A, OBSERVATION_CONTINUATION_HINT as B, SUMMARIZE_THREAD_DEFAULTS as C, buildObserverPrompt as D, OBSERVER_SYSTEM_PROMPT as E, parseAnchorId as F, ModelByInputTokens as G, KnowledgeSemanticIndexCoordinator as H, stripEphemeralAnchorIds as I, publishSubconsciousActivity as J, SUBCONSCIOUS_ACTIVITY_STATE_ID as K, OBSERVATIONAL_MEMORY_DEFAULTS as L, optimizeObservationsForContext as M, parseObserverOutput as N, buildObserverSystemPrompt as O, injectAnchorIds as P, OBSERVATION_CONTEXT_INSTRUCTIONS as R, WorkingMemoryExtractor as S, TokenCounter as T, StaleKnowledgeSemanticIndexError as U, Subconscious as V, SubconsciousRemindExtractor as W, Extractor as X, renderSubconsciousActivity as Y, wrapInObservationGroup as _, extractWorkingMemoryContent as a, WorkingMemoryStateProcessor as b, getObservationsAsOf as c, combineObservationGroupRanges as d, deriveObservationGroupProvenance as f, stripObservationGroups as g, renderObservationGroupsForReflection as h, WorkingMemory as i, hasCurrentTaskSection as j, extractCurrentTask as k, ObservationalMemoryProcessor as l, reconcileObservationGroupsFromReflection as m, MessageHistory$1 as n, extractWorkingMemoryTags as o, parseObservationGroups as p, buildSubconsciousActivitySnapshot as q, SemanticRecall as r, removeWorkingMemoryTags as s, Memory as t, ObservationalMemory as u, WORKING_MEMORY_STATE_ID as v, summarizeConversation as w, deepMergeWorkingMemory as x, WORKING_MEMORY_STATE_PROCESSOR_ID as y, OBSERVATION_CONTEXT_PROMPT as z };
 
-//# sourceMappingURL=src-Dt8oPiQN.js.map
+//# sourceMappingURL=src-DqLGJfSb.js.map