@veolab/discoverylab 0.1.0

package/dist/chunk-QJXXHOV7.js

@@ -0,0 +1,205 @@
+// src/mcp/server.ts
+import { z } from "zod";
+var MCPServer = class {
+  tools = /* @__PURE__ */ new Map();
+  serverInfo = {
+    name: "discoverylab",
+    version: "0.1.0"
+  };
+  registerTool(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  registerTools(tools) {
+    for (const tool of tools) {
+      this.registerTool(tool);
+    }
+  }
+  async handleRequest(request) {
+    const { id, method, params } = request;
+    try {
+      switch (method) {
+        case "initialize":
+          return this.handleInitialize(id, params);
+        case "tools/list":
+          return this.handleToolsList(id);
+        case "tools/call":
+          return this.handleToolCall(id, params);
+        case "ping":
+          return { jsonrpc: "2.0", id, result: { pong: true } };
+        default:
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32601, message: `Method not found: ${method}` }
+          };
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32603, message }
+      };
+    }
+  }
+  handleInitialize(id, params) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: "2024-11-05",
+        serverInfo: this.serverInfo,
+        capabilities: {
+          tools: {}
+        }
+      }
+    };
+  }
+  handleToolsList(id) {
+    const tools = Array.from(this.tools.values()).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: this.zodToJsonSchema(tool.inputSchema)
+    }));
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { tools }
+    };
+  }
+  async handleToolCall(id, params) {
+    const { name, arguments: args } = params;
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32602, message: `Tool not found: ${name}` }
+      };
+    }
+    try {
+      const validatedArgs = tool.inputSchema.parse(args || {});
+      const result = await tool.handler(validatedArgs);
+      return {
+        jsonrpc: "2.0",
+        id,
+        result
+      };
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32602,
+            message: "Invalid parameters",
+            data: error.errors
+          }
+        };
+      }
+      const message = error instanceof Error ? error.message : "Tool execution failed";
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        }
+      };
+    }
+  }
+  zodToJsonSchema(schema) {
+    if (schema instanceof z.ZodObject) {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = this.zodToJsonSchema(value);
+        if (!value.isOptional()) {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      };
+    }
+    if (schema instanceof z.ZodString) {
+      return { type: "string" };
+    }
+    if (schema instanceof z.ZodNumber) {
+      return { type: "number" };
+    }
+    if (schema instanceof z.ZodBoolean) {
+      return { type: "boolean" };
+    }
+    if (schema instanceof z.ZodArray) {
+      return {
+        type: "array",
+        items: this.zodToJsonSchema(schema.element)
+      };
+    }
+    if (schema instanceof z.ZodOptional) {
+      return this.zodToJsonSchema(schema.unwrap());
+    }
+    if (schema instanceof z.ZodEnum) {
+      return {
+        type: "string",
+        enum: schema.options
+      };
+    }
+    return { type: "object" };
+  }
+  // STDIO transport
+  async runStdio() {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    rl.on("line", async (line) => {
+      try {
+        const request = JSON.parse(line);
+        const response = await this.handleRequest(request);
+        console.log(JSON.stringify(response));
+      } catch (error) {
+        const errorResponse = {
+          jsonrpc: "2.0",
+          id: 0,
+          error: { code: -32700, message: "Parse error" }
+        };
+        console.log(JSON.stringify(errorResponse));
+      }
+    });
+    rl.on("close", () => {
+      process.exit(0);
+    });
+  }
+};
+function createTextResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function createErrorResult(message) {
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+function createJsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+var mcpServer = new MCPServer();
+
+export {
+  MCPServer,
+  createTextResult,
+  createErrorResult,
+  createJsonResult,
+  mcpServer
+};