@juspay/neurolink 7.14.7 → 7.15.0

package/dist/mcp/toolDiscoveryService.js

@@ -6,7 +6,7 @@
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
 import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
-import { isObject, isString, isBoolean, isNullish, } from "../utils/typeUtils.js";
+import { isObject, isNullish, } from "../utils/typeUtils.js";
 import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
 /**
  * ToolDiscoveryService
@@ -342,7 +342,7 @@ export class ToolDiscoveryService extends EventEmitter {
             // Update tool statistics
             this.updateToolStats(toolKey, true, duration);
             // Validate output if requested
-            if (options.validateOutput !== false && result) {
+            if (options.validateOutput !== false) {
                 this.validateToolOutput(result);
             }
             mcpLogger.debug(`[ToolDiscoveryService] Tool execution completed: ${toolName}`, {
@@ -445,46 +445,30 @@ export class ToolDiscoveryService extends EventEmitter {
      * Validate tool output with enhanced type safety
      */
     validateToolOutput(result) {
-        // Check for null/undefined results
+        // GENERIC ERROR HANDLING FOR ALL MCP TOOLS
+        // Different MCP servers return different error formats, so we should be permissive
+        // and let the AI handle any response format instead of throwing errors
+        // Only throw for truly invalid responses (null/undefined)
         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}`);
-            }
-        }
-        // Validate that string results are not empty
-        if (isString(result) && result.trim() === "") {
-            throw new Error("Tool returned empty string result");
+            mcpLogger.debug("[ToolDiscoveryService] Tool returned null/undefined, treating as empty response");
+            // Even null responses can be valid for some tools - don't throw
+            return;
         }
+        // Log what we received for debugging, but don't validate specific formats
+        mcpLogger.debug("[ToolDiscoveryService] Tool response received", {
+            type: typeof result,
+            isArray: Array.isArray(result),
+            isObject: isObject(result),
+            hasKeys: isObject(result) ? Object.keys(result).length : 0,
+            fullResponse: result // Log the complete response, not a truncated sample
+        });
+        // COMPLETELY PERMISSIVE APPROACH:
+        // - Any response format is valid (objects, strings, arrays, booleans, numbers)
+        // - Even error responses are passed to the AI to handle
+        // - The AI can interpret error messages and retry with different approaches
+        // - This works with any MCP server regardless of their response format
+        // No validation or throwing - let the AI handle everything
+        return;
     }
     /**
      * Update tool statistics

package/dist/neurolink.js

@@ -32,6 +32,8 @@ import { EventEmitter } from "events";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import { applyConversationMemoryDefaults, getConversationMessages, storeConversationTurn, } from "./utils/conversationMemoryUtils.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
+// Import direct tools server for automatic registration
+import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
 import { ContextManager } from "./context/ContextManager.js";
 import { defaultContextConfig } from "./context/config.js";
 import { isNonNullObject } from "./utils/typeUtils.js";
@@ -130,6 +132,19 @@ export class NeuroLink {
             ]);
             // Register all providers with lazy loading support
             await ProviderRegistry.registerAllProviders();
+            // Register the direct tools server to make websearch and other tools available
+            try {
+                // Use the server ID string for registration instead of the server object
+                await toolRegistry.registerServer("neurolink-direct", directToolsServer);
+                mcpLogger.debug("[NeuroLink] Direct tools server registered successfully", {
+                    serverId: "neurolink-direct",
+                });
+            }
+            catch (error) {
+                mcpLogger.warn("[NeuroLink] Failed to register direct tools server", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
             // Load MCP configuration from .mcp-config.json using ExternalServerManager
             try {
                 const configResult = await this.externalServerManager.loadMCPConfiguration();
@@ -356,27 +371,55 @@ export class NeuroLink {
             }
             // Try MCP-enhanced generation first (if not explicitly disabled)
             if (!options.disableTools) {
-                try {
-                    logger.debug(`[${functionTag}] Attempting MCP generation...`);
-                    const mcpResult = await this.tryMCPGeneration(options);
-                    if (mcpResult && mcpResult.content) {
-                        logger.debug(`[${functionTag}] MCP generation successful`);
-                        // Store conversation turn
-                        await storeConversationTurn(this.conversationMemory, options, mcpResult);
-                        return mcpResult;
+                let mcpAttempts = 0;
+                const maxMcpRetries = 2; // Allow retries for tool-related failures
+                while (mcpAttempts <= maxMcpRetries) {
+                    try {
+                        logger.debug(`[${functionTag}] Attempting MCP generation (attempt ${mcpAttempts + 1}/${maxMcpRetries + 1})...`);
+                        const mcpResult = await this.tryMCPGeneration(options);
+                        if (mcpResult && mcpResult.content) {
+                            logger.debug(`[${functionTag}] MCP generation successful on attempt ${mcpAttempts + 1}`, {
+                                contentLength: mcpResult.content.length,
+                                toolsUsed: mcpResult.toolsUsed?.length || 0,
+                                toolExecutions: mcpResult.toolExecutions?.length || 0,
+                            });
+                            // Store conversation turn
+                            await storeConversationTurn(this.conversationMemory, options, mcpResult);
+                            return mcpResult;
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] MCP generation returned empty result on attempt ${mcpAttempts + 1}:`, {
+                                hasResult: !!mcpResult,
+                                hasContent: !!(mcpResult && mcpResult.content),
+                                contentLength: mcpResult?.content?.length || 0,
+                                toolExecutions: mcpResult?.toolExecutions?.length || 0,
+                            });
+                            // If we got a result but no content, and we have tool executions, this might be a tool success case
+                            if (mcpResult &&
+                                mcpResult.toolExecutions &&
+                                mcpResult.toolExecutions.length > 0) {
+                                logger.debug(`[${functionTag}] Found tool executions but no content, continuing with result`);
+                                // Store conversation turn even with empty content if tools executed
+                                await storeConversationTurn(this.conversationMemory, options, mcpResult);
+                                return mcpResult;
+                            }
+                        }
                     }
