@juspay/neurolink 6.1.0 → 6.2.1

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/logging.d.ts

@@ -1,38 +0,0 @@
-/**
- * MCP Logging Utility
- * Centralized logging for the MCP ecosystem
- */
-export type LogLevel = "debug" | "info" | "warn" | "error";
-interface LogEntry {
-    level: LogLevel;
-    message: string;
-    timestamp: Date;
-    data?: unknown;
-}
-declare class MCPLogger {
-    private logLevel;
-    private logs;
-    private maxLogs;
-    constructor();
-    setLogLevel(level: LogLevel): void;
-    private shouldLog;
-    private log;
-    debug(message: string, data?: unknown): void;
-    info(message: string, data?: unknown): void;
-    warn(message: string, data?: unknown): void;
-    error(message: string, data?: unknown): void;
-    getLogs(level?: LogLevel): LogEntry[];
-    clearLogs(): void;
-}
-export declare const mcpLogger: MCPLogger;
-export declare const autoDiscoveryLogger: MCPLogger;
-export declare const registryLogger: MCPLogger;
-export declare const unifiedRegistryLogger: MCPLogger;
-export declare function setGlobalMCPLogLevel(level: LogLevel): void;
-export declare const LogLevels: {
-    readonly debug: "debug";
-    readonly info: "info";
-    readonly warn: "warn";
-    readonly error: "error";
-};
-export {};

package/dist/mcp/logging.js

@@ -1,100 +0,0 @@
-/**
- * MCP Logging Utility
- * Centralized logging for the MCP ecosystem
- */
-class MCPLogger {
-    logLevel = "info";
-    logs = [];
-    maxLogs = 1000;
-    constructor() {
-        // Set log level from environment
-        const envLevel = process.env.MCP_LOG_LEVEL?.toLowerCase();
-        if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
-            this.logLevel = envLevel;
-        }
-    }
-    setLogLevel(level) {
-        this.logLevel = level;
-    }
-    shouldLog(level) {
-        // CRITICAL: Respect CLI debug flag - hide all logs except errors unless debugging
-        const isDebugMode = process.argv.includes("--debug");
-        if (!isDebugMode && level !== "error") {
-            return false;
-        }
-        const levels = ["debug", "info", "warn", "error"];
-        return levels.indexOf(level) >= levels.indexOf(this.logLevel);
-    }
-    log(level, message, data) {
-        if (!this.shouldLog(level)) {
-            return;
-        }
-        const entry = {
-            level,
-            message,
-            timestamp: new Date(),
-            data,
-        };
-        // Store log entry
-        this.logs.push(entry);
-        // Trim old logs
-        if (this.logs.length > this.maxLogs) {
-            this.logs = this.logs.slice(-this.maxLogs);
-        }
-        // Console output
-        const timestamp = entry.timestamp.toISOString();
-        const prefix = `[${timestamp}] [MCP:${level.toUpperCase()}]`;
-        switch (level) {
-            case "debug":
-                console.debug(prefix, message, data ? data : "");
-                break;
-            case "info":
-                console.info(prefix, message, data ? data : "");
-                break;
-            case "warn":
-                console.warn(prefix, message, data ? data : "");
-                break;
-            case "error":
-                console.error(prefix, message, data ? data : "");
-                break;
-        }
-    }
-    debug(message, data) {
-        this.log("debug", message, data);
-    }
-    info(message, data) {
-        this.log("info", message, data);
-    }
-    warn(message, data) {
-        this.log("warn", message, data);
-    }
-    error(message, data) {
-        this.log("error", message, data);
-    }
-    getLogs(level) {
-        if (level) {
-            return this.logs.filter((log) => log.level === level);
-        }
-        return [...this.logs];
-    }
-    clearLogs() {
-        this.logs = [];
-    }
-}
-// Export singleton instance
-export const mcpLogger = new MCPLogger();
-// Additional logger instances for different modules
-export const autoDiscoveryLogger = mcpLogger;
-export const registryLogger = mcpLogger;
-export const unifiedRegistryLogger = mcpLogger;
-// Global log level setter
-export function setGlobalMCPLogLevel(level) {
-    mcpLogger.setLogLevel(level);
-}
-// Export LogLevel enum for runtime use
-export const LogLevels = {
-    debug: "debug",
-    info: "info",
-    warn: "warn",
-    error: "error",
-};

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 };