kernl 0.1.1

package/dist/tool/__tests__/fixtures.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { Context } from "../../context";
+import { tool, HostedTool } from "../tool";
+/**
+ * Create a minimal mock context for testing
+ */
+export const mockContext = (data) => {
+    return new Context(data ?? {});
+};
+/**
+ * Simple string tool with no parameters
+ */
+export const simpleStringTool = tool({
+    id: "simple",
+    description: "A simple tool that echoes input",
+    parameters: undefined,
+    execute: async (ctx, input) => `Echo: ${input}`,
+});
+/**
+ * Tool with Zod schema validation
+ */
+export const zodTool = tool({
+    id: "zod-tool",
+    description: "Tool with Zod schema",
+    parameters: z.object({
+        name: z.string(),
+        age: z.number(),
+    }),
+    execute: async (ctx, { name, age }) => `${name} is ${age} years old`,
+});
+/**
+ * Tool that always throws an error
+ */
+export const errorTool = tool({
+    id: "error-tool",
+    description: "Always throws an error",
+    parameters: undefined,
+    execute: async () => {
+        throw new Error("Tool execution failed");
+    },
+});
+/**
+ * Tool with custom error handler
+ */
+export const customErrorTool = tool({
+    id: "custom-error-tool",
+    description: "Tool with custom error handler",
+    parameters: undefined,
+    execute: async () => {
+        throw new Error("Original error");
+    },
+    errorfn: (ctx, error) => {
+        return "Custom error message";
+    },
+});
+/**
+ * Tool requiring approval (boolean)
+ */
+export const approvalRequiredTool = tool({
+    id: "approval-tool",
+    description: "Requires approval",
+    parameters: undefined,
+    requiresApproval: true,
+    execute: async () => "executed",
+});
+/**
+ * Tool with conditional approval (function)
+ */
+export const conditionalApprovalTool = tool({
+    id: "conditional-approval",
+    description: "Conditionally requires approval",
+    parameters: z.object({
+        dangerous: z.boolean(),
+    }),
+    requiresApproval: async (ctx, input) => {
+        return input.dangerous === true;
+    },
+    execute: async (ctx, { dangerous }) => `Executed with dangerous=${dangerous}`,
+});
+/**
+ * Mock hosted tool (e.g., web_search)
+ */
+export const mockHostedTool = new HostedTool({
+    id: "web-search",
+    name: "Web Search",
+    providerData: {
+        provider: "anthropic",
+        capabilities: ["search", "fetch"],
+    },
+});
+/**
+ * Another mock hosted tool
+ */
+export const anotherHostedTool = new HostedTool({
+    id: "file-search",
+    name: "File Search",
+});

package/dist/tool/__tests__/tool.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool.test.d.ts.map

package/dist/tool/__tests__/tool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.test.d.ts","sourceRoot":"","sources":["../../../src/tool/__tests__/tool.test.ts"],"names":[],"mappings":""}

package/dist/tool/__tests__/tool.test.js

