@forklaunch/core 0.9.21 → 0.10.0

package/lib/http/index.js

@@ -45,6 +45,7 @@ __export(http_exports, {
   discriminateResponseBodies: () => discriminateResponseBodies,
   enrichExpressLikeSend: () => enrichExpressLikeSend,
   evaluateTelemetryOptions: () => evaluateTelemetryOptions,
+  generateMcpServer: () => generateMcpServer,
   generateSwaggerDocument: () => generateSwaggerDocument,
   get: () => get,
   getCodeForStatus: () => getCodeForStatus,
@@ -90,35 +91,8 @@ function cors(corsOptions) {
   };
 }
 
-// src/http/middleware/request/createContext.middleware.ts
-var import_api = require("@opentelemetry/api");
-var import_uuid = require("uuid");
-
-// src/http/telemetry/constants.ts
-var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
-var ATTR_API_NAME = "api.name";
-var ATTR_CORRELATION_ID = "correlation.id";
-
-// src/http/middleware/request/createContext.middleware.ts
-function createContext(schemaValidator) {
-  return function setContext(req, res, next) {
-    req.schemaValidator = schemaValidator;
-    let correlationId = (0, import_uuid.v4)();
-    if (req.headers["x-correlation-id"]) {
-      correlationId = req.headers["x-correlation-id"];
-    }
-    res.setHeader("x-correlation-id", correlationId);
-    req.context = {
-      correlationId
-    };
-    const span = import_api.trace.getActiveSpan();
-    if (span != null) {
-      req.context.span = span;
-      req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
-    }
-    next?.();
-  };
-}
+// src/http/router/expressLikeRouter.ts
+var import_common5 = require("@forklaunch/common");
 
 // src/http/guards/isForklaunchRouter.ts
 function isForklaunchRouter(maybeForklaunchRouter) {
@@ -138,7 +112,7 @@ function isExpressLikeSchemaHandler(middleware2) {
       (argumentName) => argumentName.toLowerCase()
     )
   );
-  return extractedArgumentNames && extractedArgumentNames.size <= 3;
+  return extractedArgumentNames && extractedArgumentNames.size <= 4;
 }
 
 // src/http/guards/isForklaunchExpressLikeRouter.ts
@@ -295,6 +269,36 @@ async function parseRequestAuth(req, res, next) {
   next?.();
 }
 
+// src/http/middleware/request/createContext.middleware.ts
+var import_api = require("@opentelemetry/api");
+var import_uuid = require("uuid");
+
+// src/http/telemetry/constants.ts
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var ATTR_API_NAME = "api.name";
+var ATTR_CORRELATION_ID = "correlation.id";
+
+// src/http/middleware/request/createContext.middleware.ts
+function createContext(schemaValidator) {
+  return function setContext(req, res, next) {
+    req.schemaValidator = schemaValidator;
+    let correlationId = (0, import_uuid.v4)();
+    if (req.headers["x-correlation-id"]) {
+      correlationId = req.headers["x-correlation-id"];
+    }
+    res.setHeader("x-correlation-id", correlationId);
+    req.context = {
+      correlationId
+    };
+    const span = import_api.trace.getActiveSpan();
+    if (span != null) {
+      req.context.span = span;
+      req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
+    }
+    next?.();
+  };
+}
+
 // src/http/middleware/request/enrichDetails.middleware.ts
 var import_common4 = require("@forklaunch/common");
 
