@forklaunch/core 0.9.22 → 0.10.1

package/lib/http/index.mjs

@@ -15,6 +15,13 @@ function cors(corsOptions) {
   };
 }
 
+// src/http/router/expressLikeRouter.ts
+import {
+  sanitizePathSlashes,
+  toPrettyCamelCase,
+  toRecord
+} from "@forklaunch/common";
+
 // src/http/guards/isForklaunchRouter.ts
 function isForklaunchRouter(maybeForklaunchRouter) {
   return maybeForklaunchRouter != null && typeof maybeForklaunchRouter === "object" && "basePath" in maybeForklaunchRouter && "routes" in maybeForklaunchRouter && Array.isArray(maybeForklaunchRouter.routes);
@@ -33,7 +40,7 @@ function isExpressLikeSchemaHandler(middleware2) {
       (argumentName) => argumentName.toLowerCase()
     )
   );
-  return extractedArgumentNames && extractedArgumentNames.size <= 3;
+  return extractedArgumentNames && extractedArgumentNames.size <= 4;
 }
 
 // src/http/guards/isForklaunchExpressLikeRouter.ts
@@ -617,6 +624,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",
@@ -668,6 +681,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",
@@ -687,37 +706,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;
-    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.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.
    *
@@ -836,6 +856,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
    *
@@ -855,24 +889,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;
@@ -926,24 +942,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");
@@ -975,10 +987,13 @@ var ForklaunchExpressLikeRouter = class {
           ).concat(handlers),
           this.#parseAndRunControllerHandler(controllerHandler)
         );
-        return this.#localParamRequest(
+        const localParamRequest = this.#localParamRequest(
           handlers,
           controllerHandler
         );
+        toRecord(this.fetchMap)[sanitizePathSlashes(`${this.basePath}${path}`)] = localParamRequest;
+        toRecord(this.sdk)[toPrettyCamelCase(contractDetails.name ?? this.basePath)] = (req) => localParamRequest(`${this.basePath}${path}`, req);
+        return this;
       }
     }
   }
