@juspay/neurolink 1.6.0 → 1.9.0

package/dist/lib/mcp/logging.d.ts

@@ -0,0 +1,71 @@
+/**
+ * NeuroLink MCP Logging System
+ * Provides configurable logging with different verbosity levels
+ */
+export declare enum LogLevel {
+    SILENT = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4
+}
+export interface LoggerConfig {
+    level: LogLevel;
+    prefix?: string;
+    colors?: boolean;
+    timestamp?: boolean;
+}
+/**
+ * Configurable logger for MCP operations
+ */
+export declare class MCPLogger {
+    private config;
+    constructor(config?: Partial<LoggerConfig>);
+    /**
+     * Set log level
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Get current log level
+     */
+    getLevel(): LogLevel;
+    /**
+     * Log an error message
+     */
+    error(message: string, ...args: any[]): void;
+    /**
+     * Log a warning message
+     */
+    warn(message: string, ...args: any[]): void;
+    /**
+     * Log an info message
+     */
+    info(message: string, ...args: any[]): void;
+    /**
+     * Log a debug message
+     */
+    debug(message: string, ...args: any[]): void;
+    /**
+     * Internal logging method
+     */
+    private log;
+}
+/**
+ * Create logger instances for different MCP components
+ */
+export declare const createLogger: (component: string) => MCPLogger;
+/**
+ * Default loggers for common MCP components
+ */
+export declare const mcpLogger: MCPLogger;
+export declare const autoDiscoveryLogger: MCPLogger;
+export declare const registryLogger: MCPLogger;
+export declare const unifiedRegistryLogger: MCPLogger;
+/**
+ * Utility function to set global MCP log level
+ */
+export declare function setGlobalMCPLogLevel(level: LogLevel): void;
+/**
+ * Utility function to parse log level from string
+ */
+export declare function parseLogLevel(level: string): LogLevel;

package/dist/lib/mcp/logging.js

