feat(mcp): update tools handler

Author: taltultc

src/index.ts

@@ -42,6 +42,7 @@ import {
   formatZodError,
   handleGeneralError,
 } from "./utils/util.js";
+import { executeToolHandler } from "./utils/toolsHandler.js";
 
 import { prompts } from "./utils/prompts.js";
 import {
@@ -121,45 +122,7 @@ function createServer() {
       return createErrorResponse("Unauthorized");
     }
 
-    try {
-      switch (name) {
-        case "get_cloud_incidents":
-          return await handleCloudIncidentsRequest(args, token);
-        case "get_cloud_incident":
-          return await handleCloudIncidentRequest(args, token);
-        case "get_anomalies":
-          return await handleAnomaliesRequest(args, token);
-        case "get_anomaly":
-          return await handleAnomalyRequest(args, token);
-        case "list_reports":
-          return await handleReportsRequest(args, token);
-        case "run_query":
-          return await handleRunQueryRequest(args, token);
-        case "get_report_results":
-          return await handleGetReportResultsRequest(args, token);
-        case "validate_user":
-          return await handleValidateUserRequest(args, token);
-        case "list_dimensions":
-          return await handleDimensionsRequest(args, token);
-        case "get_dimension":
-          return await handleDimensionRequest(args, token);
-        case "list_tickets":
-          return await handleListTicketsRequest(args, token);
-        case "create_ticket":
-          return await handleCreateTicketRequest(args, token);
-        case "list_invoices":
-          return await handleListInvoicesRequest(args, token);
-        case "get_invoice":
-          return await handleGetInvoiceRequest(args, token);
-        default:
-          return createErrorResponse(`Unknown tool: ${name}`);
-      }
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        return createErrorResponse(formatZodError(error));
-      }
-      return handleGeneralError(error, "handling tool request");
-    }
+    return await executeToolHandler(name, args, token);
   });
 
   // Handle initialize method

src/utils/toolsHandler.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import {
+  createErrorResponse,
+  formatZodError,
+  handleGeneralError,
+} from "./util.js";
+
+// Import all tool handlers
+import {
+  handleCloudIncidentsRequest,
+  handleCloudIncidentRequest,
+} from "../tools/cloudIncidents.js";
+import {
+  handleAnomaliesRequest,
+  handleAnomalyRequest,
+} from "../tools/anomalies.js";
+import {
+  handleReportsRequest,
+  handleRunQueryRequest,
+  handleGetReportResultsRequest,
+} from "../tools/reports.js";
+import { handleValidateUserRequest } from "../tools/validateUser.js";
+import { handleDimensionsRequest } from "../tools/dimensions.js";
+import { handleDimensionRequest } from "../tools/dimension.js";
+import {
+  handleListTicketsRequest,
+  handleCreateTicketRequest,
+} from "../tools/tickets.js";
+import {
+  handleListInvoicesRequest,
+  handleGetInvoiceRequest,
+} from "../tools/invoices.js";
+
+/**
+ * Executes a tool handler with proper error handling
+ * @param toolName - The name of the tool to execute
+ * @param args - The arguments to pass to the tool handler
+ * @param token - The API token to use
+ * @param convertResponse - Optional function to convert the response format
+ * @returns The tool execution result
+ */
+export async function executeToolHandler(
+  toolName: string,
+  args: any,
+  token: string,
+  convertResponse?: (response: any) => any
+): Promise<any> {
+  try {
+    let result: any;
+
+    switch (toolName) {
+      case "get_cloud_incidents":
+        result = await handleCloudIncidentsRequest(args, token);
+        break;
+      case "get_cloud_incident":
+        result = await handleCloudIncidentRequest(args, token);
+        break;
+      case "get_anomalies":
+        result = await handleAnomaliesRequest(args, token);
+        break;
+      case "get_anomaly":
+        result = await handleAnomalyRequest(args, token);
+        break;
+      case "list_reports":
+        result = await handleReportsRequest(args, token);
+        break;
+      case "run_query":
+        result = await handleRunQueryRequest(args, token);
+        break;
+      case "get_report_results":
+        result = await handleGetReportResultsRequest(args, token);
+        break;
+      case "validate_user":
+        result = await handleValidateUserRequest(args, token);
+        break;
+      case "list_dimensions":
+        result = await handleDimensionsRequest(args, token);
+        break;
+      case "get_dimension":
+        result = await handleDimensionRequest(args, token);
+        break;
+      case "list_tickets":
+        result = await handleListTicketsRequest(args, token);
+        break;
+      case "create_ticket":
+        result = await handleCreateTicketRequest(args, token);
+        break;
+      case "list_invoices":
+        result = await handleListInvoicesRequest(args, token);
+        break;
+      case "get_invoice":
+        result = await handleGetInvoiceRequest(args, token);
+        break;
+      default:
+        return createErrorResponse(`Unknown tool: ${toolName}`);
+    }
+
+    // Apply response conversion if provided
+    return convertResponse ? convertResponse(result) : result;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorResult = createErrorResponse(formatZodError(error));
+      return convertResponse ? convertResponse(errorResult) : errorResult;
+    }
+    const errorResult = handleGeneralError(error, "handling tool request");
+    return convertResponse ? convertResponse(errorResult) : errorResult;
+  }
+}