@juspay/neurolink 1.6.0 → 1.9.0

package/dist/mcp/client.d.ts

@@ -0,0 +1,66 @@
+/**
+ * NeuroLink MCP Client
+ * Following Lighthouse's pattern for MCP tool registration and execution
+ */
+import { EventEmitter } from "events";
+import type { ToolResult, NeuroLinkExecutionContext } from "./factory.js";
+/**
+ * MCP Client Configuration
+ */
+export interface MCPClientConfig {
+    sessionId: string;
+    userId?: string;
+    aiProvider?: string;
+    modelId?: string;
+    logLevel?: "debug" | "info" | "warn" | "error";
+}
+/**
+ * NeuroLink MCP Client
+ * Manages tool registration and execution following Lighthouse patterns
+ */
+export declare class NeuroLinkMCPClient extends EventEmitter {
+    private tools;
+    private config;
+    private executionCount;
+    private isConnected;
+    constructor(config: MCPClientConfig);
+    /**
+     * Register a tool with the MCP client
+     * Following Lighthouse's pattern of namespacing tools with server ID
+     */
+    registerTool(toolName: string, execute: (name: string, params: Record<string, unknown>) => Promise<any>, description?: string, inputSchema?: unknown): void;
+    /**
+     * Get all registered tools
+     */
+    getTools(): Record<string, {
+        description?: string;
+        inputSchema?: unknown;
+    }>;
+    /**
+     * Execute a tool by name
+     */
+    executeTool(toolName: string, params: unknown, context?: Partial<NeuroLinkExecutionContext>): Promise<ToolResult>;
+    /**
+     * Check if connected to MCP
+     */
+    isConnectedToMCP(): boolean;
+    /**
+     * Disconnect from MCP
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get client statistics
+     */
+    getStats(): {
+        sessionId: string;
+        toolCount: number;
+        executionCount: number;
+        isConnected: boolean;
+        uptime: number;
+    };
+    private startTime;
+}
+/**
+ * Create a new MCP client instance
+ */
+export declare function createMCPClient(config: MCPClientConfig): NeuroLinkMCPClient;

package/dist/mcp/client.js