@@ -0,0 +1,172 @@
+import { describe, it, expect } from "vitest";
+import { COMPLETED, FAILED } from "@kernl/protocol";
+import { tool } from "../tool";
+import { mockContext, simpleStringTool, zodTool, errorTool, customErrorTool, approvalRequiredTool, conditionalApprovalTool, } from "./fixtures";
+describe("FunctionTool", () => {
+    describe("creation", () => {
+        it("should create tool with required config", () => {
+            const t = tool({
+                id: "test",
+                description: "Test tool",
+                parameters: undefined,
+                execute: async () => "result",
+            });
+            expect(t.id).toBe("test");
+            expect(t.description).toBe("Test tool");
+            expect(t.type).toBe("function");
+        });
+        it("should default mode to blocking", () => {
+            const t = tool({
+                id: "test",
+                description: "Test tool",
+                parameters: undefined,
+                execute: async () => "result",
+            });
+            expect(t.mode).toBe("blocking");
+        });
+        it("should accept custom mode", () => {
+            const t = tool({
+                id: "test",
+                description: "Test tool",
+                parameters: undefined,
+                mode: "async",
+                execute: async () => "result",
+            });
+            expect(t.mode).toBe("async");
+        });
+    });
+    describe("parameter parsing", () => {
+        it("should handle string input when no parameters schema", async () => {
+            const ctx = mockContext();
+            const result = await simpleStringTool.invoke(ctx, "hello");
+            expect(result.state).toBe(COMPLETED);
+            expect(result.result).toBe("Echo: hello");
+        });
+        it("should parse and validate with Zod schema", async () => {
+            const ctx = mockContext();
+            const input = JSON.stringify({ name: "Alice", age: 30 });
+            const result = await zodTool.invoke(ctx, input);
+            expect(result.state).toBe(COMPLETED);
+            expect(result.result).toBe("Alice is 30 years old");
+        });
+        it("should throw ModelBehaviorError on invalid JSON", async () => {
+            const ctx = mockContext();
+            const result = await zodTool.invoke(ctx, "not valid json");
+            expect(result.state).toBe(FAILED);
+            expect(result.error).toContain("Invalid JSON input for tool");
+        });
+        it("should throw ModelBehaviorError on schema validation failure", async () => {
+            const ctx = mockContext();
+            const input = JSON.stringify({ name: "Alice", age: "not a number" });
+            const result = await zodTool.invoke(ctx, input);
+            expect(result.state).toBe(FAILED);
+            expect(result.error).toContain("Invalid JSON input for tool");
+        });
+    });
+    describe("execution", () => {
+        it("should execute and return ToolResult with completed status", async () => {
+            const ctx = mockContext();
+            const result = await simpleStringTool.invoke(ctx, "test");
+            expect(result.state).toBe(COMPLETED);
+            expect(result.result).toBe("Echo: test");
+            expect(result.error).toBe(null);
+        });
+        it("should handle sync execute functions", async () => {
+            const syncTool = tool({
+                id: "sync",
+                description: "Sync tool",
+                parameters: undefined,
+                execute: (ctx, input) => `Sync: ${input}`,
+            });
+            const ctx = mockContext();
+            const result = await syncTool.invoke(ctx, "test");
+            expect(result.state).toBe(COMPLETED);
+            expect(result.result).toBe("Sync: test");
+        });
+        it("should handle async execute functions", async () => {
+            const asyncTool = tool({
+                id: "async",
+                description: "Async tool",
+                parameters: undefined,
+                execute: async (ctx, input) => Promise.resolve(`Async: ${input}`),
+            });
+            const ctx = mockContext();
+            const result = await asyncTool.invoke(ctx, "test");
+            expect(result.state).toBe(COMPLETED);
+            expect(result.result).toBe("Async: test");
+        });
+    });
+    describe("error handling", () => {
+        it("should return error ToolResult when execute throws", async () => {
+            const ctx = mockContext();
+            const result = await errorTool.invoke(ctx, "test");
+            expect(result.state).toBe(FAILED);
+            expect(result.result).toBe(undefined);
+            expect(result.error).toContain("Tool execution failed");
+        });
+        it("should use custom error function if provided", async () => {
+            const ctx = mockContext();
+            const result = await customErrorTool.invoke(ctx, "test");
+            expect(result.state).toBe(FAILED);
+            expect(result.error).toBe("Custom error message");
+        });
+        it("should use default error function if none provided", async () => {
+            const ctx = mockContext();
+            const result = await errorTool.invoke(ctx, "test");
+            expect(result.state).toBe(FAILED);
+            expect(result.error).toContain("An error occurred while running the tool");
+        });
+    });
+    describe("approval", () => {
+        it("should evaluate boolean requiresApproval", async () => {
+            const ctx = mockContext();
+            const requiresApproval = await approvalRequiredTool.requiresApproval(ctx, "test");
+            expect(requiresApproval).toBe(true);
+        });
+        it("should evaluate function requiresApproval", async () => {
+            const ctx = mockContext();
+            const dangerous = await conditionalApprovalTool.requiresApproval(ctx, {
+                dangerous: true,
+            });
+            const safe = await conditionalApprovalTool.requiresApproval(ctx, {
+                dangerous: false,
+            });
+            expect(dangerous).toBe(true);
+            expect(safe).toBe(false);
+        });
+    });
+    describe("isEnabled", () => {
+        it("should default to enabled", async () => {
+            const ctx = mockContext();
+            const enabled = await simpleStringTool.isEnabled(ctx, null);
+            expect(enabled).toBe(true);
+        });
+        it("should evaluate boolean isEnabled", async () => {
+            const disabledTool = tool({
+                id: "disabled",
+                description: "Disabled tool",
+                parameters: undefined,
+                isEnabled: false,
+                execute: async () => "result",
+            });
+            const ctx = mockContext();
+            const enabled = await disabledTool.isEnabled(ctx, null);
+            expect(enabled).toBe(false);
+        });
+        it("should evaluate function isEnabled with typed context", async () => {
+            const conditionalTool = tool({
+                id: "conditional",
+                description: "Conditional tool",
+                parameters: undefined,
+                isEnabled: ({ context }) => {
+                    return context.context.enabled === true;
+                },
+                execute: async () => "result",
+            });
+            const enabledCtx = mockContext({ enabled: true });
+            const disabledCtx = mockContext({ enabled: false });
+            expect(await conditionalTool.isEnabled(enabledCtx, null)).toBe(true);
+            expect(await conditionalTool.isEnabled(disabledCtx, null)).toBe(false);
+        });
+    });
+});

