@mastra/memory 1.10.1-alpha.1 → 1.10.1-alpha.3

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @mastra/memory
 
+## 1.10.1-alpha.3
+
+### Patch Changes
+
+- Fixed OM repro capture so recordings keep writing usable artifacts even when live state contains circular values. ([#14744](https://github.com/mastra-ai/mastra/pull/14744))
+
+- Fixed observational memory response ID rotation at buffered chunk boundaries so assistant output continues in a fresh message slot. ([#14745](https://github.com/mastra-ai/mastra/pull/14745))
+
+- Updated dependencies [[`dc9fc19`](https://github.com/mastra-ai/mastra/commit/dc9fc19da4437f6b508cc355f346a8856746a76b), [`260fe12`](https://github.com/mastra-ai/mastra/commit/260fe1295fe7354e39d6def2775e0797a7a277f0)]:
+  - @mastra/core@1.18.0-alpha.1
+
+## 1.10.1-alpha.2
+
+### Patch Changes
+
+- The internal architecture of observational memory has been refactored. The public API and behavior remain unchanged. ([#14453](https://github.com/mastra-ai/mastra/pull/14453))
+
+- Improved observational memory continuation prompts to reduce leaked context-management language in long conversations. ([#14650](https://github.com/mastra-ai/mastra/pull/14650))
+
+- Updated dependencies [[`dc514a8`](https://github.com/mastra-ai/mastra/commit/dc514a83dba5f719172dddfd2c7b858e4943d067), [`404fea1`](https://github.com/mastra-ai/mastra/commit/404fea13042181f0b0c73a101392ac87c79ceae2), [`ebf5047`](https://github.com/mastra-ai/mastra/commit/ebf5047e825c38a1a356f10b214c1d4260dfcd8d), [`675f15b`](https://github.com/mastra-ai/mastra/commit/675f15b7eaeea649158d228ea635be40480c584d), [`b174c63`](https://github.com/mastra-ai/mastra/commit/b174c63a093108d4e53b9bc89a078d9f66202b3f), [`eef7cb2`](https://github.com/mastra-ai/mastra/commit/eef7cb2abe7ef15951e2fdf792a5095c6c643333), [`e8a5b0b`](https://github.com/mastra-ai/mastra/commit/e8a5b0b9bc94d12dee4150095512ca27a288d778)]:
+  - @mastra/core@1.18.0-alpha.0
+
 ## 1.10.1-alpha.1
 
 ### Patch Changes

package/dist/{chunk-NS47X3OB.cjs → chunk-DTAZSLVU.cjs}

@@ -13,6 +13,7 @@ var tokenx = require('tokenx');
 var agent = require('@mastra/core/agent');
 var async_hooks = require('async_hooks');
 var imageSize = require('image-size');
+var util = require('util');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -1946,7 +1947,17 @@ var ObservationStep = class {
         writer: this.turn.writer,
         requestContext: this.turn.requestContext,
         beforeBuffer: async (candidates) => {
+          if (candidates.length === 0) {
+            return;
+          }
           om.sealMessagesForBuffering(candidates);
+          try {
+            await this.turn.hooks?.onBufferChunkSealed?.();
+          } catch (error) {
+            omDebug(
+              `[OM:buffer] onBufferChunkSealed hook failed: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
           if (this.turn.memory) {
             await this.turn.memory.persistMessages(candidates);
           }
@@ -2093,12 +2104,6 @@ var ObservationStep = class {
 
 // src/processors/observational-memory/observation-turn/turn.ts
 var ObservationTurn = class {
-  constructor(om, threadId, resourceId, messageList) {
-    this.om = om;
-    this.threadId = threadId;
-    this.resourceId = resourceId;
-    this.messageList = messageList;
-  }
   _record;
   _context;
   _currentStep;
@@ -2112,6 +2117,19 @@ var ObservationTurn = class {
   writer;
   /** Optional request context for observation calls. */
   requestContext;
+  /** Optional processor-provided hooks for turn/step lifecycle integration. */
+  hooks;
+  constructor(opts) {
+    this.om = opts.om;
+    this.threadId = opts.threadId;
+    this.resourceId = opts.resourceId;
+    this.messageList = opts.messageList;
+    this.hooks = opts.hooks;
+  }
+  om;
+  threadId;
+  resourceId;
+  messageList;
   /** The current cached record. Refreshed after mutations (activate/observe/reflect). */
   get record() {
     if (!this._record) throw new Error("Turn not started \u2014 call start() first");
@@ -2174,7 +2192,7 @@ var ObservationTurn = class {
     return this._currentStep;
   }
   /**
-   * Finalize the turn: save any remaining messages, await in-flight buffering, return final state.
+   * Finalize the turn: save any remaining messages and return the latest record state.
    */
   async end() {
     if (this._ended) throw new Error("Turn already ended");
@@ -2185,22 +2203,6 @@ var ObservationTurn = class {
     if (unsavedMessages.length > 0) {
       await this.om.persistMessages(unsavedMessages, this.threadId, this.resourceId);
     }
-    await this.om.waitForBuffering(this.threadId, this.resourceId);
-    const status = await this.om.getStatus({
-      threadId: this.threadId,
-      resourceId: this.resourceId,
-      messages: this.messageList.get.all.db()
-    });
-    if (status.shouldObserve) {
-      await this.om.observe({
-        threadId: this.threadId,
-        resourceId: this.resourceId,
-        messages: this.messageList.get.all.db(),
-        requestContext: this.requestContext,
-        writer: this.writer
-      });
-    }
-    await this.refreshRecord();
     return { record: this._record };
   }
   /**
@@ -7723,7 +7725,13 @@ ${grouped}` : grouped;
    * ```
    */
   beginTurn(opts) {
-    return new ObservationTurn(this, opts.threadId, opts.resourceId, opts.messageList);
+    return new ObservationTurn({
+      om: this,
+      threadId: opts.threadId,
+      resourceId: opts.resourceId,
+      messageList: opts.messageList,
+      hooks: opts.hooks
+    });
   }
 };
 var OM_REPRO_CAPTURE_DIR = process.env.OM_REPRO_CAPTURE_DIR ?? ".mastra-om-repro";
@@ -7739,6 +7747,7 @@ function safeCaptureJson(value) {
     JSON.stringify(value, (_key, current) => {
       if (typeof current === "bigint") return current.toString();
       if (typeof current === "function") return "[function]";
+      if (typeof current === "symbol") return current.toString();
       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()) };
@@ -7746,6 +7755,87 @@ function safeCaptureJson(value) {
     })
   );
 }
+function safeCaptureJsonOrError(value) {
+  try {
+    return { ok: true, value: safeCaptureJson(value) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: safeCaptureJson({
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        inspected: util.inspect(value, { depth: 3, maxArrayLength: 20, breakLength: 120 })
+      })
+    };
+  }
+}
+function formatCaptureDate(value) {
+  if (!value) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  try {
+    return new Date(value).toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function summarizeOmTurn(value) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const turn = value;
+  return {
+    __type: "ObservationTurn",
+    threadId: turn.threadId,
+    resourceId: turn.resourceId,
+    started: turn._started,
+    ended: turn._ended,
+    generationCountAtStart: turn._generationCountAtStart,
+    record: turn._record ? {
+      id: turn._record.id,
+      scope: turn._record.scope,
+      threadId: turn._record.threadId,
+      resourceId: turn._record.resourceId,
+      createdAt: formatCaptureDate(turn._record.createdAt),
+      updatedAt: formatCaptureDate(turn._record.updatedAt),
+      lastObservedAt: formatCaptureDate(turn._record.lastObservedAt),
+      generationCount: turn._record.generationCount,
+      observationTokenCount: turn._record.observationTokenCount,
+      pendingMessageTokens: turn._record.pendingMessageTokens,
+      isBufferingObservation: turn._record.isBufferingObservation,
+      isBufferingReflection: turn._record.isBufferingReflection
+    } : void 0,
+    context: turn._context ? {
+      messageCount: Array.isArray(turn._context.messages) ? turn._context.messages.length : void 0,
+      hasSystemMessage: Array.isArray(turn._context.systemMessage) ? turn._context.systemMessage.length > 0 : Boolean(turn._context.systemMessage),
+      continuationId: turn._context.continuation?.id,
+      hasOtherThreadsContext: Boolean(turn._context.otherThreadsContext),
+      recordId: turn._context.record?.id
+    } : void 0,
+    currentStep: turn._currentStep ? {
+      stepNumber: turn._currentStep.stepNumber,
+      prepared: turn._currentStep._prepared,
+      context: turn._currentStep._context ? {
+        activated: turn._currentStep._context.activated,
+        observed: turn._currentStep._context.observed,
+        buffered: turn._currentStep._context.buffered,
+        reflected: turn._currentStep._context.reflected,
+        didThresholdCleanup: turn._currentStep._context.didThresholdCleanup,
+        messageCount: Array.isArray(turn._currentStep._context.messages) ? turn._currentStep._context.messages.length : void 0,
+        systemMessageCount: Array.isArray(turn._currentStep._context.systemMessage) ? turn._currentStep._context.systemMessage.length : void 0
+      } : void 0
+    } : void 0
+  };
+}
+function sanitizeCaptureState(rawState) {
+  return Object.fromEntries(
+    Object.entries(rawState).map(([key, value]) => {
+      if (key === "__omTurn") {
+        return [key, summarizeOmTurn(value)];
+      }
+      return [key, value];
+    })
+  );
+}
 function buildReproMessageFingerprint(message) {
   const createdAt = message.createdAt instanceof Date ? message.createdAt.toISOString() : message.createdAt ? new Date(message.createdAt).toISOString() : "";
   return JSON.stringify({
@@ -7801,60 +7891,88 @@ function writeProcessInputStepReproCapture(params) {
     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 sanitizedState = sanitizeCaptureState(rawState);
+    const payloads = [
+      {
+        fileName: "input.json",
+        data: {
+          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: sanitizedState,
+          args: {
+            messages: params.args.messages,
+            steps: params.args.steps,
+            systemMessages: params.args.systemMessages,
+            retryCount: params.args.retryCount,
+            toolChoice: params.args.toolChoice,
+            activeTools: params.args.activeTools,
+            modelSettings: params.args.modelSettings,
+            structuredOutput: params.args.structuredOutput
+          }
+        }
+      },
+      {
+        fileName: "pre-state.json",
+        data: {
+          record: params.preRecord,
+          bufferedChunks: params.preBufferedChunks,
+          contextTokenCount: params.preContextTokenCount,
+          messages: params.preMessages,
+          messageList: params.preSerializedMessageList
+        }
+      },
+      {
+        fileName: "output.json",
+        data: {
+          details: params.details,
+          messageDiff: {
+            removedMessageIds,
+            addedMessageIds,
+            idRemap
+          }
+        }
+      },
+      {
+        fileName: "post-state.json",
+        data: {
+          record: params.postRecord,
+          bufferedChunks: params.postBufferedChunks,
+          contextTokenCount: params.postContextTokenCount,
+          messageCount: contextMessages.length,
+          messageIds: contextMessages.map((message) => message.id),
+          messages: contextMessages,
+          messageList: params.messageList.serialize()
+        }
       }
-    });
-    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()
-    });
-    fs.writeFileSync(path.join(captureDir, "input.json"), `${JSON.stringify(inputPayload, null, 2)}
-`);
-    fs.writeFileSync(path.join(captureDir, "pre-state.json"), `${JSON.stringify(preStatePayload, null, 2)}
-`);
-    fs.writeFileSync(path.join(captureDir, "output.json"), `${JSON.stringify(outputPayload, null, 2)}
+    ];
+    const captureErrors = [];
+    for (const payload of payloads) {
+      const serialized = safeCaptureJsonOrError(payload.data);
+      if (serialized.ok) {
+        fs.writeFileSync(path.join(captureDir, payload.fileName), `${JSON.stringify(serialized.value, null, 2)}
 `);
-    fs.writeFileSync(path.join(captureDir, "post-state.json"), `${JSON.stringify(postStatePayload, null, 2)}
+        continue;
+      }
+      captureErrors.push({ fileName: payload.fileName, error: serialized.error });
+      fs.writeFileSync(
+        path.join(captureDir, payload.fileName),
+        `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
+`
+      );
+    }
+    if (captureErrors.length > 0) {
+      fs.writeFileSync(path.join(captureDir, "capture-error.json"), `${JSON.stringify(captureErrors, null, 2)}
 `);
+      params.debug?.(
+        `[OM:repro-capture] wrote processInputStep capture with ${captureErrors.length} serialization error(s) to ${captureDir}`
+      );
+      return;
+    }
     params.debug?.(`[OM:repro-capture] wrote processInputStep capture to ${captureDir}`);
   } catch (error) {
     params.debug?.(`[OM:repro-capture] failed to write processInputStep capture: ${String(error)}`);
@@ -7877,7 +7995,17 @@ var ObservationalMemoryProcessor = class {
   }
   // ─── Processor lifecycle hooks ──────────────────────────────────────────
   async processInputStep(args) {
-    const { messageList, requestContext, stepNumber, state: _state, writer, model, abortSignal, abort } = args;
+    const {
+      messageList,
+      requestContext,
+      stepNumber,
+      state: _state,
+      writer,
+      model,
+      abortSignal,
+      abort,
+      rotateResponseMessageId
+    } = args;
     const state = _state ?? {};
     omDebug(
       `[OM:processInputStep:ENTER] step=${stepNumber}, hasMastraMemory=${!!requestContext?.get("MastraMemory")}, hasMemoryInfo=${!!messageList?.serialize()?.memoryInfo?.threadId}`
@@ -7905,7 +8033,14 @@ var ObservationalMemoryProcessor = class {
           await this.turn.end().catch(() => {
           });
         }
-        this.turn = this.engine.beginTurn({ threadId, resourceId, messageList });
+        this.turn = this.engine.beginTurn({
+          threadId,
+          resourceId,
+          messageList,
+          hooks: {
+            onBufferChunkSealed: rotateResponseMessageId
+          }
+        });
         this.turn.writer = writer;
         this.turn.requestContext = requestContext;
         await this.turn.start(this.memory);
@@ -8065,5 +8200,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.truncateStringByTokens = truncateStringByTokens;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-NS47X3OB.cjs.map
-//# sourceMappingURL=chunk-NS47X3OB.cjs.map
+//# sourceMappingURL=chunk-DTAZSLVU.cjs.map
+//# sourceMappingURL=chunk-DTAZSLVU.cjs.map