@mastra/memory 1.13.0 → 1.13.1-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @mastra/memory
 
+## 1.13.1-alpha.0
+
+### Patch Changes
+
+- Fixed thread titles not persisting when generated during async buffered observation. Titles now update immediately when the observer produces them, rather than being lost until activation. ([#14992](https://github.com/mastra-ai/mastra/pull/14992))
+
+- Updated dependencies [[`cb15509`](https://github.com/mastra-ai/mastra/commit/cb15509b58f6a83e11b765c945082afc027db972), [`80c5668`](https://github.com/mastra-ai/mastra/commit/80c5668e365470d3a96d3e953868fd7a643ff67c), [`3d478c1`](https://github.com/mastra-ai/mastra/commit/3d478c1e13f17b80f330ac49d7aa42ef929b93ff), [`6039f17`](https://github.com/mastra-ai/mastra/commit/6039f176f9c457304825ff1df8c83b8e457376c0), [`06b928d`](https://github.com/mastra-ai/mastra/commit/06b928dfc2f5630d023467476cc5919dfa858d0a), [`6a8d984`](https://github.com/mastra-ai/mastra/commit/6a8d9841f2933456ee1598099f488d742b600054)]:
+  - @mastra/core@1.22.0-alpha.2
+
 ## 1.13.0
 
 ### Minor Changes

package/dist/{chunk-O3KNDDJV.cjs → chunk-HNVSYZRA.cjs}

@@ -1406,8 +1406,6 @@ var SyncObservationStrategy = class extends ObservationStrategy {
     }
   }
 };
-
-// src/processors/observational-memory/observation-strategies/async-buffer.ts
 var AsyncBufferObservationStrategy = class extends ObservationStrategy {
   startedAt;
   cycleId;
@@ -1498,6 +1496,30 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
       lastBufferedAtTime: processed.lastObservedAt
     });
     await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt);
