@mastra/memory 1.8.2 → 1.8.3-alpha.1

package/dist/{chunk-YPFNHFT6.cjs → chunk-LGCREJMO.cjs}

@@ -8,10 +8,10 @@ var llm = require('@mastra/core/llm');
 var memory = require('@mastra/core/memory');
 var processors = require('@mastra/core/processors');
 var xxhash = require('xxhash-wasm');
+var tokenx = require('tokenx');
 var crypto$1 = require('crypto');
 var async_hooks = require('async_hooks');
 var imageSize = require('image-size');
-var tokenx = require('tokenx');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -307,6 +307,97 @@ function createActivationMarker(params) {
     }
   };
 }
+var ENCRYPTED_CONTENT_KEY = "encryptedContent";
+var ENCRYPTED_CONTENT_REDACTION_THRESHOLD = 256;
+var DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS = 1e4;
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+function sanitizeToolResultValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (!isObjectLike(value)) {
+    return value;
+  }
+  if (seen.has(value)) {
+    return seen.get(value);
+  }
+  if (Array.isArray(value)) {
+    const sanitizedArray = [];
+    seen.set(value, sanitizedArray);
+    for (const item of value) {
+      sanitizedArray.push(sanitizeToolResultValue(item, seen));
+    }
+    return sanitizedArray;
+  }
+  const sanitizedObject = {};
+  seen.set(value, sanitizedObject);
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === ENCRYPTED_CONTENT_KEY && typeof entry === "string" && entry.length > ENCRYPTED_CONTENT_REDACTION_THRESHOLD) {
+      sanitizedObject[key] = `[stripped encryptedContent: ${entry.length} characters]`;
+      continue;
+    }
+    sanitizedObject[key] = sanitizeToolResultValue(entry, seen);
+  }
+  return sanitizedObject;
+}
+function stringifyToolResult(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const sanitized = sanitizeToolResultValue(value);
+  try {
+    return JSON.stringify(sanitized, null, 2);
+  } catch {
+    return String(sanitized);
+  }
+}
+function resolveToolResultValue(part, invocationResult) {
+  const mastraMetadata = part?.providerMetadata?.mastra;
+  if (mastraMetadata && typeof mastraMetadata === "object" && "modelOutput" in mastraMetadata) {
+    return {
+      value: mastraMetadata.modelOutput,
+      usingStoredModelOutput: true
+    };
+  }
+  return {
+    value: invocationResult,
+    usingStoredModelOutput: false
+  };
+}
+function truncateStringByTokens(text, maxTokens) {
+  if (!text || maxTokens <= 0) {
+    return "";
+  }
+  const totalTokens = tokenx.estimateTokenCount(text);
+  if (totalTokens <= maxTokens) {
+    return text;
+  }
+  const buildCandidate = (sliceEnd) => {
+    const visible = text.slice(0, sliceEnd);
+    const omittedChars = text.length - sliceEnd;
+    return `${visible}
+... [truncated ~${totalTokens - tokenx.estimateTokenCount(visible)} tokens / ${omittedChars} characters]`;
+  };
+  let low = 0;
+  let high = text.length;
+  let best = buildCandidate(0);
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const candidate = buildCandidate(mid);
+    const candidateTokens = tokenx.estimateTokenCount(candidate);
+    if (candidateTokens <= maxTokens) {
+      best = candidate;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return best;
+}
+function formatToolResultForObserver(value, options) {
+  const serialized = stringifyToolResult(value);
+  const maxTokens = options?.maxTokens ?? DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS;
+  return truncateStringByTokens(serialized, maxTokens);
+}
 
 // src/processors/observational-memory/observer-agent.ts
 var OBSERVER_EXTRACTION_INSTRUCTIONS = `CRITICAL: DISTINGUISH USER ASSERTIONS FROM QUESTIONS
@@ -781,6 +872,7 @@ function formatObserverAttachmentPlaceholder(part, counter) {
 }
 function formatObserverMessage(msg, counter, options) {
   const maxLen = options?.maxPartLength;
+  const maxToolResultTokens = options?.maxToolResultTokens ?? DEFAULT_OBSERVER_TOOL_RESULT_MAX_TOKENS;
   const timestamp = formatObserverTimestamp(msg.createdAt);
   const role = msg.role.charAt(0).toUpperCase() + msg.role.slice(1);
   const timestampStr = timestamp ? ` (${timestamp})` : "";
@@ -794,7 +886,11 @@ function formatObserverMessage(msg, counter, options) {
       if (part.type === "tool-invocation") {
         const inv = part.toolInvocation;
         if (inv.state === "result") {
-          const resultStr = JSON.stringify(inv.result, null, 2);
+          const { value: resultForObserver } = resolveToolResultValue(
+            part,
+            inv.result
+          );
+          const resultStr = formatToolResultForObserver(resultForObserver, { maxTokens: maxToolResultTokens });
           return `[Tool Result: ${inv.toolName}]
 ${maybeTruncate(resultStr, maxLen)}`;
         }
@@ -835,12 +931,12 @@ function formatMessagesForObserver(messages, options) {
   const counter = { nextImageId: 1, nextFileId: 1 };
   return messages.map((msg) => formatObserverMessage(msg, counter, options).text).filter(Boolean).join("\n\n---\n\n");
 }
-function buildObserverHistoryMessage(messages) {
+function buildObserverHistoryMessage(messages, options) {
   const counter = { nextImageId: 1, nextFileId: 1 };
   const content = [{ type: "text", text: "## New Message History to Observe\n\n" }];
   let visibleCount = 0;
   messages.forEach((message) => {
-    const formatted = formatObserverMessage(message, counter);
+    const formatted = formatObserverMessage(message, counter, options);
     if (!formatted.text && formatted.attachments.length === 0) return;
     if (visibleCount > 0) {
       content.push({ type: "text", text: "\n\n---\n\n" });
@@ -861,7 +957,7 @@ function maybeTruncate(str, maxLen) {
   return `${truncated}
 ... [truncated ${remaining} characters]`;
 }
-function buildMultiThreadObserverHistoryMessage(messagesByThread, threadOrder) {
+function buildMultiThreadObserverHistoryMessage(messagesByThread, threadOrder, options) {
   const counter = { nextImageId: 1, nextFileId: 1 };
   const content = [
     {
@@ -879,7 +975,7 @@ The following messages are from ${threadOrder.length} different conversation thr
     const threadContent = [];
     let visibleCount = 0;
     messages.forEach((message) => {
-      const formatted = formatObserverMessage(message, counter);
+      const formatted = formatObserverMessage(message, counter, options);
       if (!formatted.text && formatted.attachments.length === 0) return;
       if (visibleCount > 0) {
         threadContent.push({ type: "text", text: "\n\n---\n\n" });
@@ -2523,17 +2619,7 @@ var TokenCounter = class _TokenCounter {
     return tokens;
   }
   resolveToolResultForTokenCounting(part, invocationResult) {
-    const mastraMetadata = part?.providerMetadata?.mastra;
-    if (mastraMetadata && typeof mastraMetadata === "object" && "modelOutput" in mastraMetadata) {
-      return {
-        value: mastraMetadata.modelOutput,
-        usingStoredModelOutput: true
-      };
-    }
-    return {
-      value: invocationResult,
-      usingStoredModelOutput: false
-    };
+    return resolveToolResultValue(part, invocationResult);
   }
   estimateImageAssetTokens(part, asset, kind) {
     const modelContext = this.getModelContext();
@@ -2772,19 +2858,13 @@ var TokenCounter = class _TokenCounter {
           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
-            );
+          const formattedResult = formatToolResultForObserver(resultForCounting);
+          tokens += this.readOrPersistPartEstimate(
+            part,
+            usingStoredModelOutput ? "tool-result-model-output-json" : "tool-result-json",
+            formattedResult
+          );
+          if (typeof resultForCounting !== "string") {
             overheadDelta -= 12;
           }
         }
@@ -2900,6 +2980,14 @@ function omDebug(msg) {
   } catch {
   }
 }
+function getLatestStepParts(parts) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    if (parts[i]?.type === "step-start") {
+      return parts.slice(i + 1);
+    }
+  }
+  return parts;
+}
 function omError(msg, err) {
   const errStr = err instanceof Error ? err.stack ?? err.message : err !== void 0 ? String(err) : "";
   const full = errStr ? `${msg}: ${errStr}` : msg;
@@ -4346,38 +4434,51 @@ ${unreflectedContent}` : bufferedReflection;
     if (currentDate) {
       optimized = addRelativeTimeToObservations(optimized, currentDate);
     }
-    let content = `
-${OBSERVATION_CONTEXT_PROMPT}
-
-<observations>
-${optimized}
-</observations>
+    const messages = [`${OBSERVATION_CONTEXT_PROMPT}
 
-${OBSERVATION_CONTEXT_INSTRUCTIONS}`;
+${OBSERVATION_CONTEXT_INSTRUCTIONS}`];
     if (unobservedContextBlocks) {
-      content += `
-
-The following content is from OTHER conversations different from the current conversation, they're here for reference,  but they're not necessarily your focus:
+      messages.push(
+        `The following content is from OTHER conversations different from the current conversation, they're here for reference,  but they're not necessarily your focus:
 START_OTHER_CONVERSATIONS_BLOCK
 ${unobservedContextBlocks}
-END_OTHER_CONVERSATIONS_BLOCK`;
+END_OTHER_CONVERSATIONS_BLOCK`
+      );
+    }
+    const observationChunks = this.splitObservationContextChunks(optimized);
+    if (observationChunks.length > 0) {
+      messages.push("<observations>", ...observationChunks);
     }
     if (currentTask) {
-      content += `
-
-<current-task>
+      messages.push(`<current-task>
 ${currentTask}
-</current-task>`;
+</current-task>`);
     }
     if (suggestedResponse) {
-      content += `
-
-<suggested-response>
+      messages.push(`<suggested-response>
 ${suggestedResponse}
-</suggested-response>
-`;
+</suggested-response>`);
+    }
+    return messages;
+  }
+  splitObservationContextChunks(observations) {
+    const trimmed = observations.trim();
+    if (!trimmed) {
+      return [];
     }
-    return content;
+    return trimmed.split(/\n{2,}--- message boundary \(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\) ---\n{2,}/).map((chunk) => chunk.trim()).filter(Boolean);
+  }
+  /**
+   * Create a message boundary delimiter with an ISO 8601 date.
+   * The date should be the lastObservedAt timestamp — the latest message
+   * timestamp that was observed to produce the observations following this boundary.
+   */
+  static createMessageBoundary(date) {
+    return `
+
+--- message boundary (${date.toISOString()}) ---
+
+`;
   }
   /**
    * Get threadId and resourceId from either RequestContext or MessageList
@@ -4815,7 +4916,7 @@ ${suggestedResponse}
     if (!record.activeObservations) {
       return;
     }
-    const observationSystemMessage = this.formatObservationsForContext(
+    const observationSystemMessages = this.formatObservationsForContext(
       record.activeObservations,
       currentTask,
       suggestedResponse,
@@ -4823,7 +4924,7 @@ ${suggestedResponse}
       currentDate
     );
     messageList.clearSystemMessages("observational-memory");
-    messageList.addSystem(observationSystemMessage, "observational-memory");
+    messageList.addSystem(observationSystemMessages, "observational-memory");
     const continuationMessage = {
       id: `om-continuation`,
       role: "user",
@@ -5099,12 +5200,20 @@ ${suggestedResponse}
         const sealedIds = /* @__PURE__ */ new Set([...stateSealedIds, ...staticSealedIds]);
         state.sealedIds = sealedIds;
         const lockKey = this.getLockKey(threadId, resourceId);
