@mastra/memory 1.30.0-alpha.3 → 1.30.0

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

@@ -25266,10 +25266,61 @@ async function loadMemoryContextMessages({ memory, messageList, threadId, resour
 		resourceId,
 		runState
 	});
-	for (const msg of ctx.messages) if (msg.role !== "system") messageList.add(msg, "memory");
+	const existingIds = new Set(messageList.get.all.db().map((message) => message.id));
+	for (const msg of ctx.messages) if (msg.role !== "system" && !existingIds.has(msg.id)) messageList.add(msg, "memory");
 	return ctx;
 }
 //#endregion
+//#region src/processors/observational-memory/observation-turn/safe-buffer-prefix.ts
+function hasPendingToolCall(message) {
+	return message.content.parts?.some((part) => part.type === "tool-invocation" && part.toolInvocation.state === "call") ?? false;
+}
+/**
+* Selects the unobserved messages that are safe to buffer while a tool call
+* may still be in flight.
+*
+* Only the chronologically last candidate can hold a live pending call: a
+* `tool-invocation` still in state `call` (client- or provider-executed) on the
+* newest message means the request ended waiting for its result. Any earlier
+* `call` is an orphan — the conversation already continued past it, and core's
+* output converter drops or placeholder-pairs it before the prompt reaches a
+* provider — so it is buffered like any other message.
+*
+* When the last candidate is pending, the prefix before it is buffered, but only
+* when the cut is clean. The cut is unsafe — and the whole attempt is deferred —
+* when:
+*
+* - Cursor collision: buffering advances the persisted cursor to
+*   `max(buffered.createdAt) + 1ms`, and later candidate selection requires
+*   `createdAt > cursor`. If the retained message sits at the same or +1ms
+*   timestamp, the cursor would permanently hide it even after its result
+*   arrives.
+* - Split tool exchange: a `toolCallId` appears on both sides of the cut, so
+*   the observer would see half of a tool exchange.
+* - Ambiguous tail: several candidates share the newest timestamp and one of
+*   them holds a pending call. `createdAt` alone cannot say which is really
+*   last, so the pending call is treated as the tail and the attempt deferred.
+*
+* The result is always in chronological order. When the tail has no pending
+* call, every message is returned. An empty result means "defer this buffering
+* attempt" — callers must skip buffering entirely. Raw message persistence is
+* unaffected and happens elsewhere; the retained message becomes eligible again
+* once its tool call completes.
+*/
+function selectSafeBufferPrefix(messages) {
+	const chronological = [...messages].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+	const last = chronological[chronological.length - 1];
+	if (!last) return chronological;
+	const newestTime = new Date(last.createdAt).getTime();
+	const newestGroup = chronological.filter((message) => new Date(message.createdAt).getTime() === newestTime);
+	if (!newestGroup.some(hasPendingToolCall)) return chronological;
+	if (newestGroup.length > 1) return [];
+	const prefix = chronological.slice(0, -1);
+	const retainedTime = new Date(last.createdAt).getTime();
+	const retainedToolIds = new Set((last.content.parts ?? []).flatMap((part) => part.type === "tool-invocation" ? [part.toolInvocation.toolCallId] : []));
+	return prefix.some((message) => new Date(message.createdAt).getTime() + 1 >= retainedTime || message.content.parts?.some((part) => part.type === "tool-invocation" && retainedToolIds.has(part.toolInvocation.toolCallId))) ? [] : prefix;
+}
+//#endregion
 //#region src/processors/observational-memory/observation-turn/step.ts
 /**
 * Represents a single step in the agentic loop within an observation turn.
@@ -25392,37 +25443,41 @@ var ObservationStep = class {
 			record: this.turn.record,
 			messages: getObservableMessages(messageList)
 		});
-		if (statusSnapshot.shouldBuffer && !hasIncompleteToolCalls) {
+		if (statusSnapshot.shouldBuffer) {
 			const allMessages = getObservableMessages(messageList);
 			const unobservedMessages = om.getUnobservedMessages(allMessages, statusSnapshot.record);
 			const candidates = om.getUnobservedMessages(unobservedMessages, statusSnapshot.record, { excludeBuffered: true });
-			if (candidates.length > 0) {
-				om.sealMessagesForBuffering(candidates);
+			const safeCandidates = selectSafeBufferPrefix(candidates);
+			const deferred = candidates.length > 0 && safeCandidates.length === 0;
+			if (safeCandidates.length > 0) {
+				om.sealMessagesForBuffering(safeCandidates);
 				try {
 					await this.turn.hooks?.onBufferChunkSealed?.();
 				} catch (error) {
 					omDebug(`[OM:buffer] onBufferChunkSealed hook failed: ${error instanceof Error ? error.message : String(error)}`);
 				}
-				if (this.turn.memory) await this.turn.memory.persistMessages(candidates);
-				messageList.removeByIds(candidates.map((msg) => msg.id));
-				for (const msg of candidates) messageList.add(msg, "memory");
+				if (this.turn.memory) await this.turn.memory.persistMessages(safeCandidates);
+				messageList.removeByIds(safeCandidates.map((msg) => msg.id));
+				for (const msg of safeCandidates) messageList.add(msg, "memory");
+			}
+			if (!deferred) {
+				om.trackBackgroundWork(om.buffer({
+					threadId,
+					resourceId,
+					messages: safeCandidates,
+					pendingTokens: statusSnapshot.pendingTokens,
+					record: statusSnapshot.record,
+					writer: this.turn.writer,
+					agent: this.turn.agent,
+					sendSignal: this.turn.sendSignal,
+					sendStateSignal: this.turn.sendStateSignal,
+					requestContext: this.turn.requestContext,
+					observabilityContext: this.turn.observabilityContext
+				}).catch((err) => {
+					omDebug(`[OM:buffer] fire-and-forget buffer failed: ${err?.message}`);
+				}));
+				buffered = true;
 			}
-			om.trackBackgroundWork(om.buffer({
-				threadId,
-				resourceId,
-				messages: unobservedMessages,
-				pendingTokens: statusSnapshot.pendingTokens,
-				record: statusSnapshot.record,
-				writer: this.turn.writer,
-				agent: this.turn.agent,
-				sendSignal: this.turn.sendSignal,
-				sendStateSignal: this.turn.sendStateSignal,
-				requestContext: this.turn.requestContext,
-				observabilityContext: this.turn.observabilityContext
-			}).catch((err) => {
-				omDebug(`[OM:buffer] fire-and-forget buffer failed: ${err?.message}`);
-			}));
-			buffered = true;
 		}
 		const willObserveNow = statusSnapshot.shouldObserve && !hasIncompleteToolCalls;
 		/** In-flight message ids the step-0 cleanup must never remove from live context. */
