@mastra/memory 1.9.1-alpha.1 → 1.10.0

package/dist/{chunk-CNOHXG5O.cjs → chunk-EVBFYGDL.cjs}

@@ -6,6 +6,7 @@ var agent = require('@mastra/core/agent');
 var features = require('@mastra/core/features');
 var llm = require('@mastra/core/llm');
 var memory = require('@mastra/core/memory');
+var observability = require('@mastra/core/observability');
 var processors = require('@mastra/core/processors');
 var xxhash = require('xxhash-wasm');
 var crypto$1 = require('crypto');
@@ -319,6 +320,53 @@ function createThreadUpdateMarker(params) {
     }
   };
 }
+
+// src/processors/observational-memory/model-by-input-tokens.ts
+function isTieredModelTarget(model) {
+  if (typeof model === "string") {
+    return true;
+  }
+  if (!model || typeof model !== "object") {
+    return false;
+  }
+  return "modelId" in model || "id" in model || "providerId" in model || "provider" in model || "doGenerate" in model && "doStream" in model;
+}
+function normalizeThresholds(config) {
+  const entries = Object.entries(config.upTo);
+  if (entries.length === 0) {
+    throw new Error('ModelByInputTokens requires at least one threshold in "upTo"');
+  }
+  for (const [limitStr, model] of entries) {
+    const limit = Number(limitStr);
+    if (!Number.isFinite(limit) || limit <= 0) {
+      throw new Error(`ModelByInputTokens threshold keys must be positive numbers. Got: ${limitStr}`);
+    }
+    if (!isTieredModelTarget(model)) {
+      throw new Error(`ModelByInputTokens requires a valid model target for threshold ${limitStr}`);
+    }
+  }
+  return entries.map(([limitStr, model]) => ({ limit: Number(limitStr), model })).sort((a, b) => a.limit - b.limit);
+}
+var ModelByInputTokens = class {
+  thresholds;
+  constructor(config) {
+    this.thresholds = normalizeThresholds(config);
+  }
+  resolve(inputTokens) {
+    for (const { limit, model } of this.thresholds) {
+      if (inputTokens <= limit) {
+        return model;
+      }
+    }
+    const maxLimit = this.thresholds[this.thresholds.length - 1].limit;
+    throw new Error(
+      `ModelByInputTokens: input token count (${inputTokens}) exceeds the largest configured threshold (${maxLimit}). Please configure a higher threshold or use a larger model.`
+    );
+  }
+  getThresholds() {
+    return this.thresholds.map((t) => t.limit);
+  }
+};
 var OBSERVATION_GROUP_PATTERN = /<observation-group\s([^>]*)>([\s\S]*?)<\/observation-group>/g;
 var ATTRIBUTE_PATTERN = /([\w][\w-]*)="([^"]*)"/g;
 var REFLECTION_GROUP_SPLIT_PATTERN = /^##\s+Group\s+/m;