@@ -546,7 +550,7 @@ function enrichDetails(path, contractDetails, requestSchema, responseSchemas, op
     req.requestSchema = requestSchema;
     res.responseSchemas = responseSchemas;
     req.openTelemetryCollector = openTelemetryCollector;
-    req.context.span?.setAttribute(ATTR_API_NAME, req.contractDetails?.name);
+    req.context?.span?.setAttribute(ATTR_API_NAME, req.contractDetails?.name);
     const startTime = process.hrtime();
     res.on("finish", () => {
       const [seconds, nanoseconds] = process.hrtime(startTime);
@@ -681,6 +685,12 @@ function discriminateBody(schemaValidator, body) {
       parserType: "text",
       schema: maybeTypedBody
     };
+  } else if (schemaValidator.openapi(maybeTypedBody).format === "binary") {
+    return {
+      contentType: "application/octet-stream",
+      parserType: "file",
+      schema: maybeTypedBody
+    };
   } else {
     return {
       contentType: "application/json",
@@ -732,6 +742,12 @@ function discriminateResponseBodies(schemaValidator, responses) {
           parserType: "text",
           schema: response
         };
+      } else if (schemaValidator.openapi(response).format === "binary") {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: "application/octet-stream",
+          parserType: "file",
+          schema: response
+        };
       } else {
         discriminatedResponses[Number(statusCode)] = {
           contentType: "application/json",
@@ -751,18 +767,38 @@ function discriminateResponseBodies(schemaValidator, responses) {
 }
 
 // src/http/router/expressLikeRouter.ts
-var ForklaunchExpressLikeRouter = class {
-  constructor(basePath, schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector) {
+var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
+  constructor(basePath, schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector, sdkName) {
+    this.basePath = basePath;
     this.schemaValidator = schemaValidator;
     this.internal = internal;
     this.postEnrichMiddleware = postEnrichMiddleware;
     this.openTelemetryCollector = openTelemetryCollector;
-    this.basePath = basePath;
+    this.sdkName = sdkName;
+    if (process.env.NODE_ENV !== "test" && !process.env.VITEST) {
+      process.on("uncaughtException", (err) => {
+        this.openTelemetryCollector.error(`Uncaught exception: ${err}`);
+        process.exit(1);
+      });
+      process.on("unhandledRejection", (reason) => {
+        this.openTelemetryCollector.error(`Unhandled rejection: ${reason}`);
+        process.exit(1);
+      });
+      process.on("exit", () => {
+        this.openTelemetryCollector.info("Shutting down application");
+      });
+      process.on("SIGINT", () => {
+        this.openTelemetryCollector.info("Shutting down application");
+        process.exit(0);
+      });
+    }
+    this.internal.use(createContext(this.schemaValidator));
   }
   requestHandler;
   routers = [];
   routes = [];
-  basePath;
+  fetchMap = {};
+  sdk = {};
   /**
    * Resolves middlewares based on the contract details.
    *
@@ -881,6 +917,20 @@ var ForklaunchExpressLikeRouter = class {
       responseSchemas
     };
   }
+  /**
+   * Fetches a route from the route map and executes it with the given parameters.
+   *
+   * @template Path - The path type that extends keyof fetchMap and string.
+   * @param {Path} path - The route path
+   * @param {Parameters<fetchMap[Path]>[1]} [requestInit] - Optional request initialization parameters.
+   * @returns {Promise<ReturnType<fetchMap[Path]>>} - The result of executing the route handler.
+   */
+  fetch = async (path, ...reqInit) => {
+    return this.fetchMap[path](
+      path,
+      reqInit[0]
+    );
+  };
   /**
    * Executes request locally, applying parameters
    *
@@ -900,24 +950,6 @@ var ForklaunchExpressLikeRouter = class {
         body: discriminateBody(this.schemaValidator, request?.body)?.schema ?? {},
         path: route
       };
-      function remapFileBody(body) {
-        if (body instanceof File) {
-          return (name, contentType) => {
-            return new File([body], name, { type: contentType });
-          };
-        }
-        Object.entries(body).forEach(([key, value]) => {
-          if (value instanceof File) {
-            body[key] = (name, contentType) => {
-              return new File([value], name, { type: contentType });
-            };
-          } else if (typeof value === "object") {
-            body[key] = remapFileBody(value);
-          }
-        });
-        return body;
-      }
-      req.body = remapFileBody(req.body);
       const res = {
         status: (code) => {
           statusCode = code;
@@ -971,24 +1003,20 @@ var ForklaunchExpressLikeRouter = class {
   registerRoute(method, path, registrationMethod, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareAndTypedHandler) {
     if (isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
       const { contractDetails, handlers } = contractDetailsOrMiddlewareOrTypedHandler;
-      return this.registerRoute(
-        method,
-        path,
-        registrationMethod,
-        contractDetails,
-        ...handlers
-      );
+      this.registerRoute(method, path, registrationMethod, contractDetails, ...handlers);
+      return this;
     } else {
       const maybeTypedHandler = middlewareOrMiddlewareAndTypedHandler[middlewareOrMiddlewareAndTypedHandler.length - 1];
       if (isTypedHandler(maybeTypedHandler)) {
         const { contractDetails, handlers } = maybeTypedHandler;
-        return this.registerRoute(
+        this.registerRoute(
           method,
           path,
           registrationMethod,
           contractDetails,
           ...middlewareOrMiddlewareAndTypedHandler.concat(handlers)
         );
+        return this;
       } else {
         if (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler) || isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
           throw new Error("Contract details are not defined");
@@ -1020,10 +1048,13 @@ var ForklaunchExpressLikeRouter = class {
           ).concat(handlers),
           this.#parseAndRunControllerHandler(controllerHandler)
         );
-        return this.#localParamRequest(
+        const localParamRequest = this.#localParamRequest(
           handlers,
           controllerHandler
         );
+        (0, import_common5.toRecord)(this.fetchMap)[(0, import_common5.sanitizePathSlashes)(`${this.basePath}${path}`)] = localParamRequest;
+        (0, import_common5.toRecord)(this.sdk)[(0, import_common5.toPrettyCamelCase)(contractDetails.name ?? this.basePath)] = (req) => localParamRequest(`${this.basePath}${path}`, req);
+        return this;
       }
     }
   }
@@ -1047,10 +1078,13 @@ var ForklaunchExpressLikeRouter = class {
     return this.#extractHandlers(handlers);
   }
   #extractNestableMiddlewareFromEnrichedTypedHandlerArray(handlers) {
-    return this.#extractHandlers(
-      handlers,
-      (handler) => isForklaunchExpressLikeRouter(handler) ? handler.internal : handler
-    );
+    return this.#extractHandlers(handlers, (handler) => {
+      if (isForklaunchExpressLikeRouter(handler)) {
+        this.addRouterToSdk(handler);
+        return handler.internal;
+      }
+      return handler;
+    });
   }
   #processTypedHandlerOrMiddleware(handler, middleware2) {
     if (isTypedHandler(handler)) {
@@ -1074,6 +1108,7 @@ var ForklaunchExpressLikeRouter = class {
       middleware2
     );
     if (isForklaunchExpressLikeRouter(contractDetailsOrMiddlewareOrTypedHandler)) {
+      this.addRouterToSdk(contractDetailsOrMiddlewareOrTypedHandler);
       middleware2.push(contractDetailsOrMiddlewareOrTypedHandler.internal);
     }
     middleware2.push(
@@ -1103,6 +1138,16 @@ var ForklaunchExpressLikeRouter = class {
     }
     return this;
   }
+  addRouterToSdk(router) {
+    Object.entries(router.fetchMap).map(
+      ([key, value]) => (0, import_common5.toRecord)(this.fetchMap)[(0, import_common5.sanitizePathSlashes)(`${this.basePath}${key}`)] = value
+    );
+    const existingSdk = this.sdk[router.sdkName ?? (0, import_common5.toPrettyCamelCase)(router.basePath)];
+    (0, import_common5.toRecord)(this.sdk)[router.sdkName ?? (0, import_common5.toPrettyCamelCase)(router.basePath)] = {
+      ...typeof existingSdk === "object" ? existingSdk : {},
+      ...router.sdk
+    };
+  }
   registerNestableMiddlewareHandler(registrationMethod, pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) {
     const middleware2 = [];
     let path;
@@ -1118,7 +1163,9 @@ var ForklaunchExpressLikeRouter = class {
       if (isConstrainedForklaunchRouter(
         pathOrContractDetailsOrMiddlewareOrTypedHandler
       )) {
-        path = pathOrContractDetailsOrMiddlewareOrTypedHandler.basePath;
+        const router = pathOrContractDetailsOrMiddlewareOrTypedHandler;
+        this.addRouterToSdk(router);
+        path = router.basePath;
       }
       middleware2.push(
         ...this.#extractNestableMiddlewareAsRouterHandlers(
@@ -1129,6 +1176,11 @@ var ForklaunchExpressLikeRouter = class {
         )
       );
     }
+    if (!path) {
+      path = middleware2.filter(
+        (m) => isForklaunchExpressLikeRouter(m)
+      )[0]?.basePath;
+    }
     if (path) {
       registrationMethod.bind(this.internal)(path, ...middleware2);
     } else {
@@ -1183,15 +1235,13 @@ var ForklaunchExpressLikeRouter = class {
    * @returns {ExpressRouter} - The Express router.
    */
   get = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-    return {
-      get: this.registerRoute(
-        "get",
-        path,
-        this.internal.get,
-        contractDetailsOrMiddlewareOrTypedHandler,
-        ...middlewareOrMiddlewareWithTypedHandler
-      )
-    };
+    return this.registerRoute(
+      "get",
+      path,
+      this.internal.get,
+      contractDetailsOrMiddlewareOrTypedHandler,
+      ...middlewareOrMiddlewareWithTypedHandler
+    );
   };
   /**
    * Registers a POST route with the specified contract details and handler handlers.
@@ -1207,15 +1257,13 @@ var ForklaunchExpressLikeRouter = class {
    * @returns {ExpressRouter} - The Expxwress router.
    */
   post = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-    return {
-      post: this.registerRoute(
-        "post",
-        path,
-        this.internal.post,
-        contractDetailsOrMiddlewareOrTypedHandler,
-        ...middlewareOrMiddlewareWithTypedHandler
-      )
-    };
+    return this.registerRoute(
+      "post",
+      path,
+      this.internal.post,
+      contractDetailsOrMiddlewareOrTypedHandler,
+      ...middlewareOrMiddlewareWithTypedHandler
+    );
   };
   /**
    * Registers a PUT route with the specified contract details and handler handlers.
@@ -1231,15 +1279,13 @@ var ForklaunchExpressLikeRouter = class {
    * @returns {ExpressRouter} - The Express router.
    */
   put = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-    return {
-      put: this.registerRoute(
-        "put",
-        path,
-        this.internal.put,
-        contractDetailsOrMiddlewareOrTypedHandler,
-        ...middlewareOrMiddlewareWithTypedHandler
-      )
-    };
+    return this.registerRoute(
+      "put",
+      path,
+      this.internal.put,
+      contractDetailsOrMiddlewareOrTypedHandler,
+      ...middlewareOrMiddlewareWithTypedHandler
+    );
   };
   /**
    * Registers a PATCH route with the specified contract details and handler handlers.
@@ -1255,15 +1301,13 @@ var ForklaunchExpressLikeRouter = class {
    * @returns {ExpressRouter} - The Express router.
    */
   patch = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-    return {
-      patch: this.registerRoute(
-        "patch",
-        path,
-        this.internal.patch,
-        contractDetailsOrMiddlewareOrTypedHandler,
-        ...middlewareOrMiddlewareWithTypedHandler
-      )
-    };
+    return this.registerRoute(
+      "patch",
+      path,
+      this.internal.patch,
+      contractDetailsOrMiddlewareOrTypedHandler,
+      ...middlewareOrMiddlewareWithTypedHandler
+    );
   };
   /**
    * Registers a DELETE route with the specified contract details and handler handlers.
@@ -1279,15 +1323,13 @@ var ForklaunchExpressLikeRouter = class {
    * @returns {ExpressRouter} - The Express router.
    */
   delete = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-    return {
-      delete: this.registerRoute(
-        "delete",
-        path,
-        this.internal.delete,
-        contractDetailsOrMiddlewareOrTypedHandler,
-        ...middlewareOrMiddlewareWithTypedHandler
-      )
-    };
+    return this.registerRoute(
+      "delete",
+      path,
+      this.internal.delete,
+      contractDetailsOrMiddlewareOrTypedHandler,
+      ...middlewareOrMiddlewareWithTypedHandler
+    );
   };
   /**
    * Registers a OPTIONS route with the specified contract details and handler handlers.
@@ -1303,15 +1345,13 @@ var ForklaunchExpressLikeRouter = class {
    * @returns {ExpressRouter} - The Express router.
    */
   options = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-    return {
-      options: this.registerRoute(
-        "options",
-        path,
-        this.internal.options,
-        contractDetailsOrMiddlewareOrTypedHandler,
-        ...middlewareOrMiddlewareWithTypedHandler
-      )
-    };
+    return this.registerRoute(
+      "options",
+      path,
+      this.internal.options,
+      contractDetailsOrMiddlewareOrTypedHandler,
+      ...middlewareOrMiddlewareWithTypedHandler
+    );
   };
   /**
    * Registers a HEAD route with the specified contract details and handler handlers.
@@ -1327,15 +1367,13 @@ var ForklaunchExpressLikeRouter = class {
    * @returns {ExpressRouter} - The Express router.
    */
   head = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-    return {
-      head: this.registerRoute(
-        "head",
-        path,
-        this.internal.head,
-        contractDetailsOrMiddlewareOrTypedHandler,
-        ...middlewareOrMiddlewareWithTypedHandler
-      )
-    };
+    return this.registerRoute(
+      "head",
+      path,
+      this.internal.head,
+      contractDetailsOrMiddlewareOrTypedHandler,
+      ...middlewareOrMiddlewareWithTypedHandler
+    );
   };
   /**
    * Registers a TRACE route with the specified contract details and handler handlers.
@@ -1351,16 +1389,32 @@ var ForklaunchExpressLikeRouter = class {
    * @returns {ExpressRouter} - The Express router.
    */
   trace = (path, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) => {
-    return {
-      trace: this.registerRoute(
-        "trace",
-        path,
-        this.internal.trace,
-        contractDetailsOrMiddlewareOrTypedHandler,
-        ...middlewareOrMiddlewareWithTypedHandler
-      )
-    };
+    return this.registerRoute(
+      "trace",
+      path,
+      this.internal.trace,
+      contractDetailsOrMiddlewareOrTypedHandler,
+      ...middlewareOrMiddlewareWithTypedHandler
+    );
   };
