@juspay/neurolink 6.0.0 → 6.2.0

package/dist/lib/mcp/client.js

@@ -1,248 +0,0 @@
-/**
- * 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
-                        const lightouseResult = result;
-                        if (lightouseResult.text &&
-                            Array.isArray(lightouseResult.text) &&
-                            lightouseResult.text[0]?.text) {
-                            try {
-                                const data = JSON.parse(lightouseResult.text[0].text);
-                                return {
-                                    success: !lightouseResult.isError,
-                                    data,
-                                    metadata: {
-                                        toolName,
-                                        serverId,
-                                        sessionId: context.sessionId,
-                                        timestamp: Date.now(),
-                                    },
-                                };
-                            }
-                            catch (parseError) {
-                                // If JSON parsing fails, return the text as-is
-                                return {
-                                    success: !lightouseResult.isError,
-                                    data: { text: lightouseResult.text[0].text },
-                                    metadata: {
-                                        toolName,
-                                        serverId,
-                                        sessionId: context.sessionId,
-                                        timestamp: Date.now(),
-                                    },
-                                };
-                            }
-                        }
-                        // If it has a direct text property
-                        const textResult = result;
-                        if (textResult.text) {
-                            return {
-                                success: true,
-                                data: { text: textResult.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 Array.from(this.tools.entries())) {
-            tools[name] = {
-                name: name, // Include the tool name as a property
-                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 using createExecutionContext for proper structure
-        const { createExecutionContext } = await import("./context-manager.js");
-        const fullContext = createExecutionContext({
-            sessionId: this.config.sessionId,
-            userId: this.config.userId,
-            aiProvider: this.config.aiProvider,
-            modelId: this.config.modelId,
-            ...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/lib/mcp/config.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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/lib/mcp/config.js

@@ -1,99 +0,0 @@
-/**
- * NeuroLink MCP Configuration
- * Central registry for all MCP servers following Lighthouse patterns
- * Handles built-in servers only - auto-discovery handled by unified registry
- */
-import { utilityServer } from "./servers/utilities/utility-server.js";
-import { logger } from "../utils/logger.js";
-/**
- * Lazy-loaded AI Core Server to avoid circular dependencies
- */
-let aiCoreServerCache = null;
-async function getAICoreServer() {
-    if (!aiCoreServerCache) {
-        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
-        aiCoreServerCache = aiCoreServer;
-    }
-    return aiCoreServerCache;
-}
-/**
- * Lazy-loaded Direct Tools Server to avoid circular dependencies
- */
-let directToolsServerCache = null;
-async function getDirectToolsServer() {
-    if (!directToolsServerCache) {
-        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
-        directToolsServerCache = directToolsServer;
-    }
-    return directToolsServerCache;
-}
-/**
- * Built-in MCP servers (kept for backward compatibility)
- * Add new servers here as they are created
- */
-export const allServers = [
-    // aiCoreServer will be added dynamically in getServers()
-    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 = [];
-        // Get all servers including dynamically loaded ones
-        const aiCoreServer = await getAICoreServer();
-        const directToolsServer = await getDirectToolsServer();
-        const servers = [aiCoreServer, directToolsServer, ...allServers];
-        // Include built-in servers with filtering
-        for (const server of servers) {
-            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/lib/mcp/context-manager.d.ts

@@ -1,171 +0,0 @@
-/**
- * NeuroLink MCP Context Management System
- * 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";
-/**
- * Context creation request interface
- */
-export interface ContextRequest {
-    sessionId?: string;
-    userId?: string;
-    aiProvider?: string;
-    modelId?: string;
-    temperature?: number;
-    maxTokens?: number;
-    organizationId?: string;
-    projectId?: string;
-    environmentType?: "development" | "staging" | "production";
-    frameworkType?: "react" | "vue" | "svelte" | "next" | "nuxt" | "sveltekit";
-    permissions?: string[];
-    securityLevel?: "public" | "private" | "organization";
-    [key: string]: unknown;
-}
-/**
- * Context manager for creating and managing execution contexts
- * Provides rich context for all tool executions with session tracking
- */
-export declare class ContextManager {
-    private sessionCounter;
-    private activeContexts;
-    private static cachedLogger;
-    /**
-     * Create a new execution context with rich information
-     *
-     * @param request Context creation request with optional fields
-     * @returns Complete execution context ready for tool chain
-     */
-    createContext(request?: ContextRequest): NeuroLinkExecutionContext;
-    /**
-     * Add a tool to the execution chain
-     *
-     * @param context Execution context to modify
-     * @param toolName Name of the tool being executed
-     */
-    addToToolChain(context: NeuroLinkExecutionContext, toolName: string): void;
-    /**
-     * Get the current tool chain for a context
-     *
-     * @param context Execution context
-     * @returns Array of tool names in execution order
-     */
-    getToolChain(context: NeuroLinkExecutionContext): string[];
-    /**
-     * Set parent tool for nested tool execution
-     *
-     * @param context Execution context to modify
-     * @param parentToolId ID of the parent tool
-     */
-    setParentTool(context: NeuroLinkExecutionContext, parentToolId: string): void;
-    /**
-     * Create child context for nested tool execution
-     *
-     * @param parentContext Parent execution context
-     * @param childToolName Name of the child tool
-     * @returns New child context with inherited properties
-     */
-    createChildContext(parentContext: NeuroLinkExecutionContext, childToolName: string): NeuroLinkExecutionContext;
-    /**
-     * Get context by session ID
-     *
-     * @param sessionId Session identifier
-     * @returns Execution context or undefined if not found
-     */
-    getContext(sessionId: string): NeuroLinkExecutionContext | undefined;
-    /**
-     * Update context with new information
-     *
-     * @param sessionId Session identifier
-     * @param updates Partial context updates
-     */
-    updateContext(sessionId: string, updates: Partial<NeuroLinkExecutionContext>): void;
-    /**
-     * Store context directly (used when session ID changes)
-     *
-     * @param context Complete execution context to store
-     */
-    storeContext(context: NeuroLinkExecutionContext): void;
-    /**
-     * Remove context from active tracking
-     *
-     * @param sessionId Session identifier
-     */
-    removeContext(sessionId: string): void;
-    /**
-     * Get all active contexts (for debugging/monitoring)
-     *
-     * @returns Array of all active contexts
-     */
-    getActiveContexts(): NeuroLinkExecutionContext[];
-    /**
-     * Clear all active contexts
-     */
-    clearAllContexts(): void;
-    /**
-     * Get context statistics
-     *
-     * @returns Context usage statistics
-     */
-    getStats(): {
-        activeContexts: number;
-        totalSessionsCreated: number;
-        averageToolChainLength: number;
-    };
-    /**
-     * Generate unique session ID
-     *
-     * @returns Unique session identifier
-     */
-    private generateSessionId;
-    /**
-     * Extract custom fields from request (excluding known fields)
-     *
-     * @param request Context creation request
-     * @returns Custom fields object
-     */
-    private extractCustomFields;
-}
-/**
- * Default context manager instance
- * Can be used across the application for consistent context management
- */
-export declare const defaultContextManager: ContextManager;
-/**
- * Utility function to create context with defaults
- *
- * @param request Optional context request
- * @returns Execution context with sensible defaults
- */
-export declare function createExecutionContext(request?: ContextRequest): NeuroLinkExecutionContext;
-/**
- * Utility function to add tool to default context manager
- *
- * @param context Execution context
- * @param toolName Tool name to add
- */
-export declare function addToolToChain(context: NeuroLinkExecutionContext, toolName: string): void;
-/**
- * Context validation utilities
- */
-export declare class ContextValidator {
-    /**
-     * Validate context has required fields for tool execution
-     *
-     * @param context Execution context to validate
-     * @returns Validation result with details
-     */
-    static validateContext(context: NeuroLinkExecutionContext): {
-        isValid: boolean;
-        errors: string[];
-        warnings: string[];
-    };
-    /**
-     * Validate context permissions for tool execution
-     *
-     * @param context Execution context
-     * @param requiredPermissions Permissions required by tool
-     * @returns Whether context has required permissions
-     */
-    static hasPermissions(context: NeuroLinkExecutionContext, requiredPermissions: string[]): boolean;
-}