@@ -3473,8 +3521,10 @@ var ObservationalMemory = class _ObservationalMemory {
   onDebugEvent;
   /** Internal Observer agent - created lazily */
   observerAgent;
+  observerAgentModel;
   /** Internal Reflector agent - created lazily */
   reflectorAgent;
+  reflectorAgentModel;
   shouldObscureThreadIds = false;
   hasher = xxhash__default.default();
   threadIdCache = /* @__PURE__ */ new Map();
@@ -3781,7 +3831,15 @@ var ObservationalMemory = class _ObservationalMemory {
     this.storage = config.storage;
     this.scope = config.scope ?? "thread";
     this.retrieval = this.scope === "thread" && (config.retrieval ?? OBSERVATIONAL_MEMORY_DEFAULTS.retrieval);
-    const resolveModel = (m) => m === "default" ? OBSERVATIONAL_MEMORY_DEFAULTS.observation.model : m;
+    const resolveModel = (m) => {
+      if (m === "default") {
+        return OBSERVATIONAL_MEMORY_DEFAULTS.observation.model;
+      }
+      if (m instanceof ModelByInputTokens) {
+        return m;
+      }
+      return 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);
     if (!observationModel || !reflectionModel) {
@@ -3798,7 +3856,9 @@ See https://mastra.ai/docs/memory/observational-memory#models for model recommen
     const messageTokens = config.observation?.messageTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.messageTokens;
     const observationTokens = config.reflection?.observationTokens ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.observationTokens;
     const isSharedBudget = config.shareTokenBudget ?? false;
-    const isDefaultModelSelection = (model) => model === void 0 || model === "default";
+    const isDefaultModelSelection = (model) => {
+      return model === void 0 || model === "default";
+    };
     const observationSelectedModel = config.model ?? config.observation?.model ?? config.reflection?.model;
     const reflectionSelectedModel = config.model ?? config.reflection?.model ?? config.observation?.model;
     const observationDefaultMaxOutputTokens = config.observation?.modelSettings?.maxOutputTokens ?? (isDefaultModelSelection(observationSelectedModel) ? OBSERVATIONAL_MEMORY_DEFAULTS.observation.modelSettings.maxOutputTokens : void 0);
@@ -3901,6 +3961,15 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
   async waitForBuffering(threadId, resourceId, timeoutMs = 3e4) {
     return _ObservationalMemory.awaitBuffering(threadId, resourceId, this.scope, timeoutMs);
   }
+  getConcreteModel(model, inputTokens) {
+    if (model instanceof ModelByInputTokens) {
+      if (inputTokens === void 0) {
+        throw new Error("ModelByInputTokens requires inputTokens for resolution");
+      }
+      return model.resolve(inputTokens);
+    }
+    return model;
+  }
   getModelToResolve(model) {
     if (Array.isArray(model)) {
       return model[0]?.model ?? "unknown";
@@ -3939,7 +4008,11 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
    */
   async getCompressionStartLevel(requestContext) {
     try {
-      const resolved = await this.resolveModelContext(this.reflectionConfig.model, requestContext);
+      const modelConfig = this.getConcreteModel(
+        this.reflectionConfig.model,
+        this.reflectionConfig.model instanceof ModelByInputTokens ? 1 : void 0
+      );
+      const resolved = await this.resolveModelContext(modelConfig, requestContext);
       const modelId = resolved?.modelId ?? "";
       if (modelId.includes("gemini-2.5-flash")) {
         return 2;
@@ -3961,34 +4034,97 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
   runWithTokenCounterModelContext(modelContext, fn) {
     return this.tokenCounter.runWithModelContext(modelContext, fn);
   }
+  async formatRoutingModel(model, requestContext) {
+    if (!model) {
+      return void 0;
+    }
+    if (typeof model === "string") {
+      return model;
+    }
+    const resolvedModel = await this.resolveModelContext(model, requestContext);
+    if (resolvedModel) {
+      return this.formatModelName(resolvedModel);
+    }
+    const runtimeModel = this.getRuntimeModelContext(model);
+    return runtimeModel ? this.formatModelName(runtimeModel) : void 0;
+  }
+  async withOmTracingSpan(options) {
+    const { phase, inputTokens, resolvedModel, selectedThreshold, routingModel, requestContext, tracingContext, fn } = options;
+    const selectedModel = await this.formatRoutingModel(resolvedModel, requestContext) ?? "(unknown)";
+    if (!tracingContext) {
+      return fn();
+    }
+    const span = observability.getOrCreateSpan({
+      type: observability.SpanType.GENERIC,
+      name: `om.${phase}`,
+      attributes: {
+        omPhase: phase,
+        omInputTokens: inputTokens,
+        omSelectedModel: selectedModel,
+        ...selectedThreshold !== void 0 ? { omSelectedThreshold: selectedThreshold } : {},
+        ...routingModel ? {
+          omRoutingStrategy: "model-by-input-tokens",
+          omRoutingThresholds: routingModel.getThresholds().join(",")
+        } : {}
+      },
+      tracingContext,
+      requestContext
+    });
+    if (!span) {
+      return fn();
+    }
+    const observabilityContext = observability.createObservabilityContext({ currentSpan: span });
+    return span.executeInContext(() => fn(observabilityContext));
+  }
   /**
    * Get the full config including resolved model names.
    * This is async because it needs to resolve the model configs.
    */
   async getResolvedConfig(requestContext) {
-    const safeResolveModel = async (modelConfig) => {
+    const resolveRouting = async (modelConfig) => {
       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 resolved?.modelId ? this.formatModelName(resolved) : "(unknown)";
+        return {
+          model: resolved?.modelId ? this.formatModelName(resolved) : "(unknown)"
+        };
       } catch (error) {
         omError("[OM] Failed to resolve model config", error);
-        return "(unknown)";
+        return { model: "(unknown)" };
       }
     };
-    const [observationModelName, reflectionModelName] = await Promise.all([
-      safeResolveModel(this.observationConfig.model),
-      safeResolveModel(this.reflectionConfig.model)
+    const [observationResolved, reflectionResolved] = await Promise.all([
+      resolveRouting(this.observationConfig.model),
+      resolveRouting(this.reflectionConfig.model)
     ]);
     return {
       scope: this.scope,
+      shareTokenBudget: this.observationConfig.shareTokenBudget,
       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
       }
     };
   }
@@ -4090,8 +4226,11 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
   /**
    * Get or create the Observer agent
    */
-  getObserverAgent() {
-    if (!this.observerAgent) {
+  getObserverAgent(model) {
+    if (this.observerAgent && this.observerAgentModel === void 0) {
+      return this.observerAgent;
+    }
+    if (!this.observerAgent || this.observerAgentModel !== model) {
       const systemPrompt = buildObserverSystemPrompt(
         false,
         this.observationConfig.instruction,
@@ -4101,23 +4240,28 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
         id: "observational-memory-observer",
         name: "Observer",
         instructions: systemPrompt,
-        model: this.observationConfig.model
+        model
       });
+      this.observerAgentModel = model;
     }
     return this.observerAgent;
   }
   /**
    * Get or create the Reflector agent
    */
-  getReflectorAgent() {
-    if (!this.reflectorAgent) {
+  getReflectorAgent(model) {
+    if (this.reflectorAgent && this.reflectorAgentModel === void 0) {
+      return this.reflectorAgent;
+    }
+    if (!this.reflectorAgent || this.reflectorAgentModel !== model) {
       const systemPrompt = buildReflectorSystemPrompt(this.reflectionConfig.instruction);
       this.reflectorAgent = new agent.Agent({
         id: "observational-memory-reflector",
         name: "Reflector",
         instructions: systemPrompt,
-        model: this.reflectionConfig.model
+        model
       });
+      this.reflectorAgentModel = model;
     }
     return this.reflectorAgent;
   }
@@ -4597,7 +4741,6 @@ ${unreflectedContent}` : bufferedReflection;
    * Call the Observer agent to extract observations.
    */
   async callObserver(existingObservations, messagesToObserve, abortSignal, options) {
-    const agent = this.getObserverAgent();
     const observerMessages = [
       {
         role: "user",
@@ -4612,18 +4755,35 @@ ${unreflectedContent}` : bufferedReflection;
       },
       buildObserverHistoryMessage(messagesToObserve)
     ];
+    const inputTokens = this.tokenCounter.countMessages(messagesToObserve);
+    const requestContext = options?.requestContext;
+    const tracingContext = options?.tracingContext;
+    const routingModel = this.observationConfig.model instanceof ModelByInputTokens ? this.observationConfig.model : void 0;
+    const selectedThreshold = routingModel?.getThresholds().find((threshold) => inputTokens <= threshold);
+    const resolvedModel = this.getConcreteModel(this.observationConfig.model, inputTokens);
+    const agent = this.getObserverAgent(resolvedModel);
     const doGenerate = async () => {
-      const result2 = await 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);
+      const result2 = await this.withOmTracingSpan({
+        phase: "observer",
+        inputTokens,
+        resolvedModel,
+        selectedThreshold,
+        routingModel,
+        requestContext,
+        tracingContext,
+        fn: async (observabilityContext) => this.withAbortCheck(async () => {
+          const streamResult = await agent.stream(observerMessages, {
+            ...observabilityContext,
+            modelSettings: {
+              ...this.observationConfig.modelSettings
+            },
+            providerOptions: this.observationConfig.providerOptions,
+            ...abortSignal ? { abortSignal } : {},
+            ...requestContext ? { requestContext } : {}
+          });
+          return streamResult.getFullOutput();
+        }, abortSignal)
+      });
       return result2;
     };
     let result = await doGenerate();
@@ -4656,18 +4816,12 @@ ${unreflectedContent}` : bufferedReflection;
    * Returns per-thread results with observations, currentTask, and suggestedContinuation,
    * plus the total usage for the batch.
    */
-  async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, priorMetadataByThread, abortSignal, requestContext, wasTruncated) {
+  async callMultiThreadObserver(existingObservations, messagesByThread, threadOrder, priorMetadataByThread, abortSignal, requestContext, wasTruncated, tracingContext) {
     const systemPrompt = buildObserverSystemPrompt(
       true,
       this.observationConfig.instruction,
       this.observationConfig.threadTitle
     );
-    const agent$1 = new agent.Agent({
-      id: "multi-thread-observer",
-      name: "multi-thread-observer",
-      model: this.observationConfig.model,
-      instructions: systemPrompt
-    });
     const observerMessages = [
       {
         role: "user",
@@ -4688,18 +4842,38 @@ ${unreflectedContent}` : bufferedReflection;
     for (const msg of allMessages) {
       this.observedMessageIds.add(msg.id);
     }
+    const inputTokens = this.tokenCounter.countMessages(allMessages);
+    const routingModel = this.observationConfig.model instanceof ModelByInputTokens ? this.observationConfig.model : void 0;
+    const selectedThreshold = routingModel?.getThresholds().find((threshold) => inputTokens <= threshold);
+    const resolvedModel = this.getConcreteModel(this.observationConfig.model, inputTokens);
+    const agent$1 = new agent.Agent({
+      id: "multi-thread-observer",
+      name: "multi-thread-observer",
+      model: resolvedModel,
+      instructions: systemPrompt
+    });
     const doGenerate = async () => {
-      const result2 = await this.withAbortCheck(async () => {
-        const streamResult = await agent$1.stream(observerMessages, {
-          modelSettings: {
-            ...this.observationConfig.modelSettings
-          },
-          providerOptions: this.observationConfig.providerOptions,
-          ...abortSignal ? { abortSignal } : {},
-          ...requestContext ? { requestContext } : {}
-        });
-        return streamResult.getFullOutput();
-      }, abortSignal);
+      const result2 = await this.withOmTracingSpan({
+        phase: "observer",
+        inputTokens,
+        resolvedModel,
+        selectedThreshold,
+        routingModel,
+        requestContext,
+        tracingContext,
+        fn: async (observabilityContext) => this.withAbortCheck(async () => {
+          const streamResult = await agent$1.stream(observerMessages, {
+            ...observabilityContext,
+            modelSettings: {
+              ...this.observationConfig.modelSettings
+            },
+            providerOptions: this.observationConfig.providerOptions,
+            ...abortSignal ? { abortSignal } : {},
+            ...requestContext ? { requestContext } : {}
+          });
+          return streamResult.getFullOutput();
+        }, abortSignal)
+      });
       return result2;
     };
     let result = await doGenerate();
@@ -4741,9 +4915,12 @@ ${unreflectedContent}` : bufferedReflection;
    * Call the Reflector agent to condense observations.
    * Includes compression validation and retry logic.
    */
-  async callReflector(observations, manualPrompt, streamContext, observationTokensThreshold, abortSignal, skipContinuationHints, compressionStartLevel, requestContext) {
-    const agent = this.getReflectorAgent();
+  async callReflector(observations, manualPrompt, streamContext, observationTokensThreshold, abortSignal, skipContinuationHints, compressionStartLevel, requestContext, tracingContext) {
     const originalTokens = this.tokenCounter.countObservations(observations);
+    const routingModel = this.reflectionConfig.model instanceof ModelByInputTokens ? this.reflectionConfig.model : void 0;
+    const selectedThreshold = routingModel?.getThresholds().find((threshold) => originalTokens <= threshold);
+    const resolvedModel = this.getConcreteModel(this.reflectionConfig.model, originalTokens);
+    const agent = this.getReflectorAgent(resolvedModel);
     const targetThreshold = observationTokensThreshold ?? getMaxThreshold(this.reflectionConfig.observationTokens);
     let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
     const startLevel = compressionStartLevel ?? 0;
@@ -4760,37 +4937,47 @@ ${unreflectedContent}` : bufferedReflection;
         `[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 this.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 this.withOmTracingSpan({
+        phase: "reflector",
+        inputTokens: originalTokens,
+        resolvedModel,
+        selectedThreshold,
+        routingModel,
+        requestContext,
+        tracingContext,
+        fn: async (observabilityContext) => this.withAbortCheck(async () => {
+          const streamResult = await agent.stream(prompt, {
+            ...observabilityContext,
+            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 } : {},
+            ...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}`
       );
@@ -5095,7 +5282,7 @@ ${suggestedResponse}
    * Tries async activation first if enabled, then falls back to sync observation.
    * Returns whether observation succeeded.
    */
-  async handleThresholdReached(messageList, record, threadId, resourceId, threshold, lockKey, writer, abortSignal, abort, requestContext) {
+  async handleThresholdReached(messageList, record, threadId, resourceId, threshold, lockKey, writer, abortSignal, abort, requestContext, tracingContext) {
     let observationSucceeded = false;
     let updatedRecord = record;
     let activatedMessageIds;
@@ -5194,7 +5381,8 @@ ${suggestedResponse}
               currentThreadMessages: freshUnobservedMessages,
               writer,
               abortSignal,
-              requestContext
+              requestContext,
+              tracingContext
             });
           } else {
             await this.doSynchronousObservation({
@@ -5203,7 +5391,8 @@ ${suggestedResponse}
               unobservedMessages: freshUnobservedMessages,
               writer,
               abortSignal,
-              requestContext
+              requestContext,
+              tracingContext
             });
           }
           updatedRecord = await this.getOrCreateRecord(threadId, resourceId);
@@ -5473,7 +5662,17 @@ ${suggestedResponse}
    * 5. Filter out already-observed messages
    */
   async processInputStep(args) {
-    const { messageList, requestContext, stepNumber, state: _state, writer, abortSignal, abort, model } = args;
+    const {
+      messageList,
+      requestContext,
+      tracingContext,
+      stepNumber,
+      state: _state,
+      writer,
+      abortSignal,
+      abort,
+      model
+    } = args;
     const state = _state ?? {};
     omDebug(
       `[OM:processInputStep:ENTER] step=${stepNumber}, hasMastraMemory=${!!requestContext?.get("MastraMemory")}, hasMemoryInfo=${!!messageList?.serialize()?.memoryInfo?.threadId}`
@@ -5595,7 +5794,8 @@ ${suggestedResponse}
                 threadId,
                 writer,
                 messageList,
-                requestContext
+                requestContext,
+                tracingContext
               });
               record = await this.getOrCreateRecord(threadId, resourceId);
             }
@@ -5612,7 +5812,8 @@ ${suggestedResponse}
             threadId,
             writer,
             messageList,
-            requestContext
+            requestContext,
+            tracingContext
           });
           record = await this.getOrCreateRecord(threadId, resourceId);
         } else if (this.isAsyncReflectionEnabled()) {
@@ -5668,7 +5869,8 @@ ${suggestedResponse}
               lockKey,
               writer,
               unbufferedPendingTokens,
-              requestContext
+              requestContext,
+              tracingContext
             );
           }
         } else if (this.isAsyncObservationEnabled()) {
@@ -5684,7 +5886,8 @@ ${suggestedResponse}
               lockKey,
               writer,
               unbufferedPendingTokens,
-              requestContext
+              requestContext,
+              tracingContext
             );
           }
         }
