@juspay/neurolink 7.14.2 → 7.14.4

package/dist/mcp/factory.d.ts

@@ -3,7 +3,6 @@
  * Factory-First Architecture: MCP servers create tools for internal orchestration
  * Compatible with MCP patterns for seamless integration
  */
-import { z } from "zod";
 import type { ExecutionContext } from "./contracts/mcpContract.js";
 /**
  * MCP Server Categories for organization and discovery
@@ -71,19 +70,64 @@ export interface ToolResult {
     };
 }
 /**
- * MCP Tool Interface - Standard compatible with NeuroLink enhancements
+ * MCP Tool Interface - Standalone definition to avoid confusion with ToolDefinition execute signature
+ */
+/**
+ * NeuroLink MCP Tool Interface - Standardized tool definition for MCP integration
+ *
+ * This interface defines the contract for all tools in the NeuroLink ecosystem,
+ * ensuring consistent execution patterns and metadata handling across different
+ * MCP servers and tool implementations.
+ *
+ * Key features:
+ * - Promise-based execution with ToolResult return type
+ * - Rich context support for session management and permissions
+ * - Optional schema validation for input/output
+ * - Comprehensive metadata support for tool discovery
+ *
+ * @example
+ * ```typescript
+ * const calculatorTool: NeuroLinkMCPTool = {
+ *   name: "calculator",
+ *   description: "Performs basic arithmetic operations",
+ *   category: "math",
+ *   inputSchema: z.object({ a: z.number(), b: z.number(), op: z.string() }),
+ *   async execute(params, context) {
+ *     const { a, b, op } = params as { a: number; b: number; op: string };
+ *     const result = op === "add" ? a + b : a - b;
+ *     return { success: true, data: result };
+ *   }
+ * };
+ * ```
  */
 export interface NeuroLinkMCPTool {
+    /** Unique tool identifier for MCP registration and execution */
     name: string;
+    /** Human-readable description of tool functionality */
     description: string;
-    execute: (params: unknown, context: NeuroLinkExecutionContext) => Promise<ToolResult>;
-    inputSchema?: z.ZodSchema;
-    outputSchema?: z.ZodSchema;
-    isImplemented?: boolean;
+    /** Optional category for tool organization and discovery */
     category?: string;
+    /** Optional input schema for parameter validation (Zod or JSON Schema) */
+    inputSchema?: unknown;
+    /** Optional output schema for result validation */
+    outputSchema?: unknown;
+    /** Implementation status flag for development tracking */
+    isImplemented?: boolean;
+    /** Required permissions for tool execution in secured environments */
     permissions?: string[];
+    /** Tool version for compatibility and update management */
     version?: string;
+    /** Additional metadata for tool information and capabilities */
     metadata?: Record<string, unknown>;
+    /**
+     * Tool execution function with standardized signature
+     *
+     * @param params - Input parameters for the tool (validated against inputSchema if provided)
+     * @param context - Execution context with session, user, and environment information
+     * @returns Promise resolving to ToolResult with success status, data, and metadata
+     * @throws ValidationError if parameters fail validation
+     */
+    execute: (params: unknown, context: NeuroLinkExecutionContext) => Promise<ToolResult>;
 }
 /**
  * MCP Server Interface - Standard compatible
@@ -145,7 +189,8 @@ export interface MCPServerConfig {
  */
 export declare function createMCPServer(config: MCPServerConfig): NeuroLinkMCPServer;
 /**
- * Utility function to validate tool interface
+ * Utility function to validate tool interface using centralized validation
+ * Ensures proper async patterns and type safety
  */
 export declare function validateTool(tool: NeuroLinkMCPTool): boolean;
 /**
@@ -159,3 +204,12 @@ export declare function getServerInfo(server: NeuroLinkMCPServer): {
     toolCount: number;
     capabilities: string[];
 };
+/**
+ * Async utility function to validate all tools in a server
+ * Ensures all registered tools follow proper async patterns
+ */
+export declare function validateServerTools(server: NeuroLinkMCPServer): Promise<{
+    isValid: boolean;
+    invalidTools: string[];
+    errors: string[];
+}>;

package/dist/mcp/factory.js

