@juspay/neurolink 7.14.0 → 7.14.1

package/dist/lib/neurolink.js

@@ -21,7 +21,7 @@ import { toolRegistry } from "./mcp/toolRegistry.js";
 import { logger } from "./utils/logger.js";
 import { getBestProvider } from "./utils/providerUtils.js";
 import { ProviderRegistry } from "./factories/providerRegistry.js";
-import { validateTool, createMCPServerFromTools, } from "./sdk/toolRegistration.js";
+import { createCustomToolServerInfo, detectCategory, } from "./utils/mcpDefaults.js";
 // Factory processing imports
 import { processFactoryOptions, enhanceTextGenerationOptions, validateFactoryConfig, processStreamingFactoryOptions, createCleanStreamOptions, } from "./utils/factoryProcessing.js";
 // Enhanced error handling imports
@@ -37,9 +37,7 @@ export class NeuroLink {
     mcpInitialized = false;
     emitter = new EventEmitter();
     contextManager = null;
-    // Tool registration support
-    customTools = new Map();
-    inMemoryServers = new Map();
+    autoDiscoveredServerInfos = [];
     // External MCP server management
     externalServerManager;
     // Enhanced error handling support
@@ -76,12 +74,14 @@ export class NeuroLink {
                 maxTurnsPerSession: memoryConfig.maxTurnsPerSession,
             });
         }
