@mastra/memory 1.8.3-alpha.0 → 1.8.3-alpha.2

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @mastra/memory
 
+## 1.8.3-alpha.2
+
+### Patch Changes
+
+- Fixed working memory tool description to accurately reflect merge behavior. The previous description incorrectly stated "Set a field to null to remove it" but null values are stripped by validation before reaching the merge logic. The updated description clarifies: omit fields to preserve existing data, and pass complete arrays or omit them since arrays are replaced entirely. ([#14424](https://github.com/mastra-ai/mastra/pull/14424))
+
+- Updated dependencies [[`8b4ce84`](https://github.com/mastra-ai/mastra/commit/8b4ce84aed0808b9805cc4fd7147c1f8a2ef7a36), [`8d4cfe6`](https://github.com/mastra-ai/mastra/commit/8d4cfe6b9a7157d3876206227ec9f04cde6dbc4a), [`68a019d`](https://github.com/mastra-ai/mastra/commit/68a019d30d22251ddd628a2947d60215c03c350a), [`68a019d`](https://github.com/mastra-ai/mastra/commit/68a019d30d22251ddd628a2947d60215c03c350a)]:
+  - @mastra/core@1.14.0-alpha.3
+
+## 1.8.3-alpha.1
+
+### Patch Changes
+
+- Fixed observational memory triggering observation while provider-executed tool calls are still pending, which could split messages and cause errors on follow-up turns. ([#14282](https://github.com/mastra-ai/mastra/pull/14282))
+
+- Limit oversized observational-memory tool results before they reach the observer. ([#14344](https://github.com/mastra-ai/mastra/pull/14344))
+
+  This strips large `encryptedContent` blobs and truncates remaining tool result payloads to keep observer prompts and token estimates aligned with what the model actually sees.
+
+- Improved observational memory cache stability by splitting persisted observations into separate prompt chunks using dated message boundary delimiters. ([#14367](https://github.com/mastra-ai/mastra/pull/14367))
+
+  Added `getObservationsAsOf()` utility to retrieve the observations that were active at a specific point in time. This enables filtering observation history by message creation date.
+
+  ```ts
+  import { getObservationsAsOf } from '@mastra/memory';
+
+  // Get observations that existed when a specific message was created
+  const observations = getObservationsAsOf(record.activeObservations, message.createdAt);
+  ```
+
+- Updated dependencies [[`4444280`](https://github.com/mastra-ai/mastra/commit/444428094253e916ec077e66284e685fde67021e), [`dbb879a`](https://github.com/mastra-ai/mastra/commit/dbb879af0b809c668e9b3a9d8bac97d806caa267), [`8de3555`](https://github.com/mastra-ai/mastra/commit/8de355572c6fd838f863a3e7e6fe24d0947b774f)]:
+  - @mastra/core@1.14.0-alpha.2
+
 ## 1.8.3-alpha.0
 
 ### Patch Changes

package/dist/{chunk-SUU4IAZJ.js → chunk-4KPXPQX3.js}

@@ -6,10 +6,10 @@ 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 { estimateTokenCount } from 'tokenx';
 import { createHash, randomUUID } from 'crypto';
 import { AsyncLocalStorage } from 'async_hooks';
 import imageSize from 'image-size';
-import { estimateTokenCount } from 'tokenx';
 
 // src/processors/observational-memory/observational-memory.ts
 
@@ -300,6 +300,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 = 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 - 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 = 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
@@ -774,6 +865,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})` : "";
@@ -787,7 +879,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)}`;
         }
@@ -828,12 +924,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" });
@@ -854,7 +950,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 = [
     {
@@ -872,7 +968,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" });
@@ -2516,17 +2612,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();
@@ -2765,19 +2851,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;
           }
         }
@@ -2893,6 +2973,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;
@@ -4339,38 +4427,51 @@ ${unreflectedContent}` : bufferedReflection;
     if (currentDate) {
       optimized = addRelativeTimeToObservations(optimized, currentDate);
     }
-    let content = `
-${OBSERVATION_CONTEXT_PROMPT}
+    const messages = [`${OBSERVATION_CONTEXT_PROMPT}
 
-<observations>
-${optimized}
-</observations>
-
-${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 content;
+    return messages;
+  }
+  splitObservationContextChunks(observations) {
+    const trimmed = observations.trim();
+    if (!trimmed) {
+      return [];
+    }
+    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
@@ -4808,7 +4909,7 @@ ${suggestedResponse}
     if (!record.activeObservations) {
       return;
     }
-    const observationSystemMessage = this.formatObservationsForContext(
+    const observationSystemMessages = this.formatObservationsForContext(
       record.activeObservations,
       currentTask,
       suggestedResponse,
@@ -4816,7 +4917,7 @@ ${suggestedResponse}
       currentDate
     );
     messageList.clearSystemMessages("observational-memory");
-    messageList.addSystem(observationSystemMessage, "observational-memory");
+    messageList.addSystem(observationSystemMessages, "observational-memory");
     const continuationMessage = {
       id: `om-continuation`,
       role: "user",
@@ -5092,12 +5193,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,
@@ -5111,9 +5220,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,
@@ -5128,7 +5237,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,
@@ -5486,16 +5595,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];
@@ -5530,9 +5637,7 @@ ${threadClose}`;
         }
       }
     }
-    return `${existingObservations}
-
-${newThreadSection}`;
+    return `${existingObservations}${_ObservationalMemory.createMessageBoundary(lastObservedAt)}${newThreadSection}`;
   }
   /**
    * Sort threads by their oldest unobserved message.
@@ -5615,19 +5720,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])];
@@ -6521,9 +6629,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 = setThreadOMMetadata(thread.metadata, {
@@ -6968,6 +7081,30 @@ ${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-SUU4IAZJ.js.map
-//# sourceMappingURL=chunk-SUU4IAZJ.js.map
+// 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");
+}
+
+export { OBSERVATIONAL_MEMORY_DEFAULTS, OBSERVATION_CONTEXT_INSTRUCTIONS, OBSERVATION_CONTEXT_PROMPT, OBSERVATION_CONTINUATION_HINT, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, TokenCounter, buildObserverPrompt, buildObserverSystemPrompt, extractCurrentTask, formatMessagesForObserver, getObservationsAsOf, hasCurrentTaskSection, optimizeObservationsForContext, parseObserverOutput };
+//# sourceMappingURL=chunk-4KPXPQX3.js.map
+//# sourceMappingURL=chunk-4KPXPQX3.js.map