@juspay/neurolink 6.0.0 → 6.2.0

package/dist/mcp/initialize-tools.js

@@ -1,262 +0,0 @@
-/**
- * NeuroLink MCP Tool Initialization
- * Following Lighthouse's pattern for registering MCP server tools with the client
- */
-import { mcpConfig } from "./config.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { z } from "zod";
-import { logger } from "../utils/logger.js";
-/**
- * Sanitize tool name for compatibility
- * Following Lighthouse's pattern of ensuring valid tool names
- */
-const sanitizeToolName = (name) => {
-    return name.replace(/[^a-zA-Z0-9_-]/g, "_");
-};
-/**
- * Check if a schema is a Zod schema
- */
-const isZodSchema = (schema) => {
-    if (typeof schema !== "object" || schema === null) {
-        return false;
-    }
-    return "_def" in schema || "parse" in schema;
-};
-/**
- * Initialize and register tools from MCP Servers with the MCP client
- * Following Lighthouse's pattern for tool registration
- */
-export const initializeMCPTools = async (sessionId, client, context) => {
-    try {
-        logger.info(`[MCP Tools] Initializing tools for session: ${sessionId}`);
-        // Get all registered servers
-        const servers = await mcpConfig.getServers();
-        if (!servers || servers.length === 0) {
-            logger.warn("[MCP Tools] No MCP servers found to register tools from");
-            return;
-        }
-        let totalToolsRegistered = 0;
-        // Process each server
-        servers.forEach((server) => {
-            if (!server || !server.id || !server.tools) {
-                logger.warn(`[MCP Tools] Skipping invalid server configuration: ${JSON.stringify(server)}`);
-                return;
-            }
-            const serverId = server.id;
-            logger.info(`[MCP Tools] Registering tools from server: ${serverId}`);
-            // Process each tool in the server
-            Object.entries(server.tools).forEach(([originalToolName, tool]) => {
-                if (!tool || typeof tool.execute !== "function") {
-                    logger.warn(`[MCP Tools] Skipping invalid tool definition for ${originalToolName} in server ${serverId}`);
-                    return;
-                }
-                // Create namespaced tool name (serverId_toolName)
-                let finalToolName = originalToolName;
-                const prefix = `${serverId}_`;
-                const maxToolNameLength = 64 - prefix.length;
-                // Truncate if necessary
-                if (finalToolName.length > maxToolNameLength) {
-                    finalToolName = finalToolName.substring(0, maxToolNameLength);
-                    logger.info(`[MCP Tools] Truncated tool name: ${originalToolName} -> ${finalToolName}`);
-                }
-                // Sanitize and combine
-                const namespacedToolName = sanitizeToolName(`${prefix}${finalToolName}`);
-                // Validate final length
-                if (namespacedToolName.length > 64) {
-                    logger.warn(`[MCP Tools] Tool name too long after sanitization: ${namespacedToolName}. Skipping.`);
-                    return;
-                }
-                // Prepare description
-                const description = tool.description ||
-                    `Tool ${originalToolName} from server ${serverId}`;
-                // Convert schema if needed
-                let schemaForClient = undefined;
-                if (tool.inputSchema) {
-                    if (isZodSchema(tool.inputSchema)) {
-                        try {
-                            const jsonSchemaOutput = zodToJsonSchema(tool.inputSchema);
-                            if (typeof jsonSchemaOutput === "object" &&
-                                jsonSchemaOutput !== null &&
-                                "type" in jsonSchemaOutput &&
-                                jsonSchemaOutput.type === "object") {
-                                schemaForClient = jsonSchemaOutput;
-                            }
-                            else {
-                                logger.warn(`[MCP Tools] Converted schema for ${originalToolName} is not a root object type`);
-                            }
-                        }
-                        catch (schemaError) {
-                            logger.error(`[MCP Tools] Error converting Zod schema for tool ${originalToolName}: ${schemaError}`);
-                        }
-                    }
-                    else if (typeof tool.inputSchema === "object" &&
-                        tool.inputSchema !== null) {
-                        if (tool.inputSchema.type === "object") {
-                            schemaForClient = tool.inputSchema;
-                        }
-                        else {
-                            logger.warn(`[MCP Tools] Input schema for ${originalToolName} is not type 'object'`);
-                        }
-                    }
-                }
-                try {
-                    // Register tool with client
-                    client.registerTool(namespacedToolName, async (_name, input) => {
-                        // Execute the tool with full context
-                        const result = await tool.execute(input, context);
-                        // Convert to Lighthouse-style response
-                        if (result.success) {
-                            return {
-                                content: [{ text: JSON.stringify(result.data ?? {}) }],
-                            };
-                        }
-                        else {
-                            return {
-                                content: [
-                                    { text: `Error: ${result.error || "Unknown error"}` },
-                                ],
-                                isError: true,
-                            };
-                        }
-                    }, description, schemaForClient);
-                    logger.debug(`[MCP Tools] Registered tool: ${namespacedToolName}`, {
-                        serverId,
-                        originalToolName,
-                    });
-                    totalToolsRegistered++;
-                }
-                catch (registrationError) {
-                    logger.error(`[MCP Tools] Failed to register tool ${originalToolName} from server ${serverId}: ${registrationError}`);
-                }
-            });
-        });
-        logger.info(`[MCP Tools] Successfully registered ${totalToolsRegistered} tools for session: ${sessionId}`);
-    }
-    catch (error) {
-        logger.error(`[MCP Tools] Error during tool initialization for session ${sessionId}: ${error}`);
-    }
-};
-/**
- * Get all available tools across all servers
- * Useful for documentation and discovery
- */
-export async function getAllAvailableTools(inMemoryServers) {
-    const tools = [];
-    // Add in-memory server tools first
-    if (inMemoryServers) {
-        for (const [serverId, serverConfig] of inMemoryServers) {
-            const server = serverConfig.server;
-            if (server &&
-                typeof server === "object" &&
-                "tools" in server &&
-                server.tools) {
-                // Handle both Map and object formats
-                const toolEntries = server.tools instanceof Map
-                    ? Array.from(server.tools.entries())
-                    : Object.entries(server.tools || {});
-                for (const [toolName, toolInfo] of toolEntries) {
-                    const prefix = `${serverId}_`;
-                    const finalToolName = toolName.length > 64 - prefix.length
-                        ? toolName.substring(0, 64 - prefix.length)
-                        : toolName;
-                    const namespacedName = sanitizeToolName(`${prefix}${finalToolName}`);
-                    // Handle different tool info structures
-                    let description = `Tool from ${serverId}`;
-                    let isImplemented = true;
-                    if (toolInfo) {
-                        // Check if it's a tool info object with description
-                        if (typeof toolInfo.description === "string") {
-                            description = toolInfo.description;
-                        }
-                        else if (typeof toolInfo === "function") {
-                            // It's a raw function, no description available
-                            description = `${toolName} from ${serverId}`;
-                        }
-                        // Check implementation status
-                        if (typeof toolInfo.isImplemented === "boolean") {
-                            isImplemented = toolInfo.isImplemented;
-                        }
-                    }
-                    tools.push({
-                        serverId,
-                        serverTitle: typeof server === "object" &&
-                            server &&
-                            "title" in server &&
-                            typeof server.title === "string"
-                            ? server.title
-                            : serverId,
-                        toolName,
-                        namespacedName,
-                        description,
-                        isImplemented,
-                    });
-                }
-            }
-        }
-    }
-    const servers = await mcpConfig.getServers();
-    servers.forEach((server) => {
-        Object.entries(server.tools).forEach(([toolName, tool]) => {
-            const prefix = `${server.id}_`;
-            const finalToolName = toolName.length > 64 - prefix.length
-                ? toolName.substring(0, 64 - prefix.length)
-                : toolName;
-            const namespacedName = sanitizeToolName(`${prefix}${finalToolName}`);
-            tools.push({
-                serverId: server.id,
-                serverTitle: server.title,
-                toolName,
-                namespacedName,
-                description: tool.description || "",
-                isImplemented: tool.isImplemented !== false,
-            });
-        });
-    });
-    return tools;
-}
-/**
- * Initialize tools for a specific server only
- * Useful for selective tool registration
- */
-export async function initializeServerTools(serverId, client, context) {
-    const servers = await mcpConfig.getServers();
-    const server = servers.find((s) => s.id === serverId);
-    if (!server) {
-        logger.warn(`[MCP Tools] Server not found: ${serverId}`);
-        return 0;
-    }
-    let toolsRegistered = 0;
-    Object.entries(server.tools).forEach(([toolName, tool]) => {
-        if (!tool || typeof tool.execute !== "function") {
-            return;
-        }
-        const prefix = `${serverId}_`;
-        const finalToolName = toolName.length > 64 - prefix.length
-            ? toolName.substring(0, 64 - prefix.length)
-            : toolName;
-        const namespacedToolName = sanitizeToolName(`${prefix}${finalToolName}`);
-        if (namespacedToolName.length > 64) {
-            return;
-        }
-        try {
-            client.registerTool(namespacedToolName, async (_name, input) => {
-                const result = await tool.execute(input, context);
-                if (result.success) {
-                    return { content: [{ text: JSON.stringify(result.data ?? {}) }] };
-                }
-                else {
-                    return {
-                        content: [{ text: `Error: ${result.error || "Unknown error"}` }],
-                        isError: true,
-                    };
-                }
-            }, tool.description || `Tool ${toolName} from server ${serverId}`, tool.inputSchema);
-            toolsRegistered++;
-        }
-        catch (error) {
-            logger.error(`[MCP Tools] Failed to register tool ${toolName}: ${error}`);
-        }
-    });
-    logger.info(`[MCP Tools] Registered ${toolsRegistered} tools from server ${serverId}`);
-    return toolsRegistered;
-}

