@mastra/memory 1.40.0-alpha.0 → 1.40.0

package/dist/{src-tZXqilfm.js → src-RKBjZOzr.js}

@@ -35727,14 +35727,26 @@ var ObservationStrategy = class ObservationStrategy {
 	* Wrap observations in a thread attribution tag.
 	* In resource scope, thread IDs can be obscured via xxhash.
 	*/
-	async wrapWithThreadTag(threadId, observations, messageRange) {
-		const cleanObservations = stripThreadTags(observations);
-		const groupedObservations = this.retrieval && messageRange ? wrapInObservationGroup(cleanObservations, messageRange) : cleanObservations;
+	async wrapWithThreadTag(threadId, observations, group) {
+		const groupedObservations = group ? wrapInObservationGroup(group.content, group.range, group.id) : stripThreadTags(observations);
 		let displayId = threadId;
 		if (this.deps.obscureThreadIds) displayId = (await hasherPromise).h32ToString(threadId);
 		return `<thread id="${displayId}">\n${groupedObservations}\n</thread>`;
 	}
 	/**
+	* Build the observation group a cycle adds, or undefined when retrieval is off. The group is
+	* what the cycle wraps into the observations and what it indexes, so both carry the same ID.
+	*/
+	createObservationGroup(observations, range) {
+		if (!this.retrieval) return void 0;
+		const content = this.scope === "resource" ? stripThreadTags(observations) : observations;
+		return {
+			id: generateAnchorId(),
+			range,
+			content: content.trim()
+		};
+	}
+	/**
 	* Create a message boundary delimiter with an ISO 8601 date.
 	* Used to separate observation chunks for cache stability.
 	*/
@@ -35744,13 +35756,14 @@ var ObservationStrategy = class ObservationStrategy {
 	/**
 	* Wrap raw observations — in resource scope, wraps with thread tag and merges;
 	* in thread scope, simply appends with a message boundary delimiter.
+	* `group` is the cycle's new observation group when retrieval is on.
 	*/
-	wrapObservations(rawObservations, existingObservations, threadId, lastObservedAt, messageRange) {
+	wrapObservations(rawObservations, existingObservations, threadId, lastObservedAt, group) {
 		if (this.scope === "resource") return (async () => {
-			const threadSection = await this.wrapWithThreadTag(threadId, rawObservations, messageRange);
+			const threadSection = await this.wrapWithThreadTag(threadId, rawObservations, group);
 			return this.replaceOrAppendThreadSection(existingObservations, threadId, threadSection, lastObservedAt);
 		})();
-		const grouped = this.retrieval && messageRange ? wrapInObservationGroup(rawObservations, messageRange) : rawObservations;
+		const grouped = group ? wrapInObservationGroup(group.content, group.range, group.id) : rawObservations;
 		if (!existingObservations) return grouped;
 		return `${existingObservations}${lastObservedAt ? ObservationStrategy.createMessageBoundary(lastObservedAt) : "\n\n"}${grouped}`;
 	}
@@ -35777,10 +35790,13 @@ var ObservationStrategy = class ObservationStrategy {
 			}
 		}
 		if (existingSection) {
-			const dateLineEnd = newThreadSection.indexOf("\n", newThreadSection.indexOf("Date:"));
+			const dateIdx = newThreadSection.indexOf("Date:");
+			const dateLineEnd = newThreadSection.indexOf("\n", dateIdx);
 			const newCloseIdx = newThreadSection.lastIndexOf(threadClose);
+			const groupIdx = newThreadSection.indexOf("<observation-group ");
+			const contentStart = groupIdx !== -1 && groupIdx < dateIdx ? groupIdx : dateLineEnd + 1;
 			if (dateLineEnd !== -1 && newCloseIdx !== -1) {
-				const newObsContent = newThreadSection.slice(dateLineEnd + 1, newCloseIdx).trim();
+				const newObsContent = newThreadSection.slice(contentStart, newCloseIdx).trim();
 				if (newObsContent) {
 					const merged = `${existingSection.slice(0, existingSection.length - 9).trimEnd()}\n${newObsContent}\n${threadClose}`;
 					return existingObservations.slice(0, existingSectionStart) + merged + existingObservations.slice(existingSectionEnd);
@@ -35837,7 +35853,8 @@ var ObservationStrategy = class ObservationStrategy {
 				processed: {
 					...processed,
 					observations: target.activeObservations ?? "",
-					observationTokens: target.observationTokenCount
+					observationTokens: target.observationTokenCount,
+					newObservationGroup: void 0
 				},
 				record: target,
 				alreadyCovered: true
@@ -35863,11 +35880,24 @@ var ObservationStrategy = class ObservationStrategy {
 			return op();
 		}, { abortSignal: this.opts.abortSignal });
 	}
+	/** Index every group parsed out of `observations` (used for buffered chunks, which carry no producer group). */
 	async indexObservationGroups(observations, threadId, resourceId, observedAt, recordId) {
-		if (!resourceId || !this.deps.onIndexObservations) return;
-		const groups = parseObservationGroups(observations);
-		if (groups.length === 0) return;
-		await Promise.all(groups.map((group) => withRetry(() => this.deps.onIndexObservations({
+		const groups = parseObservationGroups(observations).map((group) => ({
+			group,
+			threadId,
+			observedAt
+		}));
+		await this.indexNewObservationGroups(groups, resourceId, recordId);
+	}
+	/**
+	* Write the vectors for the groups a commit added, once. Call this right after the commit. The
+	* observations are already committed, so a failed write is logged and must not fail the cycle:
+	* that would skip its end markers and reflection.
+	*/
+	async indexNewObservationGroups(groups, resourceId, recordId) {
+		const onIndexObservations = this.deps.onIndexObservations;
+		if (!resourceId || !onIndexObservations || groups.length === 0) return;
+		const failures = (await Promise.allSettled(groups.map(({ group, threadId, observedAt }) => withRetry(() => onIndexObservations({
 			text: group.content,
 			groupId: group.id,
 			range: group.range,
@@ -35878,7 +35908,12 @@ var ObservationStrategy = class ObservationStrategy {
 		}), {
 			label: "index-observations",
 			abortSignal: this.opts.abortSignal
-		})));
+		})))).filter((result) => result.status === "rejected");
+		if (failures.length > 0) {
+			const reason = failures[0].reason;
+			omError("[OM] Indexing committed observation groups failed", reason);
+			console.warn(`[observational-memory] Storing observation vectors failed for ${failures.length} of ${groups.length} group(s) (${reason instanceof Error ? reason.message : String(reason)}).`);
+		}
 	}
 	/**
 	* Messages this cycle observed for `threadId`, or undefined when the strategy does not
@@ -36208,8 +36243,8 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 	async compose(output, existingObservations, baseRecord) {
 		const { threadId, messages } = this.opts;
 		const lastObservedAt = this.getMaxMessageTimestamp(messages);
-		const messageRange = this.retrieval ? buildMessageRange(messages) : void 0;
-		const newObservations = await this.wrapObservations(output.observations, existingObservations, threadId, lastObservedAt, messageRange);
+		const newObservationGroup = this.createObservationGroup(output.observations, buildMessageRange(messages));
+		const newObservations = await this.wrapObservations(output.observations, existingObservations, threadId, lastObservedAt, newObservationGroup);
 		const observationTokens = this.tokenCounter.countObservations(newObservations);
 		const cycleObservationTokens = this.tokenCounter.countObservations(output.observations);
 		const newMessageIds = messages.map((m) => m.id);
@@ -36220,6 +36255,7 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			cycleObservationTokens,
 			observedMessageIds: [.../* @__PURE__ */ new Set([...Array.isArray(existingIds) ? existingIds : [], ...newMessageIds])],
 			lastObservedAt,
+			newObservationGroup,
 			suggestedContinuation: output.suggestedContinuation,
 			currentTask: output.currentTask,
 			threadTitle: output.threadTitle,
@@ -36250,6 +36286,11 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			reason: "the observational memory head kept changing during the commit"
 		};
 		processed = committed.processed;
+		if (!committed.alreadyCovered && processed.newObservationGroup) await this.indexNewObservationGroups([{
+			group: processed.newObservationGroup,
+			threadId,
+			observedAt: processed.lastObservedAt
+		}], resourceId, committed.record.id);
 		const thread = committed.alreadyCovered ? null : await this.storage.getThreadById({ threadId });
 		if (thread) {
 			const oldTitle = thread.title?.trim();
@@ -36280,7 +36321,6 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 				newTitle
 			}));
 		}
-		if (!committed.alreadyCovered) await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt, committed.record.id);
 		return {
 			status: "committed",
 			processed,
@@ -36414,10 +36454,10 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 				lastObservedAt: /* @__PURE__ */ new Date()
 			};
 		}