package/dist/tool/__tests__/toolkit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=toolkit.test.d.ts.map

package/dist/tool/__tests__/toolkit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolkit.test.d.ts","sourceRoot":"","sources":["../../../src/tool/__tests__/toolkit.test.ts"],"names":[],"mappings":""}

package/dist/tool/__tests__/toolkit.test.js

@@ -0,0 +1,134 @@
+import { describe, it, expect } from "vitest";
+import { FunctionToolkit } from "../toolkit";
+import { simpleStringTool, zodTool, errorTool, mockHostedTool, anotherHostedTool, } from "./fixtures";
+describe("FunctionToolkit", () => {
+    describe("constructor", () => {
+        it("should create empty toolkit with no tools", async () => {
+            const toolkit = new FunctionToolkit({ id: "empty", tools: [] });
+            expect(await toolkit.list()).toEqual([]);
+        });
+        it("should initialize with systools", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [mockHostedTool] });
+            expect(await toolkit.list()).toHaveLength(1);
+            expect(toolkit.get("web-search")).toBe(mockHostedTool);
+        });
+        it("should initialize with function tools", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [simpleStringTool, zodTool] });
+            expect(await toolkit.list()).toHaveLength(2);
+            expect(toolkit.get("simple")).toBe(simpleStringTool);
+            expect(toolkit.get("zod-tool")).toBe(zodTool);
+        });
+        it("should initialize with both systools and functions", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [mockHostedTool, simpleStringTool] });
+            expect(await toolkit.list()).toHaveLength(2);
+            expect(toolkit.get("web-search")).toBe(mockHostedTool);
+            expect(toolkit.get("simple")).toBe(simpleStringTool);
+        });
+    });
+    describe("get", () => {
+        it("should return undefined for non-existent tool", () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [] });
+            expect(toolkit.get("non-existent")).toBeUndefined();
+        });
+        it("should get systool by id", () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [mockHostedTool] });
+            expect(toolkit.get("web-search")).toBe(mockHostedTool);
+        });
+        it("should get function tool by id", () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [simpleStringTool] });
+            expect(toolkit.get("simple")).toBe(simpleStringTool);
+        });
+    });
+    describe("list", () => {
+        it("should return empty array for empty toolkit", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [] });
+            expect(await toolkit.list()).toEqual([]);
+        });
+        it("should list all systools", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [mockHostedTool, anotherHostedTool] });
+            const tools = await toolkit.list();
+            expect(tools).toHaveLength(2);
+            expect(tools).toContain(mockHostedTool);
+            expect(tools).toContain(anotherHostedTool);
+        });
+        it("should list all function tools", async () => {
+            const toolkit = new FunctionToolkit({
+                id: "test",
+                tools: [simpleStringTool, zodTool, errorTool],
+            });
+            const tools = await toolkit.list();
+            expect(tools).toHaveLength(3);
+            expect(tools).toContain(simpleStringTool);
+            expect(tools).toContain(zodTool);
+            expect(tools).toContain(errorTool);
+        });
+        it("should list both systools and function tools", async () => {
+            const toolkit = new FunctionToolkit({
+                id: "test",
+                tools: [mockHostedTool, simpleStringTool, zodTool],
+            });
+            const tools = await toolkit.list();
+            expect(tools).toHaveLength(3);
+            expect(tools).toContain(mockHostedTool);
+            expect(tools).toContain(simpleStringTool);
+            expect(tools).toContain(zodTool);
+        });
+    });
+    describe("serialize", () => {
+        it("should return empty array for empty toolkit", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [] });
+            expect((await toolkit.list()).map((tool) => tool.serialize())).toEqual([]);
+        });
+        it("should serialize function tools correctly", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [simpleStringTool] });
+            const serialized = (await toolkit.list()).map((tool) => tool.serialize());
+            expect(serialized).toHaveLength(1);
+            expect(serialized[0]).toEqual({
+                type: "function",
+                name: simpleStringTool.name,
+                description: simpleStringTool.description,
+                parameters: simpleStringTool.parameters,
+            });
+        });
+        it("should serialize hosted tools correctly", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [mockHostedTool] });
+            const serialized = (await toolkit.list()).map((tool) => tool.serialize());
+            expect(serialized).toHaveLength(1);
+            expect(serialized[0]).toEqual({
+                type: "hosted-tool",
+                id: mockHostedTool.id,
+                name: mockHostedTool.name,
+                providerData: mockHostedTool.providerData,
+            });
+        });
+        it("should serialize both function and hosted tools", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [mockHostedTool, simpleStringTool] });
+            const serialized = (await toolkit.list()).map((tool) => tool.serialize());
+            expect(serialized).toHaveLength(2);
+            // Check both tools are present (order not guaranteed with Map)
+            expect(serialized).toContainEqual({
+                type: "hosted-tool",
+                id: mockHostedTool.id,
+                name: mockHostedTool.name,
+                providerData: mockHostedTool.providerData,
+            });
+            expect(serialized).toContainEqual({
+                type: "function",
+                name: simpleStringTool.name,
+                description: simpleStringTool.description,
+                parameters: simpleStringTool.parameters,
+            });
+        });
+        it("should handle hosted tools without providerData", async () => {
+            const toolkit = new FunctionToolkit({ id: "test", tools: [anotherHostedTool] });
+            const serialized = (await toolkit.list()).map((tool) => tool.serialize());
+            expect(serialized).toHaveLength(1);
+            expect(serialized[0]).toEqual({
+                type: "hosted-tool",
+                id: anotherHostedTool.id,
+                name: anotherHostedTool.name,
+                providerData: undefined,
+            });
+        });
+    });
+});

