@elsium-ai/mcp 0.1.6

package/dist/client.d.ts

@@ -0,0 +1,24 @@
+import type { Tool } from '@elsium-ai/tools';
+export interface MCPClientConfig {
+    name: string;
+    transport: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+export interface MCPToolInfo {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface MCPClient {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    listTools(): Promise<MCPToolInfo[]>;
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    toElsiumTools(): Promise<Tool[]>;
+    readonly connected: boolean;
+}
+export declare function createMCPClient(config: MCPClientConfig): MCPClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAoC,MAAM,kBAAkB,CAAA;AAE9E,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC;AAgBD,MAAM,WAAW,SAAS;IACzB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3B,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAA;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACvE,aAAa,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAA;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC3B;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAuQlE"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createMCPClient } from './client';
+export type { MCPClient, MCPClientConfig, MCPToolInfo } from './client';
+export { createMCPServer } from './server';
+export type { MCPServer, MCPServerConfig } from './server';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC1C,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC1C,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1,530 @@
+// @bun
+// src/client.ts
+import { spawn } from "child_process";
+
+// ../core/src/errors.ts
+class ElsiumError extends Error {
+  code;
+  provider;
+  model;
+  statusCode;
+  retryable;
+  retryAfterMs;
+  cause;
+  metadata;
+  constructor(details) {
+    super(details.message);
+    this.name = "ElsiumError";
+    this.code = details.code;
+    this.provider = details.provider;
+    this.model = details.model;
+    this.statusCode = details.statusCode;
+    this.retryable = details.retryable;
+    this.retryAfterMs = details.retryAfterMs;
+    this.cause = details.cause;
+    this.metadata = details.metadata;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      provider: this.provider,
+      model: this.model,
+      statusCode: this.statusCode,
+      retryable: this.retryable,
+      retryAfterMs: this.retryAfterMs,
+      metadata: this.metadata
+    };
+  }
+  static providerError(message, opts) {
+    return new ElsiumError({
+      code: "PROVIDER_ERROR",
+      message,
+      provider: opts.provider,
+      statusCode: opts.statusCode,
+      retryable: opts.retryable ?? false,
+      cause: opts.cause
+    });
+  }
+  static rateLimit(provider, retryAfterMs) {
+    return new ElsiumError({
+      code: "RATE_LIMIT",
+      message: `Rate limited by ${provider}`,
+      provider,
+      statusCode: 429,
+      retryable: true,
+      retryAfterMs
+    });
+  }
+  static authError(provider) {
+    return new ElsiumError({
+      code: "AUTH_ERROR",
+      message: `Authentication failed for ${provider}. Check your API key.`,
+      provider,
+      statusCode: 401,
+      retryable: false
+    });
+  }
+  static timeout(provider, timeoutMs) {
+    return new ElsiumError({
+      code: "TIMEOUT",
+      message: `Request to ${provider} timed out after ${timeoutMs}ms`,
+      provider,
+      retryable: true
+    });
+  }
+  static validation(message, metadata) {
+    return new ElsiumError({
+      code: "VALIDATION_ERROR",
+      message,
+      retryable: false,
+      metadata
+    });
+  }
+  static budgetExceeded(spent, budget) {
+    return new ElsiumError({
+      code: "BUDGET_EXCEEDED",
+      message: `Token budget exceeded: spent ${spent}, budget ${budget}`,
+      retryable: false,
+      metadata: { spent, budget }
+    });
+  }
+}
+// ../core/src/utils.ts
+import { randomBytes } from "crypto";
+function cryptoHex(bytes) {
+  return randomBytes(bytes).toString("hex");
+}
+function generateId(prefix = "els") {
+  const timestamp = Date.now().toString(36);
+  const random = cryptoHex(4);
+  return `${prefix}_${timestamp}_${random}`;
+}
+// ../core/src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function createLogger(options = {}) {
+  const { level = "info", pretty = false, context = {} } = options;
+  const minLevel = LOG_LEVELS[level];
+  function log(logLevel, message, data) {
+    if (LOG_LEVELS[logLevel] < minLevel)
+      return;
+    const entry = {
+      ...context,
+      level: logLevel,
+      message,
+      timestamp: new Date().toISOString(),
+      ...data ? { data } : {}
+    };
+    const output = pretty ? JSON.stringify(entry, null, 2) : JSON.stringify(entry);
+    if (logLevel === "error") {
+      console.error(output);
+    } else if (logLevel === "warn") {
+      console.warn(output);
+    } else {
+      console.log(output);
+    }
+  }
+  return {
+    debug: (msg, data) => log("debug", msg, data),
+    info: (msg, data) => log("info", msg, data),
+    warn: (msg, data) => log("warn", msg, data),
+    error: (msg, data) => log("error", msg, data),
+    child(childContext) {
+      return createLogger({
+        level,
+        pretty,
+        context: { ...context, ...childContext }
+      });
+    }
+  };
+}
+// src/client.ts
+function createMCPClient(config) {
+  let process2 = null;
+  let connected = false;
+  let requestId = 0;
+  const pendingRequests = new Map;
+  let buffer = "";
+  const timeoutMs = config.timeoutMs ?? 30000;
+  function sendRequest(method, params) {
+    if (!process2?.stdin) {
+      return Promise.reject(new ElsiumError({
+        code: "NETWORK_ERROR",
+        message: "MCP client not connected",
+        retryable: false
+      }));
+    }
+    const id = ++requestId;
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      ...params ? { params } : {}
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pendingRequests.delete(id);
+        reject(new ElsiumError({
+          code: "TIMEOUT",
+          message: `MCP request timed out after ${timeoutMs}ms`,
+          retryable: true
+        }));
+      }, timeoutMs);
+      pendingRequests.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+      const proc = process2;
+      if (proc?.stdin) {
+        proc.stdin.write(`${JSON.stringify(request)}
+`);
+      }
+    });
+  }
+  function sendNotification(method, params) {
+    const proc = process2;
+    if (!proc?.stdin)
+      return;
+    const notification = {
+      jsonrpc: "2.0",
+      method,
+      ...params ? { params } : {}
+    };
+    proc.stdin.write(`${JSON.stringify(notification)}
+`);
+  }
+  const MAX_LINE_LENGTH = 1024 * 1024;
+  function processResponseLine(line) {
+    if (!line.trim())
+      return;
+    let response;
+    try {
+      response = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const pending = pendingRequests.get(response.id);
+    if (!pending)
+      return;
+    pendingRequests.delete(response.id);
+    if (response.error) {
+      pending.reject(new ElsiumError({
+        code: "PROVIDER_ERROR",
+        message: `MCP error: ${response.error.message}`,
+        retryable: false,
+        metadata: { code: response.error.code }
+      }));
+    } else {
+      pending.resolve(response.result);
+    }
+  }
+  function handleData(data) {
+    buffer += data;
+    if (buffer.length > MAX_LINE_LENGTH) {
+      buffer = "";
+      return;
+    }
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      processResponseLine(line);
+    }
+  }
+  return {
+    get connected() {
+      return connected;
+    },
+    async connect() {
+      if (connected)
+        return;
+      const childEnv = {
+        PATH: globalThis.process?.env?.PATH ?? "",
+        HOME: globalThis.process?.env?.HOME ?? "",
+        ...config.env ?? {}
+      };
+      process2 = spawn(config.command, config.args ?? [], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: childEnv
+      });
+      process2.stdout?.setEncoding("utf-8");
+      process2.stdout?.on("data", handleData);
+      process2.on("error", (err2) => {
+        connected = false;
+        for (const [, pending] of pendingRequests) {
+          pending.reject(err2);
+        }
+        pendingRequests.clear();
+      });
+      process2.on("exit", (code) => {
+        connected = false;
+        if (pendingRequests.size > 0) {
+          const err2 = new Error(`MCP subprocess exited with code ${code}`);
+          for (const [, pending] of pendingRequests) {
+            pending.reject(err2);
+          }
+          pendingRequests.clear();
+        }
+      });
+      await sendRequest("initialize", {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: `elsium-mcp-${config.name}`, version: "0.1.0" }
+      });
+      sendNotification("notifications/initialized");
+      connected = true;
+    },
+    async disconnect() {
+      if (!connected || !process2)
+        return;
+      try {
+        process2.stdin?.end();
+        process2.kill();
+      } catch {}
+      connected = false;
+      process2 = null;
+      for (const [, { reject }] of pendingRequests) {
+        reject(new Error("MCP client disconnected"));
+      }
+      pendingRequests.clear();
+    },
+    async listTools() {
+      const result = await sendRequest("tools/list");
+      return result.tools ?? [];
+    },
+    async callTool(name, args) {
+      const result = await sendRequest("tools/call", { name, arguments: args });
+      const textContent = result.content?.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+      return textContent ?? result;
+    },
+    async toElsiumTools() {
+      const mcpTools = await this.listTools();
+      const client = this;
+      return mcpTools.map((mcpTool) => {
+        const tool = {
+          name: mcpTool.name,
+          description: mcpTool.description,
+          inputSchema: { _def: { typeName: "ZodObject" } },
+          rawSchema: mcpTool.inputSchema,
+          timeoutMs,
+          async execute(input, partialCtx) {
+            const toolCallId = partialCtx?.toolCallId ?? generateId("tc");
+            const startTime = performance.now();
+            try {
+              const result = await client.callTool(mcpTool.name, input ?? {});
+              return {
+                success: true,
+                data: result,
+                toolCallId,
+                durationMs: Math.round(performance.now() - startTime)
+              };
+            } catch (error) {
+              return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                toolCallId,
+                durationMs: Math.round(performance.now() - startTime)
+              };
+            }
+          },
+          toDefinition() {
+            return {
+              name: mcpTool.name,
+              description: mcpTool.description,
+              inputSchema: mcpTool.inputSchema
+            };
+          }
+        };
+        return tool;
+      });
+    }
+  };
+}
+// src/server.ts
+var log = createLogger();
+function createMCPServer(config) {
+  let running = false;
+  const toolMap = new Map(config.tools.map((t) => [t.name, t]));
+  function handleRequest(request) {
+    const id = request.id ?? 0;
+    switch (request.method) {
+      case "initialize": {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: {
+              name: config.name,
+              version: config.version ?? "0.1.0"
+            }
+          }
+        };
+      }
+      case "notifications/initialized": {
+        return null;
+      }
+      case "tools/list": {
+        const tools = config.tools.map((t) => {
+          const def = t.toDefinition();
+          return {
+            name: def.name,
+            description: def.description,
+            inputSchema: def.inputSchema
+          };
+        });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: { tools }
+        };
+      }
+      case "tools/call": {
+        return null;
+      }
+      default: {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${request.method}`
+          }
+        };
+      }
+    }
+  }
+  async function handleToolCall(request) {
+    const id = request.id ?? 0;
+    const name = request.params?.name;
+    const args = request.params?.arguments ?? {};
+    const tool = toolMap.get(name);
+    if (!tool) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32602,
+          message: `Unknown tool: ${name}`
+        }
+      };
+    }
+    const result = await tool.execute(args, { toolCallId: generateId("tc") });
+    if (result.success) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [
+            {
+              type: "text",
+              text: typeof result.data === "string" ? result.data : JSON.stringify(result.data, null, 2)
+            }
+          ]
+        }
+      };
+    }
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        content: [{ type: "text", text: result.error ?? "Tool execution failed" }],
+        isError: true
+      }
+    };
+  }
+  function writeLine(data) {
+    process.stdout.write(`${JSON.stringify(data)}
+`);
+  }
+  async function processRequestLine(line) {
+    if (!line.trim())
+      return;
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (request.method === "tools/call") {
+      const response2 = await handleToolCall(request);
+      writeLine(response2);
+      return;
+    }
+    const response = handleRequest(request);
+    if (response) {
+      writeLine(response);
+    }
+  }
+  return {
+    get running() {
+      return running;
+    },
+    async start() {
+      if (running)
+        return;
+      running = true;
+      const MAX_BUFFER_SIZE = 1024 * 1024;
+      process.stdin.setEncoding("utf-8");
+      let buffer = "";
+      let processing = false;
+      const pendingChunks = [];
+      async function drainPendingChunks() {
+        while (pendingChunks.length > 0) {
+          const chunk = pendingChunks[0];
+          pendingChunks.shift();
+          buffer += chunk;
+          if (buffer.length > MAX_BUFFER_SIZE) {
+            log.error("MCP server: buffer size limit exceeded, resetting");
+            buffer = "";
+            continue;
+          }
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            await processRequestLine(line);
+          }
+        }
+      }
+      async function processQueue() {
+        if (processing)
+          return;
+        processing = true;
+        try {
+          await drainPendingChunks();
+        } finally {
+          processing = false;
+        }
+      }
+      process.stdin.on("data", (chunk) => {
+        pendingChunks.push(chunk);
+        processQueue();
+      });
+      process.stdin.on("end", () => {
+        running = false;
+      });
+    },
+    stop() {
+      running = false;
+    }
+  };
+}
+export {
+  createMCPServer,
+  createMCPClient
+};

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import type { Tool } from '@elsium-ai/tools';
+export interface MCPServerConfig {
+    name: string;
+    version?: string;
+    tools: Tool[];
+}
+export interface MCPServer {
+    start(): Promise<void>;
+    stop(): void;
+    readonly running: boolean;
+}
+export declare function createMCPServer(config: MCPServerConfig): MCPServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAI5C,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,IAAI,EAAE,CAAA;CACb;AAgBD,MAAM,WAAW,SAAS;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,IAAI,IAAI,IAAI,CAAA;IACZ,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CACzB;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAmMlE"}

package/package.json

@@ -0,0 +1,36 @@
+{
+	"name": "@elsium-ai/mcp",
+	"version": "0.1.6",
+	"description": "Model Context Protocol (MCP) support for ElsiumAI — bidirectional bridge",
+	"license": "MIT",
+	"author": "Eric Utrera <ebutrera9103@gmail.com>",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/elsium-ai/elsium-ai",
+		"directory": "packages/mcp"
+	},
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "bun build ./src/index.ts --outdir ./dist --target bun && bun x tsc -p tsconfig.build.json --emitDeclarationOnly",
+		"dev": "bun --watch src/index.ts"
+	},
+	"dependencies": {
+		"@elsium-ai/core": "workspace:*",
+		"@elsium-ai/tools": "workspace:*"
+	},
+	"devDependencies": {
+		"bun-types": "^1.3.0",
+		"typescript": "^5.7.0"
+	}
+}