+        const lastMessage = allMessages[allMessages.length - 1];
+        const latestStepParts = getLatestStepParts(lastMessage?.content?.parts ?? []);
+        const hasIncompleteToolCalls = latestStepParts.some(
+          (part) => part?.type === "tool-invocation" && part.toolInvocation?.state === "call"
+        );
+        omDebug(
+          `[OM:deferred-check] hasIncompleteToolCalls=${hasIncompleteToolCalls}, latestStepPartsCount=${latestStepParts.length}`
+        );
         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}`
+            `[OM:async-obs] belowThreshold: pending=${totalPendingTokens}, unbuffered=${unbufferedPendingTokens}, threshold=${threshold}, shouldTrigger=${shouldTrigger}, isBufferingObs=${record.isBufferingObservation}, lastBufferedAt=${record.lastBufferedAtTokens}, hasIncompleteToolCalls=${hasIncompleteToolCalls}`
           );
-          if (shouldTrigger) {
+          if (shouldTrigger && !hasIncompleteToolCalls) {
             void this.startAsyncBufferedObservation(
               record,
               threadId,
@@ -5118,9 +5227,9 @@ ${suggestedResponse}
         } 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}`
+            `[OM:async-obs] atOrAboveThreshold: pending=${totalPendingTokens}, unbuffered=${unbufferedPendingTokens}, threshold=${threshold}, step=${stepNumber}, shouldTrigger=${shouldTrigger}, hasIncompleteToolCalls=${hasIncompleteToolCalls}`
           );
