@mastra/server 1.79.0-alpha.9 → 1.79.0

package/dist/memory-CwwkVDh1.cjs

@@ -0,0 +1,1906 @@
+const require_rolldown_runtime = require("./rolldown-runtime-BwC_XMyb.cjs");
+const require_http_exception = require("./http-exception-CKDHupKw.cjs");
+const require_route_builder = require("./route-builder-B2Qhhd7C.cjs");
+const require_server_handlers_error = require("./server/handlers/error.cjs");
+const require_utils = require("./utils-dDLIDg8O.cjs");
+const require_memory = require("./memory-CizEIbl1.cjs");
+const require_server_handlers_gateway_memory_client = require("./server/handlers/gateway-memory-client.cjs");
+let _mastra_core_agent = require("@mastra/core/agent");
+let _mastra_core_error = require("@mastra/core/error");
+let _mastra_core_utils = require("@mastra/core/utils");
+//#region src/server/handlers/memory.ts
+var memory_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	AWAIT_BUFFER_STATUS_ROUTE: () => AWAIT_BUFFER_STATUS_ROUTE,
+	CLONE_THREAD_ROUTE: () => CLONE_THREAD_ROUTE,
+	CREATE_THREAD_NETWORK_ROUTE: () => CREATE_THREAD_NETWORK_ROUTE,
+	CREATE_THREAD_ROUTE: () => CREATE_THREAD_ROUTE,
+	DELETE_MESSAGES_NETWORK_ROUTE: () => DELETE_MESSAGES_NETWORK_ROUTE,
+	DELETE_MESSAGES_ROUTE: () => DELETE_MESSAGES_ROUTE,
+	DELETE_THREAD_NETWORK_ROUTE: () => DELETE_THREAD_NETWORK_ROUTE,
+	DELETE_THREAD_ROUTE: () => DELETE_THREAD_ROUTE,
+	GET_MEMORY_CONFIG_ROUTE: () => GET_MEMORY_CONFIG_ROUTE,
+	GET_MEMORY_STATUS_NETWORK_ROUTE: () => GET_MEMORY_STATUS_NETWORK_ROUTE,
+	GET_MEMORY_STATUS_ROUTE: () => GET_MEMORY_STATUS_ROUTE,
+	GET_OBSERVATIONAL_MEMORY_ROUTE: () => GET_OBSERVATIONAL_MEMORY_ROUTE,
+	GET_THREAD_BY_ID_NETWORK_ROUTE: () => GET_THREAD_BY_ID_NETWORK_ROUTE,
+	GET_THREAD_BY_ID_ROUTE: () => GET_THREAD_BY_ID_ROUTE,
+	GET_WORKING_MEMORY_ROUTE: () => GET_WORKING_MEMORY_ROUTE,
+	LIST_MESSAGES_NETWORK_ROUTE: () => LIST_MESSAGES_NETWORK_ROUTE,
+	LIST_MESSAGES_ROUTE: () => LIST_MESSAGES_ROUTE,
+	LIST_THREADS_NETWORK_ROUTE: () => LIST_THREADS_NETWORK_ROUTE,
+	LIST_THREADS_ROUTE: () => LIST_THREADS_ROUTE,
+	SAVE_MESSAGES_NETWORK_ROUTE: () => SAVE_MESSAGES_NETWORK_ROUTE,
+	SAVE_MESSAGES_ROUTE: () => SAVE_MESSAGES_ROUTE,
+	SEARCH_MEMORY_ROUTE: () => SEARCH_MEMORY_ROUTE,
+	TRANSFER_THREAD_ROUTE: () => TRANSFER_THREAD_ROUTE,
+	UPDATE_THREAD_NETWORK_ROUTE: () => UPDATE_THREAD_NETWORK_ROUTE,
+	UPDATE_THREAD_ROUTE: () => UPDATE_THREAD_ROUTE,
+	UPDATE_WORKING_MEMORY_ROUTE: () => UPDATE_WORKING_MEMORY_ROUTE,
+	getTextContent: () => getTextContent
+});
+function hasFGAUser(requestContext) {
+	const user = requestContext?.get("user");
+	return !!user && typeof user === "object";
+}
+function shouldFilterThreadsWithFGA(mastra, requestContext) {
+	return !!mastra.getServer?.()?.fga && hasFGAUser(requestContext);
+}
+async function filterAccessibleThreads({ mastra, requestContext, threads }) {
+	const fgaProvider = mastra.getServer?.()?.fga;
+	if (!fgaProvider || !hasFGAUser(requestContext) || threads.length === 0) return threads;
+	return fgaProvider.filterAccessible(requestContext.get("user"), threads, "thread", require_utils.MastraFGAPermissions.MEMORY_READ);
+}
+function paginateThreads({ threads, page, perPage }) {
+	const effectivePage = page ?? 0;
+	const effectivePerPage = perPage ?? 100;
+	if (effectivePerPage === false) return {
+		threads,
+		page: effectivePage,
+		perPage: false,
+		total: threads.length,
+		hasMore: false
+	};
+	const start = effectivePage * effectivePerPage;
+	const pagedThreads = threads.slice(start, start + effectivePerPage);
+	return {
+		threads: pagedThreads,
+		page: effectivePage,
+		perPage: effectivePerPage,
+		total: threads.length,
+		hasMore: start + pagedThreads.length < threads.length
+	};
+}
+async function enforceDeleteMessagesThreadAccess({ mastra, requestContext, memoryStore, messageIds, effectiveResourceId }) {
+	const { messages } = await memoryStore.listMessagesById({ messageIds });
+	const threadIds = [...new Set(messages.map((m) => m.threadId).filter(Boolean))];
+	if (messages.some((message) => !message.threadId)) throw new require_http_exception.HTTPException(403, { message: "Access denied: unable to verify message thread access" });
+	for (const threadId of threadIds) {
+		const thread = await memoryStore.getThreadById({ threadId });
+		if (!thread) throw new require_http_exception.HTTPException(403, { message: "Access denied: unable to verify message thread access" });
+		await require_utils.enforceThreadAccess({
+			mastra,
+			requestContext,
+			threadId,
+			thread,
+			effectiveResourceId,
+			permission: require_utils.MastraFGAPermissions.MEMORY_DELETE
+		});
+	}
+}
+function getTextContent(message) {
+	if (typeof message.content === "string") return message.content;
+	if (message.content && typeof message.content === "object" && "parts" in message.content) return message.content.parts.find((p) => p.type === "text")?.text || "";
+	return "";
+}
+async function getMemoryFromContext({ mastra, agentId, requestContext, allowMissingAgent = false }) {
+	const logger = mastra.getLogger();
+	let agent;
+	if (agentId) try {
+		agent = mastra.getAgentById(agentId);
+	} catch (error) {
+		logger.debug("Error getting agent from mastra, searching agents for agent", error);
+	}
+	if (agentId && !agent) {
+		logger.debug("Agent not found in registered agents, trying stored agents", { agentId });
+		try {
+			const storedAgent = await mastra.getEditor()?.agent.getById(agentId) ?? null;
+			if (storedAgent) agent = storedAgent;
+		} catch (error) {
+			logger.debug("Error getting stored agent", error);
+		}
+	}
+	if (agentId && !agent) {
+		logger.debug("Stored agent not found, searching sub-agents", { agentId });
+		const agents = mastra.listAgents();
+		if (Object.keys(agents || {}).length) for (const [_, ag] of Object.entries(agents)) try {
+			const subAgents = await ag.listAgents({ requestContext });
+			if (subAgents[agentId]) {
+				agent = subAgents[agentId];
+				break;
+			}
+		} catch (error) {
+			logger.debug("Error getting agent from agent", error);
+		}
+		if (!agent) {
+			if (allowMissingAgent) {
+				logger.debug("Agent not found in any resolution tier, returning null for storage fallback", { agentId });
+				return null;
+			}
+			throw new require_http_exception.HTTPException(404, { message: "Agent not found" });
+		}
+	}
+	if (agent) return await agent?.getMemory({ requestContext });
+}
+/**
+* Gets the storage from context, used as a fallback when agent memory can't be resolved.
+* This covers both cases where no agentId is provided and where the agentId refers to
+* a stored agent whose memory instance can't be hydrated (e.g. no editor configured).
+*/
+function getStorageFromContext({ mastra }) {
+	return mastra.getStorage();
+}
+function agentSupportsMemory(agent) {
+	if (!agent) return true;
+	const candidate = agent;
+	if (typeof candidate.supportsMemory === "function" && !candidate.supportsMemory()) return false;
+	if (typeof candidate.hasOwnMemory === "function" && !candidate.hasOwnMemory()) return false;
+	return true;
+}
+/**
+* Gets the agent from context for OM processor detection.
+*/
+async function getAgentFromContext({ mastra, agentId, requestContext }) {
+	if (!agentId) return null;
+	const logger = mastra.getLogger();
+	let agent = null;
+	try {
+		agent = mastra.getAgentById(agentId);
+	} catch (error) {
+		logger.debug("Error getting agent from mastra", error);
+	}
+	if (!agent) {
+		logger.debug("Agent not found in registered agents, trying stored agents", { agentId });
+		try {
+			const storedAgent = await mastra.getEditor()?.agent.getById(agentId) ?? null;
+			if (storedAgent) agent = storedAgent;
+		} catch (error) {
+			logger.debug("Error getting stored agent", error);
+		}
+	}
+	if (!agent) {
+		logger.debug("Stored agent not found, searching sub-agents", { agentId });
+		const agents = mastra.listAgents();
+		if (Object.keys(agents || {}).length) for (const [_, ag] of Object.entries(agents)) try {
+			const nestedAgent = (await ag.listAgents({ requestContext }))[agentId];
+			if (nestedAgent instanceof _mastra_core_agent.Agent) {
+				agent = nestedAgent;
+				break;
+			}
+		} catch (error) {
+			logger.debug("Error getting agent from agent", error);
+		}
+	}
+	return agent;
+}
+/**
+* Gets Observational Memory configuration from an agent's processors.
+* Returns null if OM is not enabled.
+*/
+async function getOMConfigFromAgent(agent, requestContext) {
+	try {
+		if (typeof agent.resolveProcessorById !== "function") return null;
+		const omProcessor = await agent.resolveProcessorById("observational-memory", requestContext);
+		if (!omProcessor) return null;
+		if (typeof omProcessor.getResolvedConfig === "function") {
+			const resolvedConfig = await omProcessor.getResolvedConfig(requestContext);
+			return {
+				enabled: true,
+				scope: resolvedConfig.scope || "resource",
+				shareTokenBudget: resolvedConfig.shareTokenBudget,
+				messageTokens: resolvedConfig.observation?.messageTokens,
+				observationTokens: resolvedConfig.reflection?.observationTokens,
+				observationModel: resolvedConfig.observation?.model,
+				reflectionModel: resolvedConfig.reflection?.model,
+				observationModelRouting: resolvedConfig.observation?.routing,
+				reflectionModelRouting: resolvedConfig.reflection?.routing
+			};
+		}
+		const processorConfig = omProcessor.config || {};
+		return {
+			enabled: true,
+			scope: processorConfig.scope || "resource",
+			shareTokenBudget: processorConfig.shareTokenBudget,
+			messageTokens: processorConfig.observation?.messageTokens,
+			observationTokens: processorConfig.reflection?.observationTokens,
+			observationModel: void 0,
+			reflectionModel: void 0,
+			observationModelRouting: void 0,
+			reflectionModelRouting: void 0
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Gets Observational Memory status for a specific resource/thread.
+*/
+async function getOMStatus(memoryStorage, resourceId, threadId) {
+	try {
+		const record = await memoryStorage.getObservationalMemory(threadId ?? null, resourceId);
+		if (!record) return { hasRecord: false };
+		return {
+			hasRecord: true,
+			originType: record.originType,
+			lastObservedAt: record.lastObservedAt ?? null,
+			tokenCount: record.totalTokensObserved,
+			observationTokenCount: record.observationTokenCount,
+			isObserving: record.isObserving,
+			isReflecting: record.isReflecting
+		};
+	} catch {
+		return null;
+	}
+}
+const GET_MEMORY_STATUS_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/status",
+	responseType: "json",
+	queryParamSchema: require_memory.getMemoryStatusQuerySchema,
+	responseSchema: require_memory.memoryStatusResponseSchema,
+	summary: "Get memory status",
+	description: "Returns the current status of the memory system including configuration and health information",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, resourceId, threadId, requestContext }) => {
+		try {
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			const isGateway = agent ? await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent) : false;
+			if (agent && isGateway) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient) {
+					let omStatus;
+					if (resourceId && threadId) try {
+						const { record } = await gwClient.getObservationRecord(threadId, resourceId);
+						if (record) omStatus = {
+							enabled: true,
+							hasRecord: true,
+							originType: record.originType,
+							lastObservedAt: record.lastObservedAt ? new Date(record.lastObservedAt) : void 0,
+							tokenCount: record.totalTokensObserved,
+							observationTokenCount: record.observationTokenCount,
+							isObserving: record.isObserving,
+							isReflecting: record.isReflecting
+						};
+						else omStatus = {
+							enabled: true,
+							hasRecord: false
+						};
+					} catch {
+						omStatus = { enabled: true };
+					}
+					else omStatus = { enabled: true };
+					return {
+						result: true,
+						memoryType: "gateway",
+						observationalMemory: omStatus
+					};
+				}
+			}
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext,
+				allowMissingAgent: true
+			});
+			if (memory) {
+				let omStatus;
+				if (agent) {
+					const omConfig = await getOMConfigFromAgent(agent, requestContext);
+					if (omConfig?.enabled && resourceId) {
+						const omThreadId = omConfig.scope === "resource" ? void 0 : threadId;
+						try {
+							const memoryStore = await memory.storage.getStore("memory");
+							if (memoryStore) {
+								const status = await getOMStatus(memoryStore, resourceId, omThreadId);
+								if (status) omStatus = {
+									enabled: true,
+									...status,
+									lastObservedAt: status.lastObservedAt ?? void 0
+								};
+								else omStatus = {
+									enabled: true,
+									hasRecord: false
+								};
+							}
+						} catch {
+							omStatus = { enabled: true };
+						}
+					} else if (omConfig?.enabled) omStatus = { enabled: true };
+				}
+				return {
+					result: true,
+					memoryType: "local",
+					observationalMemory: omStatus
+				};
+			}
+			if (!agentSupportsMemory(agent)) return { result: false };
+			if (getStorageFromContext({ mastra })) return { result: true };
+			return { result: false };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting memory status");
+		}
+	}
+});
+const GET_MEMORY_CONFIG_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/config",
+	responseType: "json",
+	queryParamSchema: require_memory.getMemoryConfigQuerySchema,
+	responseSchema: require_memory.memoryConfigResponseSchema,
+	summary: "Get memory configuration",
+	description: "Returns the memory configuration for a specific agent or the system default",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, requestContext }) => {
+		try {
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (agent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent) && require_server_handlers_gateway_memory_client.getGatewayClient()) return {
+				memoryType: "gateway",
+				config: { observationalMemory: {
+					enabled: true,
+					scope: "thread",
+					messageTokens: 3e4,
+					observationTokens: 4e4
+				} }
+			};
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext,
+				allowMissingAgent: true
+			});
+			if (!memory) return { config: null };
+			const config = memory.getMergedThreadConfig({});
+			let omConfig;
+			if (agent) omConfig = await getOMConfigFromAgent(agent, requestContext) ?? { enabled: false };
+			return { config: {
+				...config,
+				observationalMemory: omConfig
+			} };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting memory configuration");
+		}
+	}
+});
+const GET_OBSERVATIONAL_MEMORY_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/observational-memory",
+	responseType: "json",
+	queryParamSchema: require_memory.getObservationalMemoryQuerySchema,
+	responseSchema: require_memory.getObservationalMemoryResponseSchema,
+	summary: "Get observational memory data",
+	description: "Returns the current observational memory record and optional history for a resource/thread",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, resourceId, threadId, from, to, offset, limit, requestContext }) => {
+		try {
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!agent) throw new require_http_exception.HTTPException(404, { message: "Agent not found" });
+			const historyLimit = limit ?? 5;
+			const historyOptions = {
+				from,
+				to,
+				offset
+			};
+			if (await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent)) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient && resourceId && threadId) {
+					const [recordResult, historyResult] = await Promise.all([gwClient.getObservationRecord(threadId, resourceId), gwClient.getObservationHistory(threadId, {
+						resourceId,
+						limit: historyLimit,
+						from,
+						to,
+						offset
+					})]);
+					return {
+						record: recordResult.record ? require_server_handlers_gateway_memory_client.toLocalOMRecord(recordResult.record) : null,
+						history: historyResult.records?.length > 0 ? historyResult.records.map(require_server_handlers_gateway_memory_client.toLocalOMRecord) : void 0
+					};
+				}
+				return {
+					record: null,
+					history: void 0
+				};
+			}
+			const omConfig = await getOMConfigFromAgent(agent, requestContext);
+			if (!omConfig?.enabled) throw new require_http_exception.HTTPException(400, { message: "Observational Memory is not enabled for this agent" });
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not configured for this agent" });
+			let memoryStore;
+			try {
+				memoryStore = await memory.storage.getStore("memory");
+			} catch {
+				throw new require_http_exception.HTTPException(400, { message: "Memory storage is not initialized" });
+			}
+			if (!memoryStore) throw new require_http_exception.HTTPException(400, { message: "Memory storage is not initialized" });
+			const effectiveResourceId = resourceId;
+			if (!effectiveResourceId) throw new require_http_exception.HTTPException(400, { message: "resourceId is required for observational memory lookup" });
+			const omThreadId = omConfig.scope === "resource" ? null : threadId ?? null;
+			const record = await memoryStore.getObservationalMemory(omThreadId, effectiveResourceId);
+			const history = await memoryStore.getObservationalMemoryHistory(omThreadId, effectiveResourceId, historyLimit, historyOptions);
+			return {
+				record: record ?? null,
+				history: history.length > 0 ? history : void 0
+			};
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting observational memory");
+		}
+	}
+});
+const AWAIT_BUFFER_STATUS_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/observational-memory/buffer-status",
+	responseType: "json",
+	bodySchema: require_memory.awaitBufferStatusBodySchema,
+	responseSchema: require_memory.awaitBufferStatusResponseSchema,
+	summary: "Await observational memory buffering completion",
+	description: "Blocks until any in-flight buffering operations complete for the given thread/resource, then returns the updated record",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, resourceId, threadId, requestContext }) => {
+		try {
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!agent) throw new require_http_exception.HTTPException(404, { message: "Agent not found" });
+			if (await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent)) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient && resourceId && threadId) {
+					const maxWaitMs = 3e4;
+					const pollIntervalMs = 1e3;
+					const deadline = Date.now() + maxWaitMs;
+					let record = null;
+					while (Date.now() < deadline) {
+						const result = await gwClient.getObservationRecord(threadId, resourceId);
+						record = result.record ? require_server_handlers_gateway_memory_client.toLocalOMRecord(result.record) : null;
+						if (!record || !record.isBufferingObservation && !record.isBufferingReflection) break;
+						await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+					}
+					return { record };
+				}
+				return { record: null };
+			}
+			const omConfig = await getOMConfigFromAgent(agent, requestContext);
+			if (!omConfig?.enabled) throw new require_http_exception.HTTPException(400, { message: "Observational Memory is not enabled for this agent" });
+			const omProcessor = await agent.resolveProcessorById("observational-memory", requestContext);
+			if (!omProcessor || typeof omProcessor.waitForBuffering !== "function") throw new require_http_exception.HTTPException(400, { message: "Observational Memory processor not available" });
+			await omProcessor.waitForBuffering(threadId, resourceId);
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not configured for this agent" });
+			let memoryStore;
+			try {
+				memoryStore = await memory.storage.getStore("memory");
+			} catch {
+				throw new require_http_exception.HTTPException(400, { message: "Memory storage is not initialized" });
+			}
+			if (!memoryStore) throw new require_http_exception.HTTPException(400, { message: "Memory storage is not initialized" });
+			const effectiveResourceId = resourceId;
+			if (!effectiveResourceId) throw new require_http_exception.HTTPException(400, { message: "resourceId is required" });
+			const omThreadId = omConfig.scope === "resource" ? null : threadId ?? null;
+			return { record: await memoryStore.getObservationalMemory(omThreadId, effectiveResourceId) ?? null };
+		} catch (error) {
+			console.error("Error awaiting buffer status", error);
+			return require_server_handlers_error.handleError(error, "Error awaiting buffer status");
+		}
+	}
+});
+const LIST_THREADS_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/threads",
+	responseType: "json",
+	queryParamSchema: require_memory.listThreadsQuerySchema,
+	responseSchema: require_memory.listThreadsResponseSchema,
+	summary: "List memory threads",
+	description: "Returns a paginated list of conversation threads with optional filtering by resource ID and/or metadata",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, resourceId, metadata, requestContext, page, perPage, orderBy }) => {
+		try {
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			const isGateway = agent ? await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent) : false;
+			if (agent && isGateway) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient) {
+					if (shouldFilterThreadsWithFGA(mastra, requestContext)) {
+						const initialResult = await gwClient.listThreads({
+							resourceId: effectiveResourceId,
+							limit: 1,
+							offset: 0
+						});
+						return paginateThreads({
+							threads: await filterAccessibleThreads({
+								mastra,
+								requestContext,
+								threads: initialResult.total > 0 ? (await gwClient.listThreads({
+									resourceId: effectiveResourceId,
+									limit: initialResult.total,
+									offset: 0
+								})).threads.map(require_server_handlers_gateway_memory_client.toLocalThread) : []
+							}),
+							page,
+							perPage
+						});
+					}
+					const effectivePage = page ?? 0;
+					const effectivePerPage = perPage ?? 100;
+					const offset = effectivePage * effectivePerPage;
+					const result = await gwClient.listThreads({
+						resourceId: effectiveResourceId,
+						limit: effectivePerPage,
+						offset
+					});
+					return {
+						threads: result.threads.map(require_server_handlers_gateway_memory_client.toLocalThread),
+						page: effectivePage,
+						perPage: effectivePerPage,
+						total: result.total,
+						hasMore: offset + result.threads.length < result.total
+					};
+				}
+			}
+			const filter = effectiveResourceId || metadata ? {} : void 0;
+			if (effectiveResourceId) filter.resourceId = effectiveResourceId;
+			if (metadata) filter.metadata = metadata;
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext,
+				allowMissingAgent: true
+			});
+			if (memory) {
+				const result = await memory.listThreads(shouldFilterThreadsWithFGA(mastra, requestContext) ? {
+					filter,
+					perPage: false,
+					orderBy
+				} : {
+					filter,
+					page,
+					perPage,
+					orderBy
+				});
+				if (!shouldFilterThreadsWithFGA(mastra, requestContext)) return result;
+				return paginateThreads({
+					threads: await filterAccessibleThreads({
+						mastra,
+						requestContext,
+						threads: result.threads
+					}),
+					page,
+					perPage
+				});
+			}
+			const storage = getStorageFromContext({ mastra });
+			if (storage) {
+				const memoryStore = await storage.getStore("memory");
+				if (memoryStore) {
+					const result = await memoryStore.listThreads(shouldFilterThreadsWithFGA(mastra, requestContext) ? {
+						filter,
+						perPage: false,
+						orderBy
+					} : {
+						filter,
+						page,
+						perPage,
+						orderBy
+					});
+					if (!shouldFilterThreadsWithFGA(mastra, requestContext)) return result;
+					return paginateThreads({
+						threads: await filterAccessibleThreads({
+							mastra,
+							requestContext,
+							threads: result.threads
+						}),
+						page,
+						perPage
+					});
+				}
+			}
+			throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error listing threads");
+		}
+	}
+});
+const GET_THREAD_BY_ID_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/threads/:threadId",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.getThreadByIdQuerySchema,
+	responseSchema: require_memory.getThreadByIdResponseSchema,
+	summary: "Get thread by ID",
+	description: "Returns details for a specific conversation thread",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, threadId, resourceId, requestContext }) => {
+		try {
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			require_utils.validateBody({ threadId: effectiveThreadId });
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			const isGateway = agent ? await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent) : false;
+			if (agent && isGateway) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient) {
+					const result = await gwClient.getThread(effectiveThreadId);
+					if (!result) return {
+						id: effectiveThreadId,
+						resourceId: effectiveResourceId ?? "",
+						title: "",
+						metadata: {},
+						createdAt: /* @__PURE__ */ new Date(),
+						updatedAt: /* @__PURE__ */ new Date()
+					};
+					const thread = require_server_handlers_gateway_memory_client.toLocalThread(result.thread);
+					await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread,
+						effectiveResourceId
+					});
+					return thread;
+				}
+			}
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext,
+				allowMissingAgent: true
+			});
+			if (memory) {
+				const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+				if (!thread) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+				await require_utils.enforceThreadAccess({
+					mastra,
+					requestContext,
+					threadId: effectiveThreadId,
+					thread,
+					effectiveResourceId
+				});
+				return thread;
+			}
+			const storage = getStorageFromContext({ mastra });
+			if (storage) {
+				const memoryStore = await storage.getStore("memory");
+				if (memoryStore) {
+					const thread = await memoryStore.getThreadById({ threadId: effectiveThreadId });
+					if (!thread) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+					await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread,
+						effectiveResourceId
+					});
+					return thread;
+				}
+			}
+			throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting thread");
+		}
+	}
+});
+const LIST_MESSAGES_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/threads/:threadId/messages",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.listMessagesQuerySchema,
+	responseSchema: require_memory.listMessagesResponseSchema,
+	summary: "List thread messages",
+	description: "Returns a paginated list of messages in a conversation thread",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: (async ({ mastra, agentId, threadId, resourceId, perPage, page, orderBy, include, filter, includeSystemReminders, requestContext }) => {
+		try {
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			require_utils.validateBody({ threadId: effectiveThreadId });
+			if (!effectiveThreadId) throw new require_http_exception.HTTPException(400, { message: "No threadId found" });
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (agent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent)) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient) {
+					if (filter?.metadata && Object.keys(filter.metadata).length > 0) throw new require_http_exception.HTTPException(501, { message: "Gateway memory message metadata filters are not supported by this gateway endpoint. Remove filter.metadata or query a local memory store." });
+					const threadResult = await gwClient.getThread(effectiveThreadId);
+					if (threadResult) await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread: require_server_handlers_gateway_memory_client.toLocalThread(threadResult.thread),
+						effectiveResourceId
+					});
+					const effectivePage = page ?? 0;
+					const effectivePerPage = perPage ?? 100;
+					const offset = effectivePage * effectivePerPage;
+					const result = await gwClient.listMessages(effectiveThreadId, {
+						limit: effectivePerPage,
+						offset,
+						order: orderBy?.direction?.toLowerCase()
+					});
+					if (!result) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+					return {
+						messages: result.messages.map(require_server_handlers_gateway_memory_client.toLocalMessage),
+						uiMessages: result.messages.map(require_server_handlers_gateway_memory_client.toLocalMessage)
+					};
+				}
+			}
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext,
+				allowMissingAgent: true
+			});
+			if (memory) {
+				const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+				if (!thread) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+				await require_utils.enforceThreadAccess({
+					mastra,
+					requestContext,
+					threadId: effectiveThreadId,
+					thread,
+					effectiveResourceId
+				});
+				const result = await memory.recall({
+					threadId: effectiveThreadId,
+					resourceId: effectiveResourceId,
+					perPage,
+					page,
+					orderBy,
+					include,
+					filter,
+					includeSystemReminders
+				});
+				const uiMessages = result.uiMessages;
+				return {
+					...result,
+					uiMessages: Array.isArray(uiMessages) ? uiMessages : null
+				};
+			}
+			const storage = getStorageFromContext({ mastra });
+			if (storage) {
+				const memoryStore = await storage.getStore("memory");
+				if (memoryStore) {
+					const thread = await memoryStore.getThreadById({ threadId: effectiveThreadId });
+					if (!thread) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+					await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread,
+						effectiveResourceId
+					});
+					return {
+						...await memoryStore.listMessages({
+							threadId: effectiveThreadId,
+							resourceId: effectiveResourceId,
+							perPage,
+							page,
+							orderBy,
+							include,
+							filter
+						}),
+						uiMessages: null
+					};
+				}
+			}
+			return {
+				messages: [],
+				uiMessages: []
+			};
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting messages");
+		}
+	})
+});
+const GET_WORKING_MEMORY_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/threads/:threadId/working-memory",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.getWorkingMemoryQuerySchema,
+	responseSchema: require_memory.getWorkingMemoryResponseSchema,
+	summary: "Get working memory",
+	description: "Returns the working memory state for a thread",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, threadId, resourceId, requestContext, memoryConfig }) => {
+		try {
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			require_utils.validateBody({ threadId: effectiveThreadId });
+			const gwAgent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (gwAgent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(gwAgent) && require_server_handlers_gateway_memory_client.getGatewayClient()) return {
+				workingMemory: null,
+				source: "thread",
+				workingMemoryTemplate: null,
+				threadExists: true
+			};
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext,
+				allowMissingAgent: true
+			});
+			if (!memory) return {
+				workingMemory: null,
+				source: "thread",
+				workingMemoryTemplate: null,
+				threadExists: false
+			};
+			const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+			const source = memory.getMergedThreadConfig(memoryConfig || {}).workingMemory?.scope !== "thread" && effectiveResourceId ? "resource" : "thread";
+			if (thread || source === "resource") await require_utils.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveThreadId,
+				thread,
+				effectiveResourceId
+			});
+			const threadExists = !!thread;
+			const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
+			const workingMemoryTemplate = template?.format === "json" ? {
+				...template,
+				content: JSON.stringify((0, _mastra_core_utils.generateEmptyFromSchema)(template.content))
+			} : template;
+			return {
+				workingMemory: await memory.getWorkingMemory({
+					threadId: effectiveThreadId,
+					resourceId: effectiveResourceId,
+					memoryConfig
+				}),
+				source,
+				workingMemoryTemplate,
+				threadExists
+			};
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting working memory");
+		}
+	}
+});
+const SAVE_MESSAGES_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/save-messages",
+	responseType: "json",
+	queryParamSchema: require_memory.agentIdQuerySchema,
+	bodySchema: require_memory.saveMessagesBodySchema,
+	responseSchema: require_memory.saveMessagesResponseSchema,
+	summary: "Save messages",
+	description: "Saves new messages to memory",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, messages, requestContext }) => {
+		try {
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, void 0);
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			if (!messages) throw new require_http_exception.HTTPException(400, { message: "Messages are required" });
+			if (!Array.isArray(messages)) throw new require_http_exception.HTTPException(400, { message: "Messages should be an array" });
+			const incomingMessages = messages;
+			const resourceIdByThread = /* @__PURE__ */ new Map();
+			for (const message of incomingMessages) {
+				if (!message.threadId || !message.resourceId) continue;
+				const existingResourceId = resourceIdByThread.get(message.threadId);
+				if (!existingResourceId) resourceIdByThread.set(message.threadId, message.resourceId);
+				else if (existingResourceId !== message.resourceId) throw new require_http_exception.HTTPException(400, { message: "All messages for the same threadId must use the same resourceId." });
+			}
+			const invalidMessages = incomingMessages.filter((message) => !message.threadId || !message.resourceId);
+			if (invalidMessages.length > 0) throw new require_http_exception.HTTPException(400, { message: `All messages must have threadId and resourceId fields. Found ${invalidMessages.length} invalid message(s).` });
+			if (effectiveResourceId) {
+				if (incomingMessages.filter((message) => message.resourceId !== effectiveResourceId).length > 0) throw new require_http_exception.HTTPException(403, { message: "Access denied: cannot save messages for a different resource" });
+				const threadIds = [...new Set(incomingMessages.map((m) => m.threadId).filter(Boolean))];
+				for (const threadId of threadIds) {
+					const thread = await memory.getThreadById({ threadId });
+					await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId,
+						thread,
+						effectiveResourceId,
+						permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+					});
+				}
+			} else {
+				const threadIds = [...new Set(incomingMessages.map((m) => m.threadId).filter(Boolean))];
+				for (const threadId of threadIds) {
+					const thread = await memory.getThreadById({ threadId });
+					await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId,
+						thread,
+						effectiveResourceId: resourceIdByThread.get(threadId),
+						permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+					});
+				}
+			}
+			const processedMessages = incomingMessages.map((message) => ({
+				...message,
+				id: message.id || memory.generateId(),
+				createdAt: message.createdAt ? new Date(message.createdAt) : /* @__PURE__ */ new Date()
+			}));
+			return await memory.saveMessages({
+				messages: processedMessages,
+				memoryConfig: {}
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error saving messages");
+		}
+	}
+});
+const CREATE_THREAD_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/threads",
+	responseType: "json",
+	queryParamSchema: require_memory.agentIdQuerySchema,
+	bodySchema: require_memory.createThreadBodySchema,
+	responseSchema: require_memory.getThreadByIdResponseSchema,
+	summary: "Create thread",
+	description: "Creates a new conversation thread",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, resourceId, title, metadata, threadId, requestContext }) => {
+		try {
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			const effectiveThreadId = threadId ?? mastra.generateId();
+			require_utils.validateBody({ resourceId: effectiveResourceId });
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (agent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent)) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient) {
+					const existing = threadId ? await gwClient.getThread(effectiveThreadId) : null;
+					await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread: existing ? require_server_handlers_gateway_memory_client.toLocalThread(existing.thread) : null,
+						effectiveResourceId,
+						permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+					});
+					const result = await gwClient.createThread({
+						id: effectiveThreadId,
+						resourceId: effectiveResourceId,
+						title,
+						metadata
+					});
+					return require_server_handlers_gateway_memory_client.toLocalThread(result.thread);
+				}
+			}
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			const existing = threadId ? await memory.getThreadById({ threadId: effectiveThreadId }) : null;
+			await require_utils.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveThreadId,
+				thread: existing,
+				effectiveResourceId,
+				permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+			});
+			return await memory.createThread({
+				resourceId: effectiveResourceId,
+				title,
+				metadata,
+				threadId: effectiveThreadId
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error saving thread to memory");
+		}
+	}
+});
+const UPDATE_THREAD_ROUTE = require_route_builder.createRoute({
+	method: "PATCH",
+	path: "/memory/threads/:threadId",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.agentIdQuerySchema,
+	bodySchema: require_memory.updateThreadBodySchema,
+	responseSchema: require_memory.getThreadByIdResponseSchema,
+	summary: "Update thread",
+	description: "Updates a conversation thread",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, threadId, title, metadata, resourceId, requestContext }) => {
+		try {
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			require_utils.validateBody({ threadId: effectiveThreadId });
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (agent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent)) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient) {
+					const existing = await gwClient.getThread(effectiveThreadId);
+					if (existing) await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread: require_server_handlers_gateway_memory_client.toLocalThread(existing.thread),
+						effectiveResourceId,
+						permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+					});
+					const result = await gwClient.updateThread(effectiveThreadId, {
+						title,
+						metadata
+					});
+					if (!result) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+					return require_server_handlers_gateway_memory_client.toLocalThread(result.thread);
+				}
+			}
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			const updatedAt = /* @__PURE__ */ new Date();
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+			if (!thread) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+			await require_utils.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveThreadId,
+				thread,
+				effectiveResourceId,
+				permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+			});
+			const updatedThread = {
+				...thread,
+				title: title !== void 0 ? title : thread.title,
+				metadata: metadata !== void 0 ? metadata : thread.metadata,
+				resourceId: effectiveResourceId || resourceId || thread.resourceId,
+				createdAt: thread.createdAt,
+				updatedAt
+			};
+			const result = await memory.saveThread({ thread: updatedThread });
+			return {
+				...result,
+				resourceId: result.resourceId ?? null
+			};
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error updating thread");
+		}
+	}
+});
+const DELETE_THREAD_ROUTE = require_route_builder.createRoute({
+	method: "DELETE",
+	path: "/memory/threads/:threadId",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.deleteThreadQuerySchema,
+	responseSchema: require_memory.deleteThreadResponseSchema,
+	summary: "Delete thread",
+	description: "Deletes a conversation thread",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, threadId, resourceId, requestContext }) => {
+		try {
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			require_utils.validateBody({ threadId: effectiveThreadId });
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (agent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent)) {
+				const gwClient = require_server_handlers_gateway_memory_client.getGatewayClient();
+				if (gwClient) {
+					const existing = await gwClient.getThread(effectiveThreadId);
+					if (existing) await require_utils.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread: require_server_handlers_gateway_memory_client.toLocalThread(existing.thread),
+						effectiveResourceId,
+						permission: require_utils.MastraFGAPermissions.MEMORY_DELETE
+					});
+					if (!(await gwClient.deleteThread(effectiveThreadId)).ok) throw new require_http_exception.HTTPException(404, { message: "Thread not found on gateway" });
+					return { result: "Thread deleted" };
+				}
+			}
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+			if (!thread) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+			await require_utils.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveThreadId,
+				thread,
+				effectiveResourceId,
+				permission: require_utils.MastraFGAPermissions.MEMORY_DELETE
+			});
+			await memory.deleteThread(effectiveThreadId);
+			return { result: "Thread deleted" };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error deleting thread");
+		}
+	}
+});
+const CLONE_THREAD_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/threads/:threadId/clone",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.agentIdQuerySchema,
+	bodySchema: require_memory.cloneThreadBodySchema,
+	responseSchema: require_memory.cloneThreadResponseSchema,
+	summary: "Clone thread",
+	description: "Creates a copy of a conversation thread with all its messages",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, threadId, newThreadId, resourceId, title, metadata, options, requestContext }) => {
+		try {
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			const effectiveNewThreadId = newThreadId ?? mastra.generateId();
+			require_utils.validateBody({ threadId: effectiveThreadId });
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			const sourceThread = await memory.getThreadById({ threadId: effectiveThreadId });
+			if (!sourceThread) throw new require_http_exception.HTTPException(404, { message: "Source thread not found" });
+			const cloneResourceId = effectiveResourceId ?? sourceThread.resourceId ?? void 0;
+			await require_utils.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveThreadId,
+				thread: sourceThread,
+				effectiveResourceId
+			});
+			await require_utils.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveNewThreadId,
+				effectiveResourceId: cloneResourceId,
+				permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+			});
+			return await memory.cloneThread({
+				sourceThreadId: effectiveThreadId,
+				newThreadId: effectiveNewThreadId,
+				resourceId: cloneResourceId,
+				title,
+				metadata,
+				options
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error cloning thread");
+		}
+	}
+});
+const TRANSFER_THREAD_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/threads/:threadId/transfer",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.optionalAgentIdQuerySchema,
+	bodySchema: require_memory.transferThreadBodySchema,
+	responseSchema: require_memory.transferThreadResponseSchema,
+	summary: "Transfer thread ownership",
+	description: "Reassigns a thread and all of its messages to a different resource. Requires a privileged (non-resource-scoped) context.",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, threadId, resourceId, requestContext }) => {
+		try {
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			require_utils.validateBody({ threadId: effectiveThreadId });
+			if (require_utils.getContextResourceId(requestContext)) throw new require_http_exception.HTTPException(403, { message: "Thread transfer requires a privileged (non-resource-scoped) context" });
+			const server = mastra.getServer?.();
+			if (server?.auth && !server?.fga) throw new require_http_exception.HTTPException(403, { message: "Thread transfer requires explicit authorization. Configure an FGA provider (memory:write) to authorize privileged, non-resource-scoped transfers." });
+			const agent = agentId ? await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			}) : void 0;
+			if (agent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent)) throw new require_http_exception.HTTPException(501, { message: "Thread transfer is not supported for gateway agents" });
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext,
+				allowMissingAgent: true
+			});
+			const memoryStore = memory ? void 0 : await getStorageFromContext({ mastra })?.getStore("memory");
+			if (!memory && !memoryStore) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			const sourceThread = memory ? await memory.getThreadById({ threadId: effectiveThreadId }) : await memoryStore.getThreadById({ threadId: effectiveThreadId });
+			if (!sourceThread) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+			await require_utils.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveThreadId,
+				thread: sourceThread,
+				effectiveResourceId: void 0,
+				permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+			});
+			const result = memory ? await memory.updateThreadResourceId({
+				threadId: effectiveThreadId,
+				resourceId
+			}) : await memoryStore.updateThreadResourceId({
+				threadId: effectiveThreadId,
+				resourceId
+			});
+			return {
+				...result,
+				resourceId: result.resourceId ?? null
+			};
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error transferring thread");
+		}
+	}
+});
+const UPDATE_WORKING_MEMORY_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/threads/:threadId/working-memory",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.agentIdQuerySchema,
+	bodySchema: require_memory.updateWorkingMemoryBodySchema,
+	responseSchema: require_memory.updateWorkingMemoryResponseSchema,
+	summary: "Update working memory",
+	description: "Updates the working memory state for a thread",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, threadId, resourceId, memoryConfig, workingMemory, mode, requestContext }) => {
+		try {
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			require_utils.validateBody({
+				threadId: effectiveThreadId,
+				workingMemory
+			});
+			const gwAgent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (gwAgent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(gwAgent) && require_server_handlers_gateway_memory_client.getGatewayClient()) return { success: true };
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+			if (!thread) throw new require_http_exception.HTTPException(404, { message: "Thread not found" });
+			await require_utils.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveThreadId,
+				thread,
+				effectiveResourceId,
+				permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
+			});
+			if (mode === "merge") {
+				if (!await memory.supportsAtomicWorkingMemoryMerge()) throw new require_http_exception.HTTPException(400, { message: "Working memory merge is not supported by the configured storage adapter" });
+				try {
+					await memory.mergeWorkingMemory({
+						threadId: effectiveThreadId,
+						resourceId: effectiveResourceId,
+						workingMemory,
+						memoryConfig
+					});
+				} catch (error) {
+					if (error instanceof _mastra_core_error.MastraError && error.category === _mastra_core_error.ErrorCategory.USER) throw new require_http_exception.HTTPException(400, { message: error.message });
+					throw error;
+				}
+				return { success: true };
+			}
+			await memory.updateWorkingMemory({
+				threadId: effectiveThreadId,
+				resourceId: effectiveResourceId,
+				workingMemory,
+				memoryConfig
+			});
+			return { success: true };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error updating working memory");
+		}
+	}
+});
+const DELETE_MESSAGES_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/messages/delete",
+	responseType: "json",
+	queryParamSchema: require_memory.deleteMessagesQuerySchema,
+	bodySchema: require_memory.deleteMessagesBodySchema,
+	responseSchema: require_memory.deleteMessagesResponseSchema,
+	summary: "Delete messages",
+	description: "Deletes specific messages from memory",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, resourceId, messageIds, requestContext }) => {
+		try {
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			if (messageIds === void 0 || messageIds === null) throw new require_http_exception.HTTPException(400, { message: "messageIds is required" });
+			let normalizedIds;
+			if (Array.isArray(messageIds)) normalizedIds = messageIds;
+			else if (typeof messageIds === "string") normalizedIds = [messageIds];
+			else normalizedIds = [messageIds];
+			const stringIds = normalizedIds.map((id) => typeof id === "string" ? id : id.id);
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext,
+				allowMissingAgent: true
+			});
+			if (effectiveResourceId && stringIds.length > 0) {
+				const storage = memory?.storage || getStorageFromContext({ mastra });
+				if (!storage) throw new require_http_exception.HTTPException(403, { message: "Access denied: unable to verify message ownership" });
+				const memoryStore = await storage.getStore("memory");
+				if (!memoryStore) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+				await enforceDeleteMessagesThreadAccess({
+					mastra,
+					requestContext,
+					memoryStore,
+					messageIds: stringIds,
+					effectiveResourceId
+				});
+			} else if (stringIds.length > 0) {
+				const storage = memory?.storage || getStorageFromContext({ mastra });
+				if (!storage) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+				const memoryStore = await storage.getStore("memory");
+				if (!memoryStore) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+				await enforceDeleteMessagesThreadAccess({
+					mastra,
+					requestContext,
+					memoryStore,
+					messageIds: stringIds
+				});
+			}
+			if (memory) await memory.deleteMessages(normalizedIds);
+			else {
+				const storage = getStorageFromContext({ mastra });
+				if (storage) {
+					const memoryStore = await storage.getStore("memory");
+					if (memoryStore) await memoryStore.deleteMessages(stringIds);
+					else throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+				} else throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			}
+			const count = Array.isArray(messageIds) ? messageIds.length : 1;
+			return {
+				success: true,
+				message: `${count} message${count === 1 ? "" : "s"} deleted successfully`
+			};
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error deleting messages");
+		}
+	}
+});
+const SEARCH_MEMORY_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/search",
+	responseType: "json",
+	queryParamSchema: require_memory.searchMemoryQuerySchema,
+	responseSchema: require_memory.searchMemoryResponseSchema,
+	summary: "Search memory",
+	description: "Searches across memory using semantic or text search",
+	tags: ["Memory"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, searchQuery, resourceId, threadId, limit = 20, requestContext, memoryConfig }) => {
+		try {
+			const effectiveResourceId = require_utils.getEffectiveResourceId(requestContext, resourceId);
+			const effectiveThreadId = require_utils.getEffectiveThreadId(requestContext, threadId);
+			require_utils.validateBody({
+				searchQuery,
+				resourceId: effectiveResourceId
+			});
+			const agent = await getAgentFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (agent && await require_server_handlers_gateway_memory_client.isGatewayAgentAsync(agent) && require_server_handlers_gateway_memory_client.getGatewayClient()) return {
+				results: [],
+				count: 0,
+				query: searchQuery,
+				searchScope: "resource",
+				searchType: "semantic"
+			};
+			const memory = await getMemoryFromContext({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
+			const config = memory.getMergedThreadConfig(memoryConfig || {});
+			const hasSemanticRecall = !!config?.semanticRecall;
+			const resourceScope = typeof config?.semanticRecall === "object" ? config?.semanticRecall?.scope !== "thread" : true;
+			const searchResults = [];
+			let accessibleThreadsForResource;
+			let accessibleThreadIds;
+			if (resourceScope && effectiveResourceId && shouldFilterThreadsWithFGA(mastra, requestContext)) {
+				const { threads } = await memory.listThreads({
+					filter: { resourceId: effectiveResourceId },
+					perPage: false,
+					orderBy: {
+						field: "updatedAt",
+						direction: "DESC"
+					}
+				});
+				accessibleThreadsForResource = await filterAccessibleThreads({
+					mastra,
+					requestContext,
+					threads
+				});
+				accessibleThreadIds = new Set(accessibleThreadsForResource.map((thread) => thread.id));
+				if (accessibleThreadsForResource.length === 0) return {
+					results: [],
+					count: 0,
+					query: searchQuery,
+					searchScope: resourceScope ? "resource" : "thread",
+					searchType: hasSemanticRecall ? "semantic" : "text"
+				};
+			}
+			if (effectiveThreadId && !resourceScope) {
+				const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+				if (!thread) return {
+					results: [],
+					count: 0,
+					query: searchQuery,
+					searchScope: resourceScope ? "resource" : "thread",
+					searchType: hasSemanticRecall ? "semantic" : "text"
+				};
+				await require_utils.enforceThreadAccess({
+					mastra,
+					requestContext,
+					threadId: effectiveThreadId,
+					thread,
+					effectiveResourceId
+				});
+			}
+			let searchThreadId = effectiveThreadId;
+			if (!searchThreadId) {
+				const threads = accessibleThreadsForResource ?? (await memory.listThreads({
+					filter: { resourceId: effectiveResourceId },
+					page: 0,
+					perPage: 1,
+					orderBy: {
+						field: "updatedAt",
+						direction: "DESC"
+					}
+				})).threads;
+				if (threads.length === 0) return {
+					results: [],
+					count: 0,
+					query: searchQuery,
+					searchScope: resourceScope ? "resource" : "thread",
+					searchType: hasSemanticRecall ? "semantic" : "text"
+				};
+				searchThreadId = threads[0].id;
+			}
+			const beforeRange = typeof config.semanticRecall === `boolean` ? 2 : typeof config.semanticRecall?.messageRange === `number` ? config.semanticRecall.messageRange : config.semanticRecall?.messageRange.before || 2;
+			const afterRange = typeof config.semanticRecall === `boolean` ? 2 : typeof config.semanticRecall?.messageRange === `number` ? config.semanticRecall.messageRange : config.semanticRecall?.messageRange.after || 2;
+			if (resourceScope && config.semanticRecall) config.semanticRecall = typeof config.semanticRecall === `boolean` ? {
+				messageRange: 0,
+				topK: 2,
+				scope: "resource"
+			} : {
+				...config.semanticRecall,
+				messageRange: 0
+			};
+			const threadConfig = memory.getMergedThreadConfig(config || {});
+			if (!(threadConfig.lastMessages !== false && (threadConfig.lastMessages || threadConfig.messageHistory)) && !threadConfig.semanticRecall) return {
+				results: [],
+				count: 0,
+				query: searchQuery
+			};
+			const result = await memory.recall({
+				threadId: searchThreadId,
+				resourceId: effectiveResourceId,
+				threadConfig: config,
+				vectorSearchString: threadConfig.semanticRecall && searchQuery ? searchQuery : void 0
+			});
+			const accessibleMessages = accessibleThreadIds ? result.messages.filter((message) => accessibleThreadIds.has(message.threadId || searchThreadId)) : result.messages;
+			if (accessibleMessages.length === 0) return {
+				results: [],
+				count: 0,
+				query: searchQuery,
+				searchScope: resourceScope ? "resource" : "thread",
+				searchType: hasSemanticRecall ? "semantic" : "text"
+			};
+			const threadIds = Array.from(new Set(accessibleMessages.map((m) => m.threadId || searchThreadId).filter(Boolean)));
+			const fetched = await Promise.all(threadIds.map((id) => memory.getThreadById({ threadId: id })));
+			const threadMap = new Map(fetched.filter(Boolean).map((t) => [t.id, t]));
+			for (const msg of accessibleMessages) {
+				const content = getTextContent(msg);
+				const msgThreadId = msg.threadId || searchThreadId;
+				const thread = threadMap.get(msgThreadId);
+				const threadMessages = (await memory.recall({ threadId: msgThreadId })).messages;
+				const messageIndex = threadMessages.findIndex((m) => m.id === msg.id);
+				const searchResult = {
+					id: msg.id,
+					role: msg.role,
+					content,
+					createdAt: msg.createdAt,
+					threadId: msgThreadId,
+					threadTitle: thread?.title || msgThreadId
+				};
+				if (messageIndex !== -1) searchResult.context = {
+					before: threadMessages.slice(Math.max(0, messageIndex - beforeRange), messageIndex).map((m) => ({
+						id: m.id,
+						role: m.role,
+						content: getTextContent(m),
+						createdAt: m.createdAt || /* @__PURE__ */ new Date()
+					})),
+					after: threadMessages.slice(messageIndex + 1, messageIndex + afterRange + 1).map((m) => ({
+						id: m.id,
+						role: m.role,
+						content: getTextContent(m),
+						createdAt: m.createdAt || /* @__PURE__ */ new Date()
+					}))
+				};
+				searchResults.push(searchResult);
+			}
+			const sortedResults = searchResults.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit);
+			return {
+				results: sortedResults,
+				count: sortedResults.length,
+				query: searchQuery,
+				searchScope: resourceScope ? "resource" : "thread",
+				searchType: hasSemanticRecall ? "semantic" : "text"
+			};
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error searching memory");
+		}
+	}
+});
+const GET_MEMORY_STATUS_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/network/status",
+	responseType: "json",
+	queryParamSchema: require_memory.getMemoryStatusNetworkQuerySchema,
+	responseSchema: require_memory.memoryStatusResponseSchema,
+	summary: "Get memory status (network)",
+	description: "Returns the current status of the memory system (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: GET_MEMORY_STATUS_ROUTE.handler
+});
+const LIST_THREADS_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/network/threads",
+	responseType: "json",
+	queryParamSchema: require_memory.listThreadsNetworkQuerySchema,
+	responseSchema: require_memory.listThreadsResponseSchema,
+	summary: "List memory threads (network)",
+	description: "Returns a paginated list of conversation threads (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: LIST_THREADS_ROUTE.handler
+});
+const GET_THREAD_BY_ID_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/network/threads/:threadId",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.getThreadByIdNetworkQuerySchema,
+	responseSchema: require_memory.getThreadByIdResponseSchema,
+	summary: "Get thread by ID (network)",
+	description: "Returns details for a specific conversation thread (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: GET_THREAD_BY_ID_ROUTE.handler
+});
+const LIST_MESSAGES_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/memory/network/threads/:threadId/messages",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.listMessagesNetworkQuerySchema,
+	responseSchema: require_memory.listMessagesResponseSchema,
+	summary: "List thread messages (network)",
+	description: "Returns a paginated list of messages in a conversation thread (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: LIST_MESSAGES_ROUTE.handler
+});
+const SAVE_MESSAGES_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/network/save-messages",
+	responseType: "json",
+	queryParamSchema: require_memory.saveMessagesNetworkQuerySchema,
+	bodySchema: require_memory.saveMessagesBodySchema,
+	responseSchema: require_memory.saveMessagesResponseSchema,
+	summary: "Save messages (network)",
+	description: "Saves new messages to memory (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: SAVE_MESSAGES_ROUTE.handler
+});
+const CREATE_THREAD_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/network/threads",
+	responseType: "json",
+	queryParamSchema: require_memory.createThreadNetworkQuerySchema,
+	bodySchema: require_memory.createThreadBodySchema,
+	responseSchema: require_memory.getThreadByIdResponseSchema,
+	summary: "Create thread (network)",
+	description: "Creates a new conversation thread (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: CREATE_THREAD_ROUTE.handler
+});
+const UPDATE_THREAD_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "PATCH",
+	path: "/memory/network/threads/:threadId",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.updateThreadNetworkQuerySchema,
+	bodySchema: require_memory.updateThreadBodySchema,
+	responseSchema: require_memory.getThreadByIdResponseSchema,
+	summary: "Update thread (network)",
+	description: "Updates a conversation thread (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: UPDATE_THREAD_ROUTE.handler
+});
+const DELETE_THREAD_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "DELETE",
+	path: "/memory/network/threads/:threadId",
+	responseType: "json",
+	pathParamSchema: require_memory.threadIdPathParams,
+	queryParamSchema: require_memory.deleteThreadNetworkQuerySchema,
+	responseSchema: require_memory.deleteThreadResponseSchema,
+	summary: "Delete thread (network)",
+	description: "Deletes a conversation thread (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: DELETE_THREAD_ROUTE.handler
+});
+const DELETE_MESSAGES_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/memory/network/messages/delete",
+	responseType: "json",
+	queryParamSchema: require_memory.deleteMessagesNetworkQuerySchema,
+	bodySchema: require_memory.deleteMessagesBodySchema,
+	responseSchema: require_memory.deleteMessagesResponseSchema,
+	summary: "Delete messages (network)",
+	description: "Deletes specific messages from memory (network route)",
+	tags: ["Memory - Network"],
+	requiresAuth: true,
+	handler: DELETE_MESSAGES_ROUTE.handler
+});
+//#endregion
+Object.defineProperty(exports, "AWAIT_BUFFER_STATUS_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return AWAIT_BUFFER_STATUS_ROUTE;
+	}
+});
+Object.defineProperty(exports, "CLONE_THREAD_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return CLONE_THREAD_ROUTE;
+	}
+});
+Object.defineProperty(exports, "CREATE_THREAD_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return CREATE_THREAD_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "CREATE_THREAD_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return CREATE_THREAD_ROUTE;
+	}
+});
+Object.defineProperty(exports, "DELETE_MESSAGES_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return DELETE_MESSAGES_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "DELETE_MESSAGES_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return DELETE_MESSAGES_ROUTE;
+	}
+});
+Object.defineProperty(exports, "DELETE_THREAD_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return DELETE_THREAD_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "DELETE_THREAD_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return DELETE_THREAD_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_MEMORY_CONFIG_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_MEMORY_CONFIG_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_MEMORY_STATUS_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_MEMORY_STATUS_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_MEMORY_STATUS_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_MEMORY_STATUS_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_OBSERVATIONAL_MEMORY_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_OBSERVATIONAL_MEMORY_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_THREAD_BY_ID_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_THREAD_BY_ID_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_THREAD_BY_ID_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_THREAD_BY_ID_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_WORKING_MEMORY_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_WORKING_MEMORY_ROUTE;
+	}
+});
+Object.defineProperty(exports, "LIST_MESSAGES_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return LIST_MESSAGES_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "LIST_MESSAGES_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return LIST_MESSAGES_ROUTE;
+	}
+});
+Object.defineProperty(exports, "LIST_THREADS_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return LIST_THREADS_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "LIST_THREADS_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return LIST_THREADS_ROUTE;
+	}
+});
+Object.defineProperty(exports, "SAVE_MESSAGES_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return SAVE_MESSAGES_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "SAVE_MESSAGES_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return SAVE_MESSAGES_ROUTE;
+	}
+});
+Object.defineProperty(exports, "SEARCH_MEMORY_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return SEARCH_MEMORY_ROUTE;
+	}
+});
+Object.defineProperty(exports, "TRANSFER_THREAD_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return TRANSFER_THREAD_ROUTE;
+	}
+});
+Object.defineProperty(exports, "UPDATE_THREAD_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return UPDATE_THREAD_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "UPDATE_THREAD_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return UPDATE_THREAD_ROUTE;
+	}
+});
+Object.defineProperty(exports, "UPDATE_WORKING_MEMORY_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return UPDATE_WORKING_MEMORY_ROUTE;
+	}
+});
+Object.defineProperty(exports, "getTextContent", {
+	enumerable: true,
+	get: function() {
+		return getTextContent;
+	}
+});
+Object.defineProperty(exports, "memory_exports", {
+	enumerable: true,
+	get: function() {
+		return memory_exports;
+	}
+});
+
+//# sourceMappingURL=memory-CwwkVDh1.cjs.map