@mastra/memory 1.10.1-alpha.3 → 1.11.0

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

@@ -11,6 +11,7 @@ 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');
@@ -966,7 +967,8 @@ var ObservationStrategy = class _ObservationStrategy {
           writer,
           abortSignal,
           reflectionHooks,
-          requestContext
+          requestContext,
+          observabilityContext: this.opts.observabilityContext
         });
       }
     } catch (error) {
@@ -1107,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.
@@ -1240,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
@@ -1289,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) {
@@ -1326,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);
@@ -1391,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) {
@@ -1430,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,
@@ -1447,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;
@@ -1661,7 +1688,8 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
           batch.threadIds,
           this.opts.abortSignal,
           this.opts.requestContext,
-          this.priorMetadataByThread
+          this.priorMetadataByThread,
+          this.opts.observabilityContext
         );
       })
     );
@@ -1745,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) {
@@ -1789,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) {
@@ -1846,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);
@@ -1914,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) {
@@ -1946,6 +1988,7 @@ 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;
@@ -2082,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,
@@ -2096,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 };
   }
@@ -2117,6 +2162,8 @@ 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) {
@@ -2124,6 +2171,7 @@ var ObservationTurn = class {
     this.threadId = opts.threadId;
     this.resourceId = opts.resourceId;
     this.messageList = opts.messageList;
+    this.observabilityContext = opts.observabilityContext;
     this.hooks = opts.hooks;
   }
   om;
@@ -3368,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({
@@ -3388,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.");
@@ -3406,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",
@@ -3418,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);
@@ -3451,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",
@@ -3472,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);
@@ -3787,6 +3922,7 @@ var ReflectorRunner = class {
   reflectionConfig;
   observationConfig;
   tokenCounter;
+  resolveModel;
   storage;
   scope;
   buffering;
@@ -3798,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;
@@ -3824,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;
@@ -3843,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}`
       );
@@ -3940,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;
@@ -3950,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)}`,
@@ -3980,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;
@@ -4027,7 +4182,8 @@ var ReflectorRunner = class {
       void 0,
       true,
       compressionStartLevel,
-      requestContext
+      requestContext,
+      observabilityContext
     );
     const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
     omDebug(
@@ -4143,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) {
@@ -4163,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) {
@@ -4190,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;
       }
     }
@@ -4238,7 +4417,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         abortSignal,
         void 0,
         compressionStartLevel,
-        requestContext
+        requestContext,
+        observabilityContext
       );
       const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
       await this.storage.createReflectionGeneration({
@@ -5526,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. */
@@ -5603,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);
@@ -5697,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,
@@ -5714,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(
@@ -5776,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) {
@@ -5808,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
       }
     };
   }
@@ -6637,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);
@@ -6651,7 +6877,8 @@ ${grouped}` : grouped;
       unobservedMessages,
       bufferKey,
       writer,
-      requestContext
+      requestContext,
+      observabilityContext
     ).finally(() => {
       BufferingCoordinator.asyncBufferingOps.delete(bufferKey);
       unregisterOp(record.id, "bufferingObservation");
@@ -6665,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 {
@@ -6737,7 +6964,8 @@ ${grouped}` : grouped;
       cycleId,
       startedAt,
       writer,
-      requestContext
+      requestContext,
+      observabilityContext
     }).run();
     const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
     const cursor = new Date(maxTs.getTime() + 1);
@@ -7284,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 };
@@ -7380,7 +7608,8 @@ ${grouped}` : grouped;
         cycleId,
         startedAt,
         writer,
-        requestContext
+        requestContext,
+        observabilityContext
       }).run();
       await this.storage.setBufferingObservationFlag(record.id, false, newTokens).catch(() => {
       });
@@ -7584,7 +7813,8 @@ ${grouped}` : grouped;
           messages: unobservedMessages,
           reflectionHooks,
           requestContext,
-          writer: opts.writer
+          writer: opts.writer,
+          observabilityContext: opts.observabilityContext
         }).run();
         observed = true;
       } finally {
@@ -7606,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 };
@@ -7623,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({
@@ -7730,6 +7962,7 @@ ${grouped}` : grouped;
       threadId: opts.threadId,
       resourceId: opts.resourceId,
       messageList: opts.messageList,
+      observabilityContext: opts.observabilityContext,
       hooks: opts.hooks
     });
   }
@@ -7980,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";
@@ -8037,6 +8281,7 @@ var ObservationalMemoryProcessor = class {
           threadId,
           resourceId,
           messageList,
+          observabilityContext: getOmObservabilityContext(args),
           hooks: {
             onBufferChunkSealed: rotateResponseMessageId
           }
@@ -8046,6 +8291,9 @@ var ObservationalMemoryProcessor = class {
         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;
@@ -8126,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;
@@ -8200,5 +8450,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.truncateStringByTokens = truncateStringByTokens;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-DTAZSLVU.cjs.map
-//# sourceMappingURL=chunk-DTAZSLVU.cjs.map
+//# sourceMappingURL=chunk-VINRPDYQ.cjs.map
+//# sourceMappingURL=chunk-VINRPDYQ.cjs.map