@mastra/server 1.70.0 → 1.71.0-alpha.1

package/dist/{dist-B3wkDytS.js → dist-D19QgTH4.js}

@@ -4637,7 +4637,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-B0ISVOJX.js
+//#region ../memory/dist/src-DsewkOlu.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -27648,6 +27648,285 @@ async function summarizeConversation(opts) {
 		usage: result.usage
 	};
 }
+const UPDATE_WORKING_MEMORY_TOOL_NAME = "updateWorkingMemory";
+const SET_WORKING_MEMORY_TOOL_NAME = "setWorkingMemory";
+/**
+* Deep merges two objects, with special handling for null values (delete) and arrays (replace).
+* - Object properties are recursively merged
+* - null values in the update will delete the corresponding property, even when the property
+*   or its parent object does not exist yet (so padded nulls never get stored literally)
+* - Arrays are replaced entirely (not merged element-by-element)
+* - Primitive values are overwritten
+* - The returned object is always newly constructed and never aliases `update`
+*/
+function deepMergeWorkingMemory(existing, update) {
+	if (!update || typeof update !== "object" || Object.keys(update).length === 0) return existing && typeof existing === "object" ? { ...existing } : {};
+	const result = { ...existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {} };
+	for (const key of Object.keys(update)) {
+		const updateValue = update[key];
+		const existingValue = result[key];
+		if (updateValue === void 0) continue;
+		if (updateValue === null) delete result[key];
+		else if (Array.isArray(updateValue)) result[key] = updateValue;
+		else if (typeof updateValue === "object") result[key] = deepMergeWorkingMemory(existingValue && typeof existingValue === "object" && !Array.isArray(existingValue) ? existingValue : void 0, updateValue);
+		else result[key] = updateValue;
+	}
+	return result;
+}
+/** `.nullable()` wraps a schema as `anyOf: [schema, { type: 'null' }]`; unwrap it so its declared fields are visible. */
+function resolveNullableBranch(value, schema) {
+	const branches = schema.anyOf ?? schema.oneOf;
+	if (!Array.isArray(branches)) return schema;
+	const kind = Array.isArray(value) ? "array" : "object";
+	const matching = branches.filter((branch) => branch.type === kind);
+	return matching.length === 1 ? matching[0] : schema;
+}
+function stripNullsFromOptional(value, rawSchema) {
+	const schema = resolveNullableBranch(value, rawSchema);
+	if (Array.isArray(value)) {
+		const itemSchema = schema.items ?? {};
+		return value.map((item) => stripNullsFromOptional(item, itemSchema));
+	}
+	if (typeof value === "object" && value !== null) {
+		const properties = schema.properties ?? {};
+		const required = schema.required ?? [];
+		const result = {};
+		for (const [key, propertyValue] of Object.entries(value)) {
+			if (propertyValue === null && Object.hasOwn(properties, key) && !required.includes(key)) continue;
+			result[key] = stripNullsFromOptional(propertyValue, properties[key] ?? {});
+		}
+		return result;
+	}
+	return value;
+}
+const updateWorkingMemoryTool = (memoryConfig) => {
+	const schema = memoryConfig?.workingMemory?.schema;
+	let inputSchema = {
+		$schema: "http://json-schema.org/draft-07/schema#",
+		type: "object",
+		properties: { memory: {
+			type: "string",
+			description: `The Markdown formatted working memory content to store. This MUST be a string. Never pass an object.`
+		} },
+		required: ["memory"]
+	};
+	if (schema) {
+		const standardSchema = isStandardSchemaWithJSON(schema) ? schema : toStandardSchema(schema);
+		const jsonSchema = standardSchemaToJSONSchema(standardSchema, { io: "input" });
+		delete jsonSchema.$schema;
+		const wrappedJsonSchema = {
+			$schema: "http://json-schema.org/draft-07/schema#",
+			type: "object",
+			description: "The JSON formatted working memory content to store.",
+			properties: { memory: jsonSchema },
+			required: ["memory"]
+		};
+		const validateMemory = (memoryValue) => standardSchema["~standard"].validate(memoryValue);
+		const toWrappedResult = (result) => "issues" in result && result.issues ? result : { value: { memory: result.value } };
+		inputSchema = { "~standard": {
+			version: 1,
+			vendor: "mastra",
+			validate: (value) => {
+				const memoryValue = stripNullsFromOptional(!!value && typeof value === "object" && !Array.isArray(value) && "memory" in value ? value.memory : value, jsonSchema);
+				const result = validateMemory(memoryValue);
+				return result instanceof Promise ? result.then(toWrappedResult) : toWrappedResult(result);
+			},
+			jsonSchema: {
+				input: () => wrappedJsonSchema,
+				output: () => wrappedJsonSchema
+			}
+		} };
+	}
+	const usesMergeSemantics = Boolean(schema);
+	const useStateSignals = memoryConfig?.workingMemory?.useStateSignals === true;
+	const stateSignalsPreamble = `The current working memory state is delivered to you each turn by the system inside a <working-memory>...</working-memory> block. That block is system-emitted state, NOT something the user typed — never describe it as the user sharing it. Read from it directly when answering. Only call this tool when the user provides genuinely NEW or CHANGED facts that should be persisted; do NOT call it to re-save unchanged data.`;
+	return createTool({
+		id: "update-working-memory",
+		description: schema ? useStateSignals ? `${stateSignalsPreamble} Data is merged with existing memory — only include fields you want to add or update.` : `Update the working memory with new information. Data is merged with existing memory - only include fields you want to add or update. To preserve existing data, omit the field entirely. Arrays are replaced entirely when provided, so pass the complete array or omit it to keep the existing values.` : useStateSignals ? `${stateSignalsPreamble} Pass the full updated Markdown blob as a string in the memory field.` : `Update the working memory with new information. Any data not included will be overwritten. Always pass data as string to the memory field. Never pass an object.`,
+		inputSchema,
+		...usesMergeSemantics ? { strict: false } : {},
+		execute: async (inputData, context) => {
+			const workingMemoryInput = inputData;
+			const threadId = context?.agent?.threadId;
+			const resourceId = context?.agent?.resourceId;
+			const memory = context?.memory;
+			if (!memory) throw new Error("Memory instance is required for working memory updates");
+			const scope = memoryConfig?.workingMemory?.scope || "resource";
+			if (scope === "thread" && !threadId) throw new Error("Thread ID is required for thread-scoped working memory updates");
+			if (scope === "resource" && !resourceId) throw new Error("Resource ID is required for resource-scoped working memory updates");
+			if (threadId) {
+				let thread = await memory.getThreadById({ threadId });
+				if (!thread) thread = await memory.createThread({
+					threadId,
+					resourceId,
+					memoryConfig
+				});
+				if (thread.resourceId && resourceId && thread.resourceId !== resourceId) throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
+			}
+			let workingMemory;
+			if (usesMergeSemantics) {
+				const existingRaw = await memory.getWorkingMemory({
+					threadId,
+					resourceId,
+					memoryConfig
+				});
+				let existingData = null;
+				if (existingRaw) try {
+					existingData = typeof existingRaw === "string" ? JSON.parse(existingRaw) : existingRaw;
+				} catch {
+					existingData = null;
+				}
+				const memoryInput = workingMemoryInput.memory;
+				if (memoryInput === void 0 || memoryInput === null) return {
+					success: true,
+					message: "No memory data provided, existing memory unchanged."
+				};
+				let newData;
+				if (typeof memoryInput === "string") try {
+					newData = JSON.parse(memoryInput);
+				} catch (parseError) {
+					const errorMessage = parseError instanceof Error ? parseError.message : String(parseError);
+					throw new Error(`Failed to parse working memory input as JSON: ${errorMessage}. Raw input: ${memoryInput.length > 500 ? memoryInput.slice(0, 500) + "..." : memoryInput}`);
+				}
+				else newData = memoryInput;
+				const mergedData = deepMergeWorkingMemory(existingData, newData);
+				workingMemory = JSON.stringify(mergedData);
+			} else {
+				const memoryInput = workingMemoryInput.memory;
+				workingMemory = typeof memoryInput === "string" ? memoryInput : JSON.stringify(memoryInput);
+				const existingRaw = await memory.getWorkingMemory({
+					threadId,
+					resourceId,
+					memoryConfig
+				});
+				if (existingRaw) {
+					const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
+					if (template?.content) {
+						const normalizedNew = workingMemory.replace(/\s+/g, " ").trim();
+						const normalizedTemplate = template.content.replace(/\s+/g, " ").trim();
+						const normalizedExisting = existingRaw.replace(/\s+/g, " ").trim();
+						if (normalizedNew === normalizedTemplate && normalizedExisting !== normalizedTemplate) return {
+							success: false,
+							message: "Attempted to replace existing working memory with empty template. Update skipped to prevent data loss."
+						};
+					}
+				}
+			}
+			await memory.updateWorkingMemory({
+				threadId,
+				resourceId,
+				workingMemory,
+				memoryConfig
+			});
+			return { success: true };
+		}
+	});
+};
+const __experimental_updateWorkingMemoryToolVNext = (config) => {
+	return createTool({
+		id: "update-working-memory",
+		description: "Update the working memory with new information.",
+		inputSchema: {
+			$schema: "http://json-schema.org/draft-07/schema#",
+			type: "object",
+			properties: {
+				newMemory: {
+					type: "string",
+					description: `The ${config.workingMemory?.schema ? "JSON" : "Markdown"} formatted working memory content to store`
+				},
+				searchString: {
+					type: "string",
+					description: "The working memory string to find. Will be replaced with the newMemory string. If this is omitted or doesn't exist, the newMemory string will be appended to the end of your working memory. Replacing single lines at a time is encouraged for greater accuracy. If updateReason is not 'append-new-memory', this search string must be provided or the tool call will be rejected."
+				},
+				updateReason: {
+					type: "string",
+					enum: [
+						"append-new-memory",
+						"clarify-existing-memory",
+						"replace-irrelevant-memory"
+					],
+					description: "The reason you're updating working memory. Passing any value other than 'append-new-memory' requires a searchString to be provided. Defaults to append-new-memory"
+				}
+			}
+		},
+		execute: async (inputData, context) => {
+			const workingMemoryInput = inputData;
+			const threadId = context?.agent?.threadId;
+			const resourceId = context?.agent?.resourceId;
+			const memory = context?.memory;
+			if (!memory) throw new Error("Memory instance is required for working memory updates");
+			const scope = config.workingMemory?.scope || "resource";
+			if (scope === "thread" && !threadId) throw new Error("Thread ID is required for thread-scoped working memory updates");
+			if (scope === "resource" && !resourceId) throw new Error("Resource ID is required for resource-scoped working memory updates");
+			if (threadId) {
+				let thread = await memory.getThreadById({ threadId });
+				if (!thread) thread = await memory.createThread({
+					threadId,
+					resourceId,
+					memoryConfig: config
+				});
+				if (thread.resourceId && resourceId && thread.resourceId !== resourceId) throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
+			}
+			const workingMemory = workingMemoryInput.newMemory || "";
+			if (!workingMemoryInput.updateReason) workingMemoryInput.updateReason = `append-new-memory`;
+			if (workingMemoryInput.searchString && config.workingMemory?.scope === `resource` && workingMemoryInput.updateReason === `replace-irrelevant-memory`) workingMemoryInput.searchString = void 0;
+			if (workingMemoryInput.updateReason === `append-new-memory` && workingMemoryInput.searchString) workingMemoryInput.searchString = void 0;
+			if (workingMemoryInput.updateReason !== `append-new-memory` && !workingMemoryInput.searchString) return {
+				success: false,
+				reason: `updateReason was ${workingMemoryInput.updateReason} but no searchString was provided. Unable to replace undefined with "${workingMemoryInput.newMemory}"`
+			};
+			const result = await memory.__experimental_updateWorkingMemoryVNext({
+				threadId,
+				resourceId,
+				workingMemory,
+				searchString: workingMemoryInput.searchString,
+				memoryConfig: config
+			});
+			if (result) return result;
+			return { success: true };
+		}
+	});
+};
+/**
+* Returns the working-memory tool plus the wire name it should be registered under.
+*
+* - Default delivery (`useStateSignals: false`): wire name `updateWorkingMemory`,
+*   identical shape to today.
+* - State-signals delivery (`useStateSignals: true`): wire name `setWorkingMemory`.
+*   The rename keeps legacy strip filters (which match the literal `updateWorkingMemory`)
+*   from removing tool-call parts so they persist as a normal audit trail. Any
+*   future state-signal-specific tweaks to the tool (e.g. delta-aware results,
+*   scoped descriptions) belong here.
+*
+* The VNext vs default tool body decision is left to the caller because Memory
+* owns the `isVNextWorkingMemoryConfig` check; pass `vNext: true` to use the
+* search-and-replace shape.
+*/
+function createWorkingMemoryTool(config, options = {}) {
+	const useStateSignals = config.workingMemory?.useStateSignals === true;
+	const tool = options.vNext ? __experimental_updateWorkingMemoryToolVNext(config) : updateWorkingMemoryTool(config);
+	return {
+		name: useStateSignals ? SET_WORKING_MEMORY_TOOL_NAME : UPDATE_WORKING_MEMORY_TOOL_NAME,
+		tool
+	};
+}
+/**
+* The structured-output schema for this extractor stays generic because every structured extractor shares one
+* response object: a strict working-memory schema there would make one invalid document fail every sibling
+* extractor. The configured schema is enforced here instead, with its own validator, before anything is stored.
+* Like the working memory tool, nulls in optional fields are treated as "not provided" rather than as invalid.
+*/
+async function validateAgainstConfiguredSchema(schema, value) {
+	const standardSchema = toStandardSchema(schema);
+	const jsonSchema = standardSchemaToJSONSchema(standardSchema, { io: "input" });
+	const result = await standardSchema["~standard"].validate(stripNullsFromOptional(value, jsonSchema));
+	if (!result.issues) return result.value;
+	const details = result.issues.map((issue) => {
+		const path = issue.path?.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+		return path ? `${path}: ${issue.message}` : issue.message;
+	}).join("; ");
+	throw new Error(`Working memory update does not match the configured schema, so it was not saved: ${details}`);
+}
 async function getWorkingMemoryDetails(context) {
 	const memory = context.memory;
 	const memoryConfig = parseMemoryRequestContext(context.requestContext)?.memoryConfig;
@@ -27692,9 +27971,13 @@ var WorkingMemoryExtractor = class extends Extractor {
 			},
 			onExtracted: async ({ current, memory, threadId, resourceId, requestContext }) => {
 				const memoryConfig = parseMemoryRequestContext(requestContext)?.memoryConfig;
-				const config = memory.getMergedThreadConfig(memoryConfig ?? {});
-				if (Boolean(config.workingMemory?.schema) && current === null) return;
-				const workingMemory = typeof current === "string" ? current : JSON.stringify(current) ?? "";
+				const configuredSchema = memory.getMergedThreadConfig(memoryConfig ?? {}).workingMemory?.schema;
+				let document = current;
+				if (configuredSchema) {
+					if (current === null) return;
+					document = await validateAgainstConfiguredSchema(configuredSchema, current);
+				}
+				const workingMemory = typeof document === "string" ? document : JSON.stringify(document) ?? "";
 				if (!workingMemory.trim()) return;
 				await memory.updateWorkingMemory({
 					threadId,
@@ -27702,7 +27985,7 @@ var WorkingMemoryExtractor = class extends Extractor {
 					workingMemory,
 					memoryConfig
 				});
-				return current;
+				return document;
 			}
 		});
 	}
