@mastra/memory 1.10.1-alpha.2 → 1.11.0-alpha.4

package/dist/{chunk-NS47X3OB.cjs → chunk-VINRPDYQ.cjs}

@@ -11,8 +11,10 @@ var path = require('path');
 var crypto$1 = require('crypto');
 var tokenx = require('tokenx');
 var agent = require('@mastra/core/agent');
+var observability = require('@mastra/core/observability');
 var async_hooks = require('async_hooks');
 var imageSize = require('image-size');
+var util = require('util');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -965,7 +967,8 @@ var ObservationStrategy = class _ObservationStrategy {
           writer,
           abortSignal,
           reflectionHooks,
-          requestContext
+          requestContext,
+          observabilityContext: this.opts.observabilityContext
         });
       }
     } catch (error) {
@@ -1106,6 +1109,27 @@ ${threadClose}`;
     const boundary = lastObservedAt ? _ObservationStrategy.createMessageBoundary(lastObservedAt) : "\n\n";
     return `${existingObservations}${boundary}${newThreadSection}`;
   }
+  async indexObservationGroups(observations, threadId, resourceId, observedAt) {
+    if (!resourceId || !this.deps.onIndexObservations) {
+      return;
+    }
+    const groups = parseObservationGroups(observations);
+    if (groups.length === 0) {
+      return;
+    }
+    await Promise.all(
+      groups.map(
+        (group) => this.deps.onIndexObservations({
+          text: group.content,
+          groupId: group.id,
+          range: group.range,
+          threadId,
+          resourceId,
+          observedAt
+        })
+      )
+    );
+  }
   // ── Marker persistence ──────────────────────────────────────
   /**
    * Persist a marker to the last assistant message in storage.
@@ -1239,6 +1263,7 @@ var SyncObservationStrategy = class extends ObservationStrategy {
     const omMeta = thread ? memory.getThreadOMMetadata(thread.metadata) : void 0;
     const result = await this.deps.observer.call(existingObservations, messages, this.opts.abortSignal, {
       requestContext: this.opts.requestContext,
+      observabilityContext: this.opts.observabilityContext,
       priorCurrentTask: omMeta?.currentTask,
       priorSuggestedResponse: omMeta?.suggestedResponse,
       priorThreadTitle: omMeta?.threadTitle
@@ -1288,7 +1313,7 @@ var SyncObservationStrategy = class extends ObservationStrategy {
     };
   }
   async persist(processed) {
-    const { record, threadId, messages } = this.opts;
+    const { record, threadId, resourceId, messages } = this.opts;
     const thread = await this.storage.getThreadById({ threadId });
     let threadUpdateMarker;
     if (thread) {
@@ -1325,6 +1350,7 @@ var SyncObservationStrategy = class extends ObservationStrategy {
       lastObservedAt: processed.lastObservedAt,
       observedMessageIds: processed.observedMessageIds
     });
+    await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt);
   }
   async emitEndMarkers(cycleId, processed) {
     const actualTokensObserved = await this.tokenCounter.countMessagesAsync(this.opts.messages);
@@ -1390,7 +1416,8 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
   async observe(existingObservations, messages) {
     return this.deps.observer.call(existingObservations, messages, void 0, {
       skipContinuationHints: true,
-      requestContext: this.opts.requestContext
+      requestContext: this.opts.requestContext,
+      observabilityContext: this.opts.observabilityContext
     });
   }
   async process(output, _existingObservations) {
@@ -1429,7 +1456,7 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
   }
   async persist(processed) {
     if (!processed.observations) return;
-    const { record, messages } = this.opts;
+    const { record, threadId, resourceId, messages } = this.opts;
     const messageTokens = await this.tokenCounter.countMessagesAsync(messages);
     await this.storage.updateBufferedObservations({
       id: record.id,
@@ -1446,6 +1473,7 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
       },
       lastBufferedAtTime: processed.lastObservedAt
     });
+    await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt);
   }
   async emitEndMarkers(_cycleId, processed) {
     if (!processed.observations || !this.opts.writer) return;
@@ -1660,7 +1688,8 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
           batch.threadIds,
           this.opts.abortSignal,
           this.opts.requestContext,
-          this.priorMetadataByThread
+          this.priorMetadataByThread,
+          this.opts.observabilityContext
         );
       })
     );
@@ -1744,7 +1773,7 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
     };
   }
   async persist(processed) {
-    const { record } = this.opts;
+    const { record, resourceId } = this.opts;
     const threadUpdateMarkers = [];
     if (processed.threadMetadataUpdates) {
       for (const update of processed.threadMetadataUpdates) {
@@ -1788,6 +1817,18 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
       lastObservedAt: processed.lastObservedAt,
       observedMessageIds: processed.observedMessageIds
     });
+    if (resourceId) {
+      await Promise.all(
+        this.observationResults.map(
+          ({ threadId, threadMessages, result }) => this.indexObservationGroups(
+            result.observations,
+            threadId,
+            resourceId,
+            this.getMaxMessageTimestamp(threadMessages)
+          )
+        )
+      );
+    }
   }
   async emitEndMarkers(cycleId, processed) {
     for (const obsResult of this.observationResults) {
@@ -1845,6 +1886,7 @@ ObservationStrategy.create = ((om, opts) => {
     reflector: om.reflector,
     observedMessageIds: om.observedMessageIds,
     obscureThreadIds: om.getObscureThreadIds(),
+    onIndexObservations: om.onIndexObservations,
     emitDebugEvent: (e) => om.emitDebugEvent(e)
   };
   if (opts.cycleId) return new AsyncBufferObservationStrategy(deps, opts);
@@ -1913,7 +1955,8 @@ var ObservationStep = class {
         observationTokens: obsTokens,
         threadId,
         writer: this.turn.writer,
-        requestContext: this.turn.requestContext
+        requestContext: this.turn.requestContext,
+        observabilityContext: this.turn.observabilityContext
       });
       await this.turn.refreshRecord();
       if (this.turn.record.generationCount > preReflectGeneration) {
@@ -1945,8 +1988,19 @@ var ObservationStep = class {
         record: statusSnapshot.record,
         writer: this.turn.writer,
         requestContext: this.turn.requestContext,
+        observabilityContext: this.turn.observabilityContext,
         beforeBuffer: async (candidates) => {
+          if (candidates.length === 0) {
+            return;
+          }
           om.sealMessagesForBuffering(candidates);
+          try {
+            await this.turn.hooks?.onBufferChunkSealed?.();
+          } catch (error) {
+            omDebug(
+              `[OM:buffer] onBufferChunkSealed hook failed: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
           if (this.turn.memory) {
             await this.turn.memory.persistMessages(candidates);
           }
@@ -2071,7 +2125,8 @@ var ObservationStep = class {
           threadId,
           writer: this.turn.writer,
           messageList,
-          requestContext: this.turn.requestContext
+          requestContext: this.turn.requestContext,
+          observabilityContext: this.turn.observabilityContext
         });
         return {
           succeeded: true,
@@ -2085,7 +2140,8 @@ var ObservationStep = class {
       resourceId,
       messages: messageList.get.all.db(),
       requestContext: this.turn.requestContext,
-      writer: this.turn.writer
+      writer: this.turn.writer,
+      observabilityContext: this.turn.observabilityContext
     });
     return { succeeded: obsResult.observed, record: obsResult.record };
   }
