kernl 0.1.1

package/dist/mcp/node.js

@@ -0,0 +1,297 @@
+import { DEFAULT_REQUEST_TIMEOUT_MSEC } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import logger from "../logger";
+import { invalidateServerToolsCache } from "./base";
+function failedToImport(error) {
+    logger.error(`
+Failed to load the MCP SDK. Please install the @modelcontextprotocol/sdk package.
+
+npm install @modelcontextprotocol/sdk
+    `.trim());
+    throw error;
+}
+export class NodeMCPServerStdio extends BaseMCPServerStdio {
+    session = null;
+    _cacheDirty = true;
+    _toolsList = [];
+    serverInitializeResult = null;
+    clientSessionTimeoutSeconds;
+    timeout;
+    params;
+    _name;
+    transport = null;
+    constructor(params) {
+        super(params);
+        this.clientSessionTimeoutSeconds = params.clientSessionTimeoutSeconds ?? 5;
+        this.timeout = params.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+        if ("fullCommand" in params) {
+            const elements = params.fullCommand.split(" ");
+            const command = elements.shift();
+            if (!command) {
+                throw new Error("Invalid fullCommand: " + params.fullCommand);
+            }
+            this.params = {
+                ...params,
+                command: command,
+                args: elements,
+                encoding: params.encoding || "utf-8",
+                encodingErrorHandler: params.encodingErrorHandler || "strict",
+            };
+        }
+        else {
+            this.params = params;
+        }
+        this._name = params.name || `stdio: ${this.params.command}`;
+    }
+    async connect() {
+        try {
+            this.transport = new StdioClientTransport({
+                command: this.params.command,
+                args: this.params.args,
+                env: this.params.env,
+                cwd: this.params.cwd,
+            });
+            this.session = new Client({
+                name: this._name,
+                version: "1.0.0",
+            });
+            await this.session.connect(this.transport);
+            this.serverInitializeResult = {
+                serverInfo: { name: this._name, version: "1.0.0" },
+            };
+        }
+        catch (e) {
+            this.logger.error("Error initializing MCP server:", e);
+            await this.close();
+            throw e;
+        }
+        this.debugLog(() => `Connected to MCP server: ${this._name}`);
+    }
+    async invalidateToolsCache() {
+        await invalidateServerToolsCache(this.name);
+        this._cacheDirty = true;
+    }
+    async listTools() {
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        if (this.cacheToolsList && !this._cacheDirty && this._toolsList) {
+            return this._toolsList;
+        }
+        this._cacheDirty = false;
+        const response = await this.session.listTools();
+        this.debugLog(() => `Listed tools: ${JSON.stringify(response)}`);
+        this._toolsList = ListToolsResultSchema.parse(response).tools;
+        return this._toolsList;
+    }
+    async callTool(toolName, args) {
+        const { CallToolResultSchema } = await import("@modelcontextprotocol/sdk/types.js").catch(failedToImport);
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        const response = await this.session.callTool({
+            name: toolName,
+            arguments: args ?? {},
+        }, undefined, {
+            timeout: this.timeout,
+        });
+        const parsed = CallToolResultSchema.parse(response);
+        const result = parsed.content;
+        this.debugLog(() => `Called tool ${toolName} (args: ${JSON.stringify(args)}, result: ${JSON.stringify(result)})`);
+        return result;
+    }
+    get name() {
+        return this._name;
+    }
+    async close() {
+        if (this.transport) {
+            await this.transport.close();
+            this.transport = null;
+        }
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+    }
+}
+export class NodeMCPServerSSE extends BaseMCPServerSSE {
+    session = null;
+    _cacheDirty = true;
+    _toolsList = [];
+    serverInitializeResult = null;
+    clientSessionTimeoutSeconds;
+    timeout;
+    params;
+    _name;
+    transport = null;
+    constructor(params) {
+        super(params);
+        this.clientSessionTimeoutSeconds = params.clientSessionTimeoutSeconds ?? 5;
+        this.params = params;
+        this._name = params.name || `sse: ${this.params.url}`;
+        this.timeout = params.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+    }
+    async connect() {
+        try {
+            const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js").catch(failedToImport);
+            const { Client } = await import("@modelcontextprotocol/sdk/client/index.js").catch(failedToImport);
+            this.transport = new SSEClientTransport(new URL(this.params.url), {
+                authProvider: this.params.authProvider,
+                requestInit: this.params.requestInit,
+                eventSourceInit: this.params.eventSourceInit,
+            });
+            this.session = new Client({
+                name: this._name,
+                version: "1.0.0", // You may want to make this configurable
+            });
+            await this.session.connect(this.transport);
+            this.serverInitializeResult = {
+                serverInfo: { name: this._name, version: "1.0.0" },
+            };
+        }
+        catch (e) {
+            this.logger.error("Error initializing MCP server:", e);
+            await this.close();
+            throw e;
+        }
+        this.debugLog(() => `Connected to MCP server: ${this._name}`);
+    }
+    async invalidateToolsCache() {
+        await invalidateServerToolsCache(this.name);
+        this._cacheDirty = true;
+    }
+    async listTools() {
+        const { ListToolsResultSchema } = await import("@modelcontextprotocol/sdk/types.js").catch(failedToImport);
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        if (this.cacheToolsList && !this._cacheDirty && this._toolsList) {
+            return this._toolsList;
+        }
+        this._cacheDirty = false;
+        const response = await this.session.listTools();
+        this.debugLog(() => `Listed tools: ${JSON.stringify(response)}`);
+        this._toolsList = ListToolsResultSchema.parse(response).tools;
+        return this._toolsList;
+    }
+    async callTool(toolName, args) {
+        const { CallToolResultSchema } = await import("@modelcontextprotocol/sdk/types.js").catch(failedToImport);
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        const response = await this.session.callTool({
+            name: toolName,
+            arguments: args ?? {},
+        }, undefined, {
+            timeout: this.timeout,
+        });
+        const parsed = CallToolResultSchema.parse(response);
+        const result = parsed.content;
+        this.debugLog(() => `Called tool ${toolName} (args: ${JSON.stringify(args)}, result: ${JSON.stringify(result)})`);
+        return result;
+    }
+    get name() {
+        return this._name;
+    }
+    async close() {
+        if (this.transport) {
+            await this.transport.close();
+            this.transport = null;
+        }
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+    }
+}
+export class NodeMCPServerStreamableHttp extends BaseMCPServerStreamableHttp {
+    session = null;
+    _cacheDirty = true;
+    _toolsList = [];
+    serverInitializeResult = null;
+    clientSessionTimeoutSeconds;
+    timeout;
+    params;
+    _name;
+    transport = null;
+    constructor(params) {
+        super(params);
+        this.clientSessionTimeoutSeconds = params.clientSessionTimeoutSeconds ?? 5;
+        this.params = params;
+        this._name = params.name || `streamable-http: ${this.params.url}`;
+        this.timeout = params.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+    }
+    async connect() {
+        try {
+            const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js").catch(failedToImport);
+            const { Client } = await import("@modelcontextprotocol/sdk/client/index.js").catch(failedToImport);
+            this.transport = new StreamableHTTPClientTransport(new URL(this.params.url), {
+                authProvider: this.params.authProvider,
+                requestInit: this.params.requestInit,
+                fetch: this.params.fetch,
+                reconnectionOptions: this.params.reconnectionOptions,
+                sessionId: this.params.sessionId,
+            });
+            this.session = new Client({
+                name: this._name,
+                version: "1.0.0", // You may want to make this configurable
+            });
+            await this.session.connect(this.transport);
+            this.serverInitializeResult = {
+                serverInfo: { name: this._name, version: "1.0.0" },
+            };
+        }
+        catch (e) {
+            this.logger.error("Error initializing MCP server:", e);
+            await this.close();
+            throw e;
+        }
+        this.debugLog(() => `Connected to MCP server: ${this._name}`);
+    }
+    async invalidateToolsCache() {
+        await invalidateServerToolsCache(this.name);
+        this._cacheDirty = true;
+    }
+    async listTools() {
+        const { ListToolsResultSchema } = await import("@modelcontextprotocol/sdk/types.js").catch(failedToImport);
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        if (this.cacheToolsList && !this._cacheDirty && this._toolsList) {
+            return this._toolsList;
+        }
+        this._cacheDirty = false;
+        const response = await this.session.listTools();
+        this.debugLog(() => `Listed tools: ${JSON.stringify(response)}`);
+        this._toolsList = ListToolsResultSchema.parse(response).tools;
+        return this._toolsList;
+    }
+    async callTool(toolName, args) {
+        const { CallToolResultSchema } = await import("@modelcontextprotocol/sdk/types.js").catch(failedToImport);
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        const response = await this.session.callTool({
+            name: toolName,
+            arguments: args ?? {},
+        }, undefined, {
+            timeout: this.timeout,
+        });
+        const parsed = CallToolResultSchema.parse(response);
+        const result = parsed.content;
+        this.debugLog(() => `Called tool ${toolName} (args: ${JSON.stringify(args)}, result: ${JSON.stringify(result)})`);
+        return result;
+    }
+    get name() {
+        return this._name;
+    }
+    async close() {
+        if (this.transport) {
+            await this.transport.close();
+            this.transport = null;
+        }
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+    }
+}

