@mastra/memory 1.40.0-alpha.1 → 1.40.0

package/dist/{src-DZnFu-zL.cjs → src-CaxT6Rpu.cjs}

@@ -35748,14 +35748,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.
 	*/
@@ -35765,13 +35777,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}`;
 	}
@@ -35798,10 +35811,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);
@@ -35858,7 +35874,8 @@ var ObservationStrategy = class ObservationStrategy {
 				processed: {
 					...processed,
 					observations: target.activeObservations ?? "",
-					observationTokens: target.observationTokenCount
+					observationTokens: target.observationTokenCount,
+					newObservationGroup: void 0
 				},
 				record: target,
 				alreadyCovered: true
@@ -35884,11 +35901,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,
@@ -35899,7 +35929,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
@@ -36229,8 +36264,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);
@@ -36241,6 +36276,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,
@@ -36271,6 +36307,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();
@@ -36301,7 +36342,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,
@@ -36435,10 +36475,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);
@@ -36531,7 +36571,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) {
@@ -36644,6 +36684,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) {
@@ -36893,8 +36935,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);
@@ -36944,6 +36986,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 });
@@ -36979,7 +37032,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,
@@ -44282,7 +44334,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 };
 	}
@@ -45692,4 +45745,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-DZnFu-zL.cjs.map
+//# sourceMappingURL=src-CaxT6Rpu.cjs.map