@mastra/memory 1.32.2-alpha.0 → 1.33.0-alpha.2

package/dist/{src-B-_pkR2t.js → src-BikfoIdS.js}

@@ -18696,10 +18696,227 @@ async function applyExtractorHooks(opts) {
 	};
 }
 //#endregion
-//#region src/processors/observational-memory/error.ts
+//#region src/processors/observational-memory/retry.ts
+/**
+* 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);
+		}
+	}
+}
+//#endregion
+//#region src/processors/observational-memory/error.ts
+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();
@@ -18709,7 +18926,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;
 		}
@@ -18719,10 +18936,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 {}
@@ -18737,8 +18954,8 @@ function formatOmError(error) {
 }
 //#endregion
 //#region src/processors/observational-memory/extraction-runner.ts
-function isAbortError$1(error, abortSignal) {
-	return abortSignal?.aborted === true || error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+function isAbortError(error, abortSignal) {
+	return abortSignal?.aborted === true || hasAbortInChain(error);
 }
 function shouldRetryEmptyStructuredObject(object, extractors) {
 	return Object.keys(object).length === 0 && extractors.some((extractor) => extractor.retryStructuredExtractionOnEmptyObject);
@@ -18764,7 +18981,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,
@@ -18784,11 +19006,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(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(fallbackError, opts.abortSignal)) throw fallbackError;
 			const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
 			return {
 				values,
@@ -18802,7 +19034,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(fallbackError, opts.abortSignal)) throw fallbackError;
 		const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
 		return {
 			values,
@@ -18830,15 +19062,15 @@ ${extractorInstructions}${priorLines.length > 0 ? `\n\n## Prior Extracted Values
 //#endregion
 //#region src/system-reminders.ts
 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");
 }
@@ -18901,12 +19133,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";
@@ -18932,8 +19193,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]`;
@@ -18941,45 +19201,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 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 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");
 /**
-* Parses a date string like "May 30, 2023", "May 27-28, 2023", "late April 2023", etc.
-* Returns the parsed Date or null if unparseable.
+* 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 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 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.)
@@ -18999,40 +19370,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
@@ -19046,11 +19436,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);
@@ -20065,11 +20454,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
@@ -20159,11 +20557,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) {
@@ -20224,7 +20622,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: []
 	};
@@ -20238,7 +20636,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
 		};
 	});
@@ -20355,6 +20753,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);
@@ -20364,8 +20763,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
 		});
@@ -20919,171 +21318,6 @@ function optimizeObservationsForContext(observations) {
 	return optimized.trim();
 }
 //#endregion
-//#region src/processors/observational-memory/retry.ts
-/**
-* 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(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(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(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);
-		}
-	}
-}
-//#endregion
 //#region src/processors/observational-memory/temporary-memory.ts
 function createTemporaryOmMemoryContext(prefix) {
 	const options = {
@@ -21225,11 +21459,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 } : {}
 		});
@@ -21321,7 +21571,10 @@ var ObserverRunner = class {
 			...options,
 			includeThreadTitle: this.observationConfig.threadTitle,
 			extractors: activeExtractors
-		}, { attachmentFilter })];
+		}, {
+			attachmentFilter,
+			timeZone: options?.timeZone
+		})];
 		const doGenerate = async () => {
 			return withRetry(() => withOmTracingSpan({
 				phase: "observer",
@@ -21359,12 +21612,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();
@@ -21432,7 +21687,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
@@ -21443,7 +21698,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) {
@@ -21454,7 +21709,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 = (() => {
@@ -21496,7 +21751,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,
@@ -21513,6 +21769,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
@@ -21521,8 +21778,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",
@@ -21560,12 +21819,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();
@@ -21621,6 +21882,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,
@@ -23114,6 +23376,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 },
@@ -24944,6 +25208,7 @@ function createObservationFailedMarker(params) {
 			durationMs,
 			tokensAttempted: params.tokensAttempted,
 			error: formatOmError(params.error),
+			...getOmFailureMetadata(params.error, params.failurePolicy ?? "abort"),
 			recordId: params.recordId,
 			threadId: params.threadId
 		}
@@ -25005,6 +25270,7 @@ function createBufferingFailedMarker(params) {
 			durationMs,
 			tokensAttempted: params.tokensAttempted,
 			error: formatOmError(params.error),
+			...getOmFailureMetadata(params.error, params.failurePolicy ?? "abort"),
 			recordId: params.recordId,
 			threadId: params.threadId
 		}
@@ -25061,7 +25327,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;
 }
 /**
@@ -25313,6 +25582,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;
@@ -25333,8 +25603,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
@@ -25721,6 +25995,7 @@ var ObservationStrategy = class ObservationStrategy {
 				observationTokens: processed.observationTokens,
 				threadId,
 				writer,
+				messageList: this.opts.messageList,
 				abortSignal,
 				mainAgent: this.opts.agent,
 				sendSignal: this.opts.sendSignal,
@@ -25745,6 +26020,7 @@ var ObservationStrategy = class ObservationStrategy {
 						operationType: "observation",
 						startedAt: (/* @__PURE__ */ new Date()).toISOString(),
 						error: formatOmError(error),
+						...getOmFailureMetadata(error, this.observationConfig.failurePolicy),
 						recordId: record.id,
 						threadId
 					}
@@ -25758,6 +26034,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;
 		}
 	}
