kernl 0.1.1

package/src/mcp/__tests__/stdio.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { MCPServerStdio } from "../stdio";
+import { withMCPServer, createMCPServer } from "./fixtures/utils";
+import path from "path";
+
+const TEST_SERVER = path.join(__dirname, "fixtures", "server.ts");
+
+describe("MCPServerStdio", () => {
+  describe("Connection Lifecycle", () => {
+    it("should connect successfully to a server", async () => {
+      await withMCPServer(TEST_SERVER, async (server) => {
+        expect(server).toBeDefined();
+        // If we get here, connection was successful
+      });
+    });
+
+    it("should handle connection failure gracefully", async () => {
+      const server = createMCPServer("/nonexistent/server.ts");
+
+      await expect(server.connect()).rejects.toThrow();
+    });
+
+    it("should close connection cleanly", async () => {
+      const server = createMCPServer(TEST_SERVER);
+      await server.connect();
+      await server.close();
+
+      // Attempting to call a tool after close should fail
+      await expect(server.callTool("add", { a: 1, b: 2 })).rejects.toThrow();
+    });
+
+    it("should allow reconnection after close", async () => {
+      const server = createMCPServer(TEST_SERVER);
+
+      await server.connect();
+      await server.close();
+
+      await server.connect();
+      const tools = await server.listTools();
+      expect(tools.length).toBeGreaterThan(0);
+
+      await server.close();
+    });
+  });
+
+  describe("Tool Discovery", () => {
+    it("should list tools after connect", async () => {
+      await withMCPServer(TEST_SERVER, async (server) => {
+        const tools = await server.listTools();
+
+        expect(tools).toHaveLength(6);
+        expect(tools.map((t: any) => t.name)).toEqual(
+          expect.arrayContaining([
+            "add",
+            "multiply",
+            "divide",
+            "echo",
+            "uppercase",
+            "reverse",
+          ]),
+        );
+      });
+    });
+
+    it("should include tool metadata", async () => {
+      await withMCPServer(TEST_SERVER, async (server) => {
+        const tools = await server.listTools();
+        const addTool = tools.find((t: any) => t.name === "add");
+
+        expect(addTool).toBeDefined();
+        expect(addTool!.description).toBe("Add two numbers");
+        expect(addTool!.inputSchema).toBeDefined();
+        expect(addTool!.inputSchema.properties).toHaveProperty("a");
+        expect(addTool!.inputSchema.properties).toHaveProperty("b");
+      });
+    });
+
+    it("should handle empty tool list", async () => {
+      // We'd need a server with no tools for this, skip for now
+      // or create a minimal-server fixture
+    });
+  });
+
+  describe("Tool Execution", () => {
+    it("should call tool with valid params", async () => {
+      await withMCPServer(TEST_SERVER, async (server) => {
+        const result = await server.callTool("add", { a: 5, b: 3 });
+
+        expect(result).toHaveLength(1);
+        expect(result[0].type).toBe("text");
+        expect(result[0].text).toBe("8");
+      });
+    });
+
+    it("should handle multiple different tool calls", async () => {
+      await withMCPServer(TEST_SERVER, async (server) => {
+        const add = await server.callTool("add", { a: 10, b: 20 });
+        expect(add[0].text).toBe("30");
+
+        const multiply = await server.callTool("multiply", { a: 4, b: 5 });
+        expect(multiply[0].text).toBe("20");
+
+        const divide = await server.callTool("divide", { a: 100, b: 4 });
+        expect(divide[0].text).toBe("25");
+      });
+    });
+
+    it("should handle tool execution error", async () => {
+      await withMCPServer(TEST_SERVER, async (server) => {
+        // Division by zero should throw
+        await expect(
+          server.callTool("divide", { a: 10, b: 0 }),
+        ).rejects.toThrow("Division by zero");
+      });
+    });
+
+    it("should handle tool not found", async () => {
+      await withMCPServer(TEST_SERVER, async (server) => {
+        await expect(
+          server.callTool("nonexistent", { foo: "bar" }),
+        ).rejects.toThrow();
+      });
+    });
+
+    it("should work with string manipulation tools", async () => {
+      await withMCPServer(TEST_SERVER, async (server) => {
+        const echo = await server.callTool("echo", { text: "hello" });
+        expect(echo[0].text).toBe("hello");
+
+        const upper = await server.callTool("uppercase", { text: "hello" });
+        expect(upper[0].text).toBe("HELLO");
+
+        const reverse = await server.callTool("reverse", { text: "hello" });
+        expect(reverse[0].text).toBe("olleh");
+      });
+    });
+  });
+
+  describe("Caching", () => {
+    it("should not cache tools list by default", async () => {
+      const server = createMCPServer(TEST_SERVER, {
+        cacheToolsList: false,
+      });
+
+      await server.connect();
+
+      const tools1 = await server.listTools();
+      const tools2 = await server.listTools();
+
+      // Both should succeed (no cache = fresh fetch each time)
+      expect(tools1).toHaveLength(6);
+      expect(tools2).toHaveLength(6);
+
+      await server.close();
+    });
+
+    it("should cache tools list when enabled", async () => {
+      const server = createMCPServer(TEST_SERVER, {
+        cacheToolsList: true,
+      });
+
+      await server.connect();
+
+      const tools1 = await server.listTools();
+      const tools2 = await server.listTools();
+
+      // Should get same results from cache
+      expect(tools1).toHaveLength(6);
+      expect(tools2).toHaveLength(6);
+      expect(tools1).toEqual(tools2);
+
+      await server.close();
+    });
+
+    it("should invalidate cache when requested", async () => {
+      const server = createMCPServer(TEST_SERVER, {
+        cacheToolsList: true,
+      });
+
+      await server.connect();
+
+      const tools1 = await server.listTools();
+      expect(tools1).toHaveLength(6);
+
+      await server.invalidateCache();
+
+      const tools2 = await server.listTools();
+      expect(tools2).toHaveLength(6);
+
+      await server.close();
+    });
+  });
+
+  describe("Constructor options", () => {
+    it("should accept command and args", async () => {
+      const server = new MCPServerStdio({
+        id: "test",
+        command: "npx",
+        args: ["tsx", TEST_SERVER],
+      });
+
+      await server.connect();
+      const tools = await server.listTools();
+      expect(tools.length).toBeGreaterThan(0);
+      await server.close();
+    });
+
+    it("should use custom id", async () => {
+      const server = createMCPServer(TEST_SERVER, { id: "my-test-server" });
+      expect(server.id).toBe("my-test-server");
+    });
+
+    it("should generate default id from command", async () => {
+      const server = new MCPServerStdio({
+        command: "npx",
+        args: ["tsx", TEST_SERVER],
+      });
+
+      expect(server.id).toContain("npx");
+    });
+  });
+
+  describe("Error handling", () => {
+    it("should throw error when calling tool before connect", async () => {
+      const server = createMCPServer(TEST_SERVER);
+
+      await expect(server.callTool("add", { a: 1, b: 2 })).rejects.toThrow();
+    });
+
+    it("should throw error when listing tools before connect", async () => {
+      const server = createMCPServer(TEST_SERVER);
+
+      await expect(server.listTools()).rejects.toThrow();
+    });
+  });
+});

