@mastra/memory 1.6.1 → 1.6.2-alpha.0

package/dist/{chunk-GBBQIJQF.js → chunk-3CM4XQJO.js}

@@ -1,11 +1,14 @@
-import { appendFileSync } from 'fs';
+import { appendFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { Agent } from '@mastra/core/agent';
+import { coreFeatures } from '@mastra/core/features';
 import { resolveModelConfig } from '@mastra/core/llm';
 import { setThreadOMMetadata, getThreadOMMetadata, parseMemoryRequestContext } from '@mastra/core/memory';
 import { MessageHistory } from '@mastra/core/processors';
 import xxhash from 'xxhash-wasm';
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
+import imageSize from 'image-size';
 import { Tiktoken } from 'js-tiktoken/lite';
 import o200k_base from 'js-tiktoken/ranks/o200k_base';
 
@@ -662,45 +665,177 @@ User messages are extremely important. If the user asks a question or gives a ne
 ${instruction}` : ""}`;
 }
 var OBSERVER_SYSTEM_PROMPT = buildObserverSystemPrompt();
-function formatMessagesForObserver(messages, options) {
+var OBSERVER_IMAGE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "webp",
+  "gif",
+  "bmp",
+  "tiff",
+  "tif",
+  "heic",
+  "heif",
+  "avif"
+]);
+function formatObserverTimestamp(createdAt) {
+  return createdAt ? new Date(createdAt).toLocaleString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  }) : "";
+}
+function getObserverPathExtension(value) {
+  const normalized = value.split("#", 1)[0]?.split("?", 1)[0] ?? value;
+  const match = normalized.match(/\.([a-z0-9]+)$/i);
+  return match?.[1]?.toLowerCase();
+}
+function hasObserverImageFilenameExtension(filename) {
+  return typeof filename === "string" && OBSERVER_IMAGE_FILE_EXTENSIONS.has(getObserverPathExtension(filename) ?? "");
+}
+function isImageLikeObserverFilePart(part) {
+  if (part.type !== "file") {
+    return false;
+  }
+  if (typeof part.mimeType === "string" && part.mimeType.toLowerCase().startsWith("image/")) {
+    return true;
+  }
+  if (typeof part.data === "string" && part.data.startsWith("data:image/")) {
+    return true;
+  }
+  if (part.data instanceof URL && hasObserverImageFilenameExtension(part.data.pathname)) {
+    return true;
+  }
+  if (typeof part.data === "string") {
+    try {
+      const url = new URL(part.data);
+      if ((url.protocol === "http:" || url.protocol === "https:") && hasObserverImageFilenameExtension(url.pathname)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return hasObserverImageFilenameExtension(part.filename);
+}
+function toObserverInputAttachmentPart(part) {
+  if (part.type === "image") {
+    return {
+      type: "image",
+      image: part.image,
+      mimeType: part.mimeType,
+      providerOptions: part.providerOptions,
+      providerMetadata: part.providerMetadata,
+      experimental_providerMetadata: part.experimental_providerMetadata
+    };
+  }
+  if (isImageLikeObserverFilePart(part)) {
+    return {
+      type: "image",
+      image: part.data,
+      mimeType: part.mimeType,
+      providerOptions: part.providerOptions,
+      providerMetadata: part.providerMetadata,
+      experimental_providerMetadata: part.experimental_providerMetadata
+    };
+  }
+  return {
+    type: "file",
+    data: part.data,
+    mimeType: part.mimeType,
+    filename: part.filename,
+    providerOptions: part.providerOptions,
+    providerMetadata: part.providerMetadata,
+    experimental_providerMetadata: part.experimental_providerMetadata
+  };
+}
+function resolveObserverAttachmentLabel(part) {
+  if (part.filename?.trim()) {
+    return part.filename.trim();
+  }
+  const asset = part.type === "image" ? part.image : part.data;
+  if (typeof asset !== "string" || asset.startsWith("data:")) {
+    return part.mimeType;
+  }
+  try {
+    const url = new URL(asset);
+    const basename = url.pathname.split("/").filter(Boolean).pop();
+    return basename ? decodeURIComponent(basename) : part.mimeType;
+  } catch {
+    return part.mimeType;
+  }
+}
+function formatObserverAttachmentPlaceholder(part, counter) {
+  const attachmentType = part.type === "image" || isImageLikeObserverFilePart(part) ? "Image" : "File";
+  const attachmentId = attachmentType === "Image" ? counter.nextImageId++ : counter.nextFileId++;
+  const label = resolveObserverAttachmentLabel(part);
+  return label ? `[${attachmentType} #${attachmentId}: ${label}]` : `[${attachmentType} #${attachmentId}]`;
+}
+function formatObserverMessage(msg, counter, options) {
   const maxLen = options?.maxPartLength;
-  return messages.map((msg) => {
-    const timestamp = msg.createdAt ? new Date(msg.createdAt).toLocaleString("en-US", {
-      year: "numeric",
-      month: "short",
-      day: "numeric",
-      hour: "numeric",
-      minute: "2-digit",
-      hour12: true
-    }) : "";
-    const role = msg.role.charAt(0).toUpperCase() + msg.role.slice(1);
-    const timestampStr = timestamp ? ` (${timestamp})` : "";
-    let content = "";
-    if (typeof msg.content === "string") {
-      content = maybeTruncate(msg.content, maxLen);
-    } else if (msg.content?.parts && Array.isArray(msg.content.parts) && msg.content.parts.length > 0) {
-      content = msg.content.parts.map((part) => {
-        if (part.type === "text") return maybeTruncate(part.text, maxLen);
-        if (part.type === "tool-invocation") {
-          const inv = part.toolInvocation;
-          if (inv.state === "result") {
-            const resultStr = JSON.stringify(inv.result, null, 2);
-            return `[Tool Result: ${inv.toolName}]
+  const timestamp = formatObserverTimestamp(msg.createdAt);
+  const role = msg.role.charAt(0).toUpperCase() + msg.role.slice(1);
+  const timestampStr = timestamp ? ` (${timestamp})` : "";
+  const attachments = [];
+  let content = "";
+  if (typeof msg.content === "string") {
+    content = maybeTruncate(msg.content, maxLen);
+  } else if (msg.content?.parts && Array.isArray(msg.content.parts) && msg.content.parts.length > 0) {
+    content = msg.content.parts.map((part) => {
+      if (part.type === "text") return maybeTruncate(part.text, maxLen);
+      if (part.type === "tool-invocation") {
+        const inv = part.toolInvocation;
+        if (inv.state === "result") {
+          const resultStr = JSON.stringify(inv.result, null, 2);
+          return `[Tool Result: ${inv.toolName}]
 ${maybeTruncate(resultStr, maxLen)}`;
-          }
-          const argsStr = JSON.stringify(inv.args, null, 2);
-          return `[Tool Call: ${inv.toolName}]
+        }
+        const argsStr = JSON.stringify(inv.args, null, 2);
+        return `[Tool Call: ${inv.toolName}]
 ${maybeTruncate(argsStr, maxLen)}`;
+      }
+      const partType = part.type;
+      if (partType === "image" || partType === "file") {
+        const attachment = part;
+        const inputAttachment = toObserverInputAttachmentPart(attachment);
+        if (inputAttachment) {
+          attachments.push(inputAttachment);
         }
-        if (part.type?.startsWith("data-")) return "";
-        return "";
-      }).filter(Boolean).join("\n");
-    } else if (msg.content?.content) {
-      content = maybeTruncate(msg.content.content, maxLen);
+        return formatObserverAttachmentPlaceholder(attachment, counter);
+      }
+      if (partType?.startsWith("data-")) return "";
+      return "";
+    }).filter(Boolean).join("\n");
+  } else if (msg.content?.content) {
+    content = maybeTruncate(msg.content.content, maxLen);
+  }
+  return {
+    text: `**${role}${timestampStr}:**
+${content}`,
+    attachments
+  };
+}
+function formatMessagesForObserver(messages, options) {
+  const counter = { nextImageId: 1, nextFileId: 1 };
+  return messages.map((msg) => formatObserverMessage(msg, counter, options).text).join("\n\n---\n\n");
+}
+function buildObserverHistoryMessage(messages) {
+  const counter = { nextImageId: 1, nextFileId: 1 };
+  const content = [{ type: "text", text: "## New Message History to Observe\n\n" }];
+  messages.forEach((message, index) => {
+    const formatted = formatObserverMessage(message, counter);
+    content.push({ type: "text", text: formatted.text });
+    content.push(...formatted.attachments);
+    if (index < messages.length - 1) {
+      content.push({ type: "text", text: "\n\n---\n\n" });
     }
-    return `**${role}${timestampStr}:**
-${content}`;
-  }).join("\n\n---\n\n");
+  });
+  return {
+    role: "user",
+    content
+  };
 }
 function maybeTruncate(str, maxLen) {
   if (!maxLen || str.length <= maxLen) return str;
@@ -709,20 +844,42 @@ function maybeTruncate(str, maxLen) {
   return `${truncated}
 ... [truncated ${remaining} characters]`;
 }
-function formatMultiThreadMessagesForObserver(messagesByThread, threadOrder) {
-  const sections = [];
-  for (const threadId of threadOrder) {
+function buildMultiThreadObserverHistoryMessage(messagesByThread, threadOrder) {
+  const counter = { nextImageId: 1, nextFileId: 1 };
+  const content = [
+    {
+      type: "text",
+      text: `## New Message History to Observe
+
+The following messages are from ${threadOrder.length} different conversation threads. Each thread is wrapped in a <thread id="..."> tag.
+
+`
+    }
+  ];
+  threadOrder.forEach((threadId, threadIndex) => {
     const messages = messagesByThread.get(threadId);
-    if (!messages || messages.length === 0) continue;
-    const formattedMessages = formatMessagesForObserver(messages);
-    sections.push(`<thread id="${threadId}">
-${formattedMessages}
-</thread>`);
-  }
-  return sections.join("\n\n");
+    if (!messages || messages.length === 0) return;
+    content.push({ type: "text", text: `<thread id="${threadId}">
+` });
+    messages.forEach((message, messageIndex) => {
+      const formatted = formatObserverMessage(message, counter);
+      content.push({ type: "text", text: formatted.text });
+      content.push(...formatted.attachments);
+      if (messageIndex < messages.length - 1) {
+        content.push({ type: "text", text: "\n\n---\n\n" });
+      }
+    });
+    content.push({ type: "text", text: "\n</thread>" });
+    if (threadIndex < threadOrder.length - 1) {
+      content.push({ type: "text", text: "\n\n" });
+    }
+  });
+  return {
+    role: "user",
+    content
+  };
 }
-function buildMultiThreadObserverPrompt(existingObservations, messagesByThread, threadOrder) {
-  const formattedMessages = formatMultiThreadMessagesForObserver(messagesByThread, threadOrder);
+function buildMultiThreadObserverTaskPrompt(existingObservations) {
   let prompt = "";
   if (existingObservations) {
     prompt += `## Previous Observations
@@ -734,15 +891,6 @@ ${existingObservations}
 `;
     prompt += "Do not repeat these existing observations. Your new observations will be appended to the existing observations.\n\n";
   }
-  prompt += `## New Message History to Observe
-
-The following messages are from ${threadOrder.length} different conversation threads. Each thread is wrapped in a <thread id="..."> tag.
-
-${formattedMessages}
-
----
-
-`;
   prompt += `## Your Task
 
 `;
@@ -819,8 +967,7 @@ function parseMultiThreadObserverOutput(output) {
     rawOutput: output
   };
 }
-function buildObserverPrompt(existingObservations, messagesToObserve, options) {
-  const formattedMessages = formatMessagesForObserver(messagesToObserve);
+function buildObserverTaskPrompt(existingObservations, options) {
   let prompt = "";
   if (existingObservations) {
     prompt += `## Previous Observations
@@ -832,13 +979,6 @@ ${existingObservations}
 `;
     prompt += "Do not repeat these existing observations. Your new observations will be appended to the existing observations.\n\n";
   }
-  prompt += `## New Message History to Observe
-
-${formattedMessages}
-
----
-
-`;
   prompt += `## Your Task
 
 `;
@@ -850,6 +990,16 @@ IMPORTANT: Do NOT include <current-task> or <suggested-response> sections in you
   }
   return prompt;
 }
+function buildObserverPrompt(existingObservations, messagesToObserve, options) {
+  const formattedMessages = formatMessagesForObserver(messagesToObserve);
+  return `## New Message History to Observe
+
+${formattedMessages}
+
+---
+
+${buildObserverTaskPrompt(existingObservations, options)}`;
+}
 function parseObserverOutput(output) {
   if (detectDegenerateRepetition(output)) {
     return {
@@ -1221,6 +1371,140 @@ function extractReflectorListItems(content) {
 function validateCompression(reflectedTokens, targetThreshold) {
   return reflectedTokens < targetThreshold;
 }
+var OM_REPRO_CAPTURE_DIR = process.env.OM_REPRO_CAPTURE_DIR ?? ".mastra-om-repro";
+function sanitizeCapturePathSegment(value) {
+  const sanitized = value.replace(/[\\/]+/g, "_").replace(/\.{2,}/g, "_").trim();
+  return sanitized.length > 0 ? sanitized : "unknown-thread";
+}
+function isOmReproCaptureEnabled() {
+  return process.env.OM_REPRO_CAPTURE === "1";
+}
+function safeCaptureJson(value) {
+  return JSON.parse(
+    JSON.stringify(value, (_key, current) => {
+      if (typeof current === "bigint") return current.toString();
+      if (typeof current === "function") return "[function]";
+      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()) };
+      return current;
+    })
+  );
+}
+function buildReproMessageFingerprint(message) {
+  const createdAt = message.createdAt instanceof Date ? message.createdAt.toISOString() : message.createdAt ? new Date(message.createdAt).toISOString() : "";
+  return JSON.stringify({
+    role: message.role,
+    createdAt,
+    content: message.content
+  });
+}
+function inferReproIdRemap(preMessages, postMessages) {
+  const preByFingerprint = /* @__PURE__ */ new Map();
+  const postByFingerprint = /* @__PURE__ */ new Map();
+  for (const message of preMessages) {
+    if (!message.id) continue;
+    const fingerprint = buildReproMessageFingerprint(message);
+    const list = preByFingerprint.get(fingerprint) ?? [];
+    list.push(message.id);
+    preByFingerprint.set(fingerprint, list);
+  }
+  for (const message of postMessages) {
+    if (!message.id) continue;
+    const fingerprint = buildReproMessageFingerprint(message);
+    const list = postByFingerprint.get(fingerprint) ?? [];
+    list.push(message.id);
+    postByFingerprint.set(fingerprint, list);
+  }
+  const remap = [];
+  for (const [fingerprint, preIds] of preByFingerprint.entries()) {
+    const postIds = postByFingerprint.get(fingerprint);
+    if (!postIds || preIds.length !== 1 || postIds.length !== 1) continue;
+    const fromId = preIds[0];
+    const toId = postIds[0];
+    if (!fromId || !toId || fromId === toId) {
+      continue;
+    }
+    remap.push({ fromId, toId, fingerprint });
+  }
+  return remap;
+}
+function writeProcessInputStepReproCapture(params) {
+  if (!isOmReproCaptureEnabled()) {
+    return;
+  }
+  try {
+    const sanitizedThreadId = sanitizeCapturePathSegment(params.threadId);
+    const runId = `${Date.now()}-step-${params.stepNumber}-${randomUUID()}`;
+    const captureDir = join(process.cwd(), OM_REPRO_CAPTURE_DIR, sanitizedThreadId, runId);
+    mkdirSync(captureDir, { recursive: true });
+    const contextMessages = params.messageList.get.all.db();
+    const memoryContext = parseMemoryRequestContext(params.args.requestContext);
+    const preMessageIds = new Set(params.preMessages.map((message) => message.id));
+    const postMessageIds = new Set(contextMessages.map((message) => message.id));
+    const removedMessageIds = params.preMessages.map((message) => message.id).filter((id) => Boolean(id) && !postMessageIds.has(id));
+    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 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()
+    });
+    writeFileSync(join(captureDir, "input.json"), `${JSON.stringify(inputPayload, null, 2)}
+`);
+    writeFileSync(join(captureDir, "pre-state.json"), `${JSON.stringify(preStatePayload, null, 2)}
+`);
+    writeFileSync(join(captureDir, "output.json"), `${JSON.stringify(outputPayload, null, 2)}
+`);
+    writeFileSync(join(captureDir, "post-state.json"), `${JSON.stringify(postStatePayload, null, 2)}
+`);
+    params.debug?.(`[OM:repro-capture] wrote processInputStep capture to ${captureDir}`);
+  } catch (error) {
+    params.debug?.(`[OM:repro-capture] failed to write processInputStep capture: ${String(error)}`);
+  }
+}
 
 // src/processors/observational-memory/thresholds.ts
 function getMaxThreshold(threshold) {
@@ -1306,14 +1590,90 @@ function calculateProjectedMessageRemoval(chunks, bufferActivation, messageToken
   }
   return bestBoundaryMessageTokens;
 }
-var sharedDefaultEncoder;
+var GLOBAL_TIKTOKEN_KEY = "__mastraTiktoken";
 function getDefaultEncoder() {
-  if (!sharedDefaultEncoder) {
-    sharedDefaultEncoder = new Tiktoken(o200k_base);
+  const cached = globalThis[GLOBAL_TIKTOKEN_KEY];
+  if (cached) return cached;
+  const encoder = new Tiktoken(o200k_base);
+  globalThis[GLOBAL_TIKTOKEN_KEY] = encoder;
+  return encoder;
+}
+var IMAGE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "webp",
+  "gif",
+  "bmp",
+  "tiff",
+  "tif",
+  "heic",
+  "heif",
+  "avif"
+]);
+var TOKEN_ESTIMATE_CACHE_VERSION = 5;
+var DEFAULT_IMAGE_ESTIMATOR = {
+  baseTokens: 85,
+  tileTokens: 170,
+  fallbackTiles: 4
+};
+var GOOGLE_LEGACY_IMAGE_TOKENS_PER_TILE = 258;
+var GOOGLE_GEMINI_3_IMAGE_TOKENS_BY_RESOLUTION = {
+  low: 280,
+  medium: 560,
+  high: 1120,
+  ultra_high: 2240,
+  unspecified: 1120
+};
+var ANTHROPIC_IMAGE_TOKENS_PER_PIXEL = 1 / 750;
+var ANTHROPIC_IMAGE_MAX_LONG_EDGE = 1568;
+var GOOGLE_MEDIA_RESOLUTION_VALUES = /* @__PURE__ */ new Set([
+  "low",
+  "medium",
+  "high",
+  "ultra_high",
+  "unspecified"
+]);
+var ATTACHMENT_COUNT_TIMEOUT_MS = 2e4;
+var REMOTE_IMAGE_PROBE_TIMEOUT_MS = 2500;
+var PROVIDER_API_KEY_ENV_VARS = {
+  openai: ["OPENAI_API_KEY"],
+  google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
+  anthropic: ["ANTHROPIC_API_KEY"]
+};
+function getPartMastraMetadata(part) {
+  return part.providerMetadata?.mastra;
+}
+function ensurePartMastraMetadata(part) {
+  const typedPart = part;
+  typedPart.providerMetadata ??= {};
+  typedPart.providerMetadata.mastra ??= {};
+  return typedPart.providerMetadata.mastra;
+}
+function getContentMastraMetadata(content) {
+  if (!content || typeof content !== "object") {
+    return void 0;
   }
-  return sharedDefaultEncoder;
+  return content.metadata?.mastra;
+}
+function ensureContentMastraMetadata(content) {
+  if (!content || typeof content !== "object") {
+    return void 0;
+  }
+  const typedContent = content;
+  typedContent.metadata ??= {};
+  typedContent.metadata.mastra ??= {};
+  return typedContent.metadata.mastra;
+}
+function getMessageMastraMetadata(message) {
+  return message.metadata?.mastra;
+}
+function ensureMessageMastraMetadata(message) {
+  const typedMessage = message;
+  typedMessage.metadata ??= {};
+  typedMessage.metadata.mastra ??= {};
+  return typedMessage.metadata.mastra;
 }
-var TOKEN_ESTIMATE_CACHE_VERSION = 1;
 function buildEstimateKey(kind, text) {
   const payloadHash = createHash("sha1").update(text).digest("hex");
   return `${kind}:${payloadHash}`;
@@ -1336,51 +1696,60 @@ function getCacheEntry(cache, key) {
   if (isTokenEstimateEntry(cache)) {
     return cache.key === key ? cache : void 0;
   }
-  return void 0;
+  const keyedEntry = cache[key];
+  return isTokenEstimateEntry(keyedEntry) ? keyedEntry : void 0;
+}
+function mergeCacheEntry(cache, key, entry) {
+  if (isTokenEstimateEntry(cache)) {
+    if (cache.key === key) {
+      return entry;
+    }
+    return {
+      [cache.key]: cache,
+      [key]: entry
+    };
+  }
+  if (cache && typeof cache === "object") {
+    return {
+      ...cache,
+      [key]: entry
+    };
+  }
+  return entry;
 }
 function getPartCacheEntry(part, key) {
-  const cache = part?.providerMetadata?.mastra?.tokenEstimate;
-  return getCacheEntry(cache, key);
+  return getCacheEntry(getPartMastraMetadata(part)?.tokenEstimate, key);
 }
-function setPartCacheEntry(part, _key, entry) {
-  const mutablePart = part;
-  mutablePart.providerMetadata ??= {};
-  mutablePart.providerMetadata.mastra ??= {};
-  mutablePart.providerMetadata.mastra.tokenEstimate = entry;
+function setPartCacheEntry(part, key, entry) {
+  const mastraMetadata = ensurePartMastraMetadata(part);
+  mastraMetadata.tokenEstimate = mergeCacheEntry(mastraMetadata.tokenEstimate, key, entry);
 }
 function getMessageCacheEntry(message, key) {
-  const content = message.content;
-  if (content && typeof content === "object") {
-    const contentLevelCache = content.metadata?.mastra?.tokenEstimate;
-    const contentLevelEntry = getCacheEntry(contentLevelCache, key);
-    if (contentLevelEntry) return contentLevelEntry;
-  }
-  const messageLevelCache = message?.metadata?.mastra?.tokenEstimate;
-  return getCacheEntry(messageLevelCache, key);
-}
-function setMessageCacheEntry(message, _key, entry) {
-  const content = message.content;
-  if (content && typeof content === "object") {
-    content.metadata ??= {};
-    content.metadata.mastra ??= {};
-    content.metadata.mastra.tokenEstimate = entry;
+  const contentLevelEntry = getCacheEntry(getContentMastraMetadata(message.content)?.tokenEstimate, key);
+  if (contentLevelEntry) return contentLevelEntry;
+  return getCacheEntry(getMessageMastraMetadata(message)?.tokenEstimate, key);
+}
+function setMessageCacheEntry(message, key, entry) {
+  const contentMastraMetadata = ensureContentMastraMetadata(message.content);
+  if (contentMastraMetadata) {
+    contentMastraMetadata.tokenEstimate = mergeCacheEntry(contentMastraMetadata.tokenEstimate, key, entry);
     return;
   }
-  message.metadata ??= {};
-  message.metadata.mastra ??= {};
-  message.metadata.mastra.tokenEstimate = entry;
+  const messageMastraMetadata = ensureMessageMastraMetadata(message);
+  messageMastraMetadata.tokenEstimate = mergeCacheEntry(messageMastraMetadata.tokenEstimate, key, entry);
 }
 function serializePartForTokenCounting(part) {
-  const hasTokenEstimate = Boolean(part?.providerMetadata?.mastra?.tokenEstimate);
+  const typedPart = part;
+  const hasTokenEstimate = Boolean(typedPart.providerMetadata?.mastra?.tokenEstimate);
   if (!hasTokenEstimate) {
     return JSON.stringify(part);
   }
   const clonedPart = {
-    ...part,
+    ...typedPart,
     providerMetadata: {
-      ...part.providerMetadata ?? {},
+      ...typedPart.providerMetadata ?? {},
       mastra: {
-        ...part.providerMetadata?.mastra ?? {}
+        ...typedPart.providerMetadata?.mastra ?? {}
       }
     }
   };
@@ -1393,23 +1762,648 @@ function serializePartForTokenCounting(part) {
   }
   return JSON.stringify(clonedPart);
 }
+function getFilenameFromAttachmentData(data) {
+  const pathname = data instanceof URL ? data.pathname : typeof data === "string" && isHttpUrlString(data) ? (() => {
+    try {
+      return new URL(data).pathname;
+    } catch {
+      return void 0;
+    }
+  })() : void 0;
+  const filename = pathname?.split("/").filter(Boolean).pop();
+  return filename ? decodeURIComponent(filename) : void 0;
+}
+function serializeNonImageFilePartForTokenCounting(part) {
+  const filename = getObjectValue(part, "filename");
+  const inferredFilename = getFilenameFromAttachmentData(getObjectValue(part, "data"));
+  return JSON.stringify({
+    type: "file",
+    mimeType: getObjectValue(part, "mimeType") ?? null,
+    filename: typeof filename === "string" && filename.trim().length > 0 ? filename.trim() : inferredFilename ?? null
+  });
+}
 function isValidCacheEntry(entry, expectedKey, expectedSource) {
   return Boolean(
     entry && entry.v === TOKEN_ESTIMATE_CACHE_VERSION && entry.source === expectedSource && entry.key === expectedKey && Number.isFinite(entry.tokens)
   );
 }
+function parseModelContext(model) {
+  if (!model) return void 0;
+  if (typeof model === "object") {
+    return model.provider || model.modelId ? { provider: model.provider, modelId: model.modelId } : void 0;
+  }
+  const slashIndex = model.indexOf("/");
+  if (slashIndex === -1) {
+    return { modelId: model };
+  }
+  return {
+    provider: model.slice(0, slashIndex),
+    modelId: model.slice(slashIndex + 1)
+  };
+}
+function normalizeImageDetail(detail) {
+  if (detail === "low" || detail === "high") return detail;
+  return "auto";
+}
+function getObjectValue(value, key) {
+  if (!value || typeof value !== "object") return void 0;
+  return value[key];
+}
+function resolveImageDetail(part) {
+  const openAIProviderOptions = getObjectValue(getObjectValue(part, "providerOptions"), "openai");
+  const openAIProviderMetadata = getObjectValue(getObjectValue(part, "providerMetadata"), "openai");
+  const mastraMetadata = getObjectValue(getObjectValue(part, "providerMetadata"), "mastra");
+  return normalizeImageDetail(
+    getObjectValue(part, "detail") ?? getObjectValue(part, "imageDetail") ?? getObjectValue(openAIProviderOptions, "detail") ?? getObjectValue(openAIProviderOptions, "imageDetail") ?? getObjectValue(openAIProviderMetadata, "detail") ?? getObjectValue(openAIProviderMetadata, "imageDetail") ?? getObjectValue(mastraMetadata, "imageDetail")
+  );
+}
+function normalizeGoogleMediaResolution(value) {
+  return typeof value === "string" && GOOGLE_MEDIA_RESOLUTION_VALUES.has(value) ? value : void 0;
+}
+function resolveGoogleMediaResolution(part) {
+  const providerOptions = getObjectValue(getObjectValue(part, "providerOptions"), "google");
+  const providerMetadata = getObjectValue(getObjectValue(part, "providerMetadata"), "google");
+  const mastraMetadata = getObjectValue(getObjectValue(part, "providerMetadata"), "mastra");
+  return normalizeGoogleMediaResolution(getObjectValue(part, "mediaResolution")) ?? normalizeGoogleMediaResolution(getObjectValue(providerOptions, "mediaResolution")) ?? normalizeGoogleMediaResolution(getObjectValue(providerMetadata, "mediaResolution")) ?? normalizeGoogleMediaResolution(getObjectValue(mastraMetadata, "mediaResolution")) ?? "unspecified";
+}
+function getFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function isHttpUrlString(value) {
+  return typeof value === "string" && /^https?:\/\//i.test(value);
+}
+function isLikelyFilesystemPath(value) {
+  return value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || value.startsWith("~/") || /^[A-Za-z]:[\\/]/.test(value) || value.includes("\\");
+}
+function isLikelyBase64Content(value) {
+  if (value.length < 16 || value.length % 4 !== 0 || /\s/.test(value) || isLikelyFilesystemPath(value)) {
+    return false;
+  }
+  return /^[A-Za-z0-9+/]+={0,2}$/.test(value);
+}
+function decodeImageBuffer(value) {
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return Buffer.from(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value !== "string" || isHttpUrlString(value)) {
+    return void 0;
+  }
+  if (value.startsWith("data:")) {
+    const commaIndex = value.indexOf(",");
+    if (commaIndex === -1) return void 0;
+    const header = value.slice(0, commaIndex);
+    const payload = value.slice(commaIndex + 1);
+    if (/;base64/i.test(header)) {
+      return Buffer.from(payload, "base64");
+    }
+    return Buffer.from(decodeURIComponent(payload), "utf8");
+  }
+  if (!isLikelyBase64Content(value)) {
+    return void 0;
+  }
+  return Buffer.from(value, "base64");
+}
+function persistImageDimensions(part, dimensions) {
+  const mastraMetadata = ensurePartMastraMetadata(part);
+  mastraMetadata.imageDimensions = dimensions;
+}
+function resolveHttpAssetUrl(value) {
+  if (value instanceof URL) {
+    return value.toString();
+  }
+  if (typeof value === "string" && isHttpUrlString(value)) {
+    return value;
+  }
+  return void 0;
+}
+async function resolveImageDimensionsAsync(part) {
+  const existing = resolveImageDimensions(part);
+  if (existing.width && existing.height) {
+    return existing;
+  }
+  const asset = getObjectValue(part, "image") ?? getObjectValue(part, "data");
+  const url = resolveHttpAssetUrl(asset);
+  if (!url) {
+    return existing;
+  }
+  try {
+    const mod = await import('probe-image-size');
+    const probeImageSize = mod.default;
+    const probed = await probeImageSize(url, {
+      open_timeout: REMOTE_IMAGE_PROBE_TIMEOUT_MS,
+      response_timeout: REMOTE_IMAGE_PROBE_TIMEOUT_MS,
+      read_timeout: REMOTE_IMAGE_PROBE_TIMEOUT_MS,
+      follow_max: 2
+    });
+    const width = existing.width ?? getFiniteNumber(probed.width);
+    const height = existing.height ?? getFiniteNumber(probed.height);
+    if (!width || !height) {
+      return existing;
+    }
+    const resolved = { width, height };
+    persistImageDimensions(part, resolved);
+    return resolved;
+  } catch {
+    return existing;
+  }
+}
+function resolveImageDimensions(part) {
+  const mastraMetadata = getObjectValue(getObjectValue(part, "providerMetadata"), "mastra");
+  const dimensions = getObjectValue(mastraMetadata, "imageDimensions");
+  const width = getFiniteNumber(getObjectValue(part, "width")) ?? getFiniteNumber(getObjectValue(part, "imageWidth")) ?? getFiniteNumber(getObjectValue(dimensions, "width"));
+  const height = getFiniteNumber(getObjectValue(part, "height")) ?? getFiniteNumber(getObjectValue(part, "imageHeight")) ?? getFiniteNumber(getObjectValue(dimensions, "height"));
+  if (width && height) {
+    return { width, height };
+  }
+  const asset = getObjectValue(part, "image") ?? getObjectValue(part, "data");
+  const buffer = decodeImageBuffer(asset);
+  if (!buffer) {
+    return { width, height };
+  }
+  try {
+    const measured = imageSize(buffer);
+    const measuredWidth = getFiniteNumber(measured.width);
+    const measuredHeight = getFiniteNumber(measured.height);
+    if (!measuredWidth || !measuredHeight) {
+      return { width, height };
+    }
+    const resolved = {
+      width: width ?? measuredWidth,
+      height: height ?? measuredHeight
+    };
+    persistImageDimensions(part, resolved);
+    return resolved;
+  } catch {
+    return { width, height };
+  }
+}
+function getBase64Size(base64) {
+  const sanitized = base64.replace(/\s+/g, "");
+  const padding = sanitized.endsWith("==") ? 2 : sanitized.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor(sanitized.length * 3 / 4) - padding);
+}
+function resolveImageSourceStats(image) {
+  if (image instanceof URL) {
+    return { source: "url" };
+  }
+  if (typeof image === "string") {
+    if (isHttpUrlString(image)) {
+      return { source: "url" };
+    }
+    if (image.startsWith("data:")) {
+      const commaIndex = image.indexOf(",");
+      const encoded = commaIndex === -1 ? "" : image.slice(commaIndex + 1);
+      return {
+        source: "data-uri",
+        sizeBytes: getBase64Size(encoded)
+      };
+    }
+    return {
+      source: "binary",
+      sizeBytes: getBase64Size(image)
+    };
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(image)) {
+    return { source: "binary", sizeBytes: image.length };
+  }
+  if (image instanceof Uint8Array) {
+    return { source: "binary", sizeBytes: image.byteLength };
+  }
+  if (image instanceof ArrayBuffer) {
+    return { source: "binary", sizeBytes: image.byteLength };
+  }
+  if (ArrayBuffer.isView(image)) {
+    return { source: "binary", sizeBytes: image.byteLength };
+  }
+  return { source: "binary" };
+}
+function getPathnameExtension(value) {
+  const normalized = value.split("#", 1)[0]?.split("?", 1)[0] ?? value;
+  const match = normalized.match(/\.([a-z0-9]+)$/i);
+  return match?.[1]?.toLowerCase();
+}
+function hasImageFilenameExtension(filename) {
+  return typeof filename === "string" && IMAGE_FILE_EXTENSIONS.has(getPathnameExtension(filename) ?? "");
+}
+function isImageLikeFilePart(part) {
+  if (getObjectValue(part, "type") !== "file") {
+    return false;
+  }
+  const mimeType = getObjectValue(part, "mimeType");
+  if (typeof mimeType === "string" && mimeType.toLowerCase().startsWith("image/")) {
+    return true;
+  }
+  const data = getObjectValue(part, "data");
+  if (typeof data === "string" && data.startsWith("data:image/")) {
+    return true;
+  }
+  if (data instanceof URL && hasImageFilenameExtension(data.pathname)) {
+    return true;
+  }
+  if (isHttpUrlString(data)) {
+    try {
+      const url = new URL(data);
+      if (hasImageFilenameExtension(url.pathname)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return hasImageFilenameExtension(getObjectValue(part, "filename"));
+}
+function resolveProviderId(modelContext) {
+  return modelContext?.provider?.toLowerCase();
+}
+function resolveModelId(modelContext) {
+  return modelContext?.modelId?.toLowerCase() ?? "";
+}
+function resolveOpenAIImageEstimatorConfig(modelContext) {
+  const modelId = resolveModelId(modelContext);
+  if (modelId.startsWith("gpt-5") || modelId === "gpt-5-chat-latest") {
+    return { baseTokens: 70, tileTokens: 140, fallbackTiles: 4 };
+  }
+  if (modelId.startsWith("gpt-4o-mini")) {
+    return { baseTokens: 2833, tileTokens: 5667, fallbackTiles: 1 };
+  }
+  if (modelId.startsWith("o1") || modelId.startsWith("o3")) {
+    return { baseTokens: 75, tileTokens: 150, fallbackTiles: 4 };
+  }
+  if (modelId.includes("computer-use")) {
+    return { baseTokens: 65, tileTokens: 129, fallbackTiles: 4 };
+  }
+  return DEFAULT_IMAGE_ESTIMATOR;
+}
+function isGoogleGemini3Model(modelContext) {
+  return resolveProviderId(modelContext) === "google" && resolveModelId(modelContext).startsWith("gemini-3");
+}
+function scaleDimensionsForOpenAIHighDetail(width, height) {
+  let scaledWidth = width;
+  let scaledHeight = height;
+  const largestSide = Math.max(scaledWidth, scaledHeight);
+  if (largestSide > 2048) {
+    const ratio = 2048 / largestSide;
+    scaledWidth *= ratio;
+    scaledHeight *= ratio;
+  }
+  const shortestSide = Math.min(scaledWidth, scaledHeight);
+  if (shortestSide > 768) {
+    const ratio = 768 / shortestSide;
+    scaledWidth *= ratio;
+    scaledHeight *= ratio;
+  }
+  return {
+    width: Math.max(1, Math.round(scaledWidth)),
+    height: Math.max(1, Math.round(scaledHeight))
+  };
+}
+function scaleDimensionsForAnthropic(width, height) {
+  const largestSide = Math.max(width, height);
+  if (largestSide <= ANTHROPIC_IMAGE_MAX_LONG_EDGE) {
+    return { width, height };
+  }
+  const ratio = ANTHROPIC_IMAGE_MAX_LONG_EDGE / largestSide;
+  return {
+    width: Math.max(1, Math.round(width * ratio)),
+    height: Math.max(1, Math.round(height * ratio))
+  };
+}
+function estimateOpenAIHighDetailTiles(dimensions, sourceStats, estimator) {
+  if (dimensions.width && dimensions.height) {
+    const scaled = scaleDimensionsForOpenAIHighDetail(dimensions.width, dimensions.height);
+    return Math.max(1, Math.ceil(scaled.width / 512) * Math.ceil(scaled.height / 512));
+  }
+  if (sourceStats.sizeBytes !== void 0) {
+    if (sourceStats.sizeBytes <= 512 * 1024) return 1;
+    if (sourceStats.sizeBytes <= 2 * 1024 * 1024) return 4;
+    if (sourceStats.sizeBytes <= 4 * 1024 * 1024) return 6;
+    return 8;
+  }
+  return estimator.fallbackTiles;
+}
+function resolveEffectiveOpenAIImageDetail(detail, dimensions, sourceStats) {
+  if (detail === "low" || detail === "high") return detail;
+  if (dimensions.width && dimensions.height) {
+    return Math.max(dimensions.width, dimensions.height) > 768 ? "high" : "low";
+  }
+  if (sourceStats.sizeBytes !== void 0) {
+    return sourceStats.sizeBytes > 1024 * 1024 ? "high" : "low";
+  }
+  return "low";
+}
+function estimateLegacyGoogleImageTiles(dimensions) {
+  if (!dimensions.width || !dimensions.height) return 1;
+  return Math.max(1, Math.ceil(dimensions.width / 768) * Math.ceil(dimensions.height / 768));
+}
+function estimateAnthropicImageTokens(dimensions, sourceStats) {
+  if (dimensions.width && dimensions.height) {
+    const scaled = scaleDimensionsForAnthropic(dimensions.width, dimensions.height);
+    return Math.max(1, Math.ceil(scaled.width * scaled.height * ANTHROPIC_IMAGE_TOKENS_PER_PIXEL));
+  }
+  if (sourceStats.sizeBytes !== void 0) {
+    if (sourceStats.sizeBytes <= 512 * 1024) return 341;
+    if (sourceStats.sizeBytes <= 2 * 1024 * 1024) return 1366;
+    if (sourceStats.sizeBytes <= 4 * 1024 * 1024) return 2048;
+    return 2731;
+  }
+  return 1600;
+}
+function estimateGoogleImageTokens(modelContext, part, dimensions) {
+  if (isGoogleGemini3Model(modelContext)) {
+    const mediaResolution = resolveGoogleMediaResolution(part);
+    return {
+      tokens: GOOGLE_GEMINI_3_IMAGE_TOKENS_BY_RESOLUTION[mediaResolution],
+      mediaResolution
+    };
+  }
+  return {
+    tokens: estimateLegacyGoogleImageTiles(dimensions) * GOOGLE_LEGACY_IMAGE_TOKENS_PER_TILE,
+    mediaResolution: "unspecified"
+  };
+}
+function getProviderApiKey(provider) {
+  for (const envVar of PROVIDER_API_KEY_ENV_VARS[provider] ?? []) {
+    const value = process.env[envVar];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function getAttachmentFilename(part) {
+  const explicitFilename = getObjectValue(part, "filename");
+  if (typeof explicitFilename === "string" && explicitFilename.trim().length > 0) {
+    return explicitFilename.trim();
+  }
+  return getFilenameFromAttachmentData(getObjectValue(part, "data") ?? getObjectValue(part, "image"));
+}
+function getAttachmentMimeType(part, fallback) {
+  const mimeType = getObjectValue(part, "mimeType");
+  if (typeof mimeType === "string" && mimeType.trim().length > 0) {
+    return mimeType.trim();
+  }
+  const asset = getObjectValue(part, "data") ?? getObjectValue(part, "image");
+  if (typeof asset === "string" && asset.startsWith("data:")) {
+    const semicolonIndex = asset.indexOf(";");
+    const commaIndex = asset.indexOf(",");
+    const endIndex = semicolonIndex === -1 ? commaIndex : Math.min(semicolonIndex, commaIndex);
+    if (endIndex > 5) {
+      return asset.slice(5, endIndex);
+    }
+  }
+  return fallback;
+}
+function getAttachmentUrl(asset) {
+  if (asset instanceof URL) {
+    return asset.toString();
+  }
+  if (typeof asset === "string" && /^(https?:\/\/|data:)/i.test(asset)) {
+    return asset;
+  }
+  return void 0;
+}
+function getAttachmentFingerprint(asset) {
+  const url = getAttachmentUrl(asset);
+  if (url) {
+    return { url };
+  }
+  const base64 = encodeAttachmentBase64(asset);
+  if (base64) {
+    return { contentHash: createHash("sha1").update(base64).digest("hex") };
+  }
+  return {};
+}
+function encodeAttachmentBase64(asset) {
+  if (typeof asset === "string") {
+    if (asset.startsWith("data:")) {
+      const commaIndex = asset.indexOf(",");
+      return commaIndex === -1 ? void 0 : asset.slice(commaIndex + 1);
+    }
+    if (/^https?:\/\//i.test(asset)) {
+      return void 0;
+    }
+    return asset;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(asset)) {
+    return asset.toString("base64");
+  }
+  if (asset instanceof Uint8Array) {
+    return Buffer.from(asset).toString("base64");
+  }
+  if (asset instanceof ArrayBuffer) {
+    return Buffer.from(asset).toString("base64");
+  }
+  if (ArrayBuffer.isView(asset)) {
+    return Buffer.from(asset.buffer, asset.byteOffset, asset.byteLength).toString("base64");
+  }
+  return void 0;
+}
+function createTimeoutSignal(timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(new Error(`Attachment token counting timed out after ${timeoutMs}ms`)),
+    timeoutMs
+  );
+  const cleanup = () => clearTimeout(timeout);
+  controller.signal.addEventListener("abort", cleanup, { once: true });
+  return { signal: controller.signal, cleanup };
+}
+function getNumericResponseField(value, paths) {
+  for (const path of paths) {
+    let current = value;
+    for (const segment of path) {
+      current = getObjectValue(current, segment);
+      if (current === void 0) break;
+    }
+    if (typeof current === "number" && Number.isFinite(current)) {
+      return current;
+    }
+  }
+  return void 0;
+}
+function toOpenAIInputPart(part) {
+  if (getObjectValue(part, "type") === "image" || isImageLikeFilePart(part)) {
+    const asset = getObjectValue(part, "image") ?? getObjectValue(part, "data");
+    const imageUrl = getAttachmentUrl(asset);
+    if (imageUrl) {
+      return { type: "input_image", image_url: imageUrl, detail: resolveImageDetail(part) };
+    }
+    const base64 = encodeAttachmentBase64(asset);
+    if (!base64) return void 0;
+    return {
+      type: "input_image",
+      image_url: `data:${getAttachmentMimeType(part, "image/png")};base64,${base64}`,
+      detail: resolveImageDetail(part)
+    };
+  }
+  if (getObjectValue(part, "type") === "file") {
+    const asset = getObjectValue(part, "data");
+    const fileUrl = getAttachmentUrl(asset);
+    return fileUrl ? {
+      type: "input_file",
+      file_url: fileUrl,
+      filename: getAttachmentFilename(part) ?? "attachment"
+    } : (() => {
+      const base64 = encodeAttachmentBase64(asset);
+      if (!base64) return void 0;
+      return {
+        type: "input_file",
+        file_data: `data:${getAttachmentMimeType(part, "application/octet-stream")};base64,${base64}`,
+        filename: getAttachmentFilename(part) ?? "attachment"
+      };
+    })();
+  }
+  return void 0;
+}
+function toAnthropicContentPart(part) {
+  const asset = getObjectValue(part, "image") ?? getObjectValue(part, "data");
+  const url = getAttachmentUrl(asset);
+  if (getObjectValue(part, "type") === "image" || isImageLikeFilePart(part)) {
+    return url && /^https?:\/\//i.test(url) ? { type: "image", source: { type: "url", url } } : (() => {
+      const base64 = encodeAttachmentBase64(asset);
+      if (!base64) return void 0;
+      return {
+        type: "image",
+        source: { type: "base64", media_type: getAttachmentMimeType(part, "image/png"), data: base64 }
+      };
+    })();
+  }
+  if (getObjectValue(part, "type") === "file") {
+    return url && /^https?:\/\//i.test(url) ? { type: "document", source: { type: "url", url } } : (() => {
+      const base64 = encodeAttachmentBase64(asset);
+      if (!base64) return void 0;
+      return {
+        type: "document",
+        source: { type: "base64", media_type: getAttachmentMimeType(part, "application/pdf"), data: base64 }
+      };
+    })();
+  }
+  return void 0;
+}
+function toGooglePart(part) {
+  const asset = getObjectValue(part, "image") ?? getObjectValue(part, "data");
+  const url = getAttachmentUrl(asset);
+  const mimeType = getAttachmentMimeType(
+    part,
+    getObjectValue(part, "type") === "file" && !isImageLikeFilePart(part) ? "application/pdf" : "image/png"
+  );
+  if (url && !url.startsWith("data:")) {
+    return { fileData: { mimeType, fileUri: url } };
+  }
+  const base64 = encodeAttachmentBase64(asset);
+  if (!base64) return void 0;
+  return { inlineData: { mimeType, data: base64 } };
+}
+async function fetchOpenAIAttachmentTokenEstimate(modelId, part) {
+  const apiKey = getProviderApiKey("openai");
+  const inputPart = toOpenAIInputPart(part);
+  if (!apiKey || !inputPart) return void 0;
+  const { signal, cleanup } = createTimeoutSignal(ATTACHMENT_COUNT_TIMEOUT_MS);
+  try {
+    const response = await fetch("https://api.openai.com/v1/responses/input_tokens", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: modelId,
+        input: [{ type: "message", role: "user", content: [inputPart] }]
+      }),
+      signal
+    });
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    return getNumericResponseField(body, [
+      ["input_tokens"],
+      ["total_tokens"],
+      ["usage", "input_tokens"],
+      ["usage", "total_tokens"]
+    ]);
+  } finally {
+    cleanup();
+  }
+}
+async function fetchAnthropicAttachmentTokenEstimate(modelId, part) {
+  const apiKey = getProviderApiKey("anthropic");
+  const contentPart = toAnthropicContentPart(part);
+  if (!apiKey || !contentPart) return void 0;
+  const { signal, cleanup } = createTimeoutSignal(ATTACHMENT_COUNT_TIMEOUT_MS);
+  try {
+    const response = await fetch("https://api.anthropic.com/v1/messages/count_tokens", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: modelId,
+        messages: [{ role: "user", content: [contentPart] }]
+      }),
+      signal
+    });
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    return getNumericResponseField(body, [["input_tokens"]]);
+  } finally {
+    cleanup();
+  }
+}
+async function fetchGoogleAttachmentTokenEstimate(modelId, part) {
+  const apiKey = getProviderApiKey("google");
+  const googlePart = toGooglePart(part);
+  if (!apiKey || !googlePart) return void 0;
+  const { signal, cleanup } = createTimeoutSignal(ATTACHMENT_COUNT_TIMEOUT_MS);
+  try {
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${modelId}:countTokens`, {
+      method: "POST",
+      headers: {
+        "x-goog-api-key": apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [googlePart] }]
+      }),
+      signal
+    });
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    return getNumericResponseField(body, [["totalTokens"], ["total_tokens"]]);
+  } finally {
+    cleanup();
+  }
+}
 var TokenCounter = class _TokenCounter {
   encoder;
   cacheSource;
+  defaultModelContext;
+  modelContextStorage = new AsyncLocalStorage();
+  inFlightAttachmentCounts = /* @__PURE__ */ new Map();
   // Per-message overhead: accounts for role tokens, message framing, and separators.
   // Empirically derived from OpenAI's token counting guide (3 tokens per message base +
   // fractional overhead from name/role encoding). 3.8 is a practical average across models.
   static TOKENS_PER_MESSAGE = 3.8;
   // Conversation-level overhead: system prompt framing, reply priming tokens, etc.
   static TOKENS_PER_CONVERSATION = 24;
-  constructor(encoding) {
+  constructor(encoding, options) {
     this.encoder = encoding ? new Tiktoken(encoding) : getDefaultEncoder();
     this.cacheSource = `v${TOKEN_ESTIMATE_CACHE_VERSION}:${resolveEncodingId(encoding)}`;
+    this.defaultModelContext = parseModelContext(options?.model);
+  }
+  runWithModelContext(model, fn) {
+    return this.modelContextStorage.run(parseModelContext(model), fn);
+  }
+  getModelContext() {
+    return this.modelContextStorage.getStore() ?? this.defaultModelContext;
   }
   /**
    * Count tokens in a plain string
@@ -1433,6 +2427,20 @@ var TokenCounter = class _TokenCounter {
     });
     return tokens;
   }
+  readOrPersistFixedPartEstimate(part, kind, payload, tokens) {
+    const key = buildEstimateKey(kind, payload);
+    const cached = getPartCacheEntry(part, key);
+    if (isValidCacheEntry(cached, key, this.cacheSource)) {
+      return cached.tokens;
+    }
+    setPartCacheEntry(part, key, {
+      v: TOKEN_ESTIMATE_CACHE_VERSION,
+      source: this.cacheSource,
+      key,
+      tokens
+    });
+    return tokens;
+  }
   readOrPersistMessageEstimate(message, kind, payload) {
     const key = buildEstimateKey(kind, payload);
     const cached = getMessageCacheEntry(message, key);
@@ -1456,15 +2464,315 @@ var TokenCounter = class _TokenCounter {
         usingStoredModelOutput: true
       };
     }
-    return {
-      value: invocationResult,
-      usingStoredModelOutput: false
-    };
+    return {
+      value: invocationResult,
+      usingStoredModelOutput: false
+    };
+  }
+  estimateImageAssetTokens(part, asset, kind) {
+    const modelContext = this.getModelContext();
+    const provider = resolveProviderId(modelContext);
+    const modelId = modelContext?.modelId ?? null;
+    const detail = resolveImageDetail(part);
+    const dimensions = resolveImageDimensions(part);
+    const sourceStats = resolveImageSourceStats(asset);
+    if (provider === "google") {
+      const googleEstimate = estimateGoogleImageTokens(modelContext, part, dimensions);
+      return {
+        tokens: googleEstimate.tokens,
+        cachePayload: JSON.stringify({
+          kind,
+          provider,
+          modelId,
+          estimator: isGoogleGemini3Model(modelContext) ? "google-gemini-3" : "google-legacy",
+          mediaResolution: googleEstimate.mediaResolution,
+          width: dimensions.width ?? null,
+          height: dimensions.height ?? null,
+          source: sourceStats.source,
+          sizeBytes: sourceStats.sizeBytes ?? null,
+          mimeType: getObjectValue(part, "mimeType") ?? null,
+          filename: getObjectValue(part, "filename") ?? null
+        })
+      };
+    }
+    if (provider === "anthropic") {
+      return {
+        tokens: estimateAnthropicImageTokens(dimensions, sourceStats),
+        cachePayload: JSON.stringify({
+          kind,
+          provider,
+          modelId,
+          estimator: "anthropic",
+          width: dimensions.width ?? null,
+          height: dimensions.height ?? null,
+          source: sourceStats.source,
+          sizeBytes: sourceStats.sizeBytes ?? null,
+          mimeType: getObjectValue(part, "mimeType") ?? null,
+          filename: getObjectValue(part, "filename") ?? null
+        })
+      };
+    }
+    const estimator = resolveOpenAIImageEstimatorConfig(modelContext);
+    const effectiveDetail = resolveEffectiveOpenAIImageDetail(detail, dimensions, sourceStats);
+    const tiles = effectiveDetail === "high" ? estimateOpenAIHighDetailTiles(dimensions, sourceStats, estimator) : 0;
+    const tokens = estimator.baseTokens + tiles * estimator.tileTokens;
+    return {
+      tokens,
+      cachePayload: JSON.stringify({
+        kind,
+        provider,
+        modelId,
+        estimator: provider === "openai" ? "openai" : "fallback",
+        detail,
+        effectiveDetail,
+        width: dimensions.width ?? null,
+        height: dimensions.height ?? null,
+        source: sourceStats.source,
+        sizeBytes: sourceStats.sizeBytes ?? null,
+        mimeType: getObjectValue(part, "mimeType") ?? null,
+        filename: getObjectValue(part, "filename") ?? null
+      })
+    };
+  }
+  estimateImageTokens(part) {
+    return this.estimateImageAssetTokens(part, part.image, "image");
+  }
+  estimateImageLikeFileTokens(part) {
+    return this.estimateImageAssetTokens(part, part.data, "file");
+  }
+  countAttachmentPartSync(part) {
+    if (part.type === "image") {
+      const estimate = this.estimateImageTokens(part);
+      return this.readOrPersistFixedPartEstimate(part, "image", estimate.cachePayload, estimate.tokens);
+    }
+    if (part.type === "file" && isImageLikeFilePart(part)) {
+      const estimate = this.estimateImageLikeFileTokens(part);
+      return this.readOrPersistFixedPartEstimate(part, "image-like-file", estimate.cachePayload, estimate.tokens);
+    }
+    if (part.type === "file") {
+      return this.readOrPersistPartEstimate(part, "file-descriptor", serializeNonImageFilePartForTokenCounting(part));
+    }
+    return void 0;
+  }
+  buildRemoteAttachmentCachePayload(part) {
+    const isImageAttachment = part.type === "image" || part.type === "file" && isImageLikeFilePart(part);
+    const isNonImageFileAttachment = part.type === "file" && !isImageAttachment;
+    if (!isImageAttachment && !isNonImageFileAttachment) {
+      return void 0;
+    }
+    const modelContext = this.getModelContext();
+    const provider = resolveProviderId(modelContext);
+    const modelId = modelContext?.modelId ?? null;
+    if (!provider || !modelId || !["openai", "google", "anthropic"].includes(provider)) {
+      return void 0;
+    }
+    const asset = getObjectValue(part, "image") ?? getObjectValue(part, "data");
+    const sourceStats = resolveImageSourceStats(asset);
+    const fingerprint = getAttachmentFingerprint(asset);
+    return JSON.stringify({
+      strategy: "provider-endpoint",
+      provider,
+      modelId,
+      type: getObjectValue(part, "type") ?? null,
+      detail: isImageAttachment ? resolveImageDetail(part) : null,
+      mediaResolution: provider === "google" && isImageAttachment ? resolveGoogleMediaResolution(part) : null,
+      mimeType: getAttachmentMimeType(part, isNonImageFileAttachment ? "application/pdf" : "image/png"),
+      filename: getAttachmentFilename(part) ?? null,
+      source: sourceStats.source,
+      sizeBytes: sourceStats.sizeBytes ?? null,
+      assetUrl: fingerprint.url ?? null,
+      assetHash: fingerprint.contentHash ?? null
+    });
+  }
+  async fetchProviderAttachmentTokenEstimate(part) {
+    const modelContext = this.getModelContext();
+    const provider = resolveProviderId(modelContext);
+    const modelId = modelContext?.modelId;
+    if (!provider || !modelId) return void 0;
+    try {
+      if (provider === "openai") {
+        return await fetchOpenAIAttachmentTokenEstimate(modelId, part);
+      }
+      if (provider === "google") {
+        return await fetchGoogleAttachmentTokenEstimate(modelId, part);
+      }
+      if (provider === "anthropic") {
+        return await fetchAnthropicAttachmentTokenEstimate(modelId, part);
+      }
+    } catch {
+      return void 0;
+    }
+    return void 0;
+  }
+  async countAttachmentPartAsync(part) {
+    const isImageAttachment = part.type === "image" || part.type === "file" && isImageLikeFilePart(part);
+    const remotePayload = this.buildRemoteAttachmentCachePayload(part);
+    if (remotePayload) {
+      const remoteKey = buildEstimateKey("attachment-provider", remotePayload);
+      const cachedRemote = getPartCacheEntry(part, remoteKey);
+      if (isValidCacheEntry(cachedRemote, remoteKey, this.cacheSource)) {
+        return cachedRemote.tokens;
+      }
+      const existingRequest = this.inFlightAttachmentCounts.get(remoteKey);
+      if (existingRequest) {
+        const remoteTokens = await existingRequest;
+        if (typeof remoteTokens === "number" && Number.isFinite(remoteTokens) && remoteTokens > 0) {
+          setPartCacheEntry(part, remoteKey, {
+            v: TOKEN_ESTIMATE_CACHE_VERSION,
+            source: this.cacheSource,
+            key: remoteKey,
+            tokens: remoteTokens
+          });
+          return remoteTokens;
+        }
+      } else {
+        const remoteRequest = this.fetchProviderAttachmentTokenEstimate(part);
+        this.inFlightAttachmentCounts.set(remoteKey, remoteRequest);
+        let remoteTokens;
+        try {
+          remoteTokens = await remoteRequest;
+        } finally {
+          this.inFlightAttachmentCounts.delete(remoteKey);
+        }
+        if (typeof remoteTokens === "number" && Number.isFinite(remoteTokens) && remoteTokens > 0) {
+          setPartCacheEntry(part, remoteKey, {
+            v: TOKEN_ESTIMATE_CACHE_VERSION,
+            source: this.cacheSource,
+            key: remoteKey,
+            tokens: remoteTokens
+          });
+          return remoteTokens;
+        }
+      }
+      if (isImageAttachment) {
+        await resolveImageDimensionsAsync(part);
+      }
+      const fallbackPayload = JSON.stringify({
+        ...JSON.parse(remotePayload),
+        strategy: "local-fallback",
+        ...isImageAttachment ? resolveImageDimensions(part) : {}
+      });
+      const fallbackKey = buildEstimateKey("attachment-provider", fallbackPayload);
+      const cachedFallback = getPartCacheEntry(part, fallbackKey);
+      if (isValidCacheEntry(cachedFallback, fallbackKey, this.cacheSource)) {
+        return cachedFallback.tokens;
+      }
+      const localTokens2 = this.countAttachmentPartSync(part);
+      if (localTokens2 === void 0) {
+        return void 0;
+      }
+      setPartCacheEntry(part, fallbackKey, {
+        v: TOKEN_ESTIMATE_CACHE_VERSION,
+        source: this.cacheSource,
+        key: fallbackKey,
+        tokens: localTokens2
+      });
+      return localTokens2;
+    }
+    if (isImageAttachment) {
+      await resolveImageDimensionsAsync(part);
+    }
+    const localTokens = this.countAttachmentPartSync(part);
+    return localTokens;
+  }
+  countNonAttachmentPart(part) {
+    let overheadDelta = 0;
+    let toolResultDelta = 0;
+    if (part.type === "text") {
+      return { tokens: this.readOrPersistPartEstimate(part, "text", part.text), overheadDelta, toolResultDelta };
+    }
+    if (part.type === "tool-invocation") {
+      const invocation = part.toolInvocation;
+      let tokens = 0;
+      if (invocation.state === "call" || invocation.state === "partial-call") {
+        if (invocation.toolName) {
+          tokens += this.readOrPersistPartEstimate(part, `tool-${invocation.state}-name`, invocation.toolName);
+        }
+        if (invocation.args) {
+          if (typeof invocation.args === "string") {
+            tokens += this.readOrPersistPartEstimate(part, `tool-${invocation.state}-args`, invocation.args);
+          } else {
+            const argsJson = JSON.stringify(invocation.args);
+            tokens += this.readOrPersistPartEstimate(part, `tool-${invocation.state}-args-json`, argsJson);
+            overheadDelta -= 12;
+          }
+        }
+        return { tokens, overheadDelta, toolResultDelta };
+      }
+      if (invocation.state === "result") {
+        toolResultDelta++;
+        const { value: resultForCounting, usingStoredModelOutput } = this.resolveToolResultForTokenCounting(
+          part,
+          invocation.result
+        );
+        if (resultForCounting !== void 0) {
+          if (typeof resultForCounting === "string") {
+            tokens += this.readOrPersistPartEstimate(
+              part,
+              usingStoredModelOutput ? "tool-result-model-output" : "tool-result",
+              resultForCounting
+            );
+          } else {
+            const resultJson = JSON.stringify(resultForCounting);
+            tokens += this.readOrPersistPartEstimate(
+              part,
+              usingStoredModelOutput ? "tool-result-model-output-json" : "tool-result-json",
+              resultJson
+            );
+            overheadDelta -= 12;
+          }
+        }
+        return { tokens, overheadDelta, toolResultDelta };
+      }
+      throw new Error(
+        `Unhandled tool-invocation state '${part.toolInvocation?.state}' in token counting for part type '${part.type}'`
+      );
+    }
+    if (typeof part.type === "string" && part.type.startsWith("data-")) {
+      return { tokens: 0, overheadDelta, toolResultDelta };
+    }
+    if (part.type === "reasoning") {
+      return { tokens: 0, overheadDelta, toolResultDelta };
+    }
+    const serialized = serializePartForTokenCounting(part);
+    return {
+      tokens: this.readOrPersistPartEstimate(part, `part-${part.type}`, serialized),
+      overheadDelta,
+      toolResultDelta
+    };
+  }
+  /**
+   * Count tokens in a single message
+   */
+  countMessage(message) {
+    let payloadTokens = this.countString(message.role);
+    let overhead = _TokenCounter.TOKENS_PER_MESSAGE;
+    let toolResultCount = 0;
+    if (typeof message.content === "string") {
+      payloadTokens += this.readOrPersistMessageEstimate(message, "message-content", message.content);
+    } else if (message.content && typeof message.content === "object") {
+      if (message.content.content && !Array.isArray(message.content.parts)) {
+        payloadTokens += this.readOrPersistMessageEstimate(message, "content-content", message.content.content);
+      } else if (Array.isArray(message.content.parts)) {
+        for (const part of message.content.parts) {
+          const attachmentTokens = this.countAttachmentPartSync(part);
+          if (attachmentTokens !== void 0) {
+            payloadTokens += attachmentTokens;
+            continue;
+          }
+          const result = this.countNonAttachmentPart(part);
+          payloadTokens += result.tokens;
+          overhead += result.overheadDelta;
+          toolResultCount += result.toolResultDelta;
+        }
+      }
+    }
+    if (toolResultCount > 0) {
+      overhead += toolResultCount * _TokenCounter.TOKENS_PER_MESSAGE;
+    }
+    return Math.round(payloadTokens + overhead);
   }
-  /**
-   * Count tokens in a single message
-   */
-  countMessage(message) {
+  async countMessageAsync(message) {
     let payloadTokens = this.countString(message.role);
     let overhead = _TokenCounter.TOKENS_PER_MESSAGE;
     let toolResultCount = 0;
@@ -1475,63 +2783,15 @@ var TokenCounter = class _TokenCounter {
         payloadTokens += this.readOrPersistMessageEstimate(message, "content-content", message.content.content);
       } else if (Array.isArray(message.content.parts)) {
         for (const part of message.content.parts) {
-          if (part.type === "text") {
-            payloadTokens += this.readOrPersistPartEstimate(part, "text", part.text);
-          } else if (part.type === "tool-invocation") {
-            const invocation = part.toolInvocation;
-            if (invocation.state === "call" || invocation.state === "partial-call") {
-              if (invocation.toolName) {
-                payloadTokens += this.readOrPersistPartEstimate(
-                  part,
-                  `tool-${invocation.state}-name`,
-                  invocation.toolName
-                );
-              }
-              if (invocation.args) {
-                if (typeof invocation.args === "string") {
-                  payloadTokens += this.readOrPersistPartEstimate(
-                    part,
-                    `tool-${invocation.state}-args`,
-                    invocation.args
-                  );
-                } else {
-                  const argsJson = JSON.stringify(invocation.args);
-                  payloadTokens += this.readOrPersistPartEstimate(part, `tool-${invocation.state}-args-json`, argsJson);
-                  overhead -= 12;
-                }
-              }
-            } else if (invocation.state === "result") {
-              toolResultCount++;
-              const { value: resultForCounting, usingStoredModelOutput } = this.resolveToolResultForTokenCounting(
-                part,
-                invocation.result
-              );
-              if (resultForCounting !== void 0) {
-                if (typeof resultForCounting === "string") {
-                  payloadTokens += this.readOrPersistPartEstimate(
-                    part,
-                    usingStoredModelOutput ? "tool-result-model-output" : "tool-result",
-                    resultForCounting
-                  );
-                } else {
-                  const resultJson = JSON.stringify(resultForCounting);
-                  payloadTokens += this.readOrPersistPartEstimate(
-                    part,
-                    usingStoredModelOutput ? "tool-result-model-output-json" : "tool-result-json",
-                    resultJson
-                  );
-                  overhead -= 12;
-                }
-              }
-            } else {
-              throw new Error(
-                `Unhandled tool-invocation state '${part.toolInvocation?.state}' in token counting for part type '${part.type}'`
-              );
-            }
-          } else if (typeof part.type === "string" && part.type.startsWith("data-")) ; else if (part.type === "reasoning") ; else {
-            const serialized = serializePartForTokenCounting(part);
-            payloadTokens += this.readOrPersistPartEstimate(part, `part-${part.type}`, serialized);
+          const attachmentTokens = await this.countAttachmentPartAsync(part);
+          if (attachmentTokens !== void 0) {
+            payloadTokens += attachmentTokens;
+            continue;
           }
+          const result = this.countNonAttachmentPart(part);
+          payloadTokens += result.tokens;
+          overhead += result.overheadDelta;
+          toolResultCount += result.toolResultDelta;
         }
       }
     }
@@ -1551,6 +2811,11 @@ var TokenCounter = class _TokenCounter {
     }
     return total;
   }
+  async countMessagesAsync(messages) {
+    if (!messages || messages.length === 0) return 0;
+    const messageTotals = await Promise.all(messages.map((message) => this.countMessageAsync(message)));
+    return _TokenCounter.TOKENS_PER_CONVERSATION + messageTotals.reduce((sum, count) => sum + count, 0);
+  }
   /**
    * Count tokens in observations string
    */
@@ -1808,6 +3073,41 @@ var ObservationalMemory = class _ObservationalMemory {
     }
     return [];
   }
+  /**
+   * Refresh per-chunk messageTokens from the current in-memory message list.
+   *
+   * Buffered chunks store a messageTokens snapshot from when they were created,
+   * but messages can be edited/sealed between buffering and activation, changing
+   * their token weight. Using stale weights causes projected-removal math to
+   * over- or under-estimate, leading to skipped activations or over-activation.
+   *
+   * Token recount only runs when the full chunk is present in the message list.
+   * Partial recount is skipped because it would undercount and could cause
+   * over-activation of buffered chunks.
+   */
+  refreshBufferedChunkMessageTokens(chunks, messageList) {
+    const allMessages = messageList.get.all.db();
+    const messageMap = new Map(allMessages.filter((m) => m?.id).map((m) => [m.id, m]));
+    return chunks.map((chunk) => {
+      const chunkMessages = chunk.messageIds.map((id) => messageMap.get(id)).filter((m) => !!m);
+      if (chunkMessages.length !== chunk.messageIds.length) {
+        return chunk;
+      }
+      const refreshedTokens = this.tokenCounter.countMessages(chunkMessages);
+      const refreshedMessageTokens = chunk.messageIds.reduce((acc, id) => {
+        const msg = messageMap.get(id);
+        if (msg) {
+          acc[id] = this.tokenCounter.countMessages([msg]);
+        }
+        return acc;
+      }, {});
+      return {
+        ...chunk,
+        messageTokens: refreshedTokens,
+        messageTokenCounts: refreshedMessageTokens
+      };
+    });
+  }
   /**
    * Check if we've crossed a new bufferTokens interval boundary.
    * Returns true if async buffering should be triggered.
@@ -1904,6 +3204,11 @@ var ObservationalMemory = class _ObservationalMemory {
     return `thread:${threadId ?? "unknown"}`;
   }
   constructor(config) {
+    if (!coreFeatures.has("request-response-id-rotation")) {
+      throw new Error(
+        "Observational memory requires @mastra/core support for request-response-id-rotation. Please bump @mastra/core to a newer version."
+      );
+    }
     if (config.model && config.observation?.model) {
       throw new Error(
         "Cannot set both `model` and `observation.model`. Use `model` to set both agents, or set each individually."
@@ -2001,7 +3306,9 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       ),
       instruction: config.reflection?.instruction
     };
-    this.tokenCounter = new TokenCounter();
+    this.tokenCounter = new TokenCounter(void 0, {
+      model: typeof observationModel === "string" ? observationModel : void 0
+    });
     this.onDebugEvent = config.onDebugEvent;
     this.messageHistory = new MessageHistory({ storage: this.storage });
     this.validateBufferConfig();
@@ -2031,25 +3338,59 @@ 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);
   }
+  getModelToResolve(model) {
+    if (Array.isArray(model)) {
+      return model[0]?.model ?? "unknown";
+    }
+    if (typeof model === "function") {
+      return async (ctx) => {
+        const result = await model(ctx);
+        if (Array.isArray(result)) {
+          return result[0]?.model ?? "unknown";
+        }
+        return result;
+      };
+    }
+    return model;
+  }
+  formatModelName(model) {
+    if (!model.modelId) {
+      return "(unknown)";
+    }
+    return model.provider ? `${model.provider}/${model.modelId}` : model.modelId;
+  }
+  async resolveModelContext(modelConfig, requestContext) {
+    const modelToResolve = this.getModelToResolve(modelConfig);
+    if (!modelToResolve) {
+      return void 0;
+    }
+    const resolved = await resolveModelConfig(modelToResolve, requestContext);
+    return {
+      provider: resolved.provider,
+      modelId: resolved.modelId
+    };
+  }
+  getRuntimeModelContext(model) {
+    if (!model?.modelId) {
+      return void 0;
+    }
+    return {
+      provider: model.provider,
+      modelId: model.modelId
+    };
+  }
+  runWithTokenCounterModelContext(modelContext, fn) {
+    return this.tokenCounter.runWithModelContext(modelContext, fn);
+  }
   /**
    * Get the full config including resolved model names.
    * This is async because it needs to resolve the model configs.
    */
   async getResolvedConfig(requestContext) {
-    const getModelToResolve = (model) => {
-      if (Array.isArray(model)) {
-        return model[0]?.model ?? "unknown";
-      }
-      return model;
-    };
-    const formatModelName = (model) => {
-      return model.provider ? `${model.provider}/${model.modelId}` : model.modelId;
-    };
     const safeResolveModel = async (modelConfig) => {
-      const modelToResolve = getModelToResolve(modelConfig);
       try {
-        const resolved = await resolveModelConfig(modelToResolve, requestContext);
-        return formatModelName(resolved);
+        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)";
@@ -2530,10 +3871,16 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
    */
   async callObserver(existingObservations, messagesToObserve, abortSignal, options) {
     const agent = this.getObserverAgent();
-    const prompt = buildObserverPrompt(existingObservations, messagesToObserve, options);
+    const observerMessages = [
+      {
+        role: "user",
+        content: buildObserverTaskPrompt(existingObservations, options)
+      },
+      buildObserverHistoryMessage(messagesToObserve)
+    ];
     const doGenerate = async () => {
       return this.withAbortCheck(async () => {
-        const streamResult = await agent.stream(prompt, {
+        const streamResult = await agent.stream(observerMessages, {
           modelSettings: {
             ...this.observationConfig.modelSettings
           },
@@ -2580,7 +3927,13 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
       model: this.observationConfig.model,
       instructions: buildObserverSystemPrompt(true, this.observationConfig.instruction)
     });
-    const prompt = buildMultiThreadObserverPrompt(existingObservations, messagesByThread, threadOrder);
+    const observerMessages = [
+      {
+        role: "user",
+        content: buildMultiThreadObserverTaskPrompt(existingObservations)
+      },
+      buildMultiThreadObserverHistoryMessage(messagesByThread, threadOrder)
+    ];
     const allMessages = [];
     for (const msgs of messagesByThread.values()) {
       allMessages.push(...msgs);
@@ -2590,7 +3943,7 @@ Async buffering is enabled by default \u2014 this opt-out is only needed when us
     }
     const doGenerate = async () => {
       return this.withAbortCheck(async () => {
-        const streamResult = await agent.stream(prompt, {
+        const streamResult = await agent.stream(observerMessages, {
           modelSettings: {
             ...this.observationConfig.modelSettings
           },
@@ -2868,8 +4221,8 @@ ${suggestedResponse}
   /**
    * Calculate all threshold-related values for observation decision making.
    */
-  calculateObservationThresholds(_allMessages, unobservedMessages, _pendingTokens, otherThreadTokens, currentObservationTokens, _record) {
-    const contextWindowTokens = this.tokenCounter.countMessages(unobservedMessages);
+  async calculateObservationThresholds(_allMessages, unobservedMessages, _pendingTokens, otherThreadTokens, currentObservationTokens, _record) {
+    const contextWindowTokens = await this.tokenCounter.countMessagesAsync(unobservedMessages);
     const totalPendingTokens = Math.max(0, contextWindowTokens + otherThreadTokens);
     const threshold = calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
     const baseReflectionThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
@@ -2979,7 +4332,7 @@ ${suggestedResponse}
       let freshRecord = await this.getOrCreateRecord(threadId, resourceId);
       const freshAllMessages = messageList.get.all.db();
       let freshUnobservedMessages = this.getUnobservedMessages(freshAllMessages, freshRecord);
-      const freshContextTokens = this.tokenCounter.countMessages(freshUnobservedMessages);
+      const freshContextTokens = await this.tokenCounter.countMessagesAsync(freshUnobservedMessages);
       let freshOtherThreadTokens = 0;
       if (this.scope === "resource" && resourceId) {
         const freshOtherContext = await this.loadOtherThreadsContext(resourceId, threadId);
@@ -3121,17 +4474,25 @@ ${suggestedResponse}
     if (observedMessageIds && observedMessageIds.length > 0) {
       const observedSet = new Set(observedMessageIds);
       const idsToRemove = /* @__PURE__ */ new Set();
+      const removalOrder = [];
       let skipped = 0;
       let backoffTriggered = false;
+      const retentionCounter = typeof minRemaining === "number" ? new TokenCounter() : null;
       for (const msg of allMsgs) {
         if (!msg?.id || msg.id === "om-continuation" || !observedSet.has(msg.id)) {
           continue;
         }
-        if (typeof minRemaining === "number") {
+        const unobservedParts = this.getUnobservedParts(msg);
+        const totalParts = msg.content?.parts?.length ?? 0;
+        if (unobservedParts.length > 0 && unobservedParts.length < totalParts) {
+          msg.content.parts = unobservedParts;
+          continue;
+        }
+        if (retentionCounter && typeof minRemaining === "number") {
           const nextRemainingMessages = allMsgs.filter(
             (m) => m?.id && m.id !== "om-continuation" && !idsToRemove.has(m.id) && m.id !== msg.id
           );
-          const remainingIfRemoved = this.tokenCounter.countMessages(nextRemainingMessages);
+          const remainingIfRemoved = retentionCounter.countMessages(nextRemainingMessages);
           if (remainingIfRemoved < minRemaining) {
             skipped += 1;
             backoffTriggered = true;
@@ -3139,6 +4500,19 @@ ${suggestedResponse}
           }
         }
         idsToRemove.add(msg.id);
+        removalOrder.push(msg.id);
+      }
+      if (retentionCounter && typeof minRemaining === "number" && idsToRemove.size > 0) {
+        let remainingMessages = allMsgs.filter((m) => m?.id && m.id !== "om-continuation" && !idsToRemove.has(m.id));
+        let remainingTokens = retentionCounter.countMessages(remainingMessages);
+        while (remainingTokens < minRemaining && removalOrder.length > 0) {
+          const restoreId = removalOrder.pop();
+          idsToRemove.delete(restoreId);
+          skipped += 1;
+          backoffTriggered = true;
+          remainingMessages = allMsgs.filter((m) => m?.id && m.id !== "om-continuation" && !idsToRemove.has(m.id));
+          remainingTokens = retentionCounter.countMessages(remainingMessages);
+        }
       }
       omDebug(
         `[OM:cleanupActivation] observedSet=${[...observedSet].map((id) => id.slice(0, 8)).join(",")}, matched=${idsToRemove.size}, skipped=${skipped}, backoffTriggered=${backoffTriggered}, idsToRemove=${[...idsToRemove].map((id) => id.slice(0, 8)).join(",")}`
@@ -3176,8 +4550,8 @@ ${suggestedResponse}
         await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
       }
     } else {
-      const newInput = messageList.clear.input.db();
-      const newOutput = messageList.clear.response.db();
+      const newInput = messageList.get.input.db();
+      const newOutput = messageList.get.response.db();
       const messagesToSave = [...newInput, ...newOutput];
       if (messagesToSave.length > 0) {
         await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
@@ -3245,11 +4619,17 @@ ${suggestedResponse}
     messageList.add(continuationMessage, "memory");
   }
   /**
-   * Filter out already-observed messages from message list (step 0 only).
-   * Historical messages loaded from DB may contain observation markers from previous sessions.
+   * Filter out already-observed messages from the in-memory context.
+   *
+   * Marker-boundary pruning is safest at step 0 (historical resume/rebuild), where
+   * list ordering mirrors persisted history.
+   * For step > 0, the list may include mid-loop mutations (sealing/splitting/trim),
+   * so we prefer record-based fallback pruning over position-based marker pruning.
    */
-  filterAlreadyObservedMessages(messageList, record) {
+  async filterAlreadyObservedMessages(messageList, record, options) {
     const allMessages = messageList.get.all.db();
+    const useMarkerBoundaryPruning = options?.useMarkerBoundaryPruning ?? true;
+    const fallbackCursor = record?.threadId ? getThreadOMMetadata((await this.storage.getThreadById({ threadId: record.threadId }))?.metadata)?.lastObservedMessageCursor : void 0;
     let markerMessageIndex = -1;
     let markerMessage = null;
     for (let i = allMessages.length - 1; i >= 0; i--) {
@@ -3261,7 +4641,7 @@ ${suggestedResponse}
         break;
       }
     }
-    if (markerMessage && markerMessageIndex !== -1) {
+    if (useMarkerBoundaryPruning && markerMessage && markerMessageIndex !== -1) {
       const messagesToRemove = [];
       for (let i = 0; i < markerMessageIndex; i++) {
         const msg = allMessages[i];
@@ -3282,6 +4662,9 @@ ${suggestedResponse}
       }
     } else if (record) {
       const observedIds = new Set(Array.isArray(record.observedMessageIds) ? record.observedMessageIds : []);
+      const derivedCursor = fallbackCursor ?? this.getLastObservedMessageCursor(
+        allMessages.filter((msg) => !!msg?.id && observedIds.has(msg.id) && !!msg.createdAt)
+      );
       const lastObservedAt = record.lastObservedAt;
       const messagesToRemove = [];
       for (const msg of allMessages) {
@@ -3290,6 +4673,10 @@ ${suggestedResponse}
           messagesToRemove.push(msg.id);
           continue;
         }
+        if (derivedCursor && this.isMessageAtOrBeforeCursor(msg, derivedCursor)) {
+          messagesToRemove.push(msg.id);
+          continue;
+        }
         if (lastObservedAt && msg.createdAt) {
           const msgDate = new Date(msg.createdAt);
           if (msgDate <= lastObservedAt) {
@@ -3314,7 +4701,7 @@ ${suggestedResponse}
    * 5. Filter out already-observed messages
    */
   async processInputStep(args) {
-    const { messageList, requestContext, stepNumber, state: _state, writer, abortSignal, abort } = args;
+    const { messageList, requestContext, 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}`
@@ -3327,262 +4714,322 @@ ${suggestedResponse}
     const { threadId, resourceId } = context;
     const memoryContext = parseMemoryRequestContext(requestContext);
     const readOnly = memoryContext?.memoryConfig?.readOnly;
-    let record = await this.getOrCreateRecord(threadId, resourceId);
-    omDebug(
-      `[OM:step] processInputStep step=${stepNumber}: recordId=${record.id}, genCount=${record.generationCount}, obsTokens=${record.observationTokenCount}, bufferedReflection=${record.bufferedReflection ? "present (" + record.bufferedReflection.length + " chars)" : "empty"}, activeObsLen=${record.activeObservations?.length}`
-    );
-    await this.loadHistoricalMessagesIfNeeded(messageList, state, threadId, resourceId, record.lastObservedAt);
-    let unobservedContextBlocks;
-    if (this.scope === "resource" && resourceId) {
-      unobservedContextBlocks = await this.loadOtherThreadsContext(resourceId, threadId);
-    }
-    if (stepNumber === 0 && !readOnly && this.isAsyncObservationEnabled()) {
-      const lockKey = this.getLockKey(threadId, resourceId);
-      const bufferedChunks = this.getBufferedChunks(record);
+    const actorModelContext = this.getRuntimeModelContext(model);
+    state.__omActorModelContext = actorModelContext;
+    return this.runWithTokenCounterModelContext(actorModelContext, async () => {
+      let record = await this.getOrCreateRecord(threadId, resourceId);
+      const reproCaptureEnabled = isOmReproCaptureEnabled();
+      const preRecordSnapshot = reproCaptureEnabled ? safeCaptureJson(record) : null;
+      const preMessagesSnapshot = reproCaptureEnabled ? safeCaptureJson(messageList.get.all.db()) : null;
+      const preSerializedMessageList = reproCaptureEnabled ? safeCaptureJson(messageList.serialize()) : null;
+      const reproCaptureDetails = {
+        step0Activation: null,
+        thresholdCleanup: null,
+        thresholdReached: false
+      };
       omDebug(
-        `[OM:step0-activation] asyncObsEnabled=true, bufferedChunks=${bufferedChunks.length}, isBufferingObs=${record.isBufferingObservation}`
+        `[OM:step] processInputStep step=${stepNumber}: recordId=${record.id}, genCount=${record.generationCount}, obsTokens=${record.observationTokenCount}, bufferedReflection=${record.bufferedReflection ? "present (" + record.bufferedReflection.length + " chars)" : "empty"}, activeObsLen=${record.activeObservations?.length}`
       );
-      {
-        const bufKey = this.getObservationBufferKey(lockKey);
-        const dbBoundary = record.lastBufferedAtTokens ?? 0;
-        const currentContextTokens = this.tokenCounter.countMessages(messageList.get.all.db());
-        if (dbBoundary > currentContextTokens) {
-          omDebug(
-            `[OM:step0-boundary-reset] dbBoundary=${dbBoundary} > currentContext=${currentContextTokens}, resetting to current`
-          );
-          _ObservationalMemory.lastBufferedBoundary.set(bufKey, currentContextTokens);
-          this.storage.setBufferingObservationFlag(record.id, false, currentContextTokens).catch(() => {
-          });
-        }
+      await this.loadHistoricalMessagesIfNeeded(messageList, state, threadId, resourceId, record.lastObservedAt);
+      let unobservedContextBlocks;
+      if (this.scope === "resource" && resourceId) {
+        unobservedContextBlocks = await this.loadOtherThreadsContext(resourceId, threadId);
       }
-      if (bufferedChunks.length > 0) {
-        const allMsgsForCheck = messageList.get.all.db();
-        const unobservedMsgsForCheck = this.getUnobservedMessages(allMsgsForCheck, record);
-        const otherThreadTokensForCheck = unobservedContextBlocks ? this.tokenCounter.countString(unobservedContextBlocks) : 0;
-        const currentObsTokensForCheck = record.observationTokenCount ?? 0;
-        const { totalPendingTokens: step0PendingTokens, threshold: step0Threshold } = this.calculateObservationThresholds(
-          allMsgsForCheck,
-          unobservedMsgsForCheck,
-          0,
-          // pendingTokens not needed — allMessages covers context
-          otherThreadTokensForCheck,
-          currentObsTokensForCheck,
-          record
-        );
+      if (stepNumber === 0 && !readOnly && this.isAsyncObservationEnabled()) {
+        const lockKey = this.getLockKey(threadId, resourceId);
+        const bufferedChunks = this.getBufferedChunks(record);
         omDebug(
-          `[OM:step0-activation] pendingTokens=${step0PendingTokens}, threshold=${step0Threshold}, blockAfter=${this.observationConfig.blockAfter}, shouldActivate=${step0PendingTokens >= step0Threshold}, allMsgs=${allMsgsForCheck.length}`
+          `[OM:step0-activation] asyncObsEnabled=true, bufferedChunks=${bufferedChunks.length}, isBufferingObs=${record.isBufferingObservation}`
         );
-        if (step0PendingTokens >= step0Threshold) {
-          const activationResult = await this.tryActivateBufferedObservations(
-            record,
-            lockKey,
-            step0PendingTokens,
-            writer,
-            messageList
+        {
+          const bufKey = this.getObservationBufferKey(lockKey);
+          const dbBoundary = record.lastBufferedAtTokens ?? 0;
+          const currentContextTokens = this.tokenCounter.countMessages(messageList.get.all.db());
+          if (dbBoundary > currentContextTokens) {
+            omDebug(
+              `[OM:step0-boundary-reset] dbBoundary=${dbBoundary} > currentContext=${currentContextTokens}, resetting to current`
+            );
+            _ObservationalMemory.lastBufferedBoundary.set(bufKey, currentContextTokens);
+            this.storage.setBufferingObservationFlag(record.id, false, currentContextTokens).catch(() => {
+            });
+          }
+        }
+        if (bufferedChunks.length > 0) {
+          const allMsgsForCheck = messageList.get.all.db();
+          const unobservedMsgsForCheck = this.getUnobservedMessages(allMsgsForCheck, record);
+          const otherThreadTokensForCheck = unobservedContextBlocks ? this.tokenCounter.countString(unobservedContextBlocks) : 0;
+          const currentObsTokensForCheck = record.observationTokenCount ?? 0;
+          const { totalPendingTokens: step0PendingTokens, threshold: step0Threshold } = await this.calculateObservationThresholds(
+            allMsgsForCheck,
+            unobservedMsgsForCheck,
+            0,
+            // pendingTokens not needed — allMessages covers context
+            otherThreadTokensForCheck,
+            currentObsTokensForCheck,
+            record
           );
-          if (activationResult.success && activationResult.updatedRecord) {
-            record = activationResult.updatedRecord;
-            const activatedIds = activationResult.activatedMessageIds ?? [];
-            if (activatedIds.length > 0) {
-              const activatedSet = new Set(activatedIds);
-              const allMsgs = messageList.get.all.db();
-              const idsToRemove = allMsgs.filter((msg) => msg?.id && msg.id !== "om-continuation" && activatedSet.has(msg.id)).map((msg) => msg.id);
-              if (idsToRemove.length > 0) {
-                messageList.removeByIds(idsToRemove);
+          omDebug(
+            `[OM:step0-activation] pendingTokens=${step0PendingTokens}, threshold=${step0Threshold}, blockAfter=${this.observationConfig.blockAfter}, shouldActivate=${step0PendingTokens >= step0Threshold}, allMsgs=${allMsgsForCheck.length}`
+          );
+          if (step0PendingTokens >= step0Threshold) {
+            const activationResult = await this.tryActivateBufferedObservations(
+              record,
+              lockKey,
+              step0PendingTokens,
+              writer,
+              messageList
+            );
+            reproCaptureDetails.step0Activation = {
+              attempted: true,
+              success: activationResult.success,
+              messageTokensActivated: activationResult.messageTokensActivated ?? 0,
+              activatedMessageIds: activationResult.activatedMessageIds ?? [],
+              hadUpdatedRecord: !!activationResult.updatedRecord
+            };
+            if (activationResult.success && activationResult.updatedRecord) {
+              record = activationResult.updatedRecord;
+              const activatedIds = activationResult.activatedMessageIds ?? [];
+              if (activatedIds.length > 0) {
+                const activatedSet = new Set(activatedIds);
+                const allMsgs = messageList.get.all.db();
+                const idsToRemove = allMsgs.filter((msg) => msg?.id && msg.id !== "om-continuation" && activatedSet.has(msg.id)).map((msg) => msg.id);
+                if (idsToRemove.length > 0) {
+                  messageList.removeByIds(idsToRemove);
+                }
               }
-            }
-            this.cleanupStaticMaps(threadId, resourceId, activatedIds);
-            const bufKey = this.getObservationBufferKey(lockKey);
-            _ObservationalMemory.lastBufferedBoundary.set(bufKey, 0);
-            this.storage.setBufferingObservationFlag(record.id, false, 0).catch(() => {
-            });
-            const thread = await this.storage.getThreadById({ threadId });
-            if (thread) {
-              const newMetadata = setThreadOMMetadata(thread.metadata, {
-                suggestedResponse: activationResult.suggestedContinuation,
-                currentTask: activationResult.currentTask
+              this.cleanupStaticMaps(threadId, resourceId, activatedIds);
+              const bufKey = this.getObservationBufferKey(lockKey);
+              _ObservationalMemory.lastBufferedBoundary.set(bufKey, 0);
+              this.storage.setBufferingObservationFlag(record.id, false, 0).catch(() => {
               });
-              await this.storage.updateThread({
-                id: threadId,
-                title: thread.title ?? "",
-                metadata: newMetadata
+              const thread = await this.storage.getThreadById({ threadId });
+              if (thread) {
+                const activatedSet = new Set(activationResult.activatedMessageIds ?? []);
+                const activatedMessages = messageList.get.all.db().filter((msg) => msg?.id && activatedSet.has(msg.id));
+                const newMetadata = setThreadOMMetadata(thread.metadata, {
+                  suggestedResponse: activationResult.suggestedContinuation,
+                  currentTask: activationResult.currentTask,
+                  lastObservedMessageCursor: this.getLastObservedMessageCursor(activatedMessages)
+                });
+                await this.storage.updateThread({
+                  id: threadId,
+                  title: thread.title ?? "",
+                  metadata: newMetadata
+                });
+              }
+              await this.maybeReflect({
+                record,
+                observationTokens: record.observationTokenCount ?? 0,
+                threadId,
+                writer,
+                messageList,
+                requestContext
               });
+              record = await this.getOrCreateRecord(threadId, resourceId);
             }
-            await this.maybeReflect({
-              record,
-              observationTokens: record.observationTokenCount ?? 0,
-              threadId,
-              writer,
-              messageList,
-              requestContext
-            });
-            record = await this.getOrCreateRecord(threadId, resourceId);
           }
         }
       }
-    }
-    if (stepNumber === 0 && !readOnly) {
-      const obsTokens = record.observationTokenCount ?? 0;
-      if (this.shouldReflect(obsTokens)) {
-        omDebug(`[OM:step0-reflect] obsTokens=${obsTokens} over reflectThreshold, triggering reflection`);
-        await this.maybeReflect({
-          record,
-          observationTokens: obsTokens,
-          threadId,
-          writer,
-          messageList,
-          requestContext
-        });
-        record = await this.getOrCreateRecord(threadId, resourceId);
-      } else if (this.isAsyncReflectionEnabled()) {
-        const lockKey = this.getLockKey(threadId, resourceId);
-        if (this.shouldTriggerAsyncReflection(obsTokens, lockKey, record)) {
-          omDebug(`[OM:step0-reflect] obsTokens=${obsTokens} above activation point, triggering async reflection`);
-          await this.maybeAsyncReflect(record, obsTokens, writer, messageList, requestContext);
-          record = await this.getOrCreateRecord(threadId, resourceId);
-        }
-      }
-    }
-    if (!readOnly) {
-      const allMessages = messageList.get.all.db();
-      const unobservedMessages = this.getUnobservedMessages(allMessages, record);
-      const otherThreadTokens = unobservedContextBlocks ? this.tokenCounter.countString(unobservedContextBlocks) : 0;
-      const currentObservationTokens = record.observationTokenCount ?? 0;
-      const thresholds = this.calculateObservationThresholds(
-        allMessages,
-        unobservedMessages,
-        0,
-        // pendingTokens not needed — allMessages covers context
-        otherThreadTokens,
-        currentObservationTokens,
-        record
-      );
-      const { totalPendingTokens, threshold } = thresholds;
-      const bufferedChunkTokens = this.getBufferedChunks(record).reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
-      const unbufferedPendingTokens = Math.max(0, totalPendingTokens - bufferedChunkTokens);
-      const stateSealedIds = state.sealedIds ?? /* @__PURE__ */ new Set();
-      const staticSealedIds = _ObservationalMemory.sealedMessageIds.get(threadId) ?? /* @__PURE__ */ new Set();
-      const sealedIds = /* @__PURE__ */ new Set([...stateSealedIds, ...staticSealedIds]);
-      state.sealedIds = sealedIds;
-      const lockKey = this.getLockKey(threadId, resourceId);
-      if (this.isAsyncObservationEnabled() && totalPendingTokens < threshold) {
-        const shouldTrigger = this.shouldTriggerAsyncObservation(totalPendingTokens, lockKey, record, threshold);
-        omDebug(
-          `[OM:async-obs] belowThreshold: pending=${totalPendingTokens}, unbuffered=${unbufferedPendingTokens}, threshold=${threshold}, shouldTrigger=${shouldTrigger}, isBufferingObs=${record.isBufferingObservation}, lastBufferedAt=${record.lastBufferedAtTokens}`
-        );
-        if (shouldTrigger) {
-          this.startAsyncBufferedObservation(
+      if (stepNumber === 0 && !readOnly) {
+        const obsTokens = record.observationTokenCount ?? 0;
+        if (this.shouldReflect(obsTokens)) {
+          omDebug(`[OM:step0-reflect] obsTokens=${obsTokens} over reflectThreshold, triggering reflection`);
+          await this.maybeReflect({
             record,
+            observationTokens: obsTokens,
             threadId,
-            unobservedMessages,
-            lockKey,
             writer,
-            unbufferedPendingTokens,
+            messageList,
             requestContext
-          );
+          });
+          record = await this.getOrCreateRecord(threadId, resourceId);
+        } else if (this.isAsyncReflectionEnabled()) {
+          const lockKey = this.getLockKey(threadId, resourceId);
+          if (this.shouldTriggerAsyncReflection(obsTokens, lockKey, record)) {
+            omDebug(`[OM:step0-reflect] obsTokens=${obsTokens} above activation point, triggering async reflection`);
+            await this.maybeAsyncReflect(record, obsTokens, writer, messageList, requestContext);
+            record = await this.getOrCreateRecord(threadId, resourceId);
+          }
         }
-      } else if (this.isAsyncObservationEnabled()) {
-        const shouldTrigger = this.shouldTriggerAsyncObservation(totalPendingTokens, lockKey, record, threshold);
-        omDebug(
-          `[OM:async-obs] atOrAboveThreshold: pending=${totalPendingTokens}, unbuffered=${unbufferedPendingTokens}, threshold=${threshold}, step=${stepNumber}, shouldTrigger=${shouldTrigger}`
+      }
+      let didThresholdCleanup = false;
+      if (!readOnly) {
+        let allMessages = messageList.get.all.db();
+        let unobservedMessages = this.getUnobservedMessages(allMessages, record);
+        const otherThreadTokens = unobservedContextBlocks ? this.tokenCounter.countString(unobservedContextBlocks) : 0;
+        let currentObservationTokens = record.observationTokenCount ?? 0;
+        let thresholds = await this.calculateObservationThresholds(
+          allMessages,
+          unobservedMessages,
+          0,
+          // pendingTokens not needed — allMessages covers context
+          otherThreadTokens,
+          currentObservationTokens,
+          record
         );
-        if (shouldTrigger) {
-          this.startAsyncBufferedObservation(
+        let { totalPendingTokens, threshold } = thresholds;
+        let bufferedChunkTokens = this.getBufferedChunks(record).reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+        let unbufferedPendingTokens = Math.max(0, totalPendingTokens - bufferedChunkTokens);
+        const stateSealedIds = state.sealedIds ?? /* @__PURE__ */ new Set();
+        const staticSealedIds = _ObservationalMemory.sealedMessageIds.get(threadId) ?? /* @__PURE__ */ new Set();
+        const sealedIds = /* @__PURE__ */ new Set([...stateSealedIds, ...staticSealedIds]);
+        state.sealedIds = sealedIds;
+        const lockKey = this.getLockKey(threadId, resourceId);
+        if (this.isAsyncObservationEnabled() && totalPendingTokens < threshold) {
+          const shouldTrigger = this.shouldTriggerAsyncObservation(totalPendingTokens, lockKey, record, threshold);
+          omDebug(
+            `[OM:async-obs] belowThreshold: pending=${totalPendingTokens}, unbuffered=${unbufferedPendingTokens}, threshold=${threshold}, shouldTrigger=${shouldTrigger}, isBufferingObs=${record.isBufferingObservation}, lastBufferedAt=${record.lastBufferedAtTokens}`
+          );
+          if (shouldTrigger) {
+            void this.startAsyncBufferedObservation(
+              record,
+              threadId,
+              unobservedMessages,
+              lockKey,
+              writer,
+              unbufferedPendingTokens,
+              requestContext
+            );
+          }
+        } else if (this.isAsyncObservationEnabled()) {
+          const shouldTrigger = this.shouldTriggerAsyncObservation(totalPendingTokens, lockKey, record, threshold);
+          omDebug(
+            `[OM:async-obs] atOrAboveThreshold: pending=${totalPendingTokens}, unbuffered=${unbufferedPendingTokens}, threshold=${threshold}, step=${stepNumber}, shouldTrigger=${shouldTrigger}`
+          );
+          if (shouldTrigger) {
+            void this.startAsyncBufferedObservation(
+              record,
+              threadId,
+              unobservedMessages,
+              lockKey,
+              writer,
+              unbufferedPendingTokens,
+              requestContext
+            );
+          }
+        }
+        if (stepNumber > 0) {
+          await this.handlePerStepSave(messageList, sealedIds, threadId, resourceId, state);
+        }
+        if (stepNumber > 0 && totalPendingTokens >= threshold) {
+          reproCaptureDetails.thresholdReached = true;
+          const { observationSucceeded, updatedRecord, activatedMessageIds } = await this.handleThresholdReached(
+            messageList,
             record,
             threadId,
-            unobservedMessages,
+            resourceId,
+            threshold,
             lockKey,
             writer,
-            unbufferedPendingTokens,
+            abortSignal,
+            abort,
             requestContext
           );
+          if (observationSucceeded) {
+            const observedIds = activatedMessageIds?.length ? activatedMessageIds : Array.isArray(updatedRecord.observedMessageIds) ? updatedRecord.observedMessageIds : void 0;
+            const minRemaining = typeof this.observationConfig.bufferActivation === "number" ? resolveRetentionFloor(this.observationConfig.bufferActivation, threshold) : void 0;
+            reproCaptureDetails.thresholdCleanup = {
+              observationSucceeded,
+              observedIdsCount: observedIds?.length ?? 0,
+              observedIds,
+              minRemaining,
+              updatedRecordObservedIds: updatedRecord.observedMessageIds
+            };
+            omDebug(
+              `[OM:cleanup] observedIds=${observedIds?.length ?? "undefined"}, ids=${observedIds?.join(",") ?? "none"}, updatedRecord.observedMessageIds=${JSON.stringify(updatedRecord.observedMessageIds)}, minRemaining=${minRemaining ?? "n/a"}`
+            );
+            await this.cleanupAfterObservation(
+              messageList,
+              sealedIds,
+              threadId,
+              resourceId,
+              state,
+              observedIds,
+              minRemaining
+            );
+            didThresholdCleanup = true;
+            if (activatedMessageIds?.length) {
+              this.cleanupStaticMaps(threadId, resourceId, activatedMessageIds);
+            }
+            if (this.isAsyncObservationEnabled()) {
+              const bufKey = this.getObservationBufferKey(lockKey);
+              _ObservationalMemory.lastBufferedBoundary.set(bufKey, 0);
+              this.storage.setBufferingObservationFlag(updatedRecord.id, false, 0).catch(() => {
+              });
+              omDebug(`[OM:threshold] post-activation boundary reset to 0`);
+            }
+          }
+          record = updatedRecord;
         }
       }
-      if (stepNumber > 0) {
-        await this.handlePerStepSave(messageList, sealedIds, threadId, resourceId, state);
+      await this.injectObservationsIntoContext(
+        messageList,
+        record,
+        threadId,
+        resourceId,
+        unobservedContextBlocks,
+        requestContext
+      );
+      if (!didThresholdCleanup) {
+        await this.filterAlreadyObservedMessages(messageList, record, { useMarkerBoundaryPruning: stepNumber === 0 });
       }
-      if (stepNumber > 0 && totalPendingTokens >= threshold) {
-        const { observationSucceeded, updatedRecord, activatedMessageIds } = await this.handleThresholdReached(
-          messageList,
-          record,
+      {
+        const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
+        const contextMessages = messageList.get.all.db();
+        const freshUnobservedTokens = await this.tokenCounter.countMessagesAsync(contextMessages);
+        const otherThreadTokens = unobservedContextBlocks ? this.tokenCounter.countString(unobservedContextBlocks) : 0;
+        const currentObservationTokens = freshRecord.observationTokenCount ?? 0;
+        const threshold = calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
+        const baseReflectionThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
+        const isSharedBudget = typeof this.observationConfig.messageTokens !== "number";
+        const totalBudget = isSharedBudget ? this.observationConfig.messageTokens.max : 0;
+        const effectiveObservationTokensThreshold = isSharedBudget ? Math.max(totalBudget - threshold, 1e3) : baseReflectionThreshold;
+        const totalPendingTokens = freshUnobservedTokens + otherThreadTokens;
+        await this.emitStepProgress(
+          writer,
           threadId,
           resourceId,
-          threshold,
-          lockKey,
-          writer,
-          abortSignal,
-          abort,
-          requestContext
+          stepNumber,
+          freshRecord,
+          {
+            totalPendingTokens,
+            threshold,
+            effectiveObservationTokensThreshold
+          },
+          currentObservationTokens
         );
-        if (observationSucceeded) {
-          const observedIds = activatedMessageIds?.length ? activatedMessageIds : Array.isArray(updatedRecord.observedMessageIds) ? updatedRecord.observedMessageIds : void 0;
-          const minRemaining = typeof this.observationConfig.bufferActivation === "number" ? resolveRetentionFloor(this.observationConfig.bufferActivation, threshold) : void 0;
-          omDebug(
-            `[OM:cleanup] observedIds=${observedIds?.length ?? "undefined"}, ids=${observedIds?.join(",") ?? "none"}, updatedRecord.observedMessageIds=${JSON.stringify(updatedRecord.observedMessageIds)}, minRemaining=${minRemaining ?? "n/a"}`
-          );
-          await this.cleanupAfterObservation(
-            messageList,
-            sealedIds,
+        this.storage.setPendingMessageTokens(freshRecord.id, totalPendingTokens).catch(() => {
+        });
+        if (reproCaptureEnabled && preRecordSnapshot && preMessagesSnapshot && preSerializedMessageList) {
+          writeProcessInputStepReproCapture({
             threadId,
             resourceId,
-            state,
-            observedIds,
-            minRemaining
-          );
-          if (activatedMessageIds?.length) {
-            this.cleanupStaticMaps(threadId, resourceId, activatedMessageIds);
-          }
-          if (this.isAsyncObservationEnabled()) {
-            const bufKey = this.getObservationBufferKey(lockKey);
-            _ObservationalMemory.lastBufferedBoundary.set(bufKey, 0);
-            this.storage.setBufferingObservationFlag(updatedRecord.id, false, 0).catch(() => {
-            });
-            omDebug(`[OM:threshold] post-activation boundary reset to 0`);
-          }
+            stepNumber,
+            args,
+            preRecord: preRecordSnapshot,
+            postRecord: freshRecord,
+            preMessages: preMessagesSnapshot,
+            preBufferedChunks: this.getBufferedChunks(preRecordSnapshot),
+            preContextTokenCount: this.tokenCounter.countMessages(preMessagesSnapshot),
+            preSerializedMessageList,
+            postBufferedChunks: this.getBufferedChunks(freshRecord),
+            postContextTokenCount: this.tokenCounter.countMessages(contextMessages),
+            messageList,
+            details: {
+              ...reproCaptureDetails,
+              totalPendingTokens,
+              threshold,
+              effectiveObservationTokensThreshold,
+              currentObservationTokens,
+              otherThreadTokens,
+              contextMessageCount: contextMessages.length
+            },
+            debug: omDebug
+          });
         }
-        record = updatedRecord;
       }
-    }
-    await this.injectObservationsIntoContext(
-      messageList,
-      record,
-      threadId,
-      resourceId,
-      unobservedContextBlocks,
-      requestContext
-    );
-    if (stepNumber === 0) {
-      this.filterAlreadyObservedMessages(messageList, record);
-    }
-    {
-      const freshRecord = await this.getOrCreateRecord(threadId, resourceId);
-      const contextMessages = messageList.get.all.db();
-      const freshUnobservedTokens = this.tokenCounter.countMessages(contextMessages);
-      const otherThreadTokens = unobservedContextBlocks ? this.tokenCounter.countString(unobservedContextBlocks) : 0;
-      const currentObservationTokens = freshRecord.observationTokenCount ?? 0;
-      const threshold = calculateDynamicThreshold(this.observationConfig.messageTokens, currentObservationTokens);
-      const baseReflectionThreshold = getMaxThreshold(this.reflectionConfig.observationTokens);
-      const isSharedBudget = typeof this.observationConfig.messageTokens !== "number";
-      const totalBudget = isSharedBudget ? this.observationConfig.messageTokens.max : 0;
-      const effectiveObservationTokensThreshold = isSharedBudget ? Math.max(totalBudget - threshold, 1e3) : baseReflectionThreshold;
-      const totalPendingTokens = freshUnobservedTokens + otherThreadTokens;
-      await this.emitStepProgress(
-        writer,
-        threadId,
-        resourceId,
-        stepNumber,
-        freshRecord,
-        {
-          totalPendingTokens,
-          threshold,
-          effectiveObservationTokensThreshold
-        },
-        currentObservationTokens
-      );
-      this.storage.setPendingMessageTokens(freshRecord.id, totalPendingTokens).catch(() => {
-      });
-    }
-    return messageList;
+      return messageList;
+    });
   }
   /**
    * Save any unsaved messages at the end of the agent turn.
@@ -3599,30 +5046,35 @@ ${suggestedResponse}
       return messageList;
     }
     const { threadId, resourceId } = context;
-    const memoryContext = parseMemoryRequestContext(requestContext);
-    const readOnly = memoryContext?.memoryConfig?.readOnly;
-    if (readOnly) {
-      return messageList;
-    }
-    const newInput = messageList.get.input.db();
-    const newOutput = messageList.get.response.db();
-    const messagesToSave = [...newInput, ...newOutput];
-    omDebug(
-      `[OM:processOutputResult] threadId=${threadId}, inputMsgs=${newInput.length}, responseMsgs=${newOutput.length}, totalToSave=${messagesToSave.length}, allMsgsInList=${messageList.get.all.db().length}`
-    );
-    if (messagesToSave.length === 0) {
-      omDebug(`[OM:processOutputResult] nothing to save \u2014 all messages were already saved during per-step saves`);
-      return messageList;
-    }
-    const sealedIds = state.sealedIds ?? /* @__PURE__ */ new Set();
-    omDebug(
-      `[OM:processOutputResult] saving ${messagesToSave.length} messages, sealedIds=${sealedIds.size}, ids=${messagesToSave.map((m) => m.id?.slice(0, 8)).join(",")}`
-    );
-    await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
-    omDebug(
-      `[OM:processOutputResult] saved successfully, finalIds=${messagesToSave.map((m) => m.id?.slice(0, 8)).join(",")}`
+    return this.runWithTokenCounterModelContext(
+      state.__omActorModelContext,
+      async () => {
+        const memoryContext = parseMemoryRequestContext(requestContext);
+        const readOnly = memoryContext?.memoryConfig?.readOnly;
+        if (readOnly) {
+          return messageList;
+        }
+        const newInput = messageList.get.input.db();
+        const newOutput = messageList.get.response.db();
+        const messagesToSave = [...newInput, ...newOutput];
+        omDebug(
+          `[OM:processOutputResult] threadId=${threadId}, inputMsgs=${newInput.length}, responseMsgs=${newOutput.length}, totalToSave=${messagesToSave.length}, allMsgsInList=${messageList.get.all.db().length}`
+        );
+        if (messagesToSave.length === 0) {
+          omDebug(`[OM:processOutputResult] nothing to save \u2014 all messages were already saved during per-step saves`);
+          return messageList;
+        }
+        const sealedIds = state.sealedIds ?? /* @__PURE__ */ new Set();
+        omDebug(
+          `[OM:processOutputResult] saving ${messagesToSave.length} messages, sealedIds=${sealedIds.size}, ids=${messagesToSave.map((m) => m.id?.slice(0, 8)).join(",")}`
+        );
+        await this.saveMessagesWithSealedIdTracking(messagesToSave, sealedIds, threadId, resourceId, state);
+        omDebug(
+          `[OM:processOutputResult] saved successfully, finalIds=${messagesToSave.map((m) => m.id?.slice(0, 8)).join(",")}`
+        );
+        return messageList;
+      }
     );
-    return messageList;
   }
   /**
    * Save messages to storage while preventing duplicate inserts for sealed messages.
@@ -3776,6 +5228,30 @@ ${formattedMessages}
     }
     return maxTime > 0 ? new Date(maxTime) : /* @__PURE__ */ new Date();
   }
+  /**
+   * Compute a cursor pointing at the latest message by createdAt.
+   * Used to derive a stable observation boundary for replay pruning.
+   */
+  getLastObservedMessageCursor(messages) {
+    let latest;
+    for (const msg of messages) {
+      if (!msg?.id || !msg.createdAt) continue;
+      if (!latest || new Date(msg.createdAt).getTime() > new Date(latest.createdAt).getTime()) {
+        latest = msg;
+      }
+    }
+    return latest ? { createdAt: new Date(latest.createdAt).toISOString(), id: latest.id } : void 0;
+  }
+  /**
+   * Check if a message is at or before a cursor (by createdAt then id).
+   */
+  isMessageAtOrBeforeCursor(msg, cursor) {
+    if (!msg.createdAt) return false;
+    const msgIso = new Date(msg.createdAt).toISOString();
+    if (msgIso < cursor.createdAt) return true;
+    if (msgIso === cursor.createdAt && msg.id === cursor.id) return true;
+    return false;
+  }
   /**
    * Wrap observations in a thread attribution tag.
    * Used in resource scope to track which thread observations came from.
@@ -3874,7 +5350,7 @@ ${newThreadSection}`;
     await this.storage.setObservingFlag(record.id, true);
     registerOp(record.id, "observing");
     const cycleId = crypto.randomUUID();
-    const tokensToObserve = this.tokenCounter.countMessages(unobservedMessages);
+    const tokensToObserve = await this.tokenCounter.countMessagesAsync(unobservedMessages);
     const lastMessage = unobservedMessages[unobservedMessages.length - 1];
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (lastMessage?.id) {
@@ -3936,7 +5412,8 @@ ${result.observations}` : result.observations;
       if (thread) {
         const newMetadata = setThreadOMMetadata(thread.metadata, {
           suggestedResponse: result.suggestedContinuation,
-          currentTask: result.currentTask
+          currentTask: result.currentTask,
+          lastObservedMessageCursor: this.getLastObservedMessageCursor(messagesToObserve)
         });
         await this.storage.updateThread({
           id: threadId,
@@ -3951,7 +5428,7 @@ ${result.observations}` : result.observations;
         lastObservedAt,
         observedMessageIds: allObservedIds
       });
-      const actualTokensObserved = this.tokenCounter.countMessages(messagesToObserve);
+      const actualTokensObserved = await this.tokenCounter.countMessagesAsync(messagesToObserve);
       if (lastMessage?.id) {
         const endMarker = createObservationEndMarker({
           cycleId,
@@ -4032,9 +5509,9 @@ ${result.observations}` : result.observations;
    * @param lockKey - Lock key for this scope
    * @param writer - Optional stream writer for emitting buffering markers
    */
-  startAsyncBufferedObservation(record, threadId, unobservedMessages, lockKey, writer, contextWindowTokens, requestContext) {
+  async startAsyncBufferedObservation(record, threadId, unobservedMessages, lockKey, writer, contextWindowTokens, requestContext) {
     const bufferKey = this.getObservationBufferKey(lockKey);
-    const currentTokens = contextWindowTokens ?? this.tokenCounter.countMessages(unobservedMessages) + (record.pendingMessageTokens ?? 0);
+    const currentTokens = contextWindowTokens ?? await this.tokenCounter.countMessagesAsync(unobservedMessages) + (record.pendingMessageTokens ?? 0);
     _ObservationalMemory.lastBufferedBoundary.set(bufferKey, currentTokens);
     registerOp(record.id, "bufferingObservation");
     this.storage.setBufferingObservationFlag(record.id, true, currentTokens).catch((err) => {
@@ -4094,7 +5571,7 @@ ${result.observations}` : result.observations;
     );
     const bufferTokens = this.observationConfig.bufferTokens ?? 5e3;
     const minNewTokens = bufferTokens / 2;
-    const newTokens = this.tokenCounter.countMessages(candidateMessages);
+    const newTokens = await this.tokenCounter.countMessagesAsync(candidateMessages);
     if (newTokens < minNewTokens) {
       return;
     }
@@ -4115,7 +5592,7 @@ ${result.observations}` : result.observations;
     }
     const cycleId = `buffer-obs-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const tokensToBuffer = this.tokenCounter.countMessages(messagesToBuffer);
+    const tokensToBuffer = await this.tokenCounter.countMessagesAsync(messagesToBuffer);
     if (writer) {
       const startMarker = createBufferingStartMarker({
         cycleId,
@@ -4193,7 +5670,7 @@ ${result.observations}` : result.observations;
     }
     const newTokenCount = this.tokenCounter.countObservations(newObservations);
     const newMessageIds = messagesToBuffer.map((m) => m.id);
-    const messageTokens = this.tokenCounter.countMessages(messagesToBuffer);
+    const messageTokens = await this.tokenCounter.countMessagesAsync(messagesToBuffer);
     const maxMessageTimestamp = this.getMaxMessageTimestamp(messagesToBuffer);
     const lastObservedAt = new Date(maxMessageTimestamp.getTime() + 1);
     await this.storage.updateBufferedObservations({
@@ -4211,7 +5688,7 @@ ${result.observations}` : result.observations;
       lastBufferedAtTime: lastObservedAt
     });
     if (writer) {
-      const tokensBuffered = this.tokenCounter.countMessages(messagesToBuffer);
+      const tokensBuffered = await this.tokenCounter.countMessagesAsync(messagesToBuffer);
       const updatedRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
       const updatedChunks = this.getBufferedChunks(updatedRecord);
       const totalBufferedTokens = updatedChunks.reduce((sum, c) => sum + (c.tokenCount ?? 0), 0) || newTokenCount;
@@ -4280,14 +5757,14 @@ ${bufferedObservations}`;
     if (!freshRecord) {
       return { success: false };
     }
-    const freshChunks = this.getBufferedChunks(freshRecord);
-    if (!freshChunks.length) {
+    const rawFreshChunks = this.getBufferedChunks(freshRecord);
+    if (!rawFreshChunks.length) {
       return { success: false };
     }
     const messageTokensThreshold = getMaxThreshold(this.observationConfig.messageTokens);
     let effectivePendingTokens = currentPendingTokens;
     if (messageList) {
-      effectivePendingTokens = this.tokenCounter.countMessages(messageList.get.all.db());
+      effectivePendingTokens = await this.tokenCounter.countMessagesAsync(messageList.get.all.db());
       if (effectivePendingTokens < messageTokensThreshold) {
         omDebug(
           `[OM:tryActivate] skipping activation: freshPendingTokens=${effectivePendingTokens} < threshold=${messageTokensThreshold}`
@@ -4295,6 +5772,7 @@ ${bufferedObservations}`;
         return { success: false };
       }
     }
+    const freshChunks = messageList ? this.refreshBufferedChunkMessageTokens(rawFreshChunks, messageList) : rawFreshChunks;
     const bufferActivation = this.observationConfig.bufferActivation ?? 0.7;
     const activationRatio = resolveActivationRatio(bufferActivation, messageTokensThreshold);
     const forceMaxActivation = !!(this.observationConfig.blockAfter && effectivePendingTokens >= this.observationConfig.blockAfter);
@@ -4322,7 +5800,8 @@ ${bufferedObservations}`;
       activationRatio,
       messageTokensThreshold,
       currentPendingTokens: effectivePendingTokens,
-      forceMaxActivation
+      forceMaxActivation,
+      bufferedChunks: freshChunks
     });
     omDebug(
       `[OM:tryActivate] swapResult: chunksActivated=${activationResult.chunksActivated}, tokensActivated=${activationResult.messageTokensActivated}, obsTokensActivated=${activationResult.observationTokensActivated}, activatedCycleIds=${activationResult.activatedCycleIds.join(",")}`
@@ -4650,10 +6129,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
     const threshold = getMaxThreshold(this.observationConfig.messageTokens);
     const threadTokenCounts = /* @__PURE__ */ new Map();
     for (const [threadId, msgs] of messagesByThread) {
-      let tokens = 0;
-      for (const msg of msgs) {
-        tokens += this.tokenCounter.countMessage(msg);
-      }
+      const tokens = await this.tokenCounter.countMessagesAsync(msgs);
       threadTokenCounts.set(threadId, tokens);
     }
     const threadsBySize = Array.from(messagesByThread.keys()).sort((a, b) => {
@@ -4710,7 +6186,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
       const allThreadIds = Array.from(threadsWithMessages.keys());
       for (const [threadId, msgs] of threadsWithMessages) {
         const lastMessage = msgs[msgs.length - 1];
-        const tokensToObserve = this.tokenCounter.countMessages(msgs);
+        const tokensToObserve = await this.tokenCounter.countMessagesAsync(msgs);
         threadTokensToObserve.set(threadId, tokensToObserve);
         if (lastMessage?.id) {
           const startMarker = createObservationStartMarker({
@@ -4802,7 +6278,8 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
           const newMetadata = setThreadOMMetadata(thread.metadata, {
             lastObservedAt: threadLastObservedAt.toISOString(),
             suggestedResponse: result.suggestedContinuation,
-            currentTask: result.currentTask
+            currentTask: result.currentTask,
+            lastObservedMessageCursor: this.getLastObservedMessageCursor(threadMessages)
           });
           await this.storage.updateThread({
             id: threadId,
@@ -4845,7 +6322,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         const { threadId, threadMessages, result } = obsResult;
         const lastMessage = threadMessages[threadMessages.length - 1];
         if (lastMessage?.id) {
-          const tokensObserved = threadTokensToObserve.get(threadId) ?? this.tokenCounter.countMessages(threadMessages);
+          const tokensObserved = threadTokensToObserve.get(threadId) ?? await this.tokenCounter.countMessagesAsync(threadMessages);
           const endMarker = createObservationEndMarker({
             cycleId,
             operationType: "observation",
@@ -5096,7 +6573,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         const currentMessages = messages ?? [];
         if (!this.meetsObservationThreshold({
           record: freshRecord,
-          unobservedTokens: this.tokenCounter.countMessages(currentMessages)
+          unobservedTokens: await this.tokenCounter.countMessagesAsync(currentMessages)
         })) {
           return;
         }
@@ -5124,7 +6601,7 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         }
         if (!this.meetsObservationThreshold({
           record: freshRecord,
-          unobservedTokens: this.tokenCounter.countMessages(unobservedMessages)
+          unobservedTokens: await this.tokenCounter.countMessagesAsync(unobservedMessages)
         })) {
           return;
         }
@@ -5241,5 +6718,5 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
 };
 
 export { OBSERVATIONAL_MEMORY_DEFAULTS, OBSERVATION_CONTEXT_INSTRUCTIONS, OBSERVATION_CONTEXT_PROMPT, OBSERVATION_CONTINUATION_HINT, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, TokenCounter, buildObserverPrompt, buildObserverSystemPrompt, extractCurrentTask, formatMessagesForObserver, hasCurrentTaskSection, optimizeObservationsForContext, parseObserverOutput };
-//# sourceMappingURL=chunk-GBBQIJQF.js.map
-//# sourceMappingURL=chunk-GBBQIJQF.js.map
+//# sourceMappingURL=chunk-3CM4XQJO.js.map
+//# sourceMappingURL=chunk-3CM4XQJO.js.map