@veolab/discoverylab 1.2.2 → 1.3.0

package/dist/chunk-QJXXHOV7.js

@@ -1,205 +0,0 @@
-// 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
-};