package/dist/mcp/sse.d.ts

@@ -0,0 +1,34 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { BaseMCPServer } from "./base";
+import type { MCPTool, CallToolResultContent, MCPServerSSEOptions, InitializeResult } from "./types";
+/**
+ * MCP server client that communicates over Server-Sent Events (SSE).
+ */
+export declare class MCPServerSSE extends BaseMCPServer {
+    readonly id: string;
+    protected session: Client | null;
+    protected timeout: number;
+    protected serverInitializeResult: InitializeResult | null;
+    params: MCPServerSSEOptions;
+    private transport;
+    constructor(options: MCPServerSSEOptions);
+    /**
+     * Establishes connection to the MCP server.
+     */
+    connect(): Promise<void>;
+    /**
+     * Internal implementation: Fetches tools from the server.
+     *
+     * Cached via the BaseMCPServer class.
+     */
+    protected _listTools(): Promise<MCPTool[]>;
+    /**
+     * Executes a tool on the server with the provided arguments.
+     */
+    callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    /**
+     * Closes the connection and cleans up resources.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=sse.d.ts.map

package/dist/mcp/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/mcp/sse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAUnE,OAAO,EAAE,aAAa,EAAsC,MAAM,QAAQ,CAAC;AAC3E,OAAO,KAAK,EACV,OAAO,EACP,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,qBAAa,YAAa,SAAQ,aAAa;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAQ;IACxC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,sBAAsB,EAAE,gBAAgB,GAAG,IAAI,CAAQ;IAEjE,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,CAAC,SAAS,CAAa;gBAElB,OAAO,EAAE,mBAAmB;IAYxC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B9B;;;;OAIG;cACa,UAAU,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAYhD;;OAEG;IACG,QAAQ,CACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GACnC,OAAO,CAAC,qBAAqB,CAAC;IA4BjC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAU7B"}

package/dist/mcp/sse.js

@@ -0,0 +1,97 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { DEFAULT_REQUEST_TIMEOUT_MSEC } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { ListToolsResultSchema, CallToolResultSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { getLogger } from "../lib/logger";
+import { BaseMCPServer, DEFAULT_SSE_MCP_CLIENT_LOGGER_NAME } from "./base";
+/**
+ * MCP server client that communicates over Server-Sent Events (SSE).
+ */
+export class MCPServerSSE extends BaseMCPServer {
+    id;
+    session = null;
+    timeout;
+    serverInitializeResult = null;
+    params;
+    transport = null;
+    constructor(options) {
+        super({
+            cacheToolsList: options.cacheToolsList,
+            toolFilter: options.toolFilter,
+            logger: options.logger ?? getLogger(DEFAULT_SSE_MCP_CLIENT_LOGGER_NAME),
+        });
+        this.params = options;
+        this.id = options.id || `sse: ${this.params.url}`;
+        this.timeout = options.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+    }
+    /**
+     * Establishes connection to the MCP server.
+     */
+    async connect() {
+        try {
+            this.transport = new SSEClientTransport(new URL(this.params.url), {
+                authProvider: this.params.authProvider,
+                requestInit: this.params.requestInit,
+                eventSourceInit: this.params.eventSourceInit,
+            });
+            this.session = new Client({
+                name: this.id,
+                version: "1.0.0",
+            });
+            await this.session.connect(this.transport);
+            this.serverInitializeResult = {
+                serverInfo: { name: this.id, version: "1.0.0" },
+            };
+        }
+        catch (e) {
+            this.logger.error("Error initializing MCP server:", e);
+            await this.close();
+            throw e;
+        }
+        this.logger.debug(`Connected to MCP server: ${this.id}`);
+    }
+    /**
+     * Internal implementation: Fetches tools from the server.
+     *
+     * Cached via the BaseMCPServer class.
+     */
+    async _listTools() {
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        const response = await this.session.listTools();
+        this.logger.debug(`Listed tools: ${JSON.stringify(response)}`);
+        return ListToolsResultSchema.parse(response).tools;
+    }
+    /**
+     * Executes a tool on the server with the provided arguments.
+     */
+    async callTool(toolName, args) {
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        const response = await this.session.callTool({
+            name: toolName,
+            arguments: args ?? {},
+        }, undefined, {
+            timeout: this.timeout,
+        });
+        const parsed = CallToolResultSchema.parse(response);
+        const result = parsed.content;
+        this.logger.debug(`Called tool ${toolName} (args: ${JSON.stringify(args)}, result: ${JSON.stringify(result)})`);
+        return result;
+    }
+    /**
+     * Closes the connection and cleans up resources.
+     */
+    async close() {
+        if (this.transport) {
+            await this.transport.close();
+            this.transport = null;
+        }
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+    }
+}

package/dist/mcp/stdio.d.ts

@@ -0,0 +1,32 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { BaseMCPServer } from "./base";
+import type { MCPTool, CallToolResultContent, MCPServerStdioOptions, InitializeResult } from "./types";
+/**
+ * MCP server client that communicates over stdio (standard input/output).
+ */
+export declare class MCPServerStdio extends BaseMCPServer {
+    readonly id: string;
+    protected session: Client | null;
+    protected timeout: number;
+    protected serverInitializeResult: InitializeResult | null;
+    private params;
+    private transport;
+    constructor(options: MCPServerStdioOptions);
+    /**
+     * Establishes connection to the MCP server.
+     */
+    connect(): Promise<void>;
+    /**
+     * Internal implementation: Fetches tools from the server.
+     */
+    protected _listTools(): Promise<MCPTool[]>;
+    /**
+     * Executes a tool on the server with the provided arguments.
+     */
+    callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    /**
+     * Closes the connection and cleans up resources.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=stdio.d.ts.map

package/dist/mcp/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/mcp/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAUnE,OAAO,EAAE,aAAa,EAAwC,MAAM,QAAQ,CAAC;AAC7E,OAAO,KAAK,EACV,OAAO,EACP,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,qBAAa,cAAe,SAAQ,aAAa;IAC/C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAQ;IACxC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,sBAAsB,EAAE,gBAAgB,GAAG,IAAI,CAAQ;IAEjE,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,SAAS,CAAa;gBAElB,OAAO,EAAE,qBAAqB;IAY1C;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA4B9B;;OAEG;cACa,UAAU,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAYhD;;OAEG;IACG,QAAQ,CACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GACnC,OAAO,CAAC,qBAAqB,CAAC;IA4BjC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAU7B"}

package/dist/mcp/stdio.js

@@ -0,0 +1,96 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { DEFAULT_REQUEST_TIMEOUT_MSEC } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { ListToolsResultSchema, CallToolResultSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { getLogger } from "../lib/logger";
+import { BaseMCPServer, DEFAULT_STDIO_MCP_CLIENT_LOGGER_NAME } from "./base";
+/**
+ * MCP server client that communicates over stdio (standard input/output).
+ */
+export class MCPServerStdio extends BaseMCPServer {
+    id;
+    session = null;
+    timeout;
+    serverInitializeResult = null;
+    params;
+    transport = null;
+    constructor(options) {
+        super({
+            cacheToolsList: options.cacheToolsList,
+            toolFilter: options.toolFilter,
+            logger: options.logger ?? getLogger(DEFAULT_STDIO_MCP_CLIENT_LOGGER_NAME),
+        });
+        this.timeout = options.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+        this.params = options;
+        this.id = options.id || `stdio: ${this.params.command}`;
+    }
+    /**
+     * Establishes connection to the MCP server.
+     */
+    async connect() {
+        try {
+            this.transport = new StdioClientTransport({
+                command: this.params.command,
+                args: this.params.args,
+                env: this.params.env,
+                cwd: this.params.cwd,
+            });
+            this.session = new Client({
+                name: this.id,
+                version: "1.0.0",
+            });
+            await this.session.connect(this.transport);
+            this.serverInitializeResult = {
+                serverInfo: { name: this.id, version: "1.0.0" },
+            };
+            this.logger.debug(`Connected to MCP server: ${this.id}`);
+        }
+        catch (e) {
+            this.logger.error("Error initializing MCP server:", e);
+            await this.close();
+            throw e;
+        }
+    }
+    /**
+     * Internal implementation: Fetches tools from the server.
+     */
+    async _listTools() {
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        const response = await this.session.listTools();
+        this.logger.debug(`Listed tools: ${JSON.stringify(response)}`);
+        return ListToolsResultSchema.parse(response).tools;
+    }
+    /**
+     * Executes a tool on the server with the provided arguments.
+     */
+    async callTool(toolName, args) {
+        if (!this.session) {
+            throw new Error("Server not initialized. Make sure you call connect() first.");
+        }
+        const response = await this.session.callTool({
+            name: toolName,
+            arguments: args ?? {},
+        }, undefined, {
+            timeout: this.timeout,
+        });
+        const parsed = CallToolResultSchema.parse(response);
+        const result = parsed.content;
+        this.logger.debug(`Called tool ${toolName} (args: ${JSON.stringify(args)}, result: ${JSON.stringify(result)})`);
+        return result;
+    }
+    /**
+     * Closes the connection and cleans up resources.
+     */
+    async close() {
+        if (this.transport) {
+            await this.transport.close();
+            this.transport = null;
+        }
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+    }
+}