@mastra/koa 1.6.11-alpha.0 → 1.6.11-alpha.2

package/dist/index.js

@@ -1,874 +1,773 @@
-import { Busboy } from '@fastify/busboy';
-import { coreAuthMiddleware, findMatchingCustomRoute, isProtectedCustomRoute } from '@mastra/server/auth';
-import { MastraServer as MastraServer$1, isZodError, checkRouteFGA, redactStreamChunk, serializeStreamChunk, normalizeQueryParams } from '@mastra/server/server-adapter';
-import { RequestContext } from '@mastra/core/request-context';
-
-// src/index.ts
-function toWebRequest(ctx) {
-  const protocol = ctx.protocol || "http";
-  const host = ctx.host || "localhost";
-  const url = `${protocol}://${host}${ctx.url}`;
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(ctx.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: ctx.method,
-    headers
-  });
+import { Busboy } from "@fastify/busboy";
+import { coreAuthMiddleware, findMatchingCustomRoute, isProtectedCustomRoute } from "@mastra/server/auth";
+import { MastraServer as MastraServer$1, checkRouteFGA, isZodError, normalizeQueryParams, redactStreamChunk, serializeStreamChunk } from "@mastra/server/server-adapter";
+import { RequestContext } from "@mastra/core/request-context";
+//#region src/auth-middleware.ts
+function toWebRequest$1(ctx) {
+	const url = `${ctx.protocol || "http"}://${ctx.host || "localhost"}${ctx.url}`;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(ctx.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: ctx.method,
+		headers
+	});
 }
 function createAuthMiddleware({ mastra, requiresAuth = true }) {
-  return async (ctx, next) => {
-    if (!requiresAuth) {
-      await next();
-      return;
-    }
-    const authConfig = mastra.getServer()?.auth;
-    if (!authConfig) {
-      await next();
-      return;
-    }
-    ctx.state.requestContext ??= new RequestContext();
-    ctx.state.mastra ??= mastra;
-    const path = String(ctx.path || "/");
-    const method = String(ctx.method || "GET");
-    const customRouteAuthConfig = new Map(ctx.state.customRouteAuthConfig ?? []);
-    customRouteAuthConfig.set(`${method}:${path}`, true);
-    const authHeader = ctx.headers.authorization;
-    let token = authHeader ? authHeader.replace("Bearer ", "") : null;
-    if (!token) {
-      token = ctx.query.apiKey || null;
-    }
-    const result = await coreAuthMiddleware({
-      path,
-      method,
-      getHeader: (name) => ctx.headers[name.toLowerCase()],
-      mastra,
-      authConfig,
-      customRouteAuthConfig,
-      requestContext: ctx.state.requestContext,
-      rawRequest: toWebRequest(ctx),
-      token,
-      buildAuthorizeContext: () => toWebRequest(ctx)
-    });
-    if (result.action === "next") {
-      await next();
-      return;
-    }
-    ctx.status = result.status;
-    ctx.body = result.body;
-  };
+	return async (ctx, next) => {
+		if (!requiresAuth) {
+			await next();
+			return;
+		}
+		const authConfig = mastra.getServer()?.auth;
+		if (!authConfig) {
+			await next();
+			return;
+		}
+		ctx.state.requestContext ??= new RequestContext();
+		ctx.state.mastra ??= mastra;
+		const path = String(ctx.path || "/");
+		const method = String(ctx.method || "GET");
+		const customRouteAuthConfig = new Map(ctx.state.customRouteAuthConfig ?? []);
+		customRouteAuthConfig.set(`${method}:${path}`, true);
+		const authHeader = ctx.headers.authorization;
+		let token = authHeader ? authHeader.replace("Bearer ", "") : null;
+		if (!token) token = ctx.query.apiKey || null;
+		const result = await coreAuthMiddleware({
+			path,
+			method,
+			getHeader: (name) => ctx.headers[name.toLowerCase()],
+			mastra,
+			authConfig,
+			customRouteAuthConfig,
+			requestContext: ctx.state.requestContext,
+			rawRequest: toWebRequest$1(ctx),
+			token,
+			buildAuthorizeContext: () => toWebRequest$1(ctx)
+		});
+		if (result.action === "next") {
+			await next();
+			return;
+		}
+		ctx.status = result.status;
+		ctx.body = 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/koa] 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/koa] Auth features require @mastra/core >= 1.6.0. Please upgrade: npm install @mastra/core@latest");
+	});
+	return _hasPermissionPromise;
 }
