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

package/dist/{src-Bze5SVTm.cjs → src-CJgJb_MC.cjs}

@@ -19819,19 +19819,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_core_request_context.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 = (0, _mastra_core_observability.getOrCreateSpan)({
 		type: _mastra_core_observability.SpanType.MEMORY_OPERATION,
 		name: config.name,
 		entityType: _mastra_core_observability.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 = (0, _mastra_core_observability.createObservabilityContext)({ currentSpan: span });
@@ -28513,7 +28522,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) {
@@ -30282,8 +30291,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 _mastra_core_memory.MastraMemory {
 	_omEngine;
@@ -31882,18 +31918,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) {
@@ -31902,28 +31960,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).
@@ -32507,4 +32662,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-Bze5SVTm.cjs.map
+//# sourceMappingURL=src-CJgJb_MC.cjs.map