kleanmcp 1.0.1 → 1.0.2

package/dist/index.mjs

@@ -0,0 +1,446 @@
+// ../elysia-jsonrpc/dist/mcp.types.js
+import { z as b } from "zod/v4";
+var P = Object.create;
+var { getPrototypeOf: Q, defineProperty: m, getOwnPropertyNames: R } = Object;
+var W = Object.prototype.hasOwnProperty;
+function X(l) {
+  return this[l];
+}
+var Y;
+var Z;
+var $ = (l, u, U) => {
+  var j = l != null && typeof l === "object";
+  if (j) {
+    var A = u ? Y ??= new WeakMap : Z ??= new WeakMap, I = A.get(l);
+    if (I)
+      return I;
+  }
+  U = l != null ? P(Q(l)) : {};
+  let V = u || !l || !l.__esModule ? m(U, "default", { value: l, enumerable: true }) : U;
+  for (let F of R(l))
+    if (!W.call(V, F))
+      m(V, F, { get: X.bind(l, F), enumerable: true });
+  if (j)
+    A.set(l, V);
+  return V;
+};
+var B = (l, u) => () => (u || l((u = { exports: {} }).exports, u), u.exports);
+var C = B((v) => {
+  Object.defineProperty(v, "__esModule", { value: true });
+});
+var G = B((D) => {
+  Object.defineProperty(D, "__esModule", { value: true });
+  var d = Symbol("inverted"), i = Symbol("expectNull"), o = Symbol("expectUndefined"), y = Symbol("expectNumber"), h = Symbol("expectString"), t = Symbol("expectBoolean"), k = Symbol("expectVoid"), a = Symbol("expectFunction"), O = Symbol("expectObject"), x = Symbol("expectArray"), r = Symbol("expectSymbol"), T = Symbol("expectAny"), s = Symbol("expectUnknown"), e = Symbol("expectNever"), f = Symbol("expectNullable"), p = Symbol("expectBigInt");
+});
+var J = B((H) => {
+  Object.defineProperty(H, "__esModule", { value: true });
+});
+var L = B((K) => {
+  Object.defineProperty(K, "__esModule", { value: true });
+  var lb = Symbol("secret"), Sb = Symbol("mismatch"), cb = Symbol("avalue");
+});
+var M = B((c) => {
+  var n = c && c.__createBinding || (Object.create ? function(l, u, U, j) {
+    if (j === undefined)
+      j = U;
+    var A = Object.getOwnPropertyDescriptor(u, U);
+    if (!A || ("get" in A ? !u.__esModule : A.writable || A.configurable))
+      A = { enumerable: true, get: function() {
+        return u[U];
+      } };
+    Object.defineProperty(l, j, A);
+  } : function(l, u, U, j) {
+    if (j === undefined)
+      j = U;
+    l[j] = u[U];
+  }), w = c && c.__exportStar || function(l, u) {
+    for (var U in l)
+      if (U !== "default" && !Object.prototype.hasOwnProperty.call(u, U))
+        n(u, l, U);
+  };
+  Object.defineProperty(c, "__esModule", { value: true });
+  c.expectTypeOf = undefined;
+  w(C(), c);
+  w(G(), c);
+  w(J(), c);
+  w(L(), c);
+  var N = () => true, q = (l) => {
+    let u = ["parameters", "returns", "resolves", "not", "items", "constructorParameters", "thisParameter", "instance", "guards", "asserts", "branded"], U = { toBeAny: N, toBeUnknown: N, toBeNever: N, toBeFunction: N, toBeObject: N, toBeArray: N, toBeString: N, toBeNumber: N, toBeBoolean: N, toBeVoid: N, toBeSymbol: N, toBeNull: N, toBeUndefined: N, toBeNullable: N, toBeBigInt: N, toMatchTypeOf: N, toEqualTypeOf: N, toBeConstructibleWith: N, toMatchObjectType: N, toExtend: N, map: c.expectTypeOf, toBeCallableWith: c.expectTypeOf, extract: c.expectTypeOf, exclude: c.expectTypeOf, pick: c.expectTypeOf, omit: c.expectTypeOf, toHaveProperty: c.expectTypeOf, parameter: c.expectTypeOf };
+    return u.forEach((A) => Object.defineProperty(U, A, { get: () => (0, c.expectTypeOf)({}) })), U;
+  };
+  c.expectTypeOf = q;
+});
+var S = $(M(), 1);
+var jb = { initialize: { params: b.object({ protocolVersion: b.string(), capabilities: b.any(), clientInfo: b.any() }), result: b.object({ protocolVersion: b.string(), capabilities: b.any(), serverInfo: b.any() }) }, ping: { params: b.object({}), result: b.object({}) }, prompts: { list: { params: b.object({ cursor: b.string().optional() }), result: b.object({ prompts: b.array(b.object({ name: b.string(), description: b.string().optional(), arguments: b.array(b.object({ name: b.string(), description: b.string().optional(), required: b.boolean().optional() })).optional() })), nextCursor: b.string().optional() }), description: "" }, get: { params: b.object({ name: b.string(), arguments: b.record(b.string(), b.string()).optional() }), result: b.object({ description: b.string().optional(), messages: b.array(b.object({ role: b.enum(["user", "assistant"]), content: b.object({ type: b.literal("text"), text: b.string() }) })) }) } }, resources: { list: { params: b.object({ cursor: b.string().optional() }), result: b.object({ resources: b.array(b.object({ uri: b.string(), name: b.string(), description: b.string().optional(), mimeType: b.string().optional() })), nextCursor: b.string().optional() }) }, read: { params: b.object({ uri: b.string() }), result: b.object({ contents: b.array(b.object({ uri: b.string(), mimeType: b.string().optional(), text: b.string().optional(), blob: b.string().optional() })) }) }, subscribe: { params: b.object({ uri: b.string() }), result: b.object({}) }, templates: { list: { params: b.object({ cursor: b.string().optional() }), result: b.object({ resourceTemplates: b.array(b.object({ uriTemplate: b.string(), name: b.string(), description: b.string().optional(), mimeType: b.string().optional() })), nextCursor: b.string().optional() }) } } }, tools: { list: { params: b.object({ cursor: b.string().optional() }), result: b.object({ tools: b.array(b.object({ name: b.string(), description: b.string().optional(), inputSchema: b.object({ type: b.literal("object"), properties: b.record(b.string(), b.any()).optional(), required: b.array(b.string()).optional() }) })), nextCursor: b.string().optional() }) }, call: { params: b.object({ name: b.string(), arguments: b.record(b.string(), b.any()).optional() }), result: b.object({ content: b.array(b.object({ type: b.enum(["text", "image", "resource"]), text: b.string().optional(), data: b.string().optional(), mimeType: b.string().optional() })), isError: b.boolean().optional() }) } }, notifications: { "prompts/list_changed": null, "resources/list_changed": null, "resources/updated": null, "tools/list_changed": null, cancelled: null } };
+
+class _ extends Error {
+  args;
+  constructor(l, u) {
+    super(`MCPError: ${l} with args ${u || {}}`);
+    this.args = u;
+  }
+}
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().not.toEqualTypeOf();
+S.expectTypeOf().not.toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf({ a: 1, b: 1 }).toMatchObjectType();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+S.expectTypeOf().toEqualTypeOf();
+// ../elysia-jsonrpc/dist/rpc.types.js
+import k from "zod/v4";
+var _2 = "2.0";
+var q = "1.3.2";
+var A = k.string();
+var n = k.enum([_2]);
+var m2 = k.enum([q]);
+var G2 = k.union([k.string(), k.number(), k.null()]);
+var U = k.union([k.array(k.unknown()), k.record(k.any(), k.unknown())]).optional();
+var b2 = k.object({ code: k.number().int(), message: k.string(), data: k.unknown().optional() });
+var W2 = k.object({ jsonrpc: A, method: k.string(), params: U, id: G2 });
+var H = k.object({ jsonrpc: A, method: k.string(), params: U });
+var f = k.unknown();
+var j = k.object({ jsonrpc: A, result: f, id: G2 });
+var D = k.object({ jsonrpc: A, error: b2, id: G2 });
+var X2 = k.union([j, D]);
+var P2 = k.union([W2, H, X2]);
+var C2 = k.union([W2, H]);
+var a = k.union([X2, H]);
+var O = { ParseError: -32700, InvalidRequest: -32600, MethodNotFound: -32601, InvalidParams: -32602, InternalError: -32603 };
+var u = k.object({ name: k.string().optional(), url: k.url().optional(), email: k.email().optional() });
+var E = k.object({ name: k.string(), url: k.url().optional() });
+var I = k.object({ title: k.string(), version: k.string(), description: k.string().optional(), termsOfService: k.string().optional(), contact: u.optional(), license: E.optional() });
+var Y2 = k.object({ name: k.string(), url: k.string(), summary: k.string().optional(), description: k.string().optional(), variables: k.record(k.string(), k.any()).optional() });
+var F = k.object({ name: k.string(), summary: k.string().optional(), description: k.string().optional(), required: k.boolean().optional(), schema: k.any(), deprecated: k.boolean().optional() });
+var d = k.object({ name: k.string(), tags: k.array(k.object({ name: k.string(), description: k.string().optional() })).optional(), summary: k.string().optional(), description: k.string().optional(), externalDocs: k.object({ description: k.string().optional(), url: k.string() }).optional(), params: k.array(F).optional(), result: F, deprecated: k.boolean().optional(), servers: k.array(Y2).optional(), errors: k.array(k.any()).optional(), links: k.array(k.any()).optional(), examples: k.array(k.any()).optional(), paramStructure: k.enum(["by-name", "by-position", "either"]).optional() });
+var p = k.object({ $ref: k.string() });
+var r = k.object({ schemas: k.record(k.string(), k.any()).optional(), links: k.record(k.string(), k.any()).optional(), errors: k.record(k.string(), k.any()).optional(), examples: k.record(k.string(), k.any()).optional(), examplePairings: k.record(k.string(), k.any()).optional(), contentDescriptors: k.record(k.string(), F).optional(), tags: k.record(k.string(), k.any()).optional() });
+var s = k.object({ description: k.string().optional(), url: k.string() });
+var R2 = k.object({ openrpc: k.string(), info: I, servers: k.array(Y2).optional(), methods: k.array(k.union([d, p])), components: r.optional(), externalDocs: s.optional() });
+
+class i extends Error {
+  code;
+  message;
+  originalError;
+  constructor(v, w, y) {
+    super(`JSONRPCException ${v}: ${w}`);
+    this.code = v;
+    this.message = w;
+    this.originalError = y;
+  }
+}
+// ../elysia-jsonrpc/dist/index.js
+import G3 from "zod/v4";
+import g, { InvertedStatusMap as jG, sse as q2, StatusMap as DG } from "elysia";
+var B2 = "2.0";
+var I2 = "1.3.2";
+var j2 = G3.string();
+var b3 = G3.enum([B2]);
+var AG = G3.enum([I2]);
+var _3 = G3.union([G3.string(), G3.number(), G3.null()]);
+var D2 = G3.union([G3.array(G3.unknown()), G3.record(G3.any(), G3.unknown())]).optional();
+var n2 = G3.object({ code: G3.number().int(), message: G3.string(), data: G3.unknown().optional() });
+var V = G3.object({ jsonrpc: j2, method: G3.string(), params: D2, id: _3 });
+var M2 = G3.object({ jsonrpc: j2, method: G3.string(), params: D2 });
+var i2 = G3.unknown();
+var R3 = G3.object({ jsonrpc: j2, result: i2, id: _3 });
+var S2 = G3.object({ jsonrpc: j2, error: n2, id: _3 });
+var v = G3.union([R3, S2]);
+var LG = G3.union([V, M2, v]);
+var UG = G3.union([V, M2]);
+var kG = G3.union([v, M2]);
+var w = { ParseError: -32700, InvalidRequest: -32600, MethodNotFound: -32601, InvalidParams: -32602, InternalError: -32603 };
+var c = G3.object({ name: G3.string().optional(), url: G3.url().optional(), email: G3.email().optional() });
+var p2 = G3.object({ name: G3.string(), url: G3.url().optional() });
+var d2 = G3.object({ title: G3.string(), version: G3.string(), description: G3.string().optional(), termsOfService: G3.string().optional(), contact: c.optional(), license: p2.optional() });
+var l = G3.object({ name: G3.string(), url: G3.string(), summary: G3.string().optional(), description: G3.string().optional(), variables: G3.record(G3.string(), G3.any()).optional() });
+var x = G3.object({ name: G3.string(), summary: G3.string().optional(), description: G3.string().optional(), required: G3.boolean().optional(), schema: G3.any(), deprecated: G3.boolean().optional() });
+var a2 = G3.object({ name: G3.string(), tags: G3.array(G3.object({ name: G3.string(), description: G3.string().optional() })).optional(), summary: G3.string().optional(), description: G3.string().optional(), externalDocs: G3.object({ description: G3.string().optional(), url: G3.string() }).optional(), params: G3.array(x).optional(), result: x, deprecated: G3.boolean().optional(), servers: G3.array(l).optional(), errors: G3.array(G3.any()).optional(), links: G3.array(G3.any()).optional(), examples: G3.array(G3.any()).optional(), paramStructure: G3.enum(["by-name", "by-position", "either"]).optional() });
+var s2 = G3.object({ $ref: G3.string() });
+var o = G3.object({ schemas: G3.record(G3.string(), G3.any()).optional(), links: G3.record(G3.string(), G3.any()).optional(), errors: G3.record(G3.string(), G3.any()).optional(), examples: G3.record(G3.string(), G3.any()).optional(), examplePairings: G3.record(G3.string(), G3.any()).optional(), contentDescriptors: G3.record(G3.string(), x).optional(), tags: G3.record(G3.string(), G3.any()).optional() });
+var t = G3.object({ description: G3.string().optional(), url: G3.string() });
+var HG = G3.object({ openrpc: G3.string(), info: d2, servers: G3.array(l).optional(), methods: G3.array(G3.union([a2, s2])), components: o.optional(), externalDocs: t.optional() });
+
+class z extends Error {
+  code;
+  message;
+  originalError;
+  constructor(Q2, K, Z2) {
+    super(`JSONRPCException ${Q2}: ${K}`);
+    this.code = Q2;
+    this.message = K;
+    this.originalError = Z2;
+  }
+}
+var r2 = { version: B2, debug: false, dns_rebind_origin: undefined, rpcHandler: e, onError: undefined, onResponse: undefined, onRequest: undefined, service: null, cors: "*" };
+async function e(Q2, K, Z2) {
+  let A2 = J2(Q2, Z2.method), L2 = GG(Z2.params), U2 = await A2.apply(Q2, [L2]);
+  return { id: K, jsonrpc: "2.0", result: U2 };
+}
+function J2(Q2, K) {
+  if (!Q2)
+    throw new z(w.MethodNotFound, "Invalid Method");
+  let Z2 = Q2[K];
+  if (!Z2) {
+    let A2 = K.split("/");
+    if (A2.length > 1)
+      return J2(Q2[A2[0]], A2.slice(1).join("/"));
+    throw new z(w.MethodNotFound, "Method not found");
+  }
+  return Z2;
+}
+function y(Q2) {
+  let K = b3.safeParse(Q2);
+  if (!K.success)
+    throw new z(w.InvalidRequest, "Invalid JSON RPC Version");
+  return K.success;
+}
+function GG(Q2) {
+  let K = D2.safeParse(Q2);
+  if (!K.success)
+    throw new z(w.InvalidParams, "Invalid Params");
+  return K.data;
+}
+function KG(Q2) {
+  try {
+    let K = typeof Q2 === "string" ? JSON.parse(Q2) : Q2;
+    if (typeof Q2 == "object")
+      return K;
+    throw new z(w.ParseError, "body is not an object");
+  } catch (K) {
+    throw new z(w.ParseError, "failed json parse", K);
+  }
+}
+function E2(Q2, K, Z2 = false) {
+  return { id: Q2, jsonrpc: "2.0", error: { code: K?.code || w.InvalidRequest, message: K?.message || "InvalidRequest", data: Z2 && K ? K.originalError ?? {} : undefined } };
+}
+function QG(Q2) {
+  let K = { ...r2, ...Q2 }, Z2 = async function(X3) {
+    let $2 = null;
+    try {
+      let W3 = V.safeParse(X3), Y3 = M2.safeParse(X3 || {});
+      if (W3.success) {
+        y(W3.data.jsonrpc), $2 = W3.data?.id;
+        try {
+          if (K.onRequest)
+            K.onRequest(W3.data);
+        } catch (T) {}
+        return await K.rpcHandler(K.service, $2, W3.data);
+      } else if (Y3.success) {
+        y(Y3.data.jsonrpc);
+        try {
+          if (K.onRequest)
+            K.onRequest(Y3.data);
+        } catch (H2) {}
+      } else
+        throw new z(w.InvalidRequest, "Invalid Request", W3.error);
+    } catch (W3) {
+      let Y3 = E2($2, W3, K.debug);
+      try {
+        if (K.onError)
+          K.onError(Y3);
+      } catch (H2) {}
+      return Y3;
+    }
+  };
+  function A2() {
+    return function(X3) {
+      return X3;
+    };
+  }
+  let L2 = async function({ body: X3, set: $2 }) {
+    $2.headers["Content-Type"] = "application/json";
+    try {
+      let W3 = KG(X3);
+      if (Array.isArray(W3)) {
+        let Y3 = [];
+        if (W3.length == 0)
+          throw new z(w.InvalidRequest, "Batch empty");
+        for (let H2 of W3) {
+          let T = await Z2(H2);
+          try {
+            if (T && K.onResponse)
+              K.onResponse(T);
+          } catch (YG) {}
+          if (T)
+            Y3.push(T);
+        }
+        return Y3;
+      } else {
+        let Y3 = await Z2(W3);
+        try {
+          if (Y3 && K.onResponse)
+            K.onResponse(Y3);
+        } catch (H2) {}
+        return Y3;
+      }
+    } catch (W3) {
+      let Y3 = E2(null, W3, K.debug);
+      try {
+        if (K.onError)
+          K.onError(Y3);
+      } catch (H2) {}
+      return Y3;
+    }
+  }, U2 = new g().options("sse", async ({ set: X3 }) => {
+    X3.headers.Allow = ["GET", "POST", "OPTIONS"].join(",");
+  }).get("sse", async function* ({ set: X3 }) {
+    X3.headers["Content-Type"] = "text/event-stream";
+    for await (let $2 of [])
+      yield q2({ data: $2, event: "message" });
+    yield q2({ event: "done" });
+  }).post("sse", ({ body: X3 }) => {}), k2 = new g().options("stream", async ({ set: X3, status: $2 }) => {
+    X3.headers.Allow = ["POST", "OPTIONS"].join(",");
+  }).post("stream", L2, {}), F2 = new g().get("/openrpc.json", async ({}) => {
+    let X3 = Object.getPrototypeOf(K.service), $2 = Object.getOwnPropertyNames(X3).filter((W3) => W3 !== "constructor" && typeof K.service[W3] === "function");
+    return { openrpc: I2, info: { title: K.title || "JSON RPC Server", version: K.version }, methods: $2.map((W3) => {
+      return { name: W3, params: [], result: { name: "", schema: "" } };
+    }) };
+  });
+  return new g({ name: "jsonRPC" }).onRequest(({ request: X3, status: $2 }) => {
+    if (K.dns_rebind_origin !== undefined) {
+      if (X3.headers.get("Origin") != K.dns_rebind_origin)
+        return $2(400, "Wrong domain");
+    }
+  }).use(U2).use(k2).use(F2);
+}
+
+// src/types.ts
+function InputSchemaFromParameters(params) {
+  return {
+    type: "object",
+    properties: Object.fromEntries(Object.entries(params).map(([k2, v2]) => [
+      k2,
+      {
+        description: v2.description,
+        type: v2.type,
+        default: v2.default
+      }
+    ])),
+    required: Object.entries(params).map(([k2, v2]) => v2.required ? k2 : undefined).filter((v2) => v2 !== undefined)
+  };
+}
+function ToolArgsToParameterList(toolArgs, params) {
+  let res = [];
+  for (const param of params) {
+    res.push(toolArgs[param.name] ?? param.default ?? undefined);
+  }
+  return res;
+}
+function ToolDefinition(methodName, methodDescription, params) {
+  return (callback) => {
+    return {
+      name: methodName,
+      description: methodDescription,
+      params,
+      callback
+    };
+  };
+}
+
+// src/index.ts
+class MCPServerService {
+  serverTitle;
+  serverVersion;
+  serverInstructions;
+  getReferenceInstanceForToolCall;
+  toolsets;
+  constructor(serverTitle, serverVersion, serverInstructions, getReferenceInstanceForToolCall, toolsets) {
+    this.serverTitle = serverTitle;
+    this.serverVersion = serverVersion;
+    this.serverInstructions = serverInstructions;
+    this.getReferenceInstanceForToolCall = getReferenceInstanceForToolCall;
+    this.toolsets = toolsets;
+  }
+  initialize(params) {
+    return Promise.resolve({
+      capabilities: {
+        tools: {}
+      },
+      serverInfo: {
+        name: this.serverTitle,
+        version: this.serverVersion
+      },
+      protocolVersion: "2025-11-25",
+      instructions: this.serverInstructions
+    });
+  }
+  ping(params) {
+    return Promise.resolve({});
+  }
+  "tools/list"(params) {
+    return Promise.resolve({
+      tools: this.toolsets.flatMap((toolset) => {
+        return toolset.getTools().map((tool) => {
+          return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: InputSchemaFromParameters(tool.params)
+          };
+        });
+      })
+    });
+  }
+  getTool(toolName) {
+    for (const toolset of this.toolsets) {
+      const maybeTool = toolset.getTool(toolName);
+      if (maybeTool)
+        return maybeTool;
+    }
+    return null;
+  }
+  async "tools/call"(params) {
+    const toolName = params.name;
+    const toolArgs = params.arguments || {};
+    const tool = this.getTool(toolName);
+    if (!tool)
+      throw new _("Tool not found!", { toolName });
+    const referenceInstance = this.getReferenceInstanceForToolCall(toolName);
+    const result = await tool.callback(referenceInstance, ...ToolArgsToParameterList(toolArgs, tool.params), {});
+    return ((result2) => {
+      return {
+        toolUseId: "",
+        content: result2.content,
+        type: "tool_result",
+        isError: result2.isError || false
+      };
+    })(result);
+  }
+  "prompts/list"(params) {
+    throw new Error("Method not implemented.");
+  }
+  "prompts/get"(params) {
+    throw new Error("Method not implemented.");
+  }
+  "resources/list"(params) {
+    throw new Error("Method not implemented.");
+  }
+  "resources/read"(params) {
+    throw new Error("Method not implemented.");
+  }
+  "resources/subscribe"(params) {
+    throw new Error("Method not implemented.");
+  }
+  "resources/templates/list"(params) {
+    throw new Error("Method not implemented.");
+  }
+}
+export {
+  QG as elysiaJsonRPC,
+  MCPServerService
+};