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

package/dist/{src-BNyqEQlx.js → src-t3Mhge0m.js}

@@ -19797,19 +19797,28 @@ const PHASE_CONFIG = {
 };
 async function withOmTracingSpan({ phase, model, inputTokens, requestContext, observabilityContext, metadata, callback }) {
 	const config = PHASE_CONFIG[phase];
+	const tracingContext = observabilityContext?.tracingContext ?? observabilityContext?.tracing;
+	const callerMetadata = tracingContext?.currentSpan?.metadata;
+	const inheritedCallerThreadId = callerMetadata?.__mastraObservationalMemoryCallerThreadId;
+	const callerThreadId = callerMetadata?.threadId;
+	const requestThreadId = requestContext?.get(MASTRA_THREAD_ID_KEY);
+	const omCallerThreadId = typeof inheritedCallerThreadId === "string" && inheritedCallerThreadId ? inheritedCallerThreadId : typeof callerThreadId === "string" && callerThreadId ? callerThreadId : typeof requestThreadId === "string" && requestThreadId ? requestThreadId : void 0;
 	const span = getOrCreateSpan({
 		type: SpanType.MEMORY_OPERATION,
 		name: config.name,
 		entityType: EntityType.MEMORY,
 		entityName: config.entityName,
-		tracingContext: observabilityContext?.tracingContext ?? observabilityContext?.tracing,
+		tracingContext,
 		attributes: {
 			operationType: config.operationType,
 			inputTokens,
 			selectedModel: typeof model === "string" ? model : "(dynamic-model)",
 			...config.multiThread ? { multiThread: true } : {}
 		},
-		metadata,
+		metadata: omCallerThreadId !== void 0 ? {
+			...metadata,
+			__mastraObservationalMemoryCallerThreadId: omCallerThreadId
+		} : metadata,
 		requestContext
 	});
 	const childObservabilityContext = createObservabilityContext({ currentSpan: span });
@@ -28491,7 +28500,7 @@ ${formattedMessages}
 		if (!this.buffering.isAsyncObservationEnabled()) return false;
 		const lockKey = this.buffering.getLockKey(opts.threadId, opts.resourceId);
 		const shouldTrigger = this.buffering.shouldTriggerAsyncObservation(opts.pendingTokens, lockKey, opts.record, this.storage, opts.threshold);
-		if (shouldTrigger) this.trackBackgroundWork(this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext));
+		if (shouldTrigger) this.trackBackgroundWork(this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext, opts.observabilityContext));
 		return shouldTrigger;
 	}
 	isMessageList(value) {
@@ -30260,8 +30269,35 @@ const DEFAULT_TOP_K = 4;
 const VECTOR_DELETE_BATCH_SIZE = 100;
 const DEFAULT_EMBEDDING_CACHE_MAX_SIZE = 1e3;
 /**
-* Concrete implementation of MastraMemory that adds support for thread configuration
-* and message injection.
+* Gives Mastra agents conversation history, with optional working memory,
+* semantic recall, and observational memory.
+*
+* @remarks
+* Configure storage on this instance or its Mastra instance before use.
+* See the bundled docs for setup and conversation identifiers.
+*
+* @example
+* Attach memory to an agent; `yourModel` is your configured model.
+* ```typescript
+* import { Agent } from '@mastra/core/agent';
+* import { Memory } from '@mastra/memory';
+*
+* const agent = new Agent({
+*   id: 'assistant',
+*   name: 'Assistant',
+*   instructions: 'You are a helpful assistant.',
+*   model: yourModel,
+*   memory: new Memory(),
+* });
+* ```
+*
+* @see For documentation bundled with your installed package, locate
+* `@mastra/memory/package.json` with your project's resolver or package-manager
+* tooling, then read `dist/docs/SKILL.md` from that package root and follow its
+* reference links. Use package-manager tools for virtual or archived packages.
+*
+* @see [Memory documentation](https://mastra.ai/docs/memory/overview)
+* if packaged docs are unavailable.
 */
 var Memory = class Memory extends MastraMemory {
 	_omEngine;
@@ -31860,18 +31896,40 @@ Notes:
 	* ```
 	*/
 	async cloneThread(args, memoryConfig) {
-		const memoryStore = await this.getMemoryStore();
-		const config = this.getMergedThreadConfig(memoryConfig);
-		const requestedHydrate = args.options?.hydrateMessages ?? true;
-		const effectiveHydrate = requestedHydrate || Boolean(this.vector && this.embedder && config.semanticRecall);
-		const result = await memoryStore.cloneThread(effectiveHydrate === requestedHydrate ? args : {
-			...args,
-			options: {
-				...args.options,
-				hydrateMessages: effectiveHydrate
+		const result = await this.copyThread(args, memoryConfig);
+		const { messages } = await (await this.getMemoryStore()).listMessages({
+			threadId: result.thread.id,
+			resourceId: result.thread.resourceId,
+			perPage: false,
+			orderBy: {
+				field: "createdAt",
+				direction: "ASC"
 			}
 		});
+		return {
+			...result,
+			clonedMessages: messages
+		};
+	}
+	/**
+	* Copies a thread with all its messages to a new thread without returning the
+	* message payloads. Working memory, observational memory, and semantic-recall
+	* embeddings are carried over exactly as with `cloneThread`; the only difference
+	* is that message content never has to be held in the Node heap at once.
+	*
+	* Use this instead of `cloneThread` when only the new thread id is needed
+	* (e.g. forking a conversation for a subagent).
+	*
+	* @param args - Clone parameters, same as `cloneThread`
+	* @param memoryConfig - Optional memory configuration override
+	* @returns The newly created thread and the source→new message id map
+	*/
+	async copyThread(args, memoryConfig) {
+		const memoryStore = await this.getMemoryStore();
+		const config = this.getMergedThreadConfig(memoryConfig);
+		const result = await memoryStore.copyThread(args);
 		const sourceResourceId = (await this.getThreadById({ threadId: args.sourceThreadId }))?.resourceId;
+		let priorDestinationResourceWm;
 		if (config.workingMemory?.enabled) {
 			const scope = config.workingMemory.scope || "resource";
 			if (scope === "thread" || scope === "resource" && args.resourceId && args.resourceId !== sourceResourceId) {
@@ -31880,28 +31938,125 @@ Notes:
 					resourceId: sourceResourceId,
 					memoryConfig
 				});
-				if (sourceWm) await this.updateWorkingMemory({
-					threadId: result.thread.id,
-					resourceId: result.thread.resourceId,
-					workingMemory: sourceWm,
-					memoryConfig
-				});
+				if (sourceWm) {
+					if (scope === "resource") priorDestinationResourceWm = (await memoryStore.getResourceById({ resourceId: result.thread.resourceId }))?.workingMemory ?? null;
+					await this.updateWorkingMemory({
+						threadId: result.thread.id,
+						resourceId: result.thread.resourceId,
+						workingMemory: sourceWm,
+						memoryConfig
+					});
+				}
 			}
 		}
 		if (memoryStore.supportsObservationalMemory && sourceResourceId) try {
 			await this.cloneObservationalMemory(memoryStore, args.sourceThreadId, sourceResourceId, result);
 		} catch (error) {
-			try {
-				await memoryStore.deleteThread({ threadId: result.thread.id });
-			} catch (rollbackError) {
-				this.logger.error("Failed to rollback cloned thread after OM clone failure", rollbackError);
-			}
+			await this.rollbackCopiedThread(memoryStore, result.thread, "OM clone", false, priorDestinationResourceWm);
+			throw error;
+		}
+		if (this.vector && this.embedder && config.semanticRecall) try {
+			await this.embedCopiedMessagesInBatches(memoryStore, result, config);
+		} catch (error) {
+			await this.rollbackCopiedThread(memoryStore, result.thread, "embedding", true, priorDestinationResourceWm);
 			throw error;
 		}
-		if (this.vector && config.semanticRecall && result.clonedMessages.length > 0) await this.embedClonedMessages(result.clonedMessages, config);
 		return result;
 	}
 	/**
+	* Best-effort compensation when a later step of copyThread fails after the destination thread
+	* was persisted. deleteThread removes the thread, its messages and thread-scoped working memory.
+	* `priorDestinationResourceWm` is the destination resource's working memory before the copy
+	* overwrote it (`null` = none existed); when defined it is restored. When `afterOmClone` is set the OM step already succeeded, so the thread-scoped OM record and
+	* any vectors written so far are dropped too. Resource-scoped OM is left alone: it may be
+	* shared with a pre-existing resource and isn't safe to clear blindly.
+	*/
+	async rollbackCopiedThread(memoryStore, thread, failedStep, afterOmClone, priorDestinationResourceWm) {
+		const threadId = thread.id;
+		try {
+			await memoryStore.deleteThread({ threadId });
+		} catch (rollbackError) {
+			this.logger.error(`Failed to rollback copied thread after ${failedStep} failure`, rollbackError);
+		}
+		if (priorDestinationResourceWm !== void 0) try {
+			await memoryStore.updateResource({
+				resourceId: thread.resourceId,
+				workingMemory: priorDestinationResourceWm ?? ""
+			});
+		} catch (rollbackError) {
+			this.logger.error(`Failed to restore resource working memory after ${failedStep} failure`, rollbackError);
+		}
+		if (!afterOmClone) return;
+		if (memoryStore.supportsObservationalMemory) try {
+			await memoryStore.clearObservationalMemory(threadId, thread.resourceId);
+		} catch (rollbackError) {
+			this.logger.error(`Failed to rollback copied thread OM after ${failedStep} failure`, rollbackError);
+		}
+		try {
+			const messageIndexes = await this.getMemoryVectorIndexes([this.messageIndexPrefix]);
+			await Promise.all(messageIndexes.map((indexName) => this.vector.deleteVectors({
+				indexName,
+				filter: { thread_id: threadId }
+			})));
+		} catch (rollbackError) {
+			this.logger.error(`Failed to rollback copied thread vectors after ${failedStep} failure`, rollbackError);
+		}
+	}
+	static CLONE_EMBED_PAGE_SIZE = 100;
+	async embedCopiedMessagesInBatches(memoryStore, copied, config) {
+		const size = Memory.CLONE_EMBED_PAGE_SIZE;
+		const copiedIds = Object.values(copied.messageIdMap ?? {});
+		if (copiedIds.length > 0) {
+			for (let i = 0; i < copiedIds.length; i += size) {
+				const { messages } = await memoryStore.listMessagesById({ messageIds: copiedIds.slice(i, i + size) });
+				if (messages.length > 0) await this.embedClonedMessages(messages, config);
+			}
+			return;
+		}
+		const { messages } = await memoryStore.listMessages({
+			threadId: copied.thread.id,
+			resourceId: copied.thread.resourceId,
+			perPage: false,
+			includeTotal: false
+		});
+		for (let i = 0; i < messages.length; i += size) await this.embedClonedMessages(messages.slice(i, i + size), config);
+	}
+	async updateThreadResourceId({ threadId, resourceId, memoryConfig }) {
+		const memoryStore = await this.getMemoryStore();
+		const config = this.getMergedThreadConfig(memoryConfig);
+		const migratesVectors = Boolean(this.vector && this.embedder && config.semanticRecall);
+		if (!migratesVectors) {
+			const existing = await memoryStore.getThreadById({ threadId });
+			if (existing && existing.resourceId === resourceId) return existing;
+		}
+		const thread = await memoryStore.updateThreadResourceId({
+			threadId,
+			resourceId
+		});
+		if (migratesVectors) try {
+			const { messages } = await memoryStore.listMessages({
+				threadId,
+				perPage: false
+			});
+			const messageIndexes = await this.getMemoryVectorIndexes([this.messageIndexPrefix]);
+			await Promise.all(messageIndexes.map(async (indexName) => {
+				await this.vector.deleteVectors({
+					indexName,
+					filter: { thread_id: threadId }
+				});
+			}));
+			if (messages.length > 0) await this.embedClonedMessages(messages, config);
+		} catch (error) {
+			this.logger.error("Failed to migrate semantic-recall vectors during thread transfer", {
+				threadId,
+				resourceId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw new Error(`Thread "${threadId}" was transferred to resource "${resourceId}", but migrating its semantic-recall vectors failed. The thread's messages may not surface under resource-scoped recall until the vectors are re-indexed. Cause: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+		return thread;
+	}
+	/**
 	* Clone observational memory records when cloning a thread.
 	* Thread-scoped: always cloned to the new thread.
 	* Resource-scoped: cloned only when the resourceId changes (same resourceId shares OM naturally).
@@ -32204,4 +32359,4 @@ 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, publishSubconsciousActivity as J, SUBCONSCIOUS_ACTIVITY_STATE_ID as K, OBSERVATIONAL_MEMORY_DEFAULTS as L, optimizeObservationsForContext as M, parseObserverOutput as N, buildObserverSystemPrompt as O, injectAnchorIds as P, OBSERVATION_CONTEXT_INSTRUCTIONS as R, WorkingMemoryExtractor as S, TokenCounter as T, StaleKnowledgeSemanticIndexError as U, Subconscious as V, SubconsciousRemindExtractor as W, Extractor as X, renderSubconsciousActivity as Y, 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, buildSubconsciousActivitySnapshot 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-BNyqEQlx.js.map
+//# sourceMappingURL=src-t3Mhge0m.js.map