@@ -0,0 +1,245 @@
+/**
+ * NeuroLink MCP Client
+ * Following Lighthouse's pattern for MCP tool registration and execution
+ */
+import { EventEmitter } from "events";
+import { logger } from "../utils/logger.js";
+/**
+ * NeuroLink MCP Client
+ * Manages tool registration and execution following Lighthouse patterns
+ */
+export class NeuroLinkMCPClient extends EventEmitter {
+    tools = new Map();
+    config;
+    executionCount = 0;
+    isConnected = false;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.isConnected = true;
+        logger.info(`[MCP Client] Initialized for session ${config.sessionId}`, {
+            userId: config.userId,
+            aiProvider: config.aiProvider,
+            modelId: config.modelId,
+        });
+    }
+    /**
+     * Register a tool with the MCP client
+     * Following Lighthouse's pattern of namespacing tools with server ID
+     */
+    registerTool(toolName, execute, description, inputSchema) {
+        // Parse server ID from tool name (format: serverId_toolName)
+        const parts = toolName.split("_");
+        const serverId = parts[0];
+        const originalName = parts.slice(1).join("_");
+        // Create registered tool
+        const registeredTool = {
+            name: toolName,
+            originalName,
+            serverId,
+            execute: async (params, context) => {
+                try {
+                    // Call the execute function with Lighthouse-style parameters
+                    const result = await execute(toolName, params);
+                    // Handle different response formats
+                    if (result && typeof result === "object") {
+                        // If it's already in NeuroLink format
+                        if ("success" in result &&
+                            ("data" in result || "error" in result)) {
+                            return result;
+                        }
+                        // If it's in Lighthouse format with content array
+                        if (result.content &&
+                            Array.isArray(result.content) &&
+                            result.content[0]?.text) {
+                            try {
+                                const data = JSON.parse(result.content[0].text);
+                                return {
+                                    success: !result.isError,
+                                    data,
+                                    metadata: {
+                                        toolName,
+                                        serverId,
+                                        sessionId: context.sessionId,
+                                        timestamp: Date.now(),
+                                    },
+                                };
+                            }
+                            catch (parseError) {
+                                // If JSON parsing fails, return the text as-is
+                                return {
+                                    success: !result.isError,
+                                    data: { text: result.content[0].text },
+                                    metadata: {
+                                        toolName,
+                                        serverId,
+                                        sessionId: context.sessionId,
+                                        timestamp: Date.now(),
+                                    },
+                                };
+                            }
+                        }
+                        // If it has a direct text property
+                        if (result.text) {
+                            return {
+                                success: true,
+                                data: { text: result.text },
+                                metadata: {
+                                    toolName,
+                                    serverId,
+                                    sessionId: context.sessionId,
+                                    timestamp: Date.now(),
+                                },
+                            };
+                        }
+                    }
+                    return {
+                        success: false,
+                        error: "Invalid tool response format",
+                    };
+                }
+                catch (error) {
+                    logger.error(`[MCP Client] Tool execution failed: ${toolName}`, error);
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            },
+            description,
+            inputSchema,
+        };
+        // Register the tool
+        this.tools.set(toolName, registeredTool);
+        logger.debug(`[MCP Client] Registered tool: ${toolName}`, {
+            serverId,
+            originalName,
+            description,
+        });
+        // Emit tool registration event
+        this.emit("tool:registered", {
+            toolName,
+            serverId,
+            originalName,
+        });
+    }
+    /**
+     * Get all registered tools
+     */
+    getTools() {
+        const tools = {};
+        for (const [name, tool] of this.tools) {
+            tools[name] = {
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            };
+        }
+        return tools;
+    }
+    /**
+     * Execute a tool by name
+     */
+    async executeTool(toolName, params, context) {
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+            return {
+                success: false,
+                error: `Tool not found: ${toolName}`,
+            };
+        }
+        // Create full context
+        const fullContext = {
+            sessionId: this.config.sessionId,
+            userId: this.config.userId,
+            aiProvider: this.config.aiProvider,
+            modelId: this.config.modelId,
+            timestamp: Date.now(),
+            ...context,
+        };
+        // Track execution
+        this.executionCount++;
+        const executionId = `exec-${this.executionCount}`;
+        // Emit execution start event
+        this.emit("tool:execute:start", {
+            executionId,
+            toolName,
+            serverId: tool.serverId,
+            params,
+        });
+        const startTime = Date.now();
+        try {
+            // Execute the tool
+            const result = await tool.execute(params, fullContext);
+            // Add execution metadata
+            result.metadata = {
+                ...result.metadata,
+                executionId,
+                executionTime: Date.now() - startTime,
+            };
+            // Emit execution complete event
+            this.emit("tool:execute:complete", {
+                executionId,
+                toolName,
+                serverId: tool.serverId,
+                success: result.success,
+                executionTime: result.metadata.executionTime,
+            });
+            return result;
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            // Emit execution error event
+            this.emit("tool:execute:error", {
+                executionId,
+                toolName,
+                serverId: tool.serverId,
+                error: error instanceof Error ? error.message : String(error),
+                executionTime,
+            });
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                metadata: {
+                    executionId,
+                    toolName,
+                    serverId: tool.serverId,
+                    executionTime,
+                },
+            };
+        }
+    }
+    /**
+     * Check if connected to MCP
+     */
+    isConnectedToMCP() {
+        return this.isConnected;
+    }
+    /**
+     * Disconnect from MCP
+     */
+    async disconnect() {
+        this.isConnected = false;
+        this.tools.clear();
+        this.removeAllListeners();
+        logger.info(`[MCP Client] Disconnected for session ${this.config.sessionId}`);
+    }
+    /**
+     * Get client statistics
+     */
+    getStats() {
+        return {
+            sessionId: this.config.sessionId,
+            toolCount: this.tools.size,
+            executionCount: this.executionCount,
+            isConnected: this.isConnected,
+            uptime: Date.now() - (this.startTime || Date.now()),
+        };
+    }
+    startTime = Date.now();
+}
+/**
+ * Create a new MCP client instance
+ */
+export function createMCPClient(config) {
+    return new NeuroLinkMCPClient(config);
+}

