0xray 2.0.0

package/src/mcps/tools/__tests__/tool-cache.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Tool Cache Tests
+ *
+ * Comprehensive test suite for the ToolCache class.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ToolCache } from '../tool-cache.js';
+import { MCPTool } from '../../types/index.js';
+
+describe('ToolCache', () => {
+  let cache: ToolCache;
+
+  beforeEach(() => {
+    cache = new ToolCache();
+  });
+
+  describe('get', () => {
+    it('should return cached tools', () => {
+      const tools: MCPTool[] = [
+        { name: 'tool1', description: 'Test', inputSchema: { type: 'object' } },
+      ];
+
+      cache.set('server1', tools);
+      const cached = cache.get('server1');
+
+      expect(cached).toEqual(tools);
+    });
+
+    it('should return null for non-existent server', () => {
+      const result = cache.get('non-existent');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null for expired cache entry', () => {
+      const tools: MCPTool[] = [
+        { name: 'tool1', description: 'Test', inputSchema: { type: 'object' } },
+      ];
+
+      cache = new ToolCache({ ttlMs: -1 }); // Already expired
+      cache.set('server1', tools);
+
+      const result = cache.get('server1');
+
+      expect(result).toBeNull();
+    });
+
+    it('should remove expired entry on get', () => {
+      const tools: MCPTool[] = [
+        { name: 'tool1', description: 'Test', inputSchema: { type: 'object' } },
+      ];
+
+      cache = new ToolCache({ ttlMs: -1 });
+      cache.set('server1', tools);
+      cache.get('server1');
+
+      expect(cache.has('server1')).toBe(false);
+    });
+  });
+
+  describe('set', () => {
+    it('should cache tools', () => {
+      const tools: MCPTool[] = [
+        { name: 'tool1', description: 'Test', inputSchema: { type: 'object' } },
+      ];
+
+      cache.set('server1', tools);
+
+      expect(cache.has('server1')).toBe(true);
+    });
+
+    it('should update existing cache entry', () => {
+      const tools1: MCPTool[] = [
+        { name: 'tool1', description: 'Test 1', inputSchema: { type: 'object' } },
+      ];
+      const tools2: MCPTool[] = [
+        { name: 'tool1', description: 'Test 2', inputSchema: { type: 'object' } },
+      ];
+
+      cache.set('server1', tools1);
+      cache.set('server1', tools2);
+
+      expect(cache.get('server1')).toEqual(tools2);
+    });
+
+    it('should evict oldest entry when at capacity', () => {
+      cache = new ToolCache({ maxEntries: 2 });
+
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+      cache.set('server2', [{ name: 'tool2', description: 'Test', inputSchema: { type: "object" } }]);
+      cache.set('server3', [{ name: 'tool3', description: 'Test', inputSchema: { type: "object" } }]);
+
+      expect(cache.has('server1')).toBe(false);
+      expect(cache.has('server2')).toBe(true);
+      expect(cache.has('server3')).toBe(true);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all entries', () => {
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+      cache.set('server2', [{ name: 'tool2', description: 'Test', inputSchema: { type: "object" } }]);
+
+      cache.clear();
+
+      expect(cache.has('server1')).toBe(false);
+      expect(cache.has('server2')).toBe(false);
+      expect(cache.getCachedServers()).toEqual([]);
+    });
+  });
+
+  describe('invalidate', () => {
+    it('should remove specific server entry', () => {
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+
+      const result = cache.invalidate('server1');
+
+      expect(result).toBe(true);
+      expect(cache.has('server1')).toBe(false);
+    });
+
+    it('should return false for non-existent server', () => {
+      const result = cache.invalidate('non-existent');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('has', () => {
+    it('should return true for valid cached entry', () => {
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+
+      expect(cache.has('server1')).toBe(true);
+    });
+
+    it('should return false for non-existent entry', () => {
+      expect(cache.has('non-existent')).toBe(false);
+    });
+
+    it('should return false for expired entry', () => {
+      cache = new ToolCache({ ttlMs: -1 });
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+
+      expect(cache.has('server1')).toBe(false);
+    });
+  });
+
+  describe('getCachedServers', () => {
+    it('should return all cached server names', () => {
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+      cache.set('server2', [{ name: 'tool2', description: 'Test', inputSchema: { type: "object" } }]);
+
+      const servers = cache.getCachedServers();
+
+      expect(servers).toContain('server1');
+      expect(servers).toContain('server2');
+      expect(servers).toHaveLength(2);
+    });
+
+    it('should not include expired servers', () => {
+      cache = new ToolCache({ ttlMs: -1 });
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+
+      expect(cache.getCachedServers()).toEqual([]);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return cache statistics', () => {
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+      cache.set('server2', [{ name: 'tool2', description: 'Test', inputSchema: { type: "object" } }]);
+
+      const stats = cache.getStats();
+
+      expect(stats.size).toBe(2);
+      expect(stats.maxEntries).toBe(100);
+      expect(stats.ttlMs).toBe(300000);
+    });
+
+    it('should return custom configuration', () => {
+      cache = new ToolCache({ maxEntries: 50, ttlMs: 60000 });
+
+      const stats = cache.getStats();
+
+      expect(stats.maxEntries).toBe(50);
+      expect(stats.ttlMs).toBe(60000);
+    });
+  });
+
+  describe('LRU eviction', () => {
+    it('should evict least recently used entry', () => {
+      cache = new ToolCache({ maxEntries: 2 });
+
+      cache.set('server1', [{ name: 'tool1', description: 'Test', inputSchema: { type: "object" } }]);
+      cache.set('server2', [{ name: 'tool2', description: 'Test', inputSchema: { type: "object" } }]);
+      cache.get('server1'); // Access server1 to make it recently used
+      cache.set('server3', [{ name: 'tool3', description: 'Test', inputSchema: { type: "object" } }]);
+
+      expect(cache.has('server1')).toBe(true); // Recently accessed, kept
+      expect(cache.has('server2')).toBe(false); // Least recently used, evicted
+      expect(cache.has('server3')).toBe(true);
+    });
+  });
+});

package/src/mcps/tools/__tests__/tool-discovery.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Tool Discovery Tests
+ *
+ * Comprehensive test suite for the ToolDiscovery class.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ToolDiscovery } from '../tool-discovery.js';
+import { MCPTool, IMcpConnection, JsonRpcResponse } from '../../types/index.js';
+
+describe('ToolDiscovery', () => {
+  let discovery: ToolDiscovery;
+  let mockConnection: any;
+
+  beforeEach(() => {
+    discovery = new ToolDiscovery();
+    mockConnection = {
+      serverName: 'test-server',
+      isConnected: true,
+      connect: vi.fn().mockResolvedValue(undefined),
+      disconnect: vi.fn().mockResolvedValue(undefined),
+      sendRequest: vi.fn() as any,
+    } as any;
+  });
+
+  describe('discoverTools', () => {
+    it('should discover tools from server', async () => {
+      const mockTools: MCPTool[] = [
+        { name: 'tool1', description: 'Test tool 1', inputSchema: { type: 'object' } },
+      ];
+
+      mockConnection.sendRequest.mockResolvedValue({
+        jsonrpc: '2.0',
+        id: 1,
+        result: { tools: mockTools },
+      });
+
+      const tools = await discovery.discoverTools(mockConnection);
+
+      expect(tools).toEqual(mockTools);
+      expect(mockConnection.sendRequest).toHaveBeenCalledWith({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/list',
+      });
+    });
+
+    it('should return empty array when no tools found', async () => {
+      mockConnection.sendRequest.mockResolvedValue({
+        jsonrpc: '2.0',
+        id: 1,
+        result: { tools: [] },
+      });
+
+      const tools = await discovery.discoverTools(mockConnection);
+
+      expect(tools).toEqual([]);
+    });
+
+    it('should throw error when response contains error', async () => {
+      mockConnection.sendRequest.mockResolvedValue({
+        jsonrpc: '2.0',
+        id: 1,
+        error: { code: -32600, message: 'Invalid request' },
+      });
+
+      await expect(discovery.discoverTools(mockConnection)).rejects.toThrow(
+        'Tool discovery failed: Invalid request'
+      );
+    });
+
+    it('should return empty array when result is undefined', async () => {
+      mockConnection.sendRequest.mockResolvedValue({
+        jsonrpc: '2.0',
+        id: 1,
+        result: undefined,
+      });
+
+      const tools = await discovery.discoverTools(mockConnection);
+
+      expect(tools).toEqual([]);
+    });
+  });
+
+  describe('buildToolListRequest', () => {
+    it('should build request with default ID', () => {
+      const request = discovery.buildToolListRequest();
+
+      expect(request).toEqual({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/list',
+      });
+    });
+
+    it('should build request with custom ID', () => {
+      const request = discovery.buildToolListRequest(42);
+
+      expect(request).toEqual({
+        jsonrpc: '2.0',
+        id: 42,
+        method: 'tools/list',
+      });
+    });
+  });
+
+  describe('parseTools', () => {
+    it('should parse tools from response', () => {
+      const mockTools: MCPTool[] = [
+        { name: 'tool1', description: 'Test', inputSchema: { type: 'object' } },
+      ];
+
+      const response: JsonRpcResponse = {
+        jsonrpc: '2.0',
+        id: 1,
+        result: { tools: mockTools },
+      };
+
+      const tools = discovery.parseTools(response);
+
+      expect(tools).toEqual(mockTools);
+    });
+
+    it('should throw error when response has error', () => {
+      const response: JsonRpcResponse = {
+        jsonrpc: '2.0',
+        id: 1,
+        error: { code: -32600, message: 'Parse error' },
+      };
+
+      expect(() => discovery.parseTools(response)).toThrow('Tool discovery failed: Parse error');
+    });
+
+    it('should return empty array when result has no tools', () => {
+      const response: JsonRpcResponse = {
+        jsonrpc: '2.0',
+        id: 1,
+        result: {},
+      };
+
+      const tools = discovery.parseTools(response);
+
+      expect(tools).toEqual([]);
+    });
+  });
+
+  describe('validateTools', () => {
+    it('should validate and return valid tools', () => {
+      const input = [
+        { name: 'tool1', description: 'Test', inputSchema: { type: 'object' } },
+        { name: 'tool2', description: 'Test 2', inputSchema: { type: 'string' } },
+      ];
+
+      const tools = discovery.validateTools(input);
+
+      expect(tools).toHaveLength(2);
+      expect(tools[0].name).toBe('tool1');
+    });
+
+    it('should filter out invalid tools', () => {
+      const input = [
+        { name: 'valid', description: 'Test', inputSchema: { type: 'object' } },
+        { name: 'invalid', description: 'Missing schema' },
+        null,
+        'not an object',
+        { description: 'Missing name', inputSchema: {} },
+      ];
+
+      const tools = discovery.validateTools(input);
+
+      expect(tools).toHaveLength(1);
+      expect(tools[0].name).toBe('valid');
+    });
+
+    it('should return empty array for empty input', () => {
+      const tools = discovery.validateTools([]);
+
+      expect(tools).toEqual([]);
+    });
+
+    it('should handle tool with null inputSchema', () => {
+      const input = [{ name: 'tool', description: 'Test', inputSchema: null }];
+
+      const tools = discovery.validateTools(input);
+
+      expect(tools).toHaveLength(0);
+    });
+  });
+});

package/src/mcps/tools/__tests__/tool-executor.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Tool Executor Tests
+ *
+ * Comprehensive test suite for the ToolExecutor class.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ToolExecutor } from '../tool-executor.js';
+import { IMcpConnection, MCPToolResult, JsonRpcResponse } from '../../types/index.js';
+
+describe('ToolExecutor', () => {
+  let executor: ToolExecutor;
+  let mockConnection: any;
+
+  beforeEach(() => {
+    executor = new ToolExecutor();
+    mockConnection = {
+      serverName: 'test-server',
+      isConnected: true,
+      connect: vi.fn().mockResolvedValue(undefined),
+      disconnect: vi.fn().mockResolvedValue(undefined),
+      sendRequest: vi.fn(),
+    };
+  });
+
+  describe('executeTool', () => {
+    it('should execute tool and return result', async () => {
+      const mockResult: MCPToolResult = {
+        content: [{ type: 'text', text: 'Success' }],
+      };
+
+      mockConnection.sendRequest.mockResolvedValue({
+        jsonrpc: '2.0',
+        id: 1,
+        result: mockResult,
+      });
+
+      const result = await executor.executeTool(mockConnection, 'test-tool', { arg1: 'value1' });
+
+      expect(result).toEqual(mockResult);
+    });
+
+    it('should send correct JSON-RPC request', async () => {
+      mockConnection.sendRequest.mockResolvedValue({
+        jsonrpc: '2.0',
+        id: 1,
+        result: { content: [] },
+      });
+
+      await executor.executeTool(mockConnection, 'my-tool', { foo: 'bar' });
+
+      expect(mockConnection.sendRequest).toHaveBeenCalledWith({
+        jsonrpc: '2.0',
+        id: expect.any(Number),
+        method: 'tools/call',
+        params: {
+          name: 'my-tool',
+          arguments: { foo: 'bar' },
+        },
+      });
+    });
+
+    it('should handle error response', async () => {
+      mockConnection.sendRequest.mockResolvedValue({
+        jsonrpc: '2.0',
+        id: 1,
+        error: { code: -32600, message: 'Tool not found' },
+      });
+
+      const result = await executor.executeTool(mockConnection, 'missing-tool', {});
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toBe('Tool not found');
+    });
+  });
+
+  describe('buildToolCallRequest', () => {
+    it('should build request with auto-incrementing ID', () => {
+      const request1 = executor.buildToolCallRequest('tool1', {});
+      const request2 = executor.buildToolCallRequest('tool2', {});
+
+      expect(request1.id).toBe(1);
+      expect(request2.id).toBe(2);
+    });
+
+    it('should build request with custom ID', () => {
+      const request = executor.buildToolCallRequest('tool1', {}, 42);
+
+      expect(request.id).toBe(42);
+    });
+
+    it('should include correct method and params', () => {
+      const request = executor.buildToolCallRequest('my-tool', { arg: 'value' });
+
+      expect(request).toEqual({
+        jsonrpc: '2.0',
+        id: expect.any(Number),
+        method: 'tools/call',
+        params: {
+          name: 'my-tool',
+          arguments: { arg: 'value' },
+        },
+      });
+    });
+  });
+
+  describe('parseToolResult', () => {
+    it('should parse successful response', () => {
+      const mockResult: MCPToolResult = {
+        content: [{ type: 'text', text: 'Result' }],
+      };
+
+      const response: JsonRpcResponse = {
+        jsonrpc: '2.0',
+        id: 1,
+        result: mockResult,
+      };
+
+      const result = executor.parseToolResult(response);
+
+      expect(result).toEqual(mockResult);
+    });
+
+    it('should parse error response', () => {
+      const response: JsonRpcResponse = {
+        jsonrpc: '2.0',
+        id: 1,
+        error: { code: -32600, message: 'Execution failed' },
+      };
+
+      const result = executor.parseToolResult(response);
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toBe('Execution failed');
+    });
+
+    it('should handle undefined result', () => {
+      const response: JsonRpcResponse = {
+        jsonrpc: '2.0',
+        id: 1,
+        result: undefined,
+      };
+
+      const result = executor.parseToolResult(response);
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toBe('No result returned from tool execution');
+    });
+  });
+
+  describe('executeTools', () => {
+    it('should execute multiple tools in sequence', async () => {
+      mockConnection.sendRequest
+        .mockResolvedValueOnce({
+          jsonrpc: '2.0',
+          id: 1,
+          result: { content: [{ type: 'text', text: 'Result 1' }] },
+        })
+        .mockResolvedValueOnce({
+          jsonrpc: '2.0',
+          id: 2,
+          result: { content: [{ type: 'text', text: 'Result 2' }] },
+        });
+
+      const results = await executor.executeTools(mockConnection, [
+        { toolName: 'tool1', args: {} },
+        { toolName: 'tool2', args: {} },
+      ]);
+
+      expect(results).toHaveLength(2);
+      expect(results[0].content[0].text).toBe('Result 1');
+      expect(results[1].content[0].text).toBe('Result 2');
+    });
+
+    it('should return empty array for empty executions', async () => {
+      const results = await executor.executeTools(mockConnection, []);
+
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe('executeToolsParallel', () => {
+    it('should execute multiple tools in parallel', async () => {
+      mockConnection.sendRequest
+        .mockResolvedValueOnce({
+          jsonrpc: '2.0',
+          id: 1,
+          result: { content: [{ type: 'text', text: 'Result 1' }] },
+        })
+        .mockResolvedValueOnce({
+          jsonrpc: '2.0',
+          id: 2,
+          result: { content: [{ type: 'text', text: 'Result 2' }] },
+        });
+
+      const results = await executor.executeToolsParallel(mockConnection, [
+        { toolName: 'tool1', args: {} },
+        { toolName: 'tool2', args: {} },
+      ]);
+
+      expect(results).toHaveLength(2);
+    });
+  });
+
+  describe('resetRequestId', () => {
+    it('should reset request ID counter', () => {
+      executor.buildToolCallRequest('tool1', {});
+      executor.buildToolCallRequest('tool2', {});
+      executor.resetRequestId();
+      const request = executor.buildToolCallRequest('tool3', {});
+
+      expect(request.id).toBe(1);
+    });
+  });
+});