@mastra/server 1.79.0-alpha.9 → 1.79.0

package/dist/agents-BOWEUKyV.cjs

@@ -0,0 +1,3127 @@
+const require_rolldown_runtime = require("./rolldown-runtime-BwC_XMyb.cjs");
+const require_http_exception = require("./http-exception-CKDHupKw.cjs");
+const require_agents = require("./agents-T-OIM9IK.cjs");
+const require_schema_CzbEIyhE = require("./schema-CzbEIyhE-20gGIWkz.cjs");
+const require_route_builder = require("./route-builder-B2Qhhd7C.cjs");
+const require_utils = require("./utils-CF76qzZR.cjs");
+const require_constants = require("./constants-e7aaPCLj.cjs");
+const require_server_handlers_error = require("./server/handlers/error.cjs");
+const require_utils$1 = require("./utils-dDLIDg8O.cjs");
+const require_stored_agents = require("./stored-agents-BTL-o6aM.cjs");
+const require_workspace = require("./workspace-BJYV2lkt.cjs");
+const require_server_handlers_tool_schema_overrides = require("./server/handlers/tool-schema-overrides.cjs");
+let zod_v4 = require("zod/v4");
+let _mastra_core_utils_zod_to_json = require("@mastra/core/utils/zod-to-json");
+let _mastra_core_agent = require("@mastra/core/agent");
+let _mastra_core_agent_durable = require("@mastra/core/agent/durable");
+let _mastra_core_di = require("@mastra/core/di");
+let _mastra_core_error = require("@mastra/core/error");
+let _mastra_core_llm = require("@mastra/core/llm");
+//#region src/server/handlers/agents.ts
+var agents_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	ABORT_AGENT_THREAD_ROUTE: () => ABORT_AGENT_THREAD_ROUTE,
+	APPROVE_NETWORK_TOOL_CALL_ROUTE: () => APPROVE_NETWORK_TOOL_CALL_ROUTE,
+	APPROVE_TOOL_CALL_GENERATE_ROUTE: () => APPROVE_TOOL_CALL_GENERATE_ROUTE,
+	APPROVE_TOOL_CALL_ROUTE: () => APPROVE_TOOL_CALL_ROUTE,
+	CANCEL_AGENT_PENDING_SIGNALS_ROUTE: () => CANCEL_AGENT_PENDING_SIGNALS_ROUTE,
+	CLONE_AGENT_ROUTE: () => CLONE_AGENT_ROUTE,
+	DECLINE_NETWORK_TOOL_CALL_ROUTE: () => DECLINE_NETWORK_TOOL_CALL_ROUTE,
+	DECLINE_TOOL_CALL_GENERATE_ROUTE: () => DECLINE_TOOL_CALL_GENERATE_ROUTE,
+	DECLINE_TOOL_CALL_ROUTE: () => DECLINE_TOOL_CALL_ROUTE,
+	ENHANCE_INSTRUCTIONS_ROUTE: () => ENHANCE_INSTRUCTIONS_ROUTE,
+	GENERATE_AGENT_ROUTE: () => GENERATE_AGENT_ROUTE,
+	GENERATE_AGENT_VNEXT_ROUTE: () => GENERATE_AGENT_VNEXT_ROUTE,
+	GENERATE_LEGACY_ROUTE: () => GENERATE_LEGACY_ROUTE,
+	GET_AGENT_BY_ID_ROUTE: () => GET_AGENT_BY_ID_ROUTE,
+	GET_AGENT_SKILL_ROUTE: () => GET_AGENT_SKILL_ROUTE,
+	GET_PROVIDERS_ROUTE: () => GET_PROVIDERS_ROUTE,
+	LIST_AGENTS_ROUTE: () => LIST_AGENTS_ROUTE,
+	LIST_SUSPENDED_RUNS_ROUTE: () => LIST_SUSPENDED_RUNS_ROUTE,
+	OBSERVE_AGENT_STREAM_ROUTE: () => OBSERVE_AGENT_STREAM_ROUTE,
+	QUEUE_AGENT_MESSAGE_ROUTE: () => QUEUE_AGENT_MESSAGE_ROUTE,
+	QUEUE_AGENT_SIGNAL_ROUTE: () => QUEUE_AGENT_SIGNAL_ROUTE,
+	RECOVER_ROUTE: () => RECOVER_ROUTE,
+	REORDER_AGENT_MODEL_LIST_ROUTE: () => REORDER_AGENT_MODEL_LIST_ROUTE,
+	RESET_AGENT_MODEL_ROUTE: () => RESET_AGENT_MODEL_ROUTE,
+	RESUME_STREAM_ROUTE: () => RESUME_STREAM_ROUTE,
+	RESUME_STREAM_UNTIL_IDLE_ROUTE: () => RESUME_STREAM_UNTIL_IDLE_ROUTE,
+	SEND_AGENT_MESSAGE_ROUTE: () => SEND_AGENT_MESSAGE_ROUTE,
+	SEND_AGENT_SIGNAL_ROUTE: () => SEND_AGENT_SIGNAL_ROUTE,
+	SEND_TOOL_APPROVAL_ROUTE: () => SEND_TOOL_APPROVAL_ROUTE,
+	STREAM_GENERATE_LEGACY_ROUTE: () => STREAM_GENERATE_LEGACY_ROUTE,
+	STREAM_GENERATE_ROUTE: () => STREAM_GENERATE_ROUTE,
+	STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE: () => STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE,
+	STREAM_NETWORK_ROUTE: () => STREAM_NETWORK_ROUTE,
+	STREAM_UI_MESSAGE_DEPRECATED_ROUTE: () => STREAM_UI_MESSAGE_DEPRECATED_ROUTE,
+	STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE: () => STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE,
+	STREAM_UNTIL_IDLE_GENERATE_ROUTE: () => STREAM_UNTIL_IDLE_GENERATE_ROUTE,
+	STREAM_VNEXT_DEPRECATED_ROUTE: () => STREAM_VNEXT_DEPRECATED_ROUTE,
+	SUBSCRIBE_AGENT_THREAD_ROUTE: () => SUBSCRIBE_AGENT_THREAD_ROUTE,
+	UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE: () => UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE,
+	UPDATE_AGENT_MODEL_ROUTE: () => UPDATE_AGENT_MODEL_ROUTE,
+	buildProvidersList: () => buildProvidersList,
+	extractVersionOptions: () => extractVersionOptions,
+	getAgentFromSystem: () => getAgentFromSystem,
+	getBrowserToolsFromAgent: () => getBrowserToolsFromAgent,
+	getSerializedAgentTools: () => getSerializedAgentTools,
+	getSerializedProcessors: () => getSerializedProcessors,
+	getSerializedSkillsFromAgent: () => getSerializedSkillsFromAgent,
+	getWorkspaceToolsFromAgent: () => getWorkspaceToolsFromAgent,
+	isProviderConnected: () => isProviderConnected
+});
+/**
+* Merge incoming version overrides onto a RequestContext.
+* Reads any existing overrides, shallow-merges per category, and writes back.
+*/
+function stashVersionOverrides(ctx, versions) {
+	if (!versions) return;
+	const existingRaw = ctx.get(_mastra_core_di.MASTRA_VERSIONS_KEY);
+	const merged = (0, _mastra_core_di.mergeVersionOverrides)(existingRaw && typeof existingRaw === "object" && !Array.isArray(existingRaw) ? existingRaw : void 0, versions);
+	if (merged) ctx.set(_mastra_core_di.MASTRA_VERSIONS_KEY, merged);
+}
+/**
+* Ensure `defaultStatus` is set on the version overrides in the RequestContext
+* so sub-agents inherit the same draft/published semantics as the parent.
+*
+* When the parent agent is resolved via a specific versionId (editor context),
+* sub-agents should default to `draft`. When resolved with published (main
+* chat), sub-agents default to `published`. An explicit `defaultStatus` from
+* the request body takes precedence.
+*/
+function ensureDefaultVersionStatus(ctx, versionOptions) {
+	const existingRaw = ctx.get(_mastra_core_di.MASTRA_VERSIONS_KEY);
+	if (existingRaw?.defaultStatus) return;
+	const inferredStatus = versionOptions ? "draft" : "published";
+	const updated = {
+		...existingRaw,
+		defaultStatus: inferredStatus
+	};
+	ctx.set(_mastra_core_di.MASTRA_VERSIONS_KEY, updated);
+}
+function getIsStudioFromContext(requestContext) {
+	return requestContext.get(require_constants.MASTRA_IS_STUDIO_KEY) === true;
+}
+function normalizePublicExecutionOptions(options, serverRequestContext) {
+	if (!options || typeof options !== "object" || Array.isArray(options)) return void 0;
+	const { actor: _actor, scopes: _scopes, requestContext, ...normalized } = options;
+	require_utils$1.stripClientCredentialHeaders(normalized);
+	require_utils$1.mergeBodyRequestContext(serverRequestContext, requestContext);
+	return {
+		...normalized,
+		requestContext: serverRequestContext
+	};
+}
+function hasSuspendedToolCall(snapshot, toolCallId) {
+	const resumeTarget = snapshot.resumeLabels?.[toolCallId];
+	const resumeStep = resumeTarget?.stepId ? snapshot.context?.[resumeTarget.stepId] : void 0;
+	if (resumeStep?.status === "suspended" && (resumeStep.suspendPayload?.requireToolApproval || resumeStep.suspendPayload?.toolCallSuspended || resumeStep.suspendPayload?.toolCallId)) return true;
+	const visit = (value) => {
+		if (!value || typeof value !== "object") return false;
+		if (Array.isArray(value)) return value.some(visit);
+		const record = value;
+		const payload = record.suspendPayload;
+		if (record.status === "suspended" && (payload?.requireToolApproval?.toolCallId === toolCallId || payload?.toolCallId === toolCallId)) return true;
+		return Object.values(record).some(visit);
+	};
+	return visit(snapshot.context);
+}
+const DURABLE_SNAPSHOT_WAIT_TIMEOUT_MS = 1e4;
+const DURABLE_SNAPSHOT_WAIT_INTERVAL_MS = 25;
+function getDurableLoopWorkflowName(agent) {
+	return agent.durableLoopWorkflowName ?? _mastra_core_agent_durable.DurableStepIds.AGENTIC_LOOP;
+}
+async function validateDurableToolCallAccess({ mastra, agent, runId, toolCallId, requestContext, threadId, abortSignal }) {
+	if (!(0, _mastra_core_agent.isDurableAgentLike)(agent)) return;
+	const workflowsStore = await mastra.getStorage()?.getStore("workflows");
+	if (!workflowsStore) throw new require_http_exception.HTTPException(403, { message: "Access denied: durable run belongs to a different resource" });
+	const workflowName = getDurableLoopWorkflowName(agent);
+	const contextResourceId = require_utils$1.getContextResourceId(requestContext);
+	const deadline = Date.now() + DURABLE_SNAPSHOT_WAIT_TIMEOUT_MS;
+	while (true) {
+		const workflowRun = await workflowsStore.getWorkflowRunById({
+			workflowName,
+			runId
+		});
+		let snapshot = workflowRun?.snapshot;
+		if (typeof snapshot === "string") try {
+			snapshot = JSON.parse(snapshot);
+		} catch {
+			snapshot = void 0;
+		}
+		const input = snapshot?.context?.input;
+		const persistedResourceIds = new Set([
+			workflowRun?.resourceId,
+			input?.state?.resourceId,
+			input?.messageListState?.memoryInfo?.resourceId,
+			input?.requestContextEntries?.[require_constants.MASTRA_RESOURCE_ID_KEY]
+		].filter((resourceId) => typeof resourceId === "string" && resourceId.length > 0));
+		const [persistedResourceId] = persistedResourceIds;
+		if (persistedResourceIds.size > 1 || contextResourceId && persistedResourceId && persistedResourceId !== contextResourceId) throw new require_http_exception.HTTPException(403, { message: "Access denied: durable run belongs to a different resource" });
+		const ready = !!workflowRun && !!snapshot && snapshot.status === "suspended" && (toolCallId === void 0 || hasSuspendedToolCall(snapshot, toolCallId));
+		if (ready || Date.now() >= deadline || abortSignal?.aborted) {
+			if (!workflowRun) throw new require_http_exception.HTTPException(403, { message: "Access denied: durable run belongs to a different resource" });
+			const persistedThreadId = input?.state?.threadId ?? input?.messageListState?.memoryInfo?.threadId;
+			if (threadId && persistedThreadId !== threadId) throw new require_http_exception.HTTPException(403, { message: "Access denied: durable run belongs to a different thread" });
+			if (!ready || input?.agentId !== agent.id) throw new require_http_exception.HTTPException(403, { message: "Access denied: tool call is not suspended on this durable run" });
+			await require_utils$1.validateRunOwnership({ resourceId: persistedResourceId }, contextResourceId, mastra);
+			return;
+		}
+		await new Promise((resolve) => setTimeout(resolve, DURABLE_SNAPSHOT_WAIT_INTERVAL_MS));
+	}
+}
+/**
+* Providers whose apiKeyEnvVar entries are aliases for the same credential (any one
+* suffices), rather than distinct required values (all needed — the default assumption).
+* Keep this list to cases with a confirmed alias relationship; see the "google" entry in
+* PROVIDER_OVERRIDES in packages/core/src/llm/model/gateways/models-dev.ts and #17343.
+*/
+const ALIASED_API_KEY_ENV_VAR_PROVIDERS = /* @__PURE__ */ new Set(["google"]);
+/**
+* Checks if a provider has its required API key environment variable(s) configured.
+* Handles provider IDs with suffixes (e.g., "openai.chat" -> "openai").
+* Also handles custom gateway providers that are stored with gateway prefix (e.g., "acme/acme-openai").
+* @param providerId - The provider identifier (may include a suffix like ".chat" or be from a custom gateway)
+* @param customProviders - Optional record of custom gateway providers to check
+* @returns true if all required environment variables are set (or, for aliased providers, if any one is set), false otherwise
+*/
+function isProviderConnected(providerId, customProviders) {
+	if (providerId === "google-vertex" || providerId.startsWith("google.vertex")) return !!(process.env.GOOGLE_VERTEX_PROJECT && process.env.GOOGLE_VERTEX_LOCATION);
+	const cleanId = providerId.includes(".") ? providerId.split(".")[0] : providerId;
+	let provider = _mastra_core_llm.PROVIDER_REGISTRY[cleanId];
+	if (!provider && customProviders) provider = customProviders[cleanId];
+	if (!provider && !cleanId.includes("/")) {
+		const matchingKey = Object.keys(_mastra_core_llm.PROVIDER_REGISTRY).find((key) => {
+			const parts = key.split("/");
+			return parts.length === 2 && parts[1] === cleanId;
+		});
+		if (matchingKey) provider = _mastra_core_llm.PROVIDER_REGISTRY[matchingKey];
+		if (!provider && customProviders) {
+			const customMatchingKey = Object.keys(customProviders).find((key) => {
+				const parts = key.split("/");
+				return parts.length === 2 && parts[1] === cleanId;
+			});
+			if (customMatchingKey) provider = customProviders[customMatchingKey];
+		}
+	}
+	if (!provider) return false;
+	const envVars = Array.isArray(provider.apiKeyEnvVar) ? provider.apiKeyEnvVar : [provider.apiKeyEnvVar];
+	if (ALIASED_API_KEY_ENV_VAR_PROVIDERS.has(cleanId)) return envVars.some((envVar) => !!process.env[envVar]);
+	return envVars.every((envVar) => !!process.env[envVar]);
+}
+function resolveLazySchema(schema) {
+	if (typeof schema === "function" && !("~standard" in schema)) return resolveLazySchema(schema());
+	return schema;
+}
+function schemaToJsonSchema(schema) {
+	if (!schema) return;
+	return require_schema_CzbEIyhE.standardSchemaToJSONSchema(require_schema_CzbEIyhE.toStandardSchema(schema), { target: "draft-2020-12" });
+}
+function getAgentModelRef(agentModel, llm) {
+	if (typeof agentModel === "string") {
+		const { provider, modelId } = (0, _mastra_core_llm.parseModelString)(agentModel);
+		return {
+			provider: provider ?? llm?.getProvider(),
+			modelId
+		};
+	}
+	const model = llm?.getModel();
+	if (model instanceof _mastra_core_llm.ModelRouterLanguageModel && model.gatewayId !== "models.dev" && model.gatewayId !== model.provider) return {
+		provider: model.gatewayId,
+		modelId: `${model.provider}/${model.modelId}`
+	};
+	return {
+		provider: llm?.getProvider(),
+		modelId: llm?.getModelId()
+	};
+}
+async function getSerializedAgentTools(tools, partial = false) {
+	return Object.entries(tools || {}).reduce((acc, [key, tool]) => {
+		const toolId = "id" in tool && typeof tool.id === "string" && tool.id.length > 0 ? tool.id : `tool-${key}`;
+		let inputSchemaForReturn = void 0;
+		let outputSchemaForReturn = void 0;
+		let requestContextSchemaForReturn = void 0;
+		if (!partial) try {
+			const inputSchema = schemaToJsonSchema(resolveLazySchema("inputSchema" in tool ? tool.inputSchema : void 0));
+			if (inputSchema !== void 0) inputSchemaForReturn = require_utils.stringify(require_server_handlers_tool_schema_overrides.stripInjectedToolOverrideFields(inputSchema));
+			const outputSchema = schemaToJsonSchema(resolveLazySchema("outputSchema" in tool ? tool.outputSchema : void 0));
+			if (outputSchema !== void 0) outputSchemaForReturn = require_utils.stringify(outputSchema);
+			const requestContextSchema = schemaToJsonSchema(resolveLazySchema("requestContextSchema" in tool ? tool.requestContextSchema : void 0));
+			if (requestContextSchema !== void 0) requestContextSchemaForReturn = require_utils.stringify(requestContextSchema);
+		} catch (error) {
+			console.error(`Error getting serialized tool`, {
+				toolId,
+				error
+			});
+		}
+		acc[key] = {
+			...tool,
+			id: toolId,
+			inputSchema: inputSchemaForReturn,
+			outputSchema: outputSchemaForReturn,
+			requestContextSchema: requestContextSchemaForReturn
+		};
+		return acc;
+	}, {});
+}
+function getSerializedProcessors(processors) {
+	return processors.map((processor) => {
+		return {
+			id: processor.id,
+			name: processor.name || processor.constructor.name
+		};
+	});
+}
+/**
+* Extract skills from an agent (both inline and workspace skills).
+* Uses agent.listSkills() which merges agent-level and workspace-level skills.
+*/
+async function getSerializedSkillsFromAgent(agent, requestContext) {
+	try {
+		return (await agent.listSkills({ requestContext })).map((skill) => ({
+			name: skill.name,
+			description: skill.description,
+			license: skill.license,
+			path: skill.path
+		}));
+	} catch {
+		return [];
+	}
+}
+/**
+* Get the list of available workspace tools for an agent.
+*
+* Tries to use core's `createWorkspaceTools` for an accurate tool list that
+* respects runtime availability (e.g. `@ast-grep/napi` for ast_edit).
+* Falls back to inlined config-based logic for older core versions that don't
+* export `createWorkspaceTools`.
+*/
+async function getWorkspaceToolsFromAgent(agent, requestContext) {
+	try {
+		const workspace = await agent.getWorkspace({ requestContext });
+		if (!workspace) return [];
+		try {
+			const mod = await import("@mastra/core/workspace");
+			if (typeof mod.createWorkspaceTools === "function") return Object.keys(await mod.createWorkspaceTools(workspace));
+		} catch {}
+		const tools = [];
+		const isReadOnly = workspace.filesystem?.readOnly ?? false;
+		const toolsConfig = workspace.getToolsConfig();
+		const configContext = {
+			workspace,
+			requestContext: requestContext ? Object.fromEntries(requestContext.entries()) : {}
+		};
+		const isEnabled = async (toolName) => {
+			return (await require_constants.resolveToolConfig(toolsConfig, toolName, configContext)).enabled;
+		};
+		if (workspace.filesystem) {
+			if (await isEnabled(require_constants.WORKSPACE_TOOLS.FILESYSTEM.READ_FILE)) tools.push(require_constants.WORKSPACE_TOOLS.FILESYSTEM.READ_FILE);
+			if (await isEnabled(require_constants.WORKSPACE_TOOLS.FILESYSTEM.LIST_FILES)) tools.push(require_constants.WORKSPACE_TOOLS.FILESYSTEM.LIST_FILES);
+			if (await isEnabled(require_constants.WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT)) tools.push(require_constants.WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT);
+			if (!isReadOnly) {
+				if (await isEnabled(require_constants.WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE)) tools.push(require_constants.WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE);
+				if (await isEnabled(require_constants.WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE)) tools.push(require_constants.WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE);
+				if (await isEnabled(require_constants.WORKSPACE_TOOLS.FILESYSTEM.DELETE)) tools.push(require_constants.WORKSPACE_TOOLS.FILESYSTEM.DELETE);
+				if (await isEnabled(require_constants.WORKSPACE_TOOLS.FILESYSTEM.MKDIR)) tools.push(require_constants.WORKSPACE_TOOLS.FILESYSTEM.MKDIR);
+			}
+			if (await isEnabled(require_constants.WORKSPACE_TOOLS.FILESYSTEM.GREP)) tools.push(require_constants.WORKSPACE_TOOLS.FILESYSTEM.GREP);
+		}
+		if (workspace.canBM25 || workspace.canVector) {
+			if (await isEnabled(require_constants.WORKSPACE_TOOLS.SEARCH.SEARCH)) tools.push(require_constants.WORKSPACE_TOOLS.SEARCH.SEARCH);
+			if (!isReadOnly && await isEnabled(require_constants.WORKSPACE_TOOLS.SEARCH.INDEX)) tools.push(require_constants.WORKSPACE_TOOLS.SEARCH.INDEX);
+		}
+		if (workspace.sandbox) {
+			if (workspace.sandbox.executeCommand && await isEnabled(require_constants.WORKSPACE_TOOLS.SANDBOX.EXECUTE_COMMAND)) tools.push(require_constants.WORKSPACE_TOOLS.SANDBOX.EXECUTE_COMMAND);
+		}
+		return tools;
+	} catch {
+		return [];
+	}
+}
+/**
+* Get the list of browser tool names for an agent.
+* Returns the tool names from the agent's browser provider if configured.
+*/
+function getBrowserToolsFromAgent(agent, onError) {
+	try {
+		const browser = agent.browser;
+		if (!browser) return [];
+		return Object.keys(browser.getTools());
+	} catch (error) {
+		onError?.(error);
+		return [];
+	}
+}
+function createBrowserToolsErrorLogger(logger, agentId) {
+	return (error) => logger.warn("Failed to get browser tools for agent", {
+		agentId,
+		error
+	});
+}
+async function getSerializedAgentDefinition({ agent, requestContext, logger }) {
+	let serializedAgentAgents = {};
+	if ("listAgents" in agent) try {
+		const agents = await agent.listAgents({ requestContext });
+		serializedAgentAgents = Object.entries(agents || {}).reduce((acc, [key, agent]) => {
+			acc[key] = {
+				id: agent.id,
+				name: agent.name ?? key
+			};
+			return acc;
+		}, {});
+	} catch (error) {
+		logger?.warn("Error getting sub-agents for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	return serializedAgentAgents;
+}
+async function formatAgentList({ id, mastra, agent, requestContext, partial = false }) {
+	const logger = mastra.getLogger();
+	const description = agent.getDescription();
+	let metadata;
+	if (typeof agent.getMetadata === "function") try {
+		metadata = await agent.getMetadata({ requestContext });
+	} catch (error) {
+		logger.warn(`Failed to get metadata for agent ${agent.name}`, { error });
+	}
+	let instructions;
+	try {
+		instructions = await agent.getInstructions({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting instructions for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let tools = {};
+	try {
+		tools = await agent.listTools({ requestContext });
+	} catch (error) {
+		logger.warn("Error listing tools for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let llm;
+	try {
+		llm = await agent.getLLM({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting LLM for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let defaultGenerateOptionsLegacy;
+	try {
+		defaultGenerateOptionsLegacy = await agent.getDefaultGenerateOptionsLegacy({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting default generate options for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let defaultStreamOptionsLegacy;
+	try {
+		defaultStreamOptionsLegacy = await agent.getDefaultStreamOptionsLegacy({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting default stream options for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let defaultOptions;
+	try {
+		defaultOptions = await agent.getDefaultOptions({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting default options for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const serializedAgentTools = await getSerializedAgentTools(tools, partial);
+	let serializedAgentWorkflows = {};
+	if ("listWorkflows" in agent) try {
+		const workflows = await agent.listWorkflows({ requestContext });
+		serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+			return {
+				...acc,
+				[key]: { name: workflow.name || "Unnamed workflow" }
+			};
+		}, {});
+	} catch (error) {
+		logger.error("Error getting workflows for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const serializedAgentAgents = await getSerializedAgentDefinition({
+		agent,
+		requestContext,
+		logger
+	});
+	let serializedInputProcessors = [];
+	let serializedOutputProcessors = [];
+	try {
+		const configuredProcessorWorkflows = await agent.getConfiguredProcessorWorkflows();
+		const inputProcessorWorkflows = configuredProcessorWorkflows.filter((w) => w.id.endsWith("-input-processor"));
+		const outputProcessorWorkflows = configuredProcessorWorkflows.filter((w) => w.id.endsWith("-output-processor"));
+		serializedInputProcessors = getSerializedProcessors(inputProcessorWorkflows);
+		serializedOutputProcessors = getSerializedProcessors(outputProcessorWorkflows);
+	} catch (error) {
+		logger.error("Error getting configured processors for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const serializedSkills = await getSerializedSkillsFromAgent(agent, requestContext);
+	const workspaceTools = await getWorkspaceToolsFromAgent(agent, requestContext);
+	const browserTools = getBrowserToolsFromAgent(agent, createBrowserToolsErrorLogger(logger, agent.id));
+	let workspaceId;
+	let workspaceBrowser = false;
+	try {
+		const workspace = await agent.getWorkspace({ requestContext });
+		workspaceId = workspace?.id;
+		workspaceBrowser = Boolean(workspace?.browser);
+	} catch {}
+	const hasBrowser = browserTools.length > 0 || workspaceBrowser;
+	const model = llm?.getModel();
+	const supportsMemory = typeof agent.supportsMemory === "function" ? agent.supportsMemory() : true;
+	let models;
+	try {
+		models = await agent.getModelList(requestContext);
+	} catch (error) {
+		logger.warn("Error getting model list for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const modelList = models?.map((md) => ({
+		...md,
+		model: {
+			modelId: md.model.modelId,
+			provider: md.model.provider,
+			modelVersion: md.model.specificationVersion
+		}
+	}));
+	let serializedRequestContextSchema;
+	if (agent.requestContextSchema) try {
+		serializedRequestContextSchema = require_utils.stringify((0, _mastra_core_utils_zod_to_json.zodToJsonSchema)(agent.requestContextSchema));
+	} catch (error) {
+		logger.error("Error serializing requestContextSchema for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	return {
+		id: agent.id || id,
+		name: agent.name,
+		description,
+		metadata,
+		instructions,
+		agents: serializedAgentAgents,
+		tools: serializedAgentTools,
+		workflows: serializedAgentWorkflows,
+		skills: serializedSkills,
+		workspaceTools,
+		browserTools,
+		hasBrowser,
+		workspaceId,
+		inputProcessors: serializedInputProcessors,
+		outputProcessors: serializedOutputProcessors,
+		...getAgentModelRef(agent.model, llm),
+		modelVersion: model?.specificationVersion,
+		supportsMemory,
+		defaultOptions,
+		modelList,
+		modelListEditable: modelList ? typeof agent.model !== "function" : void 0,
+		defaultGenerateOptionsLegacy,
+		defaultStreamOptionsLegacy,
+		requestContextSchema: serializedRequestContextSchema,
+		source: agent.source ?? "code",
+		editor: agent.__getEditorConfig?.(),
+		...agent.toRawConfig()?.status ? { status: agent.toRawConfig().status } : {},
+		...agent.toRawConfig()?.activeVersionId ? { activeVersionId: agent.toRawConfig().activeVersionId } : {},
+		hasDraft: !!(agent.toRawConfig()?.resolvedVersionId && agent.toRawConfig()?.activeVersionId && agent.toRawConfig().resolvedVersionId !== agent.toRawConfig().activeVersionId)
+	};
+}
+function extractVersionOptions(requestContext, bodyRequestContext) {
+	const agentVersionId = requestContext?.get("agentVersionId");
+	if (typeof agentVersionId === "string" && agentVersionId) return { versionId: agentVersionId };
+	const bodyVersionId = bodyRequestContext?.agentVersionId;
+	if (typeof bodyVersionId === "string" && bodyVersionId) return { versionId: bodyVersionId };
+}
+async function getAgentFromSystem({ mastra, agentId, versionOptions, requestContext }) {
+	const logger = mastra.getLogger();
+	if (!agentId) throw new require_http_exception.HTTPException(400, { message: "Agent ID is required" });
+	let agent;
+	try {
+		agent = mastra.getAgentById(agentId);
+	} catch (error) {
+		logger.debug("Error getting agent from mastra, searching agents for agent", error);
+	}
+	if (!agent) {
+		logger.debug("Agent not found, looking through sub-agents", { agentId });
+		const agents = mastra.listAgents();
+		if (Object.keys(agents || {}).length) for (const [_, ag] of Object.entries(agents)) try {
+			const subAgent = (await ag.listAgents())[agentId];
+			if (subAgent instanceof _mastra_core_agent.Agent) {
+				agent = subAgent;
+				break;
+			}
+		} catch (error) {
+			logger.debug("Error getting agent from agent", error);
+		}
+	}
+	if (agent && mastra.getEditor) try {
+		const editorAgent = mastra.getEditor()?.agent;
+		if (editorAgent) agent = await editorAgent.applyStoredOverrides(agent, versionOptions ?? { status: "published" }, requestContext);
+	} catch (error) {
+		logger.debug("Error applying stored overrides to code agent", error);
+	}
+	if (!agent) {
+		logger.debug("Agent not found in code-defined agents, looking in stored agents", { agentId });
+		try {
+			agent = await mastra.getEditor()?.agent.getById(agentId, versionOptions) ?? null;
+		} catch (error) {
+			logger.debug("Error getting stored agent", error);
+		}
+	}
+	if (!agent) throw new require_http_exception.HTTPException(404, { message: `Agent with id ${agentId} not found` });
+	return agent;
+}
+async function formatAgent({ mastra, agent, requestContext, isStudio }) {
+	const logger = mastra.getLogger();
+	const description = agent.getDescription();
+	let metadata;
+	if (typeof agent.getMetadata === "function") try {
+		metadata = await agent.getMetadata({ requestContext });
+	} catch (error) {
+		logger.warn(`Failed to get metadata for agent ${agent.name}`, { error });
+	}
+	let tools = {};
+	try {
+		tools = await agent.listTools({ requestContext });
+	} catch (error) {
+		logger.warn("Error listing tools for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const serializedAgentTools = await getSerializedAgentTools(tools);
+	let serializedAgentWorkflows = {};
+	if ("listWorkflows" in agent) try {
+		const workflows = await agent.listWorkflows({ requestContext });
+		serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+			return {
+				...acc,
+				[key]: {
+					name: workflow.name || "Unnamed workflow",
+					steps: Object.entries(workflow.steps).reduce((acc, [key, step]) => {
+						return {
+							...acc,
+							[key]: {
+								id: step.id,
+								description: step.description
+							}
+						};
+					}, {})
+				}
+			};
+		}, {});
+	} catch (error) {
+		logger.error("Error getting workflows for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const instructionsRequestContext = isStudio ? new Proxy(requestContext, { get(target, prop) {
+		if (prop === "get") return function(key) {
+			return target.get(key) ?? `<${key}>`;
+		};
+		return Reflect.get(target, prop);
+	} }) : requestContext;
+	let instructions;
+	try {
+		instructions = await agent.getInstructions({ requestContext: instructionsRequestContext });
+	} catch (error) {
+		logger.warn("Error getting instructions for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let llm;
+	try {
+		llm = await agent.getLLM({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting LLM for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let defaultGenerateOptionsLegacy;
+	try {
+		defaultGenerateOptionsLegacy = await agent.getDefaultGenerateOptionsLegacy({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting default generate options for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let defaultStreamOptionsLegacy;
+	try {
+		defaultStreamOptionsLegacy = await agent.getDefaultStreamOptionsLegacy({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting default stream options for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	let defaultOptions;
+	try {
+		defaultOptions = await agent.getDefaultOptions({ requestContext });
+	} catch (error) {
+		logger.warn("Error getting default options for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const model = llm?.getModel();
+	const supportsMemory = typeof agent.supportsMemory === "function" ? agent.supportsMemory() : true;
+	let models;
+	try {
+		models = await agent.getModelList(requestContext);
+	} catch (error) {
+		logger.warn("Error getting model list for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const modelList = models?.map((md) => ({
+		...md,
+		model: {
+			modelId: md.model.modelId,
+			provider: md.model.provider,
+			modelVersion: md.model.specificationVersion
+		}
+	}));
+	const serializedAgentAgents = await getSerializedAgentDefinition({
+		agent,
+		requestContext,
+		logger
+	});
+	let serializedInputProcessors = [];
+	let serializedOutputProcessors = [];
+	try {
+		const configuredProcessorWorkflows = await agent.getConfiguredProcessorWorkflows();
+		const inputProcessorWorkflows = configuredProcessorWorkflows.filter((w) => w.id.endsWith("-input-processor"));
+		const outputProcessorWorkflows = configuredProcessorWorkflows.filter((w) => w.id.endsWith("-output-processor"));
+		serializedInputProcessors = getSerializedProcessors(inputProcessorWorkflows);
+		serializedOutputProcessors = getSerializedProcessors(outputProcessorWorkflows);
+	} catch (error) {
+		logger.error("Error getting configured processors for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	const serializedSkills = await getSerializedSkillsFromAgent(agent, requestContext);
+	const workspaceTools = await getWorkspaceToolsFromAgent(agent, requestContext);
+	const browserTools = getBrowserToolsFromAgent(agent, createBrowserToolsErrorLogger(logger, agent.id));
+	let workspaceId;
+	let workspaceBrowser = false;
+	try {
+		const workspace = await agent.getWorkspace({ requestContext });
+		workspaceId = workspace?.id;
+		workspaceBrowser = Boolean(workspace?.browser);
+	} catch {}
+	const hasBrowser = browserTools.length > 0 || workspaceBrowser;
+	let serializedRequestContextSchema;
+	if (agent.requestContextSchema) try {
+		serializedRequestContextSchema = require_utils.stringify((0, _mastra_core_utils_zod_to_json.zodToJsonSchema)(agent.requestContextSchema));
+	} catch (error) {
+		logger.error("Error serializing requestContextSchema for agent", {
+			agentName: agent.name,
+			error
+		});
+	}
+	return {
+		name: agent.name,
+		description,
+		metadata,
+		instructions,
+		tools: serializedAgentTools,
+		agents: serializedAgentAgents,
+		workflows: serializedAgentWorkflows,
+		skills: serializedSkills,
+		workspaceTools,
+		browserTools,
+		hasBrowser,
+		workspaceId,
+		inputProcessors: serializedInputProcessors,
+		outputProcessors: serializedOutputProcessors,
+		...getAgentModelRef(agent.model, llm),
+		modelVersion: model?.specificationVersion,
+		supportsMemory,
+		modelList,
+		modelListEditable: modelList ? typeof agent.model !== "function" : void 0,
+		defaultOptions,
+		defaultGenerateOptionsLegacy,
+		defaultStreamOptionsLegacy,
+		requestContextSchema: serializedRequestContextSchema,
+		source: agent.source ?? "code",
+		editor: agent.__getEditorConfig?.(),
+		...agent.toRawConfig()?.status ? { status: agent.toRawConfig().status } : {}
+	};
+}
+const LIST_AGENTS_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/agents",
+	responseType: "json",
+	queryParamSchema: zod_v4.z.object({ partial: zod_v4.z.string().optional() }),
+	responseSchema: require_agents.listAgentsResponseSchema,
+	summary: "List all agents",
+	description: "Returns a list of all available agents in the system (both code-defined and stored)",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: require_utils$1.MastraFGAPermissions.AGENTS_READ,
+	handler: async ({ mastra, requestContext, partial }) => {
+		try {
+			const codeAgents = mastra.listAgents();
+			const isPartial = partial === "true";
+			const editor = mastra.getEditor?.();
+			const logger = mastra.getLogger();
+			const serializedCodeAgentsMap = await Promise.allSettled(Object.entries(codeAgents).map(async ([id, agent]) => {
+				let mergedAgent = agent;
+				if (editor) try {
+					mergedAgent = await editor.agent.applyStoredOverrides(agent, void 0, requestContext);
+				} catch {}
+				return formatAgentList({
+					id,
+					mastra,
+					agent: mergedAgent,
+					requestContext,
+					partial: isPartial
+				});
+			}));
+			const serializedAgents = {};
+			for (let i = 0; i < serializedCodeAgentsMap.length; i++) {
+				const settled = serializedCodeAgentsMap[i];
+				if (settled.status === "fulfilled") {
+					const { id, ...rest } = settled.value;
+					serializedAgents[id] = {
+						id,
+						...rest
+					};
+				} else {
+					const agentId = Object.keys(codeAgents)[i];
+					logger.warn("Failed to serialize agent", {
+						agentId,
+						error: settled.reason
+					});
+				}
+			}
+			try {
+				const editor = mastra.getEditor();
+				let storedAgentsResult;
+				try {
+					storedAgentsResult = await editor?.agent.list();
+				} catch (error) {
+					console.error("Error listing stored agents:", error);
+					storedAgentsResult = null;
+				}
+				const codeAgentIds = /* @__PURE__ */ new Set();
+				for (const [key, agent] of Object.entries(codeAgents)) {
+					codeAgentIds.add(key);
+					if (agent?.id) codeAgentIds.add(agent.id);
+				}
+				if (storedAgentsResult?.agents) for (const storedAgentConfig of storedAgentsResult.agents) {
+					if (codeAgentIds.has(storedAgentConfig.id)) continue;
+					try {
+						const agent = await editor?.agent.getById(storedAgentConfig.id, { status: "draft" });
+						if (!agent) continue;
+						const serialized = await formatAgentList({
+							id: agent.id,
+							mastra,
+							agent,
+							requestContext,
+							partial: isPartial
+						});
+						if (!serializedAgents[serialized.id]) serializedAgents[serialized.id] = serialized;
+					} catch (agentError) {
+						mastra.getLogger().warn("Failed to serialize stored agent", {
+							agentId: storedAgentConfig.id,
+							error: agentError
+						});
+					}
+				}
+			} catch (storageError) {
+				mastra.getLogger().debug("Could not fetch stored agents", { error: storageError });
+			}
+			const fgaProvider = mastra.getServer?.()?.fga;
+			const user = requestContext?.get("user");
+			if (fgaProvider && user) {
+				const agentList = Object.values(serializedAgents);
+				const accessible = await fgaProvider.filterAccessible(user, agentList, "agent", require_utils$1.MastraFGAPermissions.AGENTS_READ);
+				const accessibleSet = new Set(accessible.map((a) => a.id));
+				for (const id of Object.keys(serializedAgents)) if (!accessibleSet.has(id)) delete serializedAgents[id];
+			}
+			return serializedAgents;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting agents");
+		}
+	}
+});
+const GET_AGENT_BY_ID_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/agents/:agentId",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	queryParamSchema: require_agents.agentVersionQuerySchema,
+	responseSchema: require_agents.serializedAgentSchema,
+	summary: "Get agent by ID",
+	description: "Returns details for a specific agent including configuration, tools, and memory settings. Use query params to control which stored config version is used for overrides: ?status=published (active version, default), ?status=draft (latest draft), or ?versionId=<id> (specific version). Use either status or versionId, not both.",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: require_utils$1.MastraFGAPermissions.AGENTS_READ,
+	handler: async ({ agentId, mastra, requestContext, status, versionId }) => {
+		try {
+			return await formatAgent({
+				mastra,
+				agent: await getAgentFromSystem({
+					mastra,
+					agentId,
+					versionOptions: versionId ? { versionId } : status ? { status } : void 0,
+					requestContext
+				}),
+				requestContext,
+				isStudio: getIsStudioFromContext(requestContext)
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting agent");
+		}
+	}
+});
+/**
+* POST /agents/:agentId/clone - Clone an agent to a stored agent
+*/
+const CLONE_AGENT_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/clone",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: zod_v4.z.object({
+		newId: zod_v4.z.string().optional().describe("ID for the cloned agent. If not provided, derived from agent ID."),
+		newName: zod_v4.z.string().optional().describe("Name for the cloned agent. Defaults to \"{name} (Clone)\"."),
+		metadata: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).optional(),
+		authorId: zod_v4.z.string().optional()
+	}),
+	responseSchema: require_stored_agents.createStoredAgentResponseSchema,
+	summary: "Clone agent",
+	description: "Clones a code-defined or stored agent to a new stored agent in the database",
+	tags: ["Agents"],
+	requiresAuth: true,
+	handler: async ({ agentId, mastra, newId, newName, metadata, authorId, requestContext }) => {
+		try {
+			const editor = mastra.getEditor();
+			if (!editor) return require_server_handlers_error.handleError(/* @__PURE__ */ new Error("Editor is not configured on the Mastra instance"), "Error cloning agent");
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			const cloneId = require_utils.toSlug(newId || `${agentId}-clone`);
+			return await editor.agent.clone(agent, {
+				newId: cloneId,
+				newName,
+				metadata,
+				authorId,
+				requestContext
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error cloning agent");
+		}
+	}
+});
+const GENERATE_AGENT_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/generate",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionBodySchema,
+	responseSchema: require_agents.generateResponseSchema,
+	summary: "Generate agent response",
+	description: "Executes an agent with the provided messages and returns the complete response",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: require_utils$1.MastraFGAPermissions.AGENTS_EXECUTE,
+	handler: async ({ agentId, mastra, abortSignal, requestContext: serverRequestContext, ...params }) => {
+		try {
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			const { messages, memory: memoryOption, requestContext: bodyRequestContext, versions, ...rest } = params;
+			require_utils$1.validateBody({ messages });
+			const versionOptions = extractVersionOptions(serverRequestContext, bodyRequestContext);
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions,
+				requestContext: serverRequestContext
+			});
+			require_utils$1.mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
+			stashVersionOverrides(serverRequestContext, versions);
+			ensureDefaultVersionStatus(serverRequestContext, versionOptions);
+			let authorizedMemoryOption = memoryOption;
+			if (memoryOption) {
+				const clientThreadId = typeof memoryOption.thread === "string" ? memoryOption.thread : memoryOption.thread?.id;
+				const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, memoryOption.resource);
+				require_utils$1.requireEffectiveResourceId(effectiveResourceId);
+				const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, clientThreadId);
+				if (effectiveThreadId) {
+					const memoryInstance = await agent.getMemory({ requestContext: serverRequestContext });
+					if (memoryInstance) {
+						const thread = await memoryInstance.getThreadById({ threadId: effectiveThreadId });
+						if (thread) await require_utils$1.enforceThreadAccess({
+							mastra,
+							requestContext: serverRequestContext,
+							threadId: effectiveThreadId,
+							thread,
+							effectiveResourceId,
+							permission: require_utils$1.MastraFGAPermissions.MEMORY_WRITE
+						});
+					}
+				}
+				authorizedMemoryOption = {
+					...memoryOption,
+					resource: effectiveResourceId ?? memoryOption.resource,
+					thread: require_utils$1.applyEffectiveThreadId(memoryOption.thread, effectiveThreadId)
+				};
+			}
+			const { structuredOutput, ...restOptions } = rest;
+			const options = {
+				...restOptions,
+				context: restOptions.context,
+				requestContext: serverRequestContext,
+				memory: authorizedMemoryOption,
+				abortSignal
+			};
+			return structuredOutput ? await agent.generate(messages, {
+				...options,
+				structuredOutput
+			}) : await agent.generate(messages, options);
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error generating from agent");
+		}
+	}
+});
+const GENERATE_LEGACY_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/generate-legacy",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionLegacyBodySchema,
+	responseSchema: require_agents.generateResponseSchema,
+	summary: "[DEPRECATED] Generate with legacy format",
+	description: "Legacy endpoint for generating agent responses. Use /agents/:agentId/generate instead.",
+	tags: ["Agents", "Legacy"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, abortSignal, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext),
+				requestContext
+			});
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			const { messages, resourceId, resourceid, threadId, ...rest } = params;
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(requestContext, resourceId ?? resourceid);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(requestContext, threadId);
+			require_utils$1.validateBody({ messages });
+			if (effectiveThreadId && !effectiveResourceId || !effectiveThreadId && effectiveResourceId) throw new require_http_exception.HTTPException(400, { message: "Both threadId or resourceId must be provided" });
+			if (effectiveThreadId) {
+				const memory = await agent.getMemory({ requestContext });
+				if (memory) {
+					const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+					if (thread) await require_utils$1.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread,
+						effectiveResourceId,
+						permission: require_utils$1.MastraFGAPermissions.MEMORY_WRITE
+					});
+				}
+			}
+			return await agent.generateLegacy(messages, {
+				...rest,
+				abortSignal,
+				resourceId: effectiveResourceId ?? "",
+				threadId: effectiveThreadId ?? ""
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error generating from agent");
+		}
+	}
+});
+const STREAM_GENERATE_LEGACY_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/stream-legacy",
+	responseType: "datastream-response",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionLegacyBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "[DEPRECATED] Stream with legacy format",
+	description: "Legacy endpoint for streaming agent responses. Use /agents/:agentId/stream instead.",
+	tags: ["Agents", "Legacy"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, abortSignal, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext),
+				requestContext
+			});
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			const { messages, resourceId, resourceid, threadId, ...rest } = params;
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(requestContext, resourceId ?? resourceid);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(requestContext, threadId);
+			require_utils$1.validateBody({ messages });
+			if (effectiveThreadId && !effectiveResourceId || !effectiveThreadId && effectiveResourceId) throw new require_http_exception.HTTPException(400, { message: "Both threadId or resourceId must be provided" });
+			if (effectiveThreadId) {
+				const memory = await agent.getMemory({ requestContext });
+				if (memory) {
+					const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+					if (thread) await require_utils$1.enforceThreadAccess({
+						mastra,
+						requestContext,
+						threadId: effectiveThreadId,
+						thread,
+						effectiveResourceId,
+						permission: require_utils$1.MastraFGAPermissions.MEMORY_WRITE
+					});
+				}
+			}
+			const streamResult = await agent.streamLegacy(messages, {
+				...rest,
+				abortSignal,
+				resourceId: effectiveResourceId ?? "",
+				threadId: effectiveThreadId ?? ""
+			});
+			return rest.output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
+				sendUsage: true,
+				sendReasoning: true,
+				getErrorMessage: (error) => {
+					if (error instanceof Error) return `An error occurred while processing your request. ${error.message.replace(/([A-Za-z]:)?[\/][^\s,)]+/g, "<path>").replace(/\s+at\s+[^\n]*/g, "").replace(/Response body:.*/s, "").trim() || "Unknown error"}`;
+					return "An error occurred while processing your request.";
+				}
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error streaming agent response");
+		}
+	}
+});
+/**
+* Collect the full list of configured AI model providers (static registry +
+* gateway providers) in the shape returned by `GET /agents/providers`.
+*
+* Extracted so the agent-builder available-models endpoint can reuse the exact
+* same source data before applying the model policy.
+*/
+async function buildProvidersList(mastra) {
+	const allProviders = {};
+	const blockExternalProviders = process.env.AUTO_BLOCK_EXTERNAL_PROVIDERS === "true" || process.env.AUTO_BLOCK_EXTERNAL_PROVIDERS === "1";
+	const defaultGatewayIds = new Set(_mastra_core_llm.defaultGateways.map((gateway) => gateway.id));
+	if (!blockExternalProviders) for (const [id, provider] of Object.entries(_mastra_core_llm.PROVIDER_REGISTRY)) allProviders[id] = provider;
+	const gateways = mastra ? Object.values(mastra.listGateways() ?? {}) : [];
+	for (const gateway of gateways) {
+		if (gateway.id === "models.dev") continue;
+		if (blockExternalProviders && defaultGatewayIds.has(gateway.id)) continue;
+		try {
+			const gatewayProviders = await gateway.fetchProviders();
+			for (const [providerId, config] of Object.entries(gatewayProviders)) {
+				const prefixedId = providerId === gateway.id ? gateway.id : `${gateway.id}/${providerId}`;
+				if (!(prefixedId in allProviders)) allProviders[prefixedId] = config;
+			}
+		} catch (error) {
+			console.warn(`Failed to fetch providers from gateway "${gateway.id}":`, error);
+		}
+	}
+	return Object.entries(allProviders).map(([id, provider]) => {
+		return {
+			id,
+			name: provider.name,
+			label: readStringField(provider, "label") || provider.name,
+			description: readStringField(provider, "description") || "",
+			envVar: provider.apiKeyEnvVar,
+			connected: isProviderConnected(id, allProviders) || isClaimedByGateway(id, provider.models, gateways),
+			docUrl: provider.docUrl,
+			models: [...provider.models]
+		};
+	});
+}
+function isClaimedByGateway(providerId, models, gateways) {
+	const [firstModel] = models;
+	if (!firstModel) return false;
+	const routerId = `${providerId}/${firstModel}`;
+	return gateways.some((gateway) => gateway.shouldEnable?.() !== false && gateway.handlesModel?.(routerId) === true);
+}
+function readStringField(source, field) {
+	const value = source[field];
+	return typeof value === "string" ? value : void 0;
+}
+const GET_PROVIDERS_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/agents/providers",
+	responseType: "json",
+	responseSchema: require_agents.providersResponseSchema,
+	summary: "List AI providers",
+	description: "Returns a list of all configured AI model providers",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: ["agents:read"],
+	handler: async ({ mastra }) => {
+		try {
+			return { providers: await buildProvidersList(mastra) };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error fetching providers");
+		}
+	}
+});
+const GENERATE_AGENT_VNEXT_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/generate/vnext",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionBodySchema,
+	responseSchema: require_agents.generateResponseSchema,
+	summary: "Generate a response from an agent",
+	description: "Generate a response from an agent",
+	tags: ["Agents"],
+	requiresAuth: true,
+	handler: GENERATE_AGENT_ROUTE.handler
+});
+const STREAM_GENERATE_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/stream",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Stream agent response",
+	description: "Executes an agent with the provided messages and streams the response in real-time",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: require_utils$1.MastraFGAPermissions.AGENTS_EXECUTE,
+	handler: async ({ mastra, agentId, abortSignal, requestContext: serverRequestContext, ...params }) => {
+		try {
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			const { messages, memory: memoryOption, requestContext: bodyRequestContext, versions, ...rest } = params;
+			require_utils$1.validateBody({ messages });
+			const versionOptions = extractVersionOptions(serverRequestContext, bodyRequestContext);
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions,
+				requestContext: serverRequestContext
+			});
+			require_utils$1.mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
+			stashVersionOverrides(serverRequestContext, versions);
+			ensureDefaultVersionStatus(serverRequestContext, versionOptions);
+			let authorizedMemoryOption = memoryOption;
+			if (memoryOption) {
+				const clientThreadId = typeof memoryOption.thread === "string" ? memoryOption.thread : memoryOption.thread?.id;
+				const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, memoryOption.resource);
+				require_utils$1.requireEffectiveResourceId(effectiveResourceId);
+				const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, clientThreadId);
+				if (effectiveThreadId) {
+					const memoryInstance = await agent.getMemory({ requestContext: serverRequestContext });
+					if (memoryInstance) {
+						const thread = await memoryInstance.getThreadById({ threadId: effectiveThreadId });
+						if (thread) await require_utils$1.enforceThreadAccess({
+							mastra,
+							requestContext: serverRequestContext,
+							threadId: effectiveThreadId,
+							thread,
+							effectiveResourceId,
+							permission: require_utils$1.MastraFGAPermissions.MEMORY_WRITE
+						});
+					}
+				}
+				authorizedMemoryOption = {
+					...memoryOption,
+					resource: effectiveResourceId ?? memoryOption.resource,
+					thread: require_utils$1.applyEffectiveThreadId(memoryOption.thread, effectiveThreadId)
+				};
+			}
+			const { structuredOutput, untilIdle, ...restOptions } = rest;
+			const options = {
+				...restOptions,
+				requestContext: serverRequestContext,
+				memory: authorizedMemoryOption,
+				abortSignal
+			};
+			if (untilIdle) options.untilIdle = untilIdle;
+			return (structuredOutput ? await agent.stream(messages, {
+				...options,
+				structuredOutput
+			}) : await agent.stream(messages, options)).fullStream;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error streaming agent response");
+		}
+	}
+});
+const sendAgentSignalResponseSchema = zod_v4.z.object({
+	accepted: zod_v4.z.literal(true),
+	runId: zod_v4.z.string(),
+	signal: zod_v4.z.unknown().optional()
+});
+/**
+* Maps a rejected `result.accepted` (signal/message routing) to an HTTP error.
+*
+* `accepted` only rejects on a setup/misconfig failure surfaced before the run
+* starts (e.g. no model selected, request-context validation, FGA denied) — these
+* are tagged `ErrorCategory.USER` and are the caller's fault, so they map to 400.
+* Anything else falls through to `handleError` (500 by default, or the error's own
+* status). Run/generation errors never reject `accepted`; they surface on the
+* `wake` output stream instead.
+*/
+function handleSignalRoutingError(error, defaultMessage) {
+	if (error instanceof _mastra_core_error.MastraError && error.category === _mastra_core_error.ErrorCategory.USER && !error.status && !error.details?.status) throw new require_http_exception.HTTPException(400, {
+		message: error.message,
+		cause: error
+	});
+	return require_server_handlers_error.handleError(error, defaultMessage);
+}
+const sendAgentMessageResponseSchema = sendAgentSignalResponseSchema;
+const SEND_AGENT_SIGNAL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/signals",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.sendAgentSignalBodySchema,
+	responseSchema: sendAgentSignalResponseSchema,
+	summary: "Send agent signal",
+	description: "Sends a signal to an active agent run or starts a memory thread run when the thread is idle",
+	tags: ["Agents", "Streaming"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async ({ mastra, agentId, requestContext: serverRequestContext, signal, runId, resourceId, threadId, ifActive, ifIdle }) => {
+		try {
+			const idleStreamOptions = ifIdle?.streamOptions;
+			const bodyRequestContext = idleStreamOptions?.requestContext;
+			const normalizedIdleStreamOptions = normalizePublicExecutionOptions(idleStreamOptions, serverRequestContext);
+			const versionOptions = extractVersionOptions(serverRequestContext, bodyRequestContext);
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions,
+				requestContext: serverRequestContext
+			});
+			stashVersionOverrides(serverRequestContext, normalizedIdleStreamOptions?.versions);
+			ensureDefaultVersionStatus(serverRequestContext, versionOptions);
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, resourceId);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, threadId);
+			const ifIdleWithContext = { ifIdle: {
+				...ifIdle ?? {},
+				streamOptions: {
+					...normalizedIdleStreamOptions ?? {},
+					requestContext: serverRequestContext
+				}
+			} };
+			if (effectiveThreadId && effectiveResourceId) {
+				const memory = await agent.getMemory({ requestContext: serverRequestContext });
+				if (memory) {
+					const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+					await require_utils$1.validateThreadOwnership(thread, effectiveResourceId);
+				}
+			}
+			if (typeof agent.sendSignal !== "function") throw new require_http_exception.HTTPException(501, { message: "agent signals are not supported by this Mastra core version" });
+			const agentSignal = signal;
+			if (runId) {
+				const result = await agent.sendSignal(agentSignal, {
+					runId,
+					...effectiveResourceId ? { resourceId: effectiveResourceId } : {},
+					...effectiveThreadId ? { threadId: effectiveThreadId } : {},
+					...ifActive ? { ifActive } : {}
+				});
+				const settled = await result.accepted;
+				const settledRunId = "runId" in settled ? settled.runId : runId;
+				return result.signal === void 0 ? {
+					accepted: true,
+					runId: settledRunId
+				} : {
+					accepted: true,
+					runId: settledRunId,
+					signal: result.signal
+				};
+			}
+			if (!effectiveResourceId || !effectiveThreadId) throw new require_http_exception.HTTPException(400, { message: "resourceId and threadId are required when runId is not provided" });
+			const result = await agent.sendSignal(agentSignal, {
+				resourceId: effectiveResourceId,
+				threadId: effectiveThreadId,
+				...ifActive ? { ifActive } : {},
+				...ifIdleWithContext
+			});
+			const settled = await result.accepted;
+			const settledRunId = "runId" in settled ? settled.runId : result.signal?.id;
+			return result.signal === void 0 ? {
+				accepted: true,
+				runId: settledRunId
+			} : {
+				accepted: true,
+				runId: settledRunId,
+				signal: result.signal
+			};
+		} catch (error) {
+			return handleSignalRoutingError(error, "error sending agent signal");
+		}
+	}
+});
+async function handleAgentMessageRoute({ mastra, agentId, requestContext: serverRequestContext, runId, resourceId, threadId, ifActive, ifIdle, methodName, invoke }) {
+	const idleStreamOptions = ifIdle?.streamOptions;
+	const bodyRequestContext = idleStreamOptions?.requestContext;
+	const normalizedIdleStreamOptions = normalizePublicExecutionOptions(idleStreamOptions, serverRequestContext);
+	const versionOptions = extractVersionOptions(serverRequestContext, bodyRequestContext);
+	const agent = await getAgentFromSystem({
+		mastra,
+		agentId,
+		versionOptions,
+		requestContext: serverRequestContext
+	});
+	stashVersionOverrides(serverRequestContext, normalizedIdleStreamOptions?.versions);
+	ensureDefaultVersionStatus(serverRequestContext, versionOptions);
+	const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, resourceId);
+	const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, threadId);
+	const ifIdleWithContext = { ifIdle: {
+		...ifIdle ?? {},
+		streamOptions: {
+			...normalizedIdleStreamOptions ?? {},
+			requestContext: serverRequestContext
+		}
+	} };
+	if (effectiveThreadId && effectiveResourceId) {
+		const memory = await agent.getMemory({ requestContext: serverRequestContext });
+		if (memory) {
+			const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+			await require_utils$1.validateThreadOwnership(thread, effectiveResourceId);
+		}
+	}
+	if (typeof agent[methodName] !== "function") throw new require_http_exception.HTTPException(501, { message: `agent ${methodName} is not supported by this Mastra core version` });
+	if (runId) {
+		const result = await invoke(agent, {
+			runId,
+			...effectiveResourceId ? { resourceId: effectiveResourceId } : {},
+			...effectiveThreadId ? { threadId: effectiveThreadId } : {},
+			...ifActive ? { ifActive } : {}
+		});
+		const settled = await result.accepted;
+		const settledRunId = settled && "runId" in settled ? settled.runId : runId;
+		return result.signal === void 0 ? {
+			accepted: true,
+			runId: settledRunId
+		} : {
+			accepted: true,
+			runId: settledRunId,
+			signal: result.signal
+		};
+	}
+	if (!effectiveResourceId || !effectiveThreadId) throw new require_http_exception.HTTPException(400, { message: "resourceId and threadId are required when runId is not provided" });
+	const result = await invoke(agent, {
+		resourceId: effectiveResourceId,
+		threadId: effectiveThreadId,
+		...ifActive ? { ifActive } : {},
+		...ifIdleWithContext
+	});
+	const settled = await result.accepted;
+	const settledRunId = settled && "runId" in settled ? settled.runId : result.signal?.id;
+	return result.signal === void 0 ? {
+		accepted: true,
+		runId: settledRunId
+	} : {
+		accepted: true,
+		runId: settledRunId,
+		signal: result.signal
+	};
+}
+const SEND_AGENT_MESSAGE_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/send-message",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.sendAgentMessageBodySchema,
+	responseSchema: sendAgentMessageResponseSchema,
+	summary: "Send agent message",
+	description: "Sends a user message to an active agent run or starts a memory thread run when the thread is idle",
+	tags: ["Agents", "Streaming"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async (params) => {
+		try {
+			return await handleAgentMessageRoute({
+				...params,
+				methodName: "sendMessage",
+				invoke: (agent, target) => agent.sendMessage(params.message, target)
+			});
+		} catch (error) {
+			return handleSignalRoutingError(error, "error sending agent message");
+		}
+	}
+});
+const QUEUE_AGENT_MESSAGE_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/queue-message",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.queueAgentMessageBodySchema,
+	responseSchema: sendAgentMessageResponseSchema,
+	summary: "Queue agent message",
+	description: "Queues a user message to run after the active thread run completes, or starts a memory thread run when idle",
+	tags: ["Agents", "Streaming"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async (params) => {
+		try {
+			return await handleAgentMessageRoute({
+				...params,
+				methodName: "queueMessage",
+				invoke: (agent, target) => agent.queueMessage(params.message, target)
+			});
+		} catch (error) {
+			return handleSignalRoutingError(error, "error queueing agent message");
+		}
+	}
+});
+const QUEUE_AGENT_SIGNAL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/queue-signal",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.queueAgentSignalBodySchema,
+	responseSchema: sendAgentSignalResponseSchema,
+	summary: "Queue agent signal",
+	description: "Queues a typed signal to run after the active thread run completes, or starts a memory thread run when idle",
+	tags: ["Agents", "Streaming"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async (params) => {
+		try {
+			return await handleAgentMessageRoute({
+				...params,
+				methodName: "queueSignal",
+				invoke: (agent, target) => agent.queueSignal(params.signal, target)
+			});
+		} catch (error) {
+			return handleSignalRoutingError(error, "error queueing agent signal");
+		}
+	}
+});
+const ABORT_AGENT_THREAD_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/threads/abort",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.abortAgentThreadBodySchema,
+	responseSchema: require_agents.abortAgentThreadResponseSchema,
+	summary: "Abort active agent thread run",
+	description: "Aborts the currently active stream run for a memory thread without changing thread subscriptions",
+	tags: ["Agents", "Streaming"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async ({ mastra, agentId, resourceId, threadId, clearPendingSignals, expectedRunId, requestContext: serverRequestContext }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				requestContext: serverRequestContext
+			});
+			if (typeof agent.abortThreadStream !== "function") throw new require_http_exception.HTTPException(501, { message: "agent thread aborts are not supported by this Mastra core version" });
+			if (clearPendingSignals && agent.__supportsThreadSignalCancellation !== true) throw new require_http_exception.HTTPException(501, { message: "clear-on-abort requires a newer @mastra/core version. Upgrade @mastra/core alongside @mastra/server." });
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, resourceId);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, threadId);
+			if (!effectiveThreadId) throw new require_http_exception.HTTPException(400, { message: "threadId is required" });
+			const thread = await (await agent.getMemory({ requestContext: serverRequestContext }))?.getThreadById({ threadId: effectiveThreadId });
+			await require_utils$1.enforceThreadAccess({
+				mastra,
+				requestContext: serverRequestContext,
+				threadId: effectiveThreadId,
+				thread,
+				effectiveResourceId,
+				permission: require_utils$1.MastraFGAPermissions.MEMORY_WRITE
+			});
+			return { aborted: await agent.abortThreadStream({
+				resourceId: effectiveResourceId,
+				threadId: effectiveThreadId,
+				...clearPendingSignals === void 0 ? {} : { clearPendingSignals },
+				expectedRunId
+			}) };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error aborting agent thread");
+		}
+	}
+});
+const CANCEL_AGENT_PENDING_SIGNALS_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/threads/signals/cancel",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.cancelPendingAgentSignalsBodySchema,
+	responseSchema: require_agents.cancelPendingAgentSignalsResponseSchema,
+	summary: "Cancel pending thread signals",
+	description: "Cancels selected pending thread signals and propagates requested IDs through PubSub",
+	tags: ["Agents", "Streaming"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async ({ mastra, agentId, resourceId, threadId, signalIds, requestContext }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				requestContext
+			});
+			if (typeof agent.cancelQueuedMessages !== "function" || agent.__supportsThreadSignalCancellation !== true) throw new require_http_exception.HTTPException(501, { message: "thread-wide cancellation requires a newer @mastra/core version. Upgrade @mastra/core alongside @mastra/server." });
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(requestContext, resourceId);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(requestContext, threadId);
+			if (!effectiveThreadId) throw new require_http_exception.HTTPException(400, { message: "threadId is required" });
+			const thread = await (await agent.getMemory({ requestContext }))?.getThreadById({ threadId: effectiveThreadId });
+			await require_utils$1.enforceThreadAccess({
+				mastra,
+				requestContext,
+				threadId: effectiveThreadId,
+				thread,
+				effectiveResourceId,
+				permission: require_utils$1.MastraFGAPermissions.MEMORY_WRITE
+			});
+			return agent.cancelQueuedMessages({
+				resourceId: effectiveResourceId,
+				threadId: effectiveThreadId,
+				signalIds
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error cancelling pending thread signals");
+		}
+	}
+});
+const SUBSCRIBE_AGENT_THREAD_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/threads/subscribe",
+	responseType: "stream",
+	streamFormat: "sse",
+	sseFlushOnConnect: true,
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.subscribeAgentThreadBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Subscribe to agent thread runs",
+	description: "Subscribes to future and active stream runs for a memory thread",
+	tags: ["Agents", "Streaming"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async ({ mastra, agentId, resourceId, threadId, withInitialHistory, abortSignal, requestContext: serverRequestContext }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				requestContext: serverRequestContext
+			});
+			if (typeof agent.subscribeToThread !== "function") throw new require_http_exception.HTTPException(501, { message: "agent thread subscriptions are not supported by this Mastra core version" });
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, resourceId);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, threadId);
+			if (!effectiveThreadId) throw new require_http_exception.HTTPException(400, { message: "threadId is required" });
+			if (withInitialHistory) {
+				const memory = await agent.getMemory({ requestContext: serverRequestContext });
+				if (memory) {
+					const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+					await require_utils$1.enforceThreadAccess({
+						mastra,
+						requestContext: serverRequestContext,
+						threadId: effectiveThreadId,
+						thread,
+						effectiveResourceId
+					});
+				}
+			} else if (effectiveResourceId) {
+				const memory = await agent.getMemory({ requestContext: serverRequestContext });
+				if (memory) {
+					const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+					await require_utils$1.validateThreadOwnership(thread, effectiveResourceId);
+				}
+			}
+			const subscription = await agent.subscribeToThread({
+				resourceId: effectiveResourceId,
+				threadId: effectiveThreadId,
+				...withInitialHistory ? {
+					withInitialHistory,
+					requestContext: serverRequestContext
+				} : {}
+			});
+			let cleanedUp = false;
+			let heartbeat;
+			const clearHeartbeat = () => {
+				if (heartbeat) {
+					clearTimeout(heartbeat);
+					heartbeat = void 0;
+				}
+			};
+			const cleanup = (closeController) => {
+				if (cleanedUp) return;
+				cleanedUp = true;
+				clearHeartbeat();
+				subscription.unsubscribe();
+				if (closeController) try {
+					closeController.close();
+				} catch {}
+			};
+			return new ReadableStream({
+				async start(controller) {
+					const scheduleHeartbeat = () => {
+						if (cleanedUp) return;
+						clearHeartbeat();
+						heartbeat = setTimeout(() => {
+							heartbeat = void 0;
+							if (cleanedUp) return;
+							try {
+								controller.enqueue(": heartbeat\n\n");
+							} catch {
+								cleanup();
+								return;
+							}
+							scheduleHeartbeat();
+						}, 25e3);
+					};
+					const abortCleanup = () => cleanup(controller);
+					abortSignal?.addEventListener("abort", abortCleanup, { once: true });
+					scheduleHeartbeat();
+					try {
+						for await (const part of subscription.stream) {
+							controller.enqueue(part);
+							scheduleHeartbeat();
+						}
+						cleanup(controller);
+					} catch (error) {
+						cleanup();
+						controller.error(error);
+					} finally {
+						clearHeartbeat();
+						abortSignal?.removeEventListener("abort", abortCleanup);
+					}
+				},
+				cancel() {
+					cleanup();
+				}
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error subscribing to agent thread");
+		}
+	}
+});
+const STREAM_UNTIL_IDLE_GENERATE_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/stream-until-idle",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.streamUntilIdleBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Stream agent response until idle",
+	description: "Executes an agent with the provided messages and streams the response in real-time, also listens for background task completions and streams them in real-time",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: require_utils$1.MastraFGAPermissions.AGENTS_EXECUTE,
+	handler: async ({ mastra, agentId, abortSignal, requestContext: serverRequestContext, ...params }) => {
+		try {
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			const { messages, memory: memoryOption, requestContext: bodyRequestContext, ...rest } = params;
+			require_utils$1.validateBody({ messages });
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(serverRequestContext, bodyRequestContext),
+				requestContext: serverRequestContext
+			});
+			require_utils$1.mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
+			let authorizedMemoryOption = memoryOption;
+			if (memoryOption) {
+				const clientThreadId = typeof memoryOption.thread === "string" ? memoryOption.thread : memoryOption.thread?.id;
+				const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, memoryOption.resource);
+				require_utils$1.requireEffectiveResourceId(effectiveResourceId);
+				const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, clientThreadId);
+				if (effectiveThreadId && effectiveResourceId) {
+					const memoryInstance = await agent.getMemory({ requestContext: serverRequestContext });
+					if (memoryInstance) {
+						const thread = await memoryInstance.getThreadById({ threadId: effectiveThreadId });
+						await require_utils$1.validateThreadOwnership(thread, effectiveResourceId);
+					}
+				}
+				authorizedMemoryOption = {
+					...memoryOption,
+					resource: effectiveResourceId ?? memoryOption.resource,
+					thread: require_utils$1.applyEffectiveThreadId(memoryOption.thread, effectiveThreadId)
+				};
+			}
+			const { structuredOutput, ...restOptions } = rest;
+			const options = {
+				...restOptions,
+				context: restOptions.context,
+				requestContext: serverRequestContext,
+				memory: authorizedMemoryOption,
+				abortSignal
+			};
+			return (structuredOutput ? await agent.streamUntilIdle(messages, {
+				...options,
+				structuredOutput
+			}) : await agent.streamUntilIdle(messages, options)).fullStream;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error streaming agent response");
+		}
+	}
+});
+const STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/stream/vnext",
+	responseType: "stream",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Stream a response from an agent",
+	description: "[DEPRECATED] This endpoint is deprecated. Please use /stream instead.",
+	tags: ["Agents"],
+	requiresAuth: true,
+	deprecated: true,
+	handler: STREAM_GENERATE_ROUTE.handler
+});
+const OBSERVE_AGENT_STREAM_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/observe",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.observeAgentBodySchema,
+	responseSchema: require_agents.observeAgentResponseSchema,
+	summary: "Observe agent stream",
+	description: "Reconnect to an existing agent stream to receive missed events. Supports position-based resume with offset for efficient reconnection.",
+	tags: ["Agents", "Streaming"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, runId, offset, abortSignal }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId
+			});
+			const durableAgent = (0, _mastra_core_agent.isDurableAgentLike)(agent) ? agent : void 0;
+			const pubsub = durableAgent?.pubsub ?? mastra.pubsub;
+			const topic = (0, _mastra_core_agent_durable.AGENT_STREAM_TOPIC)(runId);
+			const subscribe = (onEvent, onComplete) => {
+				if (typeof durableAgent?.__subscribeToRunStream === "function") return durableAgent.__subscribeToRunStream(runId, {
+					offset,
+					onComplete
+				}, onEvent);
+				return (offset !== void 0 ? pubsub.subscribeFromOffset(topic, offset, onEvent) : pubsub.subscribeWithReplay(topic, onEvent)).then(() => () => pubsub.unsubscribe(topic, onEvent));
+			};
+			let closed = false;
+			let unsubscribe;
+			let idleTimer = null;
+			let onAbort;
+			const IDLE_TIMEOUT_MS = 3e5;
+			function releaseSubscription(unsubscribeFromRun) {
+				Promise.resolve().then(unsubscribeFromRun).catch((error) => console.error(`[ObserveAgentStream] Failed to unsubscribe from ${topic}:`, error));
+			}
+			function stop() {
+				closed = true;
+				if (idleTimer) {
+					clearTimeout(idleTimer);
+					idleTimer = null;
+				}
+				if (onAbort) {
+					abortSignal?.removeEventListener("abort", onAbort);
+					onAbort = void 0;
+				}
+				if (unsubscribe) {
+					const unsubscribeFromRun = unsubscribe;
+					unsubscribe = void 0;
+					releaseSubscription(unsubscribeFromRun);
+				}
+			}
+			function cleanup(controller) {
+				if (closed) return;
+				stop();
+				controller.close();
+			}
+			function resetIdleTimer(controller) {
+				if (closed) return;
+				if (idleTimer) clearTimeout(idleTimer);
+				idleTimer = setTimeout(() => cleanup(controller), IDLE_TIMEOUT_MS);
+			}
+			return new ReadableStream({
+				start(controller) {
+					if (abortSignal) {
+						if (abortSignal.aborted) {
+							cleanup(controller);
+							return;
+						}
+						onAbort = () => cleanup(controller);
+						abortSignal.addEventListener("abort", onAbort, { once: true });
+					}
+					resetIdleTimer(controller);
+					Promise.resolve().then(() => {
+						if (closed) return;
+						return subscribe((event) => {
+							if (closed) return;
+							const type = event.type === "chunk" ? event.data?.type : event.type;
+							controller.enqueue(event);
+							if (type === "finish" || type === "error" || type === "abort") cleanup(controller);
+							else resetIdleTimer(controller);
+						}, () => cleanup(controller));
+					}).then((unsubscribeFromRun) => {
+						if (!unsubscribeFromRun) return;
+						if (closed) releaseSubscription(unsubscribeFromRun);
+						else unsubscribe = unsubscribeFromRun;
+					}, (error) => {
+						if (closed) return;
+						console.error(`[ObserveAgentStream] Failed to subscribe to ${topic}:`, error);
+						stop();
+						controller.error(error);
+					});
+				},
+				cancel() {
+					stop();
+				}
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error observing agent stream");
+		}
+	}
+});
+const APPROVE_TOOL_CALL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/approve-tool-call",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.approveToolCallBodySchema,
+	responseSchema: require_agents.toolCallResponseSchema,
+	summary: "Approve tool call",
+	description: "Approves a pending tool call and continues agent execution",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, abortSignal, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			if (!params.toolCallId) throw new require_http_exception.HTTPException(400, { message: "Tool call id is required" });
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			await validateDurableToolCallAccess({
+				mastra,
+				agent,
+				runId: params.runId,
+				toolCallId: params.toolCallId,
+				requestContext,
+				abortSignal
+			});
+			return (await agent.approveToolCall({
+				...params,
+				requestContext,
+				abortSignal
+			})).fullStream;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error approving tool call");
+		}
+	}
+});
+async function validateSubscriptionToolCallThreadAccess({ agent, requestContext, resourceId, threadId }) {
+	const effectiveResourceId = require_utils$1.getEffectiveResourceId(requestContext, resourceId);
+	const effectiveThreadId = require_utils$1.getEffectiveThreadId(requestContext, threadId);
+	if (!effectiveThreadId) throw new require_http_exception.HTTPException(400, { message: "threadId is required" });
+	if (effectiveResourceId) {
+		const memory = await agent.getMemory({ requestContext });
+		if (memory) {
+			const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+			await require_utils$1.validateThreadOwnership(thread, effectiveResourceId);
+		}
+	}
+	return {
+		effectiveResourceId: effectiveResourceId ?? "",
+		effectiveThreadId
+	};
+}
+const SEND_TOOL_APPROVAL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/send-tool-approval",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.sendToolApprovalBodySchema,
+	responseSchema: require_agents.sendToolApprovalResponseSchema,
+	summary: "Send tool approval",
+	description: "Approves or declines a pending tool call and publishes resumed chunks to thread subscribers",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async ({ mastra, agentId, abortSignal, requestContext: serverRequestContext, ...params }) => {
+		try {
+			const bodyRequestContext = params.requestContext;
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(serverRequestContext, bodyRequestContext),
+				requestContext: serverRequestContext
+			});
+			if (!params.toolCallId) throw new require_http_exception.HTTPException(400, { message: "Tool call id is required" });
+			require_utils$1.mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			const normalizedStreamOptions = normalizePublicExecutionOptions(params.streamOptions, serverRequestContext);
+			const { effectiveResourceId, effectiveThreadId } = await validateSubscriptionToolCallThreadAccess({
+				agent,
+				requestContext: serverRequestContext,
+				resourceId: params.resourceId,
+				threadId: params.threadId
+			});
+			return await agent.sendToolApproval({
+				...params,
+				...normalizedStreamOptions ? { streamOptions: normalizedStreamOptions } : {},
+				resourceId: effectiveResourceId,
+				threadId: effectiveThreadId,
+				requestContext: serverRequestContext,
+				abortSignal
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error sending tool approval");
+		}
+	}
+});
+const LIST_SUSPENDED_RUNS_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/agents/:agentId/suspended-runs",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	queryParamSchema: require_agents.listSuspendedRunsQuerySchema,
+	responseSchema: require_agents.listSuspendedRunsResponseSchema,
+	summary: "List suspended runs",
+	description: "Lists suspended agent runs from storage — runs waiting on a tool-call approval or on a tool that suspended. Works after a server restart and across instances.",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, requestContext, ...query }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(requestContext, query.resourceId);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(requestContext, query.threadId);
+			if (effectiveThreadId) {
+				const memory = await agent.getMemory({ requestContext });
+				if (!memory) throw new require_http_exception.HTTPException(403, { message: "Access denied: agent has no memory configured to validate thread ownership" });
+				const thread = await memory.getThreadById({ threadId: effectiveThreadId });
+				if (!thread) throw new require_http_exception.HTTPException(403, { message: "Access denied: thread not found" });
+				await require_utils$1.enforceThreadAccess({
+					mastra,
+					requestContext,
+					threadId: effectiveThreadId,
+					thread,
+					effectiveResourceId
+				});
+			}
+			return await agent.listSuspendedRuns({
+				threadId: effectiveThreadId,
+				resourceId: effectiveResourceId,
+				fromDate: query.fromDate,
+				toDate: query.toDate,
+				perPage: query.perPage,
+				page: query.page
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error listing suspended runs");
+		}
+	}
+});
+const DECLINE_TOOL_CALL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/decline-tool-call",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.declineToolCallBodySchema,
+	responseSchema: require_agents.toolCallResponseSchema,
+	summary: "Decline tool call",
+	description: "Declines a pending tool call and continues agent execution without executing the tool",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, abortSignal, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			if (!params.toolCallId) throw new require_http_exception.HTTPException(400, { message: "Tool call id is required" });
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			await validateDurableToolCallAccess({
+				mastra,
+				agent,
+				runId: params.runId,
+				toolCallId: params.toolCallId,
+				requestContext,
+				abortSignal
+			});
+			return (await agent.declineToolCall({
+				...params,
+				requestContext,
+				abortSignal
+			})).fullStream;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error declining tool call");
+		}
+	}
+});
+const RESUME_STREAM_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/resume-stream",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.resumeStreamBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Resume agent stream",
+	description: "Resumes a suspended agent stream with custom resume data",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: require_utils$1.MastraFGAPermissions.AGENTS_EXECUTE,
+	handler: async ({ mastra, agentId, abortSignal, requestContext: serverRequestContext, ...params }) => {
+		try {
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			const { resumeData, runId, toolCallId, memory: memoryOption, requestContext: bodyRequestContext, versions, ...rest } = params;
+			const versionOptions = extractVersionOptions(serverRequestContext, bodyRequestContext);
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions
+			});
+			require_utils$1.mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
+			stashVersionOverrides(serverRequestContext, versions);
+			ensureDefaultVersionStatus(serverRequestContext, versionOptions);
+			let authorizedMemoryOption = memoryOption;
+			const clientThreadId = typeof memoryOption?.thread === "string" ? memoryOption.thread : memoryOption?.thread?.id;
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, memoryOption?.resource);
+			if (memoryOption) require_utils$1.requireEffectiveResourceId(effectiveResourceId);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, clientThreadId);
+			if (effectiveThreadId) {
+				const memoryInstance = await agent.getMemory({ requestContext: serverRequestContext });
+				if (memoryInstance) {
+					const thread = await memoryInstance.getThreadById({ threadId: effectiveThreadId });
+					if (thread) await require_utils$1.enforceThreadAccess({
+						mastra,
+						requestContext: serverRequestContext,
+						threadId: effectiveThreadId,
+						thread,
+						effectiveResourceId,
+						permission: require_utils$1.MastraFGAPermissions.MEMORY_WRITE
+					});
+				}
+			}
+			if (memoryOption || effectiveResourceId || effectiveThreadId) authorizedMemoryOption = {
+				...memoryOption,
+				...effectiveResourceId ? { resource: effectiveResourceId } : {},
+				...effectiveThreadId ? { thread: require_utils$1.applyEffectiveThreadId(memoryOption?.thread, effectiveThreadId) } : {}
+			};
+			await validateDurableToolCallAccess({
+				mastra,
+				agent,
+				runId,
+				toolCallId,
+				requestContext: serverRequestContext,
+				threadId: effectiveThreadId,
+				abortSignal
+			});
+			const workflowRun = await (await mastra.getStorage()?.getStore("workflows"))?.getWorkflowRunById({
+				workflowName: "agentic-loop",
+				runId
+			});
+			await require_utils$1.validateRunOwnership(workflowRun, require_utils$1.getEffectiveResourceId(serverRequestContext, void 0), mastra);
+			const { structuredOutput, untilIdle, ...restOptions } = rest;
+			const options = {
+				runId,
+				toolCallId,
+				...restOptions,
+				requestContext: serverRequestContext,
+				memory: authorizedMemoryOption,
+				abortSignal
+			};
+			if (untilIdle) options.untilIdle = untilIdle;
+			return (structuredOutput ? await agent.resumeStream(resumeData, {
+				...options,
+				structuredOutput
+			}) : await agent.resumeStream(resumeData, options)).fullStream;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error resuming agent stream");
+		}
+	}
+});
+const RECOVER_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/recover",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.recoverBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Recover an orphaned durable agent run",
+	description: "Re-drives an orphaned RUNNING durable-agent run after a process restart. Only supported on durable agents (createDurableAgent). Returns a stream that replays past chunks and continues the loop to completion.",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: require_utils$1.MastraFGAPermissions.AGENTS_EXECUTE,
+	handler: async ({ mastra, agentId, abortSignal, requestContext: serverRequestContext, ...params }) => {
+		try {
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			const { runId, versions } = params;
+			const bodyRequestContext = params.requestContext;
+			const versionOptions = extractVersionOptions(serverRequestContext, bodyRequestContext);
+			require_utils$1.mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
+			stashVersionOverrides(serverRequestContext, versions);
+			ensureDefaultVersionStatus(serverRequestContext, versionOptions);
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions
+			});
+			if (!(0, _mastra_core_agent.isDurableAgentLike)(agent)) throw new require_http_exception.HTTPException(400, { message: "Agent does not support recover. Only durable agents (createDurableAgent) can recover runs." });
+			const workflowRun = await (await mastra.getStorage()?.getStore("workflows"))?.getWorkflowRunById({
+				workflowName: getDurableLoopWorkflowName(agent),
+				runId
+			});
+			await require_utils$1.validateRunOwnership(workflowRun, require_utils$1.getEffectiveResourceId(serverRequestContext, void 0), mastra);
+			return (await agent.recover(runId, { abortSignal })).fullStream;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error recovering agent run");
+		}
+	}
+});
+const RESUME_STREAM_UNTIL_IDLE_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/resume-stream-until-idle",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.resumeStreamUntilIdleBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Resume agent stream until idle",
+	description: "Resumes a suspended agent stream until idle with custom resume data, also listens for background task completions and streams them in real-time",
+	tags: ["Agents"],
+	requiresAuth: true,
+	requiresPermission: "agents:execute",
+	handler: async ({ mastra, agentId, abortSignal, requestContext: serverRequestContext, ...params }) => {
+		try {
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			const { resumeData, runId, toolCallId, memory: memoryOption, requestContext: bodyRequestContext, versions, ...rest } = params;
+			const versionOptions = extractVersionOptions(serverRequestContext, bodyRequestContext);
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions
+			});
+			require_utils$1.mergeBodyRequestContext(serverRequestContext, bodyRequestContext);
+			stashVersionOverrides(serverRequestContext, versions);
+			ensureDefaultVersionStatus(serverRequestContext, versionOptions);
+			let authorizedMemoryOption = memoryOption;
+			const clientThreadId = typeof memoryOption?.thread === "string" ? memoryOption.thread : memoryOption?.thread?.id;
+			const effectiveResourceId = require_utils$1.getEffectiveResourceId(serverRequestContext, memoryOption?.resource);
+			if (memoryOption) require_utils$1.requireEffectiveResourceId(effectiveResourceId);
+			const effectiveThreadId = require_utils$1.getEffectiveThreadId(serverRequestContext, clientThreadId);
+			if (effectiveThreadId) {
+				const memoryInstance = await agent.getMemory({ requestContext: serverRequestContext });
+				if (memoryInstance) {
+					const thread = await memoryInstance.getThreadById({ threadId: effectiveThreadId });
+					if (thread) await require_utils$1.enforceThreadAccess({
+						mastra,
+						requestContext: serverRequestContext,
+						threadId: effectiveThreadId,
+						thread,
+						effectiveResourceId,
+						permission: require_utils$1.MastraFGAPermissions.MEMORY_WRITE
+					});
+				}
+			}
+			if (memoryOption || effectiveResourceId || effectiveThreadId) authorizedMemoryOption = {
+				...memoryOption,
+				...effectiveResourceId ? { resource: effectiveResourceId } : {},
+				...effectiveThreadId ? { thread: require_utils$1.applyEffectiveThreadId(memoryOption?.thread, effectiveThreadId) } : {}
+			};
+			await validateDurableToolCallAccess({
+				mastra,
+				agent,
+				runId,
+				toolCallId,
+				requestContext: serverRequestContext,
+				threadId: effectiveThreadId,
+				abortSignal
+			});
+			const workflowRun = await (await mastra.getStorage()?.getStore("workflows"))?.getWorkflowRunById({
+				workflowName: "agentic-loop",
+				runId
+			});
+			await require_utils$1.validateRunOwnership(workflowRun, require_utils$1.getEffectiveResourceId(serverRequestContext, void 0), mastra);
+			const { structuredOutput, ...restOptions } = rest;
+			const options = {
+				runId,
+				toolCallId,
+				...restOptions,
+				context: restOptions.context,
+				requestContext: serverRequestContext,
+				memory: authorizedMemoryOption,
+				abortSignal
+			};
+			return (structuredOutput ? await agent.resumeStreamUntilIdle(resumeData, {
+				...options,
+				structuredOutput
+			}) : await agent.resumeStreamUntilIdle(resumeData, options)).fullStream;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error resuming agent stream");
+		}
+	}
+});
+const APPROVE_TOOL_CALL_GENERATE_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/approve-tool-call-generate",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.approveToolCallBodySchema,
+	responseSchema: require_agents.generateResponseSchema,
+	summary: "Approve tool call (non-streaming)",
+	description: "Approves a pending tool call and returns the complete response",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, abortSignal, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			if (!params.toolCallId) throw new require_http_exception.HTTPException(400, { message: "Tool call id is required" });
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			await validateDurableToolCallAccess({
+				mastra,
+				agent,
+				runId: params.runId,
+				toolCallId: params.toolCallId,
+				requestContext,
+				abortSignal
+			});
+			return await agent.approveToolCallGenerate({
+				...params,
+				requestContext,
+				abortSignal
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error approving tool call");
+		}
+	}
+});
+const DECLINE_TOOL_CALL_GENERATE_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/decline-tool-call-generate",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.declineToolCallBodySchema,
+	responseSchema: require_agents.generateResponseSchema,
+	summary: "Decline tool call (non-streaming)",
+	description: "Declines a pending tool call and returns the complete response",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, abortSignal, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			if (!params.toolCallId) throw new require_http_exception.HTTPException(400, { message: "Tool call id is required" });
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			await validateDurableToolCallAccess({
+				mastra,
+				agent,
+				runId: params.runId,
+				toolCallId: params.toolCallId,
+				requestContext,
+				abortSignal
+			});
+			return await agent.declineToolCallGenerate({
+				...params,
+				requestContext,
+				abortSignal
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error declining tool call");
+		}
+	}
+});
+const STREAM_NETWORK_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/network",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Stream agent network",
+	description: "Executes an agent network with multiple agents and streams the response",
+	tags: ["Agents"],
+	requiresAuth: true,
+	handler: async ({ mastra, messages, agentId, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			require_utils$1.validateBody({ messages });
+			let authorizedMemoryOption = params.memory;
+			if (params.memory) {
+				const effectiveResourceId = require_utils$1.getEffectiveResourceId(requestContext, params.memory.resource);
+				require_utils$1.requireEffectiveResourceId(effectiveResourceId);
+				authorizedMemoryOption = {
+					...params.memory,
+					resource: effectiveResourceId
+				};
+			}
+			return await agent.network(messages, {
+				...params,
+				memory: authorizedMemoryOption
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error streaming agent loop response");
+		}
+	}
+});
+const APPROVE_NETWORK_TOOL_CALL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/approve-network-tool-call",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.approveNetworkToolCallBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Approve network tool call",
+	description: "Approves a pending network tool call and continues network agent execution",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			return await agent.approveNetworkToolCall({ ...params });
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error approving network tool call");
+		}
+	}
+});
+const DECLINE_NETWORK_TOOL_CALL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/decline-network-tool-call",
+	responseType: "stream",
+	streamFormat: "sse",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.declineNetworkToolCallBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Decline network tool call",
+	description: "Declines a pending network tool call and continues network agent execution without executing the tool",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, requestContext, ...params }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId,
+				versionOptions: extractVersionOptions(requestContext)
+			});
+			if (!params.runId) throw new require_http_exception.HTTPException(400, { message: "Run id is required" });
+			require_utils$1.sanitizeBody(params, [
+				"tools",
+				"actor",
+				"scopes"
+			]);
+			require_utils$1.stripClientCredentialHeaders(params);
+			return await agent.declineNetworkToolCall({ ...params });
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error declining network tool call");
+		}
+	}
+});
+const UPDATE_AGENT_MODEL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/model",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.updateAgentModelBodySchema,
+	responseSchema: require_agents.modelManagementResponseSchema,
+	summary: "Update agent model",
+	description: "Updates the AI model used by the agent",
+	tags: ["Agents", "Models"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, modelId, provider }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId
+			});
+			const newModel = `${provider}/${modelId}`;
+			agent.__updateModel({ model: newModel });
+			return { message: "Agent model updated" };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error updating agent model");
+		}
+	}
+});
+const RESET_AGENT_MODEL_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/model/reset",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	responseSchema: require_agents.modelManagementResponseSchema,
+	summary: "Reset agent model",
+	description: "Resets the agent model to its original configuration",
+	tags: ["Agents", "Models"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId }) => {
+		try {
+			(await getAgentFromSystem({
+				mastra,
+				agentId
+			})).__resetToOriginalModel();
+			return { message: "Agent model reset to original" };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error resetting agent model");
+		}
+	}
+});
+const REORDER_AGENT_MODEL_LIST_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/models/reorder",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.reorderAgentModelListBodySchema,
+	responseSchema: require_agents.modelManagementResponseSchema,
+	summary: "Reorder agent model list",
+	description: "Reorders the model list for agents with multiple model configurations",
+	tags: ["Agents", "Models"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, reorderedModelIds }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId
+			});
+			if (typeof agent.model === "function") throw new require_http_exception.HTTPException(409, { message: "Agent model list is dynamic (model is a function) and cannot be edited" });
+			const modelList = await agent.getModelList();
+			if (!modelList || modelList.length === 0) throw new require_http_exception.HTTPException(400, { message: "Agent model list is not found or empty" });
+			if (agent.reorderModels(reorderedModelIds) === false) throw new require_http_exception.HTTPException(400, { message: "Agent model list could not be reordered" });
+			return { message: "Model list reordered" };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error reordering model list");
+		}
+	}
+});
+const UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/models/:modelConfigId",
+	responseType: "json",
+	pathParamSchema: require_agents.modelConfigIdPathParams,
+	bodySchema: require_agents.updateAgentModelInModelListBodySchema,
+	responseSchema: require_agents.modelManagementResponseSchema,
+	summary: "Update model in model list",
+	description: "Updates a specific model configuration in the agent model list",
+	tags: ["Agents", "Models"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, modelConfigId, model: bodyModel, maxRetries, enabled }) => {
+		try {
+			const agent = await getAgentFromSystem({
+				mastra,
+				agentId
+			});
+			if (typeof agent.model === "function") throw new require_http_exception.HTTPException(409, { message: "Agent model list is dynamic (model is a function) and cannot be edited" });
+			const modelList = await agent.getModelList();
+			if (!modelList || modelList.length === 0) throw new require_http_exception.HTTPException(400, { message: "Agent model list is not found or empty" });
+			const modelConfig = modelList.find((config) => config.id === modelConfigId);
+			if (!modelConfig) throw new require_http_exception.HTTPException(404, { message: `Model config with id ${modelConfigId} not found` });
+			const newModel = bodyModel?.modelId && bodyModel?.provider ? `${bodyModel.provider}/${bodyModel.modelId}` : modelConfig.model;
+			const updated = {
+				...modelConfig,
+				model: newModel,
+				...maxRetries !== void 0 ? { maxRetries } : {},
+				...enabled !== void 0 ? { enabled } : {}
+			};
+			if (agent.updateModelInModelList(updated) === false) throw new require_http_exception.HTTPException(404, { message: `Model config with id ${modelConfigId} not found` });
+			return { message: "Model updated in model list" };
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error updating model in model list");
+		}
+	}
+});
+const ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS = `You are an expert system prompt engineer, specialized in analyzing and enhancing instructions to create clear, effective, and comprehensive system prompts. Your goal is to help users transform their basic instructions into well-structured system prompts that will guide AI behavior effectively.
+
+Follow these steps to analyze and enhance the instructions:
+
+1. ANALYSIS PHASE
+- Identify the core purpose and goals
+- Extract key constraints and requirements
+- Recognize domain-specific terminology and concepts
+- Note any implicit assumptions that should be made explicit
+
+2. PROMPT STRUCTURE
+Create a system prompt with these components:
+a) ROLE DEFINITION
+    - Clear statement of the AI's role and purpose
+    - Key responsibilities and scope
+    - Primary stakeholders and users
+b) CORE CAPABILITIES
+    - Main functions and abilities
+    - Specific domain knowledge required
+    - Tools and resources available
+c) BEHAVIORAL GUIDELINES
+    - Communication style and tone
+    - Decision-making framework
+    - Error handling approach
+    - Ethical considerations
+d) CONSTRAINTS & BOUNDARIES
+    - Explicit limitations
+    - Out-of-scope activities
+    - Security and privacy considerations
+e) SUCCESS CRITERIA
+    - Quality standards
+    - Expected outcomes
+    - Performance metrics
+
+3. QUALITY CHECKS
+Ensure the prompt is:
+- Clear and unambiguous
+- Comprehensive yet concise
+- Properly scoped
+- Technically accurate
+- Ethically sound
+
+4. OUTPUT FORMAT
+Return your response as JSON with exactly these two fields:
+- explanation: A brief explanation of the changes you made and why
+- new_prompt: The complete enhanced system prompt as a single string
+
+Remember: A good system prompt should be specific enough to guide behavior but flexible enough to handle edge cases. Focus on creating prompts that are clear, actionable, and aligned with the intended use case.`;
+async function findConnectedModel(agent) {
+	const modelList = await agent.getModelList();
+	if (modelList && modelList.length > 0) {
+		for (const modelConfig of modelList) if (modelConfig.enabled !== false) {
+			const model = modelConfig.model;
+			if (isProviderConnected(model.provider)) return model;
+		}
+		return null;
+	}
+	const defaultModel = await agent.getModel();
+	if (isProviderConnected(defaultModel.provider)) return defaultModel;
+	return null;
+}
+const ENHANCE_INSTRUCTIONS_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/instructions/enhance",
+	responseType: "json",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.enhanceInstructionsBodySchema,
+	responseSchema: require_agents.enhanceInstructionsResponseSchema,
+	summary: "Enhance agent instructions",
+	description: "Uses AI to enhance or modify agent instructions based on user feedback",
+	tags: ["Agents"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, instructions, comment }) => {
+		try {
+			const model = await findConnectedModel(await getAgentFromSystem({
+				mastra,
+				agentId
+			}));
+			if (!model) throw new require_http_exception.HTTPException(400, { message: "No model with a configured API key found. Please set the required environment variable for your model provider." });
+			return await (await new _mastra_core_agent.Agent({
+				id: "system-prompt-enhancer",
+				name: "system-prompt-enhancer",
+				instructions: ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS,
+				model
+			}).generate(`We need to improve the system prompt.
+Current: ${instructions}
+${comment ? `User feedback: ${comment}` : ""}`, { structuredOutput: { schema: require_agents.enhanceInstructionsResponseSchema } })).object;
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error enhancing instructions");
+		}
+	}
+});
+const STREAM_VNEXT_DEPRECATED_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/streamVNext",
+	responseType: "stream",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Stream a response from an agent",
+	description: "[DEPRECATED] This endpoint is deprecated. Please use /stream instead.",
+	tags: ["Agents"],
+	requiresAuth: true,
+	deprecated: true,
+	handler: async () => {
+		throw new require_http_exception.HTTPException(410, { message: "This endpoint is deprecated. Please use /stream instead." });
+	}
+});
+const STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/stream/vnext/ui",
+	responseType: "stream",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Stream UI messages from an agent",
+	description: "[DEPRECATED] This endpoint is deprecated. Please use the @mastra/ai-sdk package for uiMessage transformations",
+	tags: ["Agents"],
+	requiresAuth: true,
+	deprecated: true,
+	handler: async () => {
+		try {
+			throw new _mastra_core_error.MastraError({
+				category: _mastra_core_error.ErrorCategory.USER,
+				domain: _mastra_core_error.ErrorDomain.MASTRA_SERVER,
+				id: "DEPRECATED_ENDPOINT",
+				text: "This endpoint is deprecated. Please use the @mastra/ai-sdk package to for uiMessage transformations"
+			});
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "error streaming agent response");
+		}
+	}
+});
+const STREAM_UI_MESSAGE_DEPRECATED_ROUTE = require_route_builder.createRoute({
+	method: "POST",
+	path: "/agents/:agentId/stream/ui",
+	responseType: "stream",
+	pathParamSchema: require_agents.agentIdPathParams,
+	bodySchema: require_agents.agentExecutionBodySchema,
+	responseSchema: require_agents.streamResponseSchema,
+	summary: "Stream UI messages from an agent",
+	description: "[DEPRECATED] This endpoint is deprecated. Please use the @mastra/ai-sdk package for uiMessage transformations",
+	tags: ["Agents"],
+	requiresAuth: true,
+	deprecated: true,
+	handler: STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE.handler
+});
+const GET_AGENT_SKILL_ROUTE = require_route_builder.createRoute({
+	method: "GET",
+	path: "/agents/:agentId/skills/:skillName",
+	responseType: "json",
+	pathParamSchema: require_agents.agentSkillPathParams,
+	queryParamSchema: require_workspace.skillDisambiguationQuerySchema,
+	responseSchema: require_workspace.getAgentSkillResponseSchema,
+	summary: "Get agent skill",
+	description: "Returns details for a specific skill available to the agent (inline or workspace)",
+	tags: ["Agents", "Skills"],
+	handler: async ({ mastra, agentId, skillName, path, requestContext }) => {
+		try {
+			const agent = agentId ? mastra.getAgentById(agentId) : null;
+			if (!agent) throw new require_http_exception.HTTPException(404, { message: "Agent not found" });
+			const identifier = path ?? skillName;
+			const skill = await agent.getSkill(identifier, { requestContext });
+			if (!skill) throw new require_http_exception.HTTPException(404, { message: `Skill "${identifier}" not found` });
+			return {
+				name: skill.name,
+				description: skill.description,
+				license: skill.license,
+				compatibility: skill.compatibility,
+				metadata: skill.metadata,
+				path: skill.path,
+				instructions: skill.instructions,
+				source: skill.source,
+				references: skill.references,
+				scripts: skill.scripts,
+				assets: skill.assets
+			};
+		} catch (error) {
+			return require_server_handlers_error.handleError(error, "Error getting agent skill");
+		}
+	}
+});
+//#endregion
+Object.defineProperty(exports, "ABORT_AGENT_THREAD_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return ABORT_AGENT_THREAD_ROUTE;
+	}
+});
+Object.defineProperty(exports, "APPROVE_NETWORK_TOOL_CALL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return APPROVE_NETWORK_TOOL_CALL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "APPROVE_TOOL_CALL_GENERATE_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return APPROVE_TOOL_CALL_GENERATE_ROUTE;
+	}
+});
+Object.defineProperty(exports, "APPROVE_TOOL_CALL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return APPROVE_TOOL_CALL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "CANCEL_AGENT_PENDING_SIGNALS_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return CANCEL_AGENT_PENDING_SIGNALS_ROUTE;
+	}
+});
+Object.defineProperty(exports, "CLONE_AGENT_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return CLONE_AGENT_ROUTE;
+	}
+});
+Object.defineProperty(exports, "DECLINE_NETWORK_TOOL_CALL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return DECLINE_NETWORK_TOOL_CALL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "DECLINE_TOOL_CALL_GENERATE_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return DECLINE_TOOL_CALL_GENERATE_ROUTE;
+	}
+});
+Object.defineProperty(exports, "DECLINE_TOOL_CALL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return DECLINE_TOOL_CALL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "ENHANCE_INSTRUCTIONS_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return ENHANCE_INSTRUCTIONS_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GENERATE_AGENT_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GENERATE_AGENT_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GENERATE_AGENT_VNEXT_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GENERATE_AGENT_VNEXT_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GENERATE_LEGACY_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GENERATE_LEGACY_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_AGENT_BY_ID_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_AGENT_BY_ID_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_AGENT_SKILL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_AGENT_SKILL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "GET_PROVIDERS_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return GET_PROVIDERS_ROUTE;
+	}
+});
+Object.defineProperty(exports, "LIST_AGENTS_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return LIST_AGENTS_ROUTE;
+	}
+});
+Object.defineProperty(exports, "LIST_SUSPENDED_RUNS_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return LIST_SUSPENDED_RUNS_ROUTE;
+	}
+});
+Object.defineProperty(exports, "OBSERVE_AGENT_STREAM_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return OBSERVE_AGENT_STREAM_ROUTE;
+	}
+});
+Object.defineProperty(exports, "QUEUE_AGENT_MESSAGE_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return QUEUE_AGENT_MESSAGE_ROUTE;
+	}
+});
+Object.defineProperty(exports, "QUEUE_AGENT_SIGNAL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return QUEUE_AGENT_SIGNAL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "RECOVER_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return RECOVER_ROUTE;
+	}
+});
+Object.defineProperty(exports, "REORDER_AGENT_MODEL_LIST_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return REORDER_AGENT_MODEL_LIST_ROUTE;
+	}
+});
+Object.defineProperty(exports, "RESET_AGENT_MODEL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return RESET_AGENT_MODEL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "RESUME_STREAM_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return RESUME_STREAM_ROUTE;
+	}
+});
+Object.defineProperty(exports, "RESUME_STREAM_UNTIL_IDLE_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return RESUME_STREAM_UNTIL_IDLE_ROUTE;
+	}
+});
+Object.defineProperty(exports, "SEND_AGENT_MESSAGE_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return SEND_AGENT_MESSAGE_ROUTE;
+	}
+});
+Object.defineProperty(exports, "SEND_AGENT_SIGNAL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return SEND_AGENT_SIGNAL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "SEND_TOOL_APPROVAL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return SEND_TOOL_APPROVAL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "STREAM_GENERATE_LEGACY_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return STREAM_GENERATE_LEGACY_ROUTE;
+	}
+});
+Object.defineProperty(exports, "STREAM_GENERATE_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return STREAM_GENERATE_ROUTE;
+	}
+});
+Object.defineProperty(exports, "STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE;
+	}
+});
+Object.defineProperty(exports, "STREAM_NETWORK_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return STREAM_NETWORK_ROUTE;
+	}
+});
+Object.defineProperty(exports, "STREAM_UI_MESSAGE_DEPRECATED_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return STREAM_UI_MESSAGE_DEPRECATED_ROUTE;
+	}
+});
+Object.defineProperty(exports, "STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE;
+	}
+});
+Object.defineProperty(exports, "STREAM_UNTIL_IDLE_GENERATE_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return STREAM_UNTIL_IDLE_GENERATE_ROUTE;
+	}
+});
+Object.defineProperty(exports, "STREAM_VNEXT_DEPRECATED_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return STREAM_VNEXT_DEPRECATED_ROUTE;
+	}
+});
+Object.defineProperty(exports, "SUBSCRIBE_AGENT_THREAD_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return SUBSCRIBE_AGENT_THREAD_ROUTE;
+	}
+});
+Object.defineProperty(exports, "UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE;
+	}
+});
+Object.defineProperty(exports, "UPDATE_AGENT_MODEL_ROUTE", {
+	enumerable: true,
+	get: function() {
+		return UPDATE_AGENT_MODEL_ROUTE;
+	}
+});
+Object.defineProperty(exports, "agents_exports", {
+	enumerable: true,
+	get: function() {
+		return agents_exports;
+	}
+});
+Object.defineProperty(exports, "buildProvidersList", {
+	enumerable: true,
+	get: function() {
+		return buildProvidersList;
+	}
+});
+Object.defineProperty(exports, "extractVersionOptions", {
+	enumerable: true,
+	get: function() {
+		return extractVersionOptions;
+	}
+});
+Object.defineProperty(exports, "getAgentFromSystem", {
+	enumerable: true,
+	get: function() {
+		return getAgentFromSystem;
+	}
+});
+Object.defineProperty(exports, "getBrowserToolsFromAgent", {
+	enumerable: true,
+	get: function() {
+		return getBrowserToolsFromAgent;
+	}
+});
+Object.defineProperty(exports, "getSerializedAgentTools", {
+	enumerable: true,
+	get: function() {
+		return getSerializedAgentTools;
+	}
+});
+Object.defineProperty(exports, "getSerializedProcessors", {
+	enumerable: true,
+	get: function() {
+		return getSerializedProcessors;
+	}
+});
+Object.defineProperty(exports, "getSerializedSkillsFromAgent", {
+	enumerable: true,
+	get: function() {
+		return getSerializedSkillsFromAgent;
+	}
+});
+Object.defineProperty(exports, "getWorkspaceToolsFromAgent", {
+	enumerable: true,
+	get: function() {
+		return getWorkspaceToolsFromAgent;
+	}
+});
+Object.defineProperty(exports, "isProviderConnected", {
+	enumerable: true,
+	get: function() {
+		return isProviderConnected;
+	}
+});
+
+//# sourceMappingURL=agents-BOWEUKyV.cjs.map