-                    else {
-                        logger.debug(`[${functionTag}] MCP generation returned empty result:`, {
-                            hasResult: !!mcpResult,
-                            hasContent: !!(mcpResult && mcpResult.content),
-                            contentLength: mcpResult?.content?.length || 0,
+                    catch (error) {
+                        mcpAttempts++;
+                        logger.debug(`[${functionTag}] MCP generation failed on attempt ${mcpAttempts}/${maxMcpRetries + 1}`, {
+                            error: error instanceof Error ? error.message : String(error),
+                            willRetry: mcpAttempts <= maxMcpRetries,
                         });
+                        // If this was the last attempt, break and fall back
+                        if (mcpAttempts > maxMcpRetries) {
+                            logger.debug(`[${functionTag}] All MCP attempts exhausted, falling back to direct generation`);
+                            break;
+                        }
+                        // Small delay before retry to allow transient issues to resolve
+                        await new Promise((resolve) => setTimeout(resolve, 500));
                     }
-                }
-                catch (error) {
-                    logger.debug(`[${functionTag}] MCP generation failed, falling back`, {
-                        error: error instanceof Error ? error.message : String(error),
-                    });
+                    mcpAttempts++;
                 }
             }
             // Fall back to direct provider generation
@@ -430,19 +473,40 @@ export class NeuroLink {
                 conversationMessages, // Inject conversation history
             });
             const responseTime = Date.now() - startTime;
