@forklaunch/core 0.11.6 → 0.12.0

package/lib/http/index.mjs

@@ -10,18 +10,28 @@ function cors(corsOptions) {
         return res.getHeaders()[key];
       };
     }
-    corsMiddleware(corsOptions)(req, res, next ?? (() => {
-    }));
+    corsMiddleware(corsOptions)(
+      req,
+      res,
+      next ?? (() => {
+      })
+    );
   };
 }
 
 // src/http/router/expressLikeRouter.ts
 import {
+  isRecord as isRecord2,
   sanitizePathSlashes,
   toPrettyCamelCase,
   toRecord
 } from "@forklaunch/common";
 
+// src/http/guards/hasVersionedSchema.ts
+function hasVersionedSchema(contractDetails) {
+  return typeof contractDetails === "object" && contractDetails !== null && "versions" in contractDetails && contractDetails.versions !== null;
+}
+
 // src/http/guards/isForklaunchRouter.ts
 function isForklaunchRouter(maybeForklaunchRouter) {
   return maybeForklaunchRouter != null && typeof maybeForklaunchRouter === "object" && "basePath" in maybeForklaunchRouter && "routes" in maybeForklaunchRouter && Array.isArray(maybeForklaunchRouter.routes);
@@ -52,12 +62,16 @@ function isForklaunchExpressLikeRouter(maybeForklaunchExpressLikeRouter) {
 
 // src/http/guards/isPathParamContractDetails.ts
 function isPathParamHttpContractDetails(maybePathParamHttpContractDetails) {
-  return maybePathParamHttpContractDetails != null && typeof maybePathParamHttpContractDetails === "object" && "name" in maybePathParamHttpContractDetails && "summary" in maybePathParamHttpContractDetails && "responses" in maybePathParamHttpContractDetails && maybePathParamHttpContractDetails.name != null && maybePathParamHttpContractDetails.summary != null && maybePathParamHttpContractDetails.responses != null;
+  return maybePathParamHttpContractDetails != null && typeof maybePathParamHttpContractDetails === "object" && "name" in maybePathParamHttpContractDetails && "summary" in maybePathParamHttpContractDetails && maybePathParamHttpContractDetails.name != null && maybePathParamHttpContractDetails.summary != null && ("responses" in maybePathParamHttpContractDetails && maybePathParamHttpContractDetails.responses != null || "versions" in maybePathParamHttpContractDetails && typeof maybePathParamHttpContractDetails.versions === "object" && maybePathParamHttpContractDetails.versions != null && Object.values(maybePathParamHttpContractDetails.versions).every(
+    (version) => "responses" in version && version.responses != null
+  ));
 }
 
 // src/http/guards/isHttpContractDetails.ts
 function isHttpContractDetails(maybeContractDetails) {
-  return isPathParamHttpContractDetails(maybeContractDetails) && "body" in maybeContractDetails && maybeContractDetails.body != null;
+  return isPathParamHttpContractDetails(maybeContractDetails) && ("body" in maybeContractDetails && maybeContractDetails.body != null || "versions" in maybeContractDetails && typeof maybeContractDetails.versions === "object" && maybeContractDetails.versions != null && Object.values(maybeContractDetails.versions).every(
+    (version) => "body" in version && version.body != null
+  ));
 }
 
 // src/http/guards/isTypedHandler.ts
@@ -206,7 +220,10 @@ async function checkAuthorizationToken(authorizationMethod, authorizationToken,
     if (!authorizationMethod.mapRoles) {
       return [500, "No role mapping function provided."];
     }
-    const resourceRoles = await authorizationMethod.mapRoles(resourceId, req);
+    const resourceRoles = await authorizationMethod.mapRoles(
+      resourceId,
+      req
+    );
     if ("allowedRoles" in authorizationMethod && authorizationMethod.allowedRoles) {
       if (resourceRoles.intersection(authorizationMethod.allowedRoles).size === 0) {
         return invalidAuthorizationTokenRoles;
@@ -227,6 +244,7 @@ async function parseRequestAuth(req, res, next) {
     const [error, message] = await checkAuthorizationToken(
       auth,
       req.headers[auth.headerName ?? "Authorization"] || req.headers[auth.headerName ?? "authorization"],
+      // we can safely cast here because we know that the user will supply resolution for the request
       req
     ) ?? [];
     if (error != null) {
@@ -546,6 +564,7 @@ function enrichDetails(path, contractDetails, requestSchema, responseSchemas, op
 }
 
 // src/http/middleware/request/parse.middleware.ts
+import { isRecord } from "@forklaunch/common";
 import {
   prettyPrintParseErrors
 } from "@forklaunch/validator";
@@ -568,10 +587,49 @@ function parse(req, res, next) {
     headers: req.headers,
     body: req.body
   };
-  const parsedRequest = req.schemaValidator.parse(
-    req.requestSchema,
-    request
-  );
+  const schemaValidator = req.schemaValidator;
+  let matchedVersions;
+  let parsedRequest;
+  let collectedParseErrors;
+  if (req.contractDetails.versions) {
+    if (isRecord(req.requestSchema)) {
+      let runningParseErrors = "";
+      matchedVersions = [];
+      Object.entries(req.requestSchema).forEach(([version, schema]) => {
+        const parsingResult = schemaValidator.parse(schema, request);
+        if (parsingResult.ok) {
+          parsedRequest = parsingResult;
+          matchedVersions.push(version);
+          req.version = version;
+          res.version = req.version;
+        } else {
+          runningParseErrors += prettyPrintParseErrors(
+            parsingResult.errors,
+            `Version ${version} request`
+          );
+        }
+      });
+      if (!parsedRequest) {
+        parsedRequest = {
+          ok: false,
+          errors: []
+        };
+        collectedParseErrors = runningParseErrors;
+      }
+    } else {
+      req.version = Object.keys(req.contractDetails.versions).pop();
+      res.version = req.version;
+      parsedRequest = {
+        ok: true,
+        value: request
+      };
+      matchedVersions = Object.keys(req.contractDetails.versions);
+    }
+  } else {
+    const parsingResult = schemaValidator.parse(req.requestSchema, request);
+    parsedRequest = parsingResult;
+    matchedVersions = 0;
+  }
   if (parsedRequest.ok && isRequestShape(parsedRequest.value)) {
     req.body = parsedRequest.value.body;
     req.params = parsedRequest.value.params;
@@ -602,10 +660,7 @@ function parse(req, res, next) {
         res.status(400);
         if (hasSend(res)) {
           res.send(
-            `${prettyPrintParseErrors(
-              parsedRequest.errors,
-              "Request"
-            )}
+            `${collectedParseErrors ?? prettyPrintParseErrors(parsedRequest.errors, "Request")}
 
 Correlation id: ${req.context.correlationId ?? "No correlation ID"}`
           );
@@ -615,13 +670,14 @@ Correlation id: ${req.context.correlationId ?? "No correlation ID"}`
         return;
       case "warning":
         req.openTelemetryCollector.warn(
-          prettyPrintParseErrors(parsedRequest.errors, "Request")
+          collectedParseErrors ?? prettyPrintParseErrors(parsedRequest.errors, "Request")
         );
         break;
       case "none":
         break;
     }
   }
+  req._parsedVersions = matchedVersions;
   next?.();
 }
 
@@ -759,13 +815,12 @@ function discriminateResponseBodies(schemaValidator, responses) {
 
 // src/http/router/expressLikeRouter.ts
 var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
-  constructor(basePath, schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector, sdkName) {
+  constructor(basePath, schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector) {
     this.basePath = basePath;
     this.schemaValidator = schemaValidator;
     this.internal = internal;
     this.postEnrichMiddleware = postEnrichMiddleware;
     this.openTelemetryCollector = openTelemetryCollector;
-    this.sdkName = sdkName;
     if (process.env.NODE_ENV !== "test" && !process.env.VITEST) {
       process.on("uncaughtException", (err) => {
         this.openTelemetryCollector.error(`Uncaught exception: ${err}`);
@@ -788,8 +843,9 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
   requestHandler;
   routers = [];
   routes = [];
-  fetchMap = {};
+  _fetchMap = {};
   sdk = {};
+  sdkPaths = {};
   /**
    * Resolves middlewares based on the contract details.
    *
@@ -859,50 +915,112 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
     }
     return controllerHandler;
   }
-  #compile(contractDetails) {
+  #processContractDetailsIO(contractDetailsIO, params) {
     const schemaValidator = this.schemaValidator;
-    let body = null;
-    if (isHttpContractDetails(contractDetails)) {
-      body = discriminateBody(this.schemaValidator, contractDetails.body);
-    }
-    const requestSchema = schemaValidator.compile(
-      schemaValidator.schemify({
-        ...contractDetails.params ? { params: contractDetails.params } : {},
-        ...contractDetails.requestHeaders ? { headers: contractDetails.requestHeaders } : {},
-        ...contractDetails.query ? { query: contractDetails.query } : {},
-        ...body != null ? { body: body.schema } : {}
-      })
-    );
-    const responseEntries = {
+    const responseSchemas = {
       400: schemaValidator.string,
       401: schemaValidator.string,
       403: schemaValidator.string,
       404: schemaValidator.string,
       500: schemaValidator.string,
-      ...isPathParamHttpContractDetails(contractDetails) || isHttpContractDetails(contractDetails) ? Object.fromEntries(
+      ...Object.fromEntries(
         Object.entries(
           discriminateResponseBodies(
             this.schemaValidator,
-            contractDetails.responses
+            contractDetailsIO.responses
           )
         ).map(([key, value]) => {
-          return [key, value.schema];
+          return [Number(key), value.schema];
         })
-      ) : {}
+      )
     };
-    const responseSchemas = {
-      responses: {},
-      ...contractDetails.responseHeaders ? {
-        headers: schemaValidator.compile(
-          schemaValidator.schemify(contractDetails.responseHeaders)
+    return {
+      requestSchema: schemaValidator.compile(
+        schemaValidator.schemify({
+          ...params != null ? { params } : { params: schemaValidator.unknown },
+          ...contractDetailsIO.requestHeaders != null ? { headers: contractDetailsIO.requestHeaders } : { headers: schemaValidator.unknown },
+          ...contractDetailsIO.query != null ? { query: contractDetailsIO.query } : { query: schemaValidator.unknown },
+          ...contractDetailsIO.body != null ? {
+            body: discriminateBody(
+              this.schemaValidator,
+              contractDetailsIO.body
+            )?.schema
+          } : { body: schemaValidator.unknown }
+        })
+      ),
+      responseSchemas: {
+        ...contractDetailsIO.responseHeaders != null ? {
+          headers: schemaValidator.compile(
+            schemaValidator.schemify(contractDetailsIO.responseHeaders)
+          )
+        } : { headers: schemaValidator.unknown },
+        responses: Object.fromEntries(
+          Object.entries(responseSchemas).map(([key, value]) => {
+            return [
+              key,
+              schemaValidator.compile(schemaValidator.schemify(value))
+            ];
+          })
         )
-      } : {}
+      }
     };
-    Object.entries(responseEntries).forEach(([code, responseShape]) => {
-      responseSchemas.responses[Number(code)] = schemaValidator.compile(
-        schemaValidator.schemify(responseShape)
+  }
+  #compile(contractDetails) {
+    const schemaValidator = this.schemaValidator;
+    let requestSchema;
+    let responseSchemas;
+    if (hasVersionedSchema(contractDetails)) {
+      requestSchema = {};
+      responseSchemas = {};
+      Object.entries(contractDetails.versions ?? {}).forEach(
+        ([version, versionedContractDetails]) => {
+          const {
+            requestSchema: versionedRequestSchema,
+            responseSchemas: versionedResponseSchemas
+          } = this.#processContractDetailsIO(
+            versionedContractDetails,
+            contractDetails.params
+          );
+          if (isRecord2(requestSchema)) {
+            requestSchema = {
+              ...requestSchema,
+              [version]: versionedRequestSchema
+            };
+          }
+          if (isRecord2(responseSchemas)) {
+            responseSchemas = {
+              ...responseSchemas,
+              [version]: versionedResponseSchemas
+            };
+          }
+        }
       );
-    });
+    } else {
+      const {
+        requestSchema: unversionedRequestSchema,
+        responseSchemas: unversionedResponseSchemas
+      } = this.#processContractDetailsIO(
+        {
+          ..."params" in contractDetails && contractDetails.params != null ? { params: contractDetails.params } : { params: schemaValidator.unknown },
+          ..."requestHeaders" in contractDetails && contractDetails.requestHeaders != null ? { requestHeaders: contractDetails.requestHeaders } : {
+            requestHeaders: schemaValidator.unknown
+          },
+          ..."responseHeaders" in contractDetails && contractDetails.responseHeaders != null ? { responseHeaders: contractDetails.responseHeaders } : {
+            responseHeaders: schemaValidator.unknown
+          },
+          ..."query" in contractDetails && contractDetails.query != null ? { query: contractDetails.query } : {
+            query: schemaValidator.unknown
+          },
+          ..."body" in contractDetails && contractDetails.body != null ? { body: contractDetails.body } : {
+            body: schemaValidator.unknown
+          },
+          responses: "responses" in contractDetails && contractDetails.responses != null ? contractDetails.responses : schemaValidator.unknown
+        },
+        contractDetails.params
+      );
+      requestSchema = unversionedRequestSchema;
+      responseSchemas = unversionedResponseSchemas;
+    }
     return {
       requestSchema,
       responseSchemas
@@ -911,15 +1029,18 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
   /**
    * 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.
+   * @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.
+   * @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](
+    const method = reqInit[0]?.method;
+    const version = reqInit[0] != null && "version" in reqInit[0] ? reqInit[0].version : void 0;
+    return (version ? this._fetchMap[path][method ?? "GET"][version] : this._fetchMap[path][method ?? "GET"])(
       path,
       reqInit[0]
+      // reqInit
     );
   };
   /**
@@ -929,7 +1050,7 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
    * @param controllerHandler
    * @returns
    */
-  #localParamRequest(handlers, controllerHandler) {
+  #localParamRequest(handlers, controllerHandler, version) {
     return async (route, request) => {
       let statusCode;
       let responseMessage;
@@ -939,7 +1060,8 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
         query: request?.query ?? {},
         headers: request?.headers ?? {},
         body: discriminateBody(this.schemaValidator, request?.body)?.schema ?? {},
-        path: route
+        path: route,
+        version
       };
       const res = {
         status: (code) => {
@@ -960,7 +1082,8 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
         },
         sseEmitter: (generator) => {
           responseMessage = generator();
-        }
+        },
+        version
       };
       let cursor = handlers.shift();
       if (cursor) {
@@ -994,20 +1117,20 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
   registerRoute(method, path, registrationMethod, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareAndTypedHandler) {
     if (isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
       const { contractDetails, handlers } = contractDetailsOrMiddlewareOrTypedHandler;
-      this.registerRoute(method, path, registrationMethod, contractDetails, ...handlers);
-      return this;
+      const router = this.registerRoute(method, path, registrationMethod, contractDetails, ...handlers);
+      return router;
     } else {
       const maybeTypedHandler = middlewareOrMiddlewareAndTypedHandler[middlewareOrMiddlewareAndTypedHandler.length - 1];
       if (isTypedHandler(maybeTypedHandler)) {
         const { contractDetails, handlers } = maybeTypedHandler;
-        this.registerRoute(
+        const router = this.registerRoute(
           method,
           path,
           registrationMethod,
           contractDetails,
           ...middlewareOrMiddlewareAndTypedHandler.concat(handlers)
         );
-        return this;
+        return router;
       } else {
         if (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler) || isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
           throw new Error("Contract details are not defined");
@@ -1021,6 +1144,17 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
             "Contract details are malformed for route definition"
           );
         }
+        if (contractDetails.versions) {
+          const parserTypes = Object.values(contractDetails.versions).map(
+            (version) => discriminateBody(this.schemaValidator, version.body)?.parserType
+          );
+          const allParserTypesSame = parserTypes.length === 0 || parserTypes.every((pt) => pt === parserTypes[0]);
+          if (!allParserTypesSame) {
+            throw new Error(
+              "All versioned contractDetails must have the same parsing type for body."
+            );
+          }
+        }
         this.routes.push({
           basePath: this.basePath,
           path,
@@ -1029,22 +1163,39 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
         });
         const { requestSchema, responseSchemas } = this.#compile(contractDetails);
         const controllerHandler = this.#extractControllerHandler(handlers);
+        const resolvedMiddlewares = this.#resolveMiddlewares(
+          path,
+          contractDetails,
+          requestSchema,
+          responseSchemas
+        ).concat(handlers);
         registrationMethod.bind(this.internal)(
           path,
-          ...this.#resolveMiddlewares(
-            path,
-            contractDetails,
-            requestSchema,
-            responseSchemas
-          ).concat(handlers),
+          ...resolvedMiddlewares,
           this.#parseAndRunControllerHandler(controllerHandler)
         );
-        const localParamRequest = this.#localParamRequest(
-          handlers,
-          controllerHandler
+        toRecord(this._fetchMap)[sanitizePathSlashes(`${this.basePath}${path}`)] = {
+          ...this._fetchMap[sanitizePathSlashes(`${this.basePath}${path}`)] ?? {},
+          [method.toUpperCase()]: contractDetails.versions ? Object.fromEntries(
+            Object.keys(contractDetails.versions).map((version) => [
+              version,
+              this.#localParamRequest(handlers, controllerHandler, version)
+            ])
+          ) : this.#localParamRequest(handlers, controllerHandler)
+        };
+        toRecord(this.sdk)[toPrettyCamelCase(contractDetails.name)] = contractDetails.versions ? Object.fromEntries(
+          Object.keys(contractDetails.versions).map((version) => [
+            version,
+            (req) => this.#localParamRequest(
+              handlers,
+              controllerHandler,
+              version
+            )(`${this.basePath}${path}`, req)
+          ])
+        ) : (req) => this.#localParamRequest(handlers, controllerHandler)(
+          `${this.basePath}${path}`,
+          req
         );
-        toRecord(this.fetchMap)[sanitizePathSlashes(`${this.basePath}${path}`)] = localParamRequest;
-        toRecord(this.sdk)[toPrettyCamelCase(contractDetails.name ?? this.basePath)] = (req) => localParamRequest(`${this.basePath}${path}`, req);
         return this;
       }
     }
@@ -1130,8 +1281,8 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
     return this;
   }
   addRouterToSdk(router) {
-    Object.entries(router.fetchMap).map(
-      ([key, value]) => toRecord(this.fetchMap)[sanitizePathSlashes(`${this.basePath}${key}`)] = value
+    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)] = {
@@ -1391,8 +1542,9 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
   cloneInternals(clone) {
     clone.routers = [...this.routers];
     clone.routes = [...this.routes];
-    clone.fetchMap = { ...this.fetchMap };
+    clone._fetchMap = { ...this._fetchMap };
     clone.sdk = { ...this.sdk };
+    clone.sdkPaths = { ...this.sdkPaths };
   }
   clone() {
     const clone = new _ForklaunchExpressLikeRouter(
@@ -1400,8 +1552,7 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
       this.schemaValidator,
       this.internal,
       this.postEnrichMiddleware,
-      this.openTelemetryCollector,
-      this.sdkName
+      this.openTelemetryCollector
     );
     this.cloneInternals(clone);
     return clone;
@@ -1456,9 +1607,13 @@ function typedHandler(_schemaValidator, pathOrContractMethod, contractMethodOrCo
       throw new Error("Invalid definition for handler");
     }
   }
+  if (isPath(pathOrContractMethod) && typeof contractMethodOrContractDetails !== "string") {
+    throw new Error("Contract method not supplied, bailing");
+  }
   return {
     _typedHandler: true,
     _path: isPath(pathOrContractMethod) ? pathOrContractMethod : void 0,
+    _method: isPath(pathOrContractMethod) ? contractMethodOrContractDetails : pathOrContractMethod,
     contractDetails,
     handlers
   };
@@ -2498,37 +2653,57 @@ var getCodeForStatus = (status) => {
 var httpStatusCodes_default = HTTPStatuses;
 
 // src/http/mcpGenerator/mcpGenerator.ts
-import { isNever as isNever3, isRecord, safeStringify as safeStringify2 } from "@forklaunch/common";
+import { isNever as isNever3, isRecord as isRecord3, safeStringify as safeStringify2 } from "@forklaunch/common";
 import { string, ZodSchemaValidator } from "@forklaunch/validator/zod";
 import { FastMCP } from "fastmcp";
 
+// src/http/guards/isVersionedInputSchema.ts
+function isUnionable(schema) {
+  return schema.length > 1;
+}
+
 // src/http/router/unpackRouters.ts
-import { toPrettyCamelCase as toPrettyCamelCase2 } from "@forklaunch/common";
-function unpackRouters(routers, recursiveBasePath = [], recursiveSdkPath = []) {
+function unpackRouters(routers, recursiveBasePath = []) {
   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)
-        ]
-      )
+      ...unpackRouters(router.routers, [
+        ...recursiveBasePath,
+        router.basePath
+      ])
     );
     return acc;
   }, []);
 }
 
 // src/http/mcpGenerator/mcpGenerator.ts
+function generateInputSchema(schemaValidator, body, params, query, requestHeaders, auth) {
+  let discriminatedBody;
+  if (body) {
+    discriminatedBody = discriminateBody(schemaValidator, body);
+  }
+  return schemaValidator.schemify({
+    ...discriminatedBody && body ? {
+      ..."contentType" in body ? { contentType: body.contentType } : {},
+      body: schemaValidator.schemify(discriminatedBody.schema)
+    } : {},
+    ...params ? { params: schemaValidator.schemify(params) } : {},
+    ...query ? { query: schemaValidator.schemify(query) } : {},
+    ...requestHeaders ? {
+      headers: schemaValidator.schemify({
+        ...requestHeaders,
+        ...auth ? {
+          [auth.headerName ?? "authorization"]: string.startsWith(
+            auth.tokenPrefix ?? ("basic" in auth ? "Basic " : "Bearer ")
+          )
+        } : {}
+      })
+    } : {}
+  });
+}
 function generateMcpServer(schemaValidator, protocol, host, port, version, routers, options2, contentTypeMap) {
   if (!(schemaValidator instanceof ZodSchemaValidator)) {
     throw new Error(
@@ -2542,35 +2717,36 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, route
   });
   unpackRouters(routers).forEach(({ fullPath, router }) => {
     router.routes.forEach((route) => {
-      let discriminatedBody;
-      if ("body" in route.contractDetails) {
-        discriminatedBody = discriminateBody(
-          schemaValidator,
-          route.contractDetails.body
+      const inputSchemas = [];
+      if (route.contractDetails.versions) {
+        Object.values(route.contractDetails.versions).forEach((version2) => {
+          inputSchemas.push(
+            generateInputSchema(
+              schemaValidator,
+              version2.body,
+              route.contractDetails.params,
+              version2.query,
+              version2.requestHeaders,
+              route.contractDetails.auth
+            )
+          );
+        });
+      } else {
+        inputSchemas.push(
+          generateInputSchema(
+            schemaValidator,
+            route.contractDetails.body,
+            route.contractDetails.params,
+            route.contractDetails.query,
+            route.contractDetails.requestHeaders,
+            route.contractDetails.auth
+          )
         );
       }
-      const inputSchema = schemaValidator.schemify({
-        ...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,
-            ...route.contractDetails.auth ? {
-              [route.contractDetails.auth.headerName ?? "authorization"]: string.startsWith(
-                route.contractDetails.auth.tokenPrefix ?? ("basic" in route.contractDetails.auth ? "Basic " : "Bearer ")
-              )
-            } : {}
-          })
-        } : {}
-      });
       mcpServer.addTool({
         name: route.contractDetails.name,
         description: route.contractDetails.summary,
-        parameters: inputSchema,
+        parameters: isUnionable(inputSchemas) ? schemaValidator.union(inputSchemas) : inputSchemas[0],
         execute: async (args) => {
           const { contentType, body, params, query, headers } = args;
           let url = `${protocol}://${host}:${port}${fullPath}${route.path}`;
@@ -2582,6 +2758,22 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, route
               );
             }
           }
+          let bodySchema;
+          let responsesSchemas;
+          if (route.contractDetails.versions) {
+            Object.values(route.contractDetails.versions).forEach(
+              (version2, index) => {
+                if (version2.body && schemaValidator.parse(inputSchemas[index], args).ok) {
+                  bodySchema = version2.body;
+                  responsesSchemas = version2.responses;
+                }
+              }
+            );
+          } else {
+            bodySchema = route.contractDetails.body;
+            responsesSchemas = route.contractDetails.responses;
+          }
+          const discriminatedBody = bodySchema ? discriminateBody(schemaValidator, bodySchema) : void 0;
           let parsedBody;
           if (discriminatedBody) {
             switch (discriminatedBody.parserType) {
@@ -2599,7 +2791,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, route
               }
               case "multipart": {
                 const formData = new FormData();
-                if (isRecord(body)) {
+                if (isRecord3(body)) {
                   for (const key in body) {
                     if (typeof body[key] === "string" || body[key] instanceof Blob) {
                       formData.append(key, body[key]);
@@ -2614,7 +2806,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, route
                 break;
               }
               case "urlEncoded": {
-                if (isRecord(body)) {
+                if (isRecord3(body)) {
                   parsedBody = new URLSearchParams(
                     Object.entries(body).map(([key, value]) => [
                       key,
@@ -2657,9 +2849,12 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, route
               `Error received while proxying request to ${url}: ${await response.text()}`
             );
           }
+          if (!responsesSchemas) {
+            throw new Error("No responses schemas found");
+          }
           const contractContentType = discriminateResponseBodies(
             schemaValidator,
-            route.contractDetails.responses
+            responsesSchemas
           )[response.status].contentType;
           switch (contentTypeMap && contentTypeMap[contractContentType] ? contentTypeMap[contractContentType] : contractContentType) {
             case "application/json":
@@ -2715,15 +2910,56 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, route
 import {
   prettyPrintParseErrors as prettyPrintParseErrors2
 } from "@forklaunch/validator";
+
+// src/http/guards/isResponseCompiledSchema.ts
+function isResponseCompiledSchema(schema) {
+  return typeof schema === "object" && schema !== null && "responses" in schema;
+}
+
+// src/http/middleware/response/parse.middleware.ts
 function parse2(req, res, next) {
-  const { headers, responses } = res.responseSchemas;
+  let headers;
+  let responses;
+  const responseSchemas = res.responseSchemas;
+  const schemaValidator = req.schemaValidator;
+  if (!isResponseCompiledSchema(responseSchemas)) {
+    const parsedVersions = req._parsedVersions;
+    if (typeof parsedVersions === "number") {
+      throw new Error("Request failed to parse given version map");
+    }
+    const mappedHeaderSchemas = parsedVersions.map(
+      (version) => responseSchemas[version].headers
+    );
+    const mappedResponseSchemas = parsedVersions.map(
+      (version) => responseSchemas[version].responses
+    );
+    const collapsedResponseSchemas = mappedResponseSchemas.reduce((acc, responseSchema) => {
+      Object.entries(responseSchema).forEach(([status, schema]) => {
+        if (!acc[Number(status)]) {
+          acc[Number(status)] = [];
+        }
+        acc[Number(status)].push(schema);
+      });
+      return acc;
+    }, {});
+    headers = schemaValidator.union(mappedHeaderSchemas);
+    responses = Object.fromEntries(
+      Object.entries(collapsedResponseSchemas).map(([status, schemas]) => [
+        status,
+        schemaValidator.union(schemas)
+      ])
+    );
+  } else {
+    headers = responseSchemas.headers;
+    responses = responseSchemas.responses;
+  }
   const statusCode = Number(res.statusCode);
-  const parsedResponse = req.schemaValidator.parse(
-    responses?.[statusCode],
+  const parsedResponse = schemaValidator.parse(
+    [400, 401, 404, 403, 500].includes(statusCode) ? schemaValidator.union([schemaValidator.string, responses?.[statusCode]]) : responses?.[statusCode],
     res.bodyData
   );
-  const parsedHeaders = req.schemaValidator.parse(
-    headers ?? req.schemaValidator.unknown,
+  const parsedHeaders = schemaValidator.parse(
+    headers ?? schemaValidator.unknown,
     res.getHeaders()
   );
   const parseErrors = [];
@@ -2779,7 +3015,7 @@ import {
   isAsyncGenerator,
   isNever as isNever4,
   isNodeJsWriteableStream,
-  isRecord as isRecord2,
+  isRecord as isRecord4,
   readableStreamToAsyncIterable,
   safeStringify as safeStringify3
 } from "@forklaunch/common";
@@ -2822,9 +3058,21 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
     originalSend.call(instance, "Not Found");
     errorSent = true;
   }
+  let responses;
+  if (req.contractDetails.responses == null && (req.contractDetails.versions == null || Object.values(req.contractDetails.versions).some(
+    (version) => version?.responses == null
+  ))) {
+    throw new Error("Responses schema definitions are required");
+  } else {
+    if (req.contractDetails.responses != null) {
+      responses = req.contractDetails.responses;
+    } else {
+      responses = req.contractDetails.versions[req.version].responses;
+    }
+  }
   const responseBodies = discriminateResponseBodies(
     req.schemaValidator,
-    req.contractDetails.responses
+    responses
   );
   if (responseBodies != null && responseBodies[Number(res.statusCode)] != null) {
     res.type(responseBodies[Number(res.statusCode)].contentType);
@@ -2893,7 +3141,7 @@ ${res.locals.errorMessage}`;
   } else {
     const parserType = responseBodies?.[Number(res.statusCode)]?.parserType;
     res.bodyData = data;
-    if (isRecord2(data)) {
+    if (isRecord4(data)) {
       switch (parserType) {
         case "json":
           res.bodyData = "json" in data ? data.json : data;
@@ -2950,7 +3198,8 @@ ${res.locals.errorMessage}`;
 }
 
 // src/http/openApiV3Generator/openApiV3Generator.ts
-import { openApiCompliantPath, toPrettyCamelCase as toPrettyCamelCase3 } from "@forklaunch/common";
+import { openApiCompliantPath } from "@forklaunch/common";
+var OPENAPI_DEFAULT_VERSION = Symbol("default");
 function toUpperCase(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -2960,25 +3209,50 @@ function transformBasePath(basePath) {
   }
   return `/${basePath}`;
 }
-function generateOpenApiDocument(protocol, host, port, tags, paths, securitySchemes, otherServers) {
+function generateOpenApiDocument(protocol, host, port, versionedTags, versionedPaths, versionedSecuritySchemes, otherServers) {
   return {
-    openapi: "3.1.0",
-    info: {
-      title: process.env.API_TITLE || "",
-      version: process.env.VERSION || "1.0.0"
-    },
-    components: {
-      securitySchemes
-    },
-    tags,
-    servers: [
-      {
-        url: `${protocol}://${host}:${port}`,
-        description: "Main Server"
+    [OPENAPI_DEFAULT_VERSION]: {
+      openapi: "3.1.0",
+      info: {
+        title: process.env.API_TITLE || "API Definition",
+        version: process.env.VERSION || "latest"
+      },
+      components: {
+        securitySchemes: versionedSecuritySchemes[OPENAPI_DEFAULT_VERSION]
       },
-      ...otherServers || []
-    ],
-    paths
+      tags: versionedTags[OPENAPI_DEFAULT_VERSION],
+      servers: [
+        {
+          url: `${protocol}://${host}:${port}`,
+          description: "Main Server"
+        },
+        ...otherServers || []
+      ],
+      paths: versionedPaths[OPENAPI_DEFAULT_VERSION]
+    },
+    ...Object.fromEntries(
+      Object.entries(versionedPaths).map(([version, paths]) => [
+        version,
+        {
+          openapi: "3.1.0",
+          info: {
+            title: process.env.API_TITLE || "API Definition",
+            version
+          },
+          components: {
+            securitySchemes: versionedSecuritySchemes[version]
+          },
+          tags: versionedTags[version],
+          servers: [
+            {
+              url: `${protocol}://${host}:${port}`,
+              description: "Main Server"
+            }
+          ],
+          paths
+        }
+      ])
+    )
   };
 }
 function contentResolver(schemaValidator, body, contentType) {
@@ -2997,143 +3271,232 @@ function contentResolver(schemaValidator, body, contentType) {
     }
   };
 }
-function generateSwaggerDocument(schemaValidator, protocol, host, port, routers, otherServers) {
-  const tags = [];
-  const paths = {};
-  const securitySchemes = {};
-  unpackRouters(routers).forEach(({ fullPath, router, sdkPath }) => {
+function generateOperationObject(schemaValidator, path, method, controllerName, sdkPaths, securitySchemes, name, summary, responses, params, responseHeaders, requestHeaders, query, body, auth) {
+  const typedSchemaValidator = schemaValidator;
+  const coercedResponses = {};
+  const discriminatedResponseBodiesResult = discriminateResponseBodies(
+    schemaValidator,
+    responses
+  );
+  for (const key in discriminatedResponseBodiesResult) {
+    coercedResponses[key] = {
+      description: httpStatusCodes_default[key],
+      content: contentResolver(
+        schemaValidator,
+        discriminatedResponseBodiesResult[key].schema,
+        discriminatedResponseBodiesResult[key].contentType
+      ),
+      headers: responseHeaders ? Object.fromEntries(
+        Object.entries(responseHeaders).map(([key2, value]) => [
+          key2,
+          {
+            schema: typedSchemaValidator.openapi(value)
+          }
+        ])
+      ) : void 0
+    };
+  }
+  const commonErrors = [400, 404, 500];
+  for (const error of commonErrors) {
+    if (!(error in responses)) {
+      coercedResponses[error] = {
+        description: httpStatusCodes_default[error],
+        content: contentResolver(schemaValidator, schemaValidator.string)
+      };
+    }
+  }
+  const operationObject = {
+    tags: [controllerName],
+    summary: `${name}: ${summary}`,
+    parameters: [],
+    responses: coercedResponses,
+    operationId: sdkPaths[[method, path].join(".")]
+  };
+  if (params) {
+    for (const key in params) {
+      operationObject.parameters?.push({
+        name: key,
+        in: "path",
+        schema: typedSchemaValidator.openapi(params[key])
+      });
+    }
+  }
+  const discriminatedBodyResult = body ? discriminateBody(schemaValidator, body) : null;
+  if (discriminatedBodyResult) {
+    operationObject.requestBody = {
+      required: true,
+      content: contentResolver(
+        schemaValidator,
+        discriminatedBodyResult.schema,
+        discriminatedBodyResult.contentType
+      )
+    };
+  }
+  if (requestHeaders) {
+    for (const key in requestHeaders) {
+      operationObject.parameters?.push({
+        name: key,
+        in: "header",
+        schema: typedSchemaValidator.openapi(requestHeaders[key])
+      });
+    }
+  }
+  if (query) {
+    for (const key in query) {
+      operationObject.parameters?.push({
+        name: key,
+        in: "query",
+        schema: typedSchemaValidator.openapi(query[key])
+      });
+    }
+  }
+  if (auth) {
+    responses[401] = {
+      description: httpStatusCodes_default[401],
+      content: contentResolver(schemaValidator, schemaValidator.string)
+    };
+    responses[403] = {
+      description: httpStatusCodes_default[403],
+      content: contentResolver(schemaValidator, schemaValidator.string)
+    };
+    if ("basic" in auth) {
+      operationObject.security = [
+        {
+          basic: Array.from(
+            "allowedPermissions" in auth ? auth.allowedPermissions?.values() || [] : []
+          )
+        }
+      ];
+      securitySchemes["basic"] = {
+        type: "http",
+        scheme: "basic"
+      };
+    } else if (auth) {
+      operationObject.security = [
+        {
+          [auth.headerName !== "Authorization" ? "bearer" : "apiKey"]: Array.from(
+            "allowedPermissions" in auth ? auth.allowedPermissions?.values() || [] : []
+          )
+        }
+      ];
+      if (auth.headerName && auth.headerName !== "Authorization") {
+        securitySchemes[auth.headerName] = {
+          type: "apiKey",
+          in: "header",
+          name: auth.headerName
+        };
+      } else {
+        securitySchemes["Authorization"] = {
+          type: "http",
+          scheme: "bearer",
+          bearerFormat: "JWT"
+        };
+      }
+    }
+  }
+  return operationObject;
+}
+function generateOpenApiSpecs(schemaValidator, protocol, host, port, routers, otherServers) {
+  const versionedPaths = {
+    [OPENAPI_DEFAULT_VERSION]: {}
+  };
+  const versionedTags = {
+    [OPENAPI_DEFAULT_VERSION]: []
+  };
+  const versionedSecuritySchemes = {
+    [OPENAPI_DEFAULT_VERSION]: {}
+  };
+  unpackRouters(routers).forEach(({ fullPath, router }) => {
     const controllerName = transformBasePath(fullPath);
-    tags.push({
-      name: controllerName,
-      description: `${toUpperCase(controllerName)} Operations`
-    });
     router.routes.forEach((route) => {
       const openApiPath = openApiCompliantPath(
         `${fullPath}${route.path === "/" ? "" : route.path}`
       );
-      if (!paths[openApiPath]) {
-        paths[openApiPath] = {};
-      }
-      const { name, summary, query, requestHeaders } = route.contractDetails;
-      const responses = {};
-      const discriminatedResponseBodiesResult = discriminateResponseBodies(
-        schemaValidator,
-        route.contractDetails.responses
-      );
-      for (const key in discriminatedResponseBodiesResult) {
-        responses[key] = {
-          description: httpStatusCodes_default[key],
-          content: contentResolver(
+      const { name, summary, params, versions, auth } = route.contractDetails;
+      if (versions) {
+        for (const version of Object.keys(versions)) {
+          if (!versionedPaths[version]) {
+            versionedPaths[version] = {};
+          }
+          if (!versionedPaths[version][openApiPath]) {
+            versionedPaths[version][openApiPath] = {};
+          }
+          if (!versionedTags[version]) {
+            versionedTags[version] = [];
+          }
+          if (!versionedTags[version].find((tag) => tag.name === controllerName)) {
+            versionedTags[version].push({
+              name: controllerName,
+              description: `${toUpperCase(controllerName)} Operations`
+            });
+          }
+          if (!versionedSecuritySchemes[version]) {
+            versionedSecuritySchemes[version] = {};
+          }
+          const { query, requestHeaders, body, responses, responseHeaders } = versions[version];
+          const operationObject = generateOperationObject(
             schemaValidator,
-            discriminatedResponseBodiesResult[key].schema,
-            discriminatedResponseBodiesResult[key].contentType
-          )
-        };
-      }
-      const commonErrors = [400, 404, 500];
-      for (const error of commonErrors) {
-        if (!(error in responses)) {
-          responses[error] = {
-            description: httpStatusCodes_default[error],
-            content: contentResolver(schemaValidator, schemaValidator.string)
-          };
+            route.path,
+            route.method,
+            controllerName,
+            router.sdkPaths,
+            versionedSecuritySchemes[version],
+            name,
+            summary,
+            responses,
+            params,
+            responseHeaders,
+            requestHeaders,
+            query,
+            body,
+            auth
+          );
+          if (route.method !== "middleware") {
+            versionedPaths[version][openApiPath][route.method] = operationObject;
+          }
         }
-      }
-      const operationObject = {
-        tags: [controllerName],
-        summary: `${name}: ${summary}`,
-        parameters: [],
-        responses,
-        operationId: `${sdkPath}.${toPrettyCamelCase3(name)}`
-      };
-      if (route.contractDetails.params) {
-        for (const key in route.contractDetails.params) {
-          operationObject.parameters?.push({
-            name: key,
-            in: "path",
-            schema: schemaValidator.openapi(
-              route.contractDetails.params[key]
-            )
-          });
+      } else {
+        if (!versionedPaths[OPENAPI_DEFAULT_VERSION]) {
+          versionedPaths[OPENAPI_DEFAULT_VERSION] = {};
         }
-      }
-      const discriminatedBodyResult = "body" in route.contractDetails ? discriminateBody(schemaValidator, route.contractDetails.body) : null;
-      if (discriminatedBodyResult) {
-        operationObject.requestBody = {
-          required: true,
-          content: contentResolver(
-            schemaValidator,
-            discriminatedBodyResult.schema,
-            discriminatedBodyResult.contentType
-          )
-        };
-      }
-      if (requestHeaders) {
-        for (const key in requestHeaders) {
-          operationObject.parameters?.push({
-            name: key,
-            in: "header",
-            schema: schemaValidator.openapi(
-              requestHeaders[key]
-            )
-          });
+        if (!versionedPaths[OPENAPI_DEFAULT_VERSION][openApiPath]) {
+          versionedPaths[OPENAPI_DEFAULT_VERSION][openApiPath] = {};
         }
-      }
-      if (query) {
-        for (const key in query) {
-          operationObject.parameters?.push({
-            name: key,
-            in: "query",
-            schema: schemaValidator.openapi(query[key])
+        if (!versionedTags[OPENAPI_DEFAULT_VERSION]) {
+          versionedTags[OPENAPI_DEFAULT_VERSION] = [];
+        }
+        if (!versionedTags[OPENAPI_DEFAULT_VERSION].find(
+          (tag) => tag.name === controllerName
+        )) {
+          versionedTags[OPENAPI_DEFAULT_VERSION].push({
+            name: controllerName,
+            description: `${toUpperCase(controllerName)} Operations`
           });
         }
-      }
-      if (route.contractDetails.auth) {
-        responses[401] = {
-          description: httpStatusCodes_default[401],
-          content: contentResolver(schemaValidator, schemaValidator.string)
-        };
-        responses[403] = {
-          description: httpStatusCodes_default[403],
-          content: contentResolver(schemaValidator, schemaValidator.string)
-        };
-        if ("basic" in route.contractDetails.auth) {
-          operationObject.security = [
-            {
-              basic: Array.from(
-                "allowedPermissions" in route.contractDetails.auth ? route.contractDetails.auth.allowedPermissions?.values() || [] : []
-              )
-            }
-          ];
-          securitySchemes["basic"] = {
-            type: "http",
-            scheme: "basic"
-          };
-        } else if (route.contractDetails.auth) {
-          operationObject.security = [
-            {
-              [route.contractDetails.auth.headerName !== "Authorization" ? "bearer" : "apiKey"]: Array.from(
-                "allowedPermissions" in route.contractDetails.auth ? route.contractDetails.auth.allowedPermissions?.values() || [] : []
-              )
-            }
-          ];
-          if (route.contractDetails.auth.headerName && route.contractDetails.auth.headerName !== "Authorization") {
-            securitySchemes[route.contractDetails.auth.headerName] = {
-              type: "apiKey",
-              in: "header",
-              name: route.contractDetails.auth.headerName
-            };
-          } else {
-            securitySchemes["Authorization"] = {
-              type: "http",
-              scheme: "bearer",
-              bearerFormat: "JWT"
-            };
-          }
+        if (!versionedSecuritySchemes[OPENAPI_DEFAULT_VERSION]) {
+          versionedSecuritySchemes[OPENAPI_DEFAULT_VERSION] = {};
+        }
+        const { query, requestHeaders, body, responses, responseHeaders } = route.contractDetails;
+        const operationObject = generateOperationObject(
+          schemaValidator,
+          route.path,
+          route.method,
+          controllerName,
+          router.sdkPaths,
+          versionedSecuritySchemes[OPENAPI_DEFAULT_VERSION],
+          name,
+          summary,
+          responses,
+          params,
+          responseHeaders,
+          requestHeaders,
+          query,
+          body,
+          auth
+        );
+        if (route.method !== "middleware") {
+          versionedPaths[OPENAPI_DEFAULT_VERSION][openApiPath][route.method] = operationObject;
         }
-      }
-      if (route.method !== "middleware") {
-        paths[openApiPath][route.method] = operationObject;
       }
     });
   });
@@ -3141,13 +3504,116 @@ function generateSwaggerDocument(schemaValidator, protocol, host, port, routers,
     protocol,
     host,
     port,
-    tags,
-    paths,
-    securitySchemes,
+    versionedTags,
+    versionedPaths,
+    versionedSecuritySchemes,
     otherServers
   );
 }
 
+// src/http/sdk/sdkClient.ts
+import { hashString, safeStringify as safeStringify4, toRecord as toRecord2 } from "@forklaunch/common";
+
+// src/http/guards/isSdkRouter.ts
+function isSdkRouter(value) {
+  return typeof value === "object" && value !== null && "sdk" in value && "_fetchMap" in value && "sdkPaths" in value;
+}
+
+// src/http/sdk/sdkClient.ts
+function mapToSdk(schemaValidator, routerMap, runningPath = void 0) {
+  const routerUniquenessCache = /* @__PURE__ */ new Set();
+  return Object.fromEntries(
+    Object.entries(routerMap).map(([key, value]) => {
+      if (routerUniquenessCache.has(hashString(safeStringify4(value)))) {
+        throw new Error(
+          `SdkClient: Cannot use the same router pointer twice. Please clone the duplicate router with .clone() or only use the router once.`
+        );
+      }
+      routerUniquenessCache.add(hashString(safeStringify4(value)));
+      const currentPath = runningPath ? [runningPath, key].join(".") : key;
+      if (isSdkRouter(value)) {
+        Object.entries(value.sdkPaths).forEach(([routePath, sdkKey]) => {
+          if ("controllerSdkPaths" in value && Array.isArray(value.controllerSdkPaths) && value.controllerSdkPaths.includes(routePath)) {
+            value.sdkPaths[routePath] = [currentPath, sdkKey].join(".");
+          }
+        });
+        return [key, value.sdk];
+      } else {
+        return [
+          key,
+          mapToSdk(
+            schemaValidator,
+            value,
+            runningPath ? [runningPath, key].join(".") : key
+          )
+        ];
+      }
+    })
+  );
+}
+function flattenFetchMap(schemaValidator, routerMap) {
+  const _fetchMap = Object.entries(routerMap).reduce(
+    (acc, [, value]) => {
+      if ("_fetchMap" in value) {
+        return {
+          ...acc,
+          ...value._fetchMap
+        };
+      } else {
+        return {
+          ...acc,
+          ...flattenFetchMap(schemaValidator, value)
+        };
+      }
+    },
+    {}
+  );
+  return _fetchMap;
+}
+function mapToFetch(schemaValidator, routerMap) {
+  const flattenedFetchMap = flattenFetchMap(
+    schemaValidator,
+    routerMap
+  );
+  return (path, ...reqInit) => {
+    const method = reqInit[0]?.method;
+    const version = reqInit[0] != null && "version" in reqInit[0] ? reqInit[0].version : void 0;
+    return (version ? toRecord2(toRecord2(flattenedFetchMap[path])[method ?? "GET"])[version] : toRecord2(flattenedFetchMap[path])[method ?? "GET"])(path, reqInit[0]);
+  };
+}
+function sdkClient(schemaValidator, routerMap) {
+  return {
+    _finalizedSdk: true,
+    sdk: mapToSdk(schemaValidator, routerMap),
+    fetch: mapToFetch(schemaValidator, routerMap)
+  };
+}
+
+// src/http/sdk/sdkRouter.ts
+import { toPrettyCamelCase as toPrettyCamelCase2 } from "@forklaunch/common";
+function sdkRouter(schemaValidator, controller, router) {
+  const controllerSdkPaths = [];
+  const mappedSdk = Object.fromEntries(
+    Object.entries(controller).map(([key, value]) => {
+      const sdkPath = [value._method, value._path].join(".");
+      controllerSdkPaths.push(sdkPath);
+      router.sdkPaths[sdkPath] = key;
+      return [
+        key,
+        router.sdk[toPrettyCamelCase2(value.contractDetails.name)]
+      ];
+    })
+  );
+  const _fetchMap = router._fetchMap;
+  return {
+    sdk: mappedSdk,
+    fetch: router.fetch,
+    _fetchMap,
+    sdkPaths: router.sdkPaths,
+    controllerSdkPaths
+  };
+}
+
 // src/http/telemetry/evaluateTelemetryOptions.ts
 function evaluateTelemetryOptions(telemetryOptions) {
   return {
@@ -3178,6 +3644,7 @@ export {
   ForklaunchExpressLikeApplication,
   ForklaunchExpressLikeRouter,
   HTTPStatuses,
+  OPENAPI_DEFAULT_VERSION,
   OpenTelemetryCollector,
   delete_,
   discriminateBody,
@@ -3185,7 +3652,7 @@ export {
   enrichExpressLikeSend,
   evaluateTelemetryOptions,
   generateMcpServer,
-  generateSwaggerDocument,
+  generateOpenApiSpecs,
   get,
   getCodeForStatus,
   head,
@@ -3208,6 +3675,8 @@ export {
   post,
   put,
   recordMetric,
+  sdkClient,
+  sdkRouter,
   trace3 as trace,
   typedAuthHandler,
   typedHandler