@@ -28650,259 +28933,6 @@ const recallTool = (_memoryConfig, options) => {
 		}
 	});
 };
-const UPDATE_WORKING_MEMORY_TOOL_NAME = "updateWorkingMemory";
-const SET_WORKING_MEMORY_TOOL_NAME = "setWorkingMemory";
-/**
-* Deep merges two objects, with special handling for null values (delete) and arrays (replace).
-* - Object properties are recursively merged
-* - null values in the update will delete the corresponding property, even when the property
-*   or its parent object does not exist yet (so padded nulls never get stored literally)
-* - Arrays are replaced entirely (not merged element-by-element)
-* - Primitive values are overwritten
-* - The returned object is always newly constructed and never aliases `update`
-*/
-function deepMergeWorkingMemory(existing, update) {
-	if (!update || typeof update !== "object" || Object.keys(update).length === 0) return existing && typeof existing === "object" ? { ...existing } : {};
-	const result = { ...existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {} };
-	for (const key of Object.keys(update)) {
-		const updateValue = update[key];
-		const existingValue = result[key];
-		if (updateValue === void 0) continue;
-		if (updateValue === null) delete result[key];
-		else if (Array.isArray(updateValue)) result[key] = updateValue;
-		else if (typeof updateValue === "object") result[key] = deepMergeWorkingMemory(existingValue && typeof existingValue === "object" && !Array.isArray(existingValue) ? existingValue : void 0, updateValue);
-		else result[key] = updateValue;
-	}
-	return result;
-}
-function stripNullsFromOptional(value, schema) {
-	if (Array.isArray(value)) {
-		const itemSchema = schema.items ?? {};
-		return value.map((item) => stripNullsFromOptional(item, itemSchema));
-	}
-	if (typeof value === "object" && value !== null) {
-		const properties = schema.properties ?? {};
-		const required = schema.required ?? [];
-		const result = {};
-		for (const [key, propertyValue] of Object.entries(value)) {
-			if (propertyValue === null && !required.includes(key)) continue;
-			result[key] = stripNullsFromOptional(propertyValue, properties[key] ?? {});
-		}
-		return result;
-	}
-	return value;
-}
-const updateWorkingMemoryTool = (memoryConfig) => {
-	const schema = memoryConfig?.workingMemory?.schema;
-	let inputSchema = {
-		$schema: "http://json-schema.org/draft-07/schema#",
-		type: "object",
-		properties: { memory: {
-			type: "string",
-			description: `The Markdown formatted working memory content to store. This MUST be a string. Never pass an object.`
-		} },
-		required: ["memory"]
-	};
-	if (schema) {
-		const standardSchema = isStandardSchemaWithJSON(schema) ? schema : toStandardSchema(schema);
-		const jsonSchema = standardSchemaToJSONSchema(standardSchema, { io: "input" });
-		delete jsonSchema.$schema;
-		const wrappedJsonSchema = {
-			$schema: "http://json-schema.org/draft-07/schema#",
-			type: "object",
-			description: "The JSON formatted working memory content to store.",
-			properties: { memory: jsonSchema },
-			required: ["memory"]
-		};
-		const validateMemory = (memoryValue) => standardSchema["~standard"].validate(memoryValue);
-		const toWrappedResult = (result) => "issues" in result && result.issues ? result : { value: { memory: result.value } };
-		inputSchema = { "~standard": {
-			version: 1,
-			vendor: "mastra",
-			validate: (value) => {
-				const memoryValue = stripNullsFromOptional(!!value && typeof value === "object" && !Array.isArray(value) && "memory" in value ? value.memory : value, jsonSchema);
-				const result = validateMemory(memoryValue);
-				return result instanceof Promise ? result.then(toWrappedResult) : toWrappedResult(result);
-			},
-			jsonSchema: {
-				input: () => wrappedJsonSchema,
-				output: () => wrappedJsonSchema
-			}
-		} };
-	}
-	const usesMergeSemantics = Boolean(schema);
-	const useStateSignals = memoryConfig?.workingMemory?.useStateSignals === true;
-	const stateSignalsPreamble = `The current working memory state is delivered to you each turn by the system inside a <working-memory>...</working-memory> block. That block is system-emitted state, NOT something the user typed — never describe it as the user sharing it. Read from it directly when answering. Only call this tool when the user provides genuinely NEW or CHANGED facts that should be persisted; do NOT call it to re-save unchanged data.`;
-	return createTool({
-		id: "update-working-memory",
-		description: schema ? useStateSignals ? `${stateSignalsPreamble} Data is merged with existing memory — only include fields you want to add or update.` : `Update the working memory with new information. Data is merged with existing memory - only include fields you want to add or update. To preserve existing data, omit the field entirely. Arrays are replaced entirely when provided, so pass the complete array or omit it to keep the existing values.` : useStateSignals ? `${stateSignalsPreamble} Pass the full updated Markdown blob as a string in the memory field.` : `Update the working memory with new information. Any data not included will be overwritten. Always pass data as string to the memory field. Never pass an object.`,
-		inputSchema,
-		...usesMergeSemantics ? { strict: false } : {},
-		execute: async (inputData, context) => {
-			const workingMemoryInput = inputData;
-			const threadId = context?.agent?.threadId;
-			const resourceId = context?.agent?.resourceId;
-			const memory = context?.memory;
-			if (!memory) throw new Error("Memory instance is required for working memory updates");
-			const scope = memoryConfig?.workingMemory?.scope || "resource";
-			if (scope === "thread" && !threadId) throw new Error("Thread ID is required for thread-scoped working memory updates");
-			if (scope === "resource" && !resourceId) throw new Error("Resource ID is required for resource-scoped working memory updates");
-			if (threadId) {
-				let thread = await memory.getThreadById({ threadId });
-				if (!thread) thread = await memory.createThread({
-					threadId,
-					resourceId,
-					memoryConfig
-				});
-				if (thread.resourceId && resourceId && thread.resourceId !== resourceId) throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
-			}
-			let workingMemory;
-			if (usesMergeSemantics) {
-				const existingRaw = await memory.getWorkingMemory({
-					threadId,
-					resourceId,
-					memoryConfig
-				});
-				let existingData = null;
-				if (existingRaw) try {
-					existingData = typeof existingRaw === "string" ? JSON.parse(existingRaw) : existingRaw;
-				} catch {
-					existingData = null;
-				}
-				const memoryInput = workingMemoryInput.memory;
-				if (memoryInput === void 0 || memoryInput === null) return {
-					success: true,
-					message: "No memory data provided, existing memory unchanged."
-				};
-				let newData;
-				if (typeof memoryInput === "string") try {
-					newData = JSON.parse(memoryInput);
-				} catch (parseError) {
-					const errorMessage = parseError instanceof Error ? parseError.message : String(parseError);
-					throw new Error(`Failed to parse working memory input as JSON: ${errorMessage}. Raw input: ${memoryInput.length > 500 ? memoryInput.slice(0, 500) + "..." : memoryInput}`);
-				}
-				else newData = memoryInput;
-				const mergedData = deepMergeWorkingMemory(existingData, newData);
-				workingMemory = JSON.stringify(mergedData);
-			} else {
-				const memoryInput = workingMemoryInput.memory;
-				workingMemory = typeof memoryInput === "string" ? memoryInput : JSON.stringify(memoryInput);
-				const existingRaw = await memory.getWorkingMemory({
-					threadId,
-					resourceId,
-					memoryConfig
-				});
-				if (existingRaw) {
-					const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
-					if (template?.content) {
-						const normalizedNew = workingMemory.replace(/\s+/g, " ").trim();
-						const normalizedTemplate = template.content.replace(/\s+/g, " ").trim();
-						const normalizedExisting = existingRaw.replace(/\s+/g, " ").trim();
-						if (normalizedNew === normalizedTemplate && normalizedExisting !== normalizedTemplate) return {
-							success: false,
-							message: "Attempted to replace existing working memory with empty template. Update skipped to prevent data loss."
-						};
-					}
-				}
-			}
-			await memory.updateWorkingMemory({
-				threadId,
-				resourceId,
-				workingMemory,
-				memoryConfig
-			});
-			return { success: true };
-		}
-	});
-};
-const __experimental_updateWorkingMemoryToolVNext = (config) => {
-	return createTool({
-		id: "update-working-memory",
-		description: "Update the working memory with new information.",
-		inputSchema: {
-			$schema: "http://json-schema.org/draft-07/schema#",
-			type: "object",
-			properties: {
-				newMemory: {
-					type: "string",
-					description: `The ${config.workingMemory?.schema ? "JSON" : "Markdown"} formatted working memory content to store`
-				},
-				searchString: {
-					type: "string",
-					description: "The working memory string to find. Will be replaced with the newMemory string. If this is omitted or doesn't exist, the newMemory string will be appended to the end of your working memory. Replacing single lines at a time is encouraged for greater accuracy. If updateReason is not 'append-new-memory', this search string must be provided or the tool call will be rejected."
-				},
-				updateReason: {
-					type: "string",
-					enum: [
-						"append-new-memory",
-						"clarify-existing-memory",
-						"replace-irrelevant-memory"
-					],
-					description: "The reason you're updating working memory. Passing any value other than 'append-new-memory' requires a searchString to be provided. Defaults to append-new-memory"
-				}
-			}
-		},
-		execute: async (inputData, context) => {
-			const workingMemoryInput = inputData;
-			const threadId = context?.agent?.threadId;
-			const resourceId = context?.agent?.resourceId;
-			const memory = context?.memory;
-			if (!memory) throw new Error("Memory instance is required for working memory updates");
-			const scope = config.workingMemory?.scope || "resource";
-			if (scope === "thread" && !threadId) throw new Error("Thread ID is required for thread-scoped working memory updates");
-			if (scope === "resource" && !resourceId) throw new Error("Resource ID is required for resource-scoped working memory updates");
-			if (threadId) {
-				let thread = await memory.getThreadById({ threadId });
-				if (!thread) thread = await memory.createThread({
-					threadId,
-					resourceId,
-					memoryConfig: config
-				});
-				if (thread.resourceId && resourceId && thread.resourceId !== resourceId) throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
-			}
-			const workingMemory = workingMemoryInput.newMemory || "";
-			if (!workingMemoryInput.updateReason) workingMemoryInput.updateReason = `append-new-memory`;
-			if (workingMemoryInput.searchString && config.workingMemory?.scope === `resource` && workingMemoryInput.updateReason === `replace-irrelevant-memory`) workingMemoryInput.searchString = void 0;
-			if (workingMemoryInput.updateReason === `append-new-memory` && workingMemoryInput.searchString) workingMemoryInput.searchString = void 0;
-			if (workingMemoryInput.updateReason !== `append-new-memory` && !workingMemoryInput.searchString) return {
-				success: false,
-				reason: `updateReason was ${workingMemoryInput.updateReason} but no searchString was provided. Unable to replace undefined with "${workingMemoryInput.newMemory}"`
-			};
-			const result = await memory.__experimental_updateWorkingMemoryVNext({
-				threadId,
-				resourceId,
-				workingMemory,
-				searchString: workingMemoryInput.searchString,
-				memoryConfig: config
-			});
-			if (result) return result;
-			return { success: true };
-		}
-	});
-};
-/**
-* Returns the working-memory tool plus the wire name it should be registered under.
-*
-* - Default delivery (`useStateSignals: false`): wire name `updateWorkingMemory`,
-*   identical shape to today.
-* - State-signals delivery (`useStateSignals: true`): wire name `setWorkingMemory`.
-*   The rename keeps legacy strip filters (which match the literal `updateWorkingMemory`)
-*   from removing tool-call parts so they persist as a normal audit trail. Any
-*   future state-signal-specific tweaks to the tool (e.g. delta-aware results,
-*   scoped descriptions) belong here.
-*
-* The VNext vs default tool body decision is left to the caller because Memory
-* owns the `isVNextWorkingMemoryConfig` check; pass `vNext: true` to use the
-* search-and-replace shape.
-*/
-function createWorkingMemoryTool(config, options = {}) {
-	const useStateSignals = config.workingMemory?.useStateSignals === true;
-	const tool = options.vNext ? __experimental_updateWorkingMemoryToolVNext(config) : updateWorkingMemoryTool(config);
-	return {
-		name: useStateSignals ? SET_WORKING_MEMORY_TOOL_NAME : UPDATE_WORKING_MEMORY_TOOL_NAME,
-		tool
-	};
-}
 /**
 * WorkingMemoryStateProcessor
 *
@@ -49203,4 +49233,4 @@ const agentBuilderWorkflows = {
 //#endregion
 export { agentBuilderWorkflows };
 
-//# sourceMappingURL=dist-B3wkDytS.js.map
+//# sourceMappingURL=dist-D19QgTH4.js.map