@forklaunch/core 0.15.3 → 0.15.5

package/lib/http/index.js

@@ -3100,11 +3100,6 @@ var import_common10 = require("@forklaunch/common");
 var import_fastmcp_fork = require("@forklaunch/fastmcp-fork");
 var import_zod = require("@forklaunch/validator/zod");
 
-// src/http/guards/isVersionedInputSchema.ts
-function isUnionable(schema) {
-  return schema.length > 1;
-}
-
 // src/http/router/unpackRouters.ts
 function unpackRouters(routers, recursiveBasePath = []) {
   return routers.reduce((acc, router) => {
@@ -3134,8 +3129,12 @@ function generateInputSchema(schemaValidator, body, params, query, requestHeader
       ..."contentType" in body ? { contentType: body.contentType } : {},
       body: schemaValidator.schemify(discriminatedBody.schema)
     } : {},
-    ...params ? { params: schemaValidator.schemify(params) } : {},
-    ...query ? { query: schemaValidator.schemify(query) } : {},
+    ...params ? {
+      params: schemaValidator.schemify(params)
+    } : {},
+    ...query ? {
+      query: schemaValidator.schemify(query)
+    } : {},
     ...requestHeaders ? {
       headers: schemaValidator.schemify({
         ...requestHeaders,
@@ -3198,163 +3197,172 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
           )
         );
       }
-      mcpServer.addTool({
-        name: route.contractDetails.name,
-        description: route.contractDetails.summary,
-        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}`;
-          if (params) {
-            for (const key in params) {
-              url = url.replace(
-                `:${key}`,
-                encodeURIComponent(params[key])
-              );
-            }
-          }
-          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) {
-              case "json": {
-                parsedBody = (0, import_common10.safeStringify)(body);
-                break;
+      inputSchemas.forEach((inputSchema, index) => {
+        mcpServer.addTool({
+          name: route.contractDetails.name + (Object.keys(route.contractDetails.versions ?? {}).length > 1 ? ` [v${Object.keys(route.contractDetails.versions ?? {})[index]}]` : ""),
+          description: route.contractDetails.summary,
+          parameters: inputSchema,
+          execute: 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])
+                );
               }
-              case "text": {
-                parsedBody = body;
-                break;
-              }
-              case "file": {
-                parsedBody = body;
-                break;
+            }
+            let bodySchema;
+            let responsesSchemas;
+            if (route.contractDetails.versions) {
+              const version2 = route.contractDetails.versions[index];
+              if (version2.body && schemaValidator.parse(inputSchema, args).ok) {
+                bodySchema = version2.body;
+                responsesSchemas = version2.responses;
               }
-              case "multipart": {
-                const formData = new FormData();
-                if ((0, import_common10.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 {
+              bodySchema = route.contractDetails.body;
+              responsesSchemas = route.contractDetails.responses;
+            }
+            const discriminatedBody = bodySchema ? discriminateBody(schemaValidator, bodySchema) : void 0;
+            let parsedBody;
+            if (discriminatedBody) {
+              switch (discriminatedBody.parserType) {
+                case "json": {
+                  parsedBody = (0, import_common10.safeStringify)(body);
+                  break;
+                }
+                case "text": {
+                  parsedBody = body;
+                  break;
+                }
+                case "file": {
+                  parsedBody = Buffer.from((0, import_common10.safeStringify)(body));
+                  break;
+                }
+                case "multipart": {
+                  const formData = new FormData();
+                  if ((0, import_common10.isRecord)(body)) {
+                    for (const key in body) {
+                      if (typeof body[key] === "string") {
+                        if (schemaValidator.isInstanceOf(
+                          body[key],
+                          schemaValidator.file
+                        )) {
+                          formData.append(
+                            key,
+                            new Blob([Buffer.from(body[key])])
+                          );
+                        } else {
+                          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");
                   }
-                } else {
-                  throw new Error("Body is not a valid multipart object");
+                  parsedBody = formData;
+                  break;
                 }
-                parsedBody = formData;
-                break;
-              }
-              case "urlEncoded": {
-                if ((0, import_common10.isRecord)(body)) {
-                  parsedBody = new URLSearchParams(
-                    Object.entries(body).map(([key, value]) => [
-                      key,
-                      (0, import_common10.safeStringify)(value)
-                    ])
-                  );
-                } else {
-                  throw new Error("Body is not a valid url encoded object");
+                case "urlEncoded": {
+                  if ((0, import_common10.isRecord)(body)) {
+                    parsedBody = new URLSearchParams(
+                      Object.entries(body).map(([key, value]) => [
+                        key,
+                        (0, import_common10.safeStringify)(value)
+                      ])
+                    );
+                  } else {
+                    throw new Error("Body is not a valid url encoded object");
+                  }
+                  break;
+                }
+                default: {
+                  (0, import_common10.isNever)(discriminatedBody.parserType);
+                  parsedBody = (0, import_common10.safeStringify)(body);
+                  break;
                 }
-                break;
-              }
-              default: {
-                (0, import_common10.isNever)(discriminatedBody.parserType);
-                parsedBody = (0, import_common10.safeStringify)(body);
-                break;
               }
             }
-          }
-          if (query) {
-            const queryString = new URLSearchParams(
-              Object.entries(query).map(([key, value]) => [
-                key,
-                (0, import_common10.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()}`
-            );
-          }
-          if (!responsesSchemas) {
-            throw new Error("No responses schemas found");
-          }
-          const contractContentType = discriminateResponseBodies(
-            schemaValidator,
-            responsesSchemas
-          )[response.status].contentType;
-          switch (contentTypeMap && contentTypeMap[contractContentType] ? contentTypeMap[contractContentType] : contractContentType) {
-            case "application/json":
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: (0, import_common10.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")
+            if (query) {
+              const queryString = new URLSearchParams(
+                Object.entries(query).map(([key, value]) => [
+                  key,
+                  (0, import_common10.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()}`
+              );
+            }
+            if (!responsesSchemas) {
+              throw new Error("No responses schemas found");
+            }
+            const contractContentType = discriminateResponseBodies(
+              schemaValidator,
+              responsesSchemas
+            )[response.status].contentType;
+            switch (contentTypeMap && contentTypeMap[contractContentType] ? contentTypeMap[contractContentType] : contractContentType) {
+              case "application/json":
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: (0, import_common10.safeStringify)(await response.json())
                     }
-                  }
-                ]
-              };
-            case "text/event-stream":
-              return {
-                content: [
-                  { type: "text", text: await response.text() }
-                ]
-              };
-            default:
-              return {
-                content: [
-                  { type: "text", text: await response.text() }
-                ]
-              };
+                  ]
+                };
+              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() }
+                  ]
+                };
+            }
           }
-        }
+        });
       });
     });
   });