@mastra/memory 1.11.0 → 1.12.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @mastra/memory
 
+## 1.12.0-alpha.1
+
+### Minor Changes
+
+- Added more forgiving raw message browsing in the recall tool for agent follow-up calls. ([#14873](https://github.com/mastra-ai/mastra/pull/14873))
+
+  When an agent requests a `partIndex` greater than the highest visible part in a message, recall now returns the first visible part from the next visible message instead of failing. This makes it easier for agents using `recall` to keep browsing raw messages even when they guess the wrong part index.
+
+### Patch Changes
+
+- Fixed synchronous observation error handling in Observational Memory. `observe()` now throws when synchronous (thread/resource-scoped) observation fails, instead of continuing silently with stale observations. Async buffered observation failures remain non-fatal. ([#14843](https://github.com/mastra-ai/mastra/pull/14843))
+
+- Updated dependencies [[`9c57f2f`](https://github.com/mastra-ai/mastra/commit/9c57f2f7241e9f94769aa99fc86c531e8207d0f9), [`5bfc691`](https://github.com/mastra-ai/mastra/commit/5bfc69104c07ba7a9b55c2f8536422c0878b9c57)]:
+  - @mastra/core@1.19.0-alpha.2
+
+## 1.11.1-alpha.0
+
+### Patch Changes
+
+- Fixed reflected observation groups so their metadata stays compact and marks reflection-derived content. ([#14791](https://github.com/mastra-ai/mastra/pull/14791))
+
+- Updated dependencies [[`180aaaf`](https://github.com/mastra-ai/mastra/commit/180aaaf4d0903d33a49bc72de2d40ca69a5bc599)]:
+  - @mastra/core@1.18.1-alpha.0
+
 ## 1.11.0
 
 ### Minor Changes

package/README.md

@@ -1,3 +1,3 @@
 # Mastra Memory
 
-Memory management for Mastra agents. Visit [the docs](https://mastra.ai/docs/agents/agent-memory) for more information.
+Memory management for Mastra agents. Visit [the docs](https://mastra.ai/docs/memory/overview) for more information.

package/dist/{chunk-D4D6ZFBQ.js → chunk-DDQHE4NV.js}

@@ -717,10 +717,10 @@ function stripReflectionGroupMetadata(body) {
 function generateAnchorId() {
   return randomBytes(8).toString("hex");
 }
-function wrapInObservationGroup(observations, range, id = generateAnchorId(), sourceGroupIds) {
+function wrapInObservationGroup(observations, range, id = generateAnchorId(), _sourceGroupIds, kind) {
   const content = observations.trim();
-  const sourceGroupIdsAttr = sourceGroupIds?.length ? ` source-group-ids="${sourceGroupIds.join(",")}"` : "";
-  return `<observation-group id="${id}" range="${range}"${sourceGroupIdsAttr}>
+  const kindAttr = kind ? ` kind="${kind}"` : "";
+  return `<observation-group id="${id}" range="${range}"${kindAttr}>
 ${content}
 </observation-group>`;
 }
@@ -740,8 +740,8 @@ function parseObservationGroups(observations) {
     groups.push({
       id,
       range,
-      content: match[2].trim(),
-      sourceGroupIds: attributes["source-group-ids"]?.split(",").map((part) => part.trim()).filter(Boolean)
+      kind: attributes.kind,
+      content: match[2].trim()
     });
   }
   return groups;
@@ -752,12 +752,22 @@ function stripObservationGroups(observations) {
   }
   return observations.replace(OBSERVATION_GROUP_PATTERN, (_match, _attributes, content) => content.trim()).replace(/\n{3,}/g, "\n\n").trim();
 }
+function getRangeSegments(range) {
+  return range.split(",").map((segment) => segment.trim()).filter(Boolean);
+}
 function combineObservationGroupRanges(groups) {
-  return Array.from(
-    new Set(
-      groups.flatMap((group) => group.range.split(",")).map((range) => range.trim()).filter(Boolean)
-    )
-  ).join(",");
+  const segments = groups.flatMap((group) => getRangeSegments(group.range));
+  if (segments.length === 0) {
+    return "";
+  }
+  const firstSegment = segments[0];
+  const lastSegment = segments[segments.length - 1];
+  const firstStart = firstSegment?.split(":")[0]?.trim();
+  const lastEnd = lastSegment?.split(":").at(-1)?.trim();
+  if (firstStart && lastEnd) {
+    return `${firstStart}:${lastEnd}`;
+  }
+  return Array.from(new Set(segments)).join(",");
 }
 function renderObservationGroupsForReflection(observations) {
   const groups = parseObservationGroups(observations);
@@ -794,15 +804,12 @@ function deriveObservationGroupProvenance(content, groups) {
     });
     const fallbackGroup = groups[Math.min(index, groups.length - 1)];
     const resolvedGroups = matchingGroups.length > 0 ? matchingGroups : fallbackGroup ? [fallbackGroup] : [];
-    const sourceGroupIds = Array.from(
-      new Set(resolvedGroups.flatMap((group) => [group.id, ...group.sourceGroupIds ?? []]))
-    );
     const canonicalGroupId = getCanonicalGroupId(section.heading, index);
     return {
       id: canonicalGroupId,
       range: combineObservationGroupRanges(resolvedGroups),
-      content: section.body,
-      sourceGroupIds
+      kind: "reflection",
+      content: section.body
     };
   });
 }
@@ -817,13 +824,14 @@ function reconcileObservationGroupsFromReflection(content, sourceObservations) {
   }
   const derivedGroups = deriveObservationGroupProvenance(normalizedContent, sourceGroups);
   if (derivedGroups.length > 0) {
-    return derivedGroups.map((group) => wrapInObservationGroup(group.content, group.range, group.id, group.sourceGroupIds)).join("\n\n");
+    return derivedGroups.map((group) => wrapInObservationGroup(group.content, group.range, group.id, void 0, group.kind)).join("\n\n");
   }
   return wrapInObservationGroup(
     normalizedContent,
     combineObservationGroupRanges(sourceGroups),
     generateAnchorId(),
-    Array.from(new Set(sourceGroups.flatMap((group) => [group.id, ...group.sourceGroupIds ?? []])))
+    void 0,
+    "reflection"
   );
 }
 
@@ -935,7 +943,11 @@ var ObservationStrategy = class _ObservationStrategy {
   retrieval;
   /** Select the right strategy based on scope and mode. Wired up by index.ts. */
   static create;
-  /** Run the full observation lifecycle. */
+  /**
+   * Run the full observation lifecycle.
+   * @returns `true` if a full observation cycle completed; `false` if skipped (stale lock) or async-buffer failure was swallowed.
+   * @throws On sync/resource-scoped observer failure after failed markers (same as pre–Option-A contract).
+   */
   async run() {
     const { record, threadId, abortSignal, writer, reflectionHooks, requestContext } = this.opts;
     const cycleId = this.generateCycleId();
@@ -943,7 +955,7 @@ var ObservationStrategy = class _ObservationStrategy {
       if (this.needsLock) {
         const fresh = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
         if (fresh?.lastObservedAt && record.lastObservedAt && fresh.lastObservedAt > record.lastObservedAt) {
-          return;
+          return false;
         }
       }
       const { messages, existingObservations } = await this.prepare();
@@ -964,23 +976,29 @@ var ObservationStrategy = class _ObservationStrategy {
           observabilityContext: this.opts.observabilityContext
         });
       }
+      return true;
     } catch (error) {
       await this.emitFailedMarkers(cycleId, error);
-      const failedMarkerForStorage = {
-        type: "data-om-observation-failed",
-        data: {
-          cycleId,
-          operationType: "observation",
-          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          error: error instanceof Error ? error.message : String(error),
-          recordId: record.id,
-          threadId
-        }
-      };
-      await this.persistMarkerToStorage(failedMarkerForStorage, threadId, this.opts.resourceId).catch(() => {
-      });
-      if (abortSignal?.aborted) throw error;
+      if (!this.rethrowOnFailure) {
+        const failedMarkerForStorage = {
+          type: "data-om-observation-failed",
+          data: {
+            cycleId,
+            operationType: "observation",
+            startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            error: error instanceof Error ? error.message : String(error),
+            recordId: record.id,
+            threadId
+          }
+        };
+        await this.persistMarkerToStorage(failedMarkerForStorage, threadId, this.opts.resourceId).catch(() => {
+        });
+        if (abortSignal?.aborted) throw error;
+        omError("[OM] Observation failed", error);
+        return false;
+      }
       omError("[OM] Observation failed", error);
+      throw error;
     }
   }
   // ── Shared helpers ──────────────────────────────────────────
@@ -1201,6 +1219,9 @@ var SyncObservationStrategy = class extends ObservationStrategy {
   get needsReflection() {
     return true;
   }
+  get rethrowOnFailure() {
+    return true;
+  }
   async prepare() {
     const { record, threadId, messages } = this.opts;
     this.deps.emitDebugEvent({
@@ -1394,6 +1415,9 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
   get needsReflection() {
     return false;
   }
+  get rethrowOnFailure() {
+    return false;
+  }
   generateCycleId() {
     return this.cycleId;
   }
@@ -1530,6 +1554,9 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
   get needsReflection() {
     return true;
   }
+  get rethrowOnFailure() {
+    return true;
+  }
   async prepare() {
     const { record, threadId: currentThreadId, messages: currentThreadMessages } = this.opts;
     const { threads: allThreads } = await this.storage.listThreads({ filter: { resourceId: this.resourceId } });
@@ -3821,11 +3848,10 @@ Aim for a 2/10 detail level. Fewer, more generic observations are better than ma
 };
 function buildReflectorPrompt(observations, manualPrompt, compressionLevel, skipContinuationHints) {
   const level = typeof compressionLevel === "number" ? compressionLevel : compressionLevel ? 1 : 0;
-  const reflectionView = renderObservationGroupsForReflection(observations) ?? observations;
-  const anchoredObservations = injectAnchorIds(reflectionView);
+  const reflectionView = stripObservationGroups(observations);
   let prompt = `## OBSERVATIONS TO REFLECT ON
 
-${anchoredObservations}
+${reflectionView}
 
 ---
 
@@ -7799,7 +7825,7 @@ ${grouped}` : grouped;
       }
       hooks?.onObservationStart?.();
       try {
-        await ObservationStrategy.create(this, {
+        observed = await ObservationStrategy.create(this, {
           record: freshRecord,
           threadId,
           resourceId,
@@ -7809,7 +7835,6 @@ ${grouped}` : grouped;
           writer: opts.writer,
           observabilityContext: opts.observabilityContext
         }).run();
-        observed = true;
       } finally {
         hooks?.onObservationEnd?.();
       }
@@ -8418,5 +8443,5 @@ function getObservationsAsOf(activeObservations, asOf) {
 }
 
 export { ModelByInputTokens, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, ObservationalMemoryProcessor, TokenCounter, buildObserverPrompt, buildObserverSystemPrompt, combineObservationGroupRanges, deriveObservationGroupProvenance, extractCurrentTask, formatMessagesForObserver, formatToolResultForObserver, getObservationsAsOf, hasCurrentTaskSection, injectAnchorIds, optimizeObservationsForContext, parseAnchorId, parseObservationGroups, parseObserverOutput, reconcileObservationGroupsFromReflection, renderObservationGroupsForReflection, resolveToolResultValue, stripEphemeralAnchorIds, stripObservationGroups, truncateStringByTokens, wrapInObservationGroup };
-//# sourceMappingURL=chunk-D4D6ZFBQ.js.map
-//# sourceMappingURL=chunk-D4D6ZFBQ.js.map
+//# sourceMappingURL=chunk-DDQHE4NV.js.map
+//# sourceMappingURL=chunk-DDQHE4NV.js.map