@mastra/fastify 1.4.11-alpha.0 → 1.4.11-alpha.2

package/dist/index.cjs

@@ -1,800 +1,686 @@
-'use strict';
-
-var busboy = require('@fastify/busboy');
-var serverAdapter = require('@mastra/server/server-adapter');
-var requestContext = require('@mastra/core/request-context');
-var auth = require('@mastra/server/auth');
-
-// src/index.ts
-function toWebRequest(request) {
-  const protocol = request.protocol || "http";
-  const host = request.headers.host || "localhost";
-  const url = `${protocol}://${host}${request.url}`;
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(request.headers)) {
-    if (!value) continue;
-    if (Array.isArray(value)) {
-      value.forEach((v) => headers.append(key, v));
-    } else {
-      headers.set(key, value);
-    }
-  }
-  return new globalThis.Request(url, {
-    method: request.method,
-    headers
-  });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _fastify_busboy = require("@fastify/busboy");
+let _mastra_server_server_adapter = require("@mastra/server/server-adapter");
+let _mastra_core_request_context = require("@mastra/core/request-context");
+let _mastra_server_auth = require("@mastra/server/auth");
+//#region src/auth-middleware.ts
+function toWebRequest$1(request) {
+	const url = `${request.protocol || "http"}://${request.headers.host || "localhost"}${request.url}`;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(request.headers)) {
+		if (!value) continue;
+		if (Array.isArray(value)) value.forEach((v) => headers.append(key, v));
+		else headers.set(key, value);
+	}
+	return new globalThis.Request(url, {
+		method: request.method,
+		headers
+	});
 }
-function createAuthMiddleware({
-  mastra,
-  requiresAuth = true
-}) {
-  return async (request, reply) => {
-    if (!requiresAuth) {
-      return;
-    }
-    const authConfig = mastra.getServer()?.auth;
-    if (!authConfig) {
-      return;
-    }
-    request.requestContext ??= new requestContext.RequestContext();
-    request.mastra ??= mastra;
-    const path = String(request.url.split("?")[0] || "/");
-    const method = String(request.method || "GET");
-    const customRouteAuthConfig = new Map(request.customRouteAuthConfig ?? []);
-    customRouteAuthConfig.set(`${method}:${path}`, true);
-    const authHeader = request.headers.authorization;
-    let token = authHeader ? authHeader.replace("Bearer ", "") : null;
-    const query = request.query;
-    if (!token && query.apiKey) {
-      token = query.apiKey || null;
-    }
-    const result = await auth.coreAuthMiddleware({
-      path,
-      method,
-      getHeader: (name) => request.headers[name.toLowerCase()],
-      mastra,
-      authConfig,
-      customRouteAuthConfig,
-      requestContext: request.requestContext,
-      rawRequest: toWebRequest(request),
-      token,
-      buildAuthorizeContext: () => toWebRequest(request)
-    });
-    if (result.action === "error") {
-      return reply.status(result.status).send(result.body);
-    }
-  };
+function createAuthMiddleware({ mastra, requiresAuth = true }) {
+	return async (request, reply) => {
+		if (!requiresAuth) return;
+		const authConfig = mastra.getServer()?.auth;
+		if (!authConfig) return;
+		request.requestContext ??= new _mastra_core_request_context.RequestContext();
+		request.mastra ??= mastra;
+		const path = String(request.url.split("?")[0] || "/");
+		const method = String(request.method || "GET");
+		const customRouteAuthConfig = new Map(request.customRouteAuthConfig ?? []);
+		customRouteAuthConfig.set(`${method}:${path}`, true);
+		const authHeader = request.headers.authorization;
+		let token = authHeader ? authHeader.replace("Bearer ", "") : null;
+		const query = request.query;
+		if (!token && query.apiKey) token = query.apiKey || null;
+		const result = await (0, _mastra_server_auth.coreAuthMiddleware)({
+			path,
+			method,
+			getHeader: (name) => request.headers[name.toLowerCase()],
+			mastra,
+			authConfig,
+			customRouteAuthConfig,
+			requestContext: request.requestContext,
+			rawRequest: toWebRequest$1(request),
+			token,
+			buildAuthorizeContext: () => toWebRequest$1(request)
+		});
+		if (result.action === "error") return reply.status(result.status).send(result.body);
+	};
 }
-
-// src/index.ts
-var _hasPermissionPromise;
+//#endregion
+//#region src/index.ts
+let _hasPermissionPromise;
 function loadHasPermission() {
-  if (!_hasPermissionPromise) {
-    _hasPermissionPromise = import('@mastra/core/auth/ee').then((m) => m.hasPermission).catch(() => {
-      console.error(
-        "[@mastra/fastify] Auth features require @mastra/core >= 1.6.0. Please upgrade: npm install @mastra/core@latest"
-      );
-      return void 0;
-    });
-  }
-  return _hasPermissionPromise;
+	if (!_hasPermissionPromise) _hasPermissionPromise = import("@mastra/core/auth/ee").then((m) => m.hasPermission).catch(() => {
+		console.error("[@mastra/fastify] Auth features require @mastra/core >= 1.6.0. Please upgrade: npm install @mastra/core@latest");
+	});
+	return _hasPermissionPromise;
 }
-function toWebRequest2(request) {
-  const protocol = request.protocol || "http";
-  const host = request.headers.host || "localhost";
-  const url = `${protocol}://${host}${request.url}`;
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(request.headers)) {
-    if (value) {
-      if (Array.isArray(value)) {
-        value.forEach((v) => headers.append(key, v));
-      } else {
-        headers.set(key, value);
-      }
-    }
-  }
-  return new globalThis.Request(url, {
-    method: request.method,
-    headers
-  });
+/**
+* Convert Fastify request to Web API Request for cookie-based auth providers.
+*/
+function toWebRequest(request) {
+	const url = `${request.protocol || "http"}://${request.headers.host || "localhost"}${request.url}`;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(request.headers)) if (value) if (Array.isArray(value)) value.forEach((v) => headers.append(key, v));
+	else headers.set(key, value);
+	return new globalThis.Request(url, {
+		method: request.method,
+		headers
+	});
 }
 function isRequestAborted(rawRequest) {
-  return rawRequest.aborted || rawRequest.readableAborted || !rawRequest.complete;
+	return rawRequest.aborted || rawRequest.readableAborted || !rawRequest.complete;
 }
