kleanmcp 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -0,0 +1,554 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/types.ts
+var exports_types = {};
+__export(exports_types, {
+  methodDefs: () => jb,
+  defaultJSONRPCHandler: () => e,
+  ToolDefinition: () => ToolDefinition,
+  ToolArgsToParameterList: () => ToolArgsToParameterList,
+  StatusMap: () => import_elysia.StatusMap,
+  OpenRPCSupportedVersionsSchema: () => m2,
+  OpenRPCServerObjectSchema: () => Y2,
+  OpenRPCSchema: () => R2,
+  OpenRPCReferenceObjectSchema: () => p,
+  OpenRPCMethodObjectSchema: () => d,
+  OpenRPCLicenseObjectSchema: () => E,
+  OpenRPCInfoObjectSchema: () => I,
+  OpenRPCExternalDocumentationObjectSchema: () => s,
+  OpenRPCContentDescriptorSchema: () => F,
+  OpenRPCContactObjectSchema: () => u,
+  OpenRPCComponentsObjectSchema: () => r,
+  OPENRPC_VERSION: () => q,
+  MCPError: () => _,
+  JSONRPC_VERSION: () => _2,
+  JSONRPCSupportedVersionsSchema: () => n,
+  JSONRPCSchema: () => A,
+  JSONRPCResultSchema: () => f,
+  JSONRPCResultResponseSchema: () => j,
+  JSONRPCResponseSchema: () => X2,
+  JSONRPCRequestSchema: () => W2,
+  JSONRPCRequestIdSchema: () => G2,
+  JSONRPCParamsSchema: () => U,
+  JSONRPCNotificationSchema: () => H,
+  JSONRPCMessageSchema: () => P2,
+  JSONRPCHandlerReturnTypeSchema: () => a,
+  JSONRPCHandlerArgumentSchema: () => C2,
+  JSONRPCException: () => i,
+  JSONRPCErrorSchema: () => b2,
+  JSONRPCErrorResponseSchema: () => D,
+  JSONRPCErrorCode: () => O,
+  InvertedStatusMap: () => import_elysia.InvertedStatusMap,
+  InputSchemaFromParameters: () => InputSchemaFromParameters,
+  DEFAULT_OPTIONS: () => r2
+});
+module.exports = __toCommonJS(exports_types);
+
+// ../elysia-jsonrpc/dist/mcp.types.js
+var import_v4 = require("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: import_v4.z.object({ protocolVersion: import_v4.z.string(), capabilities: import_v4.z.any(), clientInfo: import_v4.z.any() }), result: import_v4.z.object({ protocolVersion: import_v4.z.string(), capabilities: import_v4.z.any(), serverInfo: import_v4.z.any() }) }, ping: { params: import_v4.z.object({}), result: import_v4.z.object({}) }, prompts: { list: { params: import_v4.z.object({ cursor: import_v4.z.string().optional() }), result: import_v4.z.object({ prompts: import_v4.z.array(import_v4.z.object({ name: import_v4.z.string(), description: import_v4.z.string().optional(), arguments: import_v4.z.array(import_v4.z.object({ name: import_v4.z.string(), description: import_v4.z.string().optional(), required: import_v4.z.boolean().optional() })).optional() })), nextCursor: import_v4.z.string().optional() }), description: "" }, get: { params: import_v4.z.object({ name: import_v4.z.string(), arguments: import_v4.z.record(import_v4.z.string(), import_v4.z.string()).optional() }), result: import_v4.z.object({ description: import_v4.z.string().optional(), messages: import_v4.z.array(import_v4.z.object({ role: import_v4.z.enum(["user", "assistant"]), content: import_v4.z.object({ type: import_v4.z.literal("text"), text: import_v4.z.string() }) })) }) } }, resources: { list: { params: import_v4.z.object({ cursor: import_v4.z.string().optional() }), result: import_v4.z.object({ resources: import_v4.z.array(import_v4.z.object({ uri: import_v4.z.string(), name: import_v4.z.string(), description: import_v4.z.string().optional(), mimeType: import_v4.z.string().optional() })), nextCursor: import_v4.z.string().optional() }) }, read: { params: import_v4.z.object({ uri: import_v4.z.string() }), result: import_v4.z.object({ contents: import_v4.z.array(import_v4.z.object({ uri: import_v4.z.string(), mimeType: import_v4.z.string().optional(), text: import_v4.z.string().optional(), blob: import_v4.z.string().optional() })) }) }, subscribe: { params: import_v4.z.object({ uri: import_v4.z.string() }), result: import_v4.z.object({}) }, templates: { list: { params: import_v4.z.object({ cursor: import_v4.z.string().optional() }), result: import_v4.z.object({ resourceTemplates: import_v4.z.array(import_v4.z.object({ uriTemplate: import_v4.z.string(), name: import_v4.z.string(), description: import_v4.z.string().optional(), mimeType: import_v4.z.string().optional() })), nextCursor: import_v4.z.string().optional() }) } } }, tools: { list: { params: import_v4.z.object({ cursor: import_v4.z.string().optional() }), result: import_v4.z.object({ tools: import_v4.z.array(import_v4.z.object({ name: import_v4.z.string(), description: import_v4.z.string().optional(), inputSchema: import_v4.z.object({ type: import_v4.z.literal("object"), properties: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional(), required: import_v4.z.array(import_v4.z.string()).optional() }) })), nextCursor: import_v4.z.string().optional() }) }, call: { params: import_v4.z.object({ name: import_v4.z.string(), arguments: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional() }), result: import_v4.z.object({ content: import_v4.z.array(import_v4.z.object({ type: import_v4.z.enum(["text", "image", "resource"]), text: import_v4.z.string().optional(), data: import_v4.z.string().optional(), mimeType: import_v4.z.string().optional() })), isError: import_v4.z.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
+var import_v42 = __toESM(require("zod/v4"));
+var _2 = "2.0";
+var q = "1.3.2";
+var A = import_v42.default.string();
+var n = import_v42.default.enum([_2]);
+var m2 = import_v42.default.enum([q]);
+var G2 = import_v42.default.union([import_v42.default.string(), import_v42.default.number(), import_v42.default.null()]);
+var U = import_v42.default.union([import_v42.default.array(import_v42.default.unknown()), import_v42.default.record(import_v42.default.any(), import_v42.default.unknown())]).optional();
+var b2 = import_v42.default.object({ code: import_v42.default.number().int(), message: import_v42.default.string(), data: import_v42.default.unknown().optional() });
+var W2 = import_v42.default.object({ jsonrpc: A, method: import_v42.default.string(), params: U, id: G2 });
+var H = import_v42.default.object({ jsonrpc: A, method: import_v42.default.string(), params: U });
+var f = import_v42.default.unknown();
+var j = import_v42.default.object({ jsonrpc: A, result: f, id: G2 });
+var D = import_v42.default.object({ jsonrpc: A, error: b2, id: G2 });
+var X2 = import_v42.default.union([j, D]);
+var P2 = import_v42.default.union([W2, H, X2]);
+var C2 = import_v42.default.union([W2, H]);
+var a = import_v42.default.union([X2, H]);
+var O = { ParseError: -32700, InvalidRequest: -32600, MethodNotFound: -32601, InvalidParams: -32602, InternalError: -32603 };
+var u = import_v42.default.object({ name: import_v42.default.string().optional(), url: import_v42.default.url().optional(), email: import_v42.default.email().optional() });
+var E = import_v42.default.object({ name: import_v42.default.string(), url: import_v42.default.url().optional() });
+var I = import_v42.default.object({ title: import_v42.default.string(), version: import_v42.default.string(), description: import_v42.default.string().optional(), termsOfService: import_v42.default.string().optional(), contact: u.optional(), license: E.optional() });
+var Y2 = import_v42.default.object({ name: import_v42.default.string(), url: import_v42.default.string(), summary: import_v42.default.string().optional(), description: import_v42.default.string().optional(), variables: import_v42.default.record(import_v42.default.string(), import_v42.default.any()).optional() });
+var F = import_v42.default.object({ name: import_v42.default.string(), summary: import_v42.default.string().optional(), description: import_v42.default.string().optional(), required: import_v42.default.boolean().optional(), schema: import_v42.default.any(), deprecated: import_v42.default.boolean().optional() });
+var d = import_v42.default.object({ name: import_v42.default.string(), tags: import_v42.default.array(import_v42.default.object({ name: import_v42.default.string(), description: import_v42.default.string().optional() })).optional(), summary: import_v42.default.string().optional(), description: import_v42.default.string().optional(), externalDocs: import_v42.default.object({ description: import_v42.default.string().optional(), url: import_v42.default.string() }).optional(), params: import_v42.default.array(F).optional(), result: F, deprecated: import_v42.default.boolean().optional(), servers: import_v42.default.array(Y2).optional(), errors: import_v42.default.array(import_v42.default.any()).optional(), links: import_v42.default.array(import_v42.default.any()).optional(), examples: import_v42.default.array(import_v42.default.any()).optional(), paramStructure: import_v42.default.enum(["by-name", "by-position", "either"]).optional() });
+var p = import_v42.default.object({ $ref: import_v42.default.string() });
+var r = import_v42.default.object({ schemas: import_v42.default.record(import_v42.default.string(), import_v42.default.any()).optional(), links: import_v42.default.record(import_v42.default.string(), import_v42.default.any()).optional(), errors: import_v42.default.record(import_v42.default.string(), import_v42.default.any()).optional(), examples: import_v42.default.record(import_v42.default.string(), import_v42.default.any()).optional(), examplePairings: import_v42.default.record(import_v42.default.string(), import_v42.default.any()).optional(), contentDescriptors: import_v42.default.record(import_v42.default.string(), F).optional(), tags: import_v42.default.record(import_v42.default.string(), import_v42.default.any()).optional() });
+var s = import_v42.default.object({ description: import_v42.default.string().optional(), url: import_v42.default.string() });
+var R2 = import_v42.default.object({ openrpc: import_v42.default.string(), info: I, servers: import_v42.default.array(Y2).optional(), methods: import_v42.default.array(import_v42.default.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
+var import_v43 = __toESM(require("zod/v4"));
+var import_elysia = __toESM(require("elysia"));
+var B2 = "2.0";
+var I2 = "1.3.2";
+var j2 = import_v43.default.string();
+var b3 = import_v43.default.enum([B2]);
+var AG = import_v43.default.enum([I2]);
+var _3 = import_v43.default.union([import_v43.default.string(), import_v43.default.number(), import_v43.default.null()]);
+var D2 = import_v43.default.union([import_v43.default.array(import_v43.default.unknown()), import_v43.default.record(import_v43.default.any(), import_v43.default.unknown())]).optional();
+var n2 = import_v43.default.object({ code: import_v43.default.number().int(), message: import_v43.default.string(), data: import_v43.default.unknown().optional() });
+var V = import_v43.default.object({ jsonrpc: j2, method: import_v43.default.string(), params: D2, id: _3 });
+var M2 = import_v43.default.object({ jsonrpc: j2, method: import_v43.default.string(), params: D2 });
+var i2 = import_v43.default.unknown();
+var R3 = import_v43.default.object({ jsonrpc: j2, result: i2, id: _3 });
+var S2 = import_v43.default.object({ jsonrpc: j2, error: n2, id: _3 });
+var v = import_v43.default.union([R3, S2]);
+var LG = import_v43.default.union([V, M2, v]);
+var UG = import_v43.default.union([V, M2]);
+var kG = import_v43.default.union([v, M2]);
+var w = { ParseError: -32700, InvalidRequest: -32600, MethodNotFound: -32601, InvalidParams: -32602, InternalError: -32603 };
+var c = import_v43.default.object({ name: import_v43.default.string().optional(), url: import_v43.default.url().optional(), email: import_v43.default.email().optional() });
+var p2 = import_v43.default.object({ name: import_v43.default.string(), url: import_v43.default.url().optional() });
+var d2 = import_v43.default.object({ title: import_v43.default.string(), version: import_v43.default.string(), description: import_v43.default.string().optional(), termsOfService: import_v43.default.string().optional(), contact: c.optional(), license: p2.optional() });
+var l = import_v43.default.object({ name: import_v43.default.string(), url: import_v43.default.string(), summary: import_v43.default.string().optional(), description: import_v43.default.string().optional(), variables: import_v43.default.record(import_v43.default.string(), import_v43.default.any()).optional() });
+var x = import_v43.default.object({ name: import_v43.default.string(), summary: import_v43.default.string().optional(), description: import_v43.default.string().optional(), required: import_v43.default.boolean().optional(), schema: import_v43.default.any(), deprecated: import_v43.default.boolean().optional() });
+var a2 = import_v43.default.object({ name: import_v43.default.string(), tags: import_v43.default.array(import_v43.default.object({ name: import_v43.default.string(), description: import_v43.default.string().optional() })).optional(), summary: import_v43.default.string().optional(), description: import_v43.default.string().optional(), externalDocs: import_v43.default.object({ description: import_v43.default.string().optional(), url: import_v43.default.string() }).optional(), params: import_v43.default.array(x).optional(), result: x, deprecated: import_v43.default.boolean().optional(), servers: import_v43.default.array(l).optional(), errors: import_v43.default.array(import_v43.default.any()).optional(), links: import_v43.default.array(import_v43.default.any()).optional(), examples: import_v43.default.array(import_v43.default.any()).optional(), paramStructure: import_v43.default.enum(["by-name", "by-position", "either"]).optional() });
+var s2 = import_v43.default.object({ $ref: import_v43.default.string() });
+var o = import_v43.default.object({ schemas: import_v43.default.record(import_v43.default.string(), import_v43.default.any()).optional(), links: import_v43.default.record(import_v43.default.string(), import_v43.default.any()).optional(), errors: import_v43.default.record(import_v43.default.string(), import_v43.default.any()).optional(), examples: import_v43.default.record(import_v43.default.string(), import_v43.default.any()).optional(), examplePairings: import_v43.default.record(import_v43.default.string(), import_v43.default.any()).optional(), contentDescriptors: import_v43.default.record(import_v43.default.string(), x).optional(), tags: import_v43.default.record(import_v43.default.string(), import_v43.default.any()).optional() });
+var t = import_v43.default.object({ description: import_v43.default.string().optional(), url: import_v43.default.string() });
+var HG = import_v43.default.object({ openrpc: import_v43.default.string(), info: d2, servers: import_v43.default.array(l).optional(), methods: import_v43.default.array(import_v43.default.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 import_elysia.default().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 import_elysia.sse({ data: $2, event: "message" });
+    yield import_elysia.sse({ event: "done" });
+  }).post("sse", ({ body: X3 }) => {}), k2 = new import_elysia.default().options("stream", async ({ set: X3, status: $2 }) => {
+    X3.headers.Allow = ["POST", "OPTIONS"].join(",");
+  }).post("stream", L2, {}), F2 = new import_elysia.default().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 import_elysia.default({ 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]) => [
+      v2.name,
+      {
+        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
+var exports_src = {};
+__export(exports_src, {
+  elysiaJsonRPC: () => QG,
+  MCPServerService: () => MCPServerService
+});
+module.exports = __toCommonJS(exports_src);
+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.");
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { type ToolDefinitionGeneric, type ToolSet } from "./types";
+import { type InitializeParams, type InitializeResult, type MCPServerInterface, type PingParams, type PingResult, type PromptsGetParams, type PromptsGetResult, type PromptsListParams, type PromptsListResult, type ResourcesListParams, type ResourcesListResult, type ResourcesReadParams, type ResourcesReadResult, type ResourcesSubscribeParams, type ResourcesSubscribeResult, type ResourcesTemplatesListParams, type ResourcesTemplatesListResult, type ToolsCallParams, type ToolsCallResult, type ToolsListParams, type ToolsListResult } from "elysia-jsonrpc/mcp";
+import elysiaJsonRPC from "elysia-jsonrpc";
+export { elysiaJsonRPC };
+export type ReferenceForToolCallFunction = (toolName: string) => any;
+export declare class MCPServerService implements MCPServerInterface {
+    readonly serverTitle: string;
+    readonly serverVersion: string;
+    readonly serverInstructions: string;
+    readonly getReferenceInstanceForToolCall: ReferenceForToolCallFunction;
+    readonly toolsets: ToolSet[];
+    constructor(serverTitle: string, serverVersion: string, serverInstructions: string, getReferenceInstanceForToolCall: ReferenceForToolCallFunction, toolsets: ToolSet[]);
+    initialize(params: InitializeParams): Promise<InitializeResult>;
+    ping(params: PingParams): Promise<PingResult>;
+    "tools/list"(params: ToolsListParams): Promise<ToolsListResult>;
+    getTool(toolName: string): ToolDefinitionGeneric | null;
+    "tools/call"(params: ToolsCallParams): Promise<ToolsCallResult>;
+    "prompts/list"(params: PromptsListParams): Promise<PromptsListResult>;
+    "prompts/get"(params: PromptsGetParams): Promise<PromptsGetResult>;
+    "resources/list"(params: ResourcesListParams): Promise<ResourcesListResult>;
+    "resources/read"(params: ResourcesReadParams): Promise<ResourcesReadResult>;
+    "resources/subscribe"(params: ResourcesSubscribeParams): Promise<ResourcesSubscribeResult>;
+    "resources/templates/list"(params: ResourcesTemplatesListParams): Promise<ResourcesTemplatesListResult>;
+}