@gguf/coder 0.3.0 → 0.3.1

package/source/tools/tool-manager.ts

@@ -0,0 +1,210 @@
+import {MCPClient} from '@/mcp/mcp-client';
+import {
+	nativeToolsRegistry as staticNativeToolsRegistry,
+	toolFormatters as staticToolFormatters,
+	toolRegistry as staticToolRegistry,
+	toolValidators as staticToolValidators,
+} from '@/tools/index';
+import {ToolRegistry} from '@/tools/tool-registry';
+import type {
+	AISDKCoreTool,
+	MCPInitResult,
+	MCPServer,
+	MCPTool,
+	ToolEntry,
+	ToolFormatter,
+	ToolHandler,
+	ToolValidator,
+} from '@/types/index';
+
+/**
+ * Manages both static tools and dynamic MCP tools
+ * All tools are stored in unified ToolEntry format via ToolRegistry
+ */
+export class ToolManager {
+	/**
+	 * Unified tool registry using ToolRegistry helper class
+	 */
+	private registry: ToolRegistry;
+
+	/**
+	 * MCP client for dynamic tool discovery and execution
+	 */
+	private mcpClient: MCPClient | null = null;
+
+	constructor() {
+		// Initialize with static tools using ToolRegistry factory method
+		this.registry = ToolRegistry.fromRegistries(
+			staticToolRegistry,
+			staticNativeToolsRegistry,
+			staticToolFormatters,
+			staticToolValidators,
+		);
+	}
+
+	/**
+	 * Initialize MCP servers and register their tools
+	 */
+	async initializeMCP(
+		servers: MCPServer[],
+		onProgress?: (result: MCPInitResult) => void,
+	): Promise<MCPInitResult[]> {
+		if (servers && servers.length > 0) {
+			this.mcpClient = new MCPClient();
+
+			const results = await this.mcpClient.connectToServers(
+				servers,
+				onProgress,
+			);
+
+			// Register MCP tools using ToolRegistry
+			// getToolEntries() returns structured ToolEntry objects
+			const mcpToolEntries = this.mcpClient.getToolEntries();
+			this.registry.registerMany(mcpToolEntries);
+
+			return results;
+		}
+		return [];
+	}
+
+	/**
+	 * Get all available native AI SDK tools (static + MCP)
+	 */
+	getAllTools(): Record<string, AISDKCoreTool> {
+		return this.registry.getNativeTools();
+	}
+
+	/**
+	 * Get all tool handlers
+	 */
+	getToolRegistry(): Record<string, ToolHandler> {
+		return this.registry.getHandlers();
+	}
+
+	/**
+	 * Get a specific tool handler
+	 */
+	getToolHandler(toolName: string): ToolHandler | undefined {
+		return this.registry.getHandler(toolName);
+	}
+
+	/**
+	 * Get a specific tool formatter
+	 */
+	getToolFormatter(toolName: string): ToolFormatter | undefined {
+		return this.registry.getFormatter(toolName);
+	}
+
+	/**
+	 * Get a specific tool validator
+	 */
+	getToolValidator(toolName: string): ToolValidator | undefined {
+		return this.registry.getValidator(toolName);
+	}
+
+	/**
+	 * Check if a tool exists
+	 */
+	hasTool(toolName: string): boolean {
+		return this.registry.hasTool(toolName);
+	}
+
+	/**
+	 * Check if a tool is an MCP tool and get server info
+	 */
+	getMCPToolInfo(toolName: string): {isMCPTool: boolean; serverName?: string} {
+		if (!this.mcpClient) {
+			return {isMCPTool: false};
+		}
+
+		const toolMapping = this.mcpClient.getToolMapping();
+		const mapping = toolMapping.get(toolName);
+
+		if (mapping) {
+			return {
+				isMCPTool: true,
+				serverName: mapping.serverName,
+			};
+		}
+
+		return {isMCPTool: false};
+	}
+
+	/**
+	 * Disconnect from MCP servers and remove their tools
+	 */
+	async disconnectMCP(): Promise<void> {
+		if (this.mcpClient) {
+			// Get list of MCP tool names
+			const mcpTools = this.mcpClient.getNativeToolsRegistry();
+			const mcpToolNames = Object.keys(mcpTools);
+
+			// Remove all MCP tools from registry in one operation
+			this.registry.unregisterMany(mcpToolNames);
+
+			// Disconnect from servers
+			await this.mcpClient.disconnect();
+
+			// Reset registry to only static tools
+			this.registry = ToolRegistry.fromRegistries(
+				staticToolRegistry,
+				staticNativeToolsRegistry,
+				staticToolFormatters,
+				staticToolValidators,
+			);
+
+			this.mcpClient = null;
+		}
+	}
+
+	/**
+	 * Get a complete tool entry (all metadata)
+	 *
+	 * Returns the full ToolEntry with all components (tool, handler, formatter, validator)
+	 */
+	getToolEntry(toolName: string): ToolEntry | undefined {
+		return this.registry.getEntry(toolName);
+	}
+
+	/**
+	 * Get all registered tool names
+	 */
+	getToolNames(): string[] {
+		return this.registry.getToolNames();
+	}
+
+	/**
+	 * Get total number of registered tools
+	 */
+	getToolCount(): number {
+		return this.registry.getToolCount();
+	}
+
+	/**
+	 * Get connected MCP servers
+	 */
+	getConnectedServers(): string[] {
+		return this.mcpClient?.getConnectedServers() || [];
+	}
+
+	/**
+	 * Get tools for a specific MCP server
+	 */
+	getServerTools(serverName: string): MCPTool[] {
+		return this.mcpClient?.getServerTools(serverName) || [];
+	}
+
+	/**
+	 * Get server information including transport type and URL
+	 */
+	getServerInfo(serverName: string) {
+		return this.mcpClient?.getServerInfo(serverName);
+	}
+
+	/**
+	 * Get the MCP client instance
+	 */
+	getMCPClient() {
+		return this.mcpClient;
+	}
+}

