@mastra/server 1.67.0-alpha.1 → 1.67.0-alpha.3

package/dist/{dist-CaVro31X.cjs → dist-Du9y2ur5.cjs}

@@ -1,6 +1,6 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Bd6kNlEP.cjs");
-const require_schema_Bv9OdW1f = require("./schema-Bv9OdW1f-CxTiW8RD.cjs");
-require("./schema-CNKnRmv1.cjs");
+const require_schema_D_ikovK6 = require("./schema-D_ikovK6-DQrOVw5N.cjs");
+require("./schema-C7CvwM1d.cjs");
 const require_sync$1 = require("./sync-C4LbbSKR.cjs");
 const require_dist = require("./dist-CLQt62Pi.cjs");
 let zod_v4 = require("zod/v4");
@@ -4694,7 +4694,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-BNyqEQlx.js
+//#region ../memory/dist/src-TN3MwGgP.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -27418,7 +27418,7 @@ const updateWorkingMemoryTool = (memoryConfig) => {
 	};
 	if (schema) {
 		const standardSchema = (0, _mastra_core_schema.isStandardSchemaWithJSON)(schema) ? schema : (0, _mastra_core_schema.toStandardSchema)(schema);
-		const jsonSchema = require_schema_Bv9OdW1f.standardSchemaToJSONSchema(standardSchema, { io: "input" });
+		const jsonSchema = require_schema_D_ikovK6.standardSchemaToJSONSchema(standardSchema, { io: "input" });
 		delete jsonSchema.$schema;
 		const wrappedJsonSchema = {
 			$schema: "http://json-schema.org/draft-07/schema#",
@@ -34739,8 +34739,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;
@@ -35509,8 +35536,8 @@ ${workingMemory}`;
 		if (config.workingMemory?.schema) try {
 			const schema = config.workingMemory.schema;
 			let convertedSchema;
-			if (require_schema_Bv9OdW1f.isStandardSchemaWithJSON(schema)) convertedSchema = schema["~standard"].jsonSchema.output({ target: "draft-07" });
-			else convertedSchema = require_schema_Bv9OdW1f.toStandardSchema(schema)["~standard"].jsonSchema.output({ target: "draft-07" });
+			if (require_schema_D_ikovK6.isStandardSchemaWithJSON(schema)) convertedSchema = schema["~standard"].jsonSchema.output({ target: "draft-07" });
+			else convertedSchema = require_schema_D_ikovK6.toStandardSchema(schema)["~standard"].jsonSchema.output({ target: "draft-07" });
 			return {
 				format: "json",
 				content: JSON.stringify(convertedSchema)
@@ -36339,18 +36366,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) {
@@ -36359,28 +36408,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).
@@ -40158,7 +40304,7 @@ Return the actual exported names of the units, as well as the file names.`,
 				maxSteps: 100
 			});
 			else {
-				const jsonSchema = require_schema_Bv9OdW1f.standardSchemaToJSONSchema((0, _mastra_core_schema.toStandardSchema)(output));
+				const jsonSchema = require_schema_D_ikovK6.standardSchemaToJSONSchema((0, _mastra_core_schema.toStandardSchema)(output));
 				result = await agent.generateLegacy(prompt, {
 					experimental_output: jsonSchema,
 					maxSteps: 100
@@ -47066,4 +47212,4 @@ const agentBuilderWorkflows = {
 //#endregion
 exports.agentBuilderWorkflows = agentBuilderWorkflows;
 
-//# sourceMappingURL=dist-CaVro31X.cjs.map
+//# sourceMappingURL=dist-Du9y2ur5.cjs.map