@@ -25797,11 +25852,11 @@ var ObservationTurn = class {
 		if (asyncObservationEnabled && bufferOnIdle) {
 			const allMessages = getObservableMessages(this.messageList);
 			const record = this._record;
-			const unobservedMessages = this.om.getUnobservedMessages(allMessages, record);
-			if (unobservedMessages.length > 0) this.om.trackBackgroundWork(this.om.buffer({
+			const idleMessages = selectSafeBufferPrefix(this.om.getUnobservedMessages(allMessages, record));
+			if (idleMessages.length > 0) this.om.trackBackgroundWork(this.om.buffer({
 				threadId: this.threadId,
 				resourceId: this.resourceId,
-				messages: unobservedMessages,
+				messages: idleMessages,
 				record,
 				writer: this.writer,
 				agent: this.agent,
@@ -27529,15 +27584,18 @@ var ObservationalMemory = class ObservationalMemory {
 		this.hookExecution = config.hookExecution ?? "non-blocking";
 		this.mastra = config.mastra;
 		this.memory = config.memory;
+		const topLevelModel = config.model;
+		const observationConfigModel = config.observation?.model;
+		const reflectionConfigModel = config.reflection?.model;
 		const resolveModel = (model, defaultModel) => model === "default" ? defaultModel : model;
-		const observationModel = resolveModel(config.model, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? resolveModel(config.observation?.model, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? resolveModel(config.reflection?.model, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.model;
-		const reflectionModel = resolveModel(config.model, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? resolveModel(config.reflection?.model, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? resolveModel(config.observation?.model, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model;
+		const observationModel = resolveModel(topLevelModel, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? resolveModel(observationConfigModel, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? resolveModel(reflectionConfigModel, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.model;
+		const reflectionModel = resolveModel(topLevelModel, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? resolveModel(reflectionConfigModel, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? resolveModel(observationConfigModel, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model;
 		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 observationSelectedModel = config.model ?? config.observation?.model ?? config.reflection?.model;
-		const reflectionSelectedModel = config.model ?? config.reflection?.model ?? config.observation?.model;
+		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 totalBudget = messageTokens + observationTokens;
@@ -30257,6 +30315,16 @@ function normalizeObservationalMemoryConfig(config) {
 	if (typeof config === "object" && config.enabled === false) return void 0;
 	return config;
 }
+/**
+* Observer model selection (`observation.model`, else top-level `model`), read into the widened
+* model type first: combining values of the public type makes TS subtype-reduce the model-id
+* literal union, which fails with TS2590 once the provider registry is large enough.
+*/
+function selectObserverModel(omConfig) {
+	const observationModel = omConfig.observation?.model;
+	const topLevelModel = omConfig.model;
+	return observationModel ?? topLevelModel;
+}
 function hasWorkingMemoryExtractor(extractors) {
 	return !!extractors?.some((extractor) => extractor.slug === "working-memory");
 }
@@ -30374,7 +30442,7 @@ var Memory = class Memory extends MastraMemory {
 		const extract = observation.extract ?? [];
 		const existingSlugs = new Set(extract.map((extractor) => extractor.slug));
 		let curatorMemory;
-		const subconsciousExtractors = omConfig.experimental_subconscious.createObservationExtractors(observation.model ?? omConfig.model, () => curatorMemory ??= new Memory({
+		const subconsciousExtractors = omConfig.experimental_subconscious.createObservationExtractors(selectObserverModel(omConfig), () => curatorMemory ??= new Memory({
 			storage: this.storage,
 			options: { observationalMemory: false }
 		})).filter((extractor) => !existingSlugs.has(extractor.slug));
@@ -31680,7 +31748,7 @@ Notes:
 			if (remind && "builtIn" in remind) tools.ask_memory = createAskMemoryTool({
 				memory: this,
 				config: remind,
-				omModel: omConfig.observation?.model ?? omConfig.model,
+				omModel: selectObserverModel(omConfig),
 				getParentAgent: (agentId) => this._mastraInstance?.getAgentById(agentId)
 			});
 		}
@@ -32359,4 +32427,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-t3Mhge0m.js.map
+//# sourceMappingURL=src-Dt8oPiQN.js.map