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

package/dist/{chunk-2QSOQQPM.js → chunk-SKRONGCV.js}

@@ -11,6 +11,7 @@ import { estimateTokenCount } from 'tokenx';
 import { Agent } from '@mastra/core/agent';
 import { AsyncLocalStorage } from 'async_hooks';
 import imageSize from 'image-size';
+import { inspect } from 'util';
 
 var OM_DEBUG_LOG = process.env.OM_DEBUG ? join(process.cwd(), "om-debug.log") : null;
 function omDebug(msg) {
@@ -1939,7 +1940,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);
           }
@@ -2086,12 +2097,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;
@@ -2105,6 +2110,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");
@@ -2167,7 +2185,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");
@@ -2178,22 +2196,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 };
   }
   /**
@@ -7716,7 +7718,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";
@@ -7732,6 +7740,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()) };
@@ -7739,6 +7748,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: 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({
@@ -7794,60 +7884,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()
-    });
-    writeFileSync(join(captureDir, "input.json"), `${JSON.stringify(inputPayload, null, 2)}
-`);
-    writeFileSync(join(captureDir, "pre-state.json"), `${JSON.stringify(preStatePayload, null, 2)}
-`);
-    writeFileSync(join(captureDir, "output.json"), `${JSON.stringify(outputPayload, null, 2)}
+    ];
+    const captureErrors = [];
+    for (const payload of payloads) {
+      const serialized = safeCaptureJsonOrError(payload.data);
+      if (serialized.ok) {
+        writeFileSync(join(captureDir, payload.fileName), `${JSON.stringify(serialized.value, null, 2)}
 `);
-    writeFileSync(join(captureDir, "post-state.json"), `${JSON.stringify(postStatePayload, null, 2)}
+        continue;
+      }
+      captureErrors.push({ fileName: payload.fileName, error: serialized.error });
+      writeFileSync(
+        join(captureDir, payload.fileName),
+        `${JSON.stringify({ __captureError: serialized.error }, null, 2)}
+`
+      );
+    }
+    if (captureErrors.length > 0) {
+      writeFileSync(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)}`);
@@ -7870,7 +7988,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}`
@@ -7898,7 +8026,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);
@@ -8033,5 +8168,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-2QSOQQPM.js.map
-//# sourceMappingURL=chunk-2QSOQQPM.js.map
+//# sourceMappingURL=chunk-SKRONGCV.js.map
+//# sourceMappingURL=chunk-SKRONGCV.js.map