-		const messageRange = this.retrieval ? buildMessageRange(messages) : void 0;
+		const group = this.createObservationGroup(output.observations, buildMessageRange(messages));
 		let newObservations;
-		if (this.scope === "resource") newObservations = await this.wrapWithThreadTag(threadId, output.observations, messageRange);
-		else newObservations = this.retrieval && messageRange ? wrapInObservationGroup(output.observations, messageRange) : output.observations;
+		if (this.scope === "resource") newObservations = await this.wrapWithThreadTag(threadId, output.observations, group);
+		else newObservations = group ? wrapInObservationGroup(group.content, group.range, group.id) : output.observations;
 		const observationTokens = this.tokenCounter.countObservations(newObservations);
 		const messageIds = messages.map((m) => m.id);
 		const maxTs = this.getMaxMessageTimestamp(messages);
@@ -36510,7 +36550,7 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			committedRecord = landedOn;
 		}
 		try {
-			await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt, this.persistedRecordId);
+			await this.indexObservationGroups(processed.observations, threadId, resourceId, processed.lastObservedAt, committedRecord.id);
 			const candidateTitle = processed.threadTitle?.trim();
 			const hasValidThreadTitle = !!candidateTitle && candidateTitle.length >= 3;
 			if (hasValidThreadTitle || processed.extractedValues) {
@@ -36623,6 +36663,8 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 	priorMetadataByThread = /* @__PURE__ */ new Map();
 	/** Each observed thread's wrapped section from the last composition. */
 	threadSections = /* @__PURE__ */ new Map();
+	/** Each observed thread's new observation group, when retrieval is on. */
+	newGroups = /* @__PURE__ */ new Map();
 	/** Head text the processed observations were composed from (the commit's expected text). */
 	composedFrom = "";
 	constructor(deps, opts) {
@@ -36872,8 +36914,8 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 		const threadMetadataUpdates = [];
 		for (const { threadId, threadMessages, result } of this.observationResults) {
 			cycleObservationTokens += this.tokenCounter.countObservations(result.observations);
-			const messageRange = this.retrieval ? buildMessageRange(threadMessages) : void 0;
-			const threadSection = await this.wrapWithThreadTag(threadId, result.observations, messageRange);
+			if (!this.newGroups.has(threadId)) this.newGroups.set(threadId, this.createObservationGroup(result.observations, buildMessageRange(threadMessages)));
+			const threadSection = await this.wrapWithThreadTag(threadId, result.observations, this.newGroups.get(threadId));
 			this.threadSections.set(threadId, threadSection);
 			const threadLastObservedAt = this.getMaxMessageTimestamp(threadMessages);
 			currentObservations = this.replaceOrAppendThreadSection(currentObservations, threadId, threadSection, threadLastObservedAt);
@@ -36923,6 +36965,17 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 			reason: "the observational memory head kept changing during the commit"
 		};
 		processed = committed.processed;
+		if (!committed.alreadyCovered) {
+			const added = this.observationResults.flatMap(({ threadId, threadMessages }) => {
+				const group = this.newGroups.get(threadId);
+				return group ? [{
+					group,
+					threadId,
+					observedAt: this.getMaxMessageTimestamp(threadMessages)
+				}] : [];
+			});
+			await this.indexNewObservationGroups(added, resourceId, committed.record.id);
+		}
 		const threadUpdateMarkers = [];
 		if (processed.threadMetadataUpdates && !committed.alreadyCovered) for (const update of processed.threadMetadataUpdates) {
 			const thread = await this.storage.getThreadById({ threadId: update.threadId });
@@ -36958,7 +37011,6 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 			}
 		}
 		for (const marker of threadUpdateMarkers) await this.streamMarker(marker);
-		if (resourceId && !committed.alreadyCovered) await Promise.all(this.observationResults.map(({ threadId, threadMessages, result }) => this.indexObservationGroups(result.observations, threadId, resourceId, this.getMaxMessageTimestamp(threadMessages), committed.record.id)));
 		return {
 			status: "committed",
 			processed,
@@ -43343,6 +43395,7 @@ var Memory = class Memory extends MastraMemory {
 		const engine = this._omEngine ? await this._omEngine : this._omEngineInstance;
 		if (engine && resourceId) await engine.waitForBuffering(threadId, resourceId, OM_DELETE_DRAIN_TIMEOUT_MS);
 		await memoryStore.deleteThread({ threadId });
+		if (typeof this.clearThreadStream === "function") this.clearThreadStream(threadId, resourceId);
 		if (resourceId && memoryStore.supportsObservationalMemory) await memoryStore.clearObservationalMemory(threadId, resourceId);
 		if (this.vector) this.trackVectorCleanup(this.deleteThreadVectors(threadId));
 	}
@@ -44260,7 +44313,8 @@ Notes:
 		if (typeof this.vector === `undefined`) throw new Error(`Tried to create observation embedding index but no vector db is attached to this Memory instance.`);
 		await this.vector.createIndex({
 			indexName,
-			dimension: usedDimensions
+			dimension: usedDimensions,
+			metadataIndexes: ["resource_id", "thread_id"]
 		});
 		return { indexName };
 	}
@@ -45365,4 +45419,4 @@ Notes:
 };
 export { renderSubconsciousActivity as $, buildObserverSystemPrompt as A, OBSERVATION_CONTEXT_INSTRUCTIONS as B, WorkingMemoryExtractor as C, TokenCounter as D, summarizeConversation as E, parseObserverOutput as F, Subconscious as G, OBSERVATION_CONTEXT_PROMPT_THREAD as H, injectAnchorIds as I, SubconsciousRemindExtractor as J, KnowledgeSemanticIndexCoordinator as K, parseAnchorId as L, formatMessagesForObserver as M, hasCurrentTaskSection as N, OBSERVER_SYSTEM_PROMPT as O, optimizeObservationsForContext as P, publishSubconsciousActivity as Q, stripEphemeralAnchorIds as R, wrapInObservationGroup as S, SUMMARIZE_THREAD_DEFAULTS as T, OBSERVATION_CONTINUATION_HINT as U, OBSERVATION_CONTEXT_PROMPT as V, getObservationContextPrompt as W, SUBCONSCIOUS_ACTIVITY_STATE_ID as X, ModelByInputTokens as Y, buildSubconsciousActivitySnapshot as Z, deriveObservationGroupProvenance as _, extractWorkingMemoryContent as a, renderObservationGroupsForReflection as b, getObservationsAsOf as c, AUTO_MODEL_BY_PROVIDER as d, Extractor as et, resolveAutoModelId as f, combineObservationGroupRanges as g, WorkingMemoryStateProcessor as h, WorkingMemory as i, extractCurrentTask as j, buildObserverPrompt as k, ObservationalMemoryProcessor as l, WORKING_MEMORY_STATE_PROCESSOR_ID as m, MessageHistory$1 as n, extractWorkingMemoryTags as o, WORKING_MEMORY_STATE_ID as p, StaleKnowledgeSemanticIndexError as q, SemanticRecall as r, removeWorkingMemoryTags as s, Memory as t, ObservationalMemory as u, parseObservationGroups as v, deepMergeWorkingMemory as w, stripObservationGroups as x, reconcileObservationGroupsFromReflection as y, OBSERVATIONAL_MEMORY_DEFAULTS as z };
 
-//# sourceMappingURL=src-tZXqilfm.js.map
+//# sourceMappingURL=src-RKBjZOzr.js.map