package/dist/tool/index.d.ts

@@ -0,0 +1,4 @@
+export { BaseTool, FunctionTool, HostedTool, tool } from "./tool";
+export { Toolkit, FunctionToolkit, MCPToolkit } from "./toolkit";
+export type { Tool, ToolResult, FunctionToolkitConfig, MCPToolkitConfig, ToolkitFilter, ToolkitFilterContext, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/tool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tool/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACjE,YAAY,EACV,IAAI,EACJ,UAAU,EACV,qBAAqB,EACrB,gBAAgB,EAChB,aAAa,EACb,oBAAoB,GACrB,MAAM,SAAS,CAAC"}

package/dist/tool/index.js

@@ -0,0 +1,2 @@
+export { BaseTool, FunctionTool, HostedTool, tool } from "./tool";
+export { Toolkit, FunctionToolkit, MCPToolkit } from "./toolkit";

package/dist/tool/mcp.d.ts

@@ -0,0 +1,75 @@
+import type { Context, UnknownContext } from "../context";
+import { Toolkit } from "./toolkit";
+import type { Tool } from ".";
+import type { MCPToolkitConfig } from "./types";
+/**
+ * A toolkit that wraps an MCP server and provides tools from it.
+ *
+ * Handles connection lifecycle automatically - connects lazily on first tool request
+ * and provides cleanup via destroy().
+ *
+ * @example
+ * ```ts
+ * const server = new MCPServerStdio({
+ *   id: "github",
+ *   command: "npx",
+ *   args: ["-y", "@modelcontextprotocol/server-github"],
+ *   env: {
+ *     GITHUB_TOKEN: process.env.GITHUB_TOKEN,
+ *   },
+ * });
+ *
+ * const github = new MCPToolkit({
+ *   id: "github",
+ *   server,
+ *   filter: async (ctx, tool) => {
+ *     // Only allow certain tools
+ *     return !tool.id.startsWith("dangerous_");
+ *   },
+ * });
+ *
+ * const agent = new Agent({
+ *   toolkits: [github],
+ * });
+ * ```
+ */
+export declare class MCPToolkit<TContext = UnknownContext> extends Toolkit<TContext> {
+    readonly id: string;
+    private server;
+    private cache;
+    private filter;
+    private connected;
+    private cached;
+    /**
+     * Create a new MCP toolkit.
+     *
+     * @param config Toolkit configuration with id and server instance
+     */
+    constructor(config: MCPToolkitConfig<TContext>);
+    /**
+     * Get a specific tool by ID.
+     *
+     * Returns the tool from the local cache. The cache is populated on the first
+     * call to list(). Returns undefined if list() hasn't been called yet.
+     *
+     * @param id The tool ID to look up
+     * @returns The tool if found in cache, undefined otherwise
+     */
+    get(id: string): Tool<TContext> | undefined;
+    /**
+     * List all tools available from the MCP server.
+     *
+     * Connects to the server lazily on first call. Tools are cached locally after
+     * the first fetch. The MCP server itself also handles caching via the
+     * cacheToolsList option, so the network call is only made once.
+     *
+     * @param context Optional context for filtering tools
+     * @returns Array of tools from the MCP server
+     */
+    list(context?: Context<TContext>): Promise<Tool<TContext>[]>;
+    /**
+     * Cleanup resources and close the MCP server connection.
+     */
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=mcp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/tool/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAOzD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC;AAC9B,OAAO,KAAK,EAAE,gBAAgB,EAAiB,MAAM,SAAS,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,UAAU,CAAC,QAAQ,GAAG,cAAc,CAAE,SAAQ,OAAO,CAAC,QAAQ,CAAC;IAC1E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,MAAM,CAA0B;IAExC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;OAIG;gBACS,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC;IAQ9C;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,SAAS;IAI3C;;;;;;;;;OASG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;IA+BlE;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ/B"}

package/dist/tool/mcp.js

@@ -0,0 +1,111 @@
+import { mcpToFunctionTool } from "../mcp/utils";
+import { filter } from "../lib/utils";
+import { Toolkit } from "./toolkit";
+/**
+ * A toolkit that wraps an MCP server and provides tools from it.
+ *
+ * Handles connection lifecycle automatically - connects lazily on first tool request
+ * and provides cleanup via destroy().
+ *
+ * @example
+ * ```ts
+ * const server = new MCPServerStdio({
+ *   id: "github",
+ *   command: "npx",
+ *   args: ["-y", "@modelcontextprotocol/server-github"],
+ *   env: {
+ *     GITHUB_TOKEN: process.env.GITHUB_TOKEN,
+ *   },
+ * });
+ *
+ * const github = new MCPToolkit({
+ *   id: "github",
+ *   server,
+ *   filter: async (ctx, tool) => {
+ *     // Only allow certain tools
+ *     return !tool.id.startsWith("dangerous_");
+ *   },
+ * });
+ *
+ * const agent = new Agent({
+ *   toolkits: [github],
+ * });
+ * ```
+ */
+export class MCPToolkit extends Toolkit {
+    id;
+    server;
+    cache;
+    filter;
+    connected = false;
+    cached = false;
+    /**
+     * Create a new MCP toolkit.
+     *
+     * @param config Toolkit configuration with id and server instance
+     */
+    constructor(config) {
+        super();
+        this.id = config.id;
+        this.server = config.server;
+        this.filter = config.filter ?? (() => true);
+        this.cache = new Map();
+    }
+    /**
+     * Get a specific tool by ID.
+     *
+     * Returns the tool from the local cache. The cache is populated on the first
+     * call to list(). Returns undefined if list() hasn't been called yet.
+     *
+     * @param id The tool ID to look up
+     * @returns The tool if found in cache, undefined otherwise
+     */
+    get(id) {
+        return this.cache.get(id);
+    }
+    /**
+     * List all tools available from the MCP server.
+     *
+     * Connects to the server lazily on first call. Tools are cached locally after
+     * the first fetch. The MCP server itself also handles caching via the
+     * cacheToolsList option, so the network call is only made once.
+     *
+     * @param context Optional context for filtering tools
+     * @returns Array of tools from the MCP server
+     */
+    async list(context) {
+        if (!this.connected) {
+            await this.server.connect();
+            this.connected = true;
+        }
+        // lazy cache population
+        if (!this.cached) {
+            const mcpTools = await this.server.listTools();
+            for (const mcpTool of mcpTools) {
+                const tool = mcpToFunctionTool(this.server, mcpTool);
+                this.cache.set(tool.id, tool);
+            }
+            this.cached = true;
+        }
+        const tools = Array.from(this.cache.values());
+        // apply filter
+        if (context && this.agent) {
+            const ctx = { context, agent: this.agent, toolkitId: this.id };
+            return filter(tools, async (tool) => {
+                return await this.filter(ctx, tool);
+            });
+        }
+        return tools;
+    }
+    /**
+     * Cleanup resources and close the MCP server connection.
+     */
+    async destroy() {
+        if (this.connected) {
+            await this.server.close();
+            this.connected = false;
+            this.cache.clear();
+            this.cached = false;
+        }
+    }
+}