@mastra/server 1.79.0-alpha.10 → 1.79.0-alpha.11

package/dist/server/handlers/memory.cjs

@@ -1,1764 +1,30 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_rolldown_runtime = require("../../rolldown-runtime-Bd6kNlEP.cjs");
-const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
-const require_route_builder = require("../../route-builder-BNZs643f.cjs");
-const require_server_handlers_error = require("./error.cjs");
-const require_utils = require("../../utils-Du-EpvDs.cjs");
-const require_memory = require("../../memory-CizEIbl1.cjs");
-const require_server_handlers_gateway_memory_client = require("./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) await require_utils.enforceThreadAccess({
-					mastra,
-					requestContext,
-					threadId,
-					thread: await memory.getThreadById({ threadId }),
-					effectiveResourceId,
-					permission: require_utils.MastraFGAPermissions.MEMORY_WRITE
-				});
-			} else {
-				const threadIds = [...new Set(incomingMessages.map((m) => m.threadId).filter(Boolean))];
-				for (const threadId of threadIds) await require_utils.enforceThreadAccess({
-					mastra,
-					requestContext,
-					threadId,
-					thread: await memory.getThreadById({ threadId }),
-					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
-					});
-					return require_server_handlers_gateway_memory_client.toLocalThread((await gwClient.createThread({
-						id: effectiveThreadId,
-						resourceId: effectiveResourceId,
-						title,
-						metadata
-					})).thread);
-				}
-			}
-			const memory = await getMemoryFromContext({
-				mastra,
-				agentId,
-				requestContext
-			});
-			if (!memory) throw new require_http_exception.HTTPException(400, { message: "Memory is not initialized" });
-			await require_utils.enforceThreadAccess({
-				mastra,
-				requestContext,
-				threadId: effectiveThreadId,
-				thread: threadId ? await memory.getThreadById({ threadId: effectiveThreadId }) : null,
-				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
-exports.AWAIT_BUFFER_STATUS_ROUTE = AWAIT_BUFFER_STATUS_ROUTE;
-exports.CLONE_THREAD_ROUTE = CLONE_THREAD_ROUTE;
-exports.CREATE_THREAD_NETWORK_ROUTE = CREATE_THREAD_NETWORK_ROUTE;
-exports.CREATE_THREAD_ROUTE = CREATE_THREAD_ROUTE;
-exports.DELETE_MESSAGES_NETWORK_ROUTE = DELETE_MESSAGES_NETWORK_ROUTE;
-exports.DELETE_MESSAGES_ROUTE = DELETE_MESSAGES_ROUTE;
-exports.DELETE_THREAD_NETWORK_ROUTE = DELETE_THREAD_NETWORK_ROUTE;
-exports.DELETE_THREAD_ROUTE = DELETE_THREAD_ROUTE;
-exports.GET_MEMORY_CONFIG_ROUTE = GET_MEMORY_CONFIG_ROUTE;
-exports.GET_MEMORY_STATUS_NETWORK_ROUTE = GET_MEMORY_STATUS_NETWORK_ROUTE;
-exports.GET_MEMORY_STATUS_ROUTE = GET_MEMORY_STATUS_ROUTE;
-exports.GET_OBSERVATIONAL_MEMORY_ROUTE = GET_OBSERVATIONAL_MEMORY_ROUTE;
-exports.GET_THREAD_BY_ID_NETWORK_ROUTE = GET_THREAD_BY_ID_NETWORK_ROUTE;
-exports.GET_THREAD_BY_ID_ROUTE = GET_THREAD_BY_ID_ROUTE;
-exports.GET_WORKING_MEMORY_ROUTE = GET_WORKING_MEMORY_ROUTE;
-exports.LIST_MESSAGES_NETWORK_ROUTE = LIST_MESSAGES_NETWORK_ROUTE;
-exports.LIST_MESSAGES_ROUTE = LIST_MESSAGES_ROUTE;
-exports.LIST_THREADS_NETWORK_ROUTE = LIST_THREADS_NETWORK_ROUTE;
-exports.LIST_THREADS_ROUTE = LIST_THREADS_ROUTE;
-exports.SAVE_MESSAGES_NETWORK_ROUTE = SAVE_MESSAGES_NETWORK_ROUTE;
-exports.SAVE_MESSAGES_ROUTE = SAVE_MESSAGES_ROUTE;
-exports.SEARCH_MEMORY_ROUTE = SEARCH_MEMORY_ROUTE;
-exports.TRANSFER_THREAD_ROUTE = TRANSFER_THREAD_ROUTE;
-exports.UPDATE_THREAD_NETWORK_ROUTE = UPDATE_THREAD_NETWORK_ROUTE;
-exports.UPDATE_THREAD_ROUTE = UPDATE_THREAD_ROUTE;
-exports.UPDATE_WORKING_MEMORY_ROUTE = UPDATE_WORKING_MEMORY_ROUTE;
-exports.getTextContent = getTextContent;
-Object.defineProperty(exports, "memory_exports", {
-	enumerable: true,
-	get: function() {
-		return memory_exports;
-	}
-});
-
-//# sourceMappingURL=memory.cjs.map
+require("../../rolldown-runtime-BwC_XMyb.cjs");
+const require_memory = require("../../memory-CwwkVDh1.cjs");
+exports.AWAIT_BUFFER_STATUS_ROUTE = require_memory.AWAIT_BUFFER_STATUS_ROUTE;
+exports.CLONE_THREAD_ROUTE = require_memory.CLONE_THREAD_ROUTE;
+exports.CREATE_THREAD_NETWORK_ROUTE = require_memory.CREATE_THREAD_NETWORK_ROUTE;
+exports.CREATE_THREAD_ROUTE = require_memory.CREATE_THREAD_ROUTE;
+exports.DELETE_MESSAGES_NETWORK_ROUTE = require_memory.DELETE_MESSAGES_NETWORK_ROUTE;
+exports.DELETE_MESSAGES_ROUTE = require_memory.DELETE_MESSAGES_ROUTE;
+exports.DELETE_THREAD_NETWORK_ROUTE = require_memory.DELETE_THREAD_NETWORK_ROUTE;
+exports.DELETE_THREAD_ROUTE = require_memory.DELETE_THREAD_ROUTE;
+exports.GET_MEMORY_CONFIG_ROUTE = require_memory.GET_MEMORY_CONFIG_ROUTE;
+exports.GET_MEMORY_STATUS_NETWORK_ROUTE = require_memory.GET_MEMORY_STATUS_NETWORK_ROUTE;
+exports.GET_MEMORY_STATUS_ROUTE = require_memory.GET_MEMORY_STATUS_ROUTE;
+exports.GET_OBSERVATIONAL_MEMORY_ROUTE = require_memory.GET_OBSERVATIONAL_MEMORY_ROUTE;
+exports.GET_THREAD_BY_ID_NETWORK_ROUTE = require_memory.GET_THREAD_BY_ID_NETWORK_ROUTE;
+exports.GET_THREAD_BY_ID_ROUTE = require_memory.GET_THREAD_BY_ID_ROUTE;
+exports.GET_WORKING_MEMORY_ROUTE = require_memory.GET_WORKING_MEMORY_ROUTE;
+exports.LIST_MESSAGES_NETWORK_ROUTE = require_memory.LIST_MESSAGES_NETWORK_ROUTE;
+exports.LIST_MESSAGES_ROUTE = require_memory.LIST_MESSAGES_ROUTE;
+exports.LIST_THREADS_NETWORK_ROUTE = require_memory.LIST_THREADS_NETWORK_ROUTE;
+exports.LIST_THREADS_ROUTE = require_memory.LIST_THREADS_ROUTE;
+exports.SAVE_MESSAGES_NETWORK_ROUTE = require_memory.SAVE_MESSAGES_NETWORK_ROUTE;
+exports.SAVE_MESSAGES_ROUTE = require_memory.SAVE_MESSAGES_ROUTE;
+exports.SEARCH_MEMORY_ROUTE = require_memory.SEARCH_MEMORY_ROUTE;
+exports.TRANSFER_THREAD_ROUTE = require_memory.TRANSFER_THREAD_ROUTE;
+exports.UPDATE_THREAD_NETWORK_ROUTE = require_memory.UPDATE_THREAD_NETWORK_ROUTE;
+exports.UPDATE_THREAD_ROUTE = require_memory.UPDATE_THREAD_ROUTE;
+exports.UPDATE_WORKING_MEMORY_ROUTE = require_memory.UPDATE_WORKING_MEMORY_ROUTE;
+exports.getTextContent = require_memory.getTextContent;