@mastra/editor 0.15.7-alpha.1 → 0.16.0-alpha.2

package/dist/index.cjs

@@ -733,6 +733,13 @@ function getProvidedAgentRecordFields(input) {
 	if (status !== void 0) recordFields.status = status;
 	return Object.keys(recordFields).length > 1 ? recordFields : null;
 }
+function isMemoryIdRef(ref) {
+	return !!ref && "type" in ref && ref.type === "id";
+}
+/** Tagged inline refs and legacy untagged configs both resolve to the serialized config. */
+function unwrapInlineMemory(ref) {
+	return "type" in ref && ref.type === "inline" ? ref.config : ref;
+}
 var EditorAgentNamespace = class extends CrudEditorNamespace {
 	constructor(..._args) {
 		super(..._args);
@@ -1074,6 +1081,41 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
 		} : { ...variant.value };
 		return result;
 	}
+	/**
+	* Accumulate matching memory variants. Inline configs shallow-merge like
+	* other object fields, but a registered-memory reference replaces whatever
+	* has accumulated (and a later inline variant replaces a reference), so the
+	* result is never a hybrid of a reference and inline config.
+	*/
+	accumulateMemoryVariants(variants, context) {
+		let result;
+		for (const variant of variants) {
+			if (variant.rules && !evaluateRuleGroup(variant.rules, context)) continue;
+			if (isMemoryIdRef(variant.value)) {
+				result = variant.value;
+				continue;
+			}
+			const inline = unwrapInlineMemory(variant.value);
+			result = result && !isMemoryIdRef(result) ? {
+				...unwrapInlineMemory(result),
+				...inline
+			} : { ...inline };
+		}
+		return result;
+	}
+	resolveConditionalMemory(variants) {
+		const registeredMemory = /* @__PURE__ */ new Map();
+		const usableVariants = variants.filter((variant) => {
+			if (!isMemoryIdRef(variant.value)) return true;
+			const registered = this.resolveRegisteredMemory(variant.value.memoryId);
+			if (registered) registeredMemory.set(variant.value.memoryId, registered);
+			return Boolean(registered);
+		});
+		return ({ requestContext }) => {
+			const resolved = this.accumulateMemoryVariants(usableVariants, requestContext.toJSON());
+			return isMemoryIdRef(resolved) ? registeredMemory.get(resolved.memoryId) : this.resolveStoredMemory(resolved);
+		};
+	}
 	async createAgentFromStoredConfig(storedAgent) {
 		if (!this.mastra) throw new Error("MastraEditor is not registered with a Mastra instance");
 		this.logger?.debug(`[createAgentFromStoredConfig] Creating agent from stored config "${storedAgent.id}"`);
@@ -1138,11 +1180,7 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
 			const resolved = Array.isArray(variants[0]?.value) ? this.accumulateArrayVariants(variants, ctx) : this.accumulateObjectVariants(variants, ctx);
 			return this.resolveStoredAgents(resolved);
 		} : this.resolveStoredAgents(storedAgent.agents);
-		const memory = hasConditionalMemory ? ({ requestContext }) => {
-			const ctx = requestContext.toJSON();
-			const resolved = this.accumulateObjectVariants(storedAgent.memory, ctx);
-			return this.resolveStoredMemory(resolved);
-		} : this.resolveStoredMemory(storedAgent.memory);
+		const memory = hasConditionalMemory ? this.resolveConditionalMemory(storedAgent.memory) : this.resolveStoredMemory(storedAgent.memory);
 		const scorers = hasConditionalScorers ? async ({ requestContext }) => {
 			const ctx = requestContext.toJSON();
 			const resolved = this.accumulateObjectVariants(storedAgent.scorers, ctx);
@@ -1485,8 +1523,8 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
 		}
 		return resolvedAgents;
 	}
-	resolveStoredMemory(memoryConfig) {
-		if (!memoryConfig) {
+	resolveStoredMemory(memoryRef) {
+		if (!memoryRef) {
 			this.logger?.debug(`[resolveStoredMemory] No memory config provided`);
 			return;
 		}
@@ -1494,6 +1532,22 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
 			this.logger?.warn("MastraEditor not registered with Mastra instance. Cannot instantiate memory.");
 			return;
 		}
+		if (isMemoryIdRef(memoryRef)) return this.resolveRegisteredMemory(memoryRef.memoryId);
+		return this.buildInlineMemory(unwrapInlineMemory(memoryRef));
+	}
+	/**
+	* Look up a Memory instance registered on Mastra, by registry key first and
+	* then by the instance's own id. A missing reference is not fatal: the agent
+	* runs without memory and stored threads/messages are left untouched.
+	*/
+	resolveRegisteredMemory(memoryId) {
+		const registry = this.mastra?.listMemory() ?? {};
+		const memory = registry[memoryId] ?? Object.values(registry).find((m) => m.id === memoryId);
+		if (!memory) this.logger?.warn(`Memory "${memoryId}" referenced in stored agent but not registered in Mastra. The agent will run without memory.`);
+		return memory;
+	}
+	buildInlineMemory(memoryConfig) {
+		if (!this.mastra) return void 0;
 		try {
 			let vector;
 			if (memoryConfig.vector) {
@@ -1604,7 +1658,12 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
 		const workflowKeys = Object.keys(workflows || {});
 		const agentsResolved = await agent.listAgents({ requestContext });
 		const agentKeys = Object.keys(agentsResolved || {});
-		const memoryConfig = (await agent.getMemory({ requestContext }))?.getConfig();
+		const memory = await agent.getMemory({ requestContext });
+		const registeredMemoryKey = memory ? Object.entries(this.mastra?.listMemory() ?? {}).find(([, registered]) => registered === memory)?.[0] : void 0;
+		const memoryConfig = registeredMemoryKey ? {
+			type: "id",
+			memoryId: registeredMemoryKey
+		} : memory?.getConfig();
 		let storedScorers;
 		const resolvedScorers = await agent.listScorers({ requestContext });
 		if (resolvedScorers && Object.keys(resolvedScorers).length > 0) {