@juspay/neurolink 7.14.7 → 7.15.0

package/dist/lib/agent/directTools.js

@@ -7,6 +7,18 @@ import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
 import { logger } from "../utils/logger.js";
+import { VertexAI } from "@google-cloud/vertexai";
+// Runtime Google Search tool creation - bypasses TypeScript strict typing
+function createGoogleSearchTools() {
+    const searchTool = {};
+    // Dynamically assign google_search property at runtime
+    Object.defineProperty(searchTool, "google_search", {
+        value: {},
+        enumerable: true,
+        configurable: true,
+    });
+    return [searchTool];
+}
 /**
  * Direct tool definitions that work immediately with Gemini/AI SDK
  * These bypass MCP complexity and provide reliable agent functionality
@@ -324,6 +336,128 @@ export const directAgentTools = {
             }
         },
     }),
+    websearchGrounding: tool({
+        description: "Search the web for current information using Google Search grounding. Returns raw search data for AI processing.",
+        parameters: z.object({
+            query: z.string().describe("Search query to find information about"),
+            maxResults: z
+                .number()
+                .optional()
+                .default(3)
+                .describe("Maximum number of search results to return (1-5)"),
+            maxWords: z
+                .number()
+                .optional()
+                .default(50)
+                .describe("Maximum number of words in the response 50"),
+        }),
+        execute: async ({ query, maxResults = 3, maxWords = 50 }) => {
+            try {
+                const hasCredentials = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+                const hasProjectId = process.env.GOOGLE_VERTEX_PROJECT;
+                const projectLocation = process.env.GOOGLE_VERTEX_LOCATION || "us-central1";
+                if (!hasCredentials || !hasProjectId) {
+                    return {
+                        success: false,
+                        error: "Google Vertex AI credentials not configured. Please set GOOGLE_APPLICATION_CREDENTIALS and GOOGLE_VERTEX_PROJECT environment variables.",
+                        requiredEnvVars: [
+                            "GOOGLE_APPLICATION_CREDENTIALS",
+                            "GOOGLE_VERTEX_PROJECT",
+                        ],
+                    };
+                }
+                const limitedResults = Math.min(Math.max(maxResults, 1), 5);
+                const vertex_ai = new VertexAI({
+                    project: hasProjectId,
+                    location: projectLocation,
+                });
+                const websearchModel = "gemini-2.5-flash-lite";
+                const model = vertex_ai.getGenerativeModel({
+                    model: websearchModel,
+                    tools: createGoogleSearchTools(),
+                });
+                // Search query with word limit constraint
+                const searchPrompt = `Search for: "${query}". Provide a concise summary in no more than ${maxWords} words.`;
+                const startTime = Date.now();
+                const response = await model.generateContent({
+                    contents: [
+                        {
+                            role: "user",
+                            parts: [{ text: searchPrompt }],
+                        },
+                    ],
+                });
+                const responseTime = Date.now() - startTime;
+                // Extract grounding metadata and search results
+                const result = response.response;
+                const candidates = result.candidates;
+                if (!candidates || candidates.length === 0) {
+                    return {
+                        success: false,
+                        error: "No search results returned",
+                        query,
+                    };
+                }
+                const content = candidates[0].content;
+                if (!content || !content.parts || content.parts.length === 0) {
+                    return {
+                        success: false,
+                        error: "No search content found",
+                        query,
+                    };
+                }
+                // Extract raw search content
+                const searchContent = content.parts[0].text || "";
+                // Extract grounding sources if available
+                const groundingMetadata = candidates[0]?.groundingMetadata;
+                const searchResults = [];
+                if (groundingMetadata?.groundingChunks) {
+                    for (const chunk of groundingMetadata.groundingChunks.slice(0, limitedResults)) {
+                        if (chunk.web) {
+                            searchResults.push({
+                                title: chunk.web.title || "No title",
+                                url: chunk.web.uri || "",
+                                snippet: searchContent, // Use full content since maxWords already limits length
+                                domain: chunk.web.uri
+                                    ? new URL(chunk.web.uri).hostname
+                                    : "unknown",
+                            });
+                        }
+                    }
+                }
+                // If no grounding metadata, create basic result structure
+                if (searchResults.length === 0) {
+                    searchResults.push({
+                        title: `Search results for: ${query}`,
+                        url: "",
+                        snippet: searchContent,
+                        domain: "google-search",
+                    });
+                }
+                return {
+                    success: true,
+                    query,
+                    searchResults,
+                    rawContent: searchContent,
+                    totalResults: searchResults.length,
+                    provider: "google-search-grounding",
+                    model: websearchModel,
+                    responseTime,
+                    timestamp: startTime,
+                    grounded: true,
+                };
+            }
+            catch (error) {
+                logger.error("Web search grounding error:", error);
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    query,
+                    provider: "google-search-grounding",
+                };
+            }
+        },
+    }),
 };
 // eslint-disable-next-line no-redeclare
 export function getToolsForCategory(category = "all") {

package/dist/lib/core/baseProvider.js

@@ -395,12 +395,41 @@ export class BaseProvider {
                             parameters: z.object({}), // Use empty schema for custom tools
                             execute: async (params) => {
                                 logger.debug(`[BaseProvider] Executing custom tool: ${toolName}`, { params });
-                                // Use the tool executor if available (from setupToolExecutor)
-                                if (this.toolExecutor) {
-                                    return await this.toolExecutor(toolName, params);
+                                try {
+                                    // Use the tool executor if available (from setupToolExecutor)
+                                    let result;
+                                    if (this.toolExecutor) {
+                                        result = await this.toolExecutor(toolName, params);
+                                    }
+                                    else {
+                                        result = await typedToolDef.execute(params);
+                                    }
+                                    // Log successful execution
+                                    logger.debug(`[BaseProvider] Tool execution successful: ${toolName}`, {
+                                        resultType: typeof result,
+                                        hasResult: result !== null && result !== undefined,
+                                        toolName,
+                                    });
+                                    return result;
                                 }
-                                else {
-                                    return await typedToolDef.execute(params);
+                                catch (error) {
+                                    logger.warn(`[BaseProvider] Tool execution failed: ${toolName}`, {
+                                        error: error instanceof Error ? error.message : String(error),
+                                        params,
+                                        toolName,
+                                    });
+                                    // GENERIC ERROR HANDLING FOR ALL MCP TOOLS:
+                                    // Return a generic error object that works with any MCP server
+                                    // The AI can interpret this and try different approaches
+                                    return {
+                                        _neurolinkToolError: true,
+                                        toolName: toolName,
+                                        error: error instanceof Error ? error.message : String(error),
+                                        timestamp: new Date().toISOString(),
+                                        params: params,
+                                        // Keep it simple - just indicate an error occurred
+                                        message: `Error calling ${toolName}: ${error instanceof Error ? error.message : String(error)}`
+                                    };
                                 }
                             },
                         });

package/dist/lib/mcp/servers/agent/directToolsServer.js

@@ -120,6 +120,8 @@ function getToolCategory(toolName) {
         case "listDirectory":
         case "searchFiles":
             return "filesystem";
+        case "websearchGrounding":
+            return "search";
         default:
             return "utility";
     }

package/dist/lib/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/lib/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/lib/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/dist/mcp/servers/agent/directToolsServer.js

@@ -120,6 +120,8 @@ function getToolCategory(toolName) {
         case "listDirectory":
         case "searchFiles":
             return "filesystem";
+        case "websearchGrounding":
+            return "search";
         default:
             return "utility";
     }