+  cloneInternals(clone) {
+    clone.routers = [...this.routers];
+    clone.routes = [...this.routes];
+    clone.fetchMap = { ...this.fetchMap };
+    clone.sdk = { ...this.sdk };
+  }
+  clone() {
+    const clone = new _ForklaunchExpressLikeRouter(
+      this.basePath,
+      this.schemaValidator,
+      this.internal,
+      this.postEnrichMiddleware,
+      this.openTelemetryCollector,
+      this.sdkName
+    );
+    this.cloneInternals(clone);
+    return clone;
+  }
 };
 
 // src/http/application/expressLikeApplication.ts
@@ -1383,25 +1437,6 @@ var ForklaunchExpressLikeApplication = class extends ForklaunchExpressLikeRouter
     this.postEnrichMiddleware = postEnrichMiddleware;
     this.openTelemetryCollector = openTelemetryCollector;
     this.appOptions = appOptions;
-    process.on("uncaughtException", (err) => {
-      this.openTelemetryCollector.log("error", `Uncaught exception: ${err}`);
-      process.exit(1);
-    });
-    process.on("unhandledRejection", (reason) => {
-      this.openTelemetryCollector.log(
-        "error",
-        `Unhandled rejection: ${reason}`
-      );
-      process.exit(1);
-    });
-    process.on("exit", () => {
-      this.openTelemetryCollector.log("info", "Shutting down application");
-    });
-    process.on("SIGINT", () => {
-      this.openTelemetryCollector.log("info", "Shutting down application");
-      process.exit(0);
-    });
-    this.internal.use(createContext(this.schemaValidator));
     this.internal.use(cors(this.appOptions?.cors ?? {}));
   }
 };
