@juspay/neurolink 1.6.0 → 1.10.0

package/dist/mcp/neurolink-mcp-client.js

@@ -0,0 +1,417 @@
+/**
+ * NeuroLink MCP Client with Automatic Tool Detection
+ * Implements automatic tool execution based on prompt analysis
+ * Following Lighthouse's pattern of prompt-based tool invocation
+ */
+import { EventEmitter } from "events";
+import { logger } from "../utils/logger.js";
+import { v4 as uuidv4 } from "uuid";
+/**
+ * NeuroLink MCP Client with Automatic Tool Detection
+ */
+export class NeuroLinkMCPClient extends EventEmitter {
+    provider;
+    tools = new Map();
+    toolPatterns = [];
+    config;
+    sessionId;
+    executionCount = 0;
+    constructor(config) {
+        super();
+        this.provider = config.provider;
+        this.config = config;
+        this.sessionId = config.sessionId || uuidv4();
+        this.initializeDefaultPatterns();
+        logger.info(`[NeuroLink MCP Client] Initialized with automatic tool detection`, {
+            sessionId: this.sessionId,
+            provider: config.providerName,
+            model: config.modelName,
+        });
+    }
+    /**
+     * Initialize default tool detection patterns
+     */
+    initializeDefaultPatterns() {
+        // NO HARDCODED PATTERNS! Let AI decide which tools to use
+        // This is TRUE automatic tool detection
+    }
+    /**
+     * Register a tool with automatic detection patterns
+     */
+    registerTool(tool, patterns) {
+        this.tools.set(tool.name, tool);
+        // Add custom patterns if provided
+        if (patterns) {
+            this.toolPatterns.push(patterns);
+        }
+        logger.debug(`[NeuroLink MCP Client] Registered tool: ${tool.name}`, {
+            hasPatterns: !!patterns,
+            sessionId: this.sessionId,
+        });
+        this.emit("tool:registered", { toolName: tool.name });
+    }
+    /**
+     * Extract tool parameters using AI
+     * No hardcoded patterns - let AI figure out the parameters
+     */
+    async extractToolParameters(toolName, tool, prompt) {
+        // If the tool has no input schema, no parameters needed
+        if (!tool.inputSchema) {
+            return {};
+        }
+        // Get the schema information
+        let schemaDescription = "";
+        try {
+            // Convert schema to a readable format
+            if (typeof tool.inputSchema === "object" && tool.inputSchema !== null) {
+                schemaDescription = JSON.stringify(tool.inputSchema, null, 2);
+            }
+        }
+        catch (error) {
+            logger.warn(`[NeuroLink MCP Client] Could not serialize schema for ${toolName}`);
+            return {};
+        }
+        // Ask AI to extract parameters
+        const extractionPrompt = `Extract the parameters needed for the tool "${toolName}" from the user prompt.
+
+Tool: ${toolName}
+Description: ${tool.description}
+Input Schema: ${schemaDescription}
+
+User prompt: "${prompt}"
+
+Instructions:
+1. Analyze the user prompt to extract values for the tool parameters
+2. Return ONLY a JSON object with the extracted parameters
+3. If a parameter cannot be extracted from the prompt, omit it or use a reasonable default
+4. Make sure the JSON is valid and matches the schema
+
+Examples:
+- Prompt: "What's the weather in New York?" → {"location": "New York"}
+- Prompt: "Calculate 5 + 3" → {"expression": "5 + 3"}
+- Prompt: "What time is it?" → {} (no parameters needed)
+
+Response (JSON object only):`;
+        try {
+            const response = await this.provider.generateText({
+                prompt: extractionPrompt,
+                temperature: 0,
+                maxTokens: 200,
+            });
+            if (response?.text) {
+                // Extract JSON object from response
+                const match = response.text.match(/\{([^}]*)\}/);
+                if (match) {
+                    try {
+                        const params = JSON.parse(match[0]);
+                        logger.debug(`[NeuroLink MCP Client] Extracted parameters for ${toolName}`, params);
+                        return params;
+                    }
+                    catch (parseError) {
+                        logger.error(`[NeuroLink MCP Client] Failed to parse parameters`, parseError);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.error(`[NeuroLink MCP Client] Failed to extract parameters with AI`, error);
+        }
+        return {};
+    }
+    /**
+     * Analyze prompt to detect required tools
+     * TRUE AUTOMATIC DETECTION - AI decides which tools to use
+     */
+    async analyzePrompt(prompt) {
+        const detectedTools = [];
+        // No patterns! Always use AI to detect tools
+        if (this.tools.size > 0) {
+            const toolList = Array.from(this.tools.values()).map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+            }));
+            const analysisPrompt = `Analyze this user prompt and determine which tools should be used to answer it properly.
+
+User prompt: "${prompt}"
+
+Available tools:
+${toolList.map((t) => `- ${t.name}: ${t.description}`).join("\n")}
+
+Instructions:
+1. Analyze what the user is asking for
+2. Determine which tools would be helpful to answer the question
+3. Return ONLY a JSON array of tool names that should be used
+4. If no tools are needed, return an empty array []
+5. Be selective - only choose tools that are directly relevant
+
+Examples:
+- "What time is it?" → ["neurolink-utility_get-current-time"]
+- "Calculate 5 + 3" → ["neurolink-utility_calculator"]
+- "What is the capital of France?" → []
+- "What's the weather in NYC?" → ["neurolink-utility_get-weather"]
+
+Response (JSON array only):`;
+            try {
+                const response = await this.provider.generateText({
+                    prompt: analysisPrompt,
+                    temperature: 0,
+                    maxTokens: 200,
+                });
+                if (response?.text) {
+                    // Extract JSON array from response
+                    const match = response.text.match(/\[([^\]]*)\]/);
+                    if (match) {
+                        try {
+                            const toolNames = JSON.parse(match[0]);
+                            // Filter to only include tools that actually exist
+                            const validTools = toolNames.filter((name) => {
+                                // Check exact match first
+                                if (this.tools.has(name)) {
+                                    return true;
+                                }
+                                // Check for partial matches (e.g., "get-current-time" matches "neurolink-utility_get-current-time")
+                                for (const [registeredName] of this.tools) {
+                                    if (registeredName.endsWith(`_${name}`) ||
+                                        registeredName.includes(name)) {
+                                        // Replace with the full registered name
+                                        const index = toolNames.indexOf(name);
+                                        if (index !== -1) {
+                                            toolNames[index] = registeredName;
+                                        }
+                                        return true;
+                                    }
+                                }
+                                return false;
+                            });
+                            detectedTools.push(...validTools);
+                        }
+                        catch (parseError) {
+                            logger.error(`[NeuroLink MCP Client] Failed to parse tool names`, parseError);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.error(`[NeuroLink MCP Client] Failed to analyze prompt with AI`, error);
+            }
+        }
+        logger.info(`[NeuroLink MCP Client] AI detected tools for prompt`, {
+            prompt: prompt.substring(0, 50),
+            detectedTools,
+            sessionId: this.sessionId,
+        });
+        return detectedTools;
+    }
+    /**
+     * Execute detected tools
+     */
+    async executeTools(toolNames, prompt) {
+        const results = [];
+        for (const toolName of toolNames) {
+            const tool = this.tools.get(toolName);
+            if (!tool) {
+                logger.warn(`[NeuroLink MCP Client] Tool not found: ${toolName}`);
+                continue;
+            }
+            // Extract parameters for the tool using AI
+            const params = await this.extractToolParameters(toolName, tool, prompt);
+            // Create execution context
+            const context = {
+                sessionId: this.sessionId,
+                userId: this.config.userId,
+                organizationId: this.config.organizationId,
+                aiProvider: this.config.providerName,
+                modelId: this.config.modelName,
+                timestamp: Date.now(),
+            };
+            // Emit tool start event
+            this.executionCount++;
+            const executionId = `exec-${this.executionCount}`;
+            this.emit("tool:start", {
+                executionId,
+                toolName,
+                params,
+            });
+            const startTime = Date.now();
+            try {
+                // Execute the tool
+                const result = await tool.execute(params, context);
+                const executionTime = Date.now() - startTime;
+                results.push({
+                    toolName,
+                    result,
+                    executionTime,
+                });
+                // Emit tool end event
+                this.emit("tool:end", {
+                    executionId,
+                    toolName,
+                    result,
+                    executionTime,
+                });
+                logger.info(`[NeuroLink MCP Client] Tool executed successfully`, {
+                    toolName,
+                    executionTime,
+                    success: result.success,
+                });
+            }
+            catch (error) {
+                const executionTime = Date.now() - startTime;
+                const errorResult = {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+                results.push({
+                    toolName,
+                    result: errorResult,
+                    executionTime,
+                });
+                // Emit tool error event
+                this.emit("tool:error", {
+                    executionId,
+                    toolName,
+                    error: errorResult.error,
+                    executionTime,
+                });
+                logger.error(`[NeuroLink MCP Client] Tool execution failed`, {
+                    toolName,
+                    error: errorResult.error,
+                    executionTime,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Generate response with tool results incorporated
+     */
+    async generateResponse(prompt, toolResults) {
+        // If no tools were used, generate regular response
+        if (toolResults.length === 0) {
+            const response = await this.provider.generateText({ prompt });
+            return response?.text || "";
+        }
+        // Extract human-readable results from tool executions
+        const toolResultsText = toolResults
+            .map((tr) => {
+            if (tr.result.success && tr.result.data) {
+                // Check if tool result has a displayString or other human-readable format
+                const data = tr.result.data;
+                // For time tool, use the displayString
+                if (data.displayString) {
+                    return data.displayString;
+                }
+                // For other tools, try to extract meaningful text
+                if (data.formatted) {
+                    return data.formatted;
+                }
+                // For complex results, create a summary
+                if (typeof data === "object") {
+                    // Try to find the most relevant field
+                    if (data.result) {
+                        return String(data.result);
+                    }
+                    if (data.output) {
+                        return String(data.output);
+                    }
+                    if (data.text) {
+                        return String(data.text);
+                    }
+                    if (data.value) {
+                        return String(data.value);
+                    }
+                    // For time-specific fields
+                    if (data.localTime) {
+                        return `The current time is ${data.localTime} in ${data.actualTimezone || data.requestedTimezone}`;
+                    }
+                }
+                // Fallback to stringified result
+                return JSON.stringify(data);
+            }
+            else {
+                return `Tool ${tr.toolName} failed: ${tr.result.error}`;
+            }
+        })
+            .join("\n");
+        // For single tool results with displayString, return directly
+        if (toolResults.length === 1) {
+            const toolResult = toolResults[0];
+            if (toolResult.result.success && toolResult.result.data) {
+                const data = toolResult.result.data;
+                if (data.displayString) {
+                    return data.displayString;
+                }
+            }
+        }
+        // For more complex queries, let the AI incorporate the results
+        const enhancedPrompt = `User question: ${prompt}
+
+Tool results: ${toolResultsText}
+
+Please provide a natural response based on the tool results.`;
+        // Generate final response
+        const response = await this.provider.generateText({
+            prompt: enhancedPrompt,
+            temperature: 0.7,
+            maxTokens: 1000,
+        });
+        return response?.text || toolResultsText;
+    }
+    /**
+     * Send a prompt and automatically execute any needed tools
+     */
+    async sendPrompt(prompt) {
+        logger.info(`[NeuroLink MCP Client] Processing prompt with automatic tool detection`, {
+            prompt: prompt.substring(0, 100),
+            sessionId: this.sessionId,
+        });
+        // Step 1: Analyze prompt for tool needs
+        const toolsNeeded = await this.analyzePrompt(prompt);
+        // Step 2: Execute tools if needed
+        const toolResults = await this.executeTools(toolsNeeded, prompt);
+        // Step 3: Generate response with tool results
+        const response = await this.generateResponse(prompt, toolResults);
+        return response;
+    }
+    /**
+     * Get registered tools
+     */
+    getTools() {
+        const tools = {};
+        for (const [name, tool] of this.tools) {
+            tools[name] = {
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            };
+        }
+        return tools;
+    }
+    /**
+     * Get session statistics
+     */
+    getStats() {
+        return {
+            sessionId: this.sessionId,
+            toolCount: this.tools.size,
+            patternCount: this.toolPatterns.length,
+            executionCount: this.executionCount,
+            provider: this.config.providerName,
+            model: this.config.modelName,
+        };
+    }
+    /**
+     * Clean up resources
+     */
+    async cleanup() {
+        this.tools.clear();
+        this.toolPatterns = [];
+        this.removeAllListeners();
+        logger.info(`[NeuroLink MCP Client] Cleaned up session ${this.sessionId}`);
+    }
+}
+/**
+ * Create a new NeuroLink MCP Client instance
+ */
+export function createNeuroLinkMCPClient(config) {
+    return new NeuroLinkMCPClient(config);
+}

package/dist/mcp/orchestrator.d.ts

@@ -3,9 +3,9 @@
  * Central orchestrator for coordinated tool execution with pipeline management
  * Coordinates factory, registry, context, and AI tools for seamless operation
  */
-import type { ToolResult } from './factory.js';
-import { MCPToolRegistry, type ToolExecutionOptions } from './registry.js';
-import { ContextManager, type ContextRequest } from './context-manager.js';
+import type { ToolResult } from "./factory.js";
+import { MCPToolRegistry, type ToolExecutionOptions } from "./registry.js";
+import { ContextManager, type ContextRequest } from "./context-manager.js";
 /**
  * Pipeline execution options
  */

package/dist/mcp/orchestrator.js

@@ -3,9 +3,9 @@
  * Central orchestrator for coordinated tool execution with pipeline management
  * Coordinates factory, registry, context, and AI tools for seamless operation
  */
-import { MCPToolRegistry, defaultToolRegistry } from './registry.js';
-import { ContextManager, defaultContextManager, createExecutionContext } from './context-manager.js';
-import { aiCoreServer } from './servers/ai-providers/ai-core-server.js';
+import { MCPToolRegistry, defaultToolRegistry, } from "./registry.js";
+import { ContextManager, defaultContextManager, createExecutionContext, } from "./context-manager.js";
+import { aiCoreServer } from "./servers/ai-providers/ai-core-server.js";
 /**
  * NeuroLink MCP Tool Orchestrator
  * Central coordination engine for tool execution, pipelines, and AI operations
@@ -26,10 +26,10 @@ export class MCPOrchestrator {
     async initializeDefaultServers() {
         try {
             await this.registry.registerServer(aiCoreServer);
-            console.log('[Orchestrator] Initialized with AI Core Server');
+            console.log("[Orchestrator] Initialized with AI Core Server");
         }
         catch (error) {
-            console.warn('[Orchestrator] Failed to register AI Core Server:', error);
+            console.warn("[Orchestrator] Failed to register AI Core Server:", error);
         }
     }
     /**
@@ -47,7 +47,7 @@ export class MCPOrchestrator {
         console.log(`[Orchestrator] Executing tool '${toolName}' in session ${context.sessionId}`);
         // Execute tool through registry
         const result = await this.registry.executeTool(toolName, params, context, options);
-        console.log(`[Orchestrator] Tool '${toolName}' execution ${result.success ? 'completed' : 'failed'}`);
+        console.log(`[Orchestrator] Tool '${toolName}' execution ${result.success ? "completed" : "failed"}`);
         return result;
     }
     /**
@@ -61,11 +61,11 @@ export class MCPOrchestrator {
     async executePipeline(steps, contextRequest = {}, options = {}) {
         const startTime = Date.now();
         const pipelineId = this.generatePipelineId();
-        const { stopOnError = true, parallel = false, timeout = 60000, trackMetrics = true, validateInputs = true } = options;
+        const { stopOnError = true, parallel = false, timeout = 60000, trackMetrics = true, validateInputs = true, } = options;
         // Create shared execution context
         const context = this.contextManager.createContext({
             ...contextRequest,
-            sessionId: contextRequest.sessionId || pipelineId
+            sessionId: contextRequest.sessionId || pipelineId,
         });
         const results = new Map();
         const errors = new Map();
@@ -79,7 +79,7 @@ export class MCPOrchestrator {
                     timeout,
                     trackMetrics,
                     validateInputs,
-                    stopOnError
+                    stopOnError,
                 });
             }
             else {
@@ -92,12 +92,12 @@ export class MCPOrchestrator {
                             ...step.options,
                             validateInput: validateInputs,
                             trackMetrics,
-                            timeoutMs: timeout / steps.length // Distribute timeout across steps
+                            timeoutMs: timeout / steps.length, // Distribute timeout across steps
                         });
                         results.set(stepId, stepResult);
                         stepsExecuted++;
                         if (!stepResult.success) {
-                            errors.set(stepId, stepResult.error || 'Unknown error');
+                            errors.set(stepId, stepResult.error || "Unknown error");
                             if (stopOnError) {
                                 console.error(`[Orchestrator] Pipeline ${pipelineId} stopped due to error in step ${stepId}`);
                                 break;
@@ -117,7 +117,7 @@ export class MCPOrchestrator {
             }
             const executionTime = Date.now() - startTime;
             const success = errors.size === 0 || !stopOnError;
-            console.log(`[Orchestrator] Pipeline ${pipelineId} completed in ${executionTime}ms - ${success ? 'SUCCESS' : 'FAILED'}`);
+            console.log(`[Orchestrator] Pipeline ${pipelineId} completed in ${executionTime}ms - ${success ? "SUCCESS" : "FAILED"}`);
             return {
                 success,
                 results,
@@ -129,8 +129,8 @@ export class MCPOrchestrator {
                     pipelineId,
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    parallel
-                }
+                    parallel,
+                },
             };
         }
         catch (error) {
@@ -140,7 +140,7 @@ export class MCPOrchestrator {
             return {
                 success: false,
                 results,
-                errors: new Map([['pipeline', errorMessage]]),
+                errors: new Map([["pipeline", errorMessage]]),
                 executionTime,
                 stepsExecuted,
                 stepsSkipped,
@@ -148,8 +148,8 @@ export class MCPOrchestrator {
                     pipelineId,
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    parallel
-                }
+                    parallel,
+                },
             };
         }
     }
@@ -172,29 +172,29 @@ export class MCPOrchestrator {
             // Step 1: Provider selection (if not specified)
             if (!options.provider) {
                 steps.push({
-                    stepId: 'select-provider',
-                    toolName: 'select-provider',
+                    stepId: "select-provider",
+                    toolName: "select-provider",
                     params: {
                         requirements: {
                             maxTokens: options.maxTokens,
-                            costEfficient: true
-                        }
-                    }
+                            costEfficient: true,
+                        },
+                    },
                 });
             }
             // Step 2: Text generation
             steps.push({
-                stepId: 'generate-text',
-                toolName: 'generate-text',
+                stepId: "generate-text",
+                toolName: "generate-text",
                 params: {
                     prompt,
                     provider: options.provider,
                     model: options.model,
                     temperature: options.temperature,
                     maxTokens: options.maxTokens,
-                    systemPrompt: options.systemPrompt
+                    systemPrompt: options.systemPrompt,
                 },
-                dependsOn: options.provider ? [] : ['select-provider']
+                dependsOn: options.provider ? [] : ["select-provider"],
             });
             // Step 3: Custom tools (if specified)
             if (options.customTools && options.customTools.length > 0) {
@@ -202,8 +202,10 @@ export class MCPOrchestrator {
                     steps.push({
                         stepId: `custom-${toolName}`,
                         toolName,
-                        params: { /* tool-specific params */},
-                        dependsOn: ['generate-text']
+                        params: {
+                        /* tool-specific params */
+                        },
+                        dependsOn: ["generate-text"],
                     });
                 }
             }
@@ -211,14 +213,14 @@ export class MCPOrchestrator {
             const pipelineResult = await this.executePipeline(steps, contextRequest, {
                 stopOnError: true,
                 parallel: false,
-                trackMetrics: true
+                trackMetrics: true,
             });
             const executionTime = Date.now() - startTime;
             // Extract text generation result
-            const textResult = pipelineResult.results.get('generate-text');
-            const providerResult = pipelineResult.results.get('select-provider');
+            const textResult = pipelineResult.results.get("generate-text");
+            const providerResult = pipelineResult.results.get("select-provider");
             if (!textResult || !textResult.success) {
-                throw new Error('Text generation failed');
+                throw new Error("Text generation failed");
             }
             const toolsUsed = Array.from(pipelineResult.results.keys());
             console.log(`[Orchestrator] Text pipeline completed in ${executionTime}ms`);
@@ -232,8 +234,8 @@ export class MCPOrchestrator {
                 metadata: {
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    toolsUsed
-                }
+                    toolsUsed,
+                },
             };
         }
         catch (error) {
@@ -246,8 +248,8 @@ export class MCPOrchestrator {
                 metadata: {
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    toolsUsed: []
-                }
+                    toolsUsed: [],
+                },
             };
         }
     }