package/src/mcp/__tests__/utils.test.ts

@@ -0,0 +1,360 @@
+import { describe, it, expect, vi } from "vitest";
+import { mcpToFunctionTool, createMCPToolStaticFilter } from "../utils";
+import type { MCPServer } from "../base";
+import type { MCPTool, MCPToolFilterContext } from "../types";
+import { Context } from "@/context";
+import { Agent } from "@/agent";
+
+describe("mcpToFunctionTool", () => {
+  // Create a mock MCP server
+  const createMockServer = (): MCPServer => ({
+    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: 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: 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",
+    } as any as MCPTool;
+
+    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: 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: 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: 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: MCPTool = {
+      name: "tool1",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const tool2: MCPTool = {
+      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: 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 = (): MCPToolFilterContext => ({
+    context: new Context({}),
+    agent: {} as 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: MCPTool = {
+      name: "tool1",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const tool2: MCPTool = {
+      name: "tool2",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const tool3: MCPTool = {
+      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: MCPTool = {
+      name: "safe_tool",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const dangerousTool: MCPTool = {
+      name: "dangerous_tool",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const riskyTool: MCPTool = {
+      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: MCPTool = {
+      name: "tool1",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const tool2: MCPTool = {
+      name: "tool2",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const tool3: MCPTool = {
+      name: "tool3",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const tool4: MCPTool = {
+      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: MCPTool = {
+      name: "tool1",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const tool2: MCPTool = {
+      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: MCPTool = {
+      name: "exact_name",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const partialMatch: MCPTool = {
+      name: "exact_name_with_suffix",
+      inputSchema: { type: "object", properties: {} },
+    };
+    const noMatch: MCPTool = {
+      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);
+  });
+});