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

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/memory
 
+## 1.23.0-alpha.3
+
+### Patch Changes
+
+- Fixed a "Converting circular structure to JSON" crash when Observational Memory was used with an input or output processor composed as a workflow (the "run guardrails in parallel" pattern). ([#17949](https://github.com/mastra-ai/mastra/pull/17949))
+
+  The circular data reached the processor workflow's snapshot and broke storage: PostgreSQL threw, and LibSQL saved a corrupted snapshot. Observational Memory now keeps its runtime data in a serializable form, so workflow-composed processors work with it and snapshots persist correctly.
+
+- Updated dependencies [[`a5c6337`](https://github.com/mastra-ai/mastra/commit/a5c6337d23c7686c81a32ce62f550f610543a240), [`8b97958`](https://github.com/mastra-ai/mastra/commit/8b979589f9aa59ba67cac565949475f2ffeb4ac3), [`8410541`](https://github.com/mastra-ai/mastra/commit/84105412c60ecd3bb33a9838146f59c4b588228f), [`01b338c`](https://github.com/mastra-ai/mastra/commit/01b338c56271f0219606710e3e8b26dee27ac6c2), [`8b7361d`](https://github.com/mastra-ai/mastra/commit/8b7361d35de68b80d05d30a74e0c69e7218fd612), [`c43f3a9`](https://github.com/mastra-ai/mastra/commit/c43f3a9d1efde99b38789364ba4d0ba670f430e3)]:
+  - @mastra/core@1.51.0-alpha.4
+
 ## 1.23.0-alpha.2
 
 ### Patch Changes

package/dist/{chunk-GHFCSEEP.js → chunk-FNWCP2TI.js}

@@ -2783,6 +2783,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");
@@ -3246,6 +3258,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
@@ -24560,7 +24599,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-HUPMKPOX.js');
+    const { ObservationalMemory: OMClass } = await import('./observational-memory-GAYCVM5R.js');
     const onIndexObservations = this.hasRetrievalSearch(omConfig.retrieval) ? async (observation) => {
       await this.indexObservation(observation);
     } : void 0;
@@ -25608,7 +25647,7 @@ Notes:
     if (!effectiveConfig) return null;
     const engine = await this.omEngine;
     if (!engine) return null;
-    const { ObservationalMemoryProcessor: ObservationalMemoryProcessor2 } = await import('./observational-memory-HUPMKPOX.js');
+    const { ObservationalMemoryProcessor: ObservationalMemoryProcessor2 } = await import('./observational-memory-GAYCVM5R.js');
     return new ObservationalMemoryProcessor2(engine, this, {
       temporalMarkers: effectiveConfig.temporalMarkers
     });
@@ -30271,6 +30310,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;
@@ -30388,7 +30430,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(() => {
         });
@@ -30505,7 +30547,7 @@ var ObservationalMemoryProcessor = class {
     return this.engine.getTokenCounter().runWithModelContext(state.__omActorModelContext, async () => {
       const memoryContext = 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;
@@ -30558,5 +30600,5 @@ function getObservationsAsOf(activeObservations, asOf) {
 }
 
 export { Extractor, Memory, ModelByInputTokens, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, ObservationalMemoryProcessor, SUMMARIZE_THREAD_DEFAULTS, TokenCounter, WorkingMemoryExtractor, buildObserverPrompt, buildObserverSystemPrompt, combineObservationGroupRanges, deepMergeWorkingMemory, deriveObservationGroupProvenance, extractCurrentTask, extractWorkingMemoryContent, extractWorkingMemoryTags, formatMessagesForObserver, getObservationsAsOf, hasCurrentTaskSection, injectAnchorIds, optimizeObservationsForContext, parseAnchorId, parseObservationGroups, parseObserverOutput, reconcileObservationGroupsFromReflection, removeWorkingMemoryTags, renderObservationGroupsForReflection, stripEphemeralAnchorIds, stripObservationGroups, summarizeConversation, wrapInObservationGroup };
-//# sourceMappingURL=chunk-GHFCSEEP.js.map
-//# sourceMappingURL=chunk-GHFCSEEP.js.map
+//# sourceMappingURL=chunk-FNWCP2TI.js.map
+//# sourceMappingURL=chunk-FNWCP2TI.js.map