@@ -5703,7 +5906,8 @@ ${suggestedResponse}
             writer,
             abortSignal,
             abort,
-            requestContext
+            requestContext,
+            tracingContext
           );
           if (observationSucceeded) {
             const observedIds = activatedMessageIds?.length ? activatedMessageIds : Array.isArray(updatedRecord.observedMessageIds) ? updatedRecord.observedMessageIds : void 0;
@@ -6112,7 +6316,16 @@ ${threadClose}`;
    * Do synchronous observation (fallback when no buffering)
    */
   async doSynchronousObservation(opts) {
-    const { record, threadId, unobservedMessages, writer, abortSignal, reflectionHooks, requestContext } = opts;
+    const {
+      record,
+      threadId,
+      unobservedMessages,
+      writer,
+      abortSignal,
+      reflectionHooks,
+      requestContext,
+      tracingContext
+    } = opts;
     this.emitDebugEvent({
       type: "observation_triggered",
       timestamp: /* @__PURE__ */ new Date(),
@@ -6171,6 +6384,7 @@ ${threadClose}`;
       const threadOMMetadata = memory.getThreadOMMetadata(thread?.metadata);
       const result = await this.callObserver(observerContext, messagesToObserve, abortSignal, {
         requestContext,
+        tracingContext,
         priorCurrentTask: threadOMMetadata?.currentTask,
         priorSuggestedResponse: threadOMMetadata?.suggestedResponse,
         priorThreadTitle: thread?.title,
@@ -6278,7 +6492,8 @@ ${threadClose}`;
         writer,
         abortSignal,
         reflectionHooks,
-        requestContext
+        requestContext,
+        tracingContext
       });
     } catch (error) {
       if (lastMessage?.id) {
@@ -6296,10 +6511,7 @@ ${threadClose}`;
           });
         }
       }
