@mastra/koa 0.1.0-beta.15 → 0.1.0-beta.16

package/dist/index.cjs

@@ -0,0 +1,699 @@
+'use strict';
+
+var busboy = require('@fastify/busboy');
+var error = require('@mastra/server/handlers/error');
+var serverAdapter = require('@mastra/server/server-adapter');
+var auth = require('@mastra/server/auth');
+
+// src/index.ts
+
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
+var util;
+(function(util2) {
+  util2.assertEqual = (_) => {
+  };
+  function assertIs(_arg) {
+  }
+  util2.assertIs = assertIs;
+  function assertNever(_x) {
+    throw new Error();
+  }
+  util2.assertNever = assertNever;
+  util2.arrayToEnum = (items) => {
+    const obj = {};
+    for (const item of items) {
+      obj[item] = item;
+    }
+    return obj;
+  };
+  util2.getValidEnumValues = (obj) => {
+    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
+    }
+    return util2.objectValues(filtered);
+  };
+  util2.objectValues = (obj) => {
+    return util2.objectKeys(obj).map(function(e) {
+      return obj[e];
+    });
+  };
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+    const keys = [];
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  };
+  util2.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
+    }
+    return void 0;
+  };
+  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+  function joinValues(array, separator = " | ") {
+    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+  }
+  util2.joinValues = joinValues;
+  util2.jsonStringifyReplacer = (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  };
+})(util || (util = {}));
+var objectUtil;
+(function(objectUtil2) {
+  objectUtil2.mergeShapes = (first, second) => {
+    return {
+      ...first,
+      ...second
+      // second overwrites first
+    };
+  };
+})(objectUtil || (objectUtil = {}));
+util.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]);
+
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.js
+util.arrayToEnum([
+  "invalid_type",
+  "invalid_literal",
+  "custom",
+  "invalid_union",
+  "invalid_union_discriminator",
+  "invalid_enum_value",
+  "unrecognized_keys",
+  "invalid_arguments",
+  "invalid_return_type",
+  "invalid_date",
+  "invalid_string",
+  "too_small",
+  "too_big",
+  "invalid_intersection_types",
+  "not_multiple_of",
+  "not_finite"
+]);
+var ZodError = class _ZodError extends Error {
+  get errors() {
+    return this.issues;
+  }
+  constructor(issues) {
+    super();
+    this.issues = [];
+    this.addIssue = (sub) => {
+      this.issues = [...this.issues, sub];
+    };
+    this.addIssues = (subs = []) => {
+      this.issues = [...this.issues, ...subs];
+    };
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      this.__proto__ = actualProto;
+    }
+    this.name = "ZodError";
+    this.issues = issues;
+  }
+  format(_mapper) {
+    const mapper = _mapper || function(issue) {
+      return issue.message;
+    };
+    const fieldErrors = { _errors: [] };
+    const processError = (error) => {
+      for (const issue of error.issues) {
+        if (issue.code === "invalid_union") {
+          issue.unionErrors.map(processError);
+        } else if (issue.code === "invalid_return_type") {
+          processError(issue.returnTypeError);
+        } else if (issue.code === "invalid_arguments") {
+          processError(issue.argumentsError);
+        } else if (issue.path.length === 0) {
+          fieldErrors._errors.push(mapper(issue));
+        } else {
+          let curr = fieldErrors;
+          let i = 0;
+          while (i < issue.path.length) {
+            const el = issue.path[i];
+            const terminal = i === issue.path.length - 1;
+            if (!terminal) {
+              curr[el] = curr[el] || { _errors: [] };
+            } else {
+              curr[el] = curr[el] || { _errors: [] };
+              curr[el]._errors.push(mapper(issue));
+            }
+            curr = curr[el];
+            i++;
+          }
+        }
+      }
+    };
+    processError(this);
+    return fieldErrors;
+  }
+  static assert(value) {
+    if (!(value instanceof _ZodError)) {
+      throw new Error(`Not a ZodError: ${value}`);
+    }
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(mapper = (issue) => issue.message) {
+    const fieldErrors = {};
+    const formErrors = [];
+    for (const sub of this.issues) {
+      if (sub.path.length > 0) {
+        const firstEl = sub.path[0];
+        fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+        fieldErrors[firstEl].push(mapper(sub));
+      } else {
+        formErrors.push(mapper(sub));
+      }
+    }
+    return { formErrors, fieldErrors };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+};
+ZodError.create = (issues) => {
+  const error = new ZodError(issues);
+  return error;
+};
+var authenticationMiddleware = async (ctx, next) => {
+  const mastra = ctx.state.mastra;
+  const authConfig = mastra.getServer()?.auth;
+  const customRouteAuthConfig = ctx.state.customRouteAuthConfig;
+  if (!authConfig) {
+    return next();
+  }
+  const path = String(ctx.path || "/");
+  const method = String(ctx.method || "GET");
+  const getHeader = (name) => ctx.headers[name.toLowerCase()];
+  if (auth.isDevPlaygroundRequest(path, method, getHeader, authConfig)) {
+    return next();
+  }
+  if (!auth.isProtectedPath(path, method, authConfig, customRouteAuthConfig)) {
+    return next();
+  }
+  if (auth.canAccessPublicly(path, method, authConfig)) {
+    return next();
+  }
+  const authHeader = ctx.headers.authorization;
+  let token = authHeader ? authHeader.replace("Bearer ", "") : null;
+  const query = ctx.query;
+  if (!token && query.apiKey) {
+    token = query.apiKey || null;
+  }
+  if (!token) {
+    ctx.status = 401;
+    ctx.body = { error: "Authentication required" };
+    return;
+  }
+  try {
+    let user;
+    if (typeof authConfig.authenticateToken === "function") {
+      user = await authConfig.authenticateToken(token, ctx.request);
+    } else {
+      throw new Error("No token verification method configured");
+    }
+    if (!user) {
+      ctx.status = 401;
+      ctx.body = { error: "Invalid or expired token" };
+      return;
+    }
+    ctx.state.requestContext.set("user", user);
+    return next();
+  } catch (err) {
+    console.error(err);
+    ctx.status = 401;
+    ctx.body = { error: "Invalid or expired token" };
+    return;
+  }
+};
+var authorizationMiddleware = async (ctx, next) => {
+  const mastra = ctx.state.mastra;
+  const authConfig = mastra.getServer()?.auth;
+  const customRouteAuthConfig = ctx.state.customRouteAuthConfig;
+  if (!authConfig) {
+    return next();
+  }
+  const path = String(ctx.path || "/");
+  const method = String(ctx.method || "GET");
+  const getHeader = (name) => ctx.headers[name.toLowerCase()];
+  if (auth.isDevPlaygroundRequest(path, method, getHeader, authConfig)) {
+    return next();
+  }
+  if (!auth.isProtectedPath(path, method, authConfig, customRouteAuthConfig)) {
+    return next();
+  }
+  if (auth.canAccessPublicly(path, method, authConfig)) {
+    return next();
+  }
+  const user = ctx.state.requestContext.get("user");
+  if ("authorizeUser" in authConfig && typeof authConfig.authorizeUser === "function") {
+    try {
+      const isAuthorized = await authConfig.authorizeUser(user, ctx.request);
+      if (isAuthorized) {
+        return next();
+      }
+      ctx.status = 403;
+      ctx.body = { error: "Access denied" };
+      return;
+    } catch (err) {
+      console.error(err);
+      ctx.status = 500;
+      ctx.body = { error: "Authorization error" };
+      return;
+    }
+  }
+  if ("authorize" in authConfig && typeof authConfig.authorize === "function") {
+    try {
+      const context = {
+        get: (key) => {
+          if (key === "mastra") return ctx.state.mastra;
+          if (key === "requestContext") return ctx.state.requestContext;
+          if (key === "tools") return ctx.state.tools;
+          if (key === "taskStore") return ctx.state.taskStore;
+          if (key === "customRouteAuthConfig") return ctx.state.customRouteAuthConfig;
+          return void 0;
+        },
+        req: ctx.request
+      };
+      const isAuthorized = await authConfig.authorize(path, method, user, context);
+      if (isAuthorized) {
+        return next();
+      }
+      ctx.status = 403;
+      ctx.body = { error: "Access denied" };
+      return;
+    } catch (err) {
+      console.error(err);
+      ctx.status = 500;
+      ctx.body = { error: "Authorization error" };
+      return;
+    }
+  }
+  if ("rules" in authConfig && authConfig.rules && authConfig.rules.length > 0) {
+    const isAuthorized = await auth.checkRules(authConfig.rules, path, method, user);
+    if (isAuthorized) {
+      return next();
+    }
+    ctx.status = 403;
+    ctx.body = { error: "Access denied" };
+    return;
+  }
+  if (auth.defaultAuthConfig.rules && auth.defaultAuthConfig.rules.length > 0) {
+    const isAuthorized = await auth.checkRules(auth.defaultAuthConfig.rules, path, method, user);
+    if (isAuthorized) {
+      return next();
+    }
+  }
+  ctx.status = 403;
+  ctx.body = { error: "Access denied" };
+};
+
+// src/index.ts
+var MastraServer = class extends serverAdapter.MastraServer {
+  createContextMiddleware() {
+    return async (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 = this.mergeRequestContext({ paramsRequestContext, bodyRequestContext });
+      ctx.state.requestContext = requestContext;
+      ctx.state.mastra = this.mastra;
+      ctx.state.tools = this.tools || {};
+      if (this.taskStore) {
+        ctx.state.taskStore = this.taskStore;
+      }
+      ctx.state.customRouteAuthConfig = this.customRouteAuthConfig;
+      const controller = new AbortController();
+      ctx.req.on("close", () => {
+        if (!ctx.res.writableEnded) {
+          controller.abort();
+        }
+      });
+      ctx.state.abortSignal = controller.signal;
+      await next();
+    };
+  }
+  async stream(route, ctx, result) {
+    ctx.respond = false;
+    ctx.res.writeHead(200, {
+      "Content-Type": "text/plain",
+      "Transfer-Encoding": "chunked"
+    });
+    const streamFormat = route.streamFormat || "stream";
+    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) {
+          const shouldRedact = this.streamOptions?.redact ?? true;
+          const outputValue = shouldRedact ? serverAdapter.redactStreamChunk(value) : value;
+          if (streamFormat === "sse") {
+            ctx.res.write(`data: ${JSON.stringify(outputValue)}
+
+`);
+          } else {
+            ctx.res.write(JSON.stringify(outputValue) + "");
+          }
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    } finally {
+      ctx.res.end();
+    }
+  }
+  async getParams(route, ctx) {
+    const urlParams = ctx.params || {};
+    const queryParams = serverAdapter.normalizeQueryParams(ctx.query || {});
+    let body;
+    if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH") {
+      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) {
+          console.error("Failed to parse multipart form data:", error);
+          if (error instanceof Error && error.message.toLowerCase().includes("size")) {
+            throw error;
+          }
+        }
+      } else {
+        body = ctx.request.body;
+      }
+    }
+    return { urlParams, queryParams, body };
+  }
+  /**
+   * 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$1 = new busboy.Busboy({
+        headers: {
+          "content-type": ctx.headers["content-type"]
+        },
+        limits: maxFileSize ? { fileSize: maxFileSize } : void 0
+      });
+      busboy$1.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$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);
+      });
+      ctx.req.pipe(busboy$1);
+    });
+  }
+  async sendResponse(route, ctx, result) {
+    if (route.responseType === "json") {
+      ctx.body = 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();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            ctx.res.write(value);
+          }
+        } finally {
+          ctx.res.end();
+        }
+      } else {
+        ctx.res.end();
+      }
+    } else if (route.responseType === "mcp-http") {
+      ctx.respond = false;
+      const { server, httpPath } = result;
+      try {
+        const rawReq = ctx.req;
+        if (ctx.request.body !== void 0) {
+          rawReq.body = ctx.request.body;
+        }
+        await server.startHTTP({
+          url: new URL(ctx.url, `http://${ctx.headers.host}`),
+          httpPath,
+          req: rawReq,
+          res: ctx.res
+        });
+      } 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,
+          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 }) {
+    const fullPath = `${prefix}${route.path}`;
+    const koaPath = fullPath;
+    const handler = async (ctx, next) => {
+      const pathRegex = this.pathToRegex(koaPath);
+      const match = pathRegex.exec(ctx.path);
+      if (!match) {
+        await next();
+        return;
+      }
+      if (route.method.toUpperCase() !== "ALL" && ctx.method.toUpperCase() !== route.method.toUpperCase()) {
+        await next();
+        return;
+      }
+      const paramNames = this.extractParamNames(koaPath);
+      ctx.params = {};
+      paramNames.forEach((name, index) => {
+        ctx.params[name] = match[index + 1];
+      });
+      const params = await this.getParams(route, ctx);
+      if (params.queryParams) {
+        try {
+          params.queryParams = await this.parseQueryParams(route, params.queryParams);
+        } catch (error$1) {
+          console.error("Error parsing query params", error$1);
+          if (error$1 instanceof ZodError) {
+            ctx.status = 400;
+            ctx.body = error.formatZodError(error$1, "query parameters");
+            return;
+          }
+          ctx.status = 400;
+          ctx.body = {
+            error: "Invalid query parameters",
+            issues: [{ field: "unknown", message: error$1 instanceof Error ? error$1.message : "Unknown error" }]
+          };
+          return;
+        }
+      }
+      if (params.body) {
+        try {
+          params.body = await this.parseBody(route, params.body);
+        } catch (error$1) {
+          console.error("Error parsing body:", error$1 instanceof Error ? error$1.message : String(error$1));
+          if (error$1 instanceof ZodError) {
+            ctx.status = 400;
+            ctx.body = error.formatZodError(error$1, "request body");
+            return;
+          }
+          ctx.status = 400;
+          ctx.body = {
+            error: "Invalid request body",
+            issues: [{ field: "unknown", message: error$1 instanceof Error ? error$1.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
+      };
+      try {
+        const result = await route.handler(handlerParams);
+        await this.sendResponse(route, ctx, result);
+      } catch (error) {
+        console.error("Error calling handler", error);
+        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;
+          }
+        }
+        ctx.status = status;
+        ctx.body = { error: error instanceof Error ? error.message : "Unknown error" };
+      }
+    };
+    app.use(handler);
+  }
+  /**
+   * 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));
+  }
+  registerContextMiddleware() {
+    this.app.use(this.createContextMiddleware());
+  }
+  registerAuthMiddleware() {
+    const authConfig = this.mastra.getServer()?.auth;
+    if (!authConfig) {
+      return;
+    }
+    this.app.use(authenticationMiddleware);
+    this.app.use(authorizationMiddleware);
+  }
+};
+
+exports.MastraServer = MastraServer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map