@mastra/elysia 0.0.0

package/dist/index.js

@@ -0,0 +1,818 @@
+import { coreAuthMiddleware, findMatchingCustomRoute, isProtectedCustomRoute } from "@mastra/server/auth";
+import { MastraServer as MastraServer$1, SERVER_ROUTES, checkRouteFGA, convertCustomRoutesToOpenAPIPaths, generateOpenAPIDocument, isZodError, normalizeQueryParams, redactStreamChunk, serializeStreamChunk } from "@mastra/server/server-adapter";
+import { toFetchResponse, toReqRes } from "fetch-to-node";
+import { RequestContext } from "@mastra/core/request-context";
+//#region src/auth-middleware.ts
+function createAuthMiddleware({ mastra, requiresAuth = true }) {
+	return async (ctx) => {
+		if (!requiresAuth) return;
+		const authConfig = mastra.getServer()?.auth;
+		if (!authConfig) return;
+		ctx.requestContext ??= new RequestContext();
+		ctx.mastra ??= mastra;
+		const path = new URL(ctx.request.url).pathname;
+		const method = ctx.request.method;
+		const customRouteAuthConfig = new Map(ctx.customRouteAuthConfig ?? []);
+		customRouteAuthConfig.set(`${method}:${path}`, true);
+		const authHeader = ctx.request.headers.get("authorization");
+		let token = authHeader ? authHeader.replace("Bearer ", "") : null;
+		if (!token && ctx.query?.apiKey) token = ctx.query.apiKey;
+		const result = await coreAuthMiddleware({
+			path,
+			method,
+			getHeader: (name) => ctx.request.headers.get(name) || void 0,
+			mastra,
+			authConfig,
+			customRouteAuthConfig,
+			requestContext: ctx.requestContext,
+			rawRequest: ctx.request,
+			token,
+			buildAuthorizeContext: () => ctx
+		});
+		if (result.action === "error") return new Response(JSON.stringify(result.body), {
+			status: result.status,
+			headers: { "Content-Type": "application/json" }
+		});
+	};
+}
+//#endregion
+//#region src/helper.ts
+/**
+* OpenAPI documentation cache to avoid regenerating on each call.
+* Uses WeakMap to prevent cache collisions between server instances.
+*/
+const openapiDocCache = /* @__PURE__ */ new WeakMap();
+/**
+* Get OpenAPI documentation from a MastraServer instance, formatted for Elysia's openapi plugin.
+*
+* This function:
+* - Extracts all Mastra routes with their Zod schemas
+* - Converts them to OpenAPI 3.1.0 format
+* - Merges custom routes if registered
+* - Applies the configured route prefix to all paths
+* - Caches the result for performance
+*
+* @param server - The MastraServer instance (must be initialized with init())
+* @param options - Optional configuration for OpenAPI metadata
+* @returns OpenAPI documentation with paths, components, and info
+*
+* @example
+* ```typescript
+* import { getMastraOpenAPIDoc } from '@mastra/elysia';
+*
+* const srv = new MastraServer({ mastra, app, prefix: '/api' });
+* await srv.init();
+*
+* const openAPIDoc = getMastraOpenAPIDoc(srv, {
+*   title: 'My Mastra API',
+*   version: '1.0.0',
+*   description: 'API with weather agent'
+* });
+*
+* app.use(openapi({
+*   documentation: {
+*     info: openAPIDoc.info,
+*     paths: openAPIDoc.paths,
+*     components: openAPIDoc.components
+*   }
+* }));
+* ```
+*/
+function getMastraOpenAPIDoc(server, options) {
+	if (options?.clearCache) openapiDocCache.delete(server);
+	const cached = openapiDocCache.get(server);
+	if (cached) {
+		if (options) return {
+			...cached,
+			info: {
+				...cached.info,
+				...options.title && { title: options.title },
+				...options.version && { version: options.version },
+				...options.description && { description: options.description }
+			}
+		};
+		return cached;
+	}
+	const openApiSpec = generateOpenAPIDocument(SERVER_ROUTES, {
+		title: options?.title || "Mastra API",
+		version: options?.version || "1.0.0",
+		description: options?.description || "Mastra Server API"
+	});
+	const customApiRoutes = server.customApiRoutes;
+	if (customApiRoutes && customApiRoutes.length > 0) {
+		const customPaths = convertCustomRoutesToOpenAPIPaths(customApiRoutes);
+		openApiSpec.paths = {
+			...openApiSpec.paths,
+			...customPaths
+		};
+	}
+	let paths = openApiSpec.paths || {};
+	const prefix = server.prefix;
+	if (prefix && prefix !== "/") {
+		const prefixedPaths = {};
+		for (const [path, pathItem] of Object.entries(paths)) {
+			const prefixedPath = `${prefix}${path}`.replace(/\/+/g, "/");
+			prefixedPaths[prefixedPath] = pathItem;
+		}
+		paths = prefixedPaths;
+	}
+	const result = {
+		paths,
+		components: openApiSpec.components,
+		info: openApiSpec.info
+	};
+	openapiDocCache.set(server, result);
+	return result;
+}
+/**
+* Clear the OpenAPI documentation cache.
+* Call this if routes are added dynamically after initialization.
+*
+* `@param` server - The MastraServer instance to clear cache for.
+* Note: WeakMap does not support clearing all entries. Pass the specific server instance whose cache should be invalidated.
+*/
+function clearMastraOpenAPICache(server) {
+	if (server) openapiDocCache.delete(server);
+}
+//#endregion
+//#region src/index.ts
+/**
+* Normalizes route path parameters to position-based names (:p0, :p1, ...)
+* to avoid Elysia router conflicts when different routes use different
+* parameter names at the same path segment position (e.g. :agentId vs
+* :storedAgentId under /stored/agents/...).
+* Returns the normalized path and the original parameter names in order.
+*/
+function normalizeRouteParams(path) {
+	const paramNames = [];
+	return {
+		normalizedPath: path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
+			paramNames.push(paramName);
+			return `:p${paramNames.length - 1}`;
+		}),
+		paramNames
+	};
+}
+/**
+* Remaps Elysia's parsed params from position-based names (p0, p1, ...)
+* back to the original parameter names expected by the route handler.
+*/
+function remapParams(rawParams, paramNames) {
+	if (paramNames.length === 0) return rawParams;
+	const result = {};
+	paramNames.forEach((paramName, i) => {
+		const key = `p${i}`;
+		if (key in rawParams) result[paramName] = rawParams[key];
+	});
+	return result;
+}
+async function createForwardRequest(ctx) {
+	const request = ctx.request;
+	const method = request.method;
+	if (method === "GET" || method === "HEAD") return request;
+	const headers = new Headers(request.headers);
+	let body;
+	if (ctx.body !== void 0) if (typeof ctx.body === "string" || ctx.body instanceof FormData || ctx.body instanceof Blob) body = ctx.body;
+	else {
+		body = JSON.stringify(ctx.body);
+		if (!headers.has("content-type")) headers.set("content-type", "application/json");
+	}
+	else if (!request.bodyUsed) {
+		const bodyBuffer = await request.clone().arrayBuffer();
+		if (bodyBuffer.byteLength > 0) body = bodyBuffer;
+	}
+	headers.delete("content-length");
+	return new Request(request.url, {
+		method,
+		headers,
+		body,
+		signal: request.signal,
+		...body ? { duplex: "half" } : {}
+	});
+}
+function createSafeReadableStream(body) {
+	if (!body) return null;
+	return new ReadableStream({ async start(controller) {
+		const reader = body.getReader();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				controller.enqueue(value);
+			}
+		} catch {} finally {
+			controller.close();
+			reader.releaseLock();
+		}
+	} });
+}
+let _hasPermissionPromise;
+function loadHasPermission() {
+	if (!_hasPermissionPromise) _hasPermissionPromise = import("@mastra/core/auth/ee").then((m) => m.hasPermission).catch(() => {
+		console.error("[@mastra/elysia] Auth features require @mastra/core >= 1.6.0. Please upgrade: npm install @mastra/core@latest");
+	});
+	return _hasPermissionPromise;
+}
+var MastraServer = class extends MastraServer$1 {
+	createContextMiddleware() {
+		return async (ctx) => {
+			let bodyRequestContext;
+			let paramsRequestContext;
+			if (ctx.request.method === "POST" || ctx.request.method === "PUT" || ctx.request.method === "PATCH") {
+				if (ctx.request.headers.get("content-type")?.includes("application/json")) try {
+					const body = ctx.body ?? await ctx.request.clone().json();
+					if (body.requestContext) bodyRequestContext = body.requestContext;
+				} catch {}
+			}
+			if (ctx.request.method === "GET") try {
+				const encodedRequestContext = ctx.query?.requestContext;
+				if (encodedRequestContext) try {
+					paramsRequestContext = JSON.parse(encodedRequestContext);
+				} catch {
+					try {
+						const json = Buffer.from(encodedRequestContext, "base64").toString("utf-8");
+						paramsRequestContext = JSON.parse(json);
+					} catch {}
+				}
+			} catch {}
+			const requestContext = this.mergeRequestContext({
+				paramsRequestContext,
+				bodyRequestContext
+			});
+			this.applyRequestMetadataToContext({
+				requestContext,
+				getHeader: (name) => ctx.request.headers.get(name) || void 0
+			});
+			return {
+				requestContext,
+				mastra: this.mastra,
+				registeredTools: this.tools || {},
+				taskStore: this.taskStore,
+				abortSignal: ctx.request.signal,
+				customRouteAuthConfig: this.customRouteAuthConfig
+			};
+		};
+	}
+	async stream(route, _res, result) {
+		const streamFormat = route.streamFormat || "stream";
+		const encoder = new TextEncoder();
+		const headers = streamFormat === "sse" ? {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			"X-Accel-Buffering": "no"
+		} : { "Content-Type": "text/plain" };
+		const stream = new ReadableStream({ start: async (controller) => {
+			const reader = (result instanceof ReadableStream ? result : result.fullStream).getReader();
+			try {
+				if (streamFormat === "sse" && route.sseFlushOnConnect) controller.enqueue(encoder.encode(": connected\n\n"));
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (value) {
+						if (streamFormat === "sse" && typeof value === "string" && value.startsWith(":")) {
+							controller.enqueue(encoder.encode(value));
+							continue;
+						}
+						const outputValue = this.streamOptions?.redact ?? true ? redactStreamChunk(value) : value;
+						const serialized = serializeStreamChunk(outputValue);
+						if (!serialized.ok) {
+							this.mastra.getLogger()?.error("Failed to serialize stream chunk, skipping", {
+								path: route.path,
+								chunkType: outputValue?.type,
+								error: serialized.error.message
+							});
+							continue;
+						}
+						if (streamFormat === "sse") controller.enqueue(encoder.encode(`data: ${serialized.json}\n\n`));
+						else controller.enqueue(encoder.encode(serialized.json + ""));
+					}
+				}
+				if (streamFormat === "sse") controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+				controller.close();
+			} catch (error) {
+				this.mastra.getLogger()?.error("Error in stream processing", { error: error instanceof Error ? {
+					message: error.message,
+					stack: error.stack
+				} : error });
+				controller.error(error);
+			} finally {
+				await reader.cancel();
+			}
+		} });
+		return new Response(stream, { headers });
+	}
+	async getParams(route, request) {
+		const url = new URL(request.url);
+		const { paramNames } = normalizeRouteParams(route.path);
+		const rawUrlParams = request.params || request.ctx?.params || {};
+		const urlParams = paramNames.length > 0 ? remapParams(rawUrlParams, paramNames) : rawUrlParams;
+		const queryParams = normalizeQueryParams(Object.fromEntries(url.searchParams));
+		let body;
+		let bodyParseError;
+		if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH" || route.method === "DELETE") {
+			const contentType = request.headers.get("content-type") || "";
+			if (contentType.includes("multipart/form-data")) try {
+				const formData = await request.formData();
+				body = await this.parseFormData(formData);
+			} catch (error) {
+				this.mastra.getLogger()?.error("Failed to parse multipart form data", { error: error instanceof Error ? {
+					message: error.message,
+					stack: error.stack
+				} : error });
+				if (error instanceof Error && error.message.toLowerCase().includes("size")) throw error;
+				bodyParseError = { message: error instanceof Error ? error.message : "Failed to parse multipart form data" };
+			}
+			else if (contentType.includes("application/json")) {
+				const bodyText = await request.clone().text();
+				if (bodyText && bodyText.trim().length > 0) try {
+					body = JSON.parse(bodyText);
+				} catch (error) {
+					this.mastra.getLogger()?.error("Failed to parse JSON body", { error: error instanceof Error ? {
+						message: error.message,
+						stack: error.stack
+					} : error });
+					bodyParseError = { message: error instanceof Error ? error.message : "Invalid JSON in request body" };
+				}
+			}
+		}
+		return {
+			urlParams,
+			queryParams,
+			body,
+			bodyParseError
+		};
+	}
+	/**
+	* Parse FormData into a plain object, converting File objects to Buffers.
+	* Handles both native FormData and Elysia's pre-parsed object format.
+	*/
+	async parseFormData(data) {
+		const result = {};
+		if (data instanceof FormData) {
+			for (const [key, value] of data.entries()) if (value instanceof File) {
+				const arrayBuffer = await value.arrayBuffer();
+				result[key] = Buffer.from(arrayBuffer);
+			} else if (typeof value === "string") try {
+				result[key] = JSON.parse(value);
+			} catch {
+				result[key] = value;
+			}
+			else result[key] = value;
+			return result;
+		}
+		for (const [key, value] of Object.entries(data)) if (value && typeof value === "object" && "arrayBuffer" in value && typeof value.arrayBuffer === "function") {
+			const arrayBuffer = await value.arrayBuffer();
+			result[key] = Buffer.from(arrayBuffer);
+		} else if (typeof value === "string") try {
+			result[key] = JSON.parse(value);
+		} catch {
+			result[key] = value;
+		}
+		else result[key] = value;
+		return result;
+	}
+	async sendResponse(route, response, result, prefix) {
+		const resolvedPrefix = prefix ?? this.prefix ?? "";
+		const refreshHeaders = {};
+		if (result && typeof result === "object" && "__refreshHeaders" in result) {
+			const headers = result.__refreshHeaders;
+			for (const [key, value] of Object.entries(headers)) refreshHeaders[key] = value;
+			delete result.__refreshHeaders;
+		}
+		if (route.responseType === "json") return new Response(JSON.stringify(result), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json",
+				...refreshHeaders
+			}
+		});
+		else if (route.responseType === "stream") return this.stream(route, response, result);
+		else if (route.responseType === "datastream-response") {
+			const fetchResponse = result;
+			const headers = new Headers(fetchResponse.headers);
+			headers.delete("Transfer-Encoding");
+			return new Response(createSafeReadableStream(fetchResponse.body), {
+				status: fetchResponse.status,
+				statusText: fetchResponse.statusText,
+				headers
+			});
+		} else if (route.responseType === "mcp-http") {
+			const { server, httpPath, mcpOptions: routeMcpOptions } = result;
+			const forwardRequest = await createForwardRequest(response);
+			const { req, res } = toReqRes(forwardRequest);
+			const options = {
+				...this.mcpOptions,
+				...routeMcpOptions
+			};
+			server.startHTTP({
+				url: new URL(forwardRequest.url),
+				httpPath: `${resolvedPrefix}${httpPath}`,
+				req,
+				res,
+				options: Object.keys(options).length > 0 ? options : void 0
+			}).catch((e) => {
+				this.mastra.getLogger()?.error("[MCP HTTP] Error in background startHTTP:", { error: e instanceof Error ? {
+					message: e.message,
+					stack: e.stack
+				} : e });
+			});
+			const mcpResponse = await toFetchResponse(res);
+			const headers = new Headers(mcpResponse.headers);
+			headers.delete("Transfer-Encoding");
+			return new Response(createSafeReadableStream(mcpResponse.body), {
+				status: mcpResponse.status,
+				statusText: mcpResponse.statusText,
+				headers
+			});
+		} else if (route.responseType === "mcp-sse") {
+			const { server, ssePath, messagePath } = result;
+			const forwardRequest = await createForwardRequest(response);
+			const { req, res } = toReqRes(forwardRequest);
+			server.startSSE({
+				url: new URL(forwardRequest.url),
+				ssePath: `${resolvedPrefix}${ssePath}`,
+				messagePath: `${resolvedPrefix}${messagePath}`,
+				req,
+				res
+			}).catch((e) => {
+				this.mastra.getLogger()?.error("[MCP SSE] Error in background startSSE:", { error: e instanceof Error ? {
+					message: e.message,
+					stack: e.stack
+				} : e });
+			});
+			const sseResponse = await toFetchResponse(res);
+			const headers = new Headers(sseResponse.headers);
+			headers.delete("Transfer-Encoding");
+			return new Response(createSafeReadableStream(sseResponse.body), {
+				status: sseResponse.status,
+				statusText: sseResponse.statusText,
+				headers
+			});
+		} else return new Response(null, { status: 500 });
+	}
+	async registerRoute(app, route, { prefix: prefixParam } = {}) {
+		const prefix = prefixParam ?? this.prefix ?? "";
+		const { normalizedPath, paramNames } = normalizeRouteParams(`${prefix}${route.path}`);
+		const handler = async (ctx) => {
+			const authError = await this.checkRouteAuth(route, {
+				path: ctx.request.url ? new URL(ctx.request.url).pathname : ctx.path,
+				method: ctx.request.method,
+				getHeader: (name) => ctx.request.headers.get(name) || void 0,
+				getQuery: (name) => ctx.query?.[name],
+				requestContext: ctx.requestContext,
+				request: ctx.request,
+				buildAuthorizeContext: () => ctx
+			});
+			if (authError) return new Response(JSON.stringify({ error: authError.error }), {
+				status: authError.status,
+				headers: {
+					"Content-Type": "application/json",
+					...authError.headers
+				}
+			});
+			if (this.mastra.getServer()?.auth) {
+				const hasPermission = await loadHasPermission();
+				if (hasPermission) {
+					const userPermissions = ctx.requestContext.get("userPermissions");
+					const permissionError = this.checkRoutePermission(route, userPermissions, hasPermission);
+					if (permissionError) return new Response(JSON.stringify({
+						error: permissionError.error,
+						message: permissionError.message
+					}), {
+						status: permissionError.status,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+			}
+			const rawParams = ctx.params || {};
+			const urlParams = paramNames.length > 0 ? remapParams(rawParams, paramNames) : rawParams;
+			const queryParams = normalizeQueryParams(ctx.query || {});
+			let body;
+			let bodyParseError;
+			if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH" || route.method === "DELETE") {
+				const maxSize = route.maxBodySize ?? this.bodyLimitOptions?.maxSize;
+				const contentLength = ctx.request.headers.get("content-length");
+				if (this.bodyLimitOptions && maxSize && contentLength && parseInt(contentLength, 10) > maxSize) {
+					let errorResponse = { error: "Request body too large" };
+					try {
+						errorResponse = this.bodyLimitOptions.onError({ error: "Request body too large" });
+					} catch {}
+					return new Response(JSON.stringify(errorResponse), {
+						status: 413,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+				const contentType = ctx.request.headers.get("content-type") || "";
+				if (contentType.includes("multipart/form-data")) try {
+					body = ctx.body ? await this.parseFormData(ctx.body) : void 0;
+				} catch (error) {
+					this.mastra.getLogger()?.error("Failed to parse multipart form data", { error: error instanceof Error ? {
+						message: error.message,
+						stack: error.stack
+					} : error });
+					if (error instanceof Error && error.message.toLowerCase().includes("size")) throw error;
+					bodyParseError = { message: error instanceof Error ? error.message : "Failed to parse multipart form data" };
+				}
+				else if (contentType.includes("application/json")) {
+					body = ctx.body;
+					if (body === void 0 && contentType.includes("application/json")) {
+						const bodyText = await ctx.request.clone().text();
+						if (bodyText && bodyText.trim().length > 0) try {
+							body = JSON.parse(bodyText);
+						} catch (error) {
+							this.mastra.getLogger()?.error("Failed to parse JSON body", { error: error instanceof Error ? {
+								message: error.message,
+								stack: error.stack
+							} : error });
+							bodyParseError = { message: error instanceof Error ? error.message : "Invalid JSON in request body" };
+						}
+					}
+				}
+			}
+			const params = {
+				urlParams,
+				queryParams,
+				body,
+				bodyParseError
+			};
+			if (params.bodyParseError) return new Response(JSON.stringify({
+				error: "Invalid request body",
+				issues: [{
+					field: "body",
+					message: params.bodyParseError.message
+				}]
+			}), {
+				status: 400,
+				headers: { "Content-Type": "application/json" }
+			});
+			if (params.queryParams) try {
+				params.queryParams = await this.parseQueryParams(route, params.queryParams);
+			} catch (error) {
+				this.mastra.getLogger()?.error("Error parsing query params", { error: error instanceof Error ? {
+					message: error.message,
+					stack: error.stack
+				} : error });
+				if (isZodError(error)) {
+					const { status, body } = this.resolveValidationError(route, error, "query");
+					return new Response(JSON.stringify(body), {
+						status,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+				return new Response(JSON.stringify({
+					error: "Invalid query parameters",
+					issues: [{
+						field: "unknown",
+						message: error instanceof Error ? error.message : "Unknown error"
+					}]
+				}), {
+					status: 400,
+					headers: { "Content-Type": "application/json" }
+				});
+			}
+			if (params.body) try {
+				params.body = await this.parseBody(route, params.body);
+			} catch (error) {
+				this.mastra.getLogger()?.error("Error parsing body", { error: error instanceof Error ? {
+					message: error.message,
+					stack: error.stack
+				} : error });
+				if (isZodError(error)) {
+					const { status, body } = this.resolveValidationError(route, error, "body");
+					return new Response(JSON.stringify(body), {
+						status,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+				return new Response(JSON.stringify({
+					error: "Invalid request body",
+					issues: [{
+						field: "unknown",
+						message: error instanceof Error ? error.message : "Unknown error"
+					}]
+				}), {
+					status: 400,
+					headers: { "Content-Type": "application/json" }
+				});
+			}
+			if (params.urlParams) try {
+				params.urlParams = await this.parsePathParams(route, params.urlParams);
+			} catch (error) {
+				this.mastra.getLogger()?.error("Error parsing path params", { error: error instanceof Error ? {
+					message: error.message,
+					stack: error.stack
+				} : error });
+				if (isZodError(error)) {
+					const { status, body } = this.resolveValidationError(route, error, "path");
+					return new Response(JSON.stringify(body), {
+						status,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+				return new Response(JSON.stringify({
+					error: "Invalid path parameters",
+					issues: [{
+						field: "unknown",
+						message: error instanceof Error ? error.message : "Unknown error"
+					}]
+				}), {
+					status: 400,
+					headers: { "Content-Type": "application/json" }
+				});
+			}
+			const fgaError = await checkRouteFGA(this.mastra, route, ctx.requestContext, {
+				...params.urlParams,
+				...params.queryParams,
+				...typeof params.body === "object" ? params.body : {}
+			});
+			if (fgaError) return new Response(JSON.stringify({
+				error: fgaError.error,
+				message: fgaError.message
+			}), {
+				status: fgaError.status,
+				headers: { "Content-Type": "application/json" }
+			});
+			const handlerParams = {
+				...params.urlParams,
+				...params.queryParams,
+				...typeof params.body === "object" ? params.body : {},
+				requestContext: ctx.requestContext,
+				mastra: ctx.mastra,
+				registeredTools: ctx.registeredTools,
+				taskStore: ctx.taskStore,
+				abortSignal: ctx.abortSignal,
+				routePrefix: prefix,
+				request: ctx.request
+			};
+			try {
+				const result = await route.handler(handlerParams);
+				return this.sendResponse(route, ctx, result, prefix);
+			} catch (error) {
+				this.mastra.getLogger()?.error("Error calling handler", {
+					error: error instanceof Error ? {
+						message: error.message,
+						stack: error.stack
+					} : error,
+					path: route.path,
+					method: route.method
+				});
+				if (error && typeof error === "object") {
+					if ("status" in error) {
+						const status = error.status;
+						return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }), {
+							status,
+							headers: { "Content-Type": "application/json" }
+						});
+					}
+					if ("details" in error && error.details && typeof error.details === "object" && "status" in error.details) {
+						const status = error.details.status;
+						return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }), {
+							status,
+							headers: { "Content-Type": "application/json" }
+						});
+					}
+				}
+				return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }), {
+					status: 500,
+					headers: { "Content-Type": "application/json" }
+				});
+			}
+		};
+		app[route.method.toLowerCase()](normalizedPath, handler);
+	}
+	async registerCustomApiRoutes() {
+		const routes = await this.registerSchemaApiRoutes();
+		if (!await this.buildCustomRouteHandler(routes)) return;
+		for (const route of routes) {
+			const method = route.method.toLowerCase();
+			const { normalizedPath: customNormalizedPath } = normalizeRouteParams(route.path);
+			this.app[method](customNormalizedPath, async (ctx) => {
+				const path = new URL(ctx.request.url).pathname;
+				const requestMethod = ctx.request.method;
+				const matchedRoute = findMatchingCustomRoute(path, requestMethod, this.customApiRoutes ?? this.mastra.getServer()?.apiRoutes);
+				const shouldRunCustomRouteAuth = isProtectedCustomRoute(path, requestMethod, this.customRouteAuthConfig);
+				const shouldRunCustomRouteFGA = !!matchedRoute?.route.fga;
+				if (shouldRunCustomRouteAuth || shouldRunCustomRouteFGA) {
+					const serverRoute = {
+						method: matchedRoute?.route.method ?? requestMethod,
+						path: matchedRoute?.route.path ?? path,
+						responseType: "json",
+						handler: async () => {},
+						requiresAuth: matchedRoute?.route.requiresAuth,
+						requiresPermission: matchedRoute?.route.requiresPermission,
+						fga: matchedRoute?.route.fga
+					};
+					if (shouldRunCustomRouteAuth) {
+						const authError = await this.checkRouteAuth(serverRoute, {
+							path,
+							method: requestMethod,
+							getHeader: (name) => ctx.request.headers.get(name) || void 0,
+							getQuery: (name) => ctx.query?.[name],
+							requestContext: ctx.requestContext,
+							request: ctx.request,
+							buildAuthorizeContext: () => ctx
+						});
+						if (authError) return new Response(JSON.stringify({ error: authError.error }), {
+							status: authError.status,
+							headers: {
+								"Content-Type": "application/json",
+								...authError.headers
+							}
+						});
+						if (this.mastra.getServer()?.auth) {
+							const hasPermission = await loadHasPermission();
+							if (hasPermission) {
+								const userPermissions = ctx.requestContext.get("userPermissions");
+								const permissionError = this.checkRoutePermission(serverRoute, userPermissions, hasPermission);
+								if (permissionError) return new Response(JSON.stringify({
+									error: permissionError.error,
+									message: permissionError.message
+								}), {
+									status: permissionError.status,
+									headers: { "Content-Type": "application/json" }
+								});
+							}
+						}
+					}
+					const fgaError = await checkRouteFGA(this.mastra, serverRoute, ctx.requestContext, {
+						...matchedRoute?.params ?? {},
+						...ctx.query,
+						...typeof ctx.body === "object" && ctx.body !== null ? ctx.body : {}
+					});
+					if (fgaError) return new Response(JSON.stringify({
+						error: fgaError.error,
+						message: fgaError.message
+					}), {
+						status: fgaError.status,
+						headers: { "Content-Type": "application/json" }
+					});
+				}
+				const headers = {};
+				ctx.request.headers.forEach((value, key) => {
+					headers[key] = value;
+				});
+				const response = await this.handleCustomRouteRequest(ctx.request.url, ctx.request.method, headers, ctx.body, ctx.requestContext, ctx.request.signal);
+				if (!response) return new Response(JSON.stringify({ error: "Not Found" }), {
+					status: 404,
+					headers: { "Content-Type": "application/json" }
+				});
+				return response;
+			});
+		}
+	}
+	registerContextMiddleware() {
+		this.app.derive(this.createContextMiddleware());
+	}
+	registerAuthMiddleware() {
+		this.app.onError((ctx) => {
+			const error = ctx.error;
+			const status = error?.status ?? error?.code ?? 500;
+			const message = error?.message ?? "Internal server error";
+			const httpStatus = typeof status === "number" && status >= 400 && status < 500 ? status : 500;
+			return new Response(JSON.stringify({
+				error: httpStatus < 500 ? message : "Internal server error",
+				...httpStatus < 500 ? { issues: [] } : {}
+			}), {
+				status: httpStatus,
+				headers: { "Content-Type": "application/json" }
+			});
+		});
+	}
+	registerHttpLoggingMiddleware() {
+		if (!this.httpLoggingConfig?.enabled) return;
+		this.app.derive(async (ctx) => {
+			const path = new URL(ctx.request.url).pathname;
+			if (!this.shouldLogRequest(path)) return {};
+			return { httpLogStart: Date.now() };
+		});
+		this.app.onAfterHandle((ctx) => {
+			const path = new URL(ctx.request.url).pathname;
+			if (!this.shouldLogRequest(path)) return;
+			const duration = Date.now() - (ctx.httpLogStart ?? Date.now());
+			const method = ctx.request.method;
+			const status = ctx.response?.status ?? ctx.set?.status ?? 200;
+			const level = this.httpLoggingConfig?.level || "info";
+			const logData = {
+				method,
+				path,
+				status,
+				duration: `${duration}ms`
+			};
+			if (this.httpLoggingConfig?.includeQueryParams) logData.query = ctx.query || {};
+			if (this.httpLoggingConfig?.includeHeaders) {
+				const headers = Object.fromEntries(ctx.request.headers.entries());
+				(this.httpLoggingConfig.redactHeaders || []).forEach((h) => {
+					const key = h.toLowerCase();
+					if (headers[key] !== void 0) headers[key] = "[REDACTED]";
+				});
+				logData.headers = headers;
+			}
+			this.logger[level](`${method} ${path} ${status} ${duration}ms`, logData);
+		});
+	}
+};
+//#endregion
+export { MastraServer, clearMastraOpenAPICache, createAuthMiddleware, getMastraOpenAPIDoc };
+
+//# sourceMappingURL=index.js.map