-var MastraServer = class extends serverAdapter.MastraServer {
-  createContextMiddleware() {
-    return async (request, reply) => {
-      let bodyRequestContext;
-      let paramsRequestContext;
-      if (request.method === "POST" || request.method === "PUT") {
-        const contentType = request.headers["content-type"];
-        if (contentType?.includes("application/json") && request.body) {
-          const body = request.body;
-          if (body.requestContext) {
-            bodyRequestContext = body.requestContext;
-          }
-        }
-      }
-      if (request.method === "GET") {
-        try {
-          const query = request.query;
-          const encodedRequestContext = query.requestContext;
-          if (typeof encodedRequestContext === "string") {
-            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) => {
-          const value = request.headers[name.toLowerCase()];
-          return Array.isArray(value) ? value[0] : value;
-        }
-      });
-      request.requestContext = requestContext;
-      request.mastra = this.mastra;
-      request.registeredTools = this.tools || {};
-      if (this.taskStore) {
-        request.taskStore = this.taskStore;
-      }
-      request.customRouteAuthConfig = this.customRouteAuthConfig;
-      const controller = new AbortController();
-      request.raw.on("close", () => {
-        if (isRequestAborted(request.raw)) {
-          controller.abort();
-        }
-      });
-      reply.raw.on("close", () => {
-        if (!reply.raw.writableEnded) {
-          controller.abort();
-        }
-      });
-      request.abortSignal = controller.signal;
-    };
-  }
-  async stream(route, reply, result, request) {
-    const rawHeaders = reply.getHeaders();
-    const existingHeaders = {};
-    for (const [key, value] of Object.entries(rawHeaders)) {
-      if (value === void 0) continue;
-      const lowerKey = key.toLowerCase();
-      if (lowerKey === "content-length" || lowerKey === "transfer-encoding") continue;
-      existingHeaders[key] = value;
-    }
-    reply.hijack();
-    const streamFormat = route.streamFormat || "stream";
-    const sseHeaders = streamFormat === "sse" ? {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "X-Accel-Buffering": "no"
-    } : {
-      "Content-Type": "text/plain"
-    };
-    reply.raw.writeHead(200, {
-      ...existingHeaders,
-      ...sseHeaders,
-      "Transfer-Encoding": "chunked"
-    });
-    if (streamFormat === "sse" && route.sseFlushOnConnect) {
-      reply.raw.write(": connected\n\n");
-    }
-    const readableStream = result instanceof ReadableStream ? result : result.fullStream;
-    const reader = readableStream.getReader();
-    let readerCanceled = false;
-    const cancelReader = (reason) => {
-      if (readerCanceled) return;
-      readerCanceled = true;
-      void reader.cancel(reason);
-    };
-    const cancelReaderOnResponseClose = () => cancelReader("request aborted");
-    const cancelReaderOnRequestClose = () => {
-      if (request && isRequestAborted(request.raw)) {
-        cancelReader("request aborted");
-      }
-    };
-    reply.raw.on("close", cancelReaderOnResponseClose);
-    request?.raw.on("close", cancelReaderOnRequestClose);
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        if (value) {
-          if (streamFormat === "sse" && typeof value === "string" && value.startsWith(":")) {
-            reply.raw.write(value);
-            continue;
-          }
-          const shouldRedact = this.streamOptions?.redact ?? true;
-          const outputValue = shouldRedact ? serverAdapter.redactStreamChunk(value) : value;
-          const serialized = serverAdapter.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") {
-            reply.raw.write(`data: ${serialized.json}
-
-`);
-          } else {
-            reply.raw.write(serialized.json + "");
-          }
-        }
-      }
-    } catch (error) {
-      this.mastra.getLogger()?.error("Error in stream processing", {
-        error: error instanceof Error ? { message: error.message, stack: error.stack } : error
-      });
-    } finally {
-      reply.raw.off("close", cancelReaderOnResponseClose);
-      request?.raw.off("close", cancelReaderOnRequestClose);
-      if (!reply.raw.writableEnded && !reply.raw.destroyed) {
-        reply.raw.end();
-      }
-    }
-  }
-  async getParams(route, request) {
-    const urlParams = request.params || {};
-    const queryParams = serverAdapter.normalizeQueryParams(request.query || {});
-    let body;
-    let bodyParseError;
-    if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH" || route.method === "DELETE") {
-      const contentType = request.headers["content-type"] || "";
-      if (contentType.includes("multipart/form-data")) {
-        try {
-          const maxFileSize = route.maxBodySize ?? this.bodyLimitOptions?.maxSize;
-          body = await this.parseMultipartFormData(request, maxFileSize);
-        } 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 {
-        body = request.body;
-      }
-    }
-    return { urlParams, queryParams, body, bodyParseError };
-  }
-  /**
-   * Parse multipart/form-data using @fastify/busboy.
-   * Converts file uploads to Buffers and parses JSON field values.
-   *
-   * @param request - The Fastify request object
-   * @param maxFileSize - Optional maximum file size in bytes
-   */
-  parseMultipartFormData(request, maxFileSize) {
-    return new Promise((resolve, reject) => {
-      const result = {};
-      const busboy$1 = new busboy.Busboy({
-        headers: {
-          "content-type": request.headers["content-type"]
-        },
-        limits: maxFileSize ? { fileSize: maxFileSize } : void 0
-      });
-      busboy$1.on(
-        "file",
-        (fieldname, file, _filename, _encoding, _mimetype) => {
-          const chunks = [];
-          let limitExceeded = false;
-          file.on("data", (chunk) => {
-            chunks.push(chunk);
-          });
-          file.on("limit", () => {
-            limitExceeded = true;
-            file.resume();
-            reject(new Error(`File size limit exceeded${maxFileSize ? ` (max: ${maxFileSize} bytes)` : ""}`));
-          });
-          file.on("end", () => {
-            if (!limitExceeded) {
-              result[fieldname] = Buffer.concat(chunks);
-            }
-          });
-        }
-      );
-      busboy$1.on("field", (fieldname, value) => {
-        try {
-          result[fieldname] = JSON.parse(value);
-        } catch {
-          result[fieldname] = value;
-        }
-      });
-      busboy$1.on("finish", () => {
-        resolve(result);
-      });
-      busboy$1.on("error", (error) => {
-        reject(error);
-      });
-      request.raw.pipe(busboy$1);
-    });
-  }
-  async sendResponse(route, reply, result, request, prefix) {
-    const resolvedPrefix = prefix ?? this.prefix ?? "";
-    if (result && typeof result === "object" && "__refreshHeaders" in result) {
-      const refreshHeaders = result.__refreshHeaders;
-      for (const [key, value] of Object.entries(refreshHeaders)) {
-        reply.header(key, value);
-      }
-      delete result.__refreshHeaders;
-    }
-    if (route.responseType === "json") {
-      await reply.send(result);
-    } else if (route.responseType === "stream") {
-      await this.stream(route, reply, result, request);
-    } else if (route.responseType === "datastream-response") {
-      const fetchResponse = result;
-      fetchResponse.headers.forEach((value, key) => reply.header(key, value));
-      reply.status(fetchResponse.status);
-      if (fetchResponse.body) {
-        const reader = fetchResponse.body.getReader();
-        let readerCanceled = false;
-        const cancelReader = (reason) => {
-          if (readerCanceled) return;
-          readerCanceled = true;
-          void reader.cancel(reason);
-        };
-        const cancelReaderOnResponseClose = () => cancelReader("request aborted");
-        const cancelReaderOnRequestClose = () => {
-          if (request && isRequestAborted(request.raw)) {
-            cancelReader("request aborted");
-          }
-        };
-        const onResError = (err) => {
-          this.mastra.getLogger()?.error("Error writing datastream response", {
-            error: err instanceof Error ? { message: err.message, stack: err.stack } : err
-          });
-          cancelReader("response write error");
-        };
-        reply.raw.once("error", onResError);
-        reply.raw.on("close", cancelReaderOnResponseClose);
-        request?.raw.on("close", cancelReaderOnRequestClose);
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            reply.raw.write(value);
-          }
-        } catch (error) {
-          this.mastra.getLogger()?.error("Error in datastream processing", {
-            error: error instanceof Error ? { message: error.message, stack: error.stack } : error
-          });
-        } finally {
-          reply.raw.off("error", onResError);
-          reply.raw.off("close", cancelReaderOnResponseClose);
-          request?.raw.off("close", cancelReaderOnRequestClose);
-          if (!reply.raw.writableEnded && !reply.raw.destroyed) {
-            reply.raw.end();
-          }
-        }
-      } else {
-        reply.raw.end();
-      }
-    } else if (route.responseType === "mcp-http") {
-      if (!request) {
-        await reply.status(500).send({ error: "Request object required for MCP transport" });
-        return;
-      }
-      const { server, httpPath, mcpOptions: routeMcpOptions } = result;
-      try {
-        reply.hijack();
-        const rawReq = request.raw;
-        if (request.body !== void 0) {
-          rawReq.body = request.body;
-        }
-        const options = { ...this.mcpOptions, ...routeMcpOptions };
-        await server.startHTTP({
-          url: new URL(request.url, `http://${request.headers.host}`),
-          httpPath: `${resolvedPrefix}${httpPath}`,
-          req: rawReq,
-          res: reply.raw,
-          options: Object.keys(options).length > 0 ? options : void 0
-        });
-      } catch {
-        if (!reply.raw.headersSent) {
-          reply.raw.writeHead(500, { "Content-Type": "application/json" });
-          reply.raw.end(
-            JSON.stringify({
-              jsonrpc: "2.0",
-              error: { code: -32603, message: "Internal server error" },
-              id: null
-            })
-          );
-        }
-      }
-    } else if (route.responseType === "mcp-sse") {
-      if (!request) {
-        await reply.status(500).send({ error: "Request object required for MCP transport" });
-        return;
-      }
-      const { server, ssePath, messagePath } = result;
-      try {
-        reply.hijack();
-        const rawReq = request.raw;
-        if (request.body !== void 0) {
-          rawReq.body = request.body;
-        }
-        await server.startSSE({
-          url: new URL(request.url, `http://${request.headers.host}`),
-          ssePath: `${resolvedPrefix}${ssePath}`,
-          messagePath: `${resolvedPrefix}${messagePath}`,
-          req: rawReq,
-          res: reply.raw
-        });
-      } catch {
-        if (!reply.raw.headersSent) {
-          reply.raw.writeHead(500, { "Content-Type": "application/json" });
-          reply.raw.end(JSON.stringify({ error: "Error handling MCP SSE request" }));
-        }
-      }
-    } else {
-      reply.status(500);
-    }
-  }
-  async registerRoute(app, route, { prefix: prefixParam } = {}) {
-    const prefix = prefixParam ?? this.prefix ?? "";
-    const fullPath = `${prefix}${route.path}`;
-    const fastifyPath = fullPath;
-    const handler = async (request, reply) => {
-      const authError = await this.checkRouteAuth(route, {
-        path: String(request.url.split("?")[0] || "/"),
-        method: String(request.method || "GET"),
-        getHeader: (name) => request.headers[name.toLowerCase()],
-        getQuery: (name) => request.query[name],
-        requestContext: request.requestContext,
-        request: toWebRequest2(request),
-        buildAuthorizeContext: () => toWebRequest2(request)
-      });
-      if (authError) {
-        if (authError.headers) {
-          for (const [key, value] of Object.entries(authError.headers)) {
-            void reply.header(key, value);
-          }
-        }
-        if (authError.error) {
-          return reply.status(authError.status).send({ error: authError.error });
-        }
-      }
-      const params = await this.getParams(route, request);
-      if (params.bodyParseError) {
-        return reply.status(400).send({
-          error: "Invalid request body",
-          issues: [{ field: "body", message: params.bodyParseError.message }]
-        });
-      }
-      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 (serverAdapter.isZodError(error)) {
-            const { status, body } = this.resolveValidationError(route, error, "query");
-            return reply.status(status).send(body);
-          }
-          return reply.status(400).send({
-            error: "Invalid query parameters",
-            issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
-          });
-        }
-      }
-      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 (serverAdapter.isZodError(error)) {
-            const { status, body } = this.resolveValidationError(route, error, "body");
-            return reply.status(status).send(body);
-          }
-          return reply.status(400).send({
-            error: "Invalid request body",
-            issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
-          });
-        }
-      }
-      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 (serverAdapter.isZodError(error)) {
-            const { status, body } = this.resolveValidationError(route, error, "path");
-            return reply.status(status).send(body);
-          }
-          return reply.status(400).send({
-            error: "Invalid path parameters",
-            issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
-          });
-        }
-      }
-      const handlerParams = {
-        ...params.urlParams,
-        ...params.queryParams,
-        ...typeof params.body === "object" ? params.body : {},
-        requestContext: request.requestContext,
-        mastra: this.mastra,
-        registeredTools: request.registeredTools,
-        taskStore: request.taskStore,
-        abortSignal: request.abortSignal,
-        routePrefix: prefix,
-        request: toWebRequest2(request)
-      };
-      const requestContext = request.requestContext;
-      const hasAuth = this.mastra.getStudio?.()?.auth || this.mastra.getServer()?.auth;
-      if (hasAuth) {
-        const hasPermission = await loadHasPermission();
-        if (hasPermission) {
-          const userPermissions = requestContext.get("mastra__userPermissions");
-          const permissionError = this.checkRoutePermission(route, userPermissions, hasPermission, requestContext);
-          if (permissionError) {
-            return reply.status(permissionError.status).send({
-              error: permissionError.error,
-              message: permissionError.message
-            });
-          }
-        }
-      }
-      const fgaError = await serverAdapter.checkRouteFGA(this.mastra, route, requestContext, {
-        ...params.urlParams,
-        ...params.queryParams,
-        ...typeof params.body === "object" ? params.body : {}
-      });
-      if (fgaError) {
-        return reply.status(fgaError.status).send({ error: fgaError.error, message: fgaError.message });
-      }
-      try {
-        const result = await route.handler(handlerParams);
-        await this.sendResponse(route, reply, result, request, prefix);
-      } catch (error) {
-        const httpStatus = error && typeof error === "object" && "status" in error ? error.status : void 0;
-        const isClientError = typeof httpStatus === "number" && httpStatus >= 400 && httpStatus < 500;
-        if (!isClientError) {
-          this.mastra.getLogger()?.error("Error calling handler", {
-            error: error instanceof Error ? { message: error.message, stack: error.stack } : error,
-            path: route.path,
-            method: route.method
-          });
-        }
-        let status = 500;
-        if (error && typeof error === "object") {
-          if ("status" in error) {
-            status = error.status;
-          } else if ("details" in error && error.details && typeof error.details === "object" && "status" in error.details) {
-            status = error.details.status;
-          }
-        }
-        await reply.status(status).send({ error: error instanceof Error ? error.message : "Unknown error" });
-      }
-    };
-    const shouldApplyBodyLimit = this.bodyLimitOptions && ["POST", "PUT", "PATCH"].includes(route.method.toUpperCase());
-    const maxSize = route.maxBodySize ?? this.bodyLimitOptions?.maxSize;
-    const config = shouldApplyBodyLimit && maxSize ? { bodyLimit: maxSize } : void 0;
-    if (route.method.toUpperCase() === "ALL") {
-      const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
-      for (const method of methods) {
-        try {
-          app.route({
-            method,
-            url: fastifyPath,
-            handler,
-            config
-          });
-        } catch (err) {
-          if (err instanceof Error && err.message.includes("already declared")) {
-            continue;
-          }
-          throw err;
-        }
-      }
-    } else {
-      app.route({
-        method: route.method,
-        url: fastifyPath,
-        handler,
-        config
-      });
-    }
-  }
-  async registerCustomApiRoutes() {
-    if (!await this.buildCustomRouteHandler()) return;
-    const routes = this.customApiRoutes ?? this.mastra.getServer()?.apiRoutes ?? [];
-    for (const route of routes) {
-      const serverRoute = {
-        method: route.method,
-        path: route.path,
-        responseType: "json",
-        handler: async () => {
-        },
-        requiresAuth: route.requiresAuth,
-        requiresPermission: route.requiresPermission,
-        fga: route.fga
-      };
-      const fastifyHandler = async (request, reply) => {
-        const authError = await this.checkRouteAuth(serverRoute, {
-          path: String(request.url.split("?")[0] || "/"),
-          method: String(request.method || "GET"),
-          getHeader: (name) => request.headers[name.toLowerCase()],
-          getQuery: (name) => request.query[name],
-          requestContext: request.requestContext,
-          request: toWebRequest2(request),
-          buildAuthorizeContext: () => toWebRequest2(request)
-        });
-        if (authError) {
-          if (authError.headers) {
-            for (const [key, value] of Object.entries(authError.headers)) {
-              void reply.header(key, value);
-            }
-          }
-          if (authError.error) {
-            return reply.status(authError.status).send({ error: authError.error });
-          }
-        }
-        const requestContext = request.requestContext;
-        const hasAuth = this.mastra.getStudio?.()?.auth || this.mastra.getServer()?.auth;
-        if (hasAuth) {
-          let hasPermission;
-          try {
-            ({ hasPermission } = await import('@mastra/core/auth/ee'));
-          } catch {
-            console.error(
-              "[@mastra/fastify] Auth features require @mastra/core >= 1.6.0. Please upgrade: npm install @mastra/core@latest"
-            );
-          }
-          if (hasPermission) {
-            const userPermissions = requestContext.get("mastra__userPermissions");
-            const permissionError = this.checkRoutePermission(
-              serverRoute,
-              userPermissions,
-              hasPermission,
-              requestContext
-            );
-            if (permissionError) {
-              return reply.status(permissionError.status).send({
-                error: permissionError.error,
-                message: permissionError.message
-              });
-            }
-          }
-        }
-        const fgaError = await serverAdapter.checkRouteFGA(this.mastra, serverRoute, requestContext, {
-          ...request.params,
-          ...request.query,
-          ...typeof request.body === "object" && request.body !== null ? request.body : {}
-        });
-        if (fgaError) {
-          return reply.status(fgaError.status).send({ error: fgaError.error, message: fgaError.message });
-        }
-        const response = await this.handleCustomRouteRequest(
-          `http://${request.headers.host}${request.url}`,
-          request.method,
-          request.headers,
-          request.body,
-          request.requestContext,
-          request.abortSignal
-        );
-        if (!response) {
-          reply.status(404).send({ error: "Not Found" });
-          return;
-        }
-        const existingHeaders = reply.getHeaders();
-        for (const [key, value] of Object.entries(existingHeaders)) {
-          if (value === void 0) continue;
-          const lowerKey = key.toLowerCase();
-          if (lowerKey === "content-length" || lowerKey === "transfer-encoding") continue;
-          const isSetCookie = lowerKey === "set-cookie";
-          if (!isSetCookie && response.headers.has(key)) continue;
-          if (Array.isArray(value)) {
-            for (const item of value) response.headers.append(key, String(item));
-          } else if (isSetCookie) {
-            response.headers.append(key, String(value));
-          } else {
-            response.headers.set(key, String(value));
-          }
-        }
-        reply.hijack();
-        await this.writeCustomRouteResponse(response, reply.raw, request.abortSignal);
-      };
-      if (route.method === "ALL") {
-        const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
-        for (const method of methods) {
-          this.app.route({ method, url: route.path, handler: fastifyHandler });
-        }
-      } else {
-        this.app.route({
-          method: route.method,
-          url: route.path,
-          handler: fastifyHandler
-        });
-      }
-    }
-  }
-  registerContextMiddleware() {
-    this.app.removeContentTypeParser("application/json");
-    this.app.addContentTypeParser("application/json", { parseAs: "string" }, (_request, body, done) => {
-      try {
-        if (!body || typeof body === "string" && body.trim() === "") {
-          done(null, void 0);
-          return;
-        }
-        const parsed = JSON.parse(body);
-        done(null, parsed);
-      } catch (err) {
-        done(err, void 0);
-      }
-    });
-    this.app.addContentTypeParser("multipart/form-data", (_request, _payload, done) => {
-      done(null, void 0);
-    });
-    this.app.addHook("preHandler", this.createContextMiddleware());
-  }
-  registerAuthMiddleware() {
-  }
-  registerHttpLoggingMiddleware() {
-    if (!this.httpLoggingConfig?.enabled) {
-      return;
-    }
-    this.app.addHook("onRequest", async (request, reply) => {
-      const urlPath = request.url.split("?")[0];
-      if (!this.shouldLogRequest(urlPath)) {
-        return;
-      }
-      const start = Date.now();
-      const method = request.method;
-      const path = urlPath;
-      reply.raw.once("finish", () => {
-        const duration = Date.now() - start;
-        const status = reply.statusCode;
-        const level = this.httpLoggingConfig?.level || "info";
-        const logData = {
-          method,
-          path,
-          status,
-          duration: `${duration}ms`
-        };
-        if (this.httpLoggingConfig?.includeQueryParams) {
-          logData.query = request.query;
-        }
-        if (this.httpLoggingConfig?.includeHeaders) {
-          const headers = { ...request.headers };
-          const redactHeaders = this.httpLoggingConfig.redactHeaders || [];
-          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);
-      });
-    });
-  }
+var MastraServer = class extends _mastra_server_server_adapter.MastraServer {
+	createContextMiddleware() {
+		return async (request, reply) => {
+			let bodyRequestContext;
+			let paramsRequestContext;
+			if (request.method === "POST" || request.method === "PUT") {
+				if (request.headers["content-type"]?.includes("application/json") && request.body) {
+					const body = request.body;
+					if (body.requestContext) bodyRequestContext = body.requestContext;
+				}
+			}
+			if (request.method === "GET") try {
+				const encodedRequestContext = request.query.requestContext;
+				if (typeof encodedRequestContext === "string") 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) => {
+					const value = request.headers[name.toLowerCase()];
+					return Array.isArray(value) ? value[0] : value;
+				}
+			});
+			request.requestContext = requestContext;
+			request.mastra = this.mastra;
+			request.registeredTools = this.tools || {};
+			if (this.taskStore) request.taskStore = this.taskStore;
+			request.customRouteAuthConfig = this.customRouteAuthConfig;
+			const controller = new AbortController();
+			request.raw.on("close", () => {
+				if (isRequestAborted(request.raw)) controller.abort();
+			});
+			reply.raw.on("close", () => {
+				if (!reply.raw.writableEnded) controller.abort();
+			});
+			request.abortSignal = controller.signal;
+		};
+	}
+	async stream(route, reply, result, request) {
+		const rawHeaders = reply.getHeaders();
+		const existingHeaders = {};
+		for (const [key, value] of Object.entries(rawHeaders)) {
+			if (value === void 0) continue;
+			const lowerKey = key.toLowerCase();
+			if (lowerKey === "content-length" || lowerKey === "transfer-encoding") continue;
+			existingHeaders[key] = value;
+		}
+		reply.hijack();
+		const streamFormat = route.streamFormat || "stream";
+		const sseHeaders = streamFormat === "sse" ? {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			"X-Accel-Buffering": "no"
+		} : { "Content-Type": "text/plain" };
+		reply.raw.writeHead(200, {
+			...existingHeaders,
+			...sseHeaders,
+			"Transfer-Encoding": "chunked"
+		});
+		if (streamFormat === "sse" && route.sseFlushOnConnect) reply.raw.write(": connected\n\n");
+		const reader = (result instanceof ReadableStream ? result : result.fullStream).getReader();
+		let readerCanceled = false;
+		const cancelReader = (reason) => {
+			if (readerCanceled) return;
+			readerCanceled = true;
+			reader.cancel(reason);
+		};
+		const cancelReaderOnResponseClose = () => cancelReader("request aborted");
+		const cancelReaderOnRequestClose = () => {
+			if (request && isRequestAborted(request.raw)) cancelReader("request aborted");
+		};
+		reply.raw.on("close", cancelReaderOnResponseClose);
+		request?.raw.on("close", cancelReaderOnRequestClose);
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				if (value) {
+					if (streamFormat === "sse" && typeof value === "string" && value.startsWith(":")) {
+						reply.raw.write(value);
+						continue;
+					}
+					const outputValue = this.streamOptions?.redact ?? true ? (0, _mastra_server_server_adapter.redactStreamChunk)(value) : value;
+					const serialized = (0, _mastra_server_server_adapter.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") reply.raw.write(`data: ${serialized.json}\n\n`);
+					else reply.raw.write(serialized.json + "");
+				}
+			}
+		} catch (error) {
+			this.mastra.getLogger()?.error("Error in stream processing", { error: error instanceof Error ? {
+				message: error.message,
+				stack: error.stack
+			} : error });
+		} finally {
+			reply.raw.off("close", cancelReaderOnResponseClose);
+			request?.raw.off("close", cancelReaderOnRequestClose);
+			if (!reply.raw.writableEnded && !reply.raw.destroyed) reply.raw.end();
+		}
+	}
+	async getParams(route, request) {
+		const urlParams = request.params || {};
+		const queryParams = (0, _mastra_server_server_adapter.normalizeQueryParams)(request.query || {});
+		let body;
+		let bodyParseError;
+		if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH" || route.method === "DELETE") if ((request.headers["content-type"] || "").includes("multipart/form-data")) try {
+			const maxFileSize = route.maxBodySize ?? this.bodyLimitOptions?.maxSize;
+			body = await this.parseMultipartFormData(request, maxFileSize);
+		} 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 body = request.body;
+		return {
+			urlParams,
+			queryParams,
+			body,
+			bodyParseError
+		};
+	}
+	/**
+	* Parse multipart/form-data using @fastify/busboy.
+	* Converts file uploads to Buffers and parses JSON field values.
+	*
+	* @param request - The Fastify request object
+	* @param maxFileSize - Optional maximum file size in bytes
+	*/
+	parseMultipartFormData(request, maxFileSize) {
+		return new Promise((resolve, reject) => {
+			const result = {};
+			const busboy = new _fastify_busboy.Busboy({
+				headers: { "content-type": request.headers["content-type"] },
+				limits: maxFileSize ? { fileSize: maxFileSize } : void 0
+			});
+			busboy.on("file", (fieldname, file, _filename, _encoding, _mimetype) => {
+				const chunks = [];
+				let limitExceeded = false;
+				file.on("data", (chunk) => {
+					chunks.push(chunk);
+				});
+				file.on("limit", () => {
+					limitExceeded = true;
+					file.resume();
+					reject(/* @__PURE__ */ new Error(`File size limit exceeded${maxFileSize ? ` (max: ${maxFileSize} bytes)` : ""}`));
+				});
+				file.on("end", () => {
+					if (!limitExceeded) result[fieldname] = Buffer.concat(chunks);
+				});
+			});
+			busboy.on("field", (fieldname, value) => {
+				try {
+					result[fieldname] = JSON.parse(value);
+				} catch {
+					result[fieldname] = value;
+				}
+			});
+			busboy.on("finish", () => {
+				resolve(result);
+			});
+			busboy.on("error", (error) => {
+				reject(error);
+			});
+			request.raw.pipe(busboy);
+		});
+	}
+	async sendResponse(route, reply, result, request, prefix) {
+		const resolvedPrefix = prefix ?? this.prefix ?? "";
+		if (result && typeof result === "object" && "__refreshHeaders" in result) {
+			const refreshHeaders = result.__refreshHeaders;
+			for (const [key, value] of Object.entries(refreshHeaders)) reply.header(key, value);
+			delete result.__refreshHeaders;
+		}
+		if (route.responseType === "json") await reply.send(result);
+		else if (route.responseType === "stream") await this.stream(route, reply, result, request);
+		else if (route.responseType === "datastream-response") {
+			const fetchResponse = result;
+			fetchResponse.headers.forEach((value, key) => reply.header(key, value));
+			reply.status(fetchResponse.status);
+			if (fetchResponse.body) {
+				const reader = fetchResponse.body.getReader();
+				let readerCanceled = false;
+				const cancelReader = (reason) => {
+					if (readerCanceled) return;
+					readerCanceled = true;
+					reader.cancel(reason);
+				};
+				const cancelReaderOnResponseClose = () => cancelReader("request aborted");
+				const cancelReaderOnRequestClose = () => {
+					if (request && isRequestAborted(request.raw)) cancelReader("request aborted");
+				};
+				const onResError = (err) => {
+					this.mastra.getLogger()?.error("Error writing datastream response", { error: err instanceof Error ? {
+						message: err.message,
+						stack: err.stack
+					} : err });
+					cancelReader("response write error");
+				};
+				reply.raw.once("error", onResError);
+				reply.raw.on("close", cancelReaderOnResponseClose);
+				request?.raw.on("close", cancelReaderOnRequestClose);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						reply.raw.write(value);
+					}
+				} catch (error) {
+					this.mastra.getLogger()?.error("Error in datastream processing", { error: error instanceof Error ? {
+						message: error.message,
+						stack: error.stack
+					} : error });
+				} finally {
+					reply.raw.off("error", onResError);
+					reply.raw.off("close", cancelReaderOnResponseClose);
+					request?.raw.off("close", cancelReaderOnRequestClose);
+					if (!reply.raw.writableEnded && !reply.raw.destroyed) reply.raw.end();
+				}
+			} else reply.raw.end();
+		} else if (route.responseType === "mcp-http") {
+			if (!request) {
+				await reply.status(500).send({ error: "Request object required for MCP transport" });
+				return;
+			}
+			const { server, httpPath, mcpOptions: routeMcpOptions } = result;
+			try {
+				reply.hijack();
+				const rawReq = request.raw;
+				if (request.body !== void 0) rawReq.body = request.body;
+				const options = {
+					...this.mcpOptions,
+					...routeMcpOptions
+				};
+				await server.startHTTP({
+					url: new URL(request.url, `http://${request.headers.host}`),
+					httpPath: `${resolvedPrefix}${httpPath}`,
+					req: rawReq,
+					res: reply.raw,
+					options: Object.keys(options).length > 0 ? options : void 0
+				});
+			} catch {
+				if (!reply.raw.headersSent) {
+					reply.raw.writeHead(500, { "Content-Type": "application/json" });
+					reply.raw.end(JSON.stringify({
+						jsonrpc: "2.0",
+						error: {
+							code: -32603,
+							message: "Internal server error"
+						},
+						id: null
+					}));
+				}
+			}
+		} else if (route.responseType === "mcp-sse") {
+			if (!request) {
+				await reply.status(500).send({ error: "Request object required for MCP transport" });
+				return;
+			}
+			const { server, ssePath, messagePath } = result;
+			try {
+				reply.hijack();
+				const rawReq = request.raw;
+				if (request.body !== void 0) rawReq.body = request.body;
+				await server.startSSE({
+					url: new URL(request.url, `http://${request.headers.host}`),
+					ssePath: `${resolvedPrefix}${ssePath}`,
+					messagePath: `${resolvedPrefix}${messagePath}`,
+					req: rawReq,
+					res: reply.raw
+				});
+			} catch {
+				if (!reply.raw.headersSent) {
+					reply.raw.writeHead(500, { "Content-Type": "application/json" });
+					reply.raw.end(JSON.stringify({ error: "Error handling MCP SSE request" }));
+				}
+			}
+		} else reply.status(500);
+	}
+	async registerRoute(app, route, { prefix: prefixParam } = {}) {
+		const prefix = prefixParam ?? this.prefix ?? "";
+		const fastifyPath = `${prefix}${route.path}`;
+		const handler = async (request, reply) => {
+			const authError = await this.checkRouteAuth(route, {
+				path: String(request.url.split("?")[0] || "/"),
+				method: String(request.method || "GET"),
+				getHeader: (name) => request.headers[name.toLowerCase()],
+				getQuery: (name) => request.query[name],
+				requestContext: request.requestContext,
+				request: toWebRequest(request),
+				buildAuthorizeContext: () => toWebRequest(request)
+			});
+			if (authError) {
+				if (authError.headers) for (const [key, value] of Object.entries(authError.headers)) reply.header(key, value);
+				if (authError.error) return reply.status(authError.status).send({ error: authError.error });
+			}
+			const params = await this.getParams(route, request);
+			if (params.bodyParseError) return reply.status(400).send({
+				error: "Invalid request body",
+				issues: [{
+					field: "body",
+					message: params.bodyParseError.message
+				}]
+			});
+			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 ((0, _mastra_server_server_adapter.isZodError)(error)) {
+					const { status, body } = this.resolveValidationError(route, error, "query");
+					return reply.status(status).send(body);
+				}
+				return reply.status(400).send({
+					error: "Invalid query parameters",
+					issues: [{
+						field: "unknown",
+						message: error instanceof Error ? error.message : "Unknown error"
+					}]
+				});
+			}
+			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 ((0, _mastra_server_server_adapter.isZodError)(error)) {
+					const { status, body } = this.resolveValidationError(route, error, "body");
+					return reply.status(status).send(body);
+				}
+				return reply.status(400).send({
+					error: "Invalid request body",
+					issues: [{
+						field: "unknown",
+						message: error instanceof Error ? error.message : "Unknown error"
+					}]
+				});
+			}
+			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 ((0, _mastra_server_server_adapter.isZodError)(error)) {
+					const { status, body } = this.resolveValidationError(route, error, "path");
+					return reply.status(status).send(body);
+				}
+				return reply.status(400).send({
+					error: "Invalid path parameters",
+					issues: [{
+						field: "unknown",
+						message: error instanceof Error ? error.message : "Unknown error"
+					}]
+				});
+			}
+			const handlerParams = {
+				...params.urlParams,
+				...params.queryParams,
+				...typeof params.body === "object" ? params.body : {},
+				requestContext: request.requestContext,
+				mastra: this.mastra,
+				registeredTools: request.registeredTools,
+				taskStore: request.taskStore,
+				abortSignal: request.abortSignal,
+				routePrefix: prefix,
+				request: toWebRequest(request)
+			};
+			const requestContext = request.requestContext;
+			if (this.mastra.getStudio?.()?.auth || this.mastra.getServer()?.auth) {
+				const hasPermission = await loadHasPermission();
+				if (hasPermission) {
+					const userPermissions = requestContext.get("mastra__userPermissions");
+					const permissionError = this.checkRoutePermission(route, userPermissions, hasPermission, requestContext);
+					if (permissionError) return reply.status(permissionError.status).send({
+						error: permissionError.error,
+						message: permissionError.message
+					});
+				}
+			}
+			const fgaError = await (0, _mastra_server_server_adapter.checkRouteFGA)(this.mastra, route, requestContext, {
+				...params.urlParams,
+				...params.queryParams,
+				...typeof params.body === "object" ? params.body : {}
+			});
+			if (fgaError) return reply.status(fgaError.status).send({
+				error: fgaError.error,
+				message: fgaError.message
+			});
+			try {
+				const result = await route.handler(handlerParams);
+				await this.sendResponse(route, reply, result, request, prefix);
+			} catch (error) {
+				const httpStatus = error && typeof error === "object" && "status" in error ? error.status : void 0;
+				if (!(typeof httpStatus === "number" && httpStatus >= 400 && httpStatus < 500)) this.mastra.getLogger()?.error("Error calling handler", {
+					error: error instanceof Error ? {
+						message: error.message,
+						stack: error.stack
+					} : error,
+					path: route.path,
+					method: route.method
+				});
+				let status = 500;
+				if (error && typeof error === "object") {
+					if ("status" in error) status = error.status;
+					else if ("details" in error && error.details && typeof error.details === "object" && "status" in error.details) status = error.details.status;
+				}
+				await reply.status(status).send({ error: error instanceof Error ? error.message : "Unknown error" });
+			}
+		};
+		const shouldApplyBodyLimit = this.bodyLimitOptions && [
+			"POST",
+			"PUT",
+			"PATCH"
+		].includes(route.method.toUpperCase());
+		const maxSize = route.maxBodySize ?? this.bodyLimitOptions?.maxSize;
+		const config = shouldApplyBodyLimit && maxSize ? { bodyLimit: maxSize } : void 0;
+		if (route.method.toUpperCase() === "ALL") for (const method of [
+			"GET",
+			"POST",
+			"PUT",
+			"DELETE",
+			"PATCH"
+		]) try {
+			app.route({
+				method,
+				url: fastifyPath,
+				handler,
+				config
+			});
+		} catch (err) {
+			if (err instanceof Error && err.message.includes("already declared")) continue;
+			throw err;
+		}
+		else app.route({
+			method: route.method,
+			url: fastifyPath,
+			handler,
+			config
+		});
+	}
+	async registerCustomApiRoutes() {
+		if (!await this.buildCustomRouteHandler()) return;
+		const routes = this.customApiRoutes ?? this.mastra.getServer()?.apiRoutes ?? [];
+		for (const route of routes) {
+			const serverRoute = {
+				method: route.method,
+				path: route.path,
+				responseType: "json",
+				handler: async () => {},
+				requiresAuth: route.requiresAuth,
+				requiresPermission: route.requiresPermission,
+				fga: route.fga
+			};
+			const fastifyHandler = async (request, reply) => {
+				const authError = await this.checkRouteAuth(serverRoute, {
+					path: String(request.url.split("?")[0] || "/"),
+					method: String(request.method || "GET"),
+					getHeader: (name) => request.headers[name.toLowerCase()],
+					getQuery: (name) => request.query[name],
+					requestContext: request.requestContext,
+					request: toWebRequest(request),
+					buildAuthorizeContext: () => toWebRequest(request)
+				});
+				if (authError) {
+					if (authError.headers) for (const [key, value] of Object.entries(authError.headers)) reply.header(key, value);
+					if (authError.error) return reply.status(authError.status).send({ error: authError.error });
+				}
+				const requestContext = request.requestContext;
+				if (this.mastra.getStudio?.()?.auth || this.mastra.getServer()?.auth) {
+					let hasPermission;
+					try {
+						({hasPermission} = await import("@mastra/core/auth/ee"));
+					} catch {
+						console.error("[@mastra/fastify] Auth features require @mastra/core >= 1.6.0. Please upgrade: npm install @mastra/core@latest");
+					}
+					if (hasPermission) {
+						const userPermissions = requestContext.get("mastra__userPermissions");
+						const permissionError = this.checkRoutePermission(serverRoute, userPermissions, hasPermission, requestContext);
+						if (permissionError) return reply.status(permissionError.status).send({
+							error: permissionError.error,
+							message: permissionError.message
+						});
+					}
+				}
+				const fgaError = await (0, _mastra_server_server_adapter.checkRouteFGA)(this.mastra, serverRoute, requestContext, {
+					...request.params,
+					...request.query,
+					...typeof request.body === "object" && request.body !== null ? request.body : {}
+				});
+				if (fgaError) return reply.status(fgaError.status).send({
+					error: fgaError.error,
+					message: fgaError.message
+				});
+				const response = await this.handleCustomRouteRequest(`http://${request.headers.host}${request.url}`, request.method, request.headers, request.body, request.requestContext, request.abortSignal);
+				if (!response) {
+					reply.status(404).send({ error: "Not Found" });
+					return;
+				}
+				const existingHeaders = reply.getHeaders();
+				for (const [key, value] of Object.entries(existingHeaders)) {
+					if (value === void 0) continue;
+					const lowerKey = key.toLowerCase();
+					if (lowerKey === "content-length" || lowerKey === "transfer-encoding") continue;
+					const isSetCookie = lowerKey === "set-cookie";
+					if (!isSetCookie && response.headers.has(key)) continue;
+					if (Array.isArray(value)) for (const item of value) response.headers.append(key, String(item));
+					else if (isSetCookie) response.headers.append(key, String(value));
+					else response.headers.set(key, String(value));
+				}
+				reply.hijack();
+				await this.writeCustomRouteResponse(response, reply.raw, request.abortSignal);
+			};
+			if (route.method === "ALL") for (const method of [
+				"GET",
+				"POST",
+				"PUT",
+				"DELETE",
+				"PATCH"
+			]) this.app.route({
+				method,
+				url: route.path,
+				handler: fastifyHandler
+			});
+			else this.app.route({
+				method: route.method,
+				url: route.path,
+				handler: fastifyHandler
+			});
+		}
+	}
+	registerContextMiddleware() {
+		this.app.removeContentTypeParser("application/json");
+		this.app.addContentTypeParser("application/json", { parseAs: "string" }, (_request, body, done) => {
+			try {
+				if (!body || typeof body === "string" && body.trim() === "") {
+					done(null, void 0);
+					return;
+				}
+				done(null, JSON.parse(body));
+			} catch (err) {
+				done(err, void 0);
+			}
+		});
+		this.app.addContentTypeParser("multipart/form-data", (_request, _payload, done) => {
+			done(null, void 0);
+		});
+		this.app.addHook("preHandler", this.createContextMiddleware());
+	}
+	registerAuthMiddleware() {}
+	registerHttpLoggingMiddleware() {
+		if (!this.httpLoggingConfig?.enabled) return;
+		this.app.addHook("onRequest", async (request, reply) => {
+			const urlPath = request.url.split("?")[0];
+			if (!this.shouldLogRequest(urlPath)) return;
+			const start = Date.now();
+			const method = request.method;
+			const path = urlPath;
+			reply.raw.once("finish", () => {
+				const duration = Date.now() - start;
+				const status = reply.statusCode;
+				const level = this.httpLoggingConfig?.level || "info";
+				const logData = {
+					method,
+					path,
+					status,
+					duration: `${duration}ms`
+				};
+				if (this.httpLoggingConfig?.includeQueryParams) logData.query = request.query;
+				if (this.httpLoggingConfig?.includeHeaders) {
+					const headers = { ...request.headers };
+					(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
 exports.MastraServer = MastraServer;
 exports.createAuthMiddleware = createAuthMiddleware;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map