@mastra/server 1.33.0-alpha.1 → 1.33.0-alpha.13

package/dist/{chunk-S65AMBAF.js → chunk-MQIZJZCT.js}

@@ -1040,7 +1040,7 @@ function imageSize(input) {
   throw new TypeError(`unsupported file type: ${type}`);
 }
 
-// ../memory/dist/chunk-NUYSX3DD.js
+// ../memory/dist/chunk-LPMZNXSF.js
 var OM_DEBUG_LOG = process.env.OM_DEBUG ? join(process.cwd(), "om-debug.log") : null;
 function omDebug(msg) {
   if (!OM_DEBUG_LOG) return;
@@ -2022,8 +2022,6 @@ var ObservationStrategy = class _ObservationStrategy {
     this.scope = deps.scope;
     this.retrieval = deps.retrieval;
   }
-  deps;
-  opts;
   storage;
   messageHistory;
   tokenCounter;
@@ -2698,8 +2696,9 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
         orderBy: { field: "createdAt", direction: "ASC" },
         filter: startDate ? { dateRange: { start: startDate } } : void 0
       });
-      if (result.messages.length > 0) {
-        this.messagesByThread.set(thread.id, result.messages);
+      const messages = result.messages.filter((msg) => msg.role !== "system");
+      if (messages.length > 0) {
+        this.messagesByThread.set(thread.id, messages);
       }
     }
     if (currentThreadMessages.length > 0) {
@@ -3028,13 +3027,25 @@ ObservationStrategy.create = ((om, opts) => {
   if (deps.scope === "resource" && opts.resourceId) return new ResourceScopedObservationStrategy(deps, opts);
   return new SyncObservationStrategy(deps, opts);
 });
+async function loadMemoryContextMessages({
+  memory,
+  messageList,
+  threadId,
+  resourceId
+}) {
+  const ctx = await memory.getContext({ threadId, resourceId });
+  for (const msg of ctx.messages) {
+    if (msg.role !== "system") {
+      messageList.add(msg, "memory");
+    }
+  }
+  return ctx;
+}
 var ObservationStep = class {
   constructor(turn, stepNumber) {
     this.turn = turn;
     this.stepNumber = stepNumber;
   }
-  turn;
-  stepNumber;
   _prepared = false;
   _context;
   /** Whether this step has been prepared. */
@@ -3393,12 +3404,12 @@ var ObservationTurn = class {
     this._generationCountAtStart = this._record.generationCount;
     this.memory = memory;
     if (memory) {
-      const ctx = await memory.getContext({ threadId: this.threadId, resourceId: this.resourceId });
-      for (const msg of ctx.messages) {
-        if (msg.role !== "system") {
-          this.messageList.add(msg, "memory");
-        }
-      }
+      const ctx = await loadMemoryContextMessages({
+        memory,
+        messageList: this.messageList,
+        threadId: this.threadId,
+        resourceId: this.resourceId
+      });
       this._context = {
         messages: ctx.messages,
         systemMessage: ctx.systemMessage,
@@ -4773,6 +4784,133 @@ function optimizeObservationsForContext(observations) {
   optimized = optimized.replace(/\n{3,}/g, "\n\n");
   return optimized.trim();
 }
+var 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: 0.2
+};
+var 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 isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isAbortError(error) {
+  if (!isRecord2(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 (!isRecord2(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 hasRetryableHttpStatus(value) {
+  if (!isRecord2(value)) return false;
+  const status = typeof value.statusCode === "number" ? value.statusCode : void 0;
+  if (status === void 0) return false;
+  if (status === 408 || status === 425 || status === 429) return true;
+  if (status >= 500 && status <= 599) return true;
+  return false;
+}
+function hasIsRetryableFlag(value) {
+  if (!isRecord2(value)) return false;
+  return value.isRetryable === true;
+}
+function isTransientLLMError(error) {
+  if (isAbortError(error)) return false;
+  const visited = /* @__PURE__ */ new WeakSet();
+  function visit(candidate) {
+    if (isRecord2(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 (isRecord2(candidate)) {
+      if (visit(candidate.cause)) return true;
+      if (visit(candidate.error)) return true;
+    }
+    return false;
+  }
+  return visit(error);
+}
+function computeDelay(attempt) {
+  const base = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, attempt);
+  const capped = Math.min(base, RETRY_CONFIG.maxDelayMs);
+  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(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(new Error("The operation was aborted."));
+    };
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+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);
+    }
+  }
+}
 var PHASE_CONFIG = {
   observer: {
     name: "om.observer",
@@ -4881,32 +5019,35 @@ var ObserverRunner = class {
       buildObserverHistoryMessage(messagesToObserve)
     ];
     const doGenerate = async () => {
-      return withOmTracingSpan({
-        phase: "observer",
-        model: resolvedModel.model,
-        inputTokens,
-        requestContext: options?.requestContext,
-        observabilityContext: options?.observabilityContext,
-        metadata: {
-          omPreviousObserverTokens: this.observationConfig.previousObserverTokens,
-          omThreadTitleEnabled: this.observationConfig.threadTitle,
-          omSkipContinuationHints: options?.skipContinuationHints ?? false,
-          omWasTruncated: options?.wasTruncated ?? false,
-          ...resolvedModel.selectedThreshold !== void 0 ? { omSelectedThreshold: resolvedModel.selectedThreshold } : {},
-          ...resolvedModel.routingStrategy ? { omRoutingStrategy: resolvedModel.routingStrategy } : {},
-          ...resolvedModel.routingThresholds ? { omRoutingThresholds: resolvedModel.routingThresholds } : {}
-        },
-        callback: (childObservabilityContext) => this.withAbortCheck(async () => {
-          const streamResult = await agent.stream(observerMessages, {
-            modelSettings: { ...this.observationConfig.modelSettings },
-            providerOptions: this.observationConfig.providerOptions,
-            ...abortSignal ? { abortSignal } : {},
-            ...options?.requestContext ? { requestContext: options.requestContext } : {},
-            ...childObservabilityContext
-          });
-          return streamResult.getFullOutput();
-        }, abortSignal)
-      });
+      return withRetry(
+        () => withOmTracingSpan({
+          phase: "observer",
+          model: resolvedModel.model,
+          inputTokens,
+          requestContext: options?.requestContext,
+          observabilityContext: options?.observabilityContext,
+          metadata: {
+            omPreviousObserverTokens: this.observationConfig.previousObserverTokens,
+            omThreadTitleEnabled: this.observationConfig.threadTitle,
+            omSkipContinuationHints: options?.skipContinuationHints ?? false,
+            omWasTruncated: options?.wasTruncated ?? false,
+            ...resolvedModel.selectedThreshold !== void 0 ? { omSelectedThreshold: resolvedModel.selectedThreshold } : {},
+            ...resolvedModel.routingStrategy ? { omRoutingStrategy: resolvedModel.routingStrategy } : {},
+            ...resolvedModel.routingThresholds ? { omRoutingThresholds: resolvedModel.routingThresholds } : {}
+          },
+          callback: (childObservabilityContext) => this.withAbortCheck(async () => {
+            const streamResult = await agent.stream(observerMessages, {
+              modelSettings: { ...this.observationConfig.modelSettings },
+              providerOptions: this.observationConfig.providerOptions,
+              ...abortSignal ? { abortSignal } : {},
+              ...options?.requestContext ? { requestContext: options.requestContext } : {},
+              ...childObservabilityContext
+            });
+            return streamResult.getFullOutput();
+          }, abortSignal)
+        }),
+        { label: "observer", abortSignal }
+      );
     };
     let result = await doGenerate();
     let parsed = parseObserverOutput(result.text);
@@ -4980,31 +5121,34 @@ var ObserverRunner = class {
       }
     }
     const doGenerate = async () => {
-      return withOmTracingSpan({
-        phase: "observer-multi-thread",
-        model: resolvedModel.model,
-        inputTokens,
-        requestContext,
-        observabilityContext,
-        metadata: {
-          omThreadCount: threadOrder.length,
-          omPreviousObserverTokens: this.observationConfig.previousObserverTokens,
-          omThreadTitleEnabled: this.observationConfig.threadTitle,
-          ...resolvedModel.selectedThreshold !== void 0 ? { omSelectedThreshold: resolvedModel.selectedThreshold } : {},
-          ...resolvedModel.routingStrategy ? { omRoutingStrategy: resolvedModel.routingStrategy } : {},
-          ...resolvedModel.routingThresholds ? { omRoutingThresholds: resolvedModel.routingThresholds } : {}
-        },
-        callback: (childObservabilityContext) => this.withAbortCheck(async () => {
-          const streamResult = await agent.stream(observerMessages, {
-            modelSettings: { ...this.observationConfig.modelSettings },
-            providerOptions: this.observationConfig.providerOptions,
-            ...abortSignal ? { abortSignal } : {},
-            ...requestContext ? { requestContext } : {},
-            ...childObservabilityContext
-          });
-          return streamResult.getFullOutput();
-        }, abortSignal)
-      });
+      return withRetry(
+        () => withOmTracingSpan({
+          phase: "observer-multi-thread",
+          model: resolvedModel.model,
+          inputTokens,
+          requestContext,
+          observabilityContext,
+          metadata: {
+            omThreadCount: threadOrder.length,
+            omPreviousObserverTokens: this.observationConfig.previousObserverTokens,
+            omThreadTitleEnabled: this.observationConfig.threadTitle,
+            ...resolvedModel.selectedThreshold !== void 0 ? { omSelectedThreshold: resolvedModel.selectedThreshold } : {},
+            ...resolvedModel.routingStrategy ? { omRoutingStrategy: resolvedModel.routingStrategy } : {},
+            ...resolvedModel.routingThresholds ? { omRoutingThresholds: resolvedModel.routingThresholds } : {}
+          },
+          callback: (childObservabilityContext) => this.withAbortCheck(async () => {
+            const streamResult = await agent.stream(observerMessages, {
+              modelSettings: { ...this.observationConfig.modelSettings },
+              providerOptions: this.observationConfig.providerOptions,
+              ...abortSignal ? { abortSignal } : {},
+              ...requestContext ? { requestContext } : {},
+              ...childObservabilityContext
+            });
+            return streamResult.getFullOutput();
+          }, abortSignal)
+        }),
+        { label: "observer-multi-thread", abortSignal }
+      );
     };
     let result = await doGenerate();
     let parsed = parseMultiThreadObserverOutput(result.text);
@@ -5444,54 +5588,60 @@ var ReflectorRunner = class {
         `[OM:callReflector] ${isRetry ? `retry #${attemptNumber - 1}` : "first attempt"}: level=${currentLevel}, originalTokens=${originalTokens}, targetThreshold=${targetThreshold}, promptLen=${prompt.length}, skipContinuationHints=${skipContinuationHints}`
       );
       let chunkCount = 0;
-      const result = await withOmTracingSpan({
-        phase: "reflector",
-        model: resolvedModel.model,
-        inputTokens: originalTokens,
-        requestContext,
-        observabilityContext,
-        metadata: {
-          omCompressionLevel: currentLevel,
-          omCompressionAttempt: attemptNumber,
-          omTargetThreshold: targetThreshold,
-          omSkipContinuationHints: skipContinuationHints ?? false,
-          ...resolvedModel.selectedThreshold !== void 0 ? { omSelectedThreshold: resolvedModel.selectedThreshold } : {},
-          ...resolvedModel.routingStrategy ? { omRoutingStrategy: resolvedModel.routingStrategy } : {},
-          ...resolvedModel.routingThresholds ? { omRoutingThresholds: resolvedModel.routingThresholds } : {}
-        },
-        callback: (childObservabilityContext) => withAbortCheck(async () => {
-          const streamResult = await agent.stream(prompt, {
-            modelSettings: {
-              ...this.reflectionConfig.modelSettings
-            },
-            providerOptions: this.reflectionConfig.providerOptions,
-            ...abortSignal ? { abortSignal } : {},
-            ...requestContext ? { requestContext } : {},
-            ...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"}`);
+      const result = await withRetry(
+        () => withOmTracingSpan({
+          phase: "reflector",
+          model: resolvedModel.model,
+          inputTokens: originalTokens,
+          requestContext,
+          observabilityContext,
+          metadata: {
+            omCompressionLevel: currentLevel,
+            omCompressionAttempt: attemptNumber,
+            omTargetThreshold: targetThreshold,
+            omSkipContinuationHints: skipContinuationHints ?? false,
+            ...resolvedModel.selectedThreshold !== void 0 ? { omSelectedThreshold: resolvedModel.selectedThreshold } : {},
+            ...resolvedModel.routingStrategy ? { omRoutingStrategy: resolvedModel.routingStrategy } : {},
+            ...resolvedModel.routingThresholds ? { omRoutingThresholds: resolvedModel.routingThresholds } : {}
+          },
+          callback: (childObservabilityContext) => withAbortCheck(async () => {
+            chunkCount = 0;
+            const streamResult = await agent.stream(prompt, {
+              modelSettings: {
+                ...this.reflectionConfig.modelSettings
               },
-              onError({ error }) {
-                omError(`[OM:callReflector] onError after ${chunkCount} chunks`, error);
-              }
-            } : {}
-          });
-          return streamResult.getFullOutput();
-        }, abortSignal)
-      });
+              providerOptions: this.reflectionConfig.providerOptions,
+              ...abortSignal ? { abortSignal } : {},
+              ...requestContext ? { requestContext } : {},
+              ...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);
+                }
+              } : {}
+            });
+            return streamResult.getFullOutput();
+          }, abortSignal)
+        }),
+        { label: "reflector", abortSignal }
+      );
       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}`
       );
@@ -6647,7 +6797,7 @@ async function resolveImageDimensionsAsync(part) {
     return existing;
   }
   try {
-    const mod = await import('./probe-image-size-QWKVSEOF.js');
+    const mod = await import('./probe-image-size-M5NYSF5D.js');
     const probeImageSize = mod.default;
     const probed = await probeImageSize(url, {
       open_timeout: REMOTE_IMAGE_PROBE_TIMEOUT_MS,
@@ -7633,7 +7783,7 @@ function getCurrentModel2(model) {
   return formatModelContext2(model?.provider, model?.modelId);
 }
 function parseActivationTTL(value, fieldPath) {
-  if (value === void 0) {
+  if (value === void 0 || value === false) {
     return void 0;
   }
   if (typeof value === "number") {
@@ -7781,6 +7931,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         );
       }
     }
+    const observationActivateAfterIdle = config.observation?.activateAfterIdle ?? config.activateAfterIdle;
+    const observationActivateAfterIdlePath = config.observation?.activateAfterIdle !== void 0 ? "observation.activateAfterIdle" : "activateAfterIdle";
     this.observationConfig = {
       model: observationModel,
       // When shared budget, store as range: min = base threshold, max = total budget
@@ -7798,8 +7950,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens
       ),
       bufferActivation: asyncBufferingDisabled ? void 0 : config.observation?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferActivation,
-      activateAfterIdle: parseActivationTTL(config.activateAfterIdle, "activateAfterIdle"),
-      activateOnProviderChange: config.activateOnProviderChange ?? false,
+      activateAfterIdle: parseActivationTTL(observationActivateAfterIdle, observationActivateAfterIdlePath),
+      activateOnProviderChange: config.observation?.activateOnProviderChange ?? config.activateOnProviderChange ?? false,
       blockAfter: asyncBufferingDisabled ? void 0 : resolveBlockAfter(
         config.observation?.blockAfter ?? (config.observation?.bufferTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.bufferTokens ? 1.2 : void 0),
         config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens
@@ -7818,8 +7970,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       },
       providerOptions: config.reflection?.providerOptions ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.providerOptions,
       bufferActivation: asyncBufferingDisabled ? void 0 : config?.reflection?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.bufferActivation,
-      activateAfterIdle: parseActivationTTL(config.activateAfterIdle, "activateAfterIdle"),
-      activateOnProviderChange: config.activateOnProviderChange ?? false,
+      activateAfterIdle: parseActivationTTL(config.reflection?.activateAfterIdle, "reflection.activateAfterIdle"),
+      activateOnProviderChange: config.reflection?.activateOnProviderChange ?? false,
       blockAfter: asyncBufferingDisabled ? void 0 : resolveBlockAfter(
         config.reflection?.blockAfter ?? (config.reflection?.bufferActivation ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.bufferActivation ? 1.2 : void 0),
         config.reflection?.observationTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.observationTokens
@@ -8410,6 +8562,9 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     }
     const result = [];
     for (const msg of allMessages) {
+      if (msg.role === "system") {
+        continue;
+      }
       if (observedMessageIds?.has(msg.id)) {
         continue;
       }
@@ -8720,7 +8875,7 @@ ${suggestedResponse}
         } : void 0
       });
     }
-    return result.messages;
+    return result.messages.filter((msg) => msg.role !== "system");
   }
   /**
    * Format unobserved messages from other threads as <unobserved-context> blocks.
@@ -10199,6 +10354,33 @@ var GATEWAY_STATE_KEY = "__isGatewayModel";
 function isMastraGatewayModel(model) {
   return typeof model === "object" && model !== null && "gatewayId" in model && model.gatewayId === "mastra";
 }
+function injectObservationContextMessages({
+  messageList,
+  systemMessages,
+  continuationMessage,
+  threadId,
+  resourceId
+}) {
+  if (!systemMessages?.length) {
+    return;
+  }
+  messageList.clearSystemMessages("observational-memory");
+  for (const msg of systemMessages) {
+    messageList.addSystem(msg, "observational-memory");
+  }
+  const contMsg = continuationMessage ?? {
+    id: "om-continuation",
+    role: "user",
+    createdAt: /* @__PURE__ */ new Date(0),
+    content: {
+      format: 2,
+      parts: [{ type: "text", text: `<system-reminder>${OBSERVATION_CONTINUATION_HINT}</system-reminder>` }]
+    },
+    threadId,
+    resourceId
+  };
+  messageList.add(contMsg, "memory");
+}
 var ObservationalMemoryProcessor = class {
   id = "observational-memory";
   name = "Observational Memory";
@@ -10253,6 +10435,25 @@ var ObservationalMemoryProcessor = class {
       const preMessagesSnapshot = reproCaptureEnabled ? safeCaptureJson(messageList.get.all.db()) : null;
       const preSerializedMessageList = reproCaptureEnabled ? safeCaptureJson(messageList.serialize()) : null;
       if (readOnly) {
+        const ctx = await loadMemoryContextMessages({
+          memory: this.memory,
+          messageList,
+          threadId,
+          resourceId
+        });
+        const systemMessages = ctx.hasObservations && ctx.omRecord ? await this.engine.buildContextSystemMessages({
+          threadId,
+          resourceId,
+          record: ctx.omRecord,
+          unobservedContextBlocks: ctx.otherThreadsContext
+        }) : void 0;
+        injectObservationContextMessages({
+          messageList,
+          systemMessages,
+          continuationMessage: ctx.continuationMessage,
+          threadId,
+          resourceId
+        });
         return messageList;
       }
       const activeTurn = state.__omTurn ?? this.turn;
@@ -10308,26 +10509,13 @@ var ObservationalMemoryProcessor = class {
           }
           throw err;
         }
-        if (ctx.systemMessage) {
-          messageList.clearSystemMessages("observational-memory");
-          for (const msg of ctx.systemMessage) {
-            messageList.addSystem(msg, "observational-memory");
-          }
-          const contMsg = this.turn.context.continuation ?? {
-            id: "om-continuation",
-            role: "user",
-            createdAt: /* @__PURE__ */ new Date(0),
-            content: {
-              format: 2,
-              parts: [
-                { type: "text", text: `<system-reminder>${OBSERVATION_CONTINUATION_HINT}</system-reminder>` }
-              ]
-            },
-            threadId,
-            resourceId
-          };
-          messageList.add(contMsg, "memory");
-        }
+        injectObservationContextMessages({
+          messageList,
+          systemMessages: ctx.systemMessage,
+          continuationMessage: this.turn.context.continuation,
+          threadId,
+          resourceId
+        });
         const freshRecord = await this.engine.getOrCreateRecord(threadId, resourceId);
         await this.engine.emitProgress({
           record: freshRecord,
@@ -10426,5 +10614,5 @@ function getObservationsAsOf(activeObservations, asOf) {
 }
 
 export { ModelByInputTokens, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, ObservationalMemoryProcessor, TokenCounter, buildObserverPrompt, buildObserverSystemPrompt, combineObservationGroupRanges, deriveObservationGroupProvenance, e, estimateTokenCount, extractCurrentTask, formatMessagesForObserver, formatToolResultForObserver, getObservationsAsOf, hasCurrentTaskSection, injectAnchorIds, optimizeObservationsForContext, parseAnchorId, parseObservationGroups, parseObserverOutput, reconcileObservationGroupsFromReflection, renderObservationGroupsForReflection, resolveToolResultValue, stripEphemeralAnchorIds, stripObservationGroups, truncateStringByTokens, wrapInObservationGroup };
-//# sourceMappingURL=chunk-S65AMBAF.js.map
-//# sourceMappingURL=chunk-S65AMBAF.js.map
+//# sourceMappingURL=chunk-MQIZJZCT.js.map
+//# sourceMappingURL=chunk-MQIZJZCT.js.map