@@ -0,0 +1,183 @@
+/**
+ * NeuroLink MCP Logging System
+ * Provides configurable logging with different verbosity levels
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["SILENT"] = 0] = "SILENT";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Configurable logger for MCP operations
+ */
+export class MCPLogger {
+    config;
+    constructor(config = {}) {
+        // Determine log level from environment or default to SILENT
+        const envLogLevel = process.env.NEUROLINK_MCP_LOG_LEVEL?.toUpperCase();
+        let defaultLevel = LogLevel.SILENT;
+        switch (envLogLevel) {
+            case "SILENT":
+                defaultLevel = LogLevel.SILENT;
+                break;
+            case "ERROR":
+                defaultLevel = LogLevel.ERROR;
+                break;
+            case "WARN":
+                defaultLevel = LogLevel.WARN;
+                break;
+            case "INFO":
+                defaultLevel = LogLevel.INFO;
+                break;
+            case "DEBUG":
+                defaultLevel = LogLevel.DEBUG;
+                break;
+        }
+        this.config = {
+            level: defaultLevel,
+            prefix: "",
+            colors: true,
+            timestamp: false,
+            ...config,
+        };
+    }
+    /**
+     * Set log level
+     */
+    setLevel(level) {
+        this.config.level = level;
+    }
+    /**
+     * Get current log level
+     */
+    getLevel() {
+        return this.config.level;
+    }
+    /**
+     * Log an error message
+     */
+    error(message, ...args) {
+        if (this.config.level >= LogLevel.ERROR) {
+            this.log("ERROR", message, ...args);
+        }
+    }
+    /**
+     * Log a warning message
+     */
+    warn(message, ...args) {
+        if (this.config.level >= LogLevel.WARN) {
+            this.log("WARN", message, ...args);
+        }
+    }
+    /**
+     * Log an info message
+     */
+    info(message, ...args) {
+        if (this.config.level >= LogLevel.INFO) {
+            this.log("INFO", message, ...args);
+        }
+    }
+    /**
+     * Log a debug message
+     */
+    debug(message, ...args) {
+        if (this.config.level >= LogLevel.DEBUG) {
+            this.log("DEBUG", message, ...args);
+        }
+    }
+    /**
+     * Internal logging method
+     */
+    log(level, message, ...args) {
+        let output = "";
+        // Add timestamp if enabled
+        if (this.config.timestamp) {
+            output += `[${new Date().toISOString()}] `;
+        }
+        // Add prefix if configured
+        if (this.config.prefix) {
+            output += `[${this.config.prefix}] `;
+        }
+        // Add log level
+        if (this.config.colors) {
+            switch (level) {
+                case "ERROR":
+                    output += `\x1b[31m[${level}]\x1b[0m `;
+                    break;
+                case "WARN":
+                    output += `\x1b[33m[${level}]\x1b[0m `;
+                    break;
+                case "INFO":
+                    output += `\x1b[36m[${level}]\x1b[0m `;
+                    break;
+                case "DEBUG":
+                    output += `\x1b[90m[${level}]\x1b[0m `;
+                    break;
+                default:
+                    output += `[${level}] `;
+            }
+        }
+        else {
+            output += `[${level}] `;
+        }
+        // Add message
+        output += message;
+        // Use appropriate console method
+        switch (level) {
+            case "ERROR":
+                console.error(output, ...args);
+                break;
+            case "WARN":
+                console.warn(output, ...args);
+                break;
+            default:
+                console.log(output, ...args);
+        }
+    }
+}
+/**
+ * Create logger instances for different MCP components
+ */
+export const createLogger = (component) => {
+    return new MCPLogger({
+        prefix: component,
+    });
+};
+/**
+ * Default loggers for common MCP components
+ */
+export const mcpLogger = createLogger("MCP");
+export const autoDiscoveryLogger = createLogger("MCPAutoDiscovery");
+export const registryLogger = createLogger("MCPRegistry");
+export const unifiedRegistryLogger = createLogger("UnifiedMCPRegistry");
+/**
+ * Utility function to set global MCP log level
+ */
+export function setGlobalMCPLogLevel(level) {
+    mcpLogger.setLevel(level);
+    autoDiscoveryLogger.setLevel(level);
+    registryLogger.setLevel(level);
+    unifiedRegistryLogger.setLevel(level);
+}
+/**
+ * Utility function to parse log level from string
+ */
+export function parseLogLevel(level) {
+    switch (level.toUpperCase()) {
+        case "SILENT":
+            return LogLevel.SILENT;
+        case "ERROR":
+            return LogLevel.ERROR;
+        case "WARN":
+            return LogLevel.WARN;
+        case "INFO":
+            return LogLevel.INFO;
+        case "DEBUG":
+            return LogLevel.DEBUG;
+        default:
+            return LogLevel.WARN;
+    }
+}

package/dist/lib/mcp/manager.d.ts

@@ -0,0 +1,67 @@
+/**
+ * NeuroLink MCP Manager
+ * Manages MCP client instances following Lighthouse's session-based pattern
+ */
+import { NeuroLinkMCPClient } from "./client.js";
+import type { MCPClientConfig } from "./client.js";
+/**
+ * MCP Manager - Factory pattern for managing multiple client instances
+ * Following Lighthouse's session-based architecture
+ */
+export declare class NeuroLinkMCPManager {
+    private static instances;
+    private static lastCleanup;
+    private static cleanupInterval;
+    /**
+     * Get or create an MCP client instance for a session
+     */
+    static getInstance(sessionId: string, config?: Partial<MCPClientConfig>): NeuroLinkMCPClient;
+    /**
+     * Remove the oldest instance based on creation time
+     */
+    private static removeOldestInstance;
+    /**
+     * Clean up instances that haven't been used recently
+     */
+    private static cleanupOldInstances;
+    /**
+     * Get list of active session IDs
+     */
+    static getActiveSessionIds(): string[];
+    /**
+     * Remove a specific instance
+     */
+    static removeInstance(sessionId: string): Promise<boolean>;
+    /**
+     * Get instance count
+     */
+    static getInstanceCount(): number;
+    /**
+     * Get maximum allowed instances
+     */
+    static getMaxInstances(): number;
+    /**
+     * Get statistics for all instances
+     */
+    static getAllStats(): {
+        instanceCount: number;
+        maxInstances: number;
+        instances: Record<string, any>;
+    };
+    /**
+     * Clear all instances (for testing or shutdown)
+     */
+    static clearAll(): Promise<void>;
+}
+/**
+ * Convenience function to get MCP manager instance
+ */
+export declare function getMCPManager(sessionId: string, config?: Partial<MCPClientConfig>): NeuroLinkMCPClient;
+/**
+ * Convenience function to remove MCP manager instance
+ */
+export declare function removeMCPManager(sessionId: string): Promise<boolean>;
+/**
+ * Export manager for direct access if needed
+ */
+export { NeuroLinkMCPManager as MCPManager };

