@mastra/server 1.67.0-alpha.4 → 1.67.0-alpha.6

package/dist/{dist-8iDh9UbP.js → dist-DOpm-tIl.js}

@@ -4693,7 +4693,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-t3Mhge0m.js
+//#region ../memory/dist/src-Dt8oPiQN.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -29781,9 +29781,58 @@ 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;
 }
+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;
+}
 /**
 * Represents a single step in the agentic loop within an observation turn.
 *
@@ -29905,37 +29954,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. */
@@ -30308,11 +30361,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,
@@ -32032,15 +32085,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;
@@ -34735,6 +34791,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");
 }
@@ -34852,7 +34918,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));
@@ -36158,7 +36224,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)
 			});
 		}
@@ -47217,4 +47283,4 @@ const agentBuilderWorkflows = {
 //#endregion
 export { agentBuilderWorkflows };
 
-//# sourceMappingURL=dist-8iDh9UbP.js.map
+//# sourceMappingURL=dist-DOpm-tIl.js.map