@@ -4,6 +4,7 @@
  * Compatible with MCP patterns for seamless integration
  */
 import { z } from "zod";
+import { validateMCPTool, ValidationError, createValidationSummary, } from "../utils/parameterValidation.js";
 /**
  * Input validation schemas
  */
@@ -27,7 +28,7 @@ const ServerConfigSchema = z.object({
     ])
         .optional(),
     visibility: z.enum(["public", "private", "organization"]).optional(),
-    metadata: z.record(z.any()).optional(),
+    metadata: z.record(z.unknown()).optional(),
     dependencies: z.array(z.string()).optional(),
     capabilities: z.array(z.string()).optional(),
 });
@@ -76,9 +77,11 @@ export function createMCPServer(config) {
         tools: {},
         // Tool registration method
         registerTool(tool) {
-            // Validate tool has required fields
-            if (!tool.name || !tool.description || !tool.execute) {
-                throw new Error(`Invalid tool: name, description, and execute are required`);
+            // Comprehensive tool validation using centralized utilities
+            const validation = validateMCPTool(tool);
+            if (!validation.isValid) {
+                const summary = createValidationSummary(validation);
+                throw new ValidationError(`Invalid tool '${tool.name}': ${summary}`, "tool", "VALIDATION_FAILED", validation.suggestions);
             }
             // Check for duplicate tool names
             if (this.tools[tool.name]) {
@@ -105,28 +108,13 @@ export function createMCPServer(config) {
     return server;
 }
 /**
- * Utility function to validate tool interface
+ * Utility function to validate tool interface using centralized validation
+ * Ensures proper async patterns and type safety
  */
 export function validateTool(tool) {
     try {
-        // Check required fields
-        if (!tool.name || typeof tool.name !== "string") {
-            return false;
-        }
-        if (!tool.description || typeof tool.description !== "string") {
-            return false;
-        }
-        if (!tool.execute || typeof tool.execute !== "function") {
-            return false;
-        }
-        // Validate optional schemas if present
-        if (tool.inputSchema && !(tool.inputSchema instanceof z.ZodSchema)) {
-            return false;
-        }
-        if (tool.outputSchema && !(tool.outputSchema instanceof z.ZodSchema)) {
-            return false;
-        }
-        return true;
+        const validation = validateMCPTool(tool);
+        return validation.isValid;
     }
     catch (error) {
         return false;
@@ -145,4 +133,29 @@ export function getServerInfo(server) {
         capabilities: server.capabilities || [],
     };
 }
+/**
+ * Async utility function to validate all tools in a server
+ * Ensures all registered tools follow proper async patterns
+ */
+export async function validateServerTools(server) {
+    const invalidTools = [];
+    const errors = [];
+    for (const [toolName, tool] of Object.entries(server.tools)) {
+        try {
+            if (!validateTool(tool)) {
+                invalidTools.push(toolName);
+                errors.push(`Tool '${toolName}' does not follow proper async patterns`);
+            }
+        }
+        catch (error) {
+            invalidTools.push(toolName);
+            errors.push(`Tool '${toolName}' validation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        isValid: invalidTools.length === 0,
+        invalidTools,
+        errors,
+    };
+}
 // Types are already exported above via export interface declarations

package/dist/mcp/mcpClientFactory.d.ts

@@ -72,7 +72,8 @@ export declare class MCPClientFactory {
      */
     private static extractCapabilities;
     /**
-     * Create a timeout promise
+     * Create a timeout promise with AbortController support
+     * Provides consistent async timeout patterns across the factory
      */
     private static createTimeoutPromise;
     /**

package/dist/mcp/mcpClientFactory.js

@@ -9,7 +9,7 @@ import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
 import { spawn } from "child_process";
 import { mcpLogger } from "../utils/logger.js";
-import { globalCircuitBreakerManager, } from "./mcpCircuitBreaker.js";
+import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports
@@ -73,7 +73,11 @@ export class MCPClientFactory {
      */
     static async createClientInternal(config, timeout) {
         // Create transport
-        const { transport, process } = await this.createTransport(config);
+        const transportResult = await this.createTransport(config);
+        // Extract transport and process with necessary type assertions
+        // Note: Type assertions required due to TransportResult using 'unknown' to avoid circular imports
+        const transport = transportResult.transport;
+        const process = transportResult.process;
         try {
             // Create client
             const client = new Client(this.NEUROLINK_IMPLEMENTATION, {
@@ -140,10 +144,12 @@ export class MCPClientFactory {
         // Spawn the process
         const childProcess = spawn(config.command, config.args || [], {
             stdio: ["pipe", "pipe", "pipe"],
-            env: {
+            env: Object.fromEntries(Object.entries({
                 ...process.env,
                 ...config.env,
-            },
+            })
+                .filter(([, value]) => value !== undefined)
+                .map(([k, v]) => [k, String(v)])),
             cwd: config.cwd,
         });
         // Handle process errors
@@ -157,14 +163,32 @@ export class MCPClientFactory {
                 }
             });
         });
-        // Wait for process to be ready or fail
-        await Promise.race([
-            new Promise((resolve) => setTimeout(resolve, 1000)), // Give process time to start
-            processErrorPromise,
-        ]);
+        // Wait for process to be ready or fail using AbortController for better async patterns
+        const processStartupController = new AbortController();
+        const processStartupTimeout = setTimeout(() => {
+            processStartupController.abort();
+        }, 1000);
+        try {
+            await Promise.race([
+                new Promise((resolve) => {
+                    const checkReady = () => {
+                        if (processStartupController.signal.aborted) {
+                            resolve(); // Timeout reached, continue
+                        }
+                        else {
+                            setTimeout(checkReady, 100);
+                        }
+                    };
+                    checkReady();
+                }),
+                processErrorPromise,
+            ]);
+        }
+        finally {
+            clearTimeout(processStartupTimeout);
+        }
         // Check if process is still running
-        if (childProcess.killed ||
-            childProcess.exitCode !== null) {
+        if (childProcess.killed || childProcess.exitCode !== null) {
             throw new Error("Process failed to start or exited immediately");
         }
         // Create transport
@@ -174,7 +198,9 @@ export class MCPClientFactory {
             env: Object.fromEntries(Object.entries({
                 ...process.env,
                 ...config.env,
-            }).filter(([, value]) => value !== undefined)),
+            })
+                .filter(([, value]) => value !== undefined)
+                .map(([key, value]) => [key, String(value)])),
             cwd: config.cwd,
         });
         return { transport, process: childProcess };
@@ -250,7 +276,7 @@ export class MCPClientFactory {
                 capabilities: this.DEFAULT_CAPABILITIES,
             };
         }
-        catch (error) {
+        catch {
             // If listing tools fails, try a simpler ping
             mcpLogger.debug("[MCPClientFactory] Tool listing failed, server may not support tools yet");
             return {
@@ -267,17 +293,25 @@ export class MCPClientFactory {
         // This can be enhanced when MCP servers provide more detailed capability info
         return {
             ...this.DEFAULT_CAPABILITIES,
-            tools: serverInfo.tools ? {} : undefined,
+            ...(serverInfo.tools ? { tools: {} } : {}),
         };
     }
     /**
-     * Create a timeout promise
+     * Create a timeout promise with AbortController support
+     * Provides consistent async timeout patterns across the factory
      */
-    static createTimeoutPromise(timeout, message) {
+    static createTimeoutPromise(timeout, message, abortSignal) {
         return new Promise((_, reject) => {
-            setTimeout(() => {
+            const timeoutId = setTimeout(() => {
                 reject(new Error(message));
             }, timeout);
+            // Support abortion for better async cleanup
+            if (abortSignal) {
+                abortSignal.addEventListener("abort", () => {
+                    clearTimeout(timeoutId);
+                    reject(new Error(`Operation aborted: ${message}`));
+                });
+            }
         });
     }
     /**
@@ -299,17 +333,30 @@ export class MCPClientFactory {
         catch (error) {
             errors.push(`Transport close error: ${error instanceof Error ? error.message : String(error)}`);
         }
-        // Kill process if exists
+        // Kill process if exists with proper async cleanup
         if (process && !process.killed) {
             try {
                 process.kill("SIGTERM");
-                // Force kill after 5 seconds
-                setTimeout(() => {
-                    if (!process.killed) {
-                        mcpLogger.warn("[MCPClientFactory] Force killing process");
-                        process.kill("SIGKILL");
-                    }
-                }, 5000);
+                // Use Promise-based approach for force kill timeout
+                await new Promise((resolve) => {
+                    const forceKillTimeout = setTimeout(() => {
+                        if (!process.killed) {
+                            mcpLogger.warn("[MCPClientFactory] Force killing process");
+                            try {
+                                process.kill("SIGKILL");
+                            }
+                            catch (killError) {
+                                mcpLogger.debug("[MCPClientFactory] Error in force kill:", killError);
+                            }
+                        }
+                        resolve();
+                    }, 5000);
+                    // If process exits gracefully before timeout, clear the force kill
+                    process.on("exit", () => {
+                        clearTimeout(forceKillTimeout);
+                        resolve();
+                    });
+                });
             }
             catch (error) {
                 errors.push(`Process kill error: ${error instanceof Error ? error.message : String(error)}`);
@@ -339,7 +386,7 @@ export class MCPClientFactory {
                 try {
                     await client.listTools();
                 }
-                catch (error) {
+                catch {
                     // Tool listing failure doesn't necessarily mean connection failure
                     mcpLogger.debug("[MCPClientFactory] Tool listing failed during test, but connection may be valid");
                 }

package/dist/mcp/registry.d.ts

@@ -16,7 +16,7 @@ export interface McpRegistry {
  * Maintains backward compatibility with existing code
  */
 export declare class MCPRegistry implements McpRegistry {
-    plugins: Map<string, DiscoveredMcp<Record<string, unknown>>>;
+    plugins: Map<string, DiscoveredMcp<import("../types/typeAliases.js").StandardRecord>>;
     /**
      * Register a plugin
      */

package/dist/mcp/toolDiscoveryService.d.ts

@@ -144,7 +144,7 @@ export declare class ToolDiscoveryService extends EventEmitter {
      */
     private validateParameterType;
     /**
-     * Validate tool output
+     * Validate tool output with enhanced type safety
      */
     private validateToolOutput;
     /**

package/dist/mcp/toolDiscoveryService.js

@@ -5,7 +5,9 @@
  */
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
-import { globalCircuitBreakerManager, } from "./mcpCircuitBreaker.js";
+import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
+import { isObject, isString, isBoolean, isNullish, } from "../utils/typeUtils.js";
+import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
 /**
  * ToolDiscoveryService
  * Handles automatic tool discovery and registration from external MCP servers
@@ -227,15 +229,15 @@ export class ToolDiscoveryService extends EventEmitter {
     validateTool(toolInfo) {
         const errors = [];
         const warnings = [];
-        // Basic validation
-        if (!toolInfo.name || toolInfo.name.trim().length === 0) {
-            errors.push("Tool name is required");
+        // Use centralized validation for name
+        const nameError = validateToolName(toolInfo.name);
+        if (nameError) {
+            errors.push(nameError.message);
         }
-        if (toolInfo.name && !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(toolInfo.name)) {
-            errors.push("Tool name must start with a letter and contain only letters, numbers, underscores, and hyphens");
-        }
-        if (!toolInfo.description || toolInfo.description.trim().length === 0) {
-            warnings.push("Tool description is empty");
+        // Use centralized validation for description
+        const descriptionError = validateToolDescription(toolInfo.description);
+        if (descriptionError) {
+            warnings.push(descriptionError.message);
         }
         if (!toolInfo.serverId) {
             errors.push("Server ID is required");
@@ -440,19 +442,48 @@ export class ToolDiscoveryService extends EventEmitter {
         }
     }
     /**
-     * Validate tool output
+     * Validate tool output with enhanced type safety
      */
     validateToolOutput(result) {
-        // Basic output validation
-        if (!result) {
-            throw new Error("Tool returned no result");
-        }
-        // Check for error indicators
-        if (result.error) {
-            throw new Error(`Tool execution error: ${result.error}`);
+        // Check for null/undefined results
+        if (isNullish(result)) {
+            throw new Error("Tool returned null or undefined result");
+        }
+        // Enhanced error detection for object results
+        if (isObject(result)) {
+            // Check for explicit error property
+            if (result.error !== undefined) {
+                const errorMessage = isString(result.error)
+                    ? result.error
+                    : "Tool execution failed with error";
+                throw new Error(`Tool execution error: ${errorMessage}`);
+            }
+            // Check for boolean error flag
+            if (isBoolean(result.isError) && result.isError === true) {
+                const errorDetail = isString(result.message)
+                    ? `: ${result.message}`
+                    : "";
+                throw new Error(`Tool execution failed${errorDetail}`);
+            }
+            // Check for common error status patterns
+            if (isString(result.status) &&
+                (result.status === "error" || result.status === "failed")) {
+                const errorDetail = isString(result.message) || isString(result.reason)
+                    ? `: ${result.message || result.reason}`
+                    : "";
+                throw new Error(`Tool execution failed${errorDetail}`);
+            }
+            // Check for success: false pattern
+            if (isBoolean(result.success) && result.success === false) {
+                const errorDetail = isString(result.message) || isString(result.error)
+                    ? `: ${result.message || result.error}`
+                    : "";
+                throw new Error(`Tool execution unsuccessful${errorDetail}`);
+            }
         }
-        if (result.isError === true) {
-            throw new Error("Tool execution failed");
+        // Validate that string results are not empty
+        if (isString(result) && result.trim() === "") {
+            throw new Error("Tool returned empty string result");
         }
     }
     /**

package/dist/mcp/toolRegistry.d.ts

@@ -43,7 +43,29 @@ export declare class MCPToolRegistry extends MCPRegistry {
     registerServer(serverInfo: MCPServerInfo, context?: ExecutionContext): Promise<void>;
     registerServer(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
     /**
-     * Execute a tool with enhanced context
+     * Execute a tool with enhanced context and automatic result wrapping
+     *
+     * This method handles both raw return values and ToolResult objects:
+     * - Raw values (primitives, objects) are automatically wrapped in ToolResult format
+     * - Existing ToolResult objects are enhanced with execution metadata
+     * - All results include execution timing and context information
+     *
+     * @param toolName - Name of the tool to execute
+     * @param args - Parameters to pass to the tool execution function
+     * @param context - Execution context with session, user, and environment info
+     * @returns Promise resolving to ToolResult object with data, metadata, and usage info
+     * @throws Error if tool is not found or execution fails
+     *
+     * @example
+     * ```typescript
+     * // Tool that returns raw value
+     * const result = await toolRegistry.executeTool("calculator", { a: 5, b: 3, op: "add" });
+     * // result.data === 8, result.metadata contains execution info
+     *
+     * // Tool that returns ToolResult
+     * const result = await toolRegistry.executeTool("complexTool", { input: "test" });
+     * // result is enhanced ToolResult with additional metadata
+     * ```
      */
     executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
     /**

package/dist/mcp/toolRegistry.js

@@ -183,7 +183,29 @@ export class MCPToolRegistry extends MCPRegistry {
         }
     }
     /**
-     * Execute a tool with enhanced context
+     * Execute a tool with enhanced context and automatic result wrapping
+     *
+     * This method handles both raw return values and ToolResult objects:
+     * - Raw values (primitives, objects) are automatically wrapped in ToolResult format
+     * - Existing ToolResult objects are enhanced with execution metadata
+     * - All results include execution timing and context information
+     *
+     * @param toolName - Name of the tool to execute
+     * @param args - Parameters to pass to the tool execution function
+     * @param context - Execution context with session, user, and environment info
+     * @returns Promise resolving to ToolResult object with data, metadata, and usage info
+     * @throws Error if tool is not found or execution fails
+     *
+     * @example
+     * ```typescript
+     * // Tool that returns raw value
+     * const result = await toolRegistry.executeTool("calculator", { a: 5, b: 3, op: "add" });
+     * // result.data === 8, result.metadata contains execution info
+     *
+     * // Tool that returns ToolResult
+     * const result = await toolRegistry.executeTool("complexTool", { input: "test" });
+     * // result is enhanced ToolResult with additional metadata
+     * ```
      */
     async executeTool(toolName, args, context) {
         const startTime = Date.now();
@@ -221,22 +243,46 @@ export class MCPToolRegistry extends MCPRegistry {
             // Execute the actual tool
             registryLogger.debug(`Executing tool '${toolName}' with args:`, args);
             const toolResult = await toolImpl.execute(args, execContext);
-            // Add metadata to the tool result (don't double-wrap)
-            const toolResultObj = toolResult;
-            const result = {
-                ...toolResultObj,
-                usage: {
-                    ...(toolResultObj.usage || {}),
-                    executionTime: Date.now() - startTime,
-                },
-                metadata: {
-                    ...(toolResultObj.metadata || {}),
-                    toolName,
-                    serverId: tool.serverId,
-                    sessionId: execContext.sessionId,
-                    executionTime: Date.now() - startTime,
-                },
-            };
+            // Properly wrap raw results in ToolResult format
+            let result;
+            // Check if result is already a ToolResult object
+            if (toolResult &&
+                typeof toolResult === "object" &&
+                "success" in toolResult &&
+                typeof toolResult.success === "boolean") {
+                // Result is already a ToolResult, enhance with metadata
+                const toolResultObj = toolResult;
+                result = {
+                    ...toolResultObj,
+                    usage: {
+                        ...(toolResultObj.usage || {}),
+                        executionTime: Date.now() - startTime,
+                    },
+                    metadata: {
+                        ...(toolResultObj.metadata || {}),
+                        toolName,
+                        serverId: tool.serverId,
+                        sessionId: execContext.sessionId,
+                        executionTime: Date.now() - startTime,
+                    },
+                };
+            }
+            else {
+                // Result is a raw value, wrap it in ToolResult format
+                result = {
+                    success: true,
+                    data: toolResult,
+                    usage: {
+                        executionTime: Date.now() - startTime,
+                    },
+                    metadata: {
+                        toolName,
+                        serverId: tool.serverId,
+                        sessionId: execContext.sessionId,
+                        executionTime: Date.now() - startTime,
+                    },
+                };
+            }
             // Update statistics
             const duration = Date.now() - startTime;
             this.updateStats(toolName, duration);
@@ -406,6 +452,51 @@ export class MCPToolRegistry extends MCPRegistry {
      */
     registerTool(toolId, toolInfo, toolImpl) {
         registryLogger.debug(`Registering tool: ${toolId}`);
+        // Import validation functions synchronously - they are pure functions
+        let validateTool;
+        let isToolNameAvailable;
+        let suggestToolNames;
+        try {
+            // Try ES module import first
+            const toolRegistrationModule = require("../sdk/toolRegistration.js");
+            ({ validateTool, isToolNameAvailable, suggestToolNames } =
+                toolRegistrationModule);
+        }
+        catch (error) {
+            // Fallback: skip validation if import fails (graceful degradation)
+            registryLogger.warn("Tool validation module not available, skipping advanced validation", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Create minimal validation functions
+            validateTool = () => { }; // No-op
+            isToolNameAvailable = () => true; // Allow all names
+            suggestToolNames = () => ["alternative_tool"];
+        }
+        // Check if tool name is available (not reserved)
+        if (!isToolNameAvailable(toolId)) {
+            const suggestions = suggestToolNames(toolId);
+            registryLogger.error(`Tool registration failed for ${toolId}: Name not available`);
+            throw new Error(`Tool name '${toolId}' is not available (reserved or invalid format). ` +
+                `Suggested alternatives: ${suggestions.slice(0, 3).join(", ")}`);
+        }
+        // Create a simplified tool object for validation
+        const toolForValidation = {
+            description: toolInfo.description || "",
+            execute: async () => "",
+            parameters: undefined,
+            metadata: {
+                category: toolInfo.category,
+                serverId: toolInfo.serverId,
+            },
+        };
+        // Use comprehensive validation logic
+        try {
+            validateTool(toolId, toolForValidation);
+        }
+        catch (error) {
+            registryLogger.error(`Tool registration failed for ${toolId}:`, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
         this.tools.set(toolId, toolInfo);
         this.toolImpls.set(toolId, toolImpl);
         registryLogger.debug(`Successfully registered tool: ${toolId}`);