@@ -261,8 +263,8 @@ export class MCPOrchestrator {
             registry: this.registry.getStats(),
             context: this.contextManager.getStats(),
             orchestrator: {
-                pipelinesExecuted: this.pipelineCounter
-            }
+                pipelinesExecuted: this.pipelineCounter,
+            },
         };
     }
     /**
@@ -283,14 +285,15 @@ export class MCPOrchestrator {
         const completed = new Set();
         const executing = new Set();
         while (completed.size < steps.length) {
-            const readySteps = Array.from(stepMap.keys()).filter(stepId => {
-                if (completed.has(stepId) || executing.has(stepId))
+            const readySteps = Array.from(stepMap.keys()).filter((stepId) => {
+                if (completed.has(stepId) || executing.has(stepId)) {
                     return false;
+                }
                 const dependencies = dependencyGraph.get(stepId) || [];
-                return dependencies.every(dep => completed.has(dep));
+                return dependencies.every((dep) => completed.has(dep));
             });
             if (readySteps.length === 0) {
-                throw new Error('Circular dependency detected in pipeline');
+                throw new Error("Circular dependency detected in pipeline");
             }
             // Execute ready steps in parallel
             const executePromises = readySteps.map(async (stepId) => {
@@ -300,7 +303,7 @@ export class MCPOrchestrator {
                     const result = await this.registry.executeTool(step.toolName, step.params, context, { ...step.options, ...options });
                     results.set(stepId, result);
                     if (!result.success) {
-                        errors.set(stepId, result.error || 'Unknown error');
+                        errors.set(stepId, result.error || "Unknown error");
                     }
                 }
                 catch (error) {