package/source/tools/tool-registry.spec.ts

@@ -0,0 +1,415 @@
+import test from 'ava';
+import { ToolRegistry } from './tool-registry';
+import type { ToolEntry } from '@/types/index';
+
+// Mock tool handler function - returns Promise<string>
+const mockHandler: ToolEntry['handler'] = async () => 'test result';
+
+// Mock formatter function
+const mockFormatter: ToolEntry['formatter'] = (output: unknown) => {
+	return String(output);
+};
+
+// Mock validator function - returns Promise<{valid: true} | {valid: false, error: string}>
+const mockValidator: ToolEntry['validator'] = async () => ({ valid: true });
+
+// Mock AI SDK tool - cast to any since we're just testing registry functionality
+const mockTool: ToolEntry['tool'] = {
+	execute: async () => 'test result',
+} as any;
+
+function createMockToolEntry(overrides: Partial<ToolEntry> = {}): ToolEntry {
+	return {
+		name: 'test-tool',
+		handler: mockHandler,
+		tool: mockTool,
+		formatter: mockFormatter,
+		validator: mockValidator,
+		...overrides
+	} as ToolEntry;
+}
+
+test('ToolRegistry - register adds a tool entry', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry();
+
+	registry.register(entry);
+
+	t.true(registry.hasTool('test-tool'));
+	t.is(registry.getToolCount(), 1);
+});
+
+test('ToolRegistry - registerMany adds multiple tools', t => {
+	const registry = new ToolRegistry();
+	const entries = [
+		createMockToolEntry({ name: 'tool1' }),
+		createMockToolEntry({ name: 'tool2' }),
+		createMockToolEntry({ name: 'tool3' })
+	];
+
+	registry.registerMany(entries);
+
+	t.is(registry.getToolCount(), 3);
+	t.true(registry.hasTool('tool1'));
+	t.true(registry.hasTool('tool2'));
+	t.true(registry.hasTool('tool3'));
+});
+
+test('ToolRegistry - registerMany with empty array', t => {
+	const registry = new ToolRegistry();
+
+	registry.registerMany([]);
+
+	t.is(registry.getToolCount(), 0);
+});
+
+test('ToolRegistry - unregister removes a tool', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry();
+
+	registry.register(entry);
+	t.true(registry.hasTool('test-tool'));
+
+	registry.unregister('test-tool');
+	t.false(registry.hasTool('test-tool'));
+});
+
+test('ToolRegistry - unregisterMany removes multiple tools', t => {
+	const registry = new ToolRegistry();
+	registry.registerMany([
+		createMockToolEntry({ name: 'tool1' }),
+		createMockToolEntry({ name: 'tool2' }),
+		createMockToolEntry({ name: 'tool3' })
+	]);
+
+	registry.unregisterMany(['tool1', 'tool3']);
+
+	t.false(registry.hasTool('tool1'));
+	t.true(registry.hasTool('tool2'));
+	t.false(registry.hasTool('tool3'));
+});
+
+test('ToolRegistry - unregisterMany with empty array', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry();
+
+	registry.register(entry);
+	registry.unregisterMany([]);
+
+	t.true(registry.hasTool('test-tool'));
+});
+
+test('ToolRegistry - getEntry returns tool entry', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry();
+
+	registry.register(entry);
+	const retrieved = registry.getEntry('test-tool');
+
+	t.truthy(retrieved);
+	t.is(retrieved?.name, 'test-tool');
+});
+
+test('ToolRegistry - getEntry returns undefined for non-existent tool', t => {
+	const registry = new ToolRegistry();
+
+	const retrieved = registry.getEntry('non-existent');
+
+	t.is(retrieved, undefined);
+});
+
+test('ToolRegistry - getHandler returns tool handler', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry();
+
+	registry.register(entry);
+	const handler = registry.getHandler('test-tool');
+
+	t.truthy(handler);
+	t.is(handler, mockHandler);
+});
+
+test('ToolRegistry - getHandler returns undefined for non-existent tool', t => {
+	const registry = new ToolRegistry();
+
+	const handler = registry.getHandler('non-existent');
+
+	t.is(handler, undefined);
+});
+
+test('ToolRegistry - getFormatter returns tool formatter', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry();
+
+	registry.register(entry);
+	const formatter = registry.getFormatter('test-tool');
+
+	t.truthy(formatter);
+	t.is(formatter, mockFormatter);
+});
+
+test('ToolRegistry - getFormatter returns undefined when no formatter', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry({ formatter: undefined });
+
+	registry.register(entry);
+	const formatter = registry.getFormatter('test-tool');
+
+	t.is(formatter, undefined);
+});
+
+test('ToolRegistry - getValidator returns tool validator', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry();
+
+	registry.register(entry);
+	const validator = registry.getValidator('test-tool');
+
+	t.truthy(validator);
+	t.is(validator, mockValidator);
+});
+
+test('ToolRegistry - getValidator returns undefined when no validator', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry({ validator: undefined });
+
+	registry.register(entry);
+	const validator = registry.getValidator('test-tool');
+
+	t.is(validator, undefined);
+});
+
+test('ToolRegistry - getTool returns native AI SDK tool', t => {
+	const registry = new ToolRegistry();
+	const entry = createMockToolEntry();
+
+	registry.register(entry);
+	const tool = registry.getTool('test-tool');
+
+	t.truthy(tool);
+	t.is(tool, mockTool);
+});
+
+test('ToolRegistry - getTool returns undefined for non-existent tool', t => {
+	const registry = new ToolRegistry();
+
+	const tool = registry.getTool('non-existent');
+
+	t.is(tool, undefined);
+});
+
+test('ToolRegistry - getHandlers returns record of all handlers', t => {
+	const registry = new ToolRegistry();
+	const handler1: ToolEntry['handler'] = async () => 'result 1';
+	const handler2: ToolEntry['handler'] = async () => 'result 2';
+
+	registry.registerMany([
+		createMockToolEntry({ name: 'tool1', handler: handler1 }),
+		createMockToolEntry({ name: 'tool2', handler: handler2 })
+	]);
+
+	const handlers = registry.getHandlers();
+
+	t.is(handlers.tool1, handler1);
+	t.is(handlers.tool2, handler2);
+});
+
+test('ToolRegistry - getHandlers returns empty object when no tools', t => {
+	const registry = new ToolRegistry();
+
+	const handlers = registry.getHandlers();
+
+	t.deepEqual(handlers, {});
+});
+
+test('ToolRegistry - getFormatters returns record of formatters', t => {
+	const registry = new ToolRegistry();
+	const formatter1: ToolEntry['formatter'] = (o) => String(o);
+	const formatter2: ToolEntry['formatter'] = (o) => String(o);
+
+	registry.registerMany([
+		createMockToolEntry({ name: 'tool1', formatter: formatter1 }),
+		createMockToolEntry({ name: 'tool2', formatter: formatter2 }),
+		createMockToolEntry({ name: 'tool3', formatter: undefined })
+	]);
+
+	const formatters = registry.getFormatters();
+
+	t.is(formatters.tool1, formatter1);
+	t.is(formatters.tool2, formatter2);
+	// tool3 has no formatter, so it shouldn't be in the record
+	t.false('tool3' in formatters);
+});
+
+test('ToolRegistry - getValidators returns record of validators', t => {
+	const registry = new ToolRegistry();
+	const validator1: ToolEntry['validator'] = async () => ({ valid: true });
+	const validator2: ToolEntry['validator'] = async () => ({ valid: false, error: 'test error' });
+
+	registry.registerMany([
+		createMockToolEntry({ name: 'tool1', validator: validator1 }),
+		createMockToolEntry({ name: 'tool2', validator: validator2 }),
+		createMockToolEntry({ name: 'tool3', validator: undefined })
+	]);
+
+	const validators = registry.getValidators();
+
+	t.is(validators.tool1, validator1);
+	t.is(validators.tool2, validator2);
+	// tool3 has no validator, so it shouldn't be in the record
+	t.false('tool3' in validators);
+});
+
+test('ToolRegistry - getNativeTools returns record of native tools', t => {
+	const registry = new ToolRegistry();
+	const tool1: ToolEntry['tool'] = { execute: async () => 'test 1' } as any;
+	const tool2: ToolEntry['tool'] = { execute: async () => 'test 2' } as any;
+
+	registry.registerMany([
+		createMockToolEntry({ name: 'tool1', tool: tool1 }),
+		createMockToolEntry({ name: 'tool2', tool: tool2 })
+	]);
+
+	const nativeTools = registry.getNativeTools();
+
+	t.is(nativeTools.tool1, tool1);
+	t.is(nativeTools.tool2, tool2);
+});
+
+test('ToolRegistry - getAllEntries returns array of all entries', t => {
+	const registry = new ToolRegistry();
+	const entry1 = createMockToolEntry({ name: 'tool1' });
+	const entry2 = createMockToolEntry({ name: 'tool2' });
+
+	registry.registerMany([entry1, entry2]);
+
+	const entries = registry.getAllEntries();
+
+	t.is(entries.length, 2);
+	t.true(entries.some(e => e.name === 'tool1'));
+	t.true(entries.some(e => e.name === 'tool2'));
+});
+
+test('ToolRegistry - getAllEntries returns empty array when no tools', t => {
+	const registry = new ToolRegistry();
+
+	const entries = registry.getAllEntries();
+
+	t.deepEqual(entries, []);
+});
+
+test('ToolRegistry - getToolNames returns array of tool names', t => {
+	const registry = new ToolRegistry();
+	registry.registerMany([
+		createMockToolEntry({ name: 'tool1' }),
+		createMockToolEntry({ name: 'tool2' }),
+		createMockToolEntry({ name: 'tool3' })
+	]);
+
+	const names = registry.getToolNames();
+
+	t.is(names.length, 3);
+	t.true(names.includes('tool1'));
+	t.true(names.includes('tool2'));
+	t.true(names.includes('tool3'));
+});
+
+test('ToolRegistry - getToolNames returns empty array when no tools', t => {
+	const registry = new ToolRegistry();
+
+	const names = registry.getToolNames();
+
+	t.deepEqual(names, []);
+});
+
+test('ToolRegistry - hasTool returns true for registered tool', t => {
+	const registry = new ToolRegistry();
+	registry.register(createMockToolEntry());
+
+	t.true(registry.hasTool('test-tool'));
+});
+
+test('ToolRegistry - hasTool returns false for non-existent tool', t => {
+	const registry = new ToolRegistry();
+
+	t.false(registry.hasTool('non-existent'));
+});
+
+test('ToolRegistry - getToolCount returns correct count', t => {
+	const registry = new ToolRegistry();
+
+	t.is(registry.getToolCount(), 0);
+
+	registry.register(createMockToolEntry());
+	t.is(registry.getToolCount(), 1);
+
+	registry.registerMany([
+		createMockToolEntry({ name: 'tool1' }),
+		createMockToolEntry({ name: 'tool2' })
+	]);
+	t.is(registry.getToolCount(), 3);
+});
+
+test('ToolRegistry - clear removes all tools', t => {
+	const registry = new ToolRegistry();
+	registry.registerMany([
+		createMockToolEntry({ name: 'tool1' }),
+		createMockToolEntry({ name: 'tool2' }),
+		createMockToolEntry({ name: 'tool3' })
+	]);
+
+	registry.clear();
+
+	t.is(registry.getToolCount(), 0);
+	t.false(registry.hasTool('tool1'));
+	t.false(registry.hasTool('tool2'));
+	t.false(registry.hasTool('tool3'));
+});
+
+test('ToolRegistry - fromRegistries creates registry from records', t => {
+	const handler1: ToolEntry['handler'] = async () => 'test';
+	const handler2: ToolEntry['handler'] = async () => 'test';
+	const formatter1: ToolEntry['formatter'] = (o) => String(o);
+	const validator1: ToolEntry['validator'] = async () => ({ valid: true });
+	const tool1: ToolEntry['tool'] = { execute: async () => 'test' } as any;
+	const tool2: ToolEntry['tool'] = { execute: async () => 'test' } as any;
+
+	const handlers = { tool1: handler1, tool2: handler2 };
+	const tools = { tool1, tool2 };
+	const formatters = { tool1: formatter1 };
+	const validators = { tool1: validator1 };
+
+	const registry = ToolRegistry.fromRegistries(handlers, tools, formatters, validators);
+
+	t.is(registry.getToolCount(), 2);
+	t.true(registry.hasTool('tool1'));
+	t.true(registry.hasTool('tool2'));
+	t.is(registry.getHandler('tool1'), handler1);
+	t.is(registry.getFormatter('tool1'), formatter1);
+	t.is(registry.getValidator('tool1'), validator1);
+});
+
+test('ToolRegistry - fromRegistries with optional parameters', t => {
+	const handler: ToolEntry['handler'] = async () => 'test';
+	const tool: ToolEntry['tool'] = { execute: async () => 'test' } as any;
+
+	const registry = ToolRegistry.fromRegistries({ tool1: handler }, { tool1: tool });
+
+	t.is(registry.getToolCount(), 1);
+	t.is(registry.getFormatter('tool1'), undefined);
+	t.is(registry.getValidator('tool1'), undefined);
+});
+
+test('ToolRegistry - fromRegistries skips tools without matching handlers', t => {
+	const handler: ToolEntry['handler'] = async () => 'test';
+	const tool: ToolEntry['tool'] = { execute: async () => 'test' } as any;
+
+	const registry = ToolRegistry.fromRegistries(
+		{ tool1: handler }, // Only has handler for tool1
+		{ tool1: tool, tool2: tool } // But tools for tool1 and tool2
+	);
+
+	t.is(registry.getToolCount(), 1);
+	t.true(registry.hasTool('tool1'));
+	t.false(registry.hasTool('tool2'));
+});