kernl 0.1.1

package/dist/mcp/__tests__/utils.test.js

@@ -0,0 +1,300 @@
+import { describe, it, expect, vi } from "vitest";
+import { mcpToFunctionTool, createMCPToolStaticFilter } from "../utils";
+import { Context } from "../../context";
+describe("mcpToFunctionTool", () => {
+    // Create a mock MCP server
+    const createMockServer = () => ({
+        id: "mock-server",
+        cacheToolsList: false,
+        toolFilter: async () => true,
+        connect: vi.fn(),
+        close: vi.fn(),
+        listTools: vi.fn(),
+        callTool: vi.fn(),
+        invalidateCache: vi.fn(),
+    });
+    it("should convert MCPTool to FunctionTool correctly", () => {
+        const server = createMockServer();
+        const mcpTool = {
+            name: "test_tool",
+            description: "A test tool",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    arg1: { type: "string" },
+                },
+            },
+        };
+        const functionTool = mcpToFunctionTool(server, mcpTool);
+        expect(functionTool.id).toBe("test_tool");
+        expect(functionTool.name).toBe("test_tool");
+        expect(functionTool.description).toBe("A test tool");
+        expect(functionTool.parameters).toBeDefined();
+        // execute is private, but we can verify the tool has an invoke method
+        expect(functionTool.invoke).toBeDefined();
+    });
+    it("should map tool metadata (name, description, inputSchema)", () => {
+        const server = createMockServer();
+        const mcpTool = {
+            name: "calculator",
+            description: "Performs calculations",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    operation: { type: "string" },
+                    values: { type: "array" },
+                },
+            },
+        };
+        const functionTool = mcpToFunctionTool(server, mcpTool);
+        expect(functionTool.id).toBe("calculator");
+        expect(functionTool.name).toBe("calculator");
+        expect(functionTool.description).toBe("Performs calculations");
+        expect(functionTool.parameters).toBeDefined();
+    });
+    it("should handle tools without inputSchema (undefined parameters)", () => {
+        const server = createMockServer();
+        // In practice, MCP SDK tools require inputSchema, but our function handles
+        // the case where it might not be present. We use 'as any' to test this edge case.
+        const mcpTool = {
+            name: "no_params",
+            description: "Tool without parameters",
+        };
+        const functionTool = mcpToFunctionTool(server, mcpTool);
+        expect(functionTool.id).toBe("no_params");
+        expect(functionTool.parameters).toBeUndefined();
+    });
+    it("should invoke server.callTool with correct params", async () => {
+        const server = createMockServer();
+        server.callTool = vi
+            .fn()
+            .mockResolvedValue([{ type: "text", text: "result" }]);
+        const mcpTool = {
+            name: "test_tool",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    arg1: { type: "string" },
+                },
+            },
+        };
+        const functionTool = mcpToFunctionTool(server, mcpTool);
+        const ctx = new Context({});
+        const input = { arg1: "value1" };
+        await functionTool.invoke(ctx, JSON.stringify(input));
+        expect(server.callTool).toHaveBeenCalledWith("test_tool", input);
+        expect(server.callTool).toHaveBeenCalledTimes(1);
+    });
+    it("should return single content item correctly", async () => {
+        const server = createMockServer();
+        server.callTool = vi
+            .fn()
+            .mockResolvedValue([{ type: "text", text: "single result" }]);
+        const mcpTool = {
+            name: "test_tool",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        };
+        const functionTool = mcpToFunctionTool(server, mcpTool);
+        const ctx = new Context({});
+        const toolResult = await functionTool.invoke(ctx, JSON.stringify({}));
+        expect(toolResult.state).toBe("completed");
+        expect(toolResult.result).toEqual({ type: "text", text: "single result" });
+    });
+    it("should return multiple content items as array", async () => {
+        const server = createMockServer();
+        const multipleItems = [
+            { type: "text", text: "result 1" },
+            { type: "text", text: "result 2" },
+            { type: "text", text: "result 3" },
+        ];
+        server.callTool = vi.fn().mockResolvedValue(multipleItems);
+        const mcpTool = {
+            name: "test_tool",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        };
+        const functionTool = mcpToFunctionTool(server, mcpTool);
+        const ctx = new Context({});
+        const toolResult = await functionTool.invoke(ctx, JSON.stringify({}));
+        expect(toolResult.state).toBe("completed");
+        expect(toolResult.result).toEqual(multipleItems);
+        expect(Array.isArray(toolResult.result)).toBe(true);
+        expect(toolResult.result).toHaveLength(3);
+    });
+    it("should preserve tool name in closure", async () => {
+        const server = createMockServer();
+        server.callTool = vi
+            .fn()
+            .mockResolvedValue([{ type: "text", text: "result" }]);
+        const tool1 = {
+            name: "tool1",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const tool2 = {
+            name: "tool2",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const functionTool1 = mcpToFunctionTool(server, tool1);
+        const functionTool2 = mcpToFunctionTool(server, tool2);
+        const ctx = new Context({});
+        await functionTool1.invoke(ctx, JSON.stringify({}));
+        expect(server.callTool).toHaveBeenCalledWith("tool1", {});
+        await functionTool2.invoke(ctx, JSON.stringify({}));
+        expect(server.callTool).toHaveBeenCalledWith("tool2", {});
+    });
+    it("should use correct parameter order (context, params)", async () => {
+        const server = createMockServer();
+        server.callTool = vi
+            .fn()
+            .mockResolvedValue([{ type: "text", text: "result" }]);
+        const mcpTool = {
+            name: "test_tool",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    foo: { type: "string" },
+                },
+            },
+        };
+        const functionTool = mcpToFunctionTool(server, mcpTool);
+        // Invoke takes (context, params as JSON string) in that order
+        const ctx = new Context({});
+        const params = { foo: "bar" };
+        await functionTool.invoke(ctx, JSON.stringify(params));
+        // Verify the tool was called with the params (not the context)
+        expect(server.callTool).toHaveBeenCalledWith("test_tool", params);
+    });
+});
+describe("createMCPToolStaticFilter", () => {
+    // Helper to create mock filter context
+    const createMockFilterContext = () => ({
+        context: new Context({}),
+        agent: {},
+        serverId: "test-server",
+    });
+    it("should return undefined when no options provided", () => {
+        const filter = createMCPToolStaticFilter();
+        expect(filter).toBeUndefined();
+    });
+    it("should return undefined when options is empty object", () => {
+        const filter = createMCPToolStaticFilter({});
+        expect(filter).toBeUndefined();
+    });
+    it("should create allowlist filter correctly", async () => {
+        const filter = createMCPToolStaticFilter({
+            allowed: ["tool1", "tool2"],
+        });
+        expect(filter).toBeDefined();
+        const mockContext = createMockFilterContext();
+        const tool1 = {
+            name: "tool1",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const tool2 = {
+            name: "tool2",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const tool3 = {
+            name: "tool3",
+            inputSchema: { type: "object", properties: {} },
+        };
+        expect(await filter(mockContext, tool1)).toBe(true);
+        expect(await filter(mockContext, tool2)).toBe(true);
+        expect(await filter(mockContext, tool3)).toBe(false);
+    });
+    it("should create blocklist filter correctly", async () => {
+        const filter = createMCPToolStaticFilter({
+            blocked: ["dangerous_tool", "risky_tool"],
+        });
+        expect(filter).toBeDefined();
+        const mockContext = createMockFilterContext();
+        const safeTool = {
+            name: "safe_tool",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const dangerousTool = {
+            name: "dangerous_tool",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const riskyTool = {
+            name: "risky_tool",
+            inputSchema: { type: "object", properties: {} },
+        };
+        expect(await filter(mockContext, safeTool)).toBe(true);
+        expect(await filter(mockContext, dangerousTool)).toBe(false);
+        expect(await filter(mockContext, riskyTool)).toBe(false);
+    });
+    it("should combine allowlist and blocklist", async () => {
+        const filter = createMCPToolStaticFilter({
+            allowed: ["tool1", "tool2", "tool3"],
+            blocked: ["tool2"],
+        });
+        expect(filter).toBeDefined();
+        const mockContext = createMockFilterContext();
+        const tool1 = {
+            name: "tool1",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const tool2 = {
+            name: "tool2",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const tool3 = {
+            name: "tool3",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const tool4 = {
+            name: "tool4",
+            inputSchema: { type: "object", properties: {} },
+        };
+        expect(await filter(mockContext, tool1)).toBe(true);
+        expect(await filter(mockContext, tool2)).toBe(false); // In allowed but blocked
+        expect(await filter(mockContext, tool3)).toBe(true);
+        expect(await filter(mockContext, tool4)).toBe(false); // Not in allowed list
+    });
+    it("should default to allow-all when lists empty", async () => {
+        const filter = createMCPToolStaticFilter({
+            allowed: [],
+            blocked: [],
+        });
+        expect(filter).toBeDefined();
+        const mockContext = createMockFilterContext();
+        const tool1 = {
+            name: "tool1",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const tool2 = {
+            name: "tool2",
+            inputSchema: { type: "object", properties: {} },
+        };
+        expect(await filter(mockContext, tool1)).toBe(true);
+        expect(await filter(mockContext, tool2)).toBe(true);
+    });
+    it("should filter based on tool.name property", async () => {
+        const filter = createMCPToolStaticFilter({
+            allowed: ["exact_name"],
+        });
+        expect(filter).toBeDefined();
+        const mockContext = createMockFilterContext();
+        const exactMatch = {
+            name: "exact_name",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const partialMatch = {
+            name: "exact_name_with_suffix",
+            inputSchema: { type: "object", properties: {} },
+        };
+        const noMatch = {
+            name: "different_name",
+            inputSchema: { type: "object", properties: {} },
+        };
+        expect(await filter(mockContext, exactMatch)).toBe(true);
+        expect(await filter(mockContext, partialMatch)).toBe(false);
+        expect(await filter(mockContext, noMatch)).toBe(false);
+    });
+});

package/dist/mcp/base.d.ts

@@ -0,0 +1,88 @@
+import { Logger } from "../lib/logger";
+import { MCPTool, MCPToolFilter, CallToolResultContent } from "./types";
+export declare const DEFAULT_STDIO_MCP_CLIENT_LOGGER_NAME = "kernl:stdio-mcp-client";
+export declare const DEFAULT_SSE_MCP_CLIENT_LOGGER_NAME = "kernl:sse-mcp-client";
+export declare const DEFAULT_STREAMABLE_HTTP_MCP_CLIENT_LOGGER_NAME = "kernl:streamable-http-mcp-client";
+/**
+ * Interface for MCP server implementations.
+ * Provides methods for connecting, listing tools, calling tools, and cleanup.
+ */
+export interface MCPServer {
+    /**
+     * The unique identifier for this MCP server.
+     */
+    readonly id: string;
+    /**
+     * Whether to cache the tools list after first fetch.
+     */
+    cacheToolsList: boolean;
+    /**
+     * Filter to control which tools are exposed to agents.
+     * Always a callable function. Defaults to allowing all tools.
+     */
+    toolFilter: MCPToolFilter;
+    /**
+     * Establishes connection to the MCP server.
+     */
+    connect(): Promise<void>;
+    /**
+     * Closes the connection and cleans up resources.
+     */
+    close(): Promise<void>;
+    /**
+     * Fetches the list of available tools from the server.
+     */
+    listTools(): Promise<MCPTool[]>;
+    /**
+     * Executes a tool on the server with the provided arguments.
+     */
+    callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    /**
+     * Clears any cached tools, forcing a fresh fetch on next request.
+     */
+    invalidateCache(): Promise<void>;
+}
+/**
+ * Base abstract class for MCP server implementations.
+ * Provides common caching logic.
+ */
+export declare abstract class BaseMCPServer implements MCPServer {
+    abstract readonly id: string;
+    cacheToolsList: boolean;
+    toolFilter: MCPToolFilter;
+    protected logger: Logger;
+    protected _cachedTools: MCPTool[] | undefined;
+    protected _cacheDirty: boolean;
+    constructor(options: {
+        cacheToolsList?: boolean;
+        toolFilter?: MCPToolFilter;
+        logger: Logger;
+    });
+    /**
+     * Establishes connection to the MCP server.
+     */
+    abstract connect(): Promise<void>;
+    /**
+     * Closes the connection and cleans up resources.
+     */
+    abstract close(): Promise<void>;
+    /**
+     * Executes a tool on the server with the provided arguments.
+     */
+    abstract callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    /**
+     * Fetches the list of available tools from the server.
+     * Handles caching and static filtering automatically.
+     */
+    listTools(): Promise<MCPTool[]>;
+    /**
+     * Clears any cached tools, forcing a fresh fetch on next request.
+     */
+    invalidateCache(): Promise<void>;
+    /**
+     * Internal implementation: Fetches tools from the server (without caching logic).
+     * Subclasses implement the transport-specific logic.
+     */
+    protected abstract _listTools(): Promise<MCPTool[]>;
+}
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/mcp/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAExE,eAAO,MAAM,oCAAoC,2BAA2B,CAAC;AAC7E,eAAO,MAAM,kCAAkC,yBAAyB,CAAC;AACzE,eAAO,MAAM,8CAA8C,qCACvB,CAAC;AAoBrC;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,UAAU,EAAE,aAAa,CAAC;IAE1B;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAEhC;;OAEG;IACH,QAAQ,CACN,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAElC;;OAEG;IACH,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAED;;;GAGG;AACH,8BAAsB,aAAc,YAAW,SAAS;IACtD,QAAQ,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,EAAE,aAAa,CAAC;IACjC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,YAAY,EAAE,OAAO,EAAE,GAAG,SAAS,CAAa;IAC1D,SAAS,CAAC,WAAW,UAAQ;gBAEjB,OAAO,EAAE;QACnB,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,aAAa,CAAC;QAC3B,MAAM,EAAE,MAAM,CAAC;KAChB;IAMD;;OAEG;IACH,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAEjC;;OAEG;IACH,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAE/B;;OAEG;IACH,QAAQ,CAAC,QAAQ,CACf,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GACnC,OAAO,CAAC,qBAAqB,CAAC;IAEjC;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IA2BrC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtC;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,UAAU,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CACpD"}

package/dist/mcp/base.js

@@ -0,0 +1,68 @@
+export const DEFAULT_STDIO_MCP_CLIENT_LOGGER_NAME = "kernl:stdio-mcp-client";
+export const DEFAULT_SSE_MCP_CLIENT_LOGGER_NAME = "kernl:sse-mcp-client";
+export const DEFAULT_STREAMABLE_HTTP_MCP_CLIENT_LOGGER_NAME = "kernl:streamable-http-mcp-client";
+/**
+ * @example
+ *
+ *  const server = new MCPServerStdio({
+ *    id: 'Filesystem Server',
+ *    command: 'npx',
+ *    args: ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/dir']
+ *  });
+ *
+ *  await server.connect();  // Establishes connection to the MCP server process
+ */
+/**
+ * Cache storage for MCP tools by server id.
+ * Enables reusing tool definitions across multiple agent executions.
+ */
+const _cachedTools = {};
+/**
+ * Base abstract class for MCP server implementations.
+ * Provides common caching logic.
+ */
+export class BaseMCPServer {
+    cacheToolsList;
+    toolFilter;
+    logger;
+    _cachedTools = undefined;
+    _cacheDirty = true;
+    constructor(options) {
+        this.logger = options.logger;
+        this.cacheToolsList = options.cacheToolsList ?? false;
+        this.toolFilter = options.toolFilter ?? (async () => true);
+    }
+    /**
+     * Fetches the list of available tools from the server.
+     * Handles caching and static filtering automatically.
+     */
+    async listTools() {
+        if (this.cacheToolsList && !this._cacheDirty && this._cachedTools) {
+            return this._cachedTools;
+        }
+        this._cacheDirty = false;
+        let tools = await this._listTools();
+        // Apply static server-level filter (without context)
+        // This is for static filtering like allowlist/blocklist
+        const filteredTools = [];
+        for (const tool of tools) {
+            // Pass empty context for static filtering
+            const allowed = await this.toolFilter({}, tool);
+            if (allowed) {
+                filteredTools.push(tool);
+            }
+        }
+        tools = filteredTools;
+        if (this.cacheToolsList) {
+            this._cachedTools = tools;
+        }
+        return tools;
+    }
+    /**
+     * Clears any cached tools, forcing a fresh fetch on next request.
+     */
+    async invalidateCache() {
+        delete _cachedTools[this.id];
+        this._cacheDirty = true;
+    }
+}

package/dist/mcp/http.d.ts

@@ -0,0 +1,34 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { BaseMCPServer } from "./base";
+import type { MCPTool, CallToolResultContent, MCPServerStreamableHttpOptions, InitializeResult } from "./types";
+/**
+ * MCP server client that communicates over streamable HTTP protocol.
+ */
+export declare class MCPServerStreamableHttp extends BaseMCPServer {
+    readonly id: string;
+    protected session: Client | null;
+    protected timeout: number;
+    protected serverInitializeResult: InitializeResult | null;
+    params: MCPServerStreamableHttpOptions;
+    private transport;
+    constructor(options: MCPServerStreamableHttpOptions);
+    /**
+     * Establishes connection to the MCP server.
+     */
+    connect(): Promise<void>;
+    /**
+     * Closes the connection and cleans up resources.
+     */
+    close(): Promise<void>;
+    /**
+     * Internal implementation: Fetches tools from the server.
+     *
+     * Cached via the abstract base 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>;
+}
+//# sourceMappingURL=http.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/mcp/http.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAUnE,OAAO,EACL,aAAa,EAEd,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EACV,OAAO,EACP,qBAAqB,EACrB,8BAA8B,EAC9B,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,aAAa;IACxD,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,8BAA8B,CAAC;IACvC,OAAO,CAAC,SAAS,CAAa;gBAElB,OAAO,EAAE,8BAA8B;IAcnD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAgC9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B;;;;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;CA2BlC"}

package/dist/mcp/http.js

@@ -0,0 +1,100 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.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_STREAMABLE_HTTP_MCP_CLIENT_LOGGER_NAME, } from "./base";
+/**
+ * MCP server client that communicates over streamable HTTP protocol.
+ */
+export class MCPServerStreamableHttp 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_STREAMABLE_HTTP_MCP_CLIENT_LOGGER_NAME),
+        });
+        this.params = options;
+        this.id = options.id || `streamable-http: ${this.params.url}`;
+        this.timeout = options.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+    }
+    /**
+     * Establishes connection to the MCP server.
+     */
+    async connect() {
+        try {
+            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.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}`);
+    }
+    /**
+     * 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;
+        }
+    }
+    /**
+     * Internal implementation: Fetches tools from the server.
+     *
+     * Cached via the abstract base 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;
+    }
+}

package/dist/mcp/node.d.ts

@@ -0,0 +1,60 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { MCPTool, CallToolResultContent, DefaultMCPServerStdioOptions, InitializeResult, MCPServerSSEOptions, MCPServerStreamableHttpOptions, MCPServerStdioOptions } from "./types";
+export interface SessionMessage {
+    message: any;
+}
+export declare class NodeMCPServerStdio extends BaseMCPServerStdio {
+    protected session: Client | null;
+    protected _cacheDirty: boolean;
+    protected _toolsList: any[];
+    protected serverInitializeResult: InitializeResult | null;
+    protected clientSessionTimeoutSeconds?: number;
+    protected timeout: number;
+    params: DefaultMCPServerStdioOptions;
+    private _name;
+    private transport;
+    constructor(params: MCPServerStdioOptions);
+    connect(): Promise<void>;
+    invalidateToolsCache(): Promise<void>;
+    listTools(): Promise<MCPTool[]>;
+    callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    get name(): string;
+    close(): Promise<void>;
+}
+export declare class NodeMCPServerSSE extends BaseMCPServerSSE {
+    protected session: Client | null;
+    protected _cacheDirty: boolean;
+    protected _toolsList: any[];
+    protected serverInitializeResult: InitializeResult | null;
+    protected clientSessionTimeoutSeconds?: number;
+    protected timeout: number;
+    params: MCPServerSSEOptions;
+    private _name;
+    private transport;
+    constructor(params: MCPServerSSEOptions);
+    connect(): Promise<void>;
+    invalidateToolsCache(): Promise<void>;
+    listTools(): Promise<MCPTool[]>;
+    callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    get name(): string;
+    close(): Promise<void>;
+}
+export declare class NodeMCPServerStreamableHttp extends BaseMCPServerStreamableHttp {
+    protected session: Client | null;
+    protected _cacheDirty: boolean;
+    protected _toolsList: any[];
+    protected serverInitializeResult: InitializeResult | null;
+    protected clientSessionTimeoutSeconds?: number;
+    protected timeout: number;
+    params: MCPServerStreamableHttpOptions;
+    private _name;
+    private transport;
+    constructor(params: MCPServerStreamableHttpOptions);
+    connect(): Promise<void>;
+    invalidateToolsCache(): Promise<void>;
+    listTools(): Promise<MCPTool[]>;
+    callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    get name(): string;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/mcp/node.ts"],"names":[],"mappings":"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"}