-          if (shouldTrigger) {
+          if (shouldTrigger && !hasIncompleteToolCalls) {
             void this.startAsyncBufferedObservation(
               record,
               threadId,
@@ -5135,7 +5244,7 @@ ${suggestedResponse}
         if (stepNumber > 0) {
           await this.handlePerStepSave(messageList, sealedIds, threadId, resourceId, state);
         }
-        if (stepNumber > 0 && totalPendingTokens >= threshold) {
+        if (stepNumber > 0 && !hasIncompleteToolCalls && totalPendingTokens >= threshold) {
           reproCaptureDetails.thresholdReached = true;
           const { observationSucceeded, updatedRecord, activatedMessageIds } = await this.handleThresholdReached(
             messageList,
@@ -5493,16 +5602,14 @@ ${cleanObservations}
    * merge the observations into that section to reduce token usage.
    * Otherwise, append as a new section.
    */
-  replaceOrAppendThreadSection(existingObservations, _threadId, newThreadSection) {
+  replaceOrAppendThreadSection(existingObservations, _threadId, newThreadSection, lastObservedAt) {
     if (!existingObservations) {
       return newThreadSection;
     }
     const threadIdMatch = newThreadSection.match(/<thread id="([^"]+)">/);
     const dateMatch = newThreadSection.match(/Date:\s*([A-Za-z]+\s+\d+,\s+\d+)/);
     if (!threadIdMatch || !dateMatch) {
-      return `${existingObservations}
-
-${newThreadSection}`;
+      return `${existingObservations}${_ObservationalMemory.createMessageBoundary(lastObservedAt)}${newThreadSection}`;
     }
     const newThreadId = threadIdMatch[1];
     const newDate = dateMatch[1];
@@ -5537,9 +5644,7 @@ ${threadClose}`;
         }
       }
     }
-    return `${existingObservations}
-
-${newThreadSection}`;
+    return `${existingObservations}${_ObservationalMemory.createMessageBoundary(lastObservedAt)}${newThreadSection}`;
   }
   /**
    * Sort threads by their oldest unobserved message.
@@ -5622,19 +5727,22 @@ ${newThreadSection}`;
         priorSuggestedResponse: threadOMMetadata?.suggestedResponse,
         wasTruncated
       });
+      const lastObservedAt = this.getMaxMessageTimestamp(messagesToObserve);
       const existingObservations = freshRecord?.activeObservations ?? record.activeObservations ?? "";
       let newObservations;
       if (this.scope === "resource") {
         const threadSection = await this.wrapWithThreadTag(threadId, result.observations);
-        newObservations = this.replaceOrAppendThreadSection(existingObservations, threadId, threadSection);
+        newObservations = this.replaceOrAppendThreadSection(
+          existingObservations,
+          threadId,
+          threadSection,
+          lastObservedAt
+        );
       } else {
-        newObservations = existingObservations ? `${existingObservations}
-
-${result.observations}` : result.observations;
+        newObservations = existingObservations ? `${existingObservations}${_ObservationalMemory.createMessageBoundary(lastObservedAt)}${result.observations}` : result.observations;
       }
       let totalTokenCount = this.tokenCounter.countObservations(newObservations);
       const cycleObservationTokens = this.tokenCounter.countObservations(result.observations);
-      const lastObservedAt = this.getMaxMessageTimestamp(messagesToObserve);
       const newMessageIds = messagesToObserve.map((m) => m.id);
       const existingIds = freshRecord?.observedMessageIds ?? record.observedMessageIds ?? [];
       const allObservedIds = [.../* @__PURE__ */ new Set([...Array.isArray(existingIds) ? existingIds : [], ...newMessageIds])];
@@ -6528,9 +6636,14 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
         if (!obsResult) continue;
         const { threadId, threadMessages, result } = obsResult;
         cycleObservationTokens += this.tokenCounter.countObservations(result.observations);
-        const threadSection = await this.wrapWithThreadTag(threadId, result.observations);
-        currentObservations = this.replaceOrAppendThreadSection(currentObservations, threadId, threadSection);
         const threadLastObservedAt = this.getMaxMessageTimestamp(threadMessages);
+        const threadSection = await this.wrapWithThreadTag(threadId, result.observations);
+        currentObservations = this.replaceOrAppendThreadSection(
+          currentObservations,
+          threadId,
+          threadSection,
+          threadLastObservedAt
+        );
         const thread = await this.storage.getThreadById({ threadId });
         if (thread) {
           const newMetadata = memory.setThreadOMMetadata(thread.metadata, {
@@ -6975,6 +7088,30 @@ ${unreflectedContent}` : freshRecord.bufferedReflection;
   }
 };
 
+// src/processors/observational-memory/observation-utils.ts
+var BOUNDARY_WITH_DATE_RE = /\n{2,}--- message boundary \((\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)\) ---\n{2,}/;
+function getObservationsAsOf(activeObservations, asOf) {
+  const trimmed = activeObservations.trim();
+  if (!trimmed) return "";
+  const parts = trimmed.split(BOUNDARY_WITH_DATE_RE);
+  const chunks = [];
+  const firstChunk = parts[0]?.trim();
+  if (firstChunk) {
+    chunks.push(firstChunk);
+  }
+  for (let i = 1; i < parts.length; i += 2) {
+    const dateStr = parts[i];
+    const chunk = parts[i + 1]?.trim();
+    if (!chunk) continue;
+    const boundaryDate = new Date(dateStr);
+    if (isNaN(boundaryDate.getTime())) continue;
+    if (boundaryDate <= asOf) {
+      chunks.push(chunk);
+    }
+  }
+  return chunks.join("\n\n");
+}
+
 exports.OBSERVATIONAL_MEMORY_DEFAULTS = OBSERVATIONAL_MEMORY_DEFAULTS;
 exports.OBSERVATION_CONTEXT_INSTRUCTIONS = OBSERVATION_CONTEXT_INSTRUCTIONS;
 exports.OBSERVATION_CONTEXT_PROMPT = OBSERVATION_CONTEXT_PROMPT;
@@ -6986,8 +7123,9 @@ exports.buildObserverPrompt = buildObserverPrompt;
 exports.buildObserverSystemPrompt = buildObserverSystemPrompt;
 exports.extractCurrentTask = extractCurrentTask;
 exports.formatMessagesForObserver = formatMessagesForObserver;
+exports.getObservationsAsOf = getObservationsAsOf;
 exports.hasCurrentTaskSection = hasCurrentTaskSection;
 exports.optimizeObservationsForContext = optimizeObservationsForContext;
 exports.parseObserverOutput = parseObserverOutput;
-//# sourceMappingURL=chunk-YPFNHFT6.cjs.map
-//# sourceMappingURL=chunk-YPFNHFT6.cjs.map
+//# sourceMappingURL=chunk-LGCREJMO.cjs.map
+//# sourceMappingURL=chunk-LGCREJMO.cjs.map