@mastra/memory 1.28.0-alpha.3 → 1.28.0

package/dist/{src-BTHCV1ov.js → src-BATJenuZ.js}

@@ -24,8 +24,8 @@ import probeImageSizeSync from "probe-image-size/sync.js";
 import { isStandardSchemaWithJSON as isStandardSchemaWithJSON$1, toStandardSchema as toStandardSchema$1 } from "@mastra/core/schema";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
 import { MessageHistory, MessageHistory as MessageHistory$1, SemanticRecall, WorkingMemory } from "@mastra/core/processors";
-import { inspect } from "util";
 import { structuredPatch } from "diff";
+import { inspect } from "util";
 //#region \0rolldown/runtime.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -22415,6 +22415,151 @@ function createWorkingMemoryTool(config, options = {}) {
 	};
 }
 //#endregion
+//#region src/processors/working-memory-state/processor.ts
+/**
+* WorkingMemoryStateProcessor
+*
+* Experimental: delivers working memory to the model as a state signal instead
+* of folding it into the system message. Storage and the `setWorkingMemory`
+* tool are unchanged — this processor only changes the delivery path.
+*
+* Pattern matches `BrowserContextProcessor` in `@mastra/core/browser`:
+* - `stateId` namespaces the state lane on the thread.
+* - `cacheKey` is derived from the rendered payload so dedup is automatic.
+* - `contextWindow.hasSnapshot` re-injection ensures the model still sees the
+*   current snapshot after older messages drop out of the window.
+*
+* Delta emission (markdown mode only): when a prior snapshot exists in the
+* context window, the processor emits a unified-diff delta against that
+* snapshot's contents. Schema mode and the snapshot fallback always emit a
+* full snapshot.
+*
+* @example
+* ```ts
+* new Memory({
+*   options: {
+*     workingMemory: {
+*       enabled: true,
+*       template: '...',
+*       useStateSignals: true, // auto-attaches this processor
+*     },
+*   },
+* });
+* ```
+*/
+const WORKING_MEMORY_STATE_ID = "working-memory";
+const WORKING_MEMORY_STATE_PROCESSOR_ID = "working-memory-state";
+var WorkingMemoryStateProcessor = class {
+	memory;
+	memoryConfig;
+	id = WORKING_MEMORY_STATE_PROCESSOR_ID;
+	stateId = WORKING_MEMORY_STATE_ID;
+	constructor(memory, memoryConfig) {
+		this.memory = memory;
+		this.memoryConfig = memoryConfig;
+	}
+	async computeStateSignal(args) {
+		const template = await this.memory.getWorkingMemoryTemplate({ memoryConfig: this.memoryConfig });
+		if (!template) return;
+		const contents = (await this.memory.getWorkingMemory({
+			threadId: args.threadId,
+			resourceId: args.resourceId,
+			memoryConfig: this.memoryConfig
+		}))?.trim();
+		if (!contents) return;
+		const cacheKey = stableWorkingMemoryCacheKey({
+			format: template.format,
+			data: contents
+		});
+		const shouldMakeSnapshot = !args.contextWindow.hasSnapshot;
+		if (args.tracking?.currentCacheKey === cacheKey && !shouldMakeSnapshot) return;
+		const scope = this.memory.getMergedThreadConfig(this.memoryConfig).workingMemory?.scope ?? "resource";
+		const deltaCandidate = template.format === "markdown" && !shouldMakeSnapshot ? buildMarkdownDelta({
+			lastSnapshot: args.lastSnapshot,
+			deltasSinceSnapshot: args.deltasSinceSnapshot,
+			nextContents: contents
+		}) : void 0;
+		if (deltaCandidate) return {
+			id: WORKING_MEMORY_STATE_ID,
+			mode: "delta",
+			cacheKey,
+			tagName: "working-memory",
+			contents: deltaCandidate.contents,
+			delta: deltaCandidate.contents,
+			value: contents,
+			attributes: {
+				format: template.format,
+				scope,
+				patch: "unified-diff"
+			}
+		};
+		return {
+			id: WORKING_MEMORY_STATE_ID,
+			mode: "snapshot",
+			cacheKey,
+			tagName: "working-memory",
+			contents,
+			value: contents,
+			attributes: {
+				format: template.format,
+				scope
+			}
+		};
+	}
+};
+/**
+* Stable cache key for the rendered working memory payload. Returns a SHA-256
+* digest so dedup metadata stays compact regardless of payload size (working
+* memory blobs can grow arbitrarily long).
+*/
+function stableWorkingMemoryCacheKey(input) {
+	const hash = createHash("sha256");
+	hash.update(input.format);
+	hash.update("\0");
+	hash.update(input.data ?? "");
+	return `sha256:${hash.digest("hex")}`;
+}
+/**
+* Build a unified-diff delta against the most recently emitted state. Prefers
+* the latest delta's `value` (the post-edit full text) when available, falling
+* back to the snapshot's `value` and finally the snapshot's `contents`. This
+* keeps deltas incremental (B→C) instead of cumulative against a stale
+* snapshot (A→C), which matters when many small edits land between snapshots.
+*
+* Returns undefined when:
+* - there's no prior state to diff against
+* - the prior state isn't a plain string (multimodal signal)
+*
+* In either case the caller falls back to emitting a full snapshot.
+*/
+function buildMarkdownDelta(args) {
+	const { lastSnapshot, deltasSinceSnapshot, nextContents } = args;
+	const prior = pickStringValue(readSignalValue(deltasSinceSnapshot.at(-1))) ?? pickStringValue(readSignalValue(lastSnapshot)) ?? (typeof lastSnapshot?.contents === "string" ? lastSnapshot.contents : void 0);
+	if (!prior) return;
+	return { contents: renderHunksOnly(prior, nextContents) };
+}
+function pickStringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function readSignalValue(signal) {
+	return (signal?.metadata)?.value;
+}
+/**
+* Render a unified-diff-style patch body containing only `@@` hunks and their
+* lines — dropping the filename preamble (`Index:` / `===` / `---` / `+++`)
+* that `createPatch` emits and the `` trailer.
+* The preamble exists for tooling like `patch -p1` to know which file to
+* apply to; we only ever diff a single working-memory blob. The newline
+* trailer is semantically meaningless to the model and adds noise to the
+* state signal.
+*/
+function renderHunksOnly(prior, next) {
+	const { hunks } = structuredPatch("", "", prior, next, "", "", { context: 0 });
+	return hunks.map((hunk) => {
+		return [`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`, ...hunk.lines.filter((line) => !line.startsWith("\"))].join("\n");
+	}).join("\n");
+}
+//#endregion
 //#region src/processors/observational-memory/activation-ttl.ts
 const MINUTE = 6e4;
 const HOUR = 60 * MINUTE;
@@ -26433,10 +26578,24 @@ function getLatestStepParts(parts) {
 	return parts;
 }
 /**
-* Returns true when a message contains at least one part with visible user/assistant
-* content (text, tool-invocation, reasoning, image, file).  Messages that only carry
-* internal `data-*` parts (buffering markers, observation markers, etc.) return false.
+* Returns true for persisted Working Memory state signals (`role: 'signal'`,
+* `signal.type: 'state'`, `state.id: 'working-memory'`). OM must not observe these:
+* they mirror memory OM itself manages, and re-observing them creates a self-feedback
+* loop that can overwrite stored working memory (#21961). Only the working-memory lane
+* is filtered — other state lanes are outside OM's write path, so re-observing them
+* cannot corrupt OM-managed state; excluding them broadly is a separate decision.
 */
+function isWorkingMemoryStateSignal(message) {
+	if (message.role !== "signal") return false;
+	const signal = message.content.metadata?.signal;
+	if (!signal || typeof signal !== "object" || Array.isArray(signal)) return false;
+	const signalRecord = signal;
+	if ((signalRecord.type ?? message.type) !== "state") return false;
+	const metadata = signalRecord.metadata;
+	if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return false;
+	const state = metadata.state;
+	return !!state && typeof state === "object" && !Array.isArray(state) && state.id === "working-memory";
+}
 function messageHasVisibleContent(msg) {
 	const content = msg.content;
 	if (content?.parts && Array.isArray(content.parts)) return content.parts.some((p) => {
@@ -27207,7 +27366,7 @@ var ObservationalMemory = class ObservationalMemory {
 		}
 		const result = [];
 		for (const msg of allMessages) {
-			if (msg.role === "system") continue;
+			if (msg.role === "system" || isWorkingMemoryStateSignal(msg)) continue;
 			if (observedMessageIds?.has(msg.id)) continue;
 			const endMarkerIndex = findLastCompletedObservationBoundary(msg);
 			if (this.hasInProgressObservation(msg)) result.push(msg);
@@ -27429,7 +27588,7 @@ var ObservationalMemory = class ObservationalMemory {
 			},
 			filter: startDate ? { dateRange: { start: startDate } } : void 0
 		});
-		return result.messages.filter((msg) => msg.role !== "system");
+		return result.messages.filter((msg) => msg.role !== "system" && !isWorkingMemoryStateSignal(msg));
 	}
 	/**
 	* Format unobserved messages from other threads as <unobserved-context> blocks.
@@ -27888,7 +28047,7 @@ ${formattedMessages}
 					direction: "ASC"
 				},
 				filter: startDate ? { dateRange: { start: startDate } } : void 0
-			})).messages.filter((m) => !this.observedMessageIds.has(m.id));
+			})).messages.filter((message) => !this.observedMessageIds.has(message.id) && !isWorkingMemoryStateSignal(message));
 			if (filtered.length > 0) messagesByThread.set(thread.id, filtered);
 		}
 		if (messagesByThread.size === 0) return void 0;
@@ -29314,151 +29473,6 @@ var observational_memory_exports = /* @__PURE__ */ __exportAll({
 	wrapInObservationGroup: () => wrapInObservationGroup
 });
 //#endregion
-//#region src/processors/working-memory-state/processor.ts
-/**
-* WorkingMemoryStateProcessor
-*
-* Experimental: delivers working memory to the model as a state signal instead
-* of folding it into the system message. Storage and the `setWorkingMemory`
-* tool are unchanged — this processor only changes the delivery path.
-*
-* Pattern matches `BrowserContextProcessor` in `@mastra/core/browser`:
-* - `stateId` namespaces the state lane on the thread.
-* - `cacheKey` is derived from the rendered payload so dedup is automatic.
-* - `contextWindow.hasSnapshot` re-injection ensures the model still sees the
-*   current snapshot after older messages drop out of the window.
-*
-* Delta emission (markdown mode only): when a prior snapshot exists in the
-* context window, the processor emits a unified-diff delta against that
-* snapshot's contents. Schema mode and the snapshot fallback always emit a
-* full snapshot.
-*
-* @example
-* ```ts
-* new Memory({
-*   options: {
-*     workingMemory: {
-*       enabled: true,
-*       template: '...',
-*       useStateSignals: true, // auto-attaches this processor
-*     },
-*   },
-* });
-* ```
-*/
-const WORKING_MEMORY_STATE_ID = "working-memory";
-const WORKING_MEMORY_STATE_PROCESSOR_ID = "working-memory-state";
-var WorkingMemoryStateProcessor = class {
-	memory;
-	memoryConfig;
-	id = WORKING_MEMORY_STATE_PROCESSOR_ID;
-	stateId = WORKING_MEMORY_STATE_ID;
-	constructor(memory, memoryConfig) {
-		this.memory = memory;
-		this.memoryConfig = memoryConfig;
-	}
-	async computeStateSignal(args) {
-		const template = await this.memory.getWorkingMemoryTemplate({ memoryConfig: this.memoryConfig });
-		if (!template) return;
-		const contents = (await this.memory.getWorkingMemory({
-			threadId: args.threadId,
-			resourceId: args.resourceId,
-			memoryConfig: this.memoryConfig
-		}))?.trim();
-		if (!contents) return;
-		const cacheKey = stableWorkingMemoryCacheKey({
-			format: template.format,
-			data: contents
-		});
-		const shouldMakeSnapshot = !args.contextWindow.hasSnapshot;
-		if (args.tracking?.currentCacheKey === cacheKey && !shouldMakeSnapshot) return;
-		const scope = this.memory.getMergedThreadConfig(this.memoryConfig).workingMemory?.scope ?? "resource";
-		const deltaCandidate = template.format === "markdown" && !shouldMakeSnapshot ? buildMarkdownDelta({
-			lastSnapshot: args.lastSnapshot,
-			deltasSinceSnapshot: args.deltasSinceSnapshot,
-			nextContents: contents
-		}) : void 0;
-		if (deltaCandidate) return {
-			id: WORKING_MEMORY_STATE_ID,
-			mode: "delta",
-			cacheKey,
-			tagName: "working-memory",
-			contents: deltaCandidate.contents,
-			delta: deltaCandidate.contents,
-			value: contents,
-			attributes: {
-				format: template.format,
-				scope,
-				patch: "unified-diff"
-			}
-		};
-		return {
-			id: WORKING_MEMORY_STATE_ID,
-			mode: "snapshot",
-			cacheKey,
-			tagName: "working-memory",
-			contents,
-			value: contents,
-			attributes: {
-				format: template.format,
-				scope
-			}
-		};
-	}
-};
-/**
-* Stable cache key for the rendered working memory payload. Returns a SHA-256
-* digest so dedup metadata stays compact regardless of payload size (working
-* memory blobs can grow arbitrarily long).
-*/
-function stableWorkingMemoryCacheKey(input) {
-	const hash = createHash("sha256");
-	hash.update(input.format);
-	hash.update("\0");
-	hash.update(input.data ?? "");
-	return `sha256:${hash.digest("hex")}`;
-}
-/**
-* Build a unified-diff delta against the most recently emitted state. Prefers
-* the latest delta's `value` (the post-edit full text) when available, falling
-* back to the snapshot's `value` and finally the snapshot's `contents`. This
-* keeps deltas incremental (B→C) instead of cumulative against a stale
-* snapshot (A→C), which matters when many small edits land between snapshots.
-*
-* Returns undefined when:
-* - there's no prior state to diff against
-* - the prior state isn't a plain string (multimodal signal)
-*
-* In either case the caller falls back to emitting a full snapshot.
-*/
-function buildMarkdownDelta(args) {
-	const { lastSnapshot, deltasSinceSnapshot, nextContents } = args;
-	const prior = pickStringValue(readSignalValue(deltasSinceSnapshot.at(-1))) ?? pickStringValue(readSignalValue(lastSnapshot)) ?? (typeof lastSnapshot?.contents === "string" ? lastSnapshot.contents : void 0);
-	if (!prior) return;
-	return { contents: renderHunksOnly(prior, nextContents) };
-}
-function pickStringValue(value) {
-	return typeof value === "string" ? value : void 0;
-}
-function readSignalValue(signal) {
-	return (signal?.metadata)?.value;
-}
-/**
-* Render a unified-diff-style patch body containing only `@@` hunks and their
-* lines — dropping the filename preamble (`Index:` / `===` / `---` / `+++`)
-* that `createPatch` emits and the `` trailer.
-* The preamble exists for tooling like `patch -p1` to know which file to
-* apply to; we only ever diff a single working-memory blob. The newline
-* trailer is semantically meaningless to the model and adds noise to the
-* state signal.
-*/
-function renderHunksOnly(prior, next) {
-	const { hunks } = structuredPatch("", "", prior, next, "", "", { context: 0 });
-	return hunks.map((hunk) => {
-		return [`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`, ...hunk.lines.filter((line) => !line.startsWith("\"))].join("\n");
-	}).join("\n");
-}
-//#endregion
 //#region src/processors/working-memory-state/index.ts
 var working_memory_state_exports = /* @__PURE__ */ __exportAll({
 	WORKING_MEMORY_STATE_ID: () => WORKING_MEMORY_STATE_ID,
@@ -31479,6 +31493,6 @@ Notes:
 	}
 };
 //#endregion
-export { formatMessagesForObserver as A, OBSERVATION_CONTINUATION_HINT as B, SUMMARIZE_THREAD_DEFAULTS as C, buildObserverPrompt as D, OBSERVER_SYSTEM_PROMPT as E, parseAnchorId as F, ModelByInputTokens as G, KnowledgeSemanticIndexCoordinator as H, stripEphemeralAnchorIds as I, SUBCONSCIOUS_ACTIVITY_STATE_ID as J, SubconsciousCaptureExtractor as K, OBSERVATIONAL_MEMORY_DEFAULTS as L, optimizeObservationsForContext as M, parseObserverOutput as N, buildObserverSystemPrompt as O, injectAnchorIds as P, Extractor as Q, OBSERVATION_CONTEXT_INSTRUCTIONS as R, WorkingMemoryExtractor as S, TokenCounter as T, StaleKnowledgeSemanticIndexError as U, Subconscious as V, SubconsciousRemindExtractor as W, publishSubconsciousActivity as X, buildSubconsciousActivitySnapshot as Y, renderSubconsciousActivity as Z, reconcileObservationGroupsFromReflection as _, extractWorkingMemoryContent as a, wrapInObservationGroup as b, WORKING_MEMORY_STATE_ID as c, getObservationsAsOf as d, ObservationalMemoryProcessor as f, parseObservationGroups as g, deriveObservationGroupProvenance as h, WorkingMemory as i, hasCurrentTaskSection as j, extractCurrentTask as k, WORKING_MEMORY_STATE_PROCESSOR_ID as l, combineObservationGroupRanges as m, MessageHistory$1 as n, extractWorkingMemoryTags as o, ObservationalMemory as p, subconsciousCaptureSchema as q, SemanticRecall as r, removeWorkingMemoryTags as s, Memory as t, WorkingMemoryStateProcessor as u, renderObservationGroupsForReflection as v, summarizeConversation as w, deepMergeWorkingMemory as x, stripObservationGroups as y, OBSERVATION_CONTEXT_PROMPT as z };
+export { formatMessagesForObserver as A, OBSERVATION_CONTINUATION_HINT as B, SUMMARIZE_THREAD_DEFAULTS as C, buildObserverPrompt as D, OBSERVER_SYSTEM_PROMPT as E, parseAnchorId as F, ModelByInputTokens as G, KnowledgeSemanticIndexCoordinator as H, stripEphemeralAnchorIds as I, SUBCONSCIOUS_ACTIVITY_STATE_ID as J, SubconsciousCaptureExtractor as K, OBSERVATIONAL_MEMORY_DEFAULTS as L, optimizeObservationsForContext as M, parseObserverOutput as N, buildObserverSystemPrompt as O, injectAnchorIds as P, Extractor as Q, OBSERVATION_CONTEXT_INSTRUCTIONS as R, WorkingMemoryExtractor as S, TokenCounter as T, StaleKnowledgeSemanticIndexError as U, Subconscious as V, SubconsciousRemindExtractor as W, publishSubconsciousActivity as X, buildSubconsciousActivitySnapshot as Y, renderSubconsciousActivity as Z, wrapInObservationGroup as _, extractWorkingMemoryContent as a, WorkingMemoryStateProcessor as b, getObservationsAsOf as c, combineObservationGroupRanges as d, deriveObservationGroupProvenance as f, stripObservationGroups as g, renderObservationGroupsForReflection as h, WorkingMemory as i, hasCurrentTaskSection as j, extractCurrentTask as k, ObservationalMemoryProcessor as l, reconcileObservationGroupsFromReflection as m, MessageHistory$1 as n, extractWorkingMemoryTags as o, parseObservationGroups as p, subconsciousCaptureSchema as q, SemanticRecall as r, removeWorkingMemoryTags as s, Memory as t, ObservationalMemory as u, WORKING_MEMORY_STATE_ID as v, summarizeConversation as w, deepMergeWorkingMemory as x, WORKING_MEMORY_STATE_PROCESSOR_ID as y, OBSERVATION_CONTEXT_PROMPT as z };
 
-//# sourceMappingURL=src-BTHCV1ov.js.map
+//# sourceMappingURL=src-BATJenuZ.js.map