@mastra/server 1.72.0-alpha.2 → 1.72.0-alpha.3

package/dist/{dist-ABdCIqbD.js → dist-Bo9o3JNW.js}

@@ -4637,7 +4637,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-B-_pkR2t.js
+//#region ../memory/dist/src-BikfoIdS.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -23223,9 +23223,224 @@ async function applyExtractorHooks(opts) {
 		failures: mergeExtractionFailures(failures)
 	};
 }
+/**
+* Retry knobs for the internal OM transport-error retry wrapper.
+* Exported as a mutable object so tests can shrink the backoff schedule
+* without changing public API.
+*
+* With the defaults the per-retry pre-jitter backoff schedule is:
+*   1s, 2s, 4s, 8s, 16s, 32s, 64s, 120s (cap)
+* giving 8 retries / 9 total attempts and ~247s (~4 minutes) of waiting
+* before the final attempt fails. Designed to ride out short provider /
+* network blips without holding the actor turn for much longer than that.
+*
+* @internal
+*/
+const RETRY_CONFIG = {
+	/** Maximum number of retry *attempts* (total tries = maxRetries + 1). */
+	maxRetries: 8,
+	/** Initial backoff delay in milliseconds. */
+	initialDelayMs: 1e3,
+	/** Multiplier applied to the delay after each failed attempt. */
+	backoffFactor: 2,
+	/** Cap on per-attempt delay (ms). */
+	maxDelayMs: 12e4,
+	/** Random jitter as a fraction of the computed delay (e.g. 0.2 = ±20%). */
+	jitter: .2
+};
+const TRANSIENT_MESSAGE_SUBSTRINGS = [
+	"terminated",
+	"fetch failed",
+	"econnreset",
+	"econnrefused",
+	"enotfound",
+	"eai_again",
+	"socket hang up",
+	"network error",
+	"request timed out",
+	"request timeout",
+	"connection reset",
+	"connection closed"
+];
 function isRecord$5(value) {
 	return typeof value === "object" && value !== null;
 }