package/dist/lib/mcp/manager.js

@@ -0,0 +1,176 @@
+/**
+ * NeuroLink MCP Manager
+ * Manages MCP client instances following Lighthouse's session-based pattern
+ */
+import { createMCPClient } from "./client.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Maximum number of concurrent MCP instances
+ */
+const MAX_MCP_INSTANCES = 50;
+/**
+ * Default MCP configuration
+ */
+const DEFAULT_MCP_CONFIG = {
+    logLevel: "info",
+};
+/**
+ * MCP Manager - Factory pattern for managing multiple client instances
+ * Following Lighthouse's session-based architecture
+ */
+export class NeuroLinkMCPManager {
+    static instances = new Map();
+    static lastCleanup = Date.now();
+    static cleanupInterval = 60000; // 1 minute
+    /**
+     * Get or create an MCP client instance for a session
+     */
+    static getInstance(sessionId, config) {
+        // Periodic cleanup of old instances
+        if (Date.now() - this.lastCleanup > this.cleanupInterval) {
+            this.cleanupOldInstances();
+        }
+        // Return existing instance if available
+        if (this.instances.has(sessionId)) {
+            const instance = this.instances.get(sessionId);
+            logger.debug(`[MCP Manager] Returning existing instance for session ${sessionId}`);
+            return instance;
+        }
+        // Check if we've reached the maximum number of instances
+        if (this.instances.size >= MAX_MCP_INSTANCES) {
+            // Remove the oldest instance to make room
+            this.removeOldestInstance();
+        }
+        // Create new instance
+        const fullConfig = {
+            sessionId,
+            ...DEFAULT_MCP_CONFIG,
+            ...config,
+        };
+        const instance = createMCPClient(fullConfig);
+        this.instances.set(sessionId, instance);
+        logger.info(`[MCP Manager] Created new instance for session ${sessionId}`, {
+            instanceCount: this.instances.size,
+            config: fullConfig,
+        });
+        return instance;
+    }
+    /**
+     * Remove the oldest instance based on creation time
+     */
+    static removeOldestInstance() {
+        let oldestSessionId = null;
+        let oldestTime = Date.now();
+        // Find the oldest instance
+        for (const [sessionId, instance] of this.instances.entries()) {
+            const stats = instance.getStats();
+            const creationTime = Date.now() - stats.uptime;
+            if (creationTime < oldestTime) {
+                oldestTime = creationTime;
+                oldestSessionId = sessionId;
+            }
+        }
+        if (oldestSessionId) {
+            const instance = this.instances.get(oldestSessionId);
+            instance.disconnect();
+            this.instances.delete(oldestSessionId);
+            logger.info(`[MCP Manager] Removed oldest instance`, {
+                sessionId: oldestSessionId,
+                remainingInstances: this.instances.size,
+            });
+        }
+    }
+    /**
+     * Clean up instances that haven't been used recently
+     */
+    static cleanupOldInstances() {
+        const now = Date.now();
+        const maxIdleTime = 300000; // 5 minutes
+        const toRemove = [];
+        for (const [sessionId, instance] of this.instances.entries()) {
+            const stats = instance.getStats();
+            // If no executions in the last 5 minutes, mark for removal
+            if (stats.executionCount === 0 && now - stats.uptime > maxIdleTime) {
+                toRemove.push(sessionId);
+            }
+        }
+        for (const sessionId of toRemove) {
+            const instance = this.instances.get(sessionId);
+            instance.disconnect();
+            this.instances.delete(sessionId);
+        }
+        if (toRemove.length > 0) {
+            logger.info(`[MCP Manager] Cleaned up ${toRemove.length} idle instances`);
+        }
+        this.lastCleanup = now;
+    }
+    /**
+     * Get list of active session IDs
+     */
+    static getActiveSessionIds() {
+        return Array.from(this.instances.keys());
+    }
+    /**
+     * Remove a specific instance
+     */
+    static async removeInstance(sessionId) {
+        const instance = this.instances.get(sessionId);
+        if (instance) {
+            await instance.disconnect();
+            return this.instances.delete(sessionId);
+        }
+        return false;
+    }
+    /**
+     * Get instance count
+     */
+    static getInstanceCount() {
+        return this.instances.size;
+    }
+    /**
+     * Get maximum allowed instances
+     */
+    static getMaxInstances() {
+        return MAX_MCP_INSTANCES;
+    }
+    /**
+     * Get statistics for all instances
+     */
+    static getAllStats() {
+        const stats = {};
+        for (const [sessionId, instance] of this.instances.entries()) {
+            stats[sessionId] = instance.getStats();
+        }
+        return {
+            instanceCount: this.instances.size,
+            maxInstances: MAX_MCP_INSTANCES,
+            instances: stats,
+        };
+    }
+    /**
+     * Clear all instances (for testing or shutdown)
+     */
+    static async clearAll() {
+        for (const instance of this.instances.values()) {
+            await instance.disconnect();
+        }
+        this.instances.clear();
+        logger.info("[MCP Manager] Cleared all instances");
+    }
+}
+/**
+ * Convenience function to get MCP manager instance
+ */
+export function getMCPManager(sessionId, config) {
+    return NeuroLinkMCPManager.getInstance(sessionId, config);
+}
+/**
+ * Convenience function to remove MCP manager instance
+ */
+export async function removeMCPManager(sessionId) {
+    return NeuroLinkMCPManager.removeInstance(sessionId);
+}
+/**
+ * Export manager for direct access if needed
+ */
+export { NeuroLinkMCPManager as MCPManager };

