openapi-directory-mcp/dist/tools/handler.js

Model Context Protocol server for accessing enhanced triple-source OpenAPI directory (APIs.guru + additional APIs + custom imports)

import { toolLoader } from "./loader.js";
import { toMcpTool } from "./types.js";
export class ToolHandler {
    constructor(loader) {
        this.initialized = false;
        this.loader = loader || toolLoader;
        // Initialize tools asynchronously
        this.initializeTools().catch(console.error);
    }
    async initializeTools() {
        await this.loader.loadAllTools();
        this.initialized = true;
    }
    async ensureInitialized() {
        if (!this.initialized) {
            await this.initializeTools();
        }
    }
    /**
     * Handle the tools/list request
     */
    async listTools() {
        await this.ensureInitialized();
        const toolDefinitions = await this.loader.loadAllTools();
        const tools = toolDefinitions.map(toMcpTool);
        return { tools };
    }
    /**
     * Handle the tools/call request
     */
    async callTool(name, args, context) {
        await this.ensureInitialized();
        const tool = await this.loader.getTool(name);
        if (!tool) {
            throw new Error(`Tool not found: ${name}`);
        }
        try {
            const result = await tool.execute(args, context);
            return result;
        }
        catch (error) {
            console.error(`Error executing tool ${name}:`, error);
            throw new Error(`Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
        }
    }
    /**
     * Get all tool names
     */
    async getToolNames() {
        await this.ensureInitialized();
        const tools = await this.loader.loadAllTools();
        return tools.map((tool) => tool.name);
    }
    /**
     * Check if a tool exists
     */
    async hasTool(name) {
        await this.ensureInitialized();
        const tool = await this.loader.getTool(name);
        return tool !== undefined;
    }
    /**
     * Get tool definition by name
     */
    async getToolDefinition(name) {
        await this.ensureInitialized();
        return await this.loader.getTool(name);
    }
    /**
     * Get tools by category
     */
    async getToolsByCategory(categoryName) {
        await this.ensureInitialized();
        return await this.loader.getToolsByCategory(categoryName);
    }
    /**
     * Get all categories
     */
    async getCategories() {
        await this.ensureInitialized();
        const categories = await this.loader.getCategories();
        return categories.map((cat) => cat.name);
    }
    /**
     * Get tool statistics
     */
    async getStats() {
        await this.ensureInitialized();
        const categories = await this.loader.getCategories();
        const categorizedTools = {};
        let totalTools = 0;
        for (const category of categories) {
            categorizedTools[category.name] = category.tools.length;
            totalTools += category.tools.length;
        }
        return {
            totalTools,
            totalCategories: categories.length,
            categorizedTools,
        };
    }
}
//# sourceMappingURL=handler.js.map