package/dist/mcp/initialize.d.ts

@@ -1,18 +0,0 @@
-/**
- * NeuroLink MCP Initialization System
- * Automatically registers built-in NeuroLink servers with the default registry
- * Ensures built-in tools are always available without manual configuration
- */
-import { type MCPToolRegistry } from "./tool-registry.js";
-/**
- * Initialize NeuroLink MCP system by registering built-in servers
- */
-export declare function initializeNeuroLinkMCP(targetRegistry?: MCPToolRegistry): Promise<void>;
-/**
- * Get initialization status
- */
-export declare function isNeuroLinkMCPInitialized(): boolean;
-/**
- * Reset initialization status (for testing)
- */
-export declare function resetInitialization(): void;

package/dist/mcp/initialize.js

@@ -1,62 +0,0 @@
-/**
- * NeuroLink MCP Initialization System
- * Automatically registers built-in NeuroLink servers with the default registry
- * Ensures built-in tools are always available without manual configuration
- */
-import { toolRegistry, defaultToolRegistry, } from "./tool-registry.js";
-import { mcpLogger } from "./logging.js";
-import { ServiceRegistry } from "../core/service-registry.js";
-let isInitialized = false;
-/**
- * Initialize NeuroLink MCP system by registering built-in servers
- */
-export async function initializeNeuroLinkMCP(targetRegistry) {
-    if (isInitialized) {
-        return;
-    }
-    mcpLogger.debug("Initializing built-in MCP servers...");
-    try {
-        // First, register AIProviderFactory in ServiceRegistry to break circular dependencies
-        ServiceRegistry.register("AIProviderFactory", async () => {
-            const { AIProviderFactory } = await import("../core/factory.js");
-            return AIProviderFactory;
-        });
-        mcpLogger.debug("Registered AIProviderFactory in ServiceRegistry");
-        // Import utility server dynamically to avoid circular dependencies
-        const { utilityServer } = await import("./servers/utilities/utility-server.js");
-        // Register built-in NeuroLink servers with specified registry (or default)
-        const registry = targetRegistry || toolRegistry;
-        await registry.registerServer(utilityServer.id, utilityServer);
-        mcpLogger.debug(`Registered neurolink-utility server with built-in tools in ${targetRegistry ? "target" : "default"} registry`);
-        // Now safe to import and register AI core server
-        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
-        await registry.registerServer(aiCoreServer.id, aiCoreServer);
-        mcpLogger.debug("Registered neurolink-ai-core server with AI tools");
-        // Register direct tools server
-        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
-        await registry.registerServer(directToolsServer.id, directToolsServer);
-        mcpLogger.debug("Registered neurolink-direct server with direct tools");
-        const stats = await registry.getStats();
-        mcpLogger.info(`Initialization complete: ${stats.totalServers} servers, ${stats.totalTools} tools available`);
-        isInitialized = true;
-    }
-    catch (error) {
-        mcpLogger.error("Failed to initialize built-in servers:", error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
-/**
- * Get initialization status
- */
-export function isNeuroLinkMCPInitialized() {
-    return isInitialized;
-}
-/**
- * Reset initialization status (for testing)
- */
-export function resetInitialization() {
-    isInitialized = false;
-    defaultToolRegistry.clear();
-}
-// Note: Auto-initialization removed to prevent circular dependencies
-// Call initializeNeuroLinkMCP() explicitly where needed

package/dist/mcp/manager.d.ts

@@ -1,68 +0,0 @@
-/**
- * NeuroLink MCP Manager
- * Manages MCP client instances following Lighthouse's session-based pattern
- */
-import { NeuroLinkMCPClient } from "./client.js";
-import type { MCPClientConfig } from "./client.js";
-import type { UnknownRecord } from "../types/common.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, UnknownRecord>;
-    };
-    /**
-     * 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/mcp/manager.js

@@ -1,176 +0,0 @@
-/**
- * NeuroLink MCP Manager
- * Manages MCP client instances following Lighthouse's session-based pattern
- */
-import { NeuroLinkMCPClient, 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/mcp/neurolink-mcp-client.d.ts

@@ -1,97 +0,0 @@
-/**
- * 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, {
-        name: 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 {};