@mastra/memory 1.30.0-alpha.2 → 1.30.0-alpha.4

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

@@ -19819,19 +19819,28 @@ const PHASE_CONFIG = {
 };
 async function withOmTracingSpan({ phase, model, inputTokens, requestContext, observabilityContext, metadata, callback }) {
 	const config = PHASE_CONFIG[phase];
+	const tracingContext = observabilityContext?.tracingContext ?? observabilityContext?.tracing;
+	const callerMetadata = tracingContext?.currentSpan?.metadata;
+	const inheritedCallerThreadId = callerMetadata?.__mastraObservationalMemoryCallerThreadId;
+	const callerThreadId = callerMetadata?.threadId;
+	const requestThreadId = requestContext?.get(_mastra_core_request_context.MASTRA_THREAD_ID_KEY);
+	const omCallerThreadId = typeof inheritedCallerThreadId === "string" && inheritedCallerThreadId ? inheritedCallerThreadId : typeof callerThreadId === "string" && callerThreadId ? callerThreadId : typeof requestThreadId === "string" && requestThreadId ? requestThreadId : void 0;
 	const span = (0, _mastra_core_observability.getOrCreateSpan)({
 		type: _mastra_core_observability.SpanType.MEMORY_OPERATION,
 		name: config.name,
 		entityType: _mastra_core_observability.EntityType.MEMORY,
 		entityName: config.entityName,
-		tracingContext: observabilityContext?.tracingContext ?? observabilityContext?.tracing,
+		tracingContext,
 		attributes: {
 			operationType: config.operationType,
 			inputTokens,
 			selectedModel: typeof model === "string" ? model : "(dynamic-model)",
 			...config.multiThread ? { multiThread: true } : {}
 		},
-		metadata,
+		metadata: omCallerThreadId !== void 0 ? {
+			...metadata,
+			__mastraObservationalMemoryCallerThreadId: omCallerThreadId
+		} : metadata,
 		requestContext
 	});
 	const childObservabilityContext = (0, _mastra_core_observability.createObservabilityContext)({ currentSpan: span });
@@ -25279,10 +25288,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.
@@ -25405,37 +25465,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. */
@@ -25810,11 +25874,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,
@@ -27542,15 +27606,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;
@@ -28513,7 +28580,7 @@ ${formattedMessages}
 		if (!this.buffering.isAsyncObservationEnabled()) return false;
 		const lockKey = this.buffering.getLockKey(opts.threadId, opts.resourceId);
 		const shouldTrigger = this.buffering.shouldTriggerAsyncObservation(opts.pendingTokens, lockKey, opts.record, this.storage, opts.threshold);
-		if (shouldTrigger) this.trackBackgroundWork(this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext));
+		if (shouldTrigger) this.trackBackgroundWork(this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext, opts.observabilityContext));
 		return shouldTrigger;
 	}
 	isMessageList(value) {
@@ -30270,6 +30337,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");
 }
@@ -30387,7 +30464,7 @@ var Memory = class Memory extends _mastra_core_memory.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));
@@ -31693,7 +31770,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)
 			});
 		}
@@ -32653,4 +32730,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-Bs9_1MCb.cjs.map
+//# sourceMappingURL=src-oL_dDHN9.cjs.map