-      if (abortSignal?.aborted) {
-        throw error;
-      }
-      omError("[OM] Observation failed", error);
+      throw error;
     } finally {
       await this.storage.setObservingFlag(record.id, false);
       unregisterOp(record.id, "observing");
@@ -6319,7 +6531,7 @@ ${threadClose}`;
    * @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, tracingContext) {
     const bufferKey = this.getObservationBufferKey(lockKey);
     const currentTokens = contextWindowTokens ?? await this.tokenCounter.countMessagesAsync(unobservedMessages) + (record.pendingMessageTokens ?? 0);
     _ObservationalMemory.lastBufferedBoundary.set(bufferKey, currentTokens);
@@ -6333,7 +6545,8 @@ ${threadClose}`;
       unobservedMessages,
       bufferKey,
       writer,
-      requestContext
+      requestContext,
+      tracingContext
     ).finally(() => {
       _ObservationalMemory.asyncBufferingOps.delete(bufferKey);
       unregisterOp(record.id, "bufferingObservation");
@@ -6347,7 +6560,7 @@ ${threadClose}`;
    * 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, tracingContext) {
     const existingOp = _ObservationalMemory.asyncBufferingOps.get(bufferKey);
     if (existingOp) {
       try {
@@ -6427,7 +6640,8 @@ ${threadClose}`;
         cycleId,
         startedAt,
         writer,
-        requestContext
+        requestContext,
+        tracingContext
       );
       const maxTs = this.getMaxMessageTimestamp(messagesToBuffer);
       const cursor = new Date(maxTs.getTime() + 1);
@@ -6457,7 +6671,7 @@ ${threadClose}`;
    * The observer sees: active observations + existing buffered observations + message history
    * (excluding already-buffered messages).
    */
-  async doAsyncBufferedObservation(record, threadId, messagesToBuffer, cycleId, startedAt, writer, requestContext) {
+  async doAsyncBufferedObservation(record, threadId, messagesToBuffer, cycleId, startedAt, writer, requestContext, tracingContext) {
     const bufferedChunks = this.getBufferedChunks(record);
     const bufferedChunksText = bufferedChunks.map((c) => c.observations).join("\n\n");
     const combinedObservations = this.combineObservationsForBuffering(record.activeObservations, bufferedChunksText);
@@ -6472,6 +6686,7 @@ ${threadClose}`;
       {
         skipContinuationHints: true,
         requestContext,
+        tracingContext,
         priorCurrentTask: threadOMMetadata?.currentTask,
         priorSuggestedResponse: threadOMMetadata?.suggestedResponse,
         priorThreadTitle: thread?.title,
@@ -6912,7 +7127,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       writer,
       abortSignal,
       reflectionHooks,
-      requestContext
+      requestContext,
+      tracingContext
     } = opts;
     const { threads: allThreads } = await this.storage.listThreads({ filter: { resourceId } });
     const threadMetadataMap = /* @__PURE__ */ new Map();
@@ -7090,7 +7306,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           batchPriorMetadata,
           abortSignal,
           requestContext,
-          wasTruncated
+          wasTruncated,
+          tracingContext
         );
         return batchResult;
       });
