@mastra/mcp 1.17.4-alpha.0 → 1.18.0

package/dist/index.cjs

@@ -9830,7 +9830,7 @@ var AiSdkSchemaWrapper = class {
 * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });
 * ```
 */
-function toStandardSchema$4(schema) {
+function toStandardSchema$5(schema) {
 	return new AiSdkSchemaWrapper(schema);
 }
 //#endregion
@@ -16779,7 +16779,7 @@ var JsonSchemaWrapper = class {
 * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });
 * ```
 */
-function toStandardSchema$3(schema, options) {
+function toStandardSchema$4(schema, options) {
 	return new JsonSchemaWrapper(schema, options);
 }
 //#endregion
@@ -16855,7 +16855,7 @@ function convertToJsonSchema$1(zodSchema, options) {
 * const jsonSchema = standardSchema['~standard'].jsonSchema.output({ target: 'draft-07' });
 * ```
 */
-function toStandardSchema$2(zodSchema) {
+function toStandardSchema$3(zodSchema) {
 	const wrapper = Object.create(zodSchema);
 	const existingStandard = zodSchema["~standard"];
 	const jsonSchemaConverter = {
@@ -17007,18 +17007,18 @@ function isZodV3(schema) {
 	}
 	return schema instanceof v3_default.ZodType;
 }
-function toStandardSchema(schema) {
+function toStandardSchema$2(schema) {
 	if (isZodV4(schema)) patchRecordSchemas(schema);
 	if (isStandardSchemaWithJSON$2(schema)) return schema;
 	if (isZodV4(schema)) return toStandardSchema$1(schema, {
 		unrepresentable: JSON_SCHEMA_LIBRARY_OPTIONS.unrepresentable,
 		override: JSON_SCHEMA_LIBRARY_OPTIONS.override
 	});
-	if (isZodV3(schema)) return toStandardSchema$2(schema);
-	if (isVercelSchema(schema)) return toStandardSchema$4(schema);
+	if (isZodV3(schema)) return toStandardSchema$3(schema);
+	if (isVercelSchema(schema)) return toStandardSchema$5(schema);
 	if (schema === null || typeof schema !== "object" && typeof schema !== "function") throw new Error(`Unsupported schema type: ${typeof schema}`);
 	if (typeof schema === "function") throw new Error(`Unsupported schema type: function (schema libraries should implement StandardSchemaWithJSON)`);
-	return toStandardSchema$3(schema);
+	return toStandardSchema$4(schema);
 }
 /**
 * Type guard to check if a value implements the StandardSchemaV1 interface.
@@ -22416,7 +22416,7 @@ var InternalMastraMCPClient = class extends _mastra_core_base.MastraBase {
 	convertOutputSchema(outputSchema) {
 		if (!outputSchema) return outputSchema;
 		return { "~standard": {
-			...toStandardSchema("jsonSchema" in outputSchema ? outputSchema.jsonSchema : outputSchema)["~standard"],
+			...toStandardSchema$2("jsonSchema" in outputSchema ? outputSchema.jsonSchema : outputSchema)["~standard"],
 			validate: (value) => ({ value })
 		} };
 	}
@@ -22537,7 +22537,7 @@ var InternalMastraMCPClient = class extends _mastra_core_base.MastraBase {
 				...annotations ? { annotations } : {}
 			} } : {};
 			const rawOutputSchema = tool.outputSchema ? "jsonSchema" in tool.outputSchema ? tool.outputSchema.jsonSchema : tool.outputSchema : void 0;
-			const outputValidator = rawOutputSchema ? toStandardSchema(rawOutputSchema) : void 0;
+			const outputValidator = rawOutputSchema ? toStandardSchema$2(rawOutputSchema) : void 0;
 			const mastraTool = (0, _mastra_core_tools.createTool)({
 				id: `${this.name}_${tool.name}`,
 				description: tool.description || "",
@@ -27399,6 +27399,709 @@ var MCPServer = class extends _mastra_core_mcp.MCPServerBase {
 	}
 };
 //#endregion
+//#region src/server/mastra-api-operations.generated.ts
+const MASTRA_API_OPERATIONS = [
+	{
+		name: "agent_list",
+		description: "List available agents",
+		method: "GET",
+		path: "/agents",
+		destructive: false
+	},
+	{
+		name: "agent_get",
+		description: "Get agent details",
+		method: "GET",
+		path: "/agents/:agentId",
+		destructive: false
+	},
+	{
+		name: "agent_run",
+		description: "Run an agent with JSON input",
+		method: "POST",
+		path: "/agents/:agentId/generate",
+		destructive: true
+	},
+	{
+		name: "workflow_list",
+		description: "List available workflows",
+		method: "GET",
+		path: "/workflows",
+		destructive: false
+	},
+	{
+		name: "workflow_get",
+		description: "Get workflow details",
+		method: "GET",
+		path: "/workflows/:workflowId",
+		destructive: false
+	},
+	{
+		name: "workflow_run_start",
+		description: "Start a workflow run",
+		method: "POST",
+		path: "/workflows/:workflowId/start-async",
+		destructive: true
+	},
+	{
+		name: "workflow_run_list",
+		description: "List workflow runs",
+		method: "GET",
+		path: "/workflows/:workflowId/runs",
+		destructive: false
+	},
+	{
+		name: "workflow_run_get",
+		description: "Get workflow run details",
+		method: "GET",
+		path: "/workflows/:workflowId/runs/:runId",
+		destructive: false
+	},
+	{
+		name: "workflow_run_resume",
+		description: "Resume a suspended workflow run",
+		method: "POST",
+		path: "/workflows/:workflowId/resume-async",
+		destructive: true
+	},
+	{
+		name: "workflow_run_cancel",
+		description: "Cancel a workflow run",
+		method: "POST",
+		path: "/workflows/:workflowId/runs/:runId/cancel",
+		destructive: true
+	},
+	{
+		name: "tool_list",
+		description: "List available tools",
+		method: "GET",
+		path: "/tools",
+		destructive: false
+	},
+	{
+		name: "tool_get",
+		description: "Get tool details and input schema",
+		method: "GET",
+		path: "/tools/:toolId",
+		destructive: false
+	},
+	{
+		name: "tool_execute",
+		description: "Execute a tool with JSON input",
+		method: "POST",
+		path: "/tools/:toolId/execute",
+		destructive: true
+	},
+	{
+		name: "mcp_list",
+		description: "List MCP servers",
+		method: "GET",
+		path: "/mcp/v0/servers",
+		destructive: false
+	},
+	{
+		name: "mcp_get",
+		description: "Get MCP server details",
+		method: "GET",
+		path: "/mcp/v0/servers/:id",
+		destructive: false
+	},
+	{
+		name: "mcp_tool_list",
+		description: "List tools for an MCP server",
+		method: "GET",
+		path: "/mcp/:serverId/tools",
+		destructive: false
+	},
+	{
+		name: "mcp_tool_get",
+		description: "Get MCP tool details",
+		method: "GET",
+		path: "/mcp/:serverId/tools/:toolId",
+		destructive: false
+	},
+	{
+		name: "mcp_tool_execute",
+		description: "Execute an MCP tool with JSON input",
+		method: "POST",
+		path: "/mcp/:serverId/tools/:toolId/execute",
+		destructive: true
+	},
+	{
+		name: "thread_list",
+		description: "List memory threads",
+		method: "GET",
+		path: "/memory/threads",
+		destructive: false
+	},
+	{
+		name: "thread_get",
+		description: "Get thread details",
+		method: "GET",
+		path: "/memory/threads/:threadId",
+		destructive: false
+	},
+	{
+		name: "thread_create",
+		description: "Create a memory thread",
+		method: "POST",
+		path: "/memory/threads",
+		destructive: true
+	},
+	{
+		name: "thread_update",
+		description: "Update a memory thread",
+		method: "PATCH",
+		path: "/memory/threads/:threadId",
+		destructive: true
+	},
+	{
+		name: "thread_delete",
+		description: "Delete a memory thread",
+		method: "DELETE",
+		path: "/memory/threads/:threadId",
+		destructive: true
+	},
+	{
+		name: "thread_messages",
+		description: "List messages in a memory thread",
+		method: "GET",
+		path: "/memory/threads/:threadId/messages",
+		destructive: false
+	},
+	{
+		name: "memory_search",
+		description: "Search long-term memory",
+		method: "GET",
+		path: "/memory/search",
+		destructive: false
+	},
+	{
+		name: "memory_current_get",
+		description: "Get current working memory",
+		method: "GET",
+		path: "/memory/threads/:threadId/working-memory",
+		destructive: false
+	},
+	{
+		name: "memory_current_update",
+		description: "Update current working memory",
+		method: "POST",
+		path: "/memory/threads/:threadId/working-memory",
+		destructive: true
+	},
+	{
+		name: "memory_status",
+		description: "Get memory system status",
+		method: "GET",
+		path: "/memory/status",
+		destructive: false
+	},
+	{
+		name: "trace_list",
+		description: "List observability traces",
+		method: "GET",
+		path: "/observability/traces/light",
+		verbosePath: "/observability/traces",
+		destructive: false
+	},
+	{
+		name: "trace_get",
+		description: "Get trace details",
+		method: "GET",
+		path: "/observability/traces/:traceId/light",
+		verbosePath: "/observability/traces/:traceId",
+		destructive: false
+	},
+	{
+		name: "trace_span",
+		description: "Get a trace span",
+		method: "GET",
+		path: "/observability/traces/:traceId/spans/:spanId",
+		destructive: false
+	},
+	{
+		name: "trace_query",
+		description: "Query observability traces with advanced predicates",
+		method: "POST",
+		path: "/observability/traces/query",
+		destructive: true
+	},
+	{
+		name: "log_list",
+		description: "List runtime logs",
+		method: "GET",
+		path: "/observability/logs",
+		destructive: false
+	},
+	{
+		name: "metric_aggregate",
+		description: "Get an aggregate metric value",
+		method: "POST",
+		path: "/observability/metrics/aggregate",
+		destructive: true
+	},
+	{
+		name: "metric_breakdown",
+		description: "Get metric values grouped by a label or field",
+		method: "POST",
+		path: "/observability/metrics/breakdown",
+		destructive: true
+	},
+	{
+		name: "metric_timeseries",
+		description: "Get metric values over time",
+		method: "POST",
+		path: "/observability/metrics/timeseries",
+		destructive: true
+	},
+	{
+		name: "metric_percentiles",
+		description: "Get metric percentile values over time",
+		method: "POST",
+		path: "/observability/metrics/percentiles",
+		destructive: true
+	},
+	{
+		name: "metric_names",
+		description: "List discovered metric names",
+		method: "GET",
+		path: "/observability/discovery/metric-names",
+		destructive: false
+	},
+	{
+		name: "metric_label_keys",
+		description: "List label keys for a metric",
+		method: "GET",
+		path: "/observability/discovery/metric-label-keys",
+		destructive: false
+	},
+	{
+		name: "metric_label_values",
+		description: "List label values for a metric label key",
+		method: "GET",
+		path: "/observability/discovery/metric-label-values",
+		destructive: false
+	},
+	{
+		name: "score_create",
+		description: "Create a score",
+		method: "POST",
+		path: "/observability/scores",
+		destructive: true
+	},
+	{
+		name: "score_list",
+		description: "List scores",
+		method: "GET",
+		path: "/observability/scores",
+		destructive: false
+	},
+	{
+		name: "score_get",
+		description: "Get score details",
+		method: "GET",
+		path: "/observability/scores/:scoreId",
+		destructive: false
+	},
+	{
+		name: "score_delete",
+		description: "Delete scores by ID",
+		method: "DELETE",
+		path: "/observability/scores",
+		destructive: true
+	},
+	{
+		name: "feedback_delete",
+		description: "Delete feedback by ID",
+		method: "DELETE",
+		path: "/observability/feedback",
+		destructive: true
+	},
+	{
+		name: "dataset_list",
+		description: "List datasets",
+		method: "GET",
+		path: "/datasets",
+		destructive: false
+	},
+	{
+		name: "dataset_get",
+		description: "Get dataset details",
+		method: "GET",
+		path: "/datasets/:datasetId",
+		destructive: false
+	},
+	{
+		name: "dataset_create",
+		description: "Create a dataset",
+		method: "POST",
+		path: "/datasets",
+		destructive: true
+	},
+	{
+		name: "dataset_items",
+		description: "List dataset items",
+		method: "GET",
+		path: "/datasets/:datasetId/items",
+		destructive: false
+	},
+	{
+		name: "experiment_list",
+		description: "List dataset experiments",
+		method: "GET",
+		path: "/datasets/:datasetId/experiments",
+		destructive: false
+	},
+	{
+		name: "experiment_get",
+		description: "Get experiment details",
+		method: "GET",
+		path: "/datasets/:datasetId/experiments/:experimentId",
+		destructive: false
+	},
+	{
+		name: "experiment_run",
+		description: "Run a dataset experiment",
+		method: "POST",
+		path: "/datasets/:datasetId/experiments",
+		destructive: true
+	},
+	{
+		name: "experiment_results",
+		description: "List experiment results",
+		method: "GET",
+		path: "/datasets/:datasetId/experiments/:experimentId/results",
+		destructive: false
+	},
+	{
+		name: "learning_entities",
+		description: "List entities with Trace Intelligence output",
+		method: "GET",
+		path: "/learning/entities",
+		destructive: false
+	},
+	{
+		name: "learning_snapshots",
+		description: "List analysis snapshots for an entity and ordered trace signals",
+		method: "GET",
+		path: "/learning/entities/:entityId/theme-snapshots",
+		destructive: false
+	},
+	{
+		name: "learning_flow",
+		description: "Get the cross-signal theme flow for one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/theme-flow",
+		destructive: false
+	},
+	{
+		name: "learning_paths",
+		description: "Get per-trace theme assignments for one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/theme-paths",
+		destructive: false
+	},
+	{
+		name: "learning_theme_list",
+		description: "List themes for one trace signal in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/themes",
+		destructive: false
+	},
+	{
+		name: "learning_theme_get",
+		description: "Get one theme in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/themes/:themeId",
+		destructive: false
+	},
+	{
+		name: "learning_theme_examples",
+		description: "List trace examples for one theme in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/themes/:themeId/examples",
+		destructive: false
+	},
+	{
+		name: "learning_theme_history",
+		description: "Get lifecycle history for one durable theme",
+		method: "GET",
+		path: "/learning/entities/:entityId/themes/:themeId/history",
+		destructive: false
+	},
+	{
+		name: "learning_noise_get",
+		description: "Get the noise bucket for one trace signal in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/noise",
+		destructive: false
+	},
+	{
+		name: "learning_noise_examples",
+		description: "List trace examples for the noise bucket in one snapshot",
+		method: "GET",
+		path: "/learning/entities/:entityId/noise/examples",
+		destructive: false
+	}
+];
+//#endregion
+//#region src/server/mastra-api-mcp-server.ts
+var MastraApiRequester = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async getSchemaManifest() {
+		const value = await this.request({
+			method: "GET",
+			path: "/system/api-schema",
+			pathParamSchema: void 0,
+			queryParamSchema: void 0,
+			bodySchema: void 0
+		}, {});
+		if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.routes)) throw new Error("The Mastra server returned an invalid API schema manifest. Confirm that the target server supports GET /api/system/api-schema.");
+		const routes = value.routes.filter(isApiSchemaRoute);
+		if (routes.length !== value.routes.length) throw new Error("The Mastra server API schema manifest contains an invalid route definition.");
+		return routes;
+	}
+	async request(route, input, authInfo, requestSignal) {
+		const pathParams = schemaPropertyNames(route.pathParamSchema);
+		const queryParams = new Set(schemaPropertyNames(route.queryParamSchema));
+		const bodyParams = new Set(schemaPropertyNames(route.bodySchema));
+		const remainingInput = { ...input };
+		let path = route.path;
+		for (const name of pathParams) {
+			path = path.replace(`:${name}`, encodeURIComponent(remainingInput[name]));
+			delete remainingInput[name];
+		}
+		const url = new URL(joinUrl(this.options.baseUrl, this.options.apiPrefix, path));
+		const body = {};
+		for (const [name, value] of Object.entries(remainingInput)) {
+			if (value === void 0) continue;
+			if (route.method === "GET" || queryParams.has(name) && !bodyParams.has(name)) {
+				if (value === null) continue;
+				url.searchParams.set(name, typeof value === "object" ? JSON.stringify(value) : String(value));
+			} else body[name] = value;
+		}
+		const headers = new Headers(this.options.headers);
+		headers.set("accept", "application/json");
+		const callerToken = getAuthToken(authInfo);
+		if (callerToken) headers.set("authorization", `Bearer ${callerToken}`);
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("request timed out")), this.options.timeoutMs);
+		const abortRequest = () => controller.abort(requestSignal?.reason);
+		if (requestSignal?.aborted) abortRequest();
+		else requestSignal?.addEventListener("abort", abortRequest, { once: true });
+		try {
+			const hasBody = route.method !== "GET" && route.bodySchema !== void 0;
+			if (hasBody) headers.set("content-type", "application/json");
+			const response = await this.options.fetch(url, {
+				method: route.method,
+				headers,
+				signal: controller.signal,
+				...hasBody ? { body: JSON.stringify(body) } : {}
+			});
+			const responseBody = await readResponseBody(response);
+			if (!response.ok) {
+				const detail = getErrorDetail(responseBody);
+				throw new Error(`Mastra API request ${route.method} ${route.path} failed with status ${response.status}${detail ? `: ${detail}` : "."}`);
+			}
+			return responseBody;
+		} catch (error) {
+			if (controller.signal.aborted) {
+				if (requestSignal?.aborted) throw new Error(`Mastra API request ${route.method} ${route.path} was canceled.`, { cause: error });
+				throw new Error(`Mastra API request ${route.method} ${route.path} timed out after ${this.options.timeoutMs}ms.`, { cause: error });
+			}
+			if (error instanceof Error && error.message.startsWith("Mastra API request ")) throw error;
+			throw new Error(`Could not reach the Mastra server at ${this.options.baseUrl}. Check the server URL and network access.`, { cause: error });
+		} finally {
+			clearTimeout(timeout);
+			requestSignal?.removeEventListener("abort", abortRequest);
+		}
+	}
+};
+/**
+* An MCP server that exposes the Mastra API CLI operations from a remote Mastra server.
+*
+* The factory reads the target server's schema manifest, registers the CLI operations
+* supported by that server, and uses the route schemas as MCP tool input schemas.
+*/
+var MastraApiMCPServer = class MastraApiMCPServer extends MCPServer {
+	constructor(options, tools) {
+		super({
+			id: options.id ?? "mastra-api",
+			name: options.name ?? "Mastra Server",
+			version: options.version ?? "1.0.0",
+			description: "Inspect and operate a Mastra server.",
+			instructions: "Inspect resources before using them. Pass tool input inside the data field for tool_execute and mcp_tool_execute. Ask for confirmation before calling a tool marked as destructive.",
+			protocolVersion: "2026-07-28",
+			tools
+		});
+	}
+	/** Creates a stateless MCP server for the target Mastra server. */
+	static async create(options) {
+		const requester = new MastraApiRequester(normalizeOptions(options));
+		const tools = createApiTools(await requester.getSchemaManifest(), requester);
+		if (Object.keys(tools).length === 0) throw new Error("The target Mastra server does not support any of the MCP server operations.");
+		return new MastraApiMCPServer(options, tools);
+	}
+};
+function createApiTools(routes, requester) {
+	const tools = {};
+	for (const operation of MASTRA_API_OPERATIONS) {
+		const primaryRoute = routes.find((candidate) => candidate.method === operation.method && candidate.path === operation.path);
+		const verboseRoute = "verbosePath" in operation ? routes.find((candidate) => candidate.method === operation.method && candidate.path === operation.verbosePath) : void 0;
+		const route = primaryRoute ?? verboseRoute;
+		if (!route) continue;
+		const readOnly = operation.method === "GET";
+		tools[operation.name] = (0, _mastra_core_tools.createTool)({
+			id: operation.name,
+			description: operation.description,
+			inputSchema: (0, _mastra_core_schema.toStandardSchema)(mergeInputSchemas(route, primaryRoute !== void 0 && verboseRoute !== void 0)),
+			mcp: { annotations: {
+				title: operation.description,
+				readOnlyHint: readOnly,
+				destructiveHint: operation.destructive,
+				idempotentHint: readOnly || operation.method === "DELETE",
+				openWorldHint: true
+			} },
+			execute: async (input, context) => {
+				let requestInput = input;
+				let selectedRoute = route;
+				if (primaryRoute && verboseRoute) {
+					const { verbose, ...inputWithoutVerbose } = input;
+					requestInput = inputWithoutVerbose;
+					if (verbose === true) selectedRoute = verboseRoute;
+				}
+				return requester.request(selectedRoute, requestInput, context.mcp?.extra.authInfo ?? getRequestAuthInfo(context.requestContext), context.abortSignal ?? context.mcp?.extra.signal);
+			}
+		});
+	}
+	return tools;
+}
+function normalizeOptions(options) {
+	let url;
+	try {
+		url = new URL(options.url);
+	} catch (error) {
+		throw new Error("The Mastra server URL must be a valid absolute URL.", { cause: error });
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("The Mastra server URL must use HTTP or HTTPS.");
+	if (url.username || url.password) throw new Error("The Mastra server URL cannot contain credentials. Use the headers option for authentication.");
+	if (url.search || url.hash) throw new Error("The Mastra server URL cannot contain a query string or fragment.");
+	const apiPrefix = normalizeApiPrefix(options.apiPrefix ?? "/api");
+	const timeoutMs = options.timeoutMs ?? 12e4;
+	if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) throw new Error("The request timeout must be a positive integer in milliseconds.");
+	return {
+		baseUrl: url.toString().replace(/\/$/, ""),
+		apiPrefix,
+		headers: { ...options.headers },
+		timeoutMs,
+		fetch: options.fetch ?? globalThis.fetch
+	};
+}
+function normalizeApiPrefix(value) {
+	if (value.includes("..") || value.includes("?") || value.includes("#")) throw new Error("The Mastra API prefix cannot contain \"..\", a query string, or a fragment.");
+	let start = 0;
+	let end = value.length;
+	while (start < end && value[start] === "/") start++;
+	while (end > start && value[end - 1] === "/") end--;
+	return start === end ? "" : `/${value.slice(start, end)}`;
+}
+function joinUrl(baseUrl, apiPrefix, path) {
+	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+	if (!apiPrefix || baseUrl.endsWith(apiPrefix)) return `${baseUrl}${normalizedPath}`;
+	return `${baseUrl}${apiPrefix}${normalizedPath}`;
+}
+function mergeInputSchemas(route, supportsVerbose = false) {
+	const definitions = {};
+	const schemas = [
+		"pathParamSchema",
+		"queryParamSchema",
+		"bodySchema"
+	].flatMap((key) => {
+		const source = route[key];
+		if (!isRecord(source)) return [];
+		const schema = relocateSchemaReferences(source, `#/definitions/${key}`);
+		definitions[key] = schema;
+		return [schema];
+	});
+	const properties = {};
+	const pathParams = new Set(schemaPropertyNames(route.pathParamSchema));
+	const required = new Set(pathParams);
+	let allowsAdditionalProperties = false;
+	for (const schema of schemas) {
+		if (isRecord(schema.properties)) for (const [name, property] of Object.entries(schema.properties)) properties[name] = pathParams.has(name) && Object.hasOwn(properties, name) ? { allOf: [properties[name], property] } : property;
+		if (Array.isArray(schema.required)) {
+			for (const name of schema.required) if (typeof name === "string") required.add(name);
+		}
+		if (schema.additionalProperties === true || isRecord(schema.additionalProperties)) allowsAdditionalProperties = true;
+	}
+	if (supportsVerbose) properties.verbose = {
+		type: "boolean",
+		description: "Return the full response instead of the lightweight response.",
+		default: false
+	};
+	for (const name of pathParams) properties[name] = {
+		type: "string",
+		minLength: 1,
+		allOf: [properties[name]]
+	};
+	return {
+		type: "object",
+		properties,
+		required: [...required],
+		additionalProperties: allowsAdditionalProperties,
+		definitions
+	};
+}
+function relocateSchemaReferences(value, root) {
+	if (Array.isArray(value)) return value.map((item) => relocateSchemaReferences(item, root));
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, key === "$ref" && typeof child === "string" && (child === "#" || child.startsWith("#/")) ? `${root}${child.slice(1)}` : relocateSchemaReferences(child, root)]));
+}
+function schemaPropertyNames(schema) {
+	return isRecord(schema?.properties) ? Object.keys(schema.properties) : [];
+}
+function isApiSchemaRoute(value) {
+	if (!isRecord(value) || typeof value.method !== "string" || typeof value.path !== "string") return false;
+	return [
+		"pathParamSchema",
+		"queryParamSchema",
+		"bodySchema"
+	].every((key) => value[key] === void 0 || isRecord(value[key]));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getAuthToken(authInfo) {
+	if (!isRecord(authInfo)) return void 0;
+	return typeof authInfo.token === "string" && authInfo.token.length > 0 ? authInfo.token : void 0;
+}
+function getRequestAuthInfo(requestContext) {
+	const authInfo = requestContext?.get("authInfo");
+	if (authInfo !== void 0) return authInfo;
+	const token = requestContext?.get(_mastra_core_request_context.MASTRA_AUTH_TOKEN_KEY);
+	return typeof token === "string" && token.length > 0 ? { token } : void 0;
+}
+async function readResponseBody(response) {
+	const text = await response.text();
+	if (!text) return null;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function getErrorDetail(body) {
+	if (typeof body === "string") return body.slice(0, 500);
+	if (!isRecord(body)) return void 0;
+	const error = isRecord(body.error) ? body.error : body;
+	if (typeof error.message === "string") return error.message.slice(0, 500);
+	return JSON.stringify(body).slice(0, 500);
+}
+//#endregion
 //#region src/server/oauth-middleware.ts
 /**
 * Creates an OAuth middleware function for protecting MCP server endpoints.
@@ -27653,6 +28356,7 @@ exports.MCPOAuthClientProvider = MCPOAuthClientProvider;
 exports.MCPServer = MCPServer;
 exports.MCP_CALL_TOOL_CONTENT = MCP_CALL_TOOL_CONTENT;
 exports.MCP_CALL_TOOL_META = MCP_CALL_TOOL_META;
+exports.MastraApiMCPServer = MastraApiMCPServer;
 Object.defineProperty(exports, "UnauthorizedError", {
 	enumerable: true,
 	get: function() {