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

package/dist/{chunk-5HE6DK63.cjs → chunk-WZKTIB4U.cjs}

@@ -2807,6 +2807,18 @@ var ObservationStep = class {
   get prepared() {
     return this._prepared;
   }
+  /**
+   * Serialize to a minimal, acyclic snapshot.
+   *
+   * The `turn` back-reference exists only so a step can read context off its parent turn at
+   * runtime. It closes the `ObservationTurn._currentStep -> ObservationStep.turn` cycle, so
+   * serializing it throws "Converting circular structure to JSON" (e.g. when a turn is stashed
+   * in processor state that flows into a processor-workflow snapshot). The parent turn fully
+   * owns the step, so omitting the back-reference is lossless.
+   */
+  toJSON() {
+    return { stepNumber: this.stepNumber, prepared: this._prepared };
+  }
   /** Step context from prepare(). Throws if prepare() hasn't been called. */
   get context() {
     if (!this._context) throw new Error("Step not prepared yet \u2014 call prepare() first");
@@ -3270,6 +3282,33 @@ var ObservationTurn = class {
     }
     return this._context?.otherThreadsContext;
   }
+  /**
+   * Serialize to a minimal, acyclic snapshot of the turn's identity and lifecycle.
+   *
+   * `ObservationTurn` is a request-scoped runtime orchestration object: it holds live
+   * references (the `ObservationalMemory` engine, the `MessageList`, the stream writer, the
+   * memory provider, lifecycle hooks) and a back-reference to its current `ObservationStep`,
+   * which points back at the turn — a cycle. None of that is persistable state. The turn is
+   * stashed in the shared processor-state map (`state.__omTurn`) only so the input and output
+   * OM processor instances can reach the *live* object within a single request; that map is
+   * also threaded into processor workflows, whose snapshots the storage layer serializes with
+   * `JSON.stringify`. Without this projection, that serialization throws "Converting circular
+   * structure to JSON" via `_currentStep` <-> `turn`.
+   *
+   * The projection is lossless: the dropped fields are live runtime objects that cannot and
+   * should not round-trip through storage, and OM never reads the turn back from a snapshot —
+   * it always reads the live `__omTurn` from the in-memory map and re-establishes a fresh turn
+   * when a deserialized `MessageList` no longer matches (see the processor's turn handling).
+   */
+  toJSON() {
+    return {
+      threadId: this.threadId,
+      resourceId: this.resourceId,
+      started: this._started,
+      ended: this._ended,
+      currentStepNumber: this._currentStep?.stepNumber
+    };
+  }
 };
 
 // src/processors/observational-memory/anchor-ids.ts
@@ -24584,7 +24623,7 @@ ${workingMemory}`;
         "Observational memory requires @mastra/core support for request-response-id-rotation. Please bump @mastra/core to a newer version."
       );
     }
-    const { ObservationalMemory: OMClass } = await import('./observational-memory-LEIZSPQ5.cjs');
+    const { ObservationalMemory: OMClass } = await import('./observational-memory-HZP3D5IO.cjs');
     const onIndexObservations = this.hasRetrievalSearch(omConfig.retrieval) ? async (observation) => {
       await this.indexObservation(observation);
     } : void 0;
@@ -25632,7 +25671,7 @@ Notes:
     if (!effectiveConfig) return null;
     const engine = await this.omEngine;
     if (!engine) return null;
-    const { ObservationalMemoryProcessor: ObservationalMemoryProcessor2 } = await import('./observational-memory-LEIZSPQ5.cjs');
+    const { ObservationalMemoryProcessor: ObservationalMemoryProcessor2 } = await import('./observational-memory-HZP3D5IO.cjs');
     return new ObservationalMemoryProcessor2(engine, this, {
       temporalMarkers: effectiveConfig.temporalMarkers
     });
@@ -30295,6 +30334,9 @@ async function insertTemporalGapMarkers({
 }
 
 // src/processors/observational-memory/processor.ts
+function asLiveTurn(value) {
+  return value && typeof value.end === "function" ? value : void 0;
+}
 function getOmObservabilityContext(args) {
   if (!args.tracing || !args.tracingContext || !args.loggerVNext || !args.metrics) {
     return void 0;
@@ -30412,7 +30454,7 @@ var ObservationalMemoryProcessor = class {
         });
         return messageList;
       }
-      const activeTurn = state.__omTurn ?? this.turn;
+      const activeTurn = asLiveTurn(state.__omTurn) ?? this.turn;
       if (activeTurn && activeTurn.messageList !== messageList) {
         await activeTurn.end().catch(() => {
         });
@@ -30529,7 +30571,7 @@ var ObservationalMemoryProcessor = class {
     return this.engine.getTokenCounter().runWithModelContext(state.__omActorModelContext, async () => {
       const memoryContext = memory.parseMemoryRequestContext(requestContext);
       if (memoryContext?.memoryConfig?.readOnly) return messageList;
-      const turn = state.__omTurn ?? this.turn;
+      const turn = asLiveTurn(state.__omTurn) ?? this.turn;
       if (turn) {
         await turn.end();
         this.turn = void 0;
@@ -30625,5 +30667,5 @@ exports.stripEphemeralAnchorIds = stripEphemeralAnchorIds;
 exports.stripObservationGroups = stripObservationGroups;
 exports.summarizeConversation = summarizeConversation;
 exports.wrapInObservationGroup = wrapInObservationGroup;
-//# sourceMappingURL=chunk-5HE6DK63.cjs.map
-//# sourceMappingURL=chunk-5HE6DK63.cjs.map
+//# sourceMappingURL=chunk-WZKTIB4U.cjs.map
+//# sourceMappingURL=chunk-WZKTIB4U.cjs.map