-        // Initialize external server manager
+        // Initialize external server manager with main registry integration
         this.externalServerManager = new ExternalServerManager({
             maxServers: 20,
             defaultTimeout: 15000,
             enableAutoRestart: true,
             enablePerformanceMonitoring: true,
+        }, {
+            enableMainRegistryIntegration: true, // Enable integration with main toolRegistry
         });
         // Forward external server events
         this.externalServerManager.on("connected", (event) => {
@@ -127,6 +127,26 @@ export class NeuroLink {
             ]);
             // Register all providers with lazy loading support
             await ProviderRegistry.registerAllProviders();
+            // Load MCP configuration from .mcp-config.json using ExternalServerManager
+            try {
+                const configResult = await this.externalServerManager.loadMCPConfiguration();
+                mcpLogger.debug("[NeuroLink] MCP configuration loaded successfully", {
+                    serversLoaded: configResult.serversLoaded,
+                    errors: configResult.errors.length,
+                });
+                if (configResult.errors.length > 0) {
+                    mcpLogger.warn("[NeuroLink] Some MCP servers failed to load", {
+                        errors: configResult.errors,
+                    });
+                }
+            }
+            catch (configError) {
+                mcpLogger.warn("[NeuroLink] MCP configuration loading failed", {
+                    error: configError instanceof Error
+                        ? configError.message
+                        : String(configError),
+                });
+            }
             this.mcpInitialized = true;
             // Monitor memory usage and provide cleanup suggestions
             const endMemory = MemoryManager.getMemoryUsageMB();
@@ -416,7 +436,7 @@ export class NeuroLink {
             this);
             // Enable tool execution for the provider using BaseProvider method
             provider.setupToolExecutor({
-                customTools: this.customTools,
+                customTools: this.getCustomTools(),
                 executeTool: this.executeTool.bind(this),
             }, functionTag);
             const result = await provider.generate({
@@ -502,7 +522,7 @@ export class NeuroLink {
                 this);
                 // Enable tool execution for direct provider generation using BaseProvider method
                 provider.setupToolExecutor({
-                    customTools: this.customTools,
+                    customTools: this.getCustomTools(),
                     executeTool: this.executeTool.bind(this),
                 }, functionTag);
                 const result = await provider.generate({
@@ -604,7 +624,7 @@ export class NeuroLink {
         for (const result of toolResults) {
             if (result && typeof result === "object") {
                 enhancedPrompt += `\n\nTool Results:\n`;
-                // Handle any structured result generically
+                // Handle structured result generically
                 try {
                     const resultStr = typeof result === "string"
                         ? result
@@ -714,7 +734,7 @@ export class NeuroLink {
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, true, this);
             // Enable tool execution for streaming using BaseProvider method
             provider.setupToolExecutor({
-                customTools: this.customTools,
+                customTools: this.getCustomTools(),
                 executeTool: this.executeTool.bind(this),
             }, functionTag);
             // Create clean options for provider (remove factoryConfig)
@@ -770,7 +790,7 @@ export class NeuroLink {
             this);
             // Enable tool execution for fallback streaming using BaseProvider method
             provider.setupToolExecutor({
-                customTools: this.customTools,
+                customTools: this.getCustomTools(),
                 executeTool: this.executeTool.bind(this),
             }, functionTag);
             // Create clean options for fallback provider (remove factoryConfig)
@@ -824,7 +844,7 @@ export class NeuroLink {
     /**
      * Register a custom tool that will be available to all AI providers
      * @param name - Unique name for the tool
-     * @param tool - Tool configuration
+     * @param tool - Tool in MCPExecutableTool format (unified MCP protocol type)
      */
     registerTool(name, tool) {
         // Emit tool registration start event
@@ -833,18 +853,10 @@ export class NeuroLink {
             timestamp: Date.now(),
         });
         try {
-            // Validate tool configuration
-            validateTool(name, tool);
-            // Store the tool
-            this.customTools.set(name, tool);
-            // Convert to MCP server format for integration
-            const serverId = `custom-tool-${name}`;
-            const mcpServer = createMCPServerFromTools(serverId, { [name]: tool }, {
-                title: `Custom Tool: ${name}`,
-                category: "custom",
-            });
-            // Store as in-memory server
-            this.inMemoryServers.set(serverId, mcpServer);
+            // SMART DEFAULTS: Use utility to eliminate boilerplate creation
+            const mcpServerInfo = createCustomToolServerInfo(name, tool);
+            // Register with toolRegistry using MCPServerInfo directly
+            toolRegistry.registerServer(mcpServerInfo);
             logger.info(`Registered custom tool: ${name}`);
             // Emit tool registration success event
             this.emitter.emit("tools-register:end", {
@@ -860,10 +872,10 @@ export class NeuroLink {
     }
     /**
      * Register multiple tools at once - Supports both object and array formats
-     * @param tools - Object mapping tool names to configurations OR Array of tools with names
+     * @param tools - Object mapping tool names to MCPExecutableTool format OR Array of tools with names
      *
-     * Object format (existing): { toolName: SimpleTool, ... }
-     * Array format (Lighthouse compatible): [{ name: string, tool: SimpleTool }, ...]
+     * Object format (existing): { toolName: MCPExecutableTool, ... }
+     * Array format (Lighthouse compatible): [{ name: string, tool: MCPExecutableTool }, ...]
      */
     registerTools(tools) {
         if (Array.isArray(tools)) {
@@ -885,40 +897,57 @@ export class NeuroLink {
      * @returns true if the tool was removed, false if it didn't exist
      */
     unregisterTool(name) {
-        const removed = this.customTools.delete(name);
+        const serverId = `custom-tool-${name}`;
+        const removed = toolRegistry.unregisterServer(serverId);
         if (removed) {
-            const serverId = `custom-tool-${name}`;
-            this.inMemoryServers.delete(serverId);
             logger.info(`Unregistered custom tool: ${name}`);
         }
         return removed;
     }
     /**
      * Get all registered custom tools
-     * @returns Map of tool names to configurations
+     * @returns Map of tool names to MCPExecutableTool format
      */
     getCustomTools() {
-        return new Map(this.customTools);
+        // Get tools from toolRegistry with smart category detection
+        const customTools = toolRegistry.getToolsByCategory(detectCategory({ isCustomTool: true }));
+        const toolMap = new Map();
+        for (const tool of customTools) {
+            // Return MCPServerInfo.tools format directly - no conversion needed
+            toolMap.set(tool.name, {
+                name: tool.name,
+                description: tool.description || "",
+                inputSchema: {},
+                execute: async (args, context) => {
+                    // Type guard to ensure context is compatible with ExecutionContext
+                    const executionContext = context && typeof context === "object" && context !== null
+                        ? context
+                        : undefined;
+                    return await toolRegistry.executeTool(tool.name, args, executionContext);
+                },
+            });
+        }
+        return toolMap;
     }
     /**
      * Add an in-memory MCP server (from git diff)
      * Allows registration of pre-instantiated server objects
      * @param serverId - Unique identifier for the server
-     * @param config - Server configuration
+     * @param serverInfo - Server configuration
      */
-    async addInMemoryMCPServer(serverId, config) {
+    async addInMemoryMCPServer(serverId, serverInfo) {
         try {
             mcpLogger.debug(`[NeuroLink] Registering in-memory MCP server: ${serverId}`);
-            // Validate server configuration
-            if (!config.server) {
-                throw new Error(`Server object is required for ${serverId}`);
+            // Initialize tools array if not provided
+            if (!serverInfo.tools) {
+                serverInfo.tools = [];
             }
-            // Store in registry
-            this.inMemoryServers.set(serverId, config);
+            // ZERO CONVERSIONS: Pass MCPServerInfo directly to toolRegistry
+            await toolRegistry.registerServer(serverInfo);
             mcpLogger.info(`[NeuroLink] Successfully registered in-memory server: ${serverId}`, {
-                category: config.category,
-                provider: config.metadata?.provider,
-                version: config.metadata?.version,
+                category: serverInfo.metadata?.category,
+                provider: serverInfo.metadata?.provider,
+                version: serverInfo.metadata?.version,
             });
         }
         catch (error) {
@@ -928,10 +957,41 @@ export class NeuroLink {
     }
     /**
      * Get all registered in-memory servers
-     * @returns Map of server IDs to configurations
+     * @returns Map of server IDs to MCPServerInfo
      */
     getInMemoryServers() {
-        return new Map(this.inMemoryServers);
+        // Get in-memory servers from toolRegistry
+        const serverInfos = toolRegistry.getBuiltInServerInfos();
+        const serverMap = new Map();
+        for (const serverInfo of serverInfos) {
+            if (detectCategory({
+                existingCategory: serverInfo.metadata?.category,
+                serverId: serverInfo.id,
+            }) === "in-memory") {
+                serverMap.set(serverInfo.id, serverInfo);
+            }
+        }
+        return serverMap;
+    }
+    /**
+     * Get in-memory servers as MCPServerInfo - ZERO conversion needed
+     * Now fetches from centralized tool registry instead of local duplication
+     * @returns Array of MCPServerInfo
+     */
+    getInMemoryServerInfos() {
+        // Get in-memory servers from centralized tool registry
+        const allServers = toolRegistry.getBuiltInServerInfos();
+        return allServers.filter((server) => detectCategory({
+            existingCategory: server.metadata?.category,
+            serverId: server.id,
+        }) === "in-memory");
+    }
+    /**
+     * Get auto-discovered servers as MCPServerInfo - ZERO conversion needed
+     * @returns Array of MCPServerInfo
+     */
+    getAutoDiscoveredServerInfos() {
+        return this.autoDiscoveredServerInfos;
     }
     /**
      * Execute a specific tool by name with robust error handling
@@ -1050,8 +1110,8 @@ export class NeuroLink {
                     structuredError = ErrorFactory.toolTimeout(toolName, finalOptions.timeout);
                 }
                 else if (error.message.includes("not found")) {
-                    const availableTools = Array.from(this.customTools.keys());
-                    structuredError = ErrorFactory.toolNotFound(toolName, availableTools);
+                    const availableTools = await this.getAllAvailableTools();
+                    structuredError = ErrorFactory.toolNotFound(toolName, availableTools.map((t) => t.name));
                 }
                 else if (error.message.includes("validation") ||
                     error.message.includes("parameter")) {
@@ -1093,57 +1153,6 @@ export class NeuroLink {
      */
     async executeToolInternal(toolName, params, options) {
         const functionTag = "NeuroLink.executeToolInternal";
-        // First check custom tools
-        if (this.customTools.has(toolName)) {
-            const tool = this.customTools.get(toolName);
-            // Validate parameters if schema is available
-            if (tool.parameters) {
-                try {
-                    tool.parameters.parse(params);
-                }
-                catch (validationError) {
-                    throw ErrorFactory.invalidParameters(toolName, validationError, params);
-                }
-            }
-            const context = {
-                sessionId: `direct-execution-${Date.now()}`,
-                logger,
-            };
-            try {
-                const result = await tool.execute(params, context);
-                return result;
-            }
-            catch (error) {
-                throw ErrorFactory.toolExecutionFailed(toolName, error instanceof Error ? error : new Error(String(error)));
-            }
-        }
-        // Then check in-memory servers
-        for (const [serverId, serverConfig] of this.inMemoryServers.entries()) {
-            const server = serverConfig.server;
-            if (server && server.tools) {
-                const tool = server.tools instanceof Map
-                    ? server.tools.get(toolName)
-                    : server.tools[toolName];
-                if (tool && typeof tool.execute === "function") {
-                    try {
-                        const result = await tool.execute(params);
-                        // Handle MCP-style results
-                        if (result && typeof result === "object" && "success" in result) {
-                            if (result.success) {
-                                return result.data;
-                            }
-                            else {
-                                throw ErrorFactory.toolExecutionFailed(toolName, new Error(result.error || "Tool execution failed"), serverId);
-                            }
-                        }
-                        return result;
-                    }
-                    catch (error) {
-                        throw ErrorFactory.toolExecutionFailed(toolName, error instanceof Error ? error : new Error(String(error)), serverId);
-                    }
-                }
-            }
-        }
         // Check external MCP servers
         const externalTools = this.externalServerManager.getAllTools();
         const externalTool = externalTools.find((tool) => tool.name === toolName);
@@ -1209,35 +1218,30 @@ export class NeuroLink {
                 serverId: tool.serverId === "direct" ? "neurolink-direct" : tool.serverId, // Update serverId for test compatibility
             }));
             // 2. Get custom tools from this NeuroLink instance
-            const customTools = Array.from(this.customTools.entries()).map(([name, tool]) => ({
-                name,
-                toolName: name, // Add toolName property for compatibility with tests
+            const customTools = toolRegistry
+                .getToolsByCategory(detectCategory({ isCustomTool: true }))
+                .map((tool) => ({
+                name: tool.name,
+                toolName: tool.name, // Add toolName property for compatibility with tests
                 description: tool.description || "Custom tool",
-                serverId: `custom-tool-${name}`, // Match the serverId pattern used in registerTool
-                category: "user-defined",
-                inputSchema: {},
+                serverId: tool.serverId || `custom-tool-${tool.name}`,
+                category: detectCategory({
+                    isCustomTool: true,
+                    serverId: tool.serverId,
+                }),
+                inputSchema: tool.inputSchema || {},
             }));
             // 3. Get tools from in-memory MCP servers
-            const inMemoryTools = [];
-            for (const [serverId, serverConfig] of this.inMemoryServers.entries()) {
-                const server = serverConfig.server;
-                if (server && server.tools) {
-                    const tools = server.tools instanceof Map
-                        ? Object.fromEntries(server.tools)
-                        : server.tools;
-                    for (const [toolName, toolDef] of Object.entries(tools)) {
-                        const toolRecord = toolDef;
-                        inMemoryTools.push({
-                            name: toolName,
-                            toolName, // Add toolName property for compatibility with tests
-                            description: toolRecord.description || "In-memory MCP tool",
-                            serverId,
-                            category: serverConfig.category || "mcp-server",
-                            inputSchema: {},
-                        });
-                    }
-                }
-            }
+            const inMemoryTools = toolRegistry
+                .getToolsByCategory("in-memory")
+                .map((tool) => ({
+                name: tool.name,
+                toolName: tool.name, // Add toolName property for compatibility with tests
+                description: tool.description || "In-memory MCP tool",
+                serverId: tool.serverId || "unknown",
+                category: tool.category || "in-memory",
+                inputSchema: {},
+            }));
             // 4. Get external MCP tools
             const externalMCPTools = this.externalServerManager
                 .getAllTools()
@@ -1246,7 +1250,13 @@ export class NeuroLink {
                 toolName: tool.name,
                 description: tool.description,
                 serverId: tool.serverId,
-                category: tool.metadata?.category || "external-mcp",
+                category: detectCategory({
+                    existingCategory: typeof tool.metadata?.category === "string"
+                        ? tool.metadata.category
+                        : undefined,
+                    isExternal: true,
+                    serverId: tool.serverId,
+                }),
                 inputSchema: tool.inputSchema || {},
                 isAvailable: tool.isAvailable,
                 stats: tool.stats,
@@ -1492,41 +1502,36 @@ export class NeuroLink {
      */
     async getMCPStatus() {
         try {
+            // Initialize MCP if not already initialized (loads external servers from config)
+            await this.initializeMCP();
             // Get built-in tools
             const allTools = await toolRegistry.listTools();
             // Get external MCP server statistics
             const externalStats = this.externalServerManager.getStatistics();
-            const externalServers = this.listExternalMCPServers();
+            // DIRECT RETURNS - ZERO conversion
+            const externalMCPServers = this.externalServerManager.listServers();
+            const inMemoryServerInfos = this.getInMemoryServerInfos();
+            const builtInServerInfos = toolRegistry.getBuiltInServerInfos();
+            const autoDiscoveredServerInfos = this.getAutoDiscoveredServerInfos();
             // Calculate totals
-            const totalServers = 1 + externalStats.totalServers + this.inMemoryServers.size; // toolRegistry + external + in-memory
-            const availableServers = 1 + externalStats.connectedServers; // toolRegistry always available + connected external
-            const totalTools = allTools.length + externalStats.totalTools + this.customTools.size;
-            // Convert external servers to MCPServerInfo format
-            const externalMCPServers = externalServers.map((server) => ({
-                id: server.serverId,
-                name: typeof server.config.metadata?.title === "string"
-                    ? server.config.metadata.title
-                    : server.serverId,
-                source: `external-${server.config.transport}`,
-                status: server.status,
-                hasServer: server.isHealthy,
-                metadata: {
-                    transport: server.config.transport,
-                    command: server.config.command,
-                    toolCount: server.toolCount,
-                    uptime: server.uptime,
-                },
-            }));
+            const totalServers = externalMCPServers.length +
+                inMemoryServerInfos.length +
+                builtInServerInfos.length +
+                autoDiscoveredServerInfos.length;
+            const availableServers = externalStats.connectedServers +
+                inMemoryServerInfos.length +
+                builtInServerInfos.length; // in-memory and built-in always available
+            const totalTools = allTools.length + externalStats.totalTools;
             return {
                 mcpInitialized: this.mcpInitialized,
                 totalServers,
                 availableServers,
-                autoDiscoveredCount: 0, // No auto-discovery for external servers
+                autoDiscoveredCount: autoDiscoveredServerInfos.length,
                 totalTools,
-                autoDiscoveredServers: [],
-                customToolsCount: this.customTools.size,
-                inMemoryServersCount: this.inMemoryServers.size,
-                externalMCPServersCount: externalStats.totalServers,
+                autoDiscoveredServers: autoDiscoveredServerInfos,
+                customToolsCount: toolRegistry.getToolsByCategory(detectCategory({ isCustomTool: true })).length,
+                inMemoryServersCount: inMemoryServerInfos.length,
+                externalMCPServersCount: externalMCPServers.length,
                 externalMCPConnectedCount: externalStats.connectedServers,
                 externalMCPFailedCount: externalStats.failedServers,
                 externalMCPServers,
@@ -1540,8 +1545,8 @@ export class NeuroLink {
                 autoDiscoveredCount: 0,
                 totalTools: 0,
                 autoDiscoveredServers: [],
-                customToolsCount: this.customTools.size,
-                inMemoryServersCount: this.inMemoryServers.size,
+                customToolsCount: toolRegistry.getToolsByCategory(detectCategory({ isCustomTool: true })).length,
+                inMemoryServersCount: 0,
                 externalMCPServersCount: 0,
                 externalMCPConnectedCount: 0,
                 externalMCPFailedCount: 0,
@@ -1555,54 +1560,13 @@ export class NeuroLink {
      * @returns Promise resolving to array of MCP server information
      */
     async listMCPServers() {
-        const servers = [];
-        // Add built-in toolRegistry as a server
-        servers.push({
-            id: "neurolink-direct",
-            name: "NeuroLink Built-in Tools",
-            source: "built-in",
-            status: "connected",
-            hasServer: true,
-            metadata: {
-                type: "direct-tools",
-                description: "Built-in NeuroLink tools (getCurrentTime, readFile, etc.)",
-            },
-        });
-        // Add in-memory servers
-        for (const [serverId, serverConfig] of this.inMemoryServers.entries()) {
-            servers.push({
-                id: serverId,
-                name: serverConfig.server.title || serverId,
-                source: "in-memory",
-                status: "connected",
-                hasServer: true,
-                metadata: {
-                    category: serverConfig.category,
-                    provider: serverConfig.metadata?.provider,
-                    version: serverConfig.metadata?.version,
-                },
-            });
-        }
-        // Add external MCP servers
-        const externalServers = this.listExternalMCPServers();
-        for (const server of externalServers) {
-            servers.push({
-                id: server.serverId,
-                name: typeof server.config.metadata?.title === "string"
-                    ? server.config.metadata.title
-                    : server.serverId,
-                source: `external-${server.config.transport}`,
-                status: server.status,
-                hasServer: server.isHealthy,
-                metadata: {
-                    transport: server.config.transport,
-                    command: server.config.command,
-                    toolCount: server.toolCount,
-                    uptime: server.uptime,
-                },
-            });
-        }
-        return servers;
+        // DIRECT RETURNS - ZERO conversion logic
+        return [
+            ...this.externalServerManager.listServers(), // Direct return
+            ...this.getInMemoryServerInfos(), // Direct return
+            ...toolRegistry.getBuiltInServerInfos(), // Direct return
+            ...this.getAutoDiscoveredServerInfos(), // Direct return
+        ];
     }
     /**
      * Test connectivity to a specific MCP server
@@ -1617,9 +1581,10 @@ export class NeuroLink {
                 return tools.length > 0;
             }
             // Test in-memory servers
-            if (this.inMemoryServers.has(serverId)) {
-                const serverConfig = this.inMemoryServers.get(serverId);
-                return !!(serverConfig.server && serverConfig.server.tools);
+            const inMemoryServers = this.getInMemoryServers();
+            if (inMemoryServers.has(serverId)) {
+                const serverInfo = inMemoryServers.get(serverId);
+                return !!(serverInfo.tools && serverInfo.tools.length > 0);
             }
             // Test external MCP servers
             const externalServer = this.externalServerManager.getServer(serverId);
@@ -1785,14 +1750,12 @@ export class NeuroLink {
      * Get comprehensive tool health report
      * @returns Detailed health report for all tools
      */
-    getToolHealthReport() {
+    async getToolHealthReport() {
         const tools = {};
         let healthyCount = 0;
-        // Get all tool names from all sources
-        const allToolNames = new Set([
-            ...this.customTools.keys(),
-            ...Array.from(this.inMemoryServers.values()).flatMap((server) => server.server?.tools ? Object.keys(server.server.tools) : []),
-        ]);
+        // Get all tool names from toolRegistry
+        const allTools = await toolRegistry.listTools();
+        const allToolNames = new Set(allTools.map((tool) => tool.name));
         for (const toolName of allToolNames) {
             const metrics = this.toolExecutionMetrics.get(toolName);
             const circuitBreaker = this.toolCircuitBreakers.get(toolName);
@@ -1950,16 +1913,16 @@ export class NeuroLink {
      */
     listExternalMCPServers() {
         const serverStatuses = this.externalServerManager.getServerStatuses();
-        const allServers = this.externalServerManager.getAllServers();
+        const allServers = this.externalServerManager.listServers();
         return serverStatuses.map((health) => {
-            const server = allServers.get(health.serverId);
+            const server = allServers.find((s) => s.id === health.serverId);
             return {
                 serverId: health.serverId,
                 status: health.status,
                 toolCount: health.toolCount,
                 uptime: health.performance.uptime,
                 isHealthy: health.isHealthy,
-                config: server?.config || {},
+                config: server || {},
             };
         });
     }

package/dist/lib/providers/googleVertex.d.ts

@@ -90,6 +90,12 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * @returns The current tool execution context
      */
     getToolContext(): Record<string, unknown>;
+    /**
+     * Set the tool executor function for custom tool execution
+     * This method is called by BaseProvider.setupToolExecutor()
+     * @param executor Function to execute tools by name
+     */
+    setToolExecutor(executor: (toolName: string, params: unknown) => Promise<unknown>): void;
     /**
      * Clear all static caches - useful for testing and memory cleanup
      * Public method to allow external cache management

package/dist/lib/providers/googleVertex.js

@@ -504,6 +504,17 @@ export class GoogleVertexProvider extends BaseProvider {
     getToolContext() {
         return { ...this.toolContext };
     }
+    /**
+     * Set the tool executor function for custom tool execution
+     * This method is called by BaseProvider.setupToolExecutor()
+     * @param executor Function to execute tools by name
+     */
+    setToolExecutor(executor) {
+        this.toolExecutor = executor;
+        logger.debug("GoogleVertexProvider.setToolExecutor: Tool executor set", {
+            hasExecutor: typeof executor === "function",
+        });
+    }
     /**
      * Clear all static caches - useful for testing and memory cleanup
      * Public method to allow external cache management

package/dist/lib/providers/huggingFace.js

@@ -87,7 +87,7 @@ export class HuggingFaceProvider extends BaseProvider {
             "openchat",
             "wizardcoder",
         ];
-        // Check if current model matches any tool-capable model patterns
+        // Check if current model matches tool-capable model patterns
         const isToolCapable = toolCapableModels.some((capableModel) => modelName.includes(capableModel));
         if (isToolCapable) {
             logger.debug("HuggingFace tool calling enabled", {

package/dist/lib/providers/mistral.js

@@ -21,11 +21,11 @@ const getDefaultMistralModel = () => {
 export class MistralProvider extends BaseProvider {
     model;
     constructor(modelName, sdk) {
-        // Type guard for NeuroLinkSDK parameter validation
-        const validatedSdk = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
+        // Type guard for NeuroLink parameter validation
+        const validatedNeurolink = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
             ? sdk
             : undefined;
-        super(modelName, "mistral", validatedSdk);
+        super(modelName, "mistral", validatedNeurolink);
         // Initialize Mistral model with API key validation
         const apiKey = getMistralApiKey();
         const mistral = createMistral({

package/dist/lib/providers/ollama.js

@@ -270,7 +270,7 @@ export class OllamaProvider extends BaseProvider {
         // Get tool-capable models from configuration
         const ollamaConfig = modelConfig.getProviderConfig("ollama");
         const toolCapableModels = ollamaConfig?.modelBehavior?.toolCapableModels || [];
-        // Check if current model matches any tool-capable model patterns
+        // Check if current model matches tool-capable model patterns
         const isToolCapable = toolCapableModels.some((capableModel) => modelName.includes(capableModel));
         if (isToolCapable) {
             logger.debug("Ollama tool calling enabled", {