@mastra/server 1.78.0-alpha.1 → 1.78.0-alpha.3

package/dist/_types/@mastra_schema-compat/dist/provider-compats/openai-reasoning.d.ts

@@ -3,7 +3,6 @@ import type { ZodType } from '../schema.types.js';
 import { OpenAISchemaCompatLayer } from './openai.js';
 export declare class OpenAIReasoningSchemaCompatLayer extends OpenAISchemaCompatLayer {
     getSchemaTarget(): Targets | undefined;
-    isReasoningModel(): boolean;
     shouldApply(): boolean;
     processZodType(value: ZodType): ZodType;
 }

package/dist/_types/@mastra_schema-compat/dist/provider-compats/openai.d.ts

@@ -6,6 +6,10 @@ import type { Schema } from '../json-schema/index.js';
 import { SchemaCompatLayer } from '../schema-compatibility.js';
 import type { PublicSchema, ZodType } from '../schema.types.js';
 import type { StandardSchemaWithJSON } from '../standard-schema/standard-schema.types.js';
+export declare function isOpenAICompatibleModel(model: {
+    provider?: string;
+    modelId?: string;
+}): boolean;
 export declare class OpenAISchemaCompatLayer extends SchemaCompatLayer {
     #private;
     getSchemaTarget(): Targets | undefined;

package/dist/{dist-aAfueiQI.js → dist-0eJzATDs.js}

@@ -4637,7 +4637,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-DWoBX5f9.js
+//#region ../memory/dist/src-CnLuefUv.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -28315,6 +28315,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,
@@ -35745,6 +35746,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,
@@ -37765,7 +37767,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;
@@ -38072,6 +38076,53 @@ ${formattedMessages}
 		});
 	}
 };
+/**
+* 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)));
+}
 const TEMPORAL_GAP_REMINDER_TYPE = "temporal-gap";
 function getTemporalGapReminderText(gapText, timestamp) {
 	return `${gapText} — ${formatTemporalTimestamp(new Date(timestamp))}`;
@@ -38179,6 +38230,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";
@@ -38418,6 +38471,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 (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;
 	}
@@ -39850,6 +39939,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,
@@ -40928,6 +41018,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.
@@ -51758,4 +51859,4 @@ const agentBuilderWorkflows = {
 //#endregion
 export { agentBuilderWorkflows };
 
-//# sourceMappingURL=dist-aAfueiQI.js.map
+//# sourceMappingURL=dist-0eJzATDs.js.map