package/dist/lib/mcp/neurolink-mcp-client.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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 type { AIProvider } from "../core/types.js";
+import type { NeuroLinkMCPTool } from "./factory.js";
+/**
+ * Tool Detection Pattern
+ */
+interface ToolDetectionPattern {
+    patterns: RegExp[];
+    toolName: string;
+    paramExtractor?: (prompt: string) => Record<string, unknown>;
+}
+/**
+ * MCP Client Configuration
+ */
+export interface NeuroLinkMCPClientConfig {
+    provider: AIProvider;
+    providerName?: string;
+    modelName?: string;
+    sessionId?: string;
+    userId?: string;
+    organizationId?: string;
+}
+/**
+ * NeuroLink MCP Client with Automatic Tool Detection
+ */
+export declare class NeuroLinkMCPClient extends EventEmitter {
+    private provider;
+    private tools;
+    private toolPatterns;
+    private config;
+    private sessionId;
+    private executionCount;
+    constructor(config: NeuroLinkMCPClientConfig);
+    /**
+     * Initialize default tool detection patterns
+     */
+    private initializeDefaultPatterns;
+    /**
+     * Register a tool with automatic detection patterns
+     */
+    registerTool(tool: NeuroLinkMCPTool, patterns?: ToolDetectionPattern): void;
+    /**
+     * Extract tool parameters using AI
+     * No hardcoded patterns - let AI figure out the parameters
+     */
+    private extractToolParameters;
+    /**
+     * Analyze prompt to detect required tools
+     * TRUE AUTOMATIC DETECTION - AI decides which tools to use
+     */
+    private analyzePrompt;
+    /**
+     * Execute detected tools
+     */
+    private executeTools;
+    /**
+     * Generate response with tool results incorporated
+     */
+    private generateResponse;
+    /**
+     * Send a prompt and automatically execute any needed tools
+     */
+    sendPrompt(prompt: string): Promise<string>;
+    /**
+     * Get registered tools
+     */
+    getTools(): Record<string, {
+        description?: string;
+        inputSchema?: unknown;
+    }>;
+    /**
+     * Get session statistics
+     */
+    getStats(): {
+        sessionId: string;
+        toolCount: number;
+        patternCount: number;
+        executionCount: number;
+        provider: string | undefined;
+        model: string | undefined;
+    };
+    /**
+     * Clean up resources
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Create a new NeuroLink MCP Client instance
+ */
+export declare function createNeuroLinkMCPClient(config: NeuroLinkMCPClientConfig): NeuroLinkMCPClient;
+export {};