@@ -2093,12 +2149,6 @@ var ObservationStep = class {
 
 // src/processors/observational-memory/observation-turn/turn.ts
 var ObservationTurn = class {
-  constructor(om, threadId, resourceId, messageList) {
-    this.om = om;
-    this.threadId = threadId;
-    this.resourceId = resourceId;
-    this.messageList = messageList;
-  }
   _record;
   _context;
   _currentStep;
@@ -2112,6 +2162,22 @@ var ObservationTurn = class {
   writer;
   /** Optional request context for observation calls. */
   requestContext;
+  /** Optional observability context for nested OM spans. */
+  observabilityContext;
+  /** Optional processor-provided hooks for turn/step lifecycle integration. */
+  hooks;
+  constructor(opts) {
+    this.om = opts.om;
+    this.threadId = opts.threadId;
+    this.resourceId = opts.resourceId;
+    this.messageList = opts.messageList;
+    this.observabilityContext = opts.observabilityContext;
+    this.hooks = opts.hooks;
+  }
+  om;
+  threadId;
+  resourceId;
+  messageList;
   /** The current cached record. Refreshed after mutations (activate/observe/reflect). */
   get record() {
     if (!this._record) throw new Error("Turn not started \u2014 call start() first");
@@ -2174,7 +2240,7 @@ var ObservationTurn = class {
     return this._currentStep;
   }
   /**
-   * Finalize the turn: save any remaining messages, await in-flight buffering, return final state.
+   * Finalize the turn: save any remaining messages and return the latest record state.
    */
   async end() {
     if (this._ended) throw new Error("Turn already ended");
@@ -2185,22 +2251,6 @@ var ObservationTurn = class {
     if (unsavedMessages.length > 0) {
       await this.om.persistMessages(unsavedMessages, this.threadId, this.resourceId);
     }
-    await this.om.waitForBuffering(this.threadId, this.resourceId);
-    const status = await this.om.getStatus({
-      threadId: this.threadId,
-      resourceId: this.resourceId,
-      messages: this.messageList.get.all.db()
-    });
-    if (status.shouldObserve) {
-      await this.om.observe({
-        threadId: this.threadId,
-        resourceId: this.resourceId,
-        messages: this.messageList.get.all.db(),
-        requestContext: this.requestContext,
-        writer: this.writer
-      });
-    }
-    await this.refreshRecord();
     return { record: this._record };
   }
   /**
@@ -3366,13 +3416,64 @@ function optimizeObservationsForContext(observations) {
   optimized = optimized.replace(/\n{3,}/g, "\n\n");
   return optimized.trim();
 }
+var PHASE_CONFIG = {
+  observer: {
+    name: "om.observer",
+    entityName: "Observer"
+  },
+  "observer-multi-thread": {
+    name: "om.observer.multi-thread",
+    entityName: "MultiThreadObserver"
+  },
+  reflector: {
+    name: "om.reflector",
+    entityName: "Reflector"
+  }
+};
+async function withOmTracingSpan({
+  phase,
+  model,
+  inputTokens,
+  requestContext,
+  observabilityContext,
+  metadata,
+  callback
+}) {
+  const config = PHASE_CONFIG[phase];
+  const span = observability.getOrCreateSpan({
+    type: observability.SpanType.GENERIC,
+    name: config.name,
+    entityType: observability.EntityType.OUTPUT_STEP_PROCESSOR,
+    entityName: config.entityName,
+    tracingContext: observabilityContext?.tracingContext ?? observabilityContext?.tracing,
+    attributes: {
+      metadata: {
+        omPhase: phase,
+        omInputTokens: inputTokens,
+        omSelectedModel: typeof model === "string" ? model : "(dynamic-model)",
+        ...metadata
+      }
+    },
+    requestContext
+  });
+  const childObservabilityContext = observability.createObservabilityContext({ currentSpan: span });
+  if (!span) {
+    return callback(childObservabilityContext);
+  }
+  return span.executeInContext(() => callback(childObservabilityContext));
+}
+
+// src/processors/observational-memory/observer-runner.ts
 var ObserverRunner = class {
   observationConfig;
   observedMessageIds;
-  observerAgent;
+  resolveModel;
+  tokenCounter;
   constructor(opts) {
     this.observationConfig = opts.observationConfig;
     this.observedMessageIds = opts.observedMessageIds;
+    this.resolveModel = opts.resolveModel;
+    this.tokenCounter = opts.tokenCounter;
   }
   createAgent(model, isMultiThread = false) {
     return new agent.Agent({
@@ -3386,10 +3487,6 @@ var ObserverRunner = class {
       model
     });
   }
-  getAgent(model) {
-    this.observerAgent ??= this.createAgent(model);
-    return this.observerAgent;
-  }
   async withAbortCheck(fn, abortSignal) {
     if (abortSignal?.aborted) {
       throw new Error("The operation was aborted.");
@@ -3404,7 +3501,9 @@ var ObserverRunner = class {
    * Call the Observer agent for a single thread.
    */
   async call(existingObservations, messagesToObserve, abortSignal, options) {
-    const agent = options?.model ? this.createAgent(options.model) : this.getAgent(this.observationConfig.model);
+    const inputTokens = this.tokenCounter.countMessages(messagesToObserve);
+    const resolvedModel = options?.model ? { model: options.model } : this.resolveModel(inputTokens);
+    const agent = this.createAgent(resolvedModel.model);
     const observerMessages = [
       {
         role: "user",
@@ -3416,15 +3515,32 @@ var ObserverRunner = class {
       buildObserverHistoryMessage(messagesToObserve)
     ];
     const doGenerate = async () => {
-      return this.withAbortCheck(async () => {
-        const streamResult = await agent.stream(observerMessages, {
-          modelSettings: { ...this.observationConfig.modelSettings },
-          providerOptions: this.observationConfig.providerOptions,
-          ...abortSignal ? { abortSignal } : {},
-          ...options?.requestContext ? { requestContext: options.requestContext } : {}
-        });
-        return streamResult.getFullOutput();
-      }, abortSignal);
+      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)
+      });
     };
     let result = await doGenerate();
     let parsed = parseObserverOutput(result.text);
@@ -3449,8 +3565,13 @@ var ObserverRunner = class {
   /**
    * Call the Observer agent for multiple threads in a single batched request.
    */
-  async callMultiThread(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, model) {
-    const agent = this.createAgent(model ?? this.observationConfig.model, true);
+  async callMultiThread(existingObservations, messagesByThread, threadOrder, abortSignal, requestContext, priorMetadataByThread, observabilityContext, model) {
+    const inputTokens = Array.from(messagesByThread.values()).reduce(
+      (total, messages) => total + this.tokenCounter.countMessages(messages),
+      0
+    );
+    const resolvedModel = model ? { model } : this.resolveModel(inputTokens);
+    const agent = this.createAgent(resolvedModel.model, true);
     const observerMessages = [
       {
         role: "user",
@@ -3470,15 +3591,31 @@ var ObserverRunner = class {
       }
     }
     const doGenerate = async () => {
-      return this.withAbortCheck(async () => {
-        const streamResult = await agent.stream(observerMessages, {
-          modelSettings: { ...this.observationConfig.modelSettings },
-          providerOptions: this.observationConfig.providerOptions,
-          ...abortSignal ? { abortSignal } : {},
-          ...requestContext ? { requestContext } : {}
-        });
-        return streamResult.getFullOutput();
-      }, abortSignal);
+      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)
+      });
     };
     let result = await doGenerate();
     let parsed = parseMultiThreadObserverOutput(result.text);
@@ -3785,6 +3922,7 @@ var ReflectorRunner = class {
   reflectionConfig;
   observationConfig;
   tokenCounter;
+  resolveModel;
   storage;
   scope;
   buffering;
@@ -3796,6 +3934,7 @@ var ReflectorRunner = class {
     this.reflectionConfig = opts.reflectionConfig;
     this.observationConfig = opts.observationConfig;
     this.tokenCounter = opts.tokenCounter;
+    this.resolveModel = opts.resolveModel;
     this.storage = opts.storage;
     this.scope = opts.scope;
     this.buffering = opts.buffering;
@@ -3822,9 +3961,10 @@ var ReflectorRunner = class {
   /**
    * Call the Reflector agent with escalating compression levels.
    */
-  async call(observations, manualPrompt, streamContext, observationTokensThreshold, abortSignal, skipContinuationHints, compressionStartLevel, requestContext, model) {
-    const agent = this.createAgent(model ?? this.reflectionConfig.model);
+  async call(observations, manualPrompt, streamContext, observationTokensThreshold, abortSignal, skipContinuationHints, compressionStartLevel, requestContext, observabilityContext, model) {
     const originalTokens = this.tokenCounter.countObservations(observations);
+    const resolvedModel = model ? { model } : this.resolveModel(originalTokens);
+    const agent = this.createAgent(resolvedModel.model);
     const targetThreshold = observationTokensThreshold ?? getMaxThreshold(this.reflectionConfig.observationTokens);
     let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
     const startLevel = compressionStartLevel ?? 0;
@@ -3841,37 +3981,54 @@ 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 withAbortCheck(async () => {
-        const streamResult = await agent.stream(prompt, {
-          modelSettings: {
-            ...this.reflectionConfig.modelSettings
-          },
-          providerOptions: this.reflectionConfig.providerOptions,
-          ...abortSignal ? { abortSignal } : {},
-          ...requestContext ? { requestContext } : {},
-          ...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 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
             },
-            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)
+      });
       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}`
       );
@@ -3938,7 +4095,7 @@ var ReflectorRunner = class {
   /**
    * Start an async buffered reflection in the background.
    */
-  startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext) {
+  startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext, observabilityContext) {
     const bufferKey = this.buffering.getReflectionBufferKey(lockKey);
     if (this.buffering.isAsyncBufferingInProgress(bufferKey)) {
       return;
@@ -3948,7 +4105,7 @@ var ReflectorRunner = class {
     this.storage.setBufferingReflectionFlag(record.id, true).catch((err) => {
       omError("[OM] Failed to set buffering reflection flag", err);
     });
-    const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext).catch(async (error) => {
+    const asyncOp = this.doAsyncBufferedReflection(record, bufferKey, writer, requestContext, observabilityContext).catch(async (error) => {
       if (writer) {
         const failedMarker = createBufferingFailedMarker({
           cycleId: `reflect-buf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
@@ -3978,7 +4135,7 @@ var ReflectorRunner = class {
    * Perform async buffered reflection — reflects observations and stores to bufferedReflection.
    * Does NOT create a new generation or update activeObservations.
    */
-  async doAsyncBufferedReflection(record, _bufferKey, writer, requestContext) {
+  async doAsyncBufferedReflection(record, _bufferKey, writer, requestContext, observabilityContext) {
     const freshRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
     const currentRecord = freshRecord ?? record;
     const observationTokens = currentRecord.observationTokenCount ?? 0;
@@ -4025,7 +4182,8 @@ var ReflectorRunner = class {
       void 0,
       true,
       compressionStartLevel,
-      requestContext
+      requestContext,
+      observabilityContext
     );
     const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
     omDebug(
@@ -4141,7 +4299,16 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
    * @internal Used by observation strategies. Do not call directly.
    */
   async maybeReflect(opts) {
-    const { record, observationTokens, writer, abortSignal, messageList, reflectionHooks, requestContext } = opts;
+    const {
+      record,
+      observationTokens,
+      writer,
+      abortSignal,
+      messageList,
+      reflectionHooks,
+      requestContext,
+      observabilityContext
+    } = opts;
     const lockKey = this.buffering.getLockKey(record.threadId, record.resourceId);
     const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
     if (this.buffering.isAsyncReflectionEnabled() && observationTokens < reflectThreshold) {
@@ -4161,7 +4328,14 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         return observationTokens >= activationPoint;
       })();
       if (shouldTrigger) {
-        this.startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext);
+        this.startAsyncBufferedReflection(
+          record,
+          observationTokens,
+          lockKey,
+          writer,
+          requestContext,
+          observabilityContext
+        );
       }
     }
     if (observationTokens < reflectThreshold) {
@@ -4188,7 +4362,14 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         omDebug(
           `[OM:reflect] async activation failed, no blockAfter or below it (obsTokens=${observationTokens}, blockAfter=${this.reflectionConfig.blockAfter}) \u2014 starting background reflection`
         );
-        this.startAsyncBufferedReflection(record, observationTokens, lockKey, writer, requestContext);
+        this.startAsyncBufferedReflection(
+          record,
+          observationTokens,
+          lockKey,
+          writer,
+          requestContext,
+          observabilityContext
+        );
         return;
       }
     }
@@ -4236,7 +4417,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         abortSignal,
         void 0,
         compressionStartLevel,
-        requestContext
+        requestContext,
+        observabilityContext
       );
       const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
       await this.storage.createReflectionGeneration({
@@ -5524,11 +5706,12 @@ var ObservationalMemory = class _ObservationalMemory {
   storage;
   tokenCounter;
   scope;
-  /** Whether retrieval-mode observation groups are enabled (thread scope only). */
+  /** Whether retrieval-mode observation groups are enabled. */
   retrieval;
   observationConfig;
   reflectionConfig;
   onDebugEvent;
+  onIndexObservations;
   /** Observer agent runner — handles LLM calls for extracting observations. */
   observer;
   /** Reflector agent runner — handles LLM calls for compressing observations. */
@@ -5601,7 +5784,8 @@ var ObservationalMemory = class _ObservationalMemory {
     this.shouldObscureThreadIds = config.obscureThreadIds || false;
     this.storage = config.storage;
     this.scope = config.scope ?? "thread";
-    this.retrieval = this.scope === "thread" && (config.retrieval ?? false);
+    this.retrieval = Boolean(config.retrieval);
+    this.onIndexObservations = config.onIndexObservations;
     const resolveModel = (m) => m === "default" ? chunkD4J4XPGM_cjs.OBSERVATIONAL_MEMORY_DEFAULTS.observation.model : m;
     const observationModel = resolveModel(config.model) ?? resolveModel(config.observation?.model) ?? resolveModel(config.reflection?.model);
     const reflectionModel = resolveModel(config.model) ?? resolveModel(config.reflection?.model) ?? resolveModel(config.observation?.model);
@@ -5695,7 +5879,9 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     this.messageHistory = new processors.MessageHistory({ storage: this.storage });
     this.observer = new ObserverRunner({
       observationConfig: this.observationConfig,
-      observedMessageIds: this.observedMessageIds
+      observedMessageIds: this.observedMessageIds,
+      resolveModel: (inputTokens) => this.resolveObservationModel(inputTokens),
+      tokenCounter: this.tokenCounter
     });
     this.buffering = new BufferingCoordinator({
       observationConfig: this.observationConfig,
@@ -5712,7 +5898,8 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       emitDebugEvent: (e) => this.emitDebugEvent(e),
       persistMarkerToStorage: (m, t, r) => this.persistMarkerToStorage(m, t, r),
       persistMarkerToMessage: (m, ml, t, r) => this.persistMarkerToMessage(m, ml, t, r),
-      getCompressionStartLevel: (rc) => this.getCompressionStartLevel(rc)
+      getCompressionStartLevel: (rc) => this.getCompressionStartLevel(rc),
+      resolveModel: (inputTokens) => this.resolveReflectionModel(inputTokens)
     });
     this.validateBufferConfig();
     omDebug(
@@ -5774,6 +5961,54 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     }
     return model.provider ? `${model.provider}/${model.modelId}` : model.modelId;
   }
+  resolveObservationModel(inputTokens) {
+    return this.resolveTieredModel(this.observationConfig.model, inputTokens);
+  }
+  resolveReflectionModel(inputTokens) {
+    return this.resolveTieredModel(this.reflectionConfig.model, inputTokens);
+  }
+  resolveTieredModel(model, inputTokens) {
+    if (!(model instanceof ModelByInputTokens)) {
+      return {
+        model
+      };
+    }
+    const thresholds = model.getThresholds();
+    const selectedThreshold = thresholds.find((upTo) => inputTokens <= upTo) ?? thresholds.at(-1);
+    return {
+      model: model.resolve(inputTokens),
+      selectedThreshold,
+      routingStrategy: "model-by-input-tokens",
+      routingThresholds: thresholds.join(",")
+    };
+  }
+  async resolveModelRouting(modelConfig, requestContext) {
+    try {
+      if (modelConfig instanceof ModelByInputTokens) {
+        const routing = await Promise.all(
+          modelConfig.getThresholds().map(async (upTo) => {
+            const resolvedModel = modelConfig.resolve(upTo);
+            const resolved2 = await this.resolveModelContext(resolvedModel, requestContext);
+            return {
+              upTo,
+              model: resolved2?.modelId ? this.formatModelName(resolved2) : "(unknown)"
+            };
+          })
+        );
+        return {
+          model: routing[0]?.model ?? "(unknown)",
+          routing
+        };
+      }
+      const resolved = await this.resolveModelContext(modelConfig, requestContext);
+      return {
+        model: resolved?.modelId ? this.formatModelName(resolved) : "(unknown)"
+      };
+    } catch (error) {
+      omError("[OM] Failed to resolve model config", error);
+      return { model: "(unknown)" };
+    }
+  }
   async resolveModelContext(modelConfig, requestContext, inputTokens) {
     const modelToResolve = this.getModelToResolve(modelConfig, inputTokens);
     if (!modelToResolve) {
@@ -5806,29 +6041,22 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
    * This is async because it needs to resolve the model configs.
    */
   async getResolvedConfig(requestContext) {
-    const safeResolveModel = async (modelConfig) => {
-      try {
-        const resolved = await this.resolveModelContext(modelConfig, requestContext);
-        return resolved?.modelId ? this.formatModelName(resolved) : "(unknown)";
-      } catch (error) {
-        omError("[OM] Failed to resolve model config", error);
-        return "(unknown)";
-      }
-    };
-    const [observationModelName, reflectionModelName] = await Promise.all([
-      safeResolveModel(this.observationConfig.model),
-      safeResolveModel(this.reflectionConfig.model)
+    const [observationResolved, reflectionResolved] = await Promise.all([
+      this.resolveModelRouting(this.observationConfig.model, requestContext),
+      this.resolveModelRouting(this.reflectionConfig.model, requestContext)
     ]);
     return {
       scope: this.scope,
       observation: {
         messageTokens: this.observationConfig.messageTokens,
-        model: observationModelName,
-        previousObserverTokens: this.observationConfig.previousObserverTokens
+        model: observationResolved.model,
+        previousObserverTokens: this.observationConfig.previousObserverTokens,
+        routing: observationResolved.routing
       },
       reflection: {
         observationTokens: this.reflectionConfig.observationTokens,
-        model: reflectionModelName
+        model: reflectionResolved.model,
+        routing: reflectionResolved.routing
       }
     };
   }
@@ -6635,7 +6863,7 @@ ${grouped}` : grouped;
    * @param lockKey - Lock key for this scope
    * @param writer - Optional stream writer for emitting buffering markers
    */
-  async startAsyncBufferedObservation(record, threadId, unobservedMessages, lockKey, writer, contextWindowTokens, requestContext) {
+  async startAsyncBufferedObservation(record, threadId, unobservedMessages, lockKey, writer, contextWindowTokens, requestContext, observabilityContext) {
     const bufferKey = this.buffering.getObservationBufferKey(lockKey);
     const currentTokens = contextWindowTokens ?? await this.tokenCounter.countMessagesAsync(unobservedMessages) + (record.pendingMessageTokens ?? 0);
     BufferingCoordinator.lastBufferedBoundary.set(bufferKey, currentTokens);
@@ -6649,7 +6877,8 @@ ${grouped}` : grouped;
       unobservedMessages,
       bufferKey,
       writer,
-      requestContext
+      requestContext,
+      observabilityContext
     ).finally(() => {
       BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
       unregisterOp(record.id, "bufferingObservation");
@@ -6663,7 +6892,7 @@ ${grouped}` : grouped;
    * Internal method that waits for existing buffering operation and then runs new buffering.
    * This implements the mutex-wait behavior.
    */
-  async runAsyncBufferedObservation(record, threadId, unobservedMessages, bufferKey, writer, requestContext) {
+  async runAsyncBufferedObservation(record, threadId, unobservedMessages, bufferKey, writer, requestContext, observabilityContext) {
     const existingOp = BufferingCoordinator.asyncBufferingOps.get(bufferKey);
     if (existingOp) {
       try {
@@ -6735,7 +6964,8 @@ ${grouped}` : grouped;
       cycleId,
       startedAt,
       writer,
-      requestContext
+      requestContext,
+      observabilityContext
     }).run();
     const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
     const cursor = new Date(maxTs.getTime() + 1);
@@ -7282,7 +7512,7 @@ ${grouped}` : grouped;
    */
   /** @internal Used by ObservationStep. */
   async buffer(opts) {
-    const { threadId, resourceId, requestContext } = opts;
+    const { threadId, resourceId, requestContext, observabilityContext } = opts;
     let record = opts.record ?? await this.getOrCreateRecord(threadId, resourceId);
     if (!this.buffering.isAsyncObservationEnabled()) {
       return { buffered: false, record };
@@ -7378,7 +7608,8 @@ ${grouped}` : grouped;
         cycleId,
         startedAt,
         writer,
-        requestContext
+        requestContext,
+        observabilityContext
       }).run();
       await this.storage.setBufferingObservationFlag(record.id, false, newTokens).catch(() => {
       });
@@ -7582,7 +7813,8 @@ ${grouped}` : grouped;
           messages: unobservedMessages,
           reflectionHooks,
           requestContext,
-          writer: opts.writer
+          writer: opts.writer,
+          observabilityContext: opts.observabilityContext
         }).run();
         observed = true;
       } finally {
@@ -7604,7 +7836,7 @@ ${grouped}` : grouped;
    * );
    * ```
    */
-  async reflect(threadId, resourceId, prompt, requestContext) {
+  async reflect(threadId, resourceId, prompt, requestContext, observabilityContext) {
     const record = await this.getOrCreateRecord(threadId, resourceId);
     if (!record.activeObservations) {
       return { reflected: false, record };
@@ -7621,7 +7853,9 @@ ${grouped}` : grouped;
         void 0,
         void 0,
         void 0,
-        requestContext
+        requestContext,
+        observabilityContext,
+        void 0
       );
       const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
       await this.storage.createReflectionGeneration({
@@ -7723,7 +7957,14 @@ ${grouped}` : grouped;
    * ```
    */
   beginTurn(opts) {
-    return new ObservationTurn(this, opts.threadId, opts.resourceId, opts.messageList);
+    return new ObservationTurn({
+      om: this,
+      threadId: opts.threadId,
+      resourceId: opts.resourceId,
+      messageList: opts.messageList,
+      observabilityContext: opts.observabilityContext,
+      hooks: opts.hooks
+    });
   }
 };
 var OM_REPRO_CAPTURE_DIR = process.env.OM_REPRO_CAPTURE_DIR ?? ".mastra-om-repro";
@@ -7739,6 +7980,7 @@ function safeCaptureJson(value) {
     JSON.stringify(value, (_key, current) => {
       if (typeof current === "bigint") return current.toString();
       if (typeof current === "function") return "[function]";
+      if (typeof current === "symbol") return current.toString();
       if (current instanceof Error) return { name: current.name, message: current.message, stack: current.stack };
       if (current instanceof Set) return { __type: "Set", values: Array.from(current.values()) };
       if (current instanceof Map) return { __type: "Map", entries: Array.from(current.entries()) };
@@ -7746,6 +7988,87 @@ function safeCaptureJson(value) {
     })
   );
 }
+function safeCaptureJsonOrError(value) {
+  try {
+    return { ok: true, value: safeCaptureJson(value) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: safeCaptureJson({
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        inspected: util.inspect(value, { depth: 3, maxArrayLength: 20, breakLength: 120 })
+      })
+    };
+  }
+}
+function formatCaptureDate(value) {
+  if (!value) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  try {
+    return new Date(value).toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function summarizeOmTurn(value) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const turn = value;
+  return {
+    __type: "ObservationTurn",
+    threadId: turn.threadId,
+    resourceId: turn.resourceId,
+    started: turn._started,
+    ended: turn._ended,
+    generationCountAtStart: turn._generationCountAtStart,
+    record: turn._record ? {
+      id: turn._record.id,
+      scope: turn._record.scope,
+      threadId: turn._record.threadId,
+      resourceId: turn._record.resourceId,
+      createdAt: formatCaptureDate(turn._record.createdAt),
+      updatedAt: formatCaptureDate(turn._record.updatedAt),
+      lastObservedAt: formatCaptureDate(turn._record.lastObservedAt),
+      generationCount: turn._record.generationCount,
+      observationTokenCount: turn._record.observationTokenCount,
+      pendingMessageTokens: turn._record.pendingMessageTokens,
+      isBufferingObservation: turn._record.isBufferingObservation,
+      isBufferingReflection: turn._record.isBufferingReflection
+    } : void 0,
+    context: turn._context ? {
+      messageCount: Array.isArray(turn._context.messages) ? turn._context.messages.length : void 0,
+      hasSystemMessage: Array.isArray(turn._context.systemMessage) ? turn._context.systemMessage.length > 0 : Boolean(turn._context.systemMessage),
+      continuationId: turn._context.continuation?.id,
+      hasOtherThreadsContext: Boolean(turn._context.otherThreadsContext),
+      recordId: turn._context.record?.id
+    } : void 0,
+    currentStep: turn._currentStep ? {
+      stepNumber: turn._currentStep.stepNumber,
+      prepared: turn._currentStep._prepared,
+      context: turn._currentStep._context ? {
+        activated: turn._currentStep._context.activated,
+        observed: turn._currentStep._context.observed,
+        buffered: turn._currentStep._context.buffered,
+        reflected: turn._currentStep._context.reflected,
+        didThresholdCleanup: turn._currentStep._context.didThresholdCleanup,
+        messageCount: Array.isArray(turn._currentStep._context.messages) ? turn._currentStep._context.messages.length : void 0,
+        systemMessageCount: Array.isArray(turn._currentStep._context.systemMessage) ? turn._currentStep._context.systemMessage.length : void 0
+      } : void 0
+    } : void 0
+  };
+}
+function sanitizeCaptureState(rawState) {
+  return Object.fromEntries(
+    Object.entries(rawState).map(([key, value]) => {
+      if (key === "__omTurn") {
+        return [key, summarizeOmTurn(value)];
+      }
+      return [key, value];
+    })
+  );
+}
 function buildReproMessageFingerprint(message) {
   const createdAt = message.createdAt instanceof Date ? message.createdAt.toISOString() : message.createdAt ? new Date(message.createdAt).toISOString() : "";
   return JSON.stringify({
@@ -7801,60 +8124,88 @@ function writeProcessInputStepReproCapture(params) {
     const addedMessageIds = contextMessages.map((message) => message.id).filter((id) => Boolean(id) && !preMessageIds.has(id));
     const idRemap = inferReproIdRemap(params.preMessages, contextMessages);
     const rawState = params.args.state ?? {};
-    const inputPayload = safeCaptureJson({
-      stepNumber: params.stepNumber,
-      threadId: params.threadId,
-      resourceId: params.resourceId,
-      readOnly: memoryContext?.memoryConfig?.readOnly,
-      messageCount: contextMessages.length,
-      messageIds: contextMessages.map((message) => message.id),
-      stateKeys: Object.keys(rawState),
-      state: rawState,
-      args: {
-        messages: params.args.messages,
-        steps: params.args.steps,
-        systemMessages: params.args.systemMessages,
-        retryCount: params.args.retryCount,
-        tools: params.args.tools,
-        toolChoice: params.args.toolChoice,
-        activeTools: params.args.activeTools,
-        providerOptions: params.args.providerOptions,
-        modelSettings: params.args.modelSettings,
-        structuredOutput: params.args.structuredOutput
-      }
-    });
-    const preStatePayload = safeCaptureJson({
-      record: params.preRecord,
-      bufferedChunks: params.preBufferedChunks,
-      contextTokenCount: params.preContextTokenCount,
-      messages: params.preMessages,
-      messageList: params.preSerializedMessageList
-    });
-    const outputPayload = safeCaptureJson({
-      details: params.details,
-      messageDiff: {
-        removedMessageIds,
-        addedMessageIds,
-        idRemap
+    const sanitizedState = sanitizeCaptureState(rawState);
+    const payloads = [
+      {
+        fileName: "input.json",
+        data: {
+          stepNumber: params.stepNumber,
+          threadId: params.threadId,
+          resourceId: params.resourceId,
+          readOnly: memoryContext?.memoryConfig?.readOnly,
+          messageCount: contextMessages.length,
+          messageIds: contextMessages.map((message) => message.id),
+          stateKeys: Object.keys(rawState),
+          state: sanitizedState,
+          args: {
+            messages: params.args.messages,
+            steps: params.args.steps,
+            systemMessages: params.args.systemMessages,
+            retryCount: params.args.retryCount,
+            toolChoice: params.args.toolChoice,
+            activeTools: params.args.activeTools,
+            modelSettings: params.args.modelSettings,
+            structuredOutput: params.args.structuredOutput
+          }
+        }
+      },
+      {
+        fileName: "pre-state.json",
+        data: {
+          record: params.preRecord,
+          bufferedChunks: params.preBufferedChunks,
+          contextTokenCount: params.preContextTokenCount,
+          messages: params.preMessages,
+          messageList: params.preSerializedMessageList
+        }
+      },
+      {
+        fileName: "output.json",
+        data: {
+          details: params.details,
+          messageDiff: {
+            removedMessageIds,
+            addedMessageIds,
+            idRemap
+          }
+        }
+      },
+      {
+        fileName: "post-state.json",
+        data: {
+          record: params.postRecord,
+          bufferedChunks: params.postBufferedChunks,
+          contextTokenCount: params.postContextTokenCount,
+          messageCount: contextMessages.length,
+          messageIds: contextMessages.map((message) => message.id),
+          messages: contextMessages,
+          messageList: params.messageList.serialize()
+        }
       }
-    });
-    const postStatePayload = safeCaptureJson({
-      record: params.postRecord,
-      bufferedChunks: params.postBufferedChunks,
-      contextTokenCount: params.postContextTokenCount,
-      messageCount: contextMessages.length,
-      messageIds: contextMessages.map((message) => message.id),
-      messages: contextMessages,
-      messageList: params.messageList.serialize()
-    });
-    fs.writeFileSync(path.join(captureDir, "input.json"), `${JSON.stringify(inputPayload, null, 2)}
-`);
-    fs.writeFileSync(path.join(captureDir, "pre-state.json"), `${JSON.stringify(preStatePayload, null, 2)}
-`);
-    fs.writeFileSync(path.join(captureDir, "output.json"), `${JSON.stringify(outputPayload, null, 2)}
+    ];
+    const captureErrors = [];
+    for (const payload of payloads) {
+      const serialized = safeCaptureJsonOrError(payload.data);
+      if (serialized.ok) {
+        fs.writeFileSync(path.join(captureDir, payload.fileName), `${JSON.stringify(serialized.value, null, 2)}
 `);
-    fs.writeFileSync(path.join(captureDir, "post-state.json"), `${JSON.stringify(postStatePayload, null, 2)}
+        continue;
+      }
+      captureErrors.push({ fileName: payload.fileName, error: serialized.error });
+      fs.writeFileSync(
+        path.join(captureDir, payload.fileName),
+        `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
+`
+      );
+    }
+    if (captureErrors.length > 0) {
+      fs.writeFileSync(path.join(captureDir, "capture-error.json"), `${JSON.stringify(captureErrors, null, 2)}
 `);
+      params.debug?.(
+        `[OM:repro-capture] wrote processInputStep capture with ${captureErrors.length} serialization error(s) to ${captureDir}`
+      );
+      return;
+    }
     params.debug?.(`[OM:repro-capture] wrote processInputStep capture to ${captureDir}`);
   } catch (error) {
     params.debug?.(`[OM:repro-capture] failed to write processInputStep capture: ${String(error)}`);
@@ -7862,6 +8213,17 @@ function writeProcessInputStepReproCapture(params) {
 }
 
 // src/processors/observational-memory/processor.ts
+function getOmObservabilityContext(args) {
+  if (!args.tracing || !args.tracingContext || !args.loggerVNext || !args.metrics) {
+    return void 0;
+  }
+  return {
+    tracing: args.tracing,
+    tracingContext: args.tracingContext,
+    loggerVNext: args.loggerVNext,
+    metrics: args.metrics
+  };
+}
 var ObservationalMemoryProcessor = class {
   id = "observational-memory";
   name = "Observational Memory";
@@ -7877,7 +8239,17 @@ var ObservationalMemoryProcessor = class {
   }
   // ─── Processor lifecycle hooks ──────────────────────────────────────────
   async processInputStep(args) {
-    const { messageList, requestContext, stepNumber, state: _state, writer, model, abortSignal, abort } = args;
+    const {
+      messageList,
+      requestContext,
+      stepNumber,
+      state: _state,
+      writer,
+      model,
+      abortSignal,
+      abort,
+      rotateResponseMessageId
+    } = args;
     const state = _state ?? {};
     omDebug(
       `[OM:processInputStep:ENTER] step=${stepNumber}, hasMastraMemory=${!!requestContext?.get("MastraMemory")}, hasMemoryInfo=${!!messageList?.serialize()?.memoryInfo?.threadId}`
@@ -7905,12 +8277,23 @@ var ObservationalMemoryProcessor = class {
           await this.turn.end().catch(() => {
           });
         }
-        this.turn = this.engine.beginTurn({ threadId, resourceId, messageList });
+        this.turn = this.engine.beginTurn({
+          threadId,
+          resourceId,
+          messageList,
+          observabilityContext: getOmObservabilityContext(args),
+          hooks: {
+            onBufferChunkSealed: rotateResponseMessageId
+          }
+        });
         this.turn.writer = writer;
         this.turn.requestContext = requestContext;
         await this.turn.start(this.memory);
         state.__omTurn = this.turn;
       }
+      const observabilityContext = getOmObservabilityContext(args);
+      state.__omObservabilityContext = observabilityContext;
+      this.turn.observabilityContext = observabilityContext;
       {
         const step = this.turn.step(stepNumber);
         let ctx;
@@ -7991,6 +8374,8 @@ var ObservationalMemoryProcessor = class {
     const state = _state ?? {};
     const context = this.engine.getThreadContext(requestContext, messageList);
     if (!context) return messageList;
+    const observabilityContext = getOmObservabilityContext(args);
+    state.__omObservabilityContext = observabilityContext;
     return this.engine.getTokenCounter().runWithModelContext(state.__omActorModelContext, async () => {
       const memoryContext = memory.parseMemoryRequestContext(requestContext);
       if (memoryContext?.memoryConfig?.readOnly) return messageList;
@@ -8065,5 +8450,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.truncateStringByTokens = truncateStringByTokens;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-NS47X3OB.cjs.map
-//# sourceMappingURL=chunk-NS47X3OB.cjs.map
+//# sourceMappingURL=chunk-VINRPDYQ.cjs.map
+//# sourceMappingURL=chunk-VINRPDYQ.cjs.map