+function isAbortError$1(error) {
+	if (!isRecord$5(error)) return false;
+	if (error.name === "AbortError") return true;
+	if (typeof error.code === "string" && error.code === "ABORT_ERR") return true;
+	return false;
+}
+function hasTransientMessage(value) {
+	if (!isRecord$5(value)) return false;
+	const message = typeof value.message === "string" ? value.message.toLowerCase() : "";
+	if (message && TRANSIENT_MESSAGE_SUBSTRINGS.some((sub) => message.includes(sub))) return true;
+	if (typeof value.code === "string" && value.code.toUpperCase().startsWith("UND_ERR_")) return true;
+	return false;
+}
+function isRetryableHttpStatus(status) {
+	if (status === 408 || status === 425 || status === 429) return true;
+	return status >= 500 && status <= 599;
+}
+function hasRetryableHttpStatus(value) {
+	if (!isRecord$5(value)) return false;
+	if (typeof value.statusCode === "number" && isRetryableHttpStatus(value.statusCode)) return true;
+	if (typeof value.code === "number" && isRetryableHttpStatus(value.code)) return true;
+	return false;
+}
+function hasIsRetryableFlag(value) {
+	if (!isRecord$5(value)) return false;
+	return value.isRetryable === true;
+}
+/**
+* Returns true when a user-initiated cancellation appears anywhere in the
+* error's `cause`/`error` wrapper chain, so a wrapped abort can never be
+* mistaken for a retryable or survivable provider failure.
+*
+* @internal
+*/
+function hasAbortInChain(error) {
+	const seen = /* @__PURE__ */ new Set();
+	function visit(candidate) {
+		if (isAbortError$1(candidate)) return true;
+		if (!isRecord$5(candidate)) return false;
+		if (seen.has(candidate)) return false;
+		seen.add(candidate);
+		return visit(candidate.cause) || visit(candidate.error);
+	}
+	return visit(error);
+}
+/**
+* Returns true when the given error looks like a transient transport-class
+* failure that's worth retrying — undici `terminated`, `fetch failed`,
+* `UND_ERR_*` codes, AI SDK `APICallError` with `isRetryable: true`, and
+* common HTTP 408/425/429/5xx statuses. Walks the `error.cause` chain so
+* wrapper errors don't hide the real failure.
+*
+* Never retries on user-initiated aborts.
+*
+* @internal
+*/
+function isTransientLLMError(error) {
+	if (hasAbortInChain(error)) return false;
+	const visited = /* @__PURE__ */ new WeakSet();
+	function visit(candidate) {
+		if (isRecord$5(candidate)) {
+			if (visited.has(candidate)) return false;
+			visited.add(candidate);
+		}
+		if (hasTransientMessage(candidate)) return true;
+		if (hasRetryableHttpStatus(candidate)) return true;
+		if (hasIsRetryableFlag(candidate)) return true;
+		if (isRecord$5(candidate)) {
+			if (visit(candidate.cause)) return true;
+			if (visit(candidate.error)) return true;
+		}
+		return false;
+	}
+	return visit(error);
+}
+/**
+* Compute the backoff delay (ms) for the Nth retry (0-indexed).
+*
+* Exponential growth (`initialDelayMs * backoffFactor^attempt`) capped at
+* `maxDelayMs`, then nudged by ±`jitter` (fractional). Exported for unit
+* tests that lock the schedule against drift.
+*
+* @internal
+*/
+function computeDelay(attempt) {
+	const base = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, attempt);
+	const capped = Math.min(base, RETRY_CONFIG.maxDelayMs);
+	if (RETRY_CONFIG.jitter <= 0) return capped;
+	const jitterRange = capped * RETRY_CONFIG.jitter;
+	const offset = (Math.random() * 2 - 1) * jitterRange;
+	return Math.max(0, Math.round(capped + offset));
+}
+function sleep(ms, abortSignal) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		if (abortSignal?.aborted) {
+			reject(/* @__PURE__ */ new Error("The operation was aborted."));
+			return;
+		}
+		const timer = setTimeout(() => {
+			abortSignal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			abortSignal?.removeEventListener("abort", onAbort);
+			reject(/* @__PURE__ */ new Error("The operation was aborted."));
+		};
+		abortSignal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Run `fn` with retries on transient transport-class errors.
+*
+* Non-transient errors (auth, validation, schema, etc.) are rethrown
+* immediately. User-initiated aborts are rethrown without delay.
+*
+* @internal
+*/
+async function withRetry(fn, opts) {
+	const { label, abortSignal, maxRetries = RETRY_CONFIG.maxRetries } = opts;
+	let attempt = 0;
+	while (true) {
+		if (abortSignal?.aborted) throw new Error("The operation was aborted.");
+		try {
+			return await fn();
+		} catch (error) {
+			if (hasAbortInChain(error) || abortSignal?.aborted) throw error;
+			if (attempt >= maxRetries || !isTransientLLMError(error)) {
+				if (attempt > 0) omDebug(`[OM:retry:${label}] giving up after ${attempt} retry/retries: ${error instanceof Error ? error.message : String(error)}`);
+				throw error;
+			}
+			const delay = computeDelay(attempt);
+			attempt++;
+			omDebug(`[OM:retry:${label}] transient error on attempt ${attempt}, retrying in ${delay}ms: ${error instanceof Error ? error.message : String(error)}`);
+			await sleep(delay, abortSignal);
+		}
+	}
+}
+const AI_API_CALL_ERROR_MARKER = Symbol.for("vercel.ai.error.AI_APICallError");
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null;
+}
+function isOmModelExecutionFailure(error) {
+	if (hasAbortInChain(error)) return false;
+	if (isTransientLLMError(error)) return true;
+	const visited = /* @__PURE__ */ new Set();
+	let current = error;
+	while (isRecord$4(current) && !visited.has(current)) {
+		visited.add(current);
+		if (Object.prototype.hasOwnProperty.call(current, AI_API_CALL_ERROR_MARKER)) return Reflect.get(current, AI_API_CALL_ERROR_MARKER) === true;
+		current = current.cause ?? current.error;
+	}
+	return false;
+}
+var OmModelExecutionError = class extends Error {
+	failureKind;
+	constructor(failureKind, cause) {
+		super(formatOmError(cause), { cause });
+		this.failureKind = failureKind;
+		this.name = "OmModelExecutionError";
+	}
+};
+function isOmModelExecutionError(error) {
+	try {
+		return error instanceof OmModelExecutionError;
+	} catch {
+		return false;
+	}
+}
+function getOmFailureMetadata(error, failurePolicy) {
+	return {
+		failurePolicy,
+		...isOmModelExecutionError(error) ? { failureKind: error.failureKind } : {}
+	};
+}
 /** Keep provider diagnostics in streamed/persisted markers, not whole API request/response objects. */
 function formatOmError(error) {
 	const details = /* @__PURE__ */ new Set();
@@ -23235,7 +23450,7 @@ function formatOmError(error) {
 	};
 	function collectErrorDetails(value, depth) {
 		if (depth > 5) return;
-		if (!isRecord$5(value)) {
+		if (!isRecord$4(value)) {
 			if (value !== void 0) add(String(value));
 			return;
 		}
@@ -23245,10 +23460,10 @@ function formatOmError(error) {
 		if (typeof value.statusCode === "number") add(`HTTP ${value.statusCode}`);
 		if (typeof value.responseBody === "string") try {
 			const body = JSON.parse(value.responseBody);
-			if (isRecord$5(body)) {
+			if (isRecord$4(body)) {
 				add(body.message);
 				add(body.detail);
-				if (isRecord$5(body.error)) add(body.error.message);
+				if (isRecord$4(body.error)) add(body.error.message);
 				else add(body.error);
 			}
 		} catch {}
@@ -23261,8 +23476,8 @@ function formatOmError(error) {
 	const message = [...details].join(": ") || "Unknown error";
 	return message.length > 2e3 ? `${message.slice(0, 1997)}...` : message;
 }
-function isAbortError$1(error, abortSignal) {
-	return abortSignal?.aborted === true || error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+function isAbortError$5(error, abortSignal) {
+	return abortSignal?.aborted === true || hasAbortInChain(error);
 }
 function shouldRetryEmptyStructuredObject(object, extractors) {
 	return Object.keys(object).length === 0 && extractors.some((extractor) => extractor.retryStructuredExtractionOnEmptyObject);
@@ -23288,7 +23503,12 @@ If a prior value is still applicable and carry-forward is enabled, return that p
 ${extractorInstructions}${priorLines.length > 0 ? `\n\n## Prior Extracted Values\n\n${priorLines.join("\n\n")}` : ""}`;
 	const values = {};
 	const failures = [];
-	const streamWithStructuredOutput = async (jsonPromptInjection) => {
+	const streamWithStructuredOutput = async (jsonPromptInjection) => withRetry(() => streamOnce(jsonPromptInjection), {
+		label: `om-${opts.source}-structured-extraction`,
+		abortSignal: opts.abortSignal,
+		maxRetries: 1
+	});
+	const streamOnce = async (jsonPromptInjection) => {
 		const object = await (await opts.agent.stream(prompt, {
 			structuredOutput: {
 				schema,
@@ -23308,11 +23528,21 @@ ${extractorInstructions}${priorLines.length > 0 ? `\n\n## Prior Extracted Values
 		object = await streamWithStructuredOutput();
 		retryEmptyObject = shouldRetryEmptyStructuredObject(object, structuredExtractors);
 	} catch (error) {
-		if (isAbortError$1(error, opts.abortSignal)) throw error;
+		if (isAbortError$5(error, opts.abortSignal)) throw error;
+		if (isTransientLLMError(error)) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				values,
+				failures: structuredExtractors.map((extractor) => ({
+					slug: extractor.slug,
+					error: message
+				}))
+			};
+		}
 		try {
 			object = await streamWithStructuredOutput(coreFeatures.has("json-prompt-injection:inline") ? "inline" : true);
 		} catch (fallbackError) {
-			if (isAbortError$1(fallbackError, opts.abortSignal)) throw fallbackError;
+			if (isAbortError$5(fallbackError, opts.abortSignal)) throw fallbackError;
 			const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
 			return {
 				values,
@@ -23326,7 +23556,7 @@ ${extractorInstructions}${priorLines.length > 0 ? `\n\n## Prior Extracted Values
 	if (retryEmptyObject) try {
 		object = await streamWithStructuredOutput(coreFeatures.has("json-prompt-injection:inline") ? "inline" : true);
 	} catch (fallbackError) {
-		if (isAbortError$1(fallbackError, opts.abortSignal)) throw fallbackError;
+		if (isAbortError$5(fallbackError, opts.abortSignal)) throw fallbackError;
 		const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
 		return {
 			values,
@@ -23352,15 +23582,15 @@ ${extractorInstructions}${priorLines.length > 0 ? `\n\n## Prior Extracted Values
 	};
 }
 const LEGACY_SYSTEM_REMINDER_METADATA_KEY = "dynamicAgentsMdReminder";
-function isRecord$4(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null;
 }
 function isSystemReminderMessage(message) {
-	if (!isRecord$4(message.content)) return false;
+	if (!isRecord$3(message.content)) return false;
 	const metadata = message.content.metadata;
-	if (message.role === "signal") return isRecord$4(metadata) && isRecord$4(metadata.signal) && (metadata.signal.type === "system-reminder" || metadata.signal.type === "reactive");
+	if (message.role === "signal") return isRecord$3(metadata) && isRecord$3(metadata.signal) && (metadata.signal.type === "system-reminder" || metadata.signal.type === "reactive");
 	if (message.role !== "user") return false;
-	if (isRecord$4(metadata) && (isRecord$4(metadata.systemReminder) || LEGACY_SYSTEM_REMINDER_METADATA_KEY in metadata)) return true;
+	if (isRecord$3(metadata) && (isRecord$3(metadata.systemReminder) || LEGACY_SYSTEM_REMINDER_METADATA_KEY in metadata)) return true;
 	const firstTextPart = message.content.parts.find((part) => part.type === "text");
 	return typeof firstTextPart?.text === "string" && firstTextPart.text.startsWith("<system-reminder");
 }
@@ -23419,12 +23649,41 @@ function stripEphemeralAnchorIds(observations) {
 * Date/time utility functions for Observational Memory.
 * Pure functions for formatting relative timestamps and annotating observations.
 */
-/**
-* Format a relative time string like "5 days ago", "2 weeks ago", "today", etc.
-*/
-function formatRelativeTime(date, currentDate) {
-	const diffMs = currentDate.getTime() - date.getTime();
-	const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+const DAY_MS = 1440 * 60 * 1e3;
+/** Day number of the calendar date a parsed date names. Parsed dates are built from local-time fields. */
+function calendarDay(date) {
+	return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) / DAY_MS;
+}
+const knownTimeZones = /* @__PURE__ */ new Map();
+/** `timeZone` when this runtime recognises it; otherwise undefined, which means the process time zone. */
+function resolveTimeZone(timeZone) {
+	if (!timeZone) return void 0;
+	let known = knownTimeZones.get(timeZone);
+	if (known === void 0) {
+		try {
+			new Intl.DateTimeFormat("en-US", { timeZone });
+			known = true;
+		} catch {
+			known = false;
+		}
+		knownTimeZones.set(timeZone, known);
+	}
+	return known ? timeZone : void 0;
+}
+/** Day number of the calendar date `instant` falls on in `timeZone` (the process time zone when unset). */
+function calendarDayIn(instant, timeZone) {
+	const zone = resolveTimeZone(timeZone);
+	if (!zone) return calendarDay(instant);
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone: zone,
+		year: "numeric",
+		month: "numeric",
+		day: "numeric"
+	}).formatToParts(instant);
+	const part = (type) => Number(parts.find((p) => p.type === type)?.value);
+	return Date.UTC(part("year"), part("month") - 1, part("day")) / DAY_MS;
+}
+function formatRelativeDays(diffDays) {
 	if (diffDays < 0) {
 		const futureDays = Math.abs(diffDays);
 		if (futureDays === 1) return "tomorrow";
@@ -23450,8 +23709,7 @@ function formatRelativeTime(date, currentDate) {
 * Returns null for consecutive days (no gap marker needed).
 */
 function formatGapBetweenDates(prevDate, currDate) {
-	const diffMs = currDate.getTime() - prevDate.getTime();
-	const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+	const diffDays = calendarDay(currDate) - calendarDay(prevDate);
 	if (diffDays <= 1) return null;
 	else if (diffDays < 7) return `[${diffDays} days later]`;
 	else if (diffDays < 14) return `[1 week later]`;
@@ -23459,45 +23717,156 @@ function formatGapBetweenDates(prevDate, currDate) {
 	else if (diffDays < 60) return `[1 month later]`;
 	else return `[${Math.floor(diffDays / 30)} months later]`;
 }
+const MONTH_INDEX = {
+	jan: 0,
+	feb: 1,
+	mar: 2,
+	apr: 3,
+	may: 4,
+	jun: 5,
+	jul: 6,
+	aug: 7,
+	sep: 8,
+	oct: 9,
+	nov: 10,
+	dec: 11
+};
+const MONTH = String.raw`(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|June?|July?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\.?`;
+const DAY = String.raw`\d{1,2}(?:st|nd|rd|th)?`;
+const YEAR = String.raw`(?:19|20|21)\d{2}(?!\d)`;
+const MERIDIEM = String.raw`(?:[AaPp]\.[Mm]\.|[AaPp][Mm]\b)`;
+const TIME = String.raw`(?:,?\s+(?:at\s+)?\d{1,2}:\d{2}(?:\s*${MERIDIEM})?|\s+at\s+\d{1,2}\s*${MERIDIEM})`;
+const QUALIFIER = String.raw`(?:(?:early|mid|late)[- ](?:to[- ](?:early|mid|late)[- ])?)`;
+const RANGE_SEP = String.raw`(?:\s*[–—]\s*|\s*-\s*|\s+(?:to|through|until)\s+)`;
+/**
+* Dates written into observation text that carry their own year, longest forms first:
+* "Mar 1 - Mar 18, 2025", "May 27-28, 2023", "January 10, 2024 at 3:00 PM",
+* "June–July 2022", "Dec 2021 – June 2023", "late April 2023".
+* Bare years, dates without a year, and ISO dates (often part of model IDs, API versions,
+* paths and branch names) are deliberately not matched.
+*/
+const FREE_TEXT_DATE = new RegExp([
+	String.raw`\b${MONTH}\s+${DAY}(?:,?\s+${YEAR})?${RANGE_SEP}${MONTH}\s+${DAY},?\s+${YEAR}${TIME}?`,
+	String.raw`\b${MONTH}\s+${DAY}${RANGE_SEP}${DAY},?\s+${YEAR}`,
+	String.raw`\b${MONTH}\s+${DAY},?\s+${YEAR}${TIME}?`,
+	String.raw`\b${QUALIFIER}?${MONTH}(?:\s+${YEAR})?${RANGE_SEP}${QUALIFIER}?${MONTH}\s+${YEAR}`,
+	String.raw`\b${QUALIFIER}?${MONTH}\s+${YEAR}`
+].join("|"), "g");
+const ENDPOINT = new RegExp(String.raw`^(?:(early|mid|late)\s*)?(?:(${MONTH})\s*)?(?:(\d{1,2})(?:st|nd|rd|th)?)?,?\s*(?:(${YEAR}))?$`, "i");
+function parseEndpoint(text) {
+	const match = ENDPOINT.exec(text.trim());
+	if (!match || !match[0]) return null;
+	const [, qualifier, month, day, year] = match;
+	return {
+		...qualifier ? { qualifier: qualifier.toLowerCase() } : {},
+		...month ? { month: MONTH_INDEX[month.slice(0, 3).toLowerCase()] } : {},
+		...day ? { day: Number(day) } : {},
+		...year ? { year: Number(year) } : {}
+	};
+}
+const QUALIFIER_DAY = {
+	early: 7,
+	mid: 15,
+	late: 23
+};
+const QUALIFIER_MONTH = {
+	early: [1, 15],
+	mid: [6, 1],
+	late: [10, 15]
+};
+/** Earliest and latest local day an endpoint can mean; null when it has no year or is not a real date. */
+function endpointBounds(date) {
+	const { qualifier, month, day, year } = date;
+	if (year === void 0) return null;
+	if (month === void 0) {
+		if (day !== void 0) return null;
+		if (qualifier) {
+			const [m, d] = QUALIFIER_MONTH[qualifier];
+			return [new Date(year, m, d), new Date(year, m, d)];
+		}
+		return [new Date(year, 0, 1), new Date(year, 11, 31)];
+	}
+	if (day !== void 0) {
+		const point = new Date(year, month, day);
+		if (point.getMonth() !== month) return null;
+		return [point, point];
+	}
+	if (qualifier) {
+		const point = new Date(year, month, QUALIFIER_DAY[qualifier]);
+		return [point, point];
+	}
+	return [new Date(year, month, 1), new Date(year, month + 1, 0)];
+}
+/** Parses one alternative: a single date or a two-ended range, filling each end's missing parts from the other. */
+function parseSpanAlternative(text) {
+	const ends = text.split(new RegExp(`${RANGE_SEP}(?=\\S)`)).filter(Boolean);
+	if (ends.length === 0 || ends.length > 2) return null;
+	const parsed = ends.map(parseEndpoint);
+	if (parsed.some((end) => end === null)) return null;
+	const [first, second = first] = parsed;
+	const from = { ...first };
+	const to = { ...second };
+	const fromYearInferred = from.year === void 0;
+	const toYearInferred = to.year === void 0;
+	from.year ??= to.year;
+	to.year ??= from.year;
+	if (from.month === void 0 && (from.day !== void 0 || from.qualifier) && to.month !== void 0) from.month = to.month;
+	if (to.month === void 0 && to.day !== void 0 && from.month !== void 0) to.month = from.month;
+	if (from.month !== void 0 && to.month !== void 0 && from.month > to.month && from.year === to.year) {
+		if (fromYearInferred) from.year -= 1;
+		else if (toYearInferred) to.year += 1;
+	}
+	const fromBounds = endpointBounds(from);
+	const toBounds = endpointBounds(to);
+	if (!fromBounds || !toBounds) return null;
+	const span = {
+		start: fromBounds[0],
+		end: toBounds[1]
+	};
+	return span.start <= span.end ? span : null;
+}
+function normalizeDateText(text) {
+	return text.replace(/\s+/g, " ").trim().replace(/^(?:approx(?:\.|imately)?|about|around|circa|c\.|~)\s*/i, "").replace(/^(?:by|in|until|before|after)\s+/i, "").replace(/\b(?:the\s+)?end\s+of\s+/gi, "late ").replace(/\b(?:the\s+)?(?:start|beginning)\s+of\s+/gi, "early ").replace(/\b(\d{4})-(\d{2})-(\d{2})\b/g, (whole, y, m, d) => {
+		const month = Object.keys(MONTH_INDEX)[Number(m) - 1];
+		return month ? `${month} ${Number(d)}, ${y}` : whole;
+	}).replace(new RegExp(TIME, "g"), "").replace(/\b(early|mid|late|to)-/gi, "$1 ").replace(/ {2,}/g, " ").trim();
+}
 /**
-* Parses a date string like "May 30, 2023", "May 27-28, 2023", "late April 2023", etc.
-* Returns the parsed Date or null if unparseable.
+* Parses the whole of `text` as a date or date range. Accepts "May 30, 2023",
+* "Mar 22, 2025 at 18:08", "May 27-28, 2023", "Dec 27–31, 2021", "Mar 1 - Mar 18, 2025",
+* "Aug 1, 2024 - Feb 28, 2025", "August 2024", "June–July 2022", "late April 2023",
+* "mid-to-late May 2023", "late 2023", "2035", "2021–2026", an "approx." prefix, and
+* "A or B" alternatives (their union). Returns null when no year is known.
 */
-function parseDateFromContent(dateContent) {
-	let targetDate = null;
-	const simpleDateMatch = dateContent.match(/([A-Z][a-z]+)\s+(\d{1,2}),?\s+(\d{4})/);
-	if (simpleDateMatch) {
-		const parsed = /* @__PURE__ */ new Date(`${simpleDateMatch[1]} ${simpleDateMatch[2]}, ${simpleDateMatch[3]}`);
-		if (!isNaN(parsed.getTime())) targetDate = parsed;
-	}
-	if (!targetDate) {
-		const rangeMatch = dateContent.match(/([A-Z][a-z]+)\s+(\d{1,2})-\d{1,2},?\s+(\d{4})/);
-		if (rangeMatch) {
-			const parsed = /* @__PURE__ */ new Date(`${rangeMatch[1]} ${rangeMatch[2]}, ${rangeMatch[3]}`);
-			if (!isNaN(parsed.getTime())) targetDate = parsed;
-		}
-	}
-	if (!targetDate) {
-		const vagueMatch = dateContent.match(/(late|early|mid)[- ]?(?:to[- ]?(?:late|early|mid)[- ]?)?([A-Z][a-z]+)\s+(\d{4})/i);
-		if (vagueMatch) {
-			const month = vagueMatch[2];
-			const year = vagueMatch[3];
-			const modifier = vagueMatch[1].toLowerCase();
-			let day = 15;
-			if (modifier === "early") day = 7;
-			if (modifier === "late") day = 23;
-			const parsed = /* @__PURE__ */ new Date(`${month} ${day}, ${year}`);
-			if (!isNaN(parsed.getTime())) targetDate = parsed;
-		}
-	}
-	if (!targetDate) {
-		const crossMonthMatch = dateContent.match(/([A-Z][a-z]+)\s+to\s+(?:early\s+)?([A-Z][a-z]+)\s+(\d{4})/i);
-		if (crossMonthMatch) {
-			const parsed = /* @__PURE__ */ new Date(`${crossMonthMatch[2]} 1, ${crossMonthMatch[3]}`);
-			if (!isNaN(parsed.getTime())) targetDate = parsed;
-		}
-	}
-	return targetDate;
+function parseDateSpan(text) {
+	const alternatives = normalizeDateText(text).split(/\s+or\s+/i).map(parseSpanAlternative);
+	if (alternatives.length === 0 || alternatives.some((span) => span === null)) return null;
+	const spans = alternatives;
+	return {
+		start: new Date(Math.min(...spans.map((span) => span.start.getTime()))),
+		end: new Date(Math.max(...spans.map((span) => span.end.getTime())))
+	};
+}
+const QUALIFIED_YEAR = new RegExp(String.raw`\b(?:by|in|until|before|after|(?:the\s+)?(?:early|mid|late|end\s+of|start\s+of|beginning\s+of))\s+${YEAR}`, "gi");
+/**
+* Like `parseDateSpan`, but falls back to the first dated expression inside longer text,
+* then to a year on its own ("by late 2027", "$500 in 2024"). Only for text known to be a date.
+*/
+function findDateSpan(text) {
+	const whole = parseDateSpan(text);
+	if (whole) return whole;
+	for (const pattern of [FREE_TEXT_DATE, QUALIFIED_YEAR]) for (const match of text.matchAll(pattern)) {
+		const span = parseDateSpan(match[0]);
+		if (span) return span;
+	}
+	return null;
+}
+function relativeSpan(span, today) {
+	const start = formatRelativeDays(today - calendarDay(span.start));
+	const end = formatRelativeDays(today - calendarDay(span.end));
+	if (start === end) return start;
+	if (!end.startsWith("in ")) return `${start} to ${end}`;
+	return start.startsWith("in ") ? `${start} to ${end.slice(3)}` : `${start} to ${end.slice(3)} from now`;
 }
 /**
 * Detects if an observation line indicates future intent (will do, plans to, looking forward to, etc.)
@@ -23517,40 +23886,59 @@ function isFutureIntentObservation(line) {
 }
 /**
 * Expand inline estimated dates with relative time.
-* Matches patterns like "(estimated May 27-28, 2023)" or "(meaning May 30, 2023)"
-* and expands them to "(meaning May 30, 2023 - which was 3 weeks ago)"
+* Matches patterns like "(estimated May 27-28, 2023)" or "(meaning May 30, 2023 at 3:00 PM)"
+* and expands them to "(meaning May 30, 2023 - 3 weeks ago)". Notes without a year are left alone.
 */
-function expandInlineEstimatedDates(observations, currentDate) {
-	return observations.replace(/\((estimated|meaning)\s+([^)]+\d{4})\)/gi, (match, prefix, dateContent, offset) => {
-		const targetDate = parseDateFromContent(dateContent);
-		if (targetDate) {
-			const relative = formatRelativeTime(targetDate, currentDate);
-			const lineStart = observations.lastIndexOf("\n", offset) + 1;
-			const lineBeforeDate = observations.slice(lineStart, offset);
-			const isPastDate = targetDate < currentDate;
-			const isFutureIntent = isFutureIntentObservation(lineBeforeDate);
-			if (isPastDate && isFutureIntent) return `(${prefix} ${dateContent} - ${relative}, likely already happened)`;
-			return `(${prefix} ${dateContent} - ${relative})`;
-		}
-		return match;
+function expandInlineEstimatedDates(observations, currentDate, timeZone) {
+	const inlineDateRegex = /\((estimated|meaning)\s([^()]*)\)/gi;
+	const today = calendarDayIn(currentDate, timeZone);
+	return observations.replace(inlineDateRegex, (match, prefix, noteText, offset) => {
+		const dateContent = noteText.trimStart();
+		const span = findDateSpan(dateContent);
+		if (!span) return match;
+		const relative = relativeSpan(span, today);
+		const lineStart = observations.lastIndexOf("\n", offset) + 1;
+		const lineBeforeDate = observations.slice(lineStart, offset);
+		if (calendarDay(span.end) < today && isFutureIntentObservation(lineBeforeDate)) return `(${prefix} ${dateContent} - ${relative}, likely already happened)`;
+		return `(${prefix} ${dateContent} - ${relative})`;
+	});
+}
+/**
+* Annotates dates written into observation text, e.g. "exam on January 10, 2024" becomes
+* "exam on January 10, 2024 (5 months ago)". Only dates that state their year are annotated;
+* "Date:" headers and "(meaning/estimated …)" notes are handled separately and skipped here.
+*/
+function annotateObservationTextDates(observations, currentDate, timeZone) {
+	const regex = new RegExp(String.raw`^Date:.*$|\((?:[Ee]stimated|[Mm]eaning)\b[^()]*\)|${FREE_TEXT_DATE.source}`, "gm");
+	const today = calendarDayIn(currentDate, timeZone);
+	return observations.replace(regex, (match, offset) => {
+		if (match.startsWith("Date:") || match.startsWith("(")) return match;
+		const span = parseDateSpan(match);
+		if (!span) return match;
+		const relative = relativeSpan(span, today);
+		return observations[offset + match.length] === ")" ? `${match} - ${relative}` : `${match} (${relative})`;
 	});
 }
 /**
 * Add relative time annotations to observations.
-* Transforms "Date: May 15, 2023" headers to "Date: May 15, 2023 (5 days ago)"
-* and expands inline estimated dates with relative time context.
+* Transforms "Date: May 15, 2023" headers to "Date: May 15, 2023 (5 days ago)", range headers such as
+* "Date: Aug 1, 2024 - Feb 28, 2025" to "(7 months ago to 4 weeks ago)", and annotates inline dates.
+*
+* `timeZone` is the zone the Observer wrote its dates in (the record's `observedTimezone`). "Today" is
+* `currentDate`'s calendar date in that zone, so the result doesn't depend on the zone of the process rendering it.
 */
-function addRelativeTimeToObservations(observations, currentDate) {
-	const withInlineDates = expandInlineEstimatedDates(observations, currentDate);
-	const dateHeaderRegex = /^(Date:\s*)([A-Z][a-z]+ \d{1,2}, \d{4})$/gm;
+function addRelativeTimeToObservations(observations, currentDate, timeZone) {
+	const today = calendarDayIn(currentDate, timeZone);
+	const withInlineDates = annotateObservationTextDates(expandInlineEstimatedDates(observations, currentDate, timeZone), currentDate, timeZone);
+	const dateHeaderRegex = /^(Date:[ \t]*)(.*)$/gm;
 	const dates = [];
 	let regexMatch;
 	while ((regexMatch = dateHeaderRegex.exec(withInlineDates)) !== null) {
-		const dateStr = regexMatch[2];
-		const parsed = new Date(dateStr);
-		if (!isNaN(parsed.getTime())) dates.push({
+		const dateStr = regexMatch[2].trimEnd();
+		const span = parseDateSpan(dateStr);
+		if (span) dates.push({
 			index: regexMatch.index,
-			date: parsed,
+			span,
 			match: regexMatch[0],
 			prefix: regexMatch[1],
 			dateStr
@@ -23564,11 +23952,10 @@ function addRelativeTimeToObservations(observations, currentDate) {
 		const prev = i > 0 ? dates[i - 1] : null;
 		result += withInlineDates.slice(lastIndex, curr.index);
 		if (prev) {
-			const gap = formatGapBetweenDates(prev.date, curr.date);
+			const gap = formatGapBetweenDates(prev.span.end, curr.span.start);
 			if (gap) result += `\n${gap}\n\n`;
 		}
-		const relative = formatRelativeTime(curr.date, currentDate);
-		result += `${curr.prefix}${curr.dateStr} (${relative})`;
+		result += `${curr.prefix}${curr.dateStr} (${relativeSpan(curr.span, today)})`;
 		lastIndex = curr.index + curr.match.length;
 	}
 	result += withInlineDates.slice(lastIndex);
@@ -24573,11 +24960,20 @@ const OBSERVER_IMAGE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 	"heif",
 	"avif"
 ]);
-function formatObserverDate(createdAt) {
-	return createdAt ? `${createdAt.toLocaleDateString("en-US", { month: "short" })} ${createdAt.getDate()} ${createdAt.getFullYear()}` : "";
+function formatObserverDate(createdAt, timeZone) {
+	if (!createdAt) return "";
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		year: "numeric",
+		month: "short",
+		day: "numeric"
+	}).formatToParts(createdAt);
+	const part = (type) => parts.find((p) => p.type === type)?.value;
+	return `${part("month")} ${part("day")} ${part("year")}`;
 }
-function formatObserverTime(createdAt) {
+function formatObserverTime(createdAt, timeZone) {
 	return createdAt ? createdAt.toLocaleTimeString("en-US", {
+		timeZone,
 		hour: "numeric",
 		minute: "2-digit",
 		hour12: true
@@ -24667,11 +25063,11 @@ function formatObserverAttachmentPlaceholder(part, counter) {
 	const label = resolveObserverAttachmentLabel(part);
 	return label ? `[${attachmentType} #${attachmentId}: ${label}]` : `[${attachmentType} #${attachmentId}]`;
 }
-function isRecord$3(value) {
+function isRecord$2(value) {
 	return !!value && typeof value === "object";
 }
 function mapToolResultBlockToAttachment(block) {
-	if (!isRecord$3(block) || typeof block.type !== "string") return;
+	if (!isRecord$2(block) || typeof block.type !== "string") return;
 	const mediaType = typeof block.mediaType === "string" ? block.mediaType : void 0;
 	const filename = typeof block.filename === "string" ? block.filename : void 0;
 	switch (block.type) {
@@ -24732,7 +25128,7 @@ function mapToolResultBlockToAttachment(block) {
 	}
 }
 function extractToolResultAttachments(result, counter, attachmentFilter) {
-	if (!isRecord$3(result) || result.type !== "content" || !Array.isArray(result.value)) return {
+	if (!isRecord$2(result) || result.type !== "content" || !Array.isArray(result.value)) return {
 		resultWithoutAttachments: result,
 		attachments: []
 	};
@@ -24746,7 +25142,7 @@ function extractToolResultAttachments(result, counter, attachmentFilter) {
 		if (shouldIncludeObserverAttachment(attachment, attachmentFilter)) attachments.push(toObserverInputAttachmentPart(attachment));
 		const placeholder = formatObserverAttachmentPlaceholder(attachment, counter);
 		return {
-			type: isRecord$3(block) ? block.type : void 0,
+			type: isRecord$2(block) ? block.type : void 0,
 			placeholder
 		};
 	});
@@ -24863,6 +25259,7 @@ function formatObserverMessage(msg, counter, toolFormatting, options) {
 	const maxLen = options?.maxPartLength;
 	const maxToolResultTokens = options?.maxToolResultTokens ?? 5e3;
 	const attachmentFilter = options?.attachmentFilter;
+	const timeZone = resolveTimeZone(options?.timeZone);
 	const role = getObserverMessageLabel(msg);
 	const attachments = [];
 	const messageCreatedAt = normalizeObserverCreatedAt(msg.createdAt);
@@ -24872,8 +25269,8 @@ function formatObserverMessage(msg, counter, toolFormatting, options) {
 		if (!body) return;
 		const normalizedCreatedAt = normalizeObserverCreatedAt(createdAt) ?? messageCreatedAt;
 		lines.push({
-			date: formatObserverDate(normalizedCreatedAt),
-			time: formatObserverTime(normalizedCreatedAt),
+			date: formatObserverDate(normalizedCreatedAt, timeZone),
+			time: formatObserverTime(normalizedCreatedAt, timeZone),
 			title,
 			body
 		});
@@ -25426,169 +25823,6 @@ function optimizeObservationsForContext(observations) {
 	optimized = optimized.replace(/\n{3,}/g, "\n\n");
 	return optimized.trim();
 }
-/**
-* Retry knobs for the internal OM transport-error retry wrapper.
-* Exported as a mutable object so tests can shrink the backoff schedule
-* without changing public API.
-*
-* With the defaults the per-retry pre-jitter backoff schedule is:
-*   1s, 2s, 4s, 8s, 16s, 32s, 64s, 120s (cap)
-* giving 8 retries / 9 total attempts and ~247s (~4 minutes) of waiting
-* before the final attempt fails. Designed to ride out short provider /
-* network blips without holding the actor turn for much longer than that.
-*
-* @internal
-*/
-const RETRY_CONFIG = {
-	/** Maximum number of retry *attempts* (total tries = maxRetries + 1). */
-	maxRetries: 8,
-	/** Initial backoff delay in milliseconds. */
-	initialDelayMs: 1e3,
-	/** Multiplier applied to the delay after each failed attempt. */
-	backoffFactor: 2,
-	/** Cap on per-attempt delay (ms). */
-	maxDelayMs: 12e4,
-	/** Random jitter as a fraction of the computed delay (e.g. 0.2 = ±20%). */
-	jitter: .2
-};
-const TRANSIENT_MESSAGE_SUBSTRINGS = [
-	"terminated",
-	"fetch failed",
-	"econnreset",
-	"econnrefused",
-	"enotfound",
-	"eai_again",
-	"socket hang up",
-	"network error",
-	"request timed out",
-	"request timeout",
-	"connection reset",
-	"connection closed"
-];
-function isRecord$2(value) {
-	return typeof value === "object" && value !== null;
-}
-function isAbortError$5(error) {
-	if (!isRecord$2(error)) return false;
-	if (error.name === "AbortError") return true;
-	if (typeof error.code === "string" && error.code === "ABORT_ERR") return true;
-	return false;
-}
-function hasTransientMessage(value) {
-	if (!isRecord$2(value)) return false;
-	const message = typeof value.message === "string" ? value.message.toLowerCase() : "";
-	if (message && TRANSIENT_MESSAGE_SUBSTRINGS.some((sub) => message.includes(sub))) return true;
-	if (typeof value.code === "string" && value.code.toUpperCase().startsWith("UND_ERR_")) return true;
-	return false;
-}
-function isRetryableHttpStatus(status) {
-	if (status === 408 || status === 425 || status === 429) return true;
-	return status >= 500 && status <= 599;
-}
-function hasRetryableHttpStatus(value) {
-	if (!isRecord$2(value)) return false;
-	if (typeof value.statusCode === "number" && isRetryableHttpStatus(value.statusCode)) return true;
-	if (typeof value.code === "number" && isRetryableHttpStatus(value.code)) return true;
-	return false;
-}
-function hasIsRetryableFlag(value) {
-	if (!isRecord$2(value)) return false;
-	return value.isRetryable === true;
-}
-/**
-* Returns true when the given error looks like a transient transport-class
-* failure that's worth retrying — undici `terminated`, `fetch failed`,
-* `UND_ERR_*` codes, AI SDK `APICallError` with `isRetryable: true`, and
-* common HTTP 408/425/429/5xx statuses. Walks the `error.cause` chain so
-* wrapper errors don't hide the real failure.
-*
-* Never retries on user-initiated aborts.
-*
-* @internal
-*/
-function isTransientLLMError(error) {
-	if (isAbortError$5(error)) return false;
-	const visited = /* @__PURE__ */ new WeakSet();
-	function visit(candidate) {
-		if (isRecord$2(candidate)) {
-			if (visited.has(candidate)) return false;
-			visited.add(candidate);
-		}
-		if (hasTransientMessage(candidate)) return true;
-		if (hasRetryableHttpStatus(candidate)) return true;
-		if (hasIsRetryableFlag(candidate)) return true;
-		if (isRecord$2(candidate)) {
-			if (visit(candidate.cause)) return true;
-			if (visit(candidate.error)) return true;
-		}
-		return false;
-	}
-	return visit(error);
-}
-/**
-* Compute the backoff delay (ms) for the Nth retry (0-indexed).
-*
-* Exponential growth (`initialDelayMs * backoffFactor^attempt`) capped at
-* `maxDelayMs`, then nudged by ±`jitter` (fractional). Exported for unit
-* tests that lock the schedule against drift.
-*
-* @internal
-*/
-function computeDelay(attempt) {
-	const base = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, attempt);
-	const capped = Math.min(base, RETRY_CONFIG.maxDelayMs);
-	if (RETRY_CONFIG.jitter <= 0) return capped;
-	const jitterRange = capped * RETRY_CONFIG.jitter;
-	const offset = (Math.random() * 2 - 1) * jitterRange;
-	return Math.max(0, Math.round(capped + offset));
-}
-function sleep(ms, abortSignal) {
-	if (ms <= 0) return Promise.resolve();
-	return new Promise((resolve, reject) => {
-		if (abortSignal?.aborted) {
-			reject(/* @__PURE__ */ new Error("The operation was aborted."));
-			return;
-		}
-		const timer = setTimeout(() => {
-			abortSignal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			abortSignal?.removeEventListener("abort", onAbort);
-			reject(/* @__PURE__ */ new Error("The operation was aborted."));
-		};
-		abortSignal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-/**
-* Run `fn` with retries on transient transport-class errors.
-*
-* Non-transient errors (auth, validation, schema, etc.) are rethrown
-* immediately. User-initiated aborts are rethrown without delay.
-*
-* @internal
-*/
-async function withRetry(fn, opts) {
-	const { label, abortSignal } = opts;
-	let attempt = 0;
-	while (true) {
-		if (abortSignal?.aborted) throw new Error("The operation was aborted.");
-		try {
-			return await fn();
-		} catch (error) {
-			if (isAbortError$5(error) || abortSignal?.aborted) throw error;
-			if (attempt >= RETRY_CONFIG.maxRetries || !isTransientLLMError(error)) {
-				if (attempt > 0) omDebug(`[OM:retry:${label}] giving up after ${attempt} retry/retries: ${error instanceof Error ? error.message : String(error)}`);
-				throw error;
-			}
-			const delay = computeDelay(attempt);
-			attempt++;
-			omDebug(`[OM:retry:${label}] transient error on attempt ${attempt}, retrying in ${delay}ms: ${error instanceof Error ? error.message : String(error)}`);
-			await sleep(delay, abortSignal);
-		}
-	}
-}
 function createTemporaryOmMemoryContext(prefix) {
 	const options = {
 		thread: `${prefix}-${randomUUID()}`,
@@ -25723,11 +25957,27 @@ var ObserverRunner = class {
 		this.mastra = mastra;
 	}
 	createAgent(model, isMultiThread = false, memory, extractors = this.observationConfig.extractors ?? []) {
+		let agentModel = model;
+		if (Array.isArray(agentModel)) agentModel = agentModel.map((fallback) => ({
+			...fallback,
+			maxRetries: 0
+		}));
+		else if (typeof agentModel === "function") {
+			const resolveDynamicModel = agentModel;
+			agentModel = (async (args) => {
+				const resolvedModel = await resolveDynamicModel(args);
+				return Array.isArray(resolvedModel) ? resolvedModel.map((fallback) => ({
+					...fallback,
+					maxRetries: 0
+				})) : resolvedModel;
+			});
+		}
 		return new Agent({
 			id: isMultiThread ? "multi-thread-observer" : "observational-memory-observer",
 			name: isMultiThread ? "multi-thread-observer" : "Observer",
+			maxRetries: 0,
 			instructions: buildObserverSystemPrompt(isMultiThread, this.observationConfig.instruction, this.observationConfig.threadTitle, extractors),
-			model,
+			model: agentModel,
 			...memory ? { memory } : {},
 			...this.mastra ? { mastra: this.mastra } : {}
 		});
@@ -25819,7 +26069,10 @@ var ObserverRunner = class {
 			...options,
 			includeThreadTitle: this.observationConfig.threadTitle,
 			extractors: activeExtractors
-		}, { attachmentFilter })];
+		}, {
+			attachmentFilter,
+			timeZone: options?.timeZone
+		})];
 		const doGenerate = async () => {
 			return withRetry(() => withOmTracingSpan({
 				phase: "observer",
@@ -25857,12 +26110,14 @@ var ObserverRunner = class {
 							hasRequestContext: Boolean(internalRequestContext),
 							aborted: abortSignal?.aborted ?? false
 						});
-						throw error;
+						if (abortSignal?.aborted || !isOmModelExecutionFailure(error)) throw error;
+						throw new OmModelExecutionError("observer-model", error);
 					}
 				}, abortSignal)
 			}), {
 				label: "observer",
-				abortSignal
+				abortSignal,
+				maxRetries: this.observationConfig.maxRetries
 			});
 		};
 		let result = await doGenerate();
@@ -25930,7 +26185,7 @@ var ObserverRunner = class {
 	/**
 	* Call the Observer agent for multiple threads in a single batched request.
 	*/
-	async callMultiThread(existingObservations, allMessagesByThread, allThreadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, hookContext) {
+	async callMultiThread(existingObservations, allMessagesByThread, allThreadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, hookContext, timeZone) {
 		const contextFor = (threadId) => ({
 			threadId,
 			...hookContext
@@ -25941,7 +26196,7 @@ var ObserverRunner = class {
 			if (filtered.length > 0) messagesByThread.set(threadId, filtered);
 		}
 		const threadOrder = allThreadOrder.filter((threadId) => messagesByThread.has(threadId));
-		const output = await this.callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model);
+		const output = await this.callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, timeZone);
 		for (const threadId of allThreadOrder) {
 			const threadResult = output.results.get(threadId);
 			if (!threadResult) {
@@ -25952,7 +26207,7 @@ var ObserverRunner = class {
 		}
 		return output;
 	}
-	async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model) {
+	async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model, timeZone) {
 		if (threadOrder.length === 0) return { results: /* @__PURE__ */ new Map() };
 		const inputTokens = Array.from(messagesByThread.values()).reduce((total, messages) => total + this.tokenCounter.countMessages(messages), 0);
 		const resolvedModel = (() => {
@@ -25994,7 +26249,8 @@ var ObserverRunner = class {
 					priorSuggestedResponse: priorMetadataByThread?.get(threadId)?.suggestedResponse,
 					priorThreadTitle: priorMetadataByThread?.get(threadId)?.threadTitle,
 					priorExtractedValues: priorMetadataByThread?.get(threadId)?.extracted,
-					model: resolvedModel.model
+					model: resolvedModel.model,
+					timeZone
 				});
 				results.set(threadId, {
 					observations: threadResult.observations,
@@ -26011,6 +26267,7 @@ var ObserverRunner = class {
 					totalUsage.totalTokens += threadResult.usage.totalTokens ?? 0;
 				}
 			}
+			for (const msgs of messagesByThread.values()) for (const msg of msgs) this.observedMessageIds.add(msg.id);
 			return {
 				results,
 				usage: totalUsage
@@ -26019,8 +26276,10 @@ var ObserverRunner = class {
 		const agent = this.createAgent(resolvedModel.model, true, void 0, activeExtractors);
 		const internalRequestContext = withOmInternalThreadId(requestContext, agent.id);
 		const multiThreadAttachmentFilter = this.resolveAttachmentFilter(resolvedModel.model, requestContext);
-		const observerMessages = [buildMultiThreadObserverRequestMessage(existingObservations, messagesByThread, threadOrder, priorMetadataByThread, void 0, this.observationConfig.threadTitle, activeExtractors, { attachmentFilter: multiThreadAttachmentFilter })];
-		for (const msgs of messagesByThread.values()) for (const msg of msgs) this.observedMessageIds.add(msg.id);
+		const observerMessages = [buildMultiThreadObserverRequestMessage(existingObservations, messagesByThread, threadOrder, priorMetadataByThread, void 0, this.observationConfig.threadTitle, activeExtractors, {
+			attachmentFilter: multiThreadAttachmentFilter,
+			timeZone
+		})];
 		const doGenerate = async () => {
 			return withRetry(() => withOmTracingSpan({
 				phase: "observer-multi-thread",
@@ -26058,12 +26317,14 @@ var ObserverRunner = class {
 							hasRequestContext: Boolean(internalRequestContext),
 							aborted: abortSignal?.aborted ?? false
 						});
-						throw error;
+						if (abortSignal?.aborted || !isOmModelExecutionFailure(error)) throw error;
+						throw new OmModelExecutionError("observer-model", error);
 					}
 				}, abortSignal)
 			}), {
 				label: "observer-multi-thread",
-				abortSignal
+				abortSignal,
+				maxRetries: this.observationConfig.maxRetries
 			});
 		};
 		let result = await doGenerate();
@@ -26119,6 +26380,7 @@ var ObserverRunner = class {
 			});
 		}
 		for (const threadId of threadOrder) if (!results.has(threadId)) results.set(threadId, { observations: "" });
+		for (const msgs of messagesByThread.values()) for (const msg of msgs) this.observedMessageIds.add(msg.id);
 		const usage = result.totalUsage ?? result.usage;
 		return {
 			results,
@@ -27606,6 +27868,8 @@ async function summarizeConversation(opts) {
 	const runner = new ObserverRunner({
 		observationConfig: {
 			model: opts.model,
+			maxRetries: 8,
+			failurePolicy: "abort",
 			messageTokens: OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens,
 			shareTokenBudget: false,
 			modelSettings: { ...OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings },
@@ -29416,6 +29680,7 @@ function createObservationFailedMarker(params) {
 			durationMs,
 			tokensAttempted: params.tokensAttempted,
 			error: formatOmError(params.error),
+			...getOmFailureMetadata(params.error, params.failurePolicy ?? "abort"),
 			recordId: params.recordId,
 			threadId: params.threadId
 		}
@@ -29477,6 +29742,7 @@ function createBufferingFailedMarker(params) {
 			durationMs,
 			tokensAttempted: params.tokensAttempted,
 			error: formatOmError(params.error),
+			...getOmFailureMetadata(params.error, params.failurePolicy ?? "abort"),
 			recordId: params.recordId,
 			threadId: params.threadId
 		}
@@ -29531,7 +29797,10 @@ function createThreadUpdateMarker(params) {
 function findLastCompletedObservationBoundary(message) {
 	const parts = message.content?.parts;
 	if (!parts || !Array.isArray(parts)) return -1;
-	for (let i = parts.length - 1; i >= 0; i--) if (parts[i]?.type === "data-om-observation-end") return i;
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const part = parts[i];
+		if (part?.type === "data-om-observation-end" && part.data?.operationType !== "reflection") return i;
+	}
 	return -1;
 }
 /**
@@ -29781,6 +30050,7 @@ function scanObservationGroupTags(observations) {
 	const incompleteOpenings = [];
 	let cursor = 0;
 	let closeFloor = 0;
+	let nestedFloor = -1;
 	while (cursor < observations.length) {
 		const start = observations.indexOf(OBSERVATION_GROUP_OPEN, cursor);
 		if (start === -1) break;
@@ -29801,8 +30071,12 @@ function scanObservationGroupTags(observations) {
 			cursor = openEnd + 1;
 			continue;
 		}
-		const nestedStart = observations.indexOf(OBSERVATION_GROUP_OPEN, openEnd + 1);
-		if (nestedStart !== -1 && nestedStart < closeStart && isLineStart(observations, nestedStart)) {
+		if (nestedFloor <= openEnd) {
+			const lineOpen = observations.indexOf(`\n${OBSERVATION_GROUP_OPEN}`, openEnd);
+			nestedFloor = lineOpen === -1 ? observations.length : lineOpen + 1;
+		}
+		const nestedStart = nestedFloor;
+		if (nestedStart < closeStart) {
 			incompleteOpenings.push({
 				start,
 				end: openEnd + 1
@@ -30185,6 +30459,7 @@ var ObservationStrategy = class ObservationStrategy {
 				observationTokens: processed.observationTokens,
 				threadId,
 				writer,
+				messageList: this.opts.messageList,
 				abortSignal,
 				mainAgent: this.opts.agent,
 				sendSignal: this.opts.sendSignal,
@@ -30209,6 +30484,7 @@ var ObservationStrategy = class ObservationStrategy {
 						operationType: "observation",
 						startedAt: (/* @__PURE__ */ new Date()).toISOString(),
 						error: formatOmError(error),
+						...getOmFailureMetadata(error, this.observationConfig.failurePolicy),
 						recordId: record.id,
 						threadId
 					}
@@ -30222,6 +30498,10 @@ var ObservationStrategy = class ObservationStrategy {
 				};
 			}
 			omError("[OM] Observation failed", error);
+			if (this.observationConfig.failurePolicy === "continue" && isOmModelExecutionError(error) && error.failureKind === "observer-model") return {
+				observed: false,
+				error
+			};
 			throw error;
 		}
 	}
@@ -30487,7 +30767,8 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			threadId: this.opts.threadId,
 			resourceId: this.opts.resourceId,
 			trigger: this.opts.trigger,
-			mainAgent: this.opts.agent
+			mainAgent: this.opts.agent,
+			timeZone: this.opts.record.observedTimezone
 		});
 		const hookedValues = await applyExtractorHooks({
 			source: "observer",
@@ -30496,7 +30777,10 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			failures: result.extractionFailures,
 			previousValues: this.priorExtractedValues,
 			rawObservations: result.observations,
-			recentMessages: formatMessagesForObserver(this.opts.messages, { maxPartLength: 500 }),
+			recentMessages: formatMessagesForObserver(this.opts.messages, {
+				maxPartLength: 500,
+				timeZone: this.opts.record.observedTimezone
+			}),
 			threadId: this.opts.threadId,
 			resourceId: this.opts.resourceId,
 			mainAgent: this.opts.agent,
@@ -30627,6 +30911,7 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 				startedAt: this.startedAt,
 				tokensAttempted: this.tokensToObserve,
 				error,
+				failurePolicy: this.observationConfig.failurePolicy,
 				recordId: this.opts.record.id,
 				threadId: this.opts.threadId
 			});
@@ -30676,7 +30961,8 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			threadId: this.opts.threadId,
 			resourceId: this.opts.resourceId,
 			trigger: this.opts.trigger,
-			mainAgent: this.opts.agent
+			mainAgent: this.opts.agent,
+			timeZone: this.opts.record.observedTimezone
 		});
 		const hookedValues = await applyExtractorHooks({
 			source: "observer",
@@ -30685,7 +30971,10 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			failures: result.extractionFailures,
 			previousValues: this.priorExtractedValues,
 			rawObservations: result.observations,
-			recentMessages: formatMessagesForObserver(messages, { maxPartLength: 500 }),
+			recentMessages: formatMessagesForObserver(messages, {
+				maxPartLength: 500,
+				timeZone: this.opts.record.observedTimezone
+			}),
 			threadId: this.opts.threadId,
 			resourceId: this.opts.resourceId,
 			mainAgent: this.opts.agent,
@@ -30831,6 +31120,7 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			startedAt: this.startedAt,
 			tokensAttempted,
 			error,
+			failurePolicy: this.observationConfig.failurePolicy,
 			recordId: record.id,
 			threadId
 		});
@@ -31005,7 +31295,7 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 			return this.deps.observer.callMultiThread(_existingObservations, batch.threadMap, batch.threadIds, this.opts.abortSignal, this.opts.requestContext, this.priorMetadataByThread, this.opts.observabilityContext, void 0, {
 				resourceId: this.opts.resourceId,
 				trigger: this.opts.trigger
-			});
+			}, this.opts.record.observedTimezone);
 		}));
 		for (const batchResult of batchResults) {
 			for (const [threadId, result] of batchResult.results) this.multiThreadResults.set(threadId, result);
@@ -31038,7 +31328,10 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 				failures: result.extractionFailures,
 				previousValues,
 				rawObservations: result.observations,
-				recentMessages: formatMessagesForObserver(threadMessages, { maxPartLength: 500 }),
+				recentMessages: formatMessagesForObserver(threadMessages, {
+					maxPartLength: 500,
+					timeZone: this.opts.record.observedTimezone
+				}),
 				threadId,
 				resourceId: this.resourceId,
 				mainAgent: this.opts.agent,
@@ -31197,6 +31490,7 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 				startedAt: this.startedAt,
 				tokensAttempted,
 				error,
+				failurePolicy: this.observationConfig.failurePolicy,
 				recordId: this.opts.record.id,
 				threadId
 			});
@@ -31603,19 +31897,28 @@ var ObservationStep = class {
 				};
 			}
 		}
-		const obsResult = await om.observe({
-			threadId,
-			resourceId,
-			messages: observableMessages,
-			messageList,
-			trigger: "turn-sync",
-			agent: this.turn.agent,
-			sendSignal: this.turn.sendSignal,
-			sendStateSignal: this.turn.sendStateSignal,
-			requestContext: this.turn.requestContext,
-			writer: this.turn.writer,
-			observabilityContext: this.turn.observabilityContext
-		});
+		let obsResult;
+		try {
+			obsResult = await om.observe({
+				threadId,
+				resourceId,
+				messages: observableMessages,
+				messageList,
+				trigger: "turn-sync",
+				agent: this.turn.agent,
+				sendSignal: this.turn.sendSignal,
+				sendStateSignal: this.turn.sendStateSignal,
+				requestContext: this.turn.requestContext,
+				writer: this.turn.writer,
+				observabilityContext: this.turn.observabilityContext
+			});
+		} catch (error) {
+			if (om.config.observation.failurePolicy !== "continue" || !isOmModelExecutionError(error) || error.failureKind !== "observer-model") throw error;
+			return {
+				succeeded: false,
+				record: freshStatus.record
+			};
+		}
 		if (obsResult.observed) {
 			const observedMessageIds = new Set(obsResult.record.observedMessageIds ?? []);
 			const liveMessages = getObservableMessages(messageList);
@@ -32267,11 +32570,27 @@ var ReflectorRunner = class {
 		this.mastra = mastra;
 	}
 	createAgent(model, memory, extractors = this.reflectionConfig.extractors) {
+		let agentModel = model;
+		if (Array.isArray(agentModel)) agentModel = agentModel.map((fallback) => ({
+			...fallback,
+			maxRetries: 0
+		}));
+		else if (typeof agentModel === "function") {
+			const resolveDynamicModel = agentModel;
+			agentModel = (async (args) => {
+				const resolvedModel = await resolveDynamicModel(args);
+				return Array.isArray(resolvedModel) ? resolvedModel.map((fallback) => ({
+					...fallback,
+					maxRetries: 0
+				})) : resolvedModel;
+			});
+		}
 		return new Agent({
 			id: "observational-memory-reflector",
 			name: "Reflector",
 			instructions: buildReflectorSystemPrompt(this.reflectionConfig.instruction, extractors),
-			model,
+			model: agentModel,
+			maxRetries: 0,
 			...memory ? { memory } : {},
 			...this.mastra ? { mastra: this.mastra } : {}
 		});
@@ -32353,36 +32672,42 @@ var ReflectorRunner = class {
 				},
 				callback: (childObservabilityContext) => withAbortCheck(async () => {
 					chunkCount = 0;
-					return (await agent.stream(prompt, {
-						modelSettings: { ...this.reflectionConfig.modelSettings },
-						providerOptions: this.reflectionConfig.providerOptions,
-						...temporaryMemory ? { memory: temporaryMemory.options } : {},
-						...abortSignal ? { abortSignal } : {},
-						...internalRequestContext ? { requestContext: internalRequestContext } : {},
-						...childObservabilityContext,
-						...attemptNumber === 1 ? {
-							onChunk(chunk) {
-								chunkCount++;
-								if (chunkCount === 1 || chunkCount % 50 === 0) {
-									const preview = chunk.type === "text-delta" ? ` text="${chunk.textDelta?.slice(0, 80)}..."` : chunk.type === "tool-call" ? ` tool=${chunk.toolName}` : "";
-									omDebug(`[OM:callReflector] chunk#${chunkCount}: type=${chunk.type}${preview}`);
+					try {
+						return await (await agent.stream(prompt, {
+							modelSettings: { ...this.reflectionConfig.modelSettings },
+							providerOptions: this.reflectionConfig.providerOptions,
+							...temporaryMemory ? { memory: temporaryMemory.options } : {},
+							...abortSignal ? { abortSignal } : {},
+							...internalRequestContext ? { requestContext: internalRequestContext } : {},
+							...childObservabilityContext,
+							...attemptNumber === 1 ? {
+								onChunk(chunk) {
+									chunkCount++;
+									if (chunkCount === 1 || chunkCount % 50 === 0) {
+										const preview = chunk.type === "text-delta" ? ` text="${chunk.textDelta?.slice(0, 80)}..."` : chunk.type === "tool-call" ? ` tool=${chunk.toolName}` : "";
+										omDebug(`[OM:callReflector] chunk#${chunkCount}: type=${chunk.type}${preview}`);
+									}
+								},
+								onFinish(event) {
+									omDebug(`[OM:callReflector] onFinish: chunks=${chunkCount}, finishReason=${event.finishReason}, inputTokens=${event.usage?.inputTokens}, outputTokens=${event.usage?.outputTokens}, textLen=${event.text?.length}`);
+								},
+								onAbort(event) {
+									omDebug(`[OM:callReflector] onAbort: chunks=${chunkCount}, reason=${event?.reason ?? "unknown"}`);
+								},
+								onError({ error }) {
+									omError(`[OM:callReflector] onError after ${chunkCount} chunks`, error);
 								}
-							},
-							onFinish(event) {
-								omDebug(`[OM:callReflector] onFinish: chunks=${chunkCount}, finishReason=${event.finishReason}, inputTokens=${event.usage?.inputTokens}, outputTokens=${event.usage?.outputTokens}, textLen=${event.text?.length}`);
-							},
-							onAbort(event) {
-								omDebug(`[OM:callReflector] onAbort: chunks=${chunkCount}, reason=${event?.reason ?? "unknown"}`);
-							},
-							onError({ error }) {
-								omError(`[OM:callReflector] onError after ${chunkCount} chunks`, error);
-							}
-						} : {}
-					})).getFullOutput();
+							} : {}
+						})).getFullOutput();
+					} catch (error) {
+						if (abortSignal?.aborted || !isOmModelExecutionFailure(error)) throw error;
+						throw new OmModelExecutionError("reflector-model", error);
+					}
 				}, abortSignal)
 			}), {
 				label: "reflector",
-				abortSignal
+				abortSignal,
+				maxRetries: this.reflectionConfig.maxRetries
 			});
 			omDebug(`[OM:callReflector] attempt #${attemptNumber} returned: textLen=${result.text?.length}, textPreview="${result.text?.slice(0, 120)}...", inputTokens=${result.usage?.inputTokens ?? result.totalUsage?.inputTokens}, outputTokens=${result.usage?.outputTokens ?? result.totalUsage?.outputTokens}`);
 			const usage = result.totalUsage ?? result.usage;
@@ -32506,6 +32831,7 @@ var ReflectorRunner = class {
 						startedAt: (/* @__PURE__ */ new Date()).toISOString(),
 						tokensAttempted: observationTokens,
 						error,
+						failurePolicy: this.reflectionConfig.failurePolicy,
 						recordId: record.id,
 						threadId: record.threadId ?? ""
 					});
@@ -32918,24 +33244,43 @@ var ReflectorRunner = class {
 				usage: reflectResult.usage
 			});
 		} catch (error) {
-			if (writer && streamContext) {
-				const failedMarker = createObservationFailedMarker({
-					cycleId: streamContext.cycleId,
-					operationType: "reflection",
-					startedAt: streamContext.startedAt,
-					tokensAttempted: observationTokens,
-					error,
-					recordId: record.id,
-					threadId
-				});
-				await writer.custom({
-					...failedMarker,
-					transient: true
-				}).catch(() => {});
+			reflectionError = error instanceof Error ? error : new Error(String(error));
+			const failedMarker = createObservationFailedMarker({
+				cycleId: streamContext?.cycleId ?? cycleId,
+				operationType: "reflection",
+				startedAt: streamContext?.startedAt ?? startedAt,
+				tokensAttempted: observationTokens,
+				error,
+				failurePolicy: this.reflectionConfig.failurePolicy,
+				recordId: record.id,
+				threadId
+			});
+			if (writer) await writer.custom({
+				...failedMarker,
+				transient: true
+			}).catch(() => {});
+			let persistedToList = false;
+			try {
+				persistedToList = await this.persistMarkerToMessage(failedMarker, messageList, threadId, record.resourceId ?? void 0);
+			} catch {
+				persistedToList = false;
+			}
+			if (!persistedToList) try {
 				await this.persistMarkerToStorage(failedMarker, threadId, record.resourceId ?? void 0);
+			} catch (markerError) {
+				omError("[OM] Failed to persist reflection-failed marker", markerError);
 			}
-			reflectionError = error instanceof Error ? error : new Error(String(error));
-			if (lifecycleError !== void 0 || abortSignal?.aborted) throw error;
+			this.emitDebugEvent({
+				type: "reflection_failed",
+				timestamp: /* @__PURE__ */ new Date(),
+				threadId,
+				resourceId: record.resourceId ?? "",
+				inputTokens: observationTokens,
+				failurePolicy: this.reflectionConfig.failurePolicy,
+				failureKind: failedMarker.data.failureKind,
+				error: reflectionError.message
+			});
+			if (lifecycleError !== void 0 || abortSignal?.aborted || this.reflectionConfig.failurePolicy !== "continue" || !isOmModelExecutionError(error) || error.failureKind !== "reflector-model") throw error;
 			this.syncReflectionSuppression.set(lockKey, observationTokens);
 			omError("[OM] Reflection failed", error);
 		} finally {
@@ -33569,6 +33914,8 @@ var ObservationalMemory = class ObservationalMemory {
 		const observationActivateAfterIdlePath = config.observation?.activateAfterIdle !== void 0 ? "observation.activateAfterIdle" : "activateAfterIdle";
 		this.observationConfig = {
 			model: observationModel,
+			maxRetries: config.observation?.maxRetries ?? RETRY_CONFIG.maxRetries,
+			failurePolicy: config.observation?.failurePolicy ?? "abort",
 			messageTokens: isSharedBudget ? {
 				min: messageTokens,
 				max: totalBudget
@@ -33598,6 +33945,8 @@ var ObservationalMemory = class ObservationalMemory {
 		};
 		this.reflectionConfig = {
 			model: reflectionModel,
+			maxRetries: config.reflection?.maxRetries ?? RETRY_CONFIG.maxRetries,
+			failurePolicy: config.reflection?.failurePolicy ?? "abort",
 			observationTokens,
 			shareTokenBudget: isSharedBudget,
 			modelSettings: {
@@ -33671,9 +34020,15 @@ var ObservationalMemory = class ObservationalMemory {
 			retrieval: this.retrieval,
 			observation: {
 				messageTokens: this.observationConfig.messageTokens,
-				previousObserverTokens: this.observationConfig.previousObserverTokens
+				previousObserverTokens: this.observationConfig.previousObserverTokens,
+				maxRetries: this.observationConfig.maxRetries,
+				failurePolicy: this.observationConfig.failurePolicy
 			},
-			reflection: { observationTokens: this.reflectionConfig.observationTokens }
+			reflection: {
+				observationTokens: this.reflectionConfig.observationTokens,
+				maxRetries: this.reflectionConfig.maxRetries,
+				failurePolicy: this.reflectionConfig.failurePolicy
+			}
 		};
 	}
 	/**
@@ -33777,11 +34132,15 @@ var ObservationalMemory = class ObservationalMemory {
 				messageTokens: this.observationConfig.messageTokens,
 				model: observationResolved.model,
 				previousObserverTokens: this.observationConfig.previousObserverTokens,
+				maxRetries: this.observationConfig.maxRetries,
+				failurePolicy: this.observationConfig.failurePolicy,
 				routing: observationResolved.routing
 			},
 			reflection: {
 				observationTokens: this.reflectionConfig.observationTokens,
 				model: reflectionResolved.model,
+				maxRetries: this.reflectionConfig.maxRetries,
+				failurePolicy: this.reflectionConfig.failurePolicy,
 				routing: reflectionResolved.routing
 			}
 		};
@@ -33798,6 +34157,7 @@ var ObservationalMemory = class ObservationalMemory {
 	* Ensures bufferTokens is less than the threshold and bufferActivation is valid.
 	*/
 	validateBufferConfig() {
+		for (const [path, value] of [["observation.maxRetries", this.observationConfig.maxRetries], ["reflection.maxRetries", this.reflectionConfig.maxRetries]]) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${path} must be a finite non-negative integer, got ${value}`);
 		if ((this.observationConfig.bufferTokens !== void 0 || this.observationConfig.bufferActivation !== void 0 || this.reflectionConfig.bufferActivation !== void 0) && this.scope === "resource") throw new Error("Async buffering is not yet supported with scope: 'resource'. Use scope: 'thread', or set observation: { bufferTokens: false } to disable async buffering.");
 		const observationThreshold = getMaxThreshold(this.observationConfig.messageTokens);
 		if (this.observationConfig.bufferTokens !== void 0) {
@@ -33925,18 +34285,19 @@ var ObservationalMemory = class ObservationalMemory {
 		};
 	}
 	/**
-	* Persist a data-om-* marker part on the last assistant message in messageList
-	* AND save the updated message to the DB so it survives page reload.
-	* (data-* parts are filtered out before sending to the LLM, so they don't affect model calls.)
+	* Persist a data-om-* marker part on the message that owns the operation in
+	* messageList and save it to the DB. Observation markers belong to the latest
+	* assistant message; reflection markers belong to the current user input.
 	* @internal Used by ReflectorRunner. Do not call directly.
 	*/
 	async persistMarkerToMessage(marker, messageList, threadId, resourceId) {
-		if (!messageList) return;
-		const allMsgs = getObservableMessages(messageList);
+		if (!messageList) return false;
+		const allMsgs = messageList.get.all.db();
+		const markerData = marker.data;
+		const targetRole = markerData?.operationType === "reflection" ? "user" : "assistant";
 		for (let i = allMsgs.length - 1; i >= 0; i--) {
 			const msg = allMsgs[i];
-			if (msg?.role === "assistant" && msg.content?.parts && Array.isArray(msg.content.parts)) {
-				const markerData = marker.data;
+			if (msg?.role === targetRole && msg.content?.parts && Array.isArray(msg.content.parts)) {
 				if (!(markerData?.cycleId && msg.content.parts.some((p) => p?.type === marker.type && p?.data?.cycleId === markerData.cycleId))) msg.content.parts.push(marker);
 				try {
 					await this.messageHistory.persistMessages({
@@ -33946,16 +34307,19 @@ var ObservationalMemory = class ObservationalMemory {
 					});
 				} catch (e) {
 					omDebug(`[OM:persistMarker] failed to save marker to DB: ${e}`);
+					return false;
 				}
-				return;
+				return true;
 			}
 		}
+		return false;
 	}
 	/**
-	* Persist a marker to the last assistant message in storage.
-	* Unlike persistMarkerToMessage, this fetches messages directly from the DB
-	* so it works even when no MessageList is available (e.g. async buffering ops).
-	* @internal Used by observation strategies. Do not call directly.
+	* Persist a marker to the message that owns the operation in storage.
+	* Observation markers belong to the latest assistant message. Reflection runs
+	* before the current assistant reply exists, so its failure marker belongs to
+	* the latest user input that triggered it.
+	* @internal Used by observation strategies and the reflector. Do not call directly.
 	*/
 	async persistMarkerToStorage(marker, threadId, resourceId) {
 		try {
@@ -33967,8 +34331,9 @@ var ObservationalMemory = class ObservationalMemory {
 					direction: "DESC"
 				}
 			}))?.messages ?? [];
-			for (const msg of messages) if (msg?.role === "assistant" && msg.content?.parts && Array.isArray(msg.content.parts)) {
-				const markerData = marker.data;
+			const markerData = marker.data;
+			const targetRole = markerData?.operationType === "reflection" ? "user" : "assistant";
+			for (const msg of messages) if (msg?.role === targetRole && msg.content?.parts && Array.isArray(msg.content.parts)) {
 				if (!(markerData?.cycleId && msg.content.parts.some((p) => p?.type === marker.type && p?.data?.cycleId === markerData.cycleId))) msg.content.parts.push(marker);
 				await this.messageHistory.persistMessages({
 					messages: [msg],
@@ -34210,9 +34575,9 @@ var ObservationalMemory = class ObservationalMemory {
 	* In resource scope mode, filters continuity messages to only show
 	* the message for the current thread.
 	*/
-	formatObservationsForContext(observations, currentTask, suggestedResponse, extractedValues, unobservedContextBlocks, currentDate, retrieval = false) {
+	formatObservationsForContext(observations, currentTask, suggestedResponse, extractedValues, unobservedContextBlocks, currentDate, retrieval = false, timeZone) {
 		let optimized = retrieval ? renderObservationGroupsForReflection(observations) ?? optimizeObservationsForContext(observations) : optimizeObservationsForContext(observations);
-		if (currentDate) optimized = addRelativeTimeToObservations(optimized, currentDate);
+		if (currentDate) optimized = addRelativeTimeToObservations(optimized, currentDate, timeZone);
 		const messages = [`${getObservationContextPrompt(this.scope)}\n\n${OBSERVATION_CONTEXT_INSTRUCTIONS}${retrieval ? `\n\n${getRetrievalInstructions(this.retrievalScope, this.retrievalInstructions, this.retrievalSearch)}` : ""}`];
 		if (unobservedContextBlocks) messages.push(`The following content is from OTHER conversations different from the current conversation, they're here for reference,  but they're not necessarily your focus:\nSTART_OTHER_CONVERSATIONS_BLOCK\n${unobservedContextBlocks}\nEND_OTHER_CONVERSATIONS_BLOCK`);
 		const observationChunks = this.splitObservationContextChunks(optimized);
@@ -34312,12 +34677,15 @@ var ObservationalMemory = class ObservationalMemory {
 	* These are injected into the Actor's context so it has awareness of activity
 	* in other threads for the same resource.
 	*/
-	async formatUnobservedContextBlocks(messagesByThread, currentThreadId) {
+	async formatUnobservedContextBlocks(messagesByThread, currentThreadId, timeZone) {
 		const blocks = [];
 		for (const [threadId, messages] of messagesByThread) {
 			if (threadId === currentThreadId) continue;
 			if (messages.length === 0) continue;
-			const formattedMessages = formatMessagesForObserver(messages, { maxPartLength: 500 });
+			const formattedMessages = formatMessagesForObserver(messages, {
+				maxPartLength: 500,
+				timeZone
+			});
 			if (formattedMessages) {
 				const obscuredId = await this.representThreadIDInContext(threadId);
 				blocks.push(`<other-conversation id="${obscuredId}">
@@ -34494,7 +34862,7 @@ ${formattedMessages}
 			transient: true
 		}).catch(() => {});
 		omDebug(`[OM:bufferInput] cycleId=${cycleId}, msgCount=${messagesToBuffer.length}, msgTokens=${tokensToBuffer}, ids=${messagesToBuffer.map((m) => `${m.id?.slice(0, 8)}@${m.createdAt ? new Date(m.createdAt).toISOString() : "none"}`).join(",")}`);
-		await this.runBufferedObservationCycle({
+		if ((await this.runBufferedObservationCycle({
 			threadId,
 			resourceId: freshRecord.resourceId ?? void 0,
 			trigger: "async-buffer"
@@ -34509,10 +34877,11 @@ ${formattedMessages}
 			requestContext,
 			observabilityContext,
 			trigger: "async-buffer"
-		}).run());
-		const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
-		const cursor = new Date(maxTs.getTime() + 1);
-		BufferingCoordinator.lastBufferedAtTime.set(bufferKey, cursor);
+		}).run()))?.observed) {
+			const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
+			const cursor = new Date(maxTs.getTime() + 1);
+			BufferingCoordinator.lastBufferedAtTime.set(bufferKey, cursor);
+		}
 	}
 	/**
 	* Trigger async buffered observation if the token count has crossed a new interval.
@@ -34740,7 +35109,7 @@ ${formattedMessages}
 		const currentTask = activeExtractors.some((extractor) => extractor.slug === "current-task") ? omMetadata?.currentTask : void 0;
 		const suggestedResponse = activeExtractors.some((extractor) => extractor.slug === "suggested-response") ? omMetadata?.suggestedResponse : void 0;
 		const currentDate = opts.currentDate ?? /* @__PURE__ */ new Date();
-		return this.formatObservationsForContext(record.activeObservations, currentTask, suggestedResponse, omMetadata?.extracted, unobservedContextBlocks, currentDate, this.retrieval);
+		return this.formatObservationsForContext(record.activeObservations, currentTask, suggestedResponse, omMetadata?.extracted, unobservedContextBlocks, currentDate, this.retrieval, record.observedTimezone);
 	}
 	/**
 	* Get unobserved messages from other threads for resource-scoped observation.
@@ -34752,7 +35121,8 @@ ${formattedMessages}
 	async getOtherThreadsContext(resourceId, currentThreadId) {
 		const { threads: allThreads } = await this.storage.listThreads({ filter: { resourceId } });
 		const messagesByThread = /* @__PURE__ */ new Map();
-		const recordLastObservedAt = (await this.getRecord(currentThreadId, resourceId))?.lastObservedAt;
+		const record = await this.getRecord(currentThreadId, resourceId);
+		const recordLastObservedAt = record?.lastObservedAt;
 		for (const thread of allThreads) {
 			if (thread.id === currentThreadId) continue;
 			const threadLastObservedAt = getThreadOMMetadata(thread.metadata)?.lastObservedAt ?? recordLastObservedAt;
@@ -34769,7 +35139,7 @@ ${formattedMessages}
 			if (filtered.length > 0) messagesByThread.set(thread.id, filtered);
 		}
 		if (messagesByThread.size === 0) return void 0;
-		return await this.formatUnobservedContextBlocks(messagesByThread, currentThreadId) || void 0;
+		return await this.formatUnobservedContextBlocks(messagesByThread, currentThreadId, record?.observedTimezone) || void 0;
 	}
 	/**
 	* Emit debug event and stream progress for UI feedback.
@@ -35112,7 +35482,7 @@ ${formattedMessages}
 				...startMarker,
 				transient: true
 			}).catch(() => {});
-			await this.runBufferedObservationCycle({
+			if (!(await this.runBufferedObservationCycle({
 				threadId,
 				resourceId: record.resourceId ?? resourceId,
 				trigger: "async-buffer"
@@ -35131,7 +35501,10 @@ ${formattedMessages}
 				currentModel: opts.currentModel,
 				observabilityContext,
 				trigger: "async-buffer"
-			}).run());
+			}).run()))?.observed) return {
+				buffered: false,
+				record
+			};
 			if (isOmReproCaptureEnabled()) writeObserverExchangeReproCapture({
 				threadId,
 				resourceId: record.resourceId ?? void 0,
@@ -35491,6 +35864,7 @@ ${formattedMessages}
 				observed = result.observed;
 				observationUsage = result.usage;
 				observationProviderMetadata = result.providerMetadata;
+				observationError = result.error;
 			});
 		} catch (error) {
 			lifecycleError = error;
@@ -37401,6 +37775,7 @@ ${workingMemory}`;
 			model: omConfig.model,
 			mastra: this._mastraInstance,
 			onIndexObservations,
+			onDebugEvent: omConfig.onDebugEvent,
 			hooks: omConfig.hooks,
 			observation: omConfig.observation ? {
 				model: omConfig.observation.model,
@@ -37417,10 +37792,14 @@ ${workingMemory}`;
 				threadTitle: omConfig.observation.threadTitle,
 				observeAttachments: omConfig.observation.observeAttachments,
 				continuationHints: omConfig.observation.continuationHints,
+				maxRetries: omConfig.observation.maxRetries,
+				failurePolicy: omConfig.observation.failurePolicy,
 				extract: omConfig.observation.extract
 			} : void 0,
 			reflection: omConfig.reflection ? {
 				model: omConfig.reflection.model,
+				maxRetries: omConfig.reflection.maxRetries,
+				failurePolicy: omConfig.reflection.failurePolicy,
 				observationTokens: omConfig.reflection.observationTokens,
 				modelSettings: omConfig.reflection.modelSettings,
 				providerOptions: omConfig.reflection.providerOptions,
@@ -49270,4 +49649,4 @@ const agentBuilderWorkflows = {
 //#endregion
 export { agentBuilderWorkflows };
 
-//# sourceMappingURL=dist-ABdCIqbD.js.map
+//# sourceMappingURL=dist-Bo9o3JNW.js.map