@@ -26027,7 +26307,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",
@@ -26036,7 +26317,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,
@@ -26167,6 +26451,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
 			});
@@ -26218,7 +26503,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",
@@ -26227,7 +26513,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,
@@ -26373,6 +26662,7 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			startedAt: this.startedAt,
 			tokensAttempted,
 			error,
+			failurePolicy: this.observationConfig.failurePolicy,
 			recordId: record.id,
 			threadId
 		});
@@ -26549,7 +26839,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);
@@ -26582,7 +26872,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,
@@ -26741,6 +27034,7 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 				startedAt: this.startedAt,
 				tokensAttempted,
 				error,
+				failurePolicy: this.observationConfig.failurePolicy,
 				recordId: this.opts.record.id,
 				threadId
 			});
@@ -27155,19 +27449,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);
@@ -27825,11 +28128,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 } : {}
 		});
@@ -27911,36 +28230,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;
@@ -28064,6 +28389,7 @@ var ReflectorRunner = class {
 						startedAt: (/* @__PURE__ */ new Date()).toISOString(),
 						tokensAttempted: observationTokens,
 						error,
+						failurePolicy: this.reflectionConfig.failurePolicy,
 						recordId: record.id,
 						threadId: record.threadId ?? ""
 					});
@@ -28476,24 +28802,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 {
@@ -29131,6 +29476,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
@@ -29160,6 +29507,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: {
@@ -29233,9 +29582,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
+			}
 		};
 	}
 	/**
@@ -29339,11 +29694,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
 			}
 		};
@@ -29360,6 +29719,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) {
@@ -29487,18 +29847,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({
@@ -29508,16 +29869,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 {
@@ -29529,8 +29893,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],
@@ -29772,9 +30137,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);
@@ -29874,12 +30239,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}">
@@ -30056,7 +30424,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"
@@ -30071,10 +30439,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.
@@ -30302,7 +30671,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.
@@ -30314,7 +30683,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;
@@ -30331,7 +30701,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.
@@ -30674,7 +31044,7 @@ ${formattedMessages}
 				...startMarker,
 				transient: true
 			}).catch(() => {});
-			await this.runBufferedObservationCycle({
+			if (!(await this.runBufferedObservationCycle({
 				threadId,
 				resourceId: record.resourceId ?? resourceId,
 				trigger: "async-buffer"
@@ -30693,7 +31063,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,
@@ -31053,6 +31426,7 @@ ${formattedMessages}
 				observed = result.observed;
 				observationUsage = result.usage;
 				observationProviderMetadata = result.providerMetadata;
+				observationError = result.error;
 			});
 		} catch (error) {
 			lifecycleError = error;
@@ -32988,6 +33362,7 @@ ${workingMemory}`;
 			model: omConfig.model,
 			mastra: this._mastraInstance,
 			onIndexObservations,
+			onDebugEvent: omConfig.onDebugEvent,
 			hooks: omConfig.hooks,
 			observation: omConfig.observation ? {
 				model: omConfig.observation.model,
@@ -33004,10 +33379,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,
@@ -34079,4 +34458,4 @@ Notes:
 //#endregion
 export { formatMessagesForObserver as A, OBSERVATION_CONTEXT_PROMPT_THREAD as B, SUMMARIZE_THREAD_DEFAULTS as C, buildObserverPrompt as D, OBSERVER_SYSTEM_PROMPT as E, parseAnchorId as F, StaleKnowledgeSemanticIndexError as G, getObservationContextPrompt as H, stripEphemeralAnchorIds as I, SUBCONSCIOUS_ACTIVITY_STATE_ID as J, SubconsciousRemindExtractor as K, OBSERVATIONAL_MEMORY_DEFAULTS as L, optimizeObservationsForContext as M, parseObserverOutput as N, buildObserverSystemPrompt as O, injectAnchorIds as P, Extractor as Q, OBSERVATION_CONTEXT_INSTRUCTIONS as R, deepMergeWorkingMemory as S, TokenCounter as T, Subconscious as U, OBSERVATION_CONTINUATION_HINT as V, KnowledgeSemanticIndexCoordinator as W, publishSubconsciousActivity as X, buildSubconsciousActivitySnapshot as Y, renderSubconsciousActivity as Z, wrapInObservationGroup as _, extractWorkingMemoryContent as a, WorkingMemoryStateProcessor as b, getObservationsAsOf as c, combineObservationGroupRanges as d, deriveObservationGroupProvenance as f, stripObservationGroups as g, renderObservationGroupsForReflection as h, WorkingMemory as i, hasCurrentTaskSection as j, extractCurrentTask as k, ObservationalMemoryProcessor as l, reconcileObservationGroupsFromReflection as m, MessageHistory$1 as n, extractWorkingMemoryTags as o, parseObservationGroups as p, ModelByInputTokens as q, SemanticRecall as r, removeWorkingMemoryTags as s, Memory as t, ObservationalMemory as u, WORKING_MEMORY_STATE_ID as v, summarizeConversation as w, WorkingMemoryExtractor as x, WORKING_MEMORY_STATE_PROCESSOR_ID as y, OBSERVATION_CONTEXT_PROMPT as z };
 
-//# sourceMappingURL=src-B-_pkR2t.js.map
+//# sourceMappingURL=src-BikfoIdS.js.map