+    const newTitle = processed.threadTitle?.trim();
+    if (newTitle && newTitle.length >= 3) {
+      const thread = await this.storage.getThreadById({ threadId });
+      if (thread) {
+        const oldTitle = thread.title?.trim();
+        if (newTitle !== oldTitle) {
+          const newMetadata = memory.setThreadOMMetadata(thread.metadata, {
+            threadTitle: processed.threadTitle
+          });
+          await this.storage.updateThread({
+            id: threadId,
+            title: newTitle,
+            metadata: newMetadata
+          });
+          const marker = createThreadUpdateMarker({
+            cycleId: this.cycleId,
+            threadId,
+            oldTitle,
+            newTitle
+          });
+          await this.streamMarker(marker);
+        }
+      }
+    }
   }
   async emitEndMarkers(_cycleId, processed) {
     if (!processed.observations || !this.opts.writer) return;
@@ -1952,6 +1974,7 @@ var ObservationStep = class {
     let buffered = false;
     let reflected = false;
     let didThresholdCleanup = false;
+    let observerExchange;
     if (this.stepNumber === 0) {
       const step0Messages = messageList.get.all.db();
       const activation = await om.activate({
@@ -2050,6 +2073,7 @@ var ObservationStep = class {
       if (statusSnapshot.shouldObserve && !hasIncompleteToolCalls) {
         const preObsGeneration = this.turn.record.generationCount;
         const obsResult = await this.runThresholdObservation();
+        observerExchange = obsResult.observerExchange;
         if (obsResult.succeeded) {
           observed = true;
           didThresholdCleanup = true;
@@ -2103,6 +2127,7 @@ var ObservationStep = class {
     }
     this._context = {
       systemMessage,
+      observerExchange,
       activated,
       observed,
       buffered,
@@ -2170,7 +2195,11 @@ var ObservationStep = class {
       writer: this.turn.writer,
       observabilityContext: this.turn.observabilityContext
     });
-    return { succeeded: obsResult.observed, record: obsResult.record };
+    return {
+      succeeded: obsResult.observed,
+      record: obsResult.record,
+      observerExchange: om.observer.lastExchange
+    };
   }
 };
 
@@ -3496,6 +3525,8 @@ var ObserverRunner = class {
   observedMessageIds;
   resolveModel;
   tokenCounter;
+  /** Captured prompt/response from the last observer call (for repro capture). */
+  lastExchange;
   constructor(opts) {
     this.observationConfig = opts.observationConfig;
     this.observedMessageIds = opts.observedMessageIds;
@@ -3571,15 +3602,38 @@ var ObserverRunner = class {
     };
     let result = await doGenerate();
     let parsed = parseObserverOutput(result.text);
+    let retriedDueToDegenerate = false;
     if (parsed.degenerate) {
       omDebug(`[OM:callObserver] degenerate repetition detected, retrying once`);
       result = await doGenerate();
       parsed = parseObserverOutput(result.text);
+      retriedDueToDegenerate = true;
       if (parsed.degenerate) {
         omDebug(`[OM:callObserver] degenerate repetition on retry, failing`);
         throw new Error("Observer produced degenerate output after retry");
       }
     }
+    const systemPrompt = buildObserverSystemPrompt(
+      false,
+      this.observationConfig.instruction,
+      this.observationConfig.threadTitle
+    );
+    this.lastExchange = {
+      systemPrompt,
+      observerMessages,
+      rawOutput: result.text,
+      parsedResult: {
+        observations: parsed.observations,
+        currentTask: parsed.currentTask,
+        suggestedContinuation: parsed.suggestedContinuation,
+        threadTitle: parsed.threadTitle,
+        degenerate: parsed.degenerate
+      },
+      model: String(resolvedModel.model),
+      inputTokens,
+      isMultiThread: false,
+      retriedDueToDegenerate
+    };
     const usage = result.totalUsage ?? result.usage;
     return {
       observations: parsed.observations,
@@ -3646,15 +3700,36 @@ var ObserverRunner = class {
     };
     let result = await doGenerate();
     let parsed = parseMultiThreadObserverOutput(result.text);
+    let retriedDueToDegenerate = false;
     if (parsed.degenerate) {
       omDebug(`[OM:callMultiThreadObserver] degenerate repetition detected, retrying once`);
       result = await doGenerate();
       parsed = parseMultiThreadObserverOutput(result.text);
+      retriedDueToDegenerate = true;
       if (parsed.degenerate) {
         omDebug(`[OM:callMultiThreadObserver] degenerate repetition on retry, failing`);
         throw new Error("Multi-thread observer produced degenerate output after retry");
       }
     }
+    const systemPrompt = buildObserverSystemPrompt(
+      true,
+      this.observationConfig.instruction,
+      this.observationConfig.threadTitle
+    );
+    this.lastExchange = {
+      systemPrompt,
+      observerMessages,
+      rawOutput: result.text,
+      parsedResult: {
+        observations: Array.from(parsed.threads.values()).map((t) => t.observations).join("\n"),
+        threadTitle: Array.from(parsed.threads.values()).map((t) => t.threadTitle).filter(Boolean).join(", "),
+        degenerate: parsed.degenerate
+      },
+      model: String(resolvedModel.model),
+      inputTokens,
+      isMultiThread: true,
+      retriedDueToDegenerate
+    };
     const results = /* @__PURE__ */ new Map();
     for (const [threadId, threadResult] of parsed.threads) {
       results.set(threadId, {
@@ -7803,13 +7878,18 @@ ${grouped}` : grouped;
       const activatedChunks = freshChunks.filter((c) => activationResult.activatedCycleIds.includes(c.cycleId));
       const lastActivated = activatedChunks[activatedChunks.length - 1];
       if (lastActivated) {
+        const chunkThreadTitle = lastActivated.threadTitle;
         const newMetadata = memory.setThreadOMMetadata(thread.metadata, {
           suggestedResponse: lastActivated.suggestedContinuation,
-          currentTask: lastActivated.currentTask
+          currentTask: lastActivated.currentTask,
+          threadTitle: chunkThreadTitle
         });
+        const oldTitle = thread.title?.trim();
+        const newTitle = chunkThreadTitle?.trim();
+        const shouldUpdateThreadTitle = !!newTitle && newTitle.length >= 3 && newTitle !== oldTitle;
         await this.storage.updateThread({
           id: threadId,
-          title: thread.title ?? "",
+          title: shouldUpdateThreadTitle ? newTitle : thread.title ?? "",
           metadata: newMetadata
         });
       }
@@ -8244,6 +8324,20 @@ function writeProcessInputStepReproCapture(params) {
 `
       );
     }
+    if (params.observerExchange) {
+      const serialized = safeCaptureJsonOrError(params.observerExchange);
+      if (serialized.ok) {
+        fs.writeFileSync(path.join(captureDir, "observer-exchange.json"), `${JSON.stringify(serialized.value, null, 2)}
+`);
+      } else {
+        captureErrors.push({ fileName: "observer-exchange.json", error: serialized.error });
+        fs.writeFileSync(
+          path.join(captureDir, "observer-exchange.json"),
+          `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
+`
+        );
+      }
+    }
     if (captureErrors.length > 0) {
       fs.writeFileSync(path.join(captureDir, "capture-error.json"), `${JSON.stringify(captureErrors, null, 2)}
 `);
@@ -8408,7 +8502,8 @@ var ObservationalMemoryProcessor = class {
             postBufferedChunks: [],
             postContextTokenCount: finalTotalPending,
             messageList,
-            details: {}
+            details: {},
+            observerExchange: ctx.observerExchange
           });
         }
       }
@@ -8496,5 +8591,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.truncateStringByTokens = truncateStringByTokens;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-O3KNDDJV.cjs.map
-//# sourceMappingURL=chunk-O3KNDDJV.cjs.map
+//# sourceMappingURL=chunk-HNVSYZRA.cjs.map
+//# sourceMappingURL=chunk-HNVSYZRA.cjs.map