@mastra/memory 1.31.0-alpha.0 → 1.31.0-alpha.2

package/dist/{src-DqLGJfSb.js → src-DquR-jTR.js}

@@ -5,7 +5,7 @@ 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, getMemoryTokenBoundary, getThreadOMMetadata, isAfterMemoryTokenBoundary, loadMessageHistory, normalizeMessageHistoryConfig, parseMemoryRequestContext, setThreadOMMetadata } from "@mastra/core/memory";
+import { MastraMemory, getMemoryTokenBoundary, getThreadOMMetadata, isAfterMemoryTokenBoundary, isThreadTitlePinned, 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";
@@ -18,7 +18,7 @@ import { appendFileSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { createTool } from "@mastra/core/tools";
 import { MASTRA_THREAD_ID_KEY, RequestContext } from "@mastra/core/request-context";
-import { modelSupportsAttachments, resolveModelConfig } from "@mastra/core/llm";
+import { modelSupportsAttachments, modelSupportsTemperature, resolveModelConfig } from "@mastra/core/llm";
 import { estimateTokenCount } from "tokenx";
 import { AsyncLocalStorage } from "async_hooks";
 import probeImageSizeSync from "probe-image-size/sync.js";
@@ -22778,13 +22778,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");
@@ -22795,7 +22795,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
 			});
@@ -22834,7 +22834,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");
@@ -22845,7 +22845,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,
@@ -22862,7 +22862,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,
@@ -23021,7 +23021,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 ? [
@@ -23232,23 +23233,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
 			});
 		}
 	});
@@ -24354,7 +24357,8 @@ function stripThreadTags(observations) {
 }
 //#endregion
 //#region src/processors/observational-memory/observation-groups.ts
-const OBSERVATION_GROUP_PATTERN = /<observation-group\s([^>]*)>([\s\S]*?)<\/observation-group>/g;
+const OBSERVATION_GROUP_OPEN = "<observation-group";
+const OBSERVATION_GROUP_CLOSE = "</observation-group>";
 const ATTRIBUTE_PATTERN = /([\w][\w-]*)="([^"]*)"/g;
 const REFLECTION_GROUP_SPLIT_PATTERN = /^##\s+Group\s+/m;
 function parseObservationGroupAttributes(attributeString) {
@@ -24365,6 +24369,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 [];
@@ -24389,9 +24468,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;
@@ -24399,54 +24477,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
 		};
@@ -24874,6 +24994,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 (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();
@@ -25026,8 +25163,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 = getThreadOMMetadata(thread.metadata);
 			const metadataUpdate = buildThreadMetadataFromExtractedValues(processed.extractors ?? this.observationConfig.extractors, processed.extractedValues);
 			const newMetadata = setThreadOMMetadata(thread.metadata, {
@@ -25226,13 +25363,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 = getThreadOMMetadata(thread.metadata);
 				const metadataUpdate = buildThreadMetadataFromExtractedValues(processed.extractors ?? this.observationConfig.extractors, processed.extractedValues);
 				const newMetadata = setThreadOMMetadata(thread.metadata, {
@@ -25589,8 +25727,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 = getThreadOMMetadata(thread.metadata);
 				const metadataUpdate = buildThreadMetadataFromExtractedValues(update.extractors ?? this.observationConfig.extractors, update.extracted);
 				const newMetadata = setThreadOMMetadata(thread.metadata, {
@@ -28023,11 +28161,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 modelSupportsTemperature(model) === true;
+			if (model && typeof model === "object" && "provider" in model && "modelId" in model && typeof model.provider === "string" && typeof model.modelId === "string") return 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;
@@ -28043,7 +28189,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,
@@ -28069,7 +28215,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,
@@ -29793,9 +29939,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 } : {},
@@ -31187,6 +31332,13 @@ var Memory = class Memory extends 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,
@@ -32942,4 +33094,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-DqLGJfSb.js.map
+//# sourceMappingURL=src-DquR-jTR.js.map