@@ -2466,6 +2501,218 @@ var getCodeForStatus = (status) => {
 };
 var httpStatusCodes_default = HTTPStatuses;
 
+// src/http/mcpGenerator/mcpGenerator.ts
+var import_common7 = require("@forklaunch/common");
+var import_zod = require("@forklaunch/validator/zod");
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+
+// src/http/router/unpackRouters.ts
+var import_common6 = require("@forklaunch/common");
+function unpackRouters(routers, recursiveBasePath = [], recursiveSdkPath = []) {
+  return routers.reduce((acc, router) => {
+    acc.push({
+      fullPath: [...recursiveBasePath, router.basePath].join(""),
+      sdkPath: [
+        ...recursiveSdkPath,
+        (0, import_common6.toPrettyCamelCase)(router.sdkName ?? router.basePath)
+      ].join("."),
+      router
+    });
+    acc.push(
+      ...unpackRouters(
+        router.routers,
+        [...recursiveBasePath, router.basePath],
+        [
+          ...recursiveSdkPath,
+          (0, import_common6.toPrettyCamelCase)(router.sdkName ?? router.basePath)
+        ]
+      )
+    );
+    return acc;
+  }, []);
+}
+
+// src/http/mcpGenerator/mcpGenerator.ts
+function generateMcpServer(schemaValidator, protocol, host, port, version, routers, contentTypeMap) {
+  if (!(schemaValidator instanceof import_zod.ZodSchemaValidator)) {
+    throw new Error(
+      "Schema validator must be an instance of ZodSchemaValidator"
+    );
+  }
+  const mcpServer = new import_mcp.McpServer({
+    name: "example-server",
+    version
+  });
+  unpackRouters(routers).forEach(({ fullPath, router }) => {
+    router.routes.forEach((route) => {
+      let discriminatedBody;
+      if ("body" in route.contractDetails) {
+        discriminatedBody = discriminateBody(
+          schemaValidator,
+          route.contractDetails.body
+        );
+      }
+      const inputSchema = {
+        ...discriminatedBody && "body" in route.contractDetails ? {
+          ..."contentType" in route.contractDetails.body ? { contentType: route.contractDetails.body.contentType } : {},
+          body: schemaValidator.schemify(discriminatedBody.schema)
+        } : {},
+        ...route.contractDetails.params ? { params: schemaValidator.schemify(route.contractDetails.params) } : {},
+        ...route.contractDetails.query ? { query: schemaValidator.schemify(route.contractDetails.query) } : {},
+        ...route.contractDetails.requestHeaders ? {
+          headers: schemaValidator.schemify(
+            route.contractDetails.requestHeaders
+          )
+        } : {}
+        // TODO: support auth
+        //   ...(route.contractDetails.auth
+        //     ? { auth: route.contractDetails.auth }
+        //     : {})
+      };
+      mcpServer.tool(
+        route.contractDetails.name,
+        route.contractDetails.summary,
+        inputSchema,
+        async (args) => {
+          const { contentType, body, params, query, headers } = args;
+          let url = `${protocol}://${host}:${port}${fullPath}${route.path}`;
+          if (params) {
+            for (const key in params) {
+              url = url.replace(
+                `:${key}`,
+                encodeURIComponent(params[key])
+              );
+            }
+          }
+          let parsedBody;
+          if (discriminatedBody) {
+            switch (discriminatedBody.parserType) {
+              case "json": {
+                parsedBody = (0, import_common7.safeStringify)(body);
+                break;
+              }
+              case "text": {
+                parsedBody = body;
+                break;
+              }
+              case "file": {
+                parsedBody = body;
+                break;
+              }
+              case "multipart": {
+                const formData = new FormData();
+                if ((0, import_common7.isRecord)(body)) {
+                  for (const key in body) {
+                    if (typeof body[key] === "string" || body[key] instanceof Blob) {
+                      formData.append(key, body[key]);
+                    } else {
+                      throw new Error("Body is not a valid multipart object");
+                    }
+                  }
+                } else {
+                  throw new Error("Body is not a valid multipart object");
+                }
+                parsedBody = formData;
+                break;
+              }
+              case "urlEncoded": {
+                if ((0, import_common7.isRecord)(body)) {
+                  parsedBody = new URLSearchParams(
+                    Object.entries(body).map(([key, value]) => [
+                      key,
+                      (0, import_common7.safeStringify)(value)
+                    ])
+                  );
+                } else {
+                  throw new Error("Body is not a valid url encoded object");
+                }
+                break;
+              }
+              default: {
+                (0, import_common7.isNever)(discriminatedBody.parserType);
+                parsedBody = (0, import_common7.safeStringify)(body);
+                break;
+              }
+            }
+          }
+          if (query) {
+            const queryString = new URLSearchParams(
+              Object.entries(query).map(([key, value]) => [
+                key,
+                (0, import_common7.safeStringify)(value)
+              ])
+            ).toString();
+            url += queryString ? `?${queryString}` : "";
+          }
+          const response = await fetch(encodeURI(url), {
+            method: route.method.toUpperCase(),
+            headers: {
+              ...headers,
+              ...discriminatedBody?.contentType != "multipart/form-data" ? {
+                "Content-Type": contentType ?? discriminatedBody?.contentType
+              } : {}
+            },
+            body: parsedBody
+          });
+          if (response.status >= 300) {
+            throw new Error(
+              `Error received while proxying request to ${url}: ${await response.text()}`
+            );
+          }
+          const contractContentType = discriminateResponseBodies(
+            schemaValidator,
+            route.contractDetails.responses
+          )[response.status].contentType;
+          switch (contentTypeMap && contentTypeMap[contractContentType] ? contentTypeMap[contractContentType] : contractContentType) {
+            case "application/json":
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: (0, import_common7.safeStringify)(await response.json())
+                  }
+                ]
+              };
+            case "text/plain":
+              return {
+                content: [
+                  { type: "text", text: await response.text() }
+                ]
+              };
+            case "application/octet-stream":
+              return {
+                content: [
+                  {
+                    type: "resource",
+                    resource: {
+                      uri: response.url,
+                      blob: Buffer.from(
+                        await (await response.blob()).arrayBuffer()
+                      ).toString("base64")
+                    }
+                  }
+                ]
+              };
+            case "text/event-stream":
+              return {
+                content: [
+                  { type: "text", text: await response.text() }
+                ]
+              };
+            default:
+              return {
+                content: [
+                  { type: "text", text: await response.text() }
+                ]
+              };
+          }
+        }
+      );
+    });
+  });
+  return mcpServer;
+}
+
 // src/http/middleware/response/parse.middleware.ts
 var import_validator2 = require("@forklaunch/validator");
 function parse2(req, res, next) {
@@ -2528,18 +2775,18 @@ ${parseErrors.join("\n\n")}`
 }
 
 // src/http/middleware/response/enrichExpressLikeSend.middleware.ts
-var import_common6 = require("@forklaunch/common");
+var import_common9 = require("@forklaunch/common");
 var import_stream = require("stream");
 
 // src/http/telemetry/recordMetric.ts
-var import_common5 = require("@forklaunch/common");
+var import_common8 = require("@forklaunch/common");
 var import_semantic_conventions3 = require("@opentelemetry/semantic-conventions");
 function recordMetric(req, res) {
   if (res.metricRecorded) {
     return;
   }
   httpRequestsTotalCounter.add(1, {
-    [import_semantic_conventions3.ATTR_SERVICE_NAME]: (0, import_common5.getEnvVar)("OTEL_SERVICE_NAME"),
+    [import_semantic_conventions3.ATTR_SERVICE_NAME]: (0, import_common8.getEnvVar)("OTEL_SERVICE_NAME"),
     [ATTR_API_NAME]: req.contractDetails?.name,
     [ATTR_CORRELATION_ID]: req.context.correlationId,
     [import_semantic_conventions3.ATTR_HTTP_REQUEST_METHOD]: req.method,
@@ -2559,7 +2806,7 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
   if (res.statusCode === 404) {
     res.type("text/plain");
     res.status(404);
-    logger("error").error("Not Found");
+    req.openTelemetryCollector.error("Not Found");
     originalSend.call(instance, "Not Found");
     errorSent = true;
   }
@@ -2577,8 +2824,8 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
         `attachment; filename="${data.name}"`
       );
     }
-    if ((0, import_common6.isNodeJsWriteableStream)(res)) {
-      import_stream.Readable.from((0, import_common6.readableStreamToAsyncIterable)(data.stream())).pipe(
+    if ((0, import_common9.isNodeJsWriteableStream)(res)) {
+      import_stream.Readable.from((0, import_common9.readableStreamToAsyncIterable)(data.stream())).pipe(
         res
       );
     } else {
@@ -2587,7 +2834,7 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
       originalSend.call(instance, "Not a NodeJS WritableStream");
       errorSent = true;
     }
-  } else if ((0, import_common6.isAsyncGenerator)(data)) {
+  } else if ((0, import_common9.isAsyncGenerator)(data)) {
     let firstPass = true;
     const transformer = new import_stream.Transform({
       objectMode: true,
@@ -2602,7 +2849,7 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
 ------------------
 ${res.locals.errorMessage}`;
               }