@@ -1002,10 +1017,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)) {
@@ -1029,6 +1047,7 @@ var ForklaunchExpressLikeRouter = class {
       middleware2
     );
     if (isForklaunchExpressLikeRouter(contractDetailsOrMiddlewareOrTypedHandler)) {
+      this.addRouterToSdk(contractDetailsOrMiddlewareOrTypedHandler);
       middleware2.push(contractDetailsOrMiddlewareOrTypedHandler.internal);
     }
     middleware2.push(
@@ -1058,6 +1077,16 @@ var ForklaunchExpressLikeRouter = class {
     }
     return this;
   }
+  addRouterToSdk(router) {
+    Object.entries(router.fetchMap).map(
+      ([key, value]) => toRecord(this.fetchMap)[sanitizePathSlashes(`${this.basePath}${key}`)] = value
+    );
+    const existingSdk = this.sdk[router.sdkName ?? toPrettyCamelCase(router.basePath)];
+    toRecord(this.sdk)[router.sdkName ?? toPrettyCamelCase(router.basePath)] = {
+      ...typeof existingSdk === "object" ? existingSdk : {},
+      ...router.sdk
+    };
+  }
   registerNestableMiddlewareHandler(registrationMethod, pathOrContractDetailsOrMiddlewareOrTypedHandler, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareWithTypedHandler) {
     const middleware2 = [];
     let path;
@@ -1073,7 +1102,9 @@ var ForklaunchExpressLikeRouter = class {
       if (isConstrainedForklaunchRouter(
         pathOrContractDetailsOrMiddlewareOrTypedHandler
       )) {
-        path = pathOrContractDetailsOrMiddlewareOrTypedHandler.basePath;
+        const router = pathOrContractDetailsOrMiddlewareOrTypedHandler;
+        this.addRouterToSdk(router);
+        path = router.basePath;
       }
       middleware2.push(
         ...this.#extractNestableMiddlewareAsRouterHandlers(
@@ -1084,6 +1115,11 @@ var ForklaunchExpressLikeRouter = class {
         )
       );
     }
+    if (!path) {
+      path = middleware2.filter(
+        (m) => isForklaunchExpressLikeRouter(m)
+      )[0]?.basePath;
+    }
     if (path) {
       registrationMethod.bind(this.internal)(path, ...middleware2);
     } else {
@@ -1138,15 +1174,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.
@@ -1162,15 +1196,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.
@@ -1186,15 +1218,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.
@@ -1210,15 +1240,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.
@@ -1234,15 +1262,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.
@@ -1258,15 +1284,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.
@@ -1282,15 +1306,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.
@@ -1306,16 +1328,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
@@ -2402,6 +2440,218 @@ var getCodeForStatus = (status) => {
 };
 var httpStatusCodes_default = HTTPStatuses;
 
+// src/http/mcpGenerator/mcpGenerator.ts
+import { isNever as isNever2, isRecord, safeStringify as safeStringify2 } from "@forklaunch/common";
+import { ZodSchemaValidator } from "@forklaunch/validator/zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/http/router/unpackRouters.ts
+import { toPrettyCamelCase as toPrettyCamelCase2 } from "@forklaunch/common";
+function unpackRouters(routers, recursiveBasePath = [], recursiveSdkPath = []) {
+  return routers.reduce((acc, router) => {
+    acc.push({
+      fullPath: [...recursiveBasePath, router.basePath].join(""),
+      sdkPath: [
+        ...recursiveSdkPath,
+        toPrettyCamelCase2(router.sdkName ?? router.basePath)
+      ].join("."),
+      router
+    });
+    acc.push(
+      ...unpackRouters(
+        router.routers,
+        [...recursiveBasePath, router.basePath],
+        [
+          ...recursiveSdkPath,
+          toPrettyCamelCase2(router.sdkName ?? router.basePath)
+        ]
+      )
+    );
+    return acc;
+  }, []);
+}
+
+// src/http/mcpGenerator/mcpGenerator.ts
+function generateMcpServer(schemaValidator, protocol, host, port, version, routers, contentTypeMap) {
+  if (!(schemaValidator instanceof ZodSchemaValidator)) {
+    throw new Error(
+      "Schema validator must be an instance of ZodSchemaValidator"
+    );
+  }
+  const mcpServer = new 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 = safeStringify2(body);
+                break;
+              }
+              case "text": {
+                parsedBody = body;
+                break;
+              }
+              case "file": {
+                parsedBody = body;
+                break;
+              }
+              case "multipart": {
+                const formData = new FormData();
+                if (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 (isRecord(body)) {
+                  parsedBody = new URLSearchParams(
+                    Object.entries(body).map(([key, value]) => [
+                      key,
+                      safeStringify2(value)
+                    ])
+                  );
+                } else {
+                  throw new Error("Body is not a valid url encoded object");
+                }
+                break;
+              }
+              default: {
+                isNever2(discriminatedBody.parserType);
+                parsedBody = safeStringify2(body);
+                break;
+              }
+            }
+          }
+          if (query) {
+            const queryString = new URLSearchParams(
+              Object.entries(query).map(([key, value]) => [
+                key,
+                safeStringify2(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: safeStringify2(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
 import {
   prettyPrintParseErrors as prettyPrintParseErrors2
@@ -2468,11 +2718,11 @@ ${parseErrors.join("\n\n")}`
 // src/http/middleware/response/enrichExpressLikeSend.middleware.ts
 import {
   isAsyncGenerator,
-  isNever as isNever2,
+  isNever as isNever3,
   isNodeJsWriteableStream,
-  isRecord,
+  isRecord as isRecord2,
   readableStreamToAsyncIterable,
-  safeStringify as safeStringify2
+  safeStringify as safeStringify3
 } from "@forklaunch/common";
 import { Readable, Transform } from "stream";
 
@@ -2509,7 +2759,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;
   }
@@ -2552,7 +2802,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);
@@ -2565,7 +2815,7 @@ ${res.locals.errorMessage}`;
         if (!errorSent) {
           let data2 = "";
           for (const [key, value] of Object.entries(chunk)) {
-            data2 += `${key}: ${typeof value === "string" ? value : safeStringify2(value)}
+            data2 += `${key}: ${typeof value === "string" ? value : safeStringify3(value)}
 `;
           }
           data2 += "\n";
@@ -2584,7 +2834,7 @@ ${res.locals.errorMessage}`;
   } else {
     const parserType = responseBodies?.[Number(res.statusCode)]?.parserType;
     res.bodyData = data;
-    if (isRecord(data)) {
+    if (isRecord2(data)) {
       switch (parserType) {
         case "json":
           res.bodyData = "json" in data ? data.json : data;
@@ -2605,7 +2855,7 @@ ${res.locals.errorMessage}`;
           res.bodyData = data;
           break;
         default:
-          isNever2(parserType);
+          isNever3(parserType);
           res.bodyData = data;
           break;
       }
@@ -2618,7 +2868,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);
@@ -2641,16 +2891,17 @@ ${res.locals.errorMessage}`;
 }
 
 // src/http/openApiV3Generator/openApiV3Generator.ts
+import { openApiCompliantPath, toPrettyCamelCase as toPrettyCamelCase3 } from "@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: {
@@ -2669,8 +2920,10 @@ function generateOpenApiDocument(port, tags, paths) {
     tags,
     servers: [
       {
-        url: `http://localhost:${port}`
-      }
+        url: `${protocol}://${host}:${port}`,
+        description: "Main Server"
+      },
+      ...otherServers || []
     ],
     paths
   };
@@ -2691,19 +2944,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 = openApiCompliantPath(
+        `${fullPath}${route.path === "/" ? "" : route.path}`
+      );
+      if (!paths[openApiPath]) {
+        paths[openApiPath] = {};
       }
       const { name, summary, query, requestHeaders } = route.contractDetails;
       const responses = {};
@@ -2730,15 +2985,16 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
           };
         }
       }
-      const pathItemObject = {
+      const operationObject = {
         tags: [controllerName],
         summary: `${name}: ${summary}`,
         parameters: [],
-        responses
+        responses,
+        operationId: `${sdkPath}.${toPrettyCamelCase3(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(
@@ -2749,7 +3005,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,
@@ -2760,7 +3016,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(
@@ -2771,7 +3027,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])
@@ -2788,7 +3044,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() || []
@@ -2798,11 +3054,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
@@ -2841,6 +3104,7 @@ export {
   discriminateResponseBodies,
   enrichExpressLikeSend,
   evaluateTelemetryOptions,
+  generateMcpServer,
   generateSwaggerDocument,
   get,
   getCodeForStatus,