@mastra/memory 1.37.1 → 1.38.0-alpha.0

package/dist/{src-BU8L6v1o.cjs → src-BfhwVNr7.cjs}

@@ -23844,6 +23844,7 @@ async function summarizeConversation(opts) {
 			providerOptions: OBSERVATIONAL_MEMORY_DEFAULTS.observation.providerOptions,
 			maxTokensPerBatch: OBSERVATIONAL_MEMORY_DEFAULTS.observation.maxTokensPerBatch,
 			bufferOnIdle: false,
+			observeOnContextOverflow: false,
 			observeAttachments: "auto",
 			instruction: opts.instructions,
 			threadTitle: false,
@@ -31338,6 +31339,7 @@ var ObservationalMemory = class ObservationalMemory {
 			maxTokensPerBatch: config.observation?.maxTokensPerBatch ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.maxTokensPerBatch,
 			bufferTokens: asyncBufferingDisabled ? void 0 : resolveBufferTokens(config.observation?.bufferTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferTokens, config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens),
 			bufferOnIdle: config.observation?.bufferOnIdle ?? false,
+			observeOnContextOverflow: config.observation?.observeOnContextOverflow ?? true,
 			bufferActivation: asyncBufferingDisabled ? void 0 : config.observation?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferActivation,
 			activateAfterIdle: parseActivationTTLConfig(observationActivateAfterIdle, observationActivateAfterIdlePath),
 			activateOnProviderChange: config.observation?.activateOnProviderChange ?? config.activateOnProviderChange ?? false,
@@ -33358,7 +33360,9 @@ ${formattedMessages}
 				recordInsideLock = freshRecord;
 				generationBefore = freshRecord.generationCount;
 				const unobservedMessages = messages ? this.getUnobservedMessages(messages, freshRecord) : await this.loadMessagesFromStorage(threadId, resourceId, freshRecord.lastObservedAt ? new Date(freshRecord.lastObservedAt) : void 0);
-				if (!this.meetsObservationThreshold({
+				if (opts.force) {
+					if (unobservedMessages.length === 0) return;
+				} else if (!this.meetsObservationThreshold({
 					record: freshRecord,
 					unobservedTokens: await this.tokenCounter.countMessagesAsync(unobservedMessages)
 				})) return;
@@ -33666,6 +33670,55 @@ ${formattedMessages}
 	}
 };
 //#endregion
+//#region src/processors/observational-memory/context-overflow.ts
+/**
+* Detects provider errors that reject a request for exceeding the model's context window.
+*
+* Providers report this with different codes and wording, so this matches the known shapes
+* (OpenAI and OpenAI-compatible APIs, Anthropic, Google, Bedrock, xAI, Mistral, local servers)
+* against the error's message, code, response body and causes.
+*/
+const CONTEXT_OVERFLOW_PATTERNS = [
+	/context[_ ]length[_ ]exceeded/i,
+	/maximum context length/i,
+	/maximum prompt length/i,
+	/prompt is too long/i,
+	/input is too long/i,
+	/exceed\w*\b[^.]{0,40}\bcontext (?:window|length|limit|size)/i,
+	/input token count[^.]{0,40}exceeds the maximum/i,
+	/reduce the length of the (?:messages|prompt|input)/i
+];
+const MAX_CAUSE_DEPTH = 4;
+function collectErrorText(error, depth = 0) {
+	if (depth > MAX_CAUSE_DEPTH || error == null) return [];
+	if (typeof error === "string") return [error];
+	if (typeof error !== "object") return [];
+	const record = error;
+	const texts = [];
+	for (const key of [
+		"message",
+		"code",
+		"type",
+		"responseBody"
+	]) {
+		const value = record[key];
+		if (typeof value === "string") texts.push(value);
+	}
+	if (record.data && typeof record.data === "object") texts.push(...collectErrorText(record.data.error ?? record.data, depth + 1));
+	if (record.error && typeof record.error === "object") texts.push(...collectErrorText(record.error, depth + 1));
+	texts.push(...collectErrorText(record.cause, depth + 1));
+	return texts;
+}
+function isRateLimited(error, depth = 0) {
+	if (depth > MAX_CAUSE_DEPTH || error == null || typeof error !== "object") return false;
+	const record = error;
+	return record.statusCode === 429 || isRateLimited(record.cause, depth + 1);
+}
+function isContextOverflowError(error) {
+	if (isRateLimited(error)) return false;
+	return collectErrorText(error).some((text) => CONTEXT_OVERFLOW_PATTERNS.some((pattern) => pattern.test(text)));
+}
+//#endregion
 //#region src/processors/observational-memory/temporal-markers.ts
 const TEMPORAL_GAP_REMINDER_TYPE = "temporal-gap";
 function getTemporalGapReminderText(gapText, timestamp) {
@@ -33776,6 +33829,8 @@ function getOmObservabilityContext(args) {
 }
 /** Key used to store gateway detection result in per-processor state. */
 const GATEWAY_STATE_KEY = "__isGatewayModel";
+/** Step number OM last recovered from a context-overflow error, so each step retries at most once. */
+const CONTEXT_OVERFLOW_STEP_KEY = "__omContextOverflowStep";
 /** Check if the model is routed through a Mastra gateway (duck-type check to avoid cross-package instanceof issues). */
 function isMastraGatewayModel(model) {
 	return typeof model === "object" && model !== null && "gatewayId" in model && model.gatewayId === "mastra";
@@ -34015,6 +34070,42 @@ var ObservationalMemoryProcessor = class {
 			return messageList;
 		});
 	}
+	async processAPIError(args) {
+		const { error, messageList, requestContext, stepNumber, state } = args;
+		if (!this.engine.getObservationConfig().observeOnContextOverflow) return;
+		if (state[GATEWAY_STATE_KEY]) return;
+		if (state[CONTEXT_OVERFLOW_STEP_KEY] === stepNumber) return;
+		if (!isContextOverflowError(error)) return;
+		const context = this.engine.getThreadContext(requestContext, messageList);
+		if (!context) return;
+		if ((0, _mastra_core_memory.parseMemoryRequestContext)(requestContext)?.memoryConfig?.readOnly) return;
+		state[CONTEXT_OVERFLOW_STEP_KEY] = stepNumber;
+		omDebug(`[OM:processAPIError] context overflow at step ${stepNumber} — observing pending messages`);
+		const { threadId, resourceId } = context;
+		await this.engine.waitForBuffering(threadId, resourceId);
+		const messages = getObservableMessages(messageList);
+		const { activated } = await this.engine.activate({
+			threadId,
+			resourceId,
+			messages,
+			messageList,
+			writer: args.writer
+		});
+		const { observed } = await this.engine.getTokenCounter().runWithModelContext(state.__omActorModelContext, () => this.engine.observe({
+			threadId,
+			resourceId,
+			messages: getObservableMessages(messageList),
+			messageList,
+			force: true,
+			agent: args.agent,
+			sendSignal: args.sendSignal,
+			sendStateSignal: args.sendStateSignal,
+			requestContext,
+			writer: args.writer,
+			observabilityContext: getOmObservabilityContext(args)
+		}));
+		return { retry: activated || observed };
+	}
 	get config() {
 		return this.engine.config;
 	}
@@ -35468,6 +35559,7 @@ ${workingMemory}`;
 				providerOptions: omConfig.observation.providerOptions,
 				bufferTokens: omConfig.observation.bufferTokens,
 				bufferOnIdle: omConfig.observation.bufferOnIdle,
+				observeOnContextOverflow: omConfig.observation.observeOnContextOverflow,
 				bufferActivation: omConfig.observation.bufferActivation,
 				blockAfter: omConfig.observation.blockAfter,
 				previousObserverTokens: omConfig.observation.previousObserverTokens,
@@ -36546,6 +36638,17 @@ Notes:
 		return processors;
 	}
 	/**
+	* Extends the base implementation to add ObservationalMemory as an error processor.
+	* OM uses processAPIError to observe pending messages and retry when the provider
+	* rejects a request for exceeding the model's context window.
+	*/
+	async getErrorProcessors(configuredProcessors = [], context) {
+		const processors = await super.getErrorProcessors(configuredProcessors, context);
+		const om = await this.createOMProcessor(configuredProcessors, context);
+		if (om) processors.push(om);
+		return processors;
+	}
+	/**
 	* Creates an ObservationalMemory processor wrapping the shared engine.
 	* Returns null if OM is not configured, not supported, or already present
 	* in the user's configured processors.
@@ -36903,4 +37006,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-BU8L6v1o.cjs.map
+//# sourceMappingURL=src-BfhwVNr7.cjs.map