-              logger("error").error(errorString);
+              req.openTelemetryCollector.error(errorString);
               res.type("text/plain");
               res.status(500);
               originalSend.call(instance, errorString);
@@ -2615,7 +2862,7 @@ ${res.locals.errorMessage}`;
         if (!errorSent) {
           let data2 = "";
           for (const [key, value] of Object.entries(chunk)) {
-            data2 += `${key}: ${typeof value === "string" ? value : (0, import_common6.safeStringify)(value)}
+            data2 += `${key}: ${typeof value === "string" ? value : (0, import_common9.safeStringify)(value)}
 `;
           }
           data2 += "\n";
@@ -2623,7 +2870,7 @@ ${res.locals.errorMessage}`;
         }
       }
     });
-    if ((0, import_common6.isNodeJsWriteableStream)(res)) {
+    if ((0, import_common9.isNodeJsWriteableStream)(res)) {
       import_stream.Readable.from(data).pipe(transformer).pipe(res);
     } else {
       res.type("text/plain");
@@ -2634,7 +2881,7 @@ ${res.locals.errorMessage}`;
   } else {
     const parserType = responseBodies?.[Number(res.statusCode)]?.parserType;
     res.bodyData = data;
-    if ((0, import_common6.isRecord)(data)) {
+    if ((0, import_common9.isRecord)(data)) {
       switch (parserType) {
         case "json":
           res.bodyData = "json" in data ? data.json : data;
@@ -2655,7 +2902,7 @@ ${res.locals.errorMessage}`;
           res.bodyData = data;
           break;
         default:
-          (0, import_common6.isNever)(parserType);
+          (0, import_common9.isNever)(parserType);
           res.bodyData = data;
           break;
       }
@@ -2668,7 +2915,7 @@ ${res.locals.errorMessage}`;
 ------------------
 ${res.locals.errorMessage}`;
         }
-        logger("error").error(errorString);
+        req.openTelemetryCollector.error(errorString);
         res.type("text/plain");
         res.status(500);
         originalSend.call(instance, errorString);
@@ -2691,16 +2938,17 @@ ${res.locals.errorMessage}`;
 }
 
 // src/http/openApiV3Generator/openApiV3Generator.ts
+var import_common10 = require("@forklaunch/common");
 function toUpperCase(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function transformBasePath(basePath) {
   if (basePath.startsWith("/")) {
-    return toUpperCase(basePath.slice(1));
+    return basePath.slice(1);
   }
   return `/${basePath}`;
 }
-function generateOpenApiDocument(port, tags, paths) {
+function generateOpenApiDocument(protocol, host, port, tags, paths, otherServers) {
   return {
     openapi: "3.1.0",
     info: {
@@ -2719,8 +2967,10 @@ function generateOpenApiDocument(port, tags, paths) {
     tags,
     servers: [
       {
-        url: `http://localhost:${port}`
-      }
+        url: `${protocol}://${host}:${port}`,
+        description: "Main Server"
+      },
+      ...otherServers || []
     ],
     paths
   };
@@ -2741,19 +2991,21 @@ function contentResolver(schemaValidator, body, contentType) {
     }
   };
 }
-function generateSwaggerDocument(schemaValidator, port, routers) {
+function generateSwaggerDocument(schemaValidator, protocol, host, port, routers, otherServers) {
   const tags = [];
   const paths = {};
-  routers.flat(Infinity).forEach((router) => {
-    const controllerName = transformBasePath(router.basePath);
+  unpackRouters(routers).forEach(({ fullPath, router, sdkPath }) => {
+    const controllerName = transformBasePath(fullPath);
     tags.push({
       name: controllerName,
-      description: `${controllerName} Operations`
+      description: `${toUpperCase(controllerName)} Operations`
     });
     router.routes.forEach((route) => {
-      const fullPath = `${router.basePath}${route.path === "/" ? "" : route.path}`.replace(/:(\w+)/g, "{$1}");
-      if (!paths[fullPath]) {
-        paths[fullPath] = {};
+      const openApiPath = (0, import_common10.openApiCompliantPath)(
+        `${fullPath}${route.path === "/" ? "" : route.path}`
+      );
+      if (!paths[openApiPath]) {
+        paths[openApiPath] = {};
       }
       const { name, summary, query, requestHeaders } = route.contractDetails;
       const responses = {};
@@ -2780,15 +3032,16 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
           };
         }
       }
-      const pathItemObject = {
+      const operationObject = {
         tags: [controllerName],
         summary: `${name}: ${summary}`,
         parameters: [],
-        responses
+        responses,
+        operationId: `${sdkPath}.${(0, import_common10.toPrettyCamelCase)(name)}`
       };
       if (route.contractDetails.params) {
         for (const key in route.contractDetails.params) {
-          pathItemObject.parameters?.push({
+          operationObject.parameters?.push({
             name: key,
             in: "path",
             schema: schemaValidator.openapi(
@@ -2799,7 +3052,7 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
       }
       const discriminatedBodyResult = "body" in route.contractDetails ? discriminateBody(schemaValidator, route.contractDetails.body) : null;
       if (discriminatedBodyResult) {
-        pathItemObject.requestBody = {
+        operationObject.requestBody = {
           required: true,
           content: contentResolver(
             schemaValidator,
@@ -2810,7 +3063,7 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
       }
       if (requestHeaders) {
         for (const key in requestHeaders) {
-          pathItemObject.parameters?.push({
+          operationObject.parameters?.push({
             name: key,
             in: "header",
             schema: schemaValidator.openapi(
@@ -2821,7 +3074,7 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
       }
       if (query) {
         for (const key in query) {
-          pathItemObject.parameters?.push({
+          operationObject.parameters?.push({
             name: key,
             in: "query",
             schema: schemaValidator.openapi(query[key])
@@ -2838,7 +3091,7 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
           content: contentResolver(schemaValidator, schemaValidator.string)
         };
         if (route.contractDetails.auth.method === "jwt") {
-          pathItemObject.security = [
+          operationObject.security = [
             {
               bearer: Array.from(
                 route.contractDetails.auth.allowedPermissions?.values() || []
@@ -2848,11 +3101,18 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
         }
       }
       if (route.method !== "middleware") {
-        paths[fullPath][route.method] = pathItemObject;
+        paths[openApiPath][route.method] = operationObject;
       }
     });
   });
-  return generateOpenApiDocument(port, tags, paths);
+  return generateOpenApiDocument(
+    protocol,
+    host,
+    port,
+    tags,
+    paths,
+    otherServers
+  );
 }
 
 // src/http/telemetry/evaluateTelemetryOptions.ts
@@ -2892,6 +3152,7 @@ function metricsDefinitions(metrics2) {
   discriminateResponseBodies,
   enrichExpressLikeSend,
   evaluateTelemetryOptions,
+  generateMcpServer,
   generateSwaggerDocument,
   get,
   getCodeForStatus,