-function toWebRequest2(ctx) {
-  const protocol = ctx.protocol || "http";
-  const host = ctx.host || "localhost";
-  const url = `${protocol}://${host}${ctx.url}`;
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(ctx.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: ctx.method,
-    headers
-  });
+/**
+* Convert Koa context to Web API Request for cookie-based auth providers.
+*/
+function toWebRequest(ctx) {
+	const url = `${ctx.protocol || "http"}://${ctx.host || "localhost"}${ctx.url}`;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(ctx.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: ctx.method,
+		headers
+	});
 }
 var MastraServer = class extends MastraServer$1 {
-  activeRouteDispatchers = /* @__PURE__ */ new WeakMap();
-  async init() {
-    this.registerErrorMiddleware();
-    await super.init();
-  }
-  /**
-   * Register a global error-handling middleware at the top of the middleware chain.
-   * This acts as a safety net for errors that propagate past route handlers
-   * (e.g., from auth middleware, context middleware, or when route handlers re-throw).
-   *
-   * When `server.onError` is configured, calls it and uses the response.
-   * Otherwise provides a default JSON error response.
-   *
-   * Errors are emitted on the app for logging (Koa convention) but NOT re-thrown,
-   * so this middleware is the final error boundary. Users who need custom error handling
-   * should use `server.onError` or register their own middleware between this and the routes.
-   */
-  registerErrorMiddleware() {
-    const server = this;
-    this.app.use(async function mastraErrorBoundary(ctx, next) {
-      try {
-        await next();
-      } catch (err) {
-        if (await server.handleOnError(err, ctx)) {
-          return;
-        }
-        const error = err instanceof Error ? err : new Error(String(err));
-        let status = 500;
-        if (err && typeof err === "object") {
-          if ("status" in err) {
-            status = err.status;
-          } else if ("details" in err && err.details && typeof err.details === "object" && "status" in err.details) {
-            status = err.details.status;
-          }
-        }
-        ctx.status = status;
-        ctx.body = { error: error.message || "Unknown error" };
-        ctx.app.emit("error", err, ctx);
-      }
-    });
-  }
-  /**
-   * Try to handle an error using the `server.onError` hook.
-   * Creates a minimal context shim compatible with the Hono-style onError signature.
-   *
-   * @returns true if the error was handled and the response was set on ctx
-   */
-  async handleOnError(err, ctx) {
-    if (ctx._mastraOnErrorAttempted) return false;
-    ctx._mastraOnErrorAttempted = true;
-    const onError = this.mastra.getServer()?.onError;
-    if (!onError) return false;
-    const error = err instanceof Error ? err : new Error(String(err));
-    const shimContext = {
-      json: (data, status = 200) => new Response(JSON.stringify(data), {
-        status,
-        headers: { "Content-Type": "application/json" }
-      }),
-      req: {
-        path: ctx.path,
-        method: ctx.method,
-        header: (name) => {
-          const value = ctx.headers[name.toLowerCase()];
-          if (Array.isArray(value)) return value.join(", ");
-          return value;
-        },
-        url: ctx.url
-      }
-    };
-    try {
-      const response = await onError(error, shimContext);
-      ctx.status = response.status;
-      const contentType = response.headers.get("content-type") || "";
-      if (contentType.includes("application/json")) {
-        ctx.body = await response.json();
-      } else {
-        ctx.body = await response.text();
-      }
-      return true;
-    } catch (onErrorErr) {
-      this.mastra.getLogger()?.error("Error in custom onError handler", {
-        error: onErrorErr instanceof Error ? { message: onErrorErr.message, stack: onErrorErr.stack } : onErrorErr
-      });
-      return false;
-    }
-  }
-  createContextMiddleware() {
-    const server = this;
-    return async function mastraRequestContext(ctx, next) {
-      let bodyRequestContext;
-      let paramsRequestContext;
-      if (ctx.method === "POST" || ctx.method === "PUT") {
-        const contentType = ctx.headers["content-type"];
-        if (contentType?.includes("application/json") && ctx.request.body) {
-          const body = ctx.request.body;
-          if (body.requestContext) {
-            bodyRequestContext = body.requestContext;
-          }
-        }
-      }
-      if (ctx.method === "GET") {
-        try {
-          const query = ctx.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 = server.mergeRequestContext({ paramsRequestContext, bodyRequestContext });
-      server.applyRequestMetadataToContext({
-        requestContext,
-        getHeader: (name) => ctx.get(name)
-      });
-      ctx.state.requestContext = requestContext;
-      ctx.state.mastra = server.mastra;
-      ctx.state.tools = server.tools || {};
-      if (server.taskStore) {
-        ctx.state.taskStore = server.taskStore;
-      }
-      ctx.state.customRouteAuthConfig = server.customRouteAuthConfig;
-      const controller = new AbortController();
-      ctx.req.on("close", () => {
-        if (!ctx.res.writableEnded) {
-          controller.abort();
-        }
-      });
-      ctx.state.abortSignal = controller.signal;
-      await next();
-    };
-  }
-  getRouteDispatcherGroup(app) {
-    const middlewareStack = app.middleware;
-    const supportsReuse = Array.isArray(middlewareStack);
-    if (supportsReuse) {
-      const activeGroup = this.activeRouteDispatchers.get(app);
-      if (activeGroup && middlewareStack.length === activeGroup.stackLengthAfterRegistration) {
-        return activeGroup;
-      }
-    }
-    const group = {
-      routes: [],
-      stackLengthAfterRegistration: 0
-    };
-    app.use(this.createRouteDispatcherMiddleware(group));
-    if (supportsReuse) {
-      group.stackLengthAfterRegistration = app.middleware.length;
-      this.activeRouteDispatchers.set(app, group);
-    }
-    return group;
-  }
-  createRouteDispatcherMiddleware(group) {
-    const server = this;
-    return async function mastraRouteDispatcher(ctx, next) {
-      const matchedRoute = server.findRegisteredRoute(group.routes, ctx);
-      if (!matchedRoute) {
-        await next();
-        return;
-      }
-      await server.handleMatchedRoute(matchedRoute, ctx);
-    };
-  }
-  findRegisteredRoute(routes, ctx) {
-    const method = ctx.method.toUpperCase();
-    for (const registeredRoute of routes) {
-      if (registeredRoute.route.method.toUpperCase() !== "ALL" && method !== registeredRoute.route.method.toUpperCase()) {
-        continue;
-      }
-      const match = registeredRoute.pathRegex.exec(ctx.path);
-      if (!match) {
-        continue;
-      }
-      ctx.params = {};
-      registeredRoute.paramNames.forEach((name, index) => {
-        ctx.params[name] = match[index + 1];
-      });
-      return registeredRoute;
-    }
-    return void 0;
-  }
-  async handleMatchedRoute(registeredRoute, ctx) {
-    const { route, prefix } = registeredRoute;
-    const authError = await this.checkRouteAuth(route, {
-      path: String(ctx.path || "/"),
-      method: String(ctx.method || "GET"),
-      getHeader: (name) => ctx.headers[name.toLowerCase()],
-      getQuery: (name) => ctx.query[name],
-      requestContext: ctx.state.requestContext,
-      request: toWebRequest2(ctx),
-      buildAuthorizeContext: () => toWebRequest2(ctx)
-    });
-    if (authError) {
-      if (authError.headers) {
-        for (const [key, value] of Object.entries(authError.headers)) {
-          ctx.set(key, value);
-        }
-      }
-      if (authError.error) {
-        ctx.status = authError.status;
-        ctx.body = { error: authError.error };
-        return;
-      }
-    }
-    const params = await this.getParams(route, ctx);
-    if (params.bodyParseError) {
-      ctx.status = 400;
-      ctx.body = {
-        error: "Invalid request body",
-        issues: [{ field: "body", message: params.bodyParseError.message }]
-      };
-      return;
-    }
-    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 resolved = this.resolveValidationError(route, error, "query");
-          ctx.status = resolved.status;
-          ctx.body = resolved.body;
-          return;
-        }
-        ctx.status = 400;
-        ctx.body = {
-          error: "Invalid query parameters",
-          issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
-        };
-        return;
-      }
-    }
-    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 resolved = this.resolveValidationError(route, error, "body");
-          ctx.status = resolved.status;
-          ctx.body = resolved.body;
-          return;
-        }
-        ctx.status = 400;
-        ctx.body = {
-          error: "Invalid request body",
-          issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
-        };
-        return;
-      }
-    }
-    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 resolved = this.resolveValidationError(route, error, "path");
-          ctx.status = resolved.status;
-          ctx.body = resolved.body;
-          return;
-        }
-        ctx.status = 400;
-        ctx.body = {
-          error: "Invalid path parameters",
-          issues: [{ field: "unknown", message: error instanceof Error ? error.message : "Unknown error" }]
-        };
-        return;
-      }
-    }
-    const handlerParams = {
-      ...params.urlParams,
-      ...params.queryParams,
-      ...typeof params.body === "object" ? params.body : {},
-      requestContext: ctx.state.requestContext,
-      mastra: this.mastra,
-      tools: ctx.state.tools,
-      taskStore: ctx.state.taskStore,
-      abortSignal: ctx.state.abortSignal,
-      routePrefix: prefix,
-      request: toWebRequest2(ctx)
-    };
-    const requestContext = ctx.state.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) {
-          ctx.status = permissionError.status;
-          ctx.body = {
-            error: permissionError.error,
-            message: permissionError.message
-          };
-          return;
-        }
-      }
-    }
-    const fgaError = await checkRouteFGA(this.mastra, route, requestContext, {
-      ...params.urlParams,
-      ...params.queryParams,
-      ...typeof params.body === "object" ? params.body : {}
-    });
-    if (fgaError) {
-      ctx.status = fgaError.status;
-      ctx.body = { error: fgaError.error, message: fgaError.message };
-      return;
-    }
-    try {
-      const result = await route.handler(handlerParams);
-      await this.sendResponse(route, ctx, result, 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
-        });
-      }
-      if (error && typeof error === "object") {
-        if (!("status" in error)) {
-          if ("details" in error && error.details && typeof error.details === "object" && "status" in error.details) {
-            error.status = error.details.status;
-          }
-        }
-      }
-      if (await this.handleOnError(error, ctx)) {
-        return;
-      }
-      throw error;
-    }
-  }
-  async stream(route, ctx, result) {
-    ctx.respond = false;
-    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"
-    };
-    ctx.res.writeHead(200, {
-      ...sseHeaders,
-      "Transfer-Encoding": "chunked"
-    });
-    if (streamFormat === "sse" && route.sseFlushOnConnect) {
-      ctx.res.write(": connected\n\n");
-    }
-    const readableStream = result instanceof ReadableStream ? result : result.fullStream;
-    const reader = readableStream.getReader();
-    ctx.res.on("close", () => {
-      void reader.cancel("request aborted");
-    });
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        if (value) {
-          if (streamFormat === "sse" && typeof value === "string" && value.startsWith(":")) {
-            ctx.res.write(value);
-            continue;
-          }
-          const shouldRedact = this.streamOptions?.redact ?? true;
-          const outputValue = shouldRedact ? 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") {
-            ctx.res.write(`data: ${serialized.json}
-
-`);
-          } else {
-            ctx.res.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 {
-      ctx.res.end();
-    }
-  }
-  async getParams(route, ctx) {
-    const urlParams = ctx.params || {};
-    const queryParams = normalizeQueryParams(ctx.query || {});
-    let body;
-    let bodyParseError;
-    if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH" || route.method === "DELETE") {
-      const contentType = ctx.headers["content-type"] || "";
-      if (contentType.includes("multipart/form-data")) {
-        try {
-          const maxFileSize = route.maxBodySize ?? this.bodyLimitOptions?.maxSize;
-          body = await this.parseMultipartFormData(ctx, 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 = ctx.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 ctx - The Koa context object
-   * @param maxFileSize - Optional maximum file size in bytes
-   */
-  parseMultipartFormData(ctx, maxFileSize) {
-    return new Promise((resolve, reject) => {
-      const result = {};
-      const busboy = new Busboy({
-        headers: {
-          "content-type": ctx.headers["content-type"]
-        },
-        limits: maxFileSize ? { fileSize: maxFileSize } : void 0
-      });
-      busboy.on("file", (fieldname, file) => {
-        const chunks = [];
-        let limitExceeded = false;
-        file.on("data", (chunk) => {
-          chunks.push(chunk);
-        });
-        file.on("limit", () => {
-          limitExceeded = true;
-          reject(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);
-      });
-      ctx.req.pipe(busboy);
-    });
-  }
-  async sendResponse(route, ctx, result, 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)) {
-        ctx.set(key, value);
-      }
-      delete result.__refreshHeaders;
-    }
-    if (route.responseType === "json") {
-      ctx.type = "application/json";
-      ctx.body = result === null || result === void 0 ? JSON.stringify(null) : result;
-    } else if (route.responseType === "stream") {
-      await this.stream(route, ctx, result);
-    } else if (route.responseType === "datastream-response") {
-      ctx.respond = false;
-      const fetchResponse = result;
-      const headers = {};
-      fetchResponse.headers.forEach((value, key) => {
-        headers[key] = value;
-      });
-      ctx.res.writeHead(fetchResponse.status, headers);
-      if (fetchResponse.body) {
-        const reader = fetchResponse.body.getReader();
-        const onResError = (err) => {
-          this.mastra.getLogger()?.error("Error writing datastream response", {
-            error: err instanceof Error ? { message: err.message, stack: err.stack } : err
-          });
-          void reader.cancel("response write error");
-        };
-        ctx.res.once("error", onResError);
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            ctx.res.write(value);
-          }
-        } catch (error) {
-          this.mastra.getLogger()?.error("Error in datastream processing", {
-            error: error instanceof Error ? { message: error.message, stack: error.stack } : error
-          });
-        } finally {
-          ctx.res.off("error", onResError);
-          ctx.res.end();
-        }
-      } else {
-        ctx.res.end();
-      }
-    } else if (route.responseType === "mcp-http") {
-      ctx.respond = false;
-      const { server, httpPath, mcpOptions: routeMcpOptions } = result;
-      try {
-        const rawReq = ctx.req;
-        if (ctx.request.body !== void 0) {
-          rawReq.body = ctx.request.body;
-        }
-        const options = { ...this.mcpOptions, ...routeMcpOptions };
-        await server.startHTTP({
-          url: new URL(ctx.url, `http://${ctx.headers.host}`),
-          httpPath: `${resolvedPrefix}${httpPath}`,
-          req: rawReq,
-          res: ctx.res,
-          options: Object.keys(options).length > 0 ? options : void 0
-        });
-      } catch {
-        if (!ctx.res.headersSent) {
-          ctx.res.writeHead(500, { "Content-Type": "application/json" });
-          ctx.res.end(
-            JSON.stringify({
-              jsonrpc: "2.0",
-              error: { code: -32603, message: "Internal server error" },
-              id: null
-            })
-          );
-        }
-      }
-    } else if (route.responseType === "mcp-sse") {
-      ctx.respond = false;
-      const { server, ssePath, messagePath } = result;
-      try {
-        const rawReq = ctx.req;
-        if (ctx.request.body !== void 0) {
-          rawReq.body = ctx.request.body;
-        }
-        await server.startSSE({
-          url: new URL(ctx.url, `http://${ctx.headers.host}`),
-          ssePath: `${resolvedPrefix}${ssePath}`,
-          messagePath: `${resolvedPrefix}${messagePath}`,
-          req: rawReq,
-          res: ctx.res
-        });
-      } catch {
-        if (!ctx.res.headersSent) {
-          ctx.res.writeHead(500, { "Content-Type": "application/json" });
-          ctx.res.end(JSON.stringify({ error: "Error handling MCP SSE request" }));
-        }
-      }
-    } else {
-      ctx.status = 500;
-    }
-  }
-  async registerRoute(app, route, { prefix: prefixParam } = {}) {
-    const prefix = prefixParam ?? this.prefix ?? "";
-    const fullPath = `${prefix}${route.path}`;
-    const koaPath = fullPath;
-    const group = this.getRouteDispatcherGroup(app);
-    group.routes.push({
-      route,
-      prefix,
-      koaPath,
-      pathRegex: this.pathToRegex(koaPath),
-      paramNames: this.extractParamNames(koaPath)
-    });
-  }
-  /**
-   * Convert Express-style path to regex for matching
-   */
-  pathToRegex(path) {
-    const PARAM_PLACEHOLDER = "\0PARAM\0";
-    const pathWithPlaceholders = path.replace(/:[^/]+/g, PARAM_PLACEHOLDER);
-    const escapedPath = pathWithPlaceholders.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regexPath = escapedPath.replace(new RegExp(PARAM_PLACEHOLDER, "g"), "([^/]+)").replace(/\//g, "\\/");
-    return new RegExp(`^${regexPath}$`);
-  }
-  /**
-   * Extract parameter names from path
-   */
-  extractParamNames(path) {
-    const matches = path.match(/:[^/]+/g) || [];
-    return matches.map((m) => m.slice(1));
-  }
-  async registerCustomApiRoutes() {
-    if (!await this.buildCustomRouteHandler()) return;
-    const server = this;
-    this.app.use(async function mastraCustomRouteDispatcher(ctx, next) {
-      const path = String(ctx.path || "/");
-      const method = String(ctx.method || "GET");
-      const matchedRoute = findMatchingCustomRoute(
-        path,
-        method,
-        server.customApiRoutes ?? server.mastra.getServer()?.apiRoutes
-      );
-      const shouldRunCustomRouteAuth = isProtectedCustomRoute(path, method, server.customRouteAuthConfig);
-      const shouldRunCustomRouteFGA = !!matchedRoute?.route.fga;
-      const customRouteAbortController = new AbortController();
-      const abortCustomRoute = () => {
-        customRouteAbortController.abort();
-      };
-      const abortCustomRouteIfOpen = () => {
-        if (!ctx.res.writableEnded) {
-          abortCustomRoute();
-        }
-      };
-      ctx.res.once("close", abortCustomRouteIfOpen);
-      ctx.res.once("error", abortCustomRouteIfOpen);
-      try {
-        if (shouldRunCustomRouteAuth || shouldRunCustomRouteFGA) {
-          const serverRoute = {
-            method: matchedRoute?.route.method ?? method,
-            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 server.checkRouteAuth(serverRoute, {
-              path,
-              method,
-              getHeader: (name) => ctx.headers[name.toLowerCase()],
-              getQuery: (name) => ctx.query[name],
-              requestContext: ctx.state.requestContext,
-              request: toWebRequest2(ctx),
-              buildAuthorizeContext: () => toWebRequest2(ctx)
-            });
-            if (authError) {
-              if (authError.headers) {
-                for (const [key, value] of Object.entries(authError.headers)) {
-                  ctx.set(key, value);
-                }
-              }
-              if (authError.error) {
-                ctx.status = authError.status;
-                ctx.body = { error: authError.error };
-                return;
-              }
-            }
-          }
-          const requestContext = ctx.state.requestContext;
-          const hasAuth = server.mastra.getStudio?.()?.auth || server.mastra.getServer()?.auth;
-          if (hasAuth) {
-            const hasPermission = await loadHasPermission();
-            if (hasPermission) {
-              const userPermissions = requestContext.get("mastra__userPermissions");
-              const permissionError = server.checkRoutePermission(
-                serverRoute,
-                userPermissions,
-                hasPermission,
-                requestContext
-              );
-              if (permissionError) {
-                ctx.status = permissionError.status;
-                ctx.body = {
-                  error: permissionError.error,
-                  message: permissionError.message
-                };
-                return;
-              }
-            }
-          }
-          const fgaError = await checkRouteFGA(server.mastra, serverRoute, ctx.state.requestContext, {
-            ...matchedRoute?.params ?? {},
-            ...ctx.query,
-            ...typeof ctx.request.body === "object" && ctx.request.body !== null ? ctx.request.body : {}
-          });
-          if (fgaError) {
-            ctx.status = fgaError.status;
-            ctx.body = { error: fgaError.error, message: fgaError.message };
-            return;
-          }
-        }
-        const response = await server.handleCustomRouteRequest(
-          `${ctx.protocol}://${ctx.host}${ctx.originalUrl || ctx.url}`,
-          ctx.method,
-          ctx.headers,
-          ctx.request.body,
-          ctx.state.requestContext,
-          customRouteAbortController.signal
-        );
-        if (!response) return next();
-        ctx.respond = false;
-        await server.writeCustomRouteResponse(response, ctx.res, customRouteAbortController.signal);
-      } finally {
-        ctx.res.off("close", abortCustomRouteIfOpen);
-        ctx.res.off("error", abortCustomRouteIfOpen);
-      }
-    });
-  }
-  registerContextMiddleware() {
-    this.app.use(this.createContextMiddleware());
-  }
-  registerAuthMiddleware() {
-  }
-  registerHttpLoggingMiddleware() {
-    if (!this.httpLoggingConfig?.enabled) {
-      return;
-    }
-    const server = this;
-    this.app.use(async function mastraHttpLogger(ctx, next) {
-      if (!server.shouldLogRequest(ctx.path)) {
-        return next();
-      }
-      const start = Date.now();
-      const method = ctx.method;
-      const path = ctx.path;
-      await next();
-      const duration = Date.now() - start;
-      const status = ctx.status;
-      const level = server.httpLoggingConfig?.level || "info";
-      const logData = {
-        method,
-        path,
-        status,
-        duration: `${duration}ms`
-      };
-      if (server.httpLoggingConfig?.includeQueryParams) {
-        logData.query = ctx.query;
-      }
-      if (server.httpLoggingConfig?.includeHeaders) {
-        const headers = { ...ctx.headers };
-        const redactHeaders = server.httpLoggingConfig.redactHeaders || [];
-        redactHeaders.forEach((h) => {
-          const key = h.toLowerCase();
-          if (headers[key] !== void 0) {
-            headers[key] = "[REDACTED]";
-          }
-        });
-        logData.headers = headers;
-      }
-      server.logger[level](`${method} ${path} ${status} ${duration}ms`, logData);
-    });
-  }
+	activeRouteDispatchers = /* @__PURE__ */ new WeakMap();
+	async init() {
+		this.registerErrorMiddleware();
+		await super.init();
+	}
+	/**
+	* Register a global error-handling middleware at the top of the middleware chain.
+	* This acts as a safety net for errors that propagate past route handlers
+	* (e.g., from auth middleware, context middleware, or when route handlers re-throw).
+	*
+	* When `server.onError` is configured, calls it and uses the response.
+	* Otherwise provides a default JSON error response.
+	*
+	* Errors are emitted on the app for logging (Koa convention) but NOT re-thrown,
+	* so this middleware is the final error boundary. Users who need custom error handling
+	* should use `server.onError` or register their own middleware between this and the routes.
+	*/
+	registerErrorMiddleware() {
+		const server = this;
+		this.app.use(async function mastraErrorBoundary(ctx, next) {
+			try {
+				await next();
+			} catch (err) {
+				if (await server.handleOnError(err, ctx)) return;
+				const error = err instanceof Error ? err : new Error(String(err));
+				let status = 500;
+				if (err && typeof err === "object") {
+					if ("status" in err) status = err.status;
+					else if ("details" in err && err.details && typeof err.details === "object" && "status" in err.details) status = err.details.status;
+				}
+				ctx.status = status;
+				ctx.body = { error: error.message || "Unknown error" };
+				ctx.app.emit("error", err, ctx);
+			}
+		});
+	}
+	/**
+	* Try to handle an error using the `server.onError` hook.
+	* Creates a minimal context shim compatible with the Hono-style onError signature.
+	*
+	* @returns true if the error was handled and the response was set on ctx
+	*/
+	async handleOnError(err, ctx) {
+		if (ctx._mastraOnErrorAttempted) return false;
+		ctx._mastraOnErrorAttempted = true;
+		const onError = this.mastra.getServer()?.onError;
+		if (!onError) return false;
+		const error = err instanceof Error ? err : new Error(String(err));
+		const shimContext = {
+			json: (data, status = 200) => new Response(JSON.stringify(data), {
+				status,
+				headers: { "Content-Type": "application/json" }
+			}),
+			req: {
+				path: ctx.path,
+				method: ctx.method,
+				header: (name) => {
+					const value = ctx.headers[name.toLowerCase()];
+					if (Array.isArray(value)) return value.join(", ");
+					return value;
+				},
+				url: ctx.url
+			}
+		};
+		try {
+			const response = await onError(error, shimContext);
+			ctx.status = response.status;
+			if ((response.headers.get("content-type") || "").includes("application/json")) ctx.body = await response.json();
+			else ctx.body = await response.text();
+			return true;
+		} catch (onErrorErr) {
+			this.mastra.getLogger()?.error("Error in custom onError handler", { error: onErrorErr instanceof Error ? {
+				message: onErrorErr.message,
+				stack: onErrorErr.stack
+			} : onErrorErr });
+			return false;
+		}
+	}
+	createContextMiddleware() {
+		const server = this;
+		return async function mastraRequestContext(ctx, next) {
+			let bodyRequestContext;
+			let paramsRequestContext;
+			if (ctx.method === "POST" || ctx.method === "PUT") {
+				if (ctx.headers["content-type"]?.includes("application/json") && ctx.request.body) {
+					const body = ctx.request.body;
+					if (body.requestContext) bodyRequestContext = body.requestContext;
+				}
+			}
+			if (ctx.method === "GET") try {
+				const encodedRequestContext = ctx.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 = server.mergeRequestContext({
+				paramsRequestContext,
+				bodyRequestContext
+			});
+			server.applyRequestMetadataToContext({
+				requestContext,
+				getHeader: (name) => ctx.get(name)
+			});
+			ctx.state.requestContext = requestContext;
+			ctx.state.mastra = server.mastra;
+			ctx.state.tools = server.tools || {};
+			if (server.taskStore) ctx.state.taskStore = server.taskStore;
+			ctx.state.customRouteAuthConfig = server.customRouteAuthConfig;
+			const controller = new AbortController();
+			ctx.req.on("close", () => {
+				if (!ctx.res.writableEnded) controller.abort();
+			});
+			ctx.state.abortSignal = controller.signal;
+			await next();
+		};
+	}
+	getRouteDispatcherGroup(app) {
+		const middlewareStack = app.middleware;
+		const supportsReuse = Array.isArray(middlewareStack);
+		if (supportsReuse) {
+			const activeGroup = this.activeRouteDispatchers.get(app);
+			if (activeGroup && middlewareStack.length === activeGroup.stackLengthAfterRegistration) return activeGroup;
+		}
+		const group = {
+			routes: [],
+			stackLengthAfterRegistration: 0
+		};
+		app.use(this.createRouteDispatcherMiddleware(group));
+		if (supportsReuse) {
+			group.stackLengthAfterRegistration = app.middleware.length;
+			this.activeRouteDispatchers.set(app, group);
+		}
+		return group;
+	}
+	createRouteDispatcherMiddleware(group) {
+		const server = this;
+		return async function mastraRouteDispatcher(ctx, next) {
+			const matchedRoute = server.findRegisteredRoute(group.routes, ctx);
+			if (!matchedRoute) {
+				await next();
+				return;
+			}
+			await server.handleMatchedRoute(matchedRoute, ctx);
+		};
+	}
+	findRegisteredRoute(routes, ctx) {
+		const method = ctx.method.toUpperCase();
+		for (const registeredRoute of routes) {
+			if (registeredRoute.route.method.toUpperCase() !== "ALL" && method !== registeredRoute.route.method.toUpperCase()) continue;
+			const match = registeredRoute.pathRegex.exec(ctx.path);
+			if (!match) continue;
+			ctx.params = {};
+			registeredRoute.paramNames.forEach((name, index) => {
+				ctx.params[name] = match[index + 1];
+			});
+			return registeredRoute;
+		}
+	}
+	async handleMatchedRoute(registeredRoute, ctx) {
+		const { route, prefix } = registeredRoute;
+		const authError = await this.checkRouteAuth(route, {
+			path: String(ctx.path || "/"),
+			method: String(ctx.method || "GET"),
+			getHeader: (name) => ctx.headers[name.toLowerCase()],
+			getQuery: (name) => ctx.query[name],
+			requestContext: ctx.state.requestContext,
+			request: toWebRequest(ctx),
+			buildAuthorizeContext: () => toWebRequest(ctx)
+		});
+		if (authError) {
+			if (authError.headers) for (const [key, value] of Object.entries(authError.headers)) ctx.set(key, value);
+			if (authError.error) {
+				ctx.status = authError.status;
+				ctx.body = { error: authError.error };
+				return;
+			}
+		}
+		const params = await this.getParams(route, ctx);
+		if (params.bodyParseError) {
+			ctx.status = 400;
+			ctx.body = {
+				error: "Invalid request body",
+				issues: [{
+					field: "body",
+					message: params.bodyParseError.message
+				}]
+			};
+			return;
+		}
+		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 resolved = this.resolveValidationError(route, error, "query");
+				ctx.status = resolved.status;
+				ctx.body = resolved.body;
+				return;
+			}
+			ctx.status = 400;
+			ctx.body = {
+				error: "Invalid query parameters",
+				issues: [{
+					field: "unknown",
+					message: error instanceof Error ? error.message : "Unknown error"
+				}]
+			};
+			return;
+		}
+		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 resolved = this.resolveValidationError(route, error, "body");
+				ctx.status = resolved.status;
+				ctx.body = resolved.body;
+				return;
+			}
+			ctx.status = 400;
+			ctx.body = {
+				error: "Invalid request body",
+				issues: [{
+					field: "unknown",
+					message: error instanceof Error ? error.message : "Unknown error"
+				}]
+			};
+			return;
+		}
+		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 resolved = this.resolveValidationError(route, error, "path");
+				ctx.status = resolved.status;
+				ctx.body = resolved.body;
+				return;
+			}
+			ctx.status = 400;
+			ctx.body = {
+				error: "Invalid path parameters",
+				issues: [{
+					field: "unknown",
+					message: error instanceof Error ? error.message : "Unknown error"
+				}]
+			};
+			return;
+		}
+		const handlerParams = {
+			...params.urlParams,
+			...params.queryParams,
+			...typeof params.body === "object" ? params.body : {},
+			requestContext: ctx.state.requestContext,
+			mastra: this.mastra,
+			tools: ctx.state.tools,
+			taskStore: ctx.state.taskStore,
+			abortSignal: ctx.state.abortSignal,
+			routePrefix: prefix,
+			request: toWebRequest(ctx)
+		};
+		const requestContext = ctx.state.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) {
+					ctx.status = permissionError.status;
+					ctx.body = {
+						error: permissionError.error,
+						message: permissionError.message
+					};
+					return;
+				}
+			}
+		}
+		const fgaError = await checkRouteFGA(this.mastra, route, requestContext, {
+			...params.urlParams,
+			...params.queryParams,
+			...typeof params.body === "object" ? params.body : {}
+		});
+		if (fgaError) {
+			ctx.status = fgaError.status;
+			ctx.body = {
+				error: fgaError.error,
+				message: fgaError.message
+			};
+			return;
+		}
+		try {
+			const result = await route.handler(handlerParams);
+			await this.sendResponse(route, ctx, result, 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
+			});
+			if (error && typeof error === "object") {
+				if (!("status" in error)) {
+					if ("details" in error && error.details && typeof error.details === "object" && "status" in error.details) error.status = error.details.status;
+				}
+			}
+			if (await this.handleOnError(error, ctx)) return;
+			throw error;
+		}
+	}
+	async stream(route, ctx, result) {
+		ctx.respond = false;
+		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" };
+		ctx.res.writeHead(200, {
+			...sseHeaders,
+			"Transfer-Encoding": "chunked"
+		});
+		if (streamFormat === "sse" && route.sseFlushOnConnect) ctx.res.write(": connected\n\n");
+		const reader = (result instanceof ReadableStream ? result : result.fullStream).getReader();
+		ctx.res.on("close", () => {
+			reader.cancel("request aborted");
+		});
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				if (value) {
+					if (streamFormat === "sse" && typeof value === "string" && value.startsWith(":")) {
+						ctx.res.write(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") ctx.res.write(`data: ${serialized.json}\n\n`);
+					else ctx.res.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 {
+			ctx.res.end();
+		}
+	}
+	async getParams(route, ctx) {
+		const urlParams = ctx.params || {};
+		const queryParams = normalizeQueryParams(ctx.query || {});
+		let body;
+		let bodyParseError;
+		if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH" || route.method === "DELETE") if ((ctx.headers["content-type"] || "").includes("multipart/form-data")) try {
+			const maxFileSize = route.maxBodySize ?? this.bodyLimitOptions?.maxSize;
+			body = await this.parseMultipartFormData(ctx, 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 = ctx.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 ctx - The Koa context object
+	* @param maxFileSize - Optional maximum file size in bytes
+	*/
+	parseMultipartFormData(ctx, maxFileSize) {
+		return new Promise((resolve, reject) => {
+			const result = {};
+			const busboy = new Busboy({
+				headers: { "content-type": ctx.headers["content-type"] },
+				limits: maxFileSize ? { fileSize: maxFileSize } : void 0
+			});
+			busboy.on("file", (fieldname, file) => {
+				const chunks = [];
+				let limitExceeded = false;
+				file.on("data", (chunk) => {
+					chunks.push(chunk);
+				});
+				file.on("limit", () => {
+					limitExceeded = true;
+					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);
+			});
+			ctx.req.pipe(busboy);
+		});
+	}
+	async sendResponse(route, ctx, result, 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)) ctx.set(key, value);
+			delete result.__refreshHeaders;
+		}
+		if (route.responseType === "json") {
+			ctx.type = "application/json";
+			ctx.body = result === null || result === void 0 ? JSON.stringify(null) : result;
+		} else if (route.responseType === "stream") await this.stream(route, ctx, result);
+		else if (route.responseType === "datastream-response") {
+			ctx.respond = false;
+			const fetchResponse = result;
+			const headers = {};
+			fetchResponse.headers.forEach((value, key) => {
+				headers[key] = value;
+			});
+			ctx.res.writeHead(fetchResponse.status, headers);
+			if (fetchResponse.body) {
+				const reader = fetchResponse.body.getReader();
+				const onResError = (err) => {
+					this.mastra.getLogger()?.error("Error writing datastream response", { error: err instanceof Error ? {
+						message: err.message,
+						stack: err.stack
+					} : err });
+					reader.cancel("response write error");
+				};
+				ctx.res.once("error", onResError);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						ctx.res.write(value);
+					}
+				} catch (error) {
+					this.mastra.getLogger()?.error("Error in datastream processing", { error: error instanceof Error ? {
+						message: error.message,
+						stack: error.stack
+					} : error });
+				} finally {
+					ctx.res.off("error", onResError);
+					ctx.res.end();
+				}
+			} else ctx.res.end();
+		} else if (route.responseType === "mcp-http") {
+			ctx.respond = false;
+			const { server, httpPath, mcpOptions: routeMcpOptions } = result;
+			try {
+				const rawReq = ctx.req;
+				if (ctx.request.body !== void 0) rawReq.body = ctx.request.body;
+				const options = {
+					...this.mcpOptions,
+					...routeMcpOptions
+				};
+				await server.startHTTP({
+					url: new URL(ctx.url, `http://${ctx.headers.host}`),
+					httpPath: `${resolvedPrefix}${httpPath}`,
+					req: rawReq,
+					res: ctx.res,
+					options: Object.keys(options).length > 0 ? options : void 0
+				});
+			} catch {
+				if (!ctx.res.headersSent) {
+					ctx.res.writeHead(500, { "Content-Type": "application/json" });
+					ctx.res.end(JSON.stringify({
+						jsonrpc: "2.0",
+						error: {
+							code: -32603,
+							message: "Internal server error"
+						},
+						id: null
+					}));
+				}
+			}
+		} else if (route.responseType === "mcp-sse") {
+			ctx.respond = false;
+			const { server, ssePath, messagePath } = result;
+			try {
+				const rawReq = ctx.req;
+				if (ctx.request.body !== void 0) rawReq.body = ctx.request.body;
+				await server.startSSE({
+					url: new URL(ctx.url, `http://${ctx.headers.host}`),
+					ssePath: `${resolvedPrefix}${ssePath}`,
+					messagePath: `${resolvedPrefix}${messagePath}`,
+					req: rawReq,
+					res: ctx.res
+				});
+			} catch {
+				if (!ctx.res.headersSent) {
+					ctx.res.writeHead(500, { "Content-Type": "application/json" });
+					ctx.res.end(JSON.stringify({ error: "Error handling MCP SSE request" }));
+				}
+			}
+		} else ctx.status = 500;
+	}
+	async registerRoute(app, route, { prefix: prefixParam } = {}) {
+		const prefix = prefixParam ?? this.prefix ?? "";
+		const koaPath = `${prefix}${route.path}`;
+		this.getRouteDispatcherGroup(app).routes.push({
+			route,
+			prefix,
+			koaPath,
+			pathRegex: this.pathToRegex(koaPath),
+			paramNames: this.extractParamNames(koaPath)
+		});
+	}
+	/**
+	* Convert Express-style path to regex for matching
+	*/
+	pathToRegex(path) {
+		const PARAM_PLACEHOLDER = "\0PARAM\0";
+		const regexPath = path.replace(/:[^/]+/g, PARAM_PLACEHOLDER).replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(new RegExp(PARAM_PLACEHOLDER, "g"), "([^/]+)").replace(/\//g, "\\/");
+		return new RegExp(`^${regexPath}$`);
+	}
+	/**
+	* Extract parameter names from path
+	*/
+	extractParamNames(path) {
+		return (path.match(/:[^/]+/g) || []).map((m) => m.slice(1));
+	}
+	async registerCustomApiRoutes() {
+		if (!await this.buildCustomRouteHandler()) return;
+		const server = this;
+		this.app.use(async function mastraCustomRouteDispatcher(ctx, next) {
+			const path = String(ctx.path || "/");
+			const method = String(ctx.method || "GET");
+			const matchedRoute = findMatchingCustomRoute(path, method, server.customApiRoutes ?? server.mastra.getServer()?.apiRoutes);
+			const shouldRunCustomRouteAuth = isProtectedCustomRoute(path, method, server.customRouteAuthConfig);
+			const shouldRunCustomRouteFGA = !!matchedRoute?.route.fga;
+			const customRouteAbortController = new AbortController();
+			const abortCustomRoute = () => {
+				customRouteAbortController.abort();
+			};
+			const abortCustomRouteIfOpen = () => {
+				if (!ctx.res.writableEnded) abortCustomRoute();
+			};
+			ctx.res.once("close", abortCustomRouteIfOpen);
+			ctx.res.once("error", abortCustomRouteIfOpen);
+			try {
+				if (shouldRunCustomRouteAuth || shouldRunCustomRouteFGA) {
+					const serverRoute = {
+						method: matchedRoute?.route.method ?? method,
+						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 server.checkRouteAuth(serverRoute, {
+							path,
+							method,
+							getHeader: (name) => ctx.headers[name.toLowerCase()],
+							getQuery: (name) => ctx.query[name],
+							requestContext: ctx.state.requestContext,
+							request: toWebRequest(ctx),
+							buildAuthorizeContext: () => toWebRequest(ctx)
+						});
+						if (authError) {
+							if (authError.headers) for (const [key, value] of Object.entries(authError.headers)) ctx.set(key, value);
+							if (authError.error) {
+								ctx.status = authError.status;
+								ctx.body = { error: authError.error };
+								return;
+							}
+						}
+					}
+					const requestContext = ctx.state.requestContext;
+					if (server.mastra.getStudio?.()?.auth || server.mastra.getServer()?.auth) {
+						const hasPermission = await loadHasPermission();
+						if (hasPermission) {
+							const userPermissions = requestContext.get("mastra__userPermissions");
+							const permissionError = server.checkRoutePermission(serverRoute, userPermissions, hasPermission, requestContext);
+							if (permissionError) {
+								ctx.status = permissionError.status;
+								ctx.body = {
+									error: permissionError.error,
+									message: permissionError.message
+								};
+								return;
+							}
+						}
+					}
+					const fgaError = await checkRouteFGA(server.mastra, serverRoute, ctx.state.requestContext, {
+						...matchedRoute?.params ?? {},
+						...ctx.query,
+						...typeof ctx.request.body === "object" && ctx.request.body !== null ? ctx.request.body : {}
+					});
+					if (fgaError) {
+						ctx.status = fgaError.status;
+						ctx.body = {
+							error: fgaError.error,
+							message: fgaError.message
+						};
+						return;
+					}
+				}
+				const response = await server.handleCustomRouteRequest(`${ctx.protocol}://${ctx.host}${ctx.originalUrl || ctx.url}`, ctx.method, ctx.headers, ctx.request.body, ctx.state.requestContext, customRouteAbortController.signal);
+				if (!response) return next();
+				ctx.respond = false;
+				await server.writeCustomRouteResponse(response, ctx.res, customRouteAbortController.signal);
+			} finally {
+				ctx.res.off("close", abortCustomRouteIfOpen);
+				ctx.res.off("error", abortCustomRouteIfOpen);
+			}
+		});
+	}
+	registerContextMiddleware() {
+		this.app.use(this.createContextMiddleware());
+	}
+	registerAuthMiddleware() {}
+	registerHttpLoggingMiddleware() {
+		if (!this.httpLoggingConfig?.enabled) return;
+		const server = this;
+		this.app.use(async function mastraHttpLogger(ctx, next) {
+			if (!server.shouldLogRequest(ctx.path)) return next();
+			const start = Date.now();
+			const method = ctx.method;
+			const path = ctx.path;
+			await next();
+			const duration = Date.now() - start;
+			const status = ctx.status;
+			const level = server.httpLoggingConfig?.level || "info";
+			const logData = {
+				method,
+				path,
+				status,
+				duration: `${duration}ms`
+			};
+			if (server.httpLoggingConfig?.includeQueryParams) logData.query = ctx.query;
+			if (server.httpLoggingConfig?.includeHeaders) {
+				const headers = { ...ctx.headers };
+				(server.httpLoggingConfig.redactHeaders || []).forEach((h) => {
+					const key = h.toLowerCase();
+					if (headers[key] !== void 0) headers[key] = "[REDACTED]";
+				});
+				logData.headers = headers;
+			}
+			server.logger[level](`${method} ${path} ${status} ${duration}ms`, logData);
+		});
+	}
 };
-
+//#endregion
 export { MastraServer, createAuthMiddleware };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map