-            // Check if result is meaningful
-            if (!result || !result.content || result.content.trim().length === 0) {
+            // Enhanced result validation - consider tool executions as valid results
+            const hasContent = result && result.content && result.content.trim().length > 0;
+            const hasToolExecutions = result && result.toolExecutions && result.toolExecutions.length > 0;
+            // Log detailed result analysis for debugging
+            mcpLogger.debug(`[${functionTag}] Result validation:`, {
+                hasResult: !!result,
+                hasContent,
+                hasToolExecutions,
+                contentLength: result?.content?.length || 0,
+                toolExecutionsCount: result?.toolExecutions?.length || 0,
+                toolsUsedCount: result?.toolsUsed?.length || 0,
+            });
+            // Accept result if it has content OR successful tool executions
+            if (!hasContent && !hasToolExecutions) {
+                mcpLogger.debug(`[${functionTag}] Result rejected: no content and no tool executions`);
                 return null; // Let caller fall back to direct generation
             }
-            // Return enhanced result with external tool information
+            // Transform tool executions with enhanced preservation
+            const transformedToolExecutions = transformToolExecutionsForMCP(result.toolExecutions);
+            // Log transformation results
+            mcpLogger.debug(`[${functionTag}] Tool execution transformation:`, {
+                originalCount: result?.toolExecutions?.length || 0,
+                transformedCount: transformedToolExecutions.length,
+                transformedTools: transformedToolExecutions.map((te) => te.toolName),
+            });
+            // Return enhanced result with preserved tool information
             return {
-                content: result.content,
+                content: result.content || "", // Ensure content is never undefined
                 provider: providerName,
                 usage: result.usage,
                 responseTime,
                 toolsUsed: result.toolsUsed || [],
-                toolExecutions: transformToolExecutionsForMCP(result.toolExecutions),
-                enhancedWithTools: true,
+                toolExecutions: transformedToolExecutions,
+                enhancedWithTools: Boolean(hasToolExecutions), // Mark as enhanced if tools were actually used
                 availableTools: transformToolsForMCP(availableTools),
                 // Include analytics and evaluation from BaseProvider
                 analytics: result.analytics,

package/dist/utils/transformationUtils.js

@@ -24,13 +24,56 @@ export function transformToolExecutions(toolExecutions) {
     if (!toolExecutions || !Array.isArray(toolExecutions)) {
         return [];
     }
-    return toolExecutions.map((te) => {
+    return toolExecutions.map((te, index) => {
         const teRecord = te;
+        // Enhanced tool name extraction with multiple fallback strategies
+        let toolName = teRecord.name ||
+            teRecord.toolName ||
+            teRecord.tool ||
+            "";
+        // If still no name, try to extract from nested objects
+        if (!toolName &&
+            teRecord.toolCall &&
+            typeof teRecord.toolCall === "object") {
+            const toolCall = teRecord.toolCall;
+            toolName =
+                toolCall.name || toolCall.toolName || "";
+        }
+        // Last resort: use index-based fallback to avoid "Unknown Tool"
+        if (!toolName) {
+            toolName = `tool_execution_${index}`;
+        }
+        // Enhanced input extraction
+        let input = teRecord.input ||
+            teRecord.parameters ||
+            teRecord.args ||
+            {};
+        // Extract input from nested toolCall if available
+        if (Object.keys(input).length === 0 &&
+            teRecord.toolCall &&
+            typeof teRecord.toolCall === "object") {
+            const toolCall = teRecord.toolCall;
+            input =
+                toolCall.input ||
+                    toolCall.parameters ||
+                    toolCall.args ||
+                    {};
+        }
+        // Enhanced output extraction with success indication
+        let output = teRecord.output ||
+            teRecord.result ||
+            teRecord.response ||
+            "success";
+        // Enhanced duration extraction
+        let duration = teRecord.duration ??
+            teRecord.executionTime ??
+            teRecord.responseTime ??
+            0;
         return {
-            name: teRecord.name || "",
-            input: teRecord.input || {},
-            output: teRecord.output || "success",
-            duration: teRecord.duration || 0,
+            name: toolName,
+            input: input,
+            output: output,
+            duration: duration,
         };
     });
 }
@@ -42,13 +85,63 @@ export function transformToolExecutionsForMCP(toolExecutions) {
     if (!toolExecutions || !Array.isArray(toolExecutions)) {
         return [];
     }
-    return toolExecutions.map((te) => {
+    return toolExecutions.map((te, index) => {
         const teRecord = te;
+        // Enhanced tool name extraction matching the main function
+        let toolName = teRecord.name ||
+            teRecord.toolName ||
+            teRecord.tool ||
+            "";
+        // Try nested toolCall extraction
+        if (!toolName &&
+            teRecord.toolCall &&
+            typeof teRecord.toolCall === "object") {
+            const toolCall = teRecord.toolCall;
+            toolName =
+                toolCall.name || toolCall.toolName || "";
+        }
+        // Fallback to avoid empty names
+        if (!toolName) {
+            toolName = `mcp_tool_execution_${index}`;
+        }
+        // Enhanced execution time extraction
+        let executionTime = teRecord.duration ??
+            teRecord.executionTime ??
+            teRecord.responseTime ??
+            0;
+        // Enhanced success detection - check for actual success indicators
+        let success = true; // Default to true
+        // Check for explicit success/error indicators
+        if (teRecord.success !== undefined) {
+            success = Boolean(teRecord.success);
+        }
+        else if (teRecord.error !== undefined) {
+            success = false;
+        }
+        else if (teRecord.status !== undefined) {
+            const status = String(teRecord.status).toLowerCase().trim();
+            success = !["error", "failed", "failure", "fail"].includes(status);
+        }
+        // Enhanced server ID extraction
+        let serverId = teRecord.serverId ||
+            teRecord.server ||
+            teRecord.source ||
+            undefined;
+        // Try to extract from nested structures
+        if (!serverId &&
+            teRecord.toolCall &&
+            typeof teRecord.toolCall === "object") {
+            const toolCall = teRecord.toolCall;
+            serverId =
+                toolCall.serverId ||
+                    toolCall.server ||
+                    undefined;
+        }
         return {
-            toolName: teRecord.name || "",
-            executionTime: teRecord.duration || 0,
-            success: true, // Assume success if tool executed (AI providers handle failures differently)
-            serverId: teRecord.serverId || undefined,
+            toolName: toolName,
+            executionTime: executionTime,
+            success: success,
+            serverId: serverId,
         };
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.14.7",
+  "version": "7.15.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -148,6 +148,7 @@
     "@aws-sdk/client-sagemaker": "^3.862.0",
     "@aws-sdk/client-sagemaker-runtime": "^3.862.0",
     "@aws-sdk/types": "^3.862.0",
+    "@google-cloud/vertexai": "^1.10.0",
     "@google/generative-ai": "^0.24.1",
     "@huggingface/inference": "^2.8.0",
     "@modelcontextprotocol/sdk": "^1.13.0",