@@ -7218,7 +7435,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         writer,
         abortSignal,
         reflectionHooks,
-        requestContext
+        requestContext,
+        tracingContext
       });
     } catch (error) {
       for (const [threadId, msgs] of threadsWithMessages) {
@@ -7240,10 +7458,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           }
         }
       }
-      if (abortSignal?.aborted) {
-        throw error;
-      }
-      omError("[OM] Resource-scoped observation failed", error);
+      throw error;
     } finally {
       await this.storage.setObservingFlag(record.id, false);
       unregisterOp(record.id, "observing");
@@ -7291,7 +7506,16 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
    * in the background at intervals, and activated when the threshold is reached.
    */
   async maybeReflect(opts) {
-    const { record, observationTokens, writer, abortSignal, messageList, reflectionHooks, requestContext } = opts;
+    const {
+      record,
+      observationTokens,
+      writer,
+      abortSignal,
+      messageList,
+      reflectionHooks,
+      requestContext,
+      tracingContext
+    } = opts;
     const lockKey = this.getLockKey(record.threadId, record.resourceId);
     const reflectThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
     if (this.isAsyncReflectionEnabled() && observationTokens < reflectThreshold) {
@@ -7370,7 +7594,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         abortSignal,
         void 0,
         void 0,
-        requestContext
+        requestContext,
+        tracingContext
       );
       const reflectionTokenCount = this.tokenCounter.countObservations(reflectResult.observations);
       await this.storage.createReflectionGeneration({
@@ -7416,10 +7641,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         await writer.custom(failedMarker).catch(() => {
         });
       }
-      if (abortSignal?.aborted) {
-        throw error;
-      }
-      omError("[OM] Reflection failed", error);
+      throw error;
     } finally {
       await this.storage.setReflectingFlag(record.id, false);
       reflectionHooks?.onReflectionEnd?.();
@@ -7611,6 +7833,7 @@ function getObservationsAsOf(activeObservations, asOf) {
   return chunks.join("\n\n");
 }
 
+exports.ModelByInputTokens = ModelByInputTokens;
 exports.OBSERVATIONAL_MEMORY_DEFAULTS = OBSERVATIONAL_MEMORY_DEFAULTS;
 exports.OBSERVATION_CONTEXT_INSTRUCTIONS = OBSERVATION_CONTEXT_INSTRUCTIONS;
 exports.OBSERVATION_CONTEXT_PROMPT = OBSERVATION_CONTEXT_PROMPT;
@@ -7639,5 +7862,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.truncateStringByTokens = truncateStringByTokens;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-CNOHXG5O.cjs.map
-//# sourceMappingURL=chunk-CNOHXG5O.cjs.map
+//# sourceMappingURL=chunk-EVBFYGDL.cjs.map
+//# sourceMappingURL=chunk-EVBFYGDL.cjs.map