package/dist/mcp/config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * NeuroLink MCP Configuration
+ * Central registry for all MCP servers following Lighthouse patterns
+ * Handles built-in servers only - auto-discovery handled by unified registry
+ */
+import type { NeuroLinkMCPServer } from "./factory.js";
+/**
+ * Built-in MCP servers (kept for backward compatibility)
+ * Add new servers here as they are created
+ */
+export declare const allServers: NeuroLinkMCPServer[];
+/**
+ * MCP Configuration following Lighthouse patterns
+ * Handles built-in servers - auto-discovery is handled by unified registry
+ */
+export declare const mcpConfig: {
+    /**
+     * Get list of active built-in MCP servers with implemented tools
+     */
+    getServers: () => Promise<NeuroLinkMCPServer[]>;
+    /**
+     * Get all available tools across all servers
+     */
+    getAllTools: () => Promise<{
+        name: string;
+        description: string;
+        serverId: string;
+        serverTitle: string;
+        category?: string;
+    }[]>;
+};

package/dist/mcp/config.js

@@ -0,0 +1,74 @@
+/**
+ * NeuroLink MCP Configuration
+ * Central registry for all MCP servers following Lighthouse patterns
+ * Handles built-in servers only - auto-discovery handled by unified registry
+ */
+import { aiCoreServer } from "./servers/ai-providers/ai-core-server.js";
+import { utilityServer } from "./servers/utilities/utility-server.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Built-in MCP servers (kept for backward compatibility)
+ * Add new servers here as they are created
+ */
+export const allServers = [
+    aiCoreServer,
+    utilityServer,
+    // Add more servers as they are created
+];
+/**
+ * MCP Configuration following Lighthouse patterns
+ * Handles built-in servers - auto-discovery is handled by unified registry
+ */
+export const mcpConfig = {
+    /**
+     * Get list of active built-in MCP servers with implemented tools
+     */
+    getServers: async () => {
+        const activeServers = [];
+        // Include built-in servers with filtering
+        for (const server of allServers) {
+            const implementedTools = {};
+            let hasImplementedTools = false;
+            for (const toolName in server.tools) {
+                const tool = server.tools[toolName];
+                // Only include tools that are implemented (default to true if not specified)
+                if (tool.isImplemented !== false) {
+                    implementedTools[toolName] = tool;
+                    hasImplementedTools = true;
+                }
+            }
+            // Only include servers that have at least one implemented tool
+            if (hasImplementedTools) {
+                activeServers.push({
+                    ...server,
+                    tools: implementedTools,
+                });
+            }
+        }
+        logger.debug("[MCP Config] Built-in servers:", {
+            total: activeServers.length,
+            serverIds: activeServers.map((s) => s.id),
+        });
+        return activeServers;
+    },
+    /**
+     * Get all available tools across all servers
+     */
+    getAllTools: async () => {
+        const servers = await mcpConfig.getServers();
+        const allTools = [];
+        for (const server of servers) {
+            for (const toolName in server.tools) {
+                const tool = server.tools[toolName];
+                allTools.push({
+                    name: toolName,
+                    description: tool.description,
+                    serverId: server.id,
+                    serverTitle: server.title,
+                    category: tool.category,
+                });
+            }
+        }
+        return allTools;
+    },
+};

package/dist/mcp/context-manager.d.ts

@@ -3,7 +3,7 @@
  * Unified context creation and management for all tool executions
  * Ensures rich context flows through tool chain with session tracking
  */
-import type { NeuroLinkExecutionContext } from './factory.js';
+import type { NeuroLinkExecutionContext } from "./factory.js";
 /**
  * Context creation request interface
  */
@@ -16,10 +16,10 @@ export interface ContextRequest {
     maxTokens?: number;
     organizationId?: string;
     projectId?: string;
-    environmentType?: 'development' | 'staging' | 'production';
-    frameworkType?: 'react' | 'vue' | 'svelte' | 'next' | 'nuxt' | 'sveltekit';
+    environmentType?: "development" | "staging" | "production";
+    frameworkType?: "react" | "vue" | "svelte" | "next" | "nuxt" | "sveltekit";
     permissions?: string[];
-    securityLevel?: 'public' | 'private' | 'organization';
+    securityLevel?: "public" | "private" | "organization";
     [key: string]: any;
 }
 /**

package/dist/mcp/context-manager.js

@@ -32,7 +32,7 @@ export class ContextManager {
             // Business Context (new for MCP)
             organizationId: request.organizationId,
             projectId: request.projectId,
-            environmentType: request.environmentType || 'development',
+            environmentType: request.environmentType || "development",
             // Framework Context (new for MCP)
             frameworkType: request.frameworkType,
             // Tool Execution Context (initialized empty)
@@ -40,9 +40,9 @@ export class ContextManager {
             parentToolId: undefined,
             // Security & Permissions
             permissions: request.permissions || [],
-            securityLevel: request.securityLevel || 'private',
+            securityLevel: request.securityLevel || "private",
             // Copy any additional custom fields
-            ...this.extractCustomFields(request)
+            ...this.extractCustomFields(request),
         };
         // Store context for session management
         this.activeContexts.set(sessionId, context);
@@ -97,7 +97,7 @@ export class ContextManager {
             // Set parent tool reference
             parentToolId: parentContext.toolChain?.[parentContext.toolChain.length - 1],
             // Reset tool chain for child (will be populated as child executes tools)
-            toolChain: []
+            toolChain: [],
         };
         // Store child context
         this.activeContexts.set(childContext.sessionId, childContext);
@@ -159,9 +159,7 @@ export class ContextManager {
         return {
             activeContexts: contexts.length,
             totalSessionsCreated: this.sessionCounter,
-            averageToolChainLength: contexts.length > 0
-                ? totalToolChainLength / contexts.length
-                : 0
+            averageToolChainLength: contexts.length > 0 ? totalToolChainLength / contexts.length : 0,
         };
     }
     /**
@@ -183,9 +181,18 @@ export class ContextManager {
      */
     extractCustomFields(request) {
         const knownFields = new Set([
-            'sessionId', 'userId', 'aiProvider', 'modelId', 'temperature', 'maxTokens',
-            'organizationId', 'projectId', 'environmentType', 'frameworkType',
-            'permissions', 'securityLevel'
+            "sessionId",
+            "userId",
+            "aiProvider",
+            "modelId",
+            "temperature",
+            "maxTokens",
+            "organizationId",
+            "projectId",
+            "environmentType",
+            "frameworkType",
+            "permissions",
+            "securityLevel",
         ]);
         const customFields = {};
         for (const [key, value] of Object.entries(request)) {
@@ -234,23 +241,23 @@ export class ContextValidator {
         const warnings = [];
         // Required field validation
         if (!context.sessionId) {
-            errors.push('sessionId is required');
+            errors.push("sessionId is required");
         }
         // Optional field validation with warnings
         if (!context.environmentType) {
-            warnings.push('environmentType not specified, defaulting to development');
+            warnings.push("environmentType not specified, defaulting to development");
         }
         if (!context.securityLevel) {
-            warnings.push('securityLevel not specified, defaulting to private');
+            warnings.push("securityLevel not specified, defaulting to private");
         }
         // Tool chain validation
         if (context.toolChain && context.toolChain.length > 10) {
-            warnings.push('Tool chain is getting long (>10 tools), consider breaking into smaller workflows');
+            warnings.push("Tool chain is getting long (>10 tools), consider breaking into smaller workflows");
         }
         return {
             isValid: errors.length === 0,
             errors,
-            warnings
+            warnings,
         };
     }
     /**
@@ -266,8 +273,7 @@ export class ContextValidator {
         }
         const contextPermissions = context.permissions || [];
         // Check if context has all required permissions
-        return requiredPermissions.every(permission => contextPermissions.includes(permission) ||
-            contextPermissions.includes('*') // Wildcard permission
-        );
+        return requiredPermissions.every((permission) => contextPermissions.includes(permission) ||
+            contextPermissions.includes("*"));
     }
 }

package/dist/mcp/factory.d.ts

@@ -3,14 +3,14 @@
  * Factory-First Architecture: MCP servers create tools for internal orchestration
  * Compatible with Lighthouse MCP patterns for seamless migration
  */
-import { z } from 'zod';
+import { z } from "zod";
 /**
  * MCP Server Categories for organization and discovery
  */
-export type MCPServerCategory = 'ai-providers' | 'frameworks' | 'development' | 'business' | 'content' | 'data' | 'integrations' | 'automation' | 'analysis' | 'custom';
+export type MCPServerCategory = "ai-providers" | "frameworks" | "development" | "business" | "content" | "data" | "integrations" | "automation" | "analysis" | "custom";
 /**
  * Tool execution context - Rich context passed to every tool execution
- * Based on Lighthouse patterns with NeuroLink enhancements
+ * Following Lighthouse's pattern for rich tool context
  */
 export interface NeuroLinkExecutionContext {
     sessionId: string;
@@ -19,14 +19,30 @@ export interface NeuroLinkExecutionContext {
     modelId?: string;
     temperature?: number;
     maxTokens?: number;
+    appId?: string;
+    clientId?: string;
+    clientVersion?: string;
     organizationId?: string;
     projectId?: string;
-    environmentType?: 'development' | 'staging' | 'production';
-    frameworkType?: 'react' | 'vue' | 'svelte' | 'next' | 'nuxt' | 'sveltekit';
+    environment?: string;
+    environmentType?: "development" | "staging" | "production";
+    platform?: string;
+    device?: string;
+    browser?: string;
+    userAgent?: string;
+    frameworkType?: "react" | "vue" | "svelte" | "next" | "nuxt" | "sveltekit";
     toolChain?: string[];
     parentToolId?: string;
+    locale?: string;
+    timezone?: string;
+    ipAddress?: string;
+    requestId?: string;
+    timestamp?: number;
     permissions?: string[];
-    securityLevel?: 'public' | 'private' | 'organization';
+    features?: string[];
+    enableDemoMode?: boolean;
+    securityLevel?: "public" | "private" | "organization";
+    metadata?: Record<string, any>;
     [key: string]: any;
 }
 /**
@@ -50,6 +66,8 @@ export interface ToolResult {
         sessionId?: string;
         timestamp?: number;
         executionTime?: number;
+        executionId?: string;
+        [key: string]: any;
     };
 }
 /**
@@ -68,8 +86,7 @@ export interface NeuroLinkMCPTool {
     metadata?: Record<string, any>;
 }
 /**
- * MCP Server Interface - 99% Lighthouse compatible
- * Minimal required fields for easy adoption
+ * MCP Server Interface - Lighthouse compatible
  */
 export interface NeuroLinkMCPServer {
     id: string;
@@ -77,9 +94,9 @@ export interface NeuroLinkMCPServer {
     description?: string;
     version?: string;
     category?: MCPServerCategory;
-    visibility?: 'public' | 'private' | 'organization';
+    visibility?: "public" | "private" | "organization";
     tools: Record<string, NeuroLinkMCPTool>;
-    registerTool: (tool: NeuroLinkMCPTool) => NeuroLinkMCPServer;
+    registerTool(tool: NeuroLinkMCPTool): NeuroLinkMCPServer;
     metadata?: Record<string, any>;
     dependencies?: string[];
     capabilities?: string[];
@@ -93,7 +110,7 @@ export interface MCPServerConfig {
     description?: string;
     version?: string;
     category?: MCPServerCategory;
-    visibility?: 'public' | 'private' | 'organization';
+    visibility?: "public" | "private" | "organization";
     metadata?: Record<string, any>;
     dependencies?: string[];
     capabilities?: string[];