@juspay/neurolink 7.14.0 → 7.14.2

package/dist/mcp/toolDiscoveryService.js

@@ -11,6 +11,7 @@ import { globalCircuitBreakerManager, } from "./mcpCircuitBreaker.js";
  * Handles automatic tool discovery and registration from external MCP servers
  */
 export class ToolDiscoveryService extends EventEmitter {
+    serverToolStorage = new Map();
     toolRegistry = new Map();
     serverTools = new Map();
     discoveryInProgress = new Set();
@@ -126,7 +127,19 @@ export class ToolDiscoveryService extends EventEmitter {
                 // Register the tool
                 const toolKey = this.createToolKey(serverId, tool.name);
                 this.toolRegistry.set(toolKey, toolInfo);
-                // Track server tools
+                if (!this.serverToolStorage.has(serverId)) {
+                    this.serverToolStorage.set(serverId, []);
+                }
+                const serverTools = this.serverToolStorage.get(serverId);
+                // Add tool if not already present
+                if (!serverTools.find((t) => t.name === tool.name)) {
+                    serverTools.push({
+                        name: tool.name,
+                        description: tool.description || "",
+                        inputSchema: tool.inputSchema,
+                    });
+                }
+                // Track server tools (legacy)
                 if (!this.serverTools.has(serverId)) {
                     this.serverTools.set(serverId, new Set());
                 }
@@ -475,6 +488,24 @@ export class ToolDiscoveryService extends EventEmitter {
      * Get all tools for a server
      */
     getServerTools(serverId) {
+        const serverTools = this.serverToolStorage.get(serverId);
+        if (serverTools) {
+            return serverTools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                serverId,
+                inputSchema: tool.inputSchema,
+                isAvailable: true,
+                stats: {
+                    totalCalls: 0,
+                    successfulCalls: 0,
+                    failedCalls: 0,
+                    averageExecutionTime: 0,
+                    lastExecutionTime: 0,
+                },
+            }));
+        }
+        // Fallback to legacy storage
         const tools = [];
         const serverToolNames = this.serverTools.get(serverId);
         if (serverToolNames) {
@@ -492,23 +523,60 @@ export class ToolDiscoveryService extends EventEmitter {
      * Get all registered tools
      */
     getAllTools() {
-        return Array.from(this.toolRegistry.values());
+        const allTools = [];
+        // Add tools from server-based storage (preferred)
+        for (const [serverId, serverTools] of this.serverToolStorage.entries()) {
+            for (const tool of serverTools) {
+                allTools.push({
+                    name: tool.name,
+                    description: tool.description,
+                    serverId,
+                    inputSchema: tool.inputSchema,
+                    isAvailable: true,
+                    stats: {
+                        totalCalls: 0,
+                        successfulCalls: 0,
+                        failedCalls: 0,
+                        averageExecutionTime: 0,
+                        lastExecutionTime: 0,
+                    },
+                });
+            }
+        }
+        // Fallback to legacy storage for any tools not in server-based storage
+        const legacyTools = Array.from(this.toolRegistry.values()).filter((tool) => !allTools.some((t) => t.name === tool.name && t.serverId === tool.serverId));
+        return [...allTools, ...legacyTools];
     }
     /**
      * Clear tools for a server
      */
     clearServerTools(serverId) {
+        const serverTools = this.serverToolStorage.get(serverId);
+        if (serverTools) {
+            // Emit unregistered events for server-based tools
+            for (const tool of serverTools) {
+                this.emit("toolUnregistered", {
+                    serverId,
+                    toolName: tool.name,
+                    timestamp: new Date(),
+                });
+            }
+            this.serverToolStorage.delete(serverId);
+        }
+        // Legacy cleanup
         const serverToolNames = this.serverTools.get(serverId);
         if (serverToolNames) {
             for (const toolName of serverToolNames) {
                 const toolKey = this.createToolKey(serverId, toolName);
                 this.toolRegistry.delete(toolKey);
-                // Emit tool unregistered event
-                this.emit("toolUnregistered", {
-                    serverId,
-                    toolName,
-                    timestamp: new Date(),
-                });
+                // Emit tool unregistered event (only if not already emitted above)
+                if (!serverTools || !serverTools.find((t) => t.name === toolName)) {
+                    this.emit("toolUnregistered", {
+                        serverId,
+                        toolName,
+                        timestamp: new Date(),
+                    });
+                }
             }
             this.serverTools.delete(serverId);
         }

package/dist/mcp/toolRegistry.d.ts

@@ -4,6 +4,7 @@
  */
 import type { ExecutionContext, ToolInfo } from "./contracts/mcpContract.js";
 import type { ToolResult } from "./factory.js";
+import type { MCPServerInfo } from "../types/mcpTypes.js";
 import { MCPRegistry } from "./registry.js";
 interface ToolImplementation {
     execute: (params: unknown, context?: ExecutionContext) => Promise<unknown> | unknown;
@@ -13,15 +14,6 @@ interface ToolImplementation {
     category?: string;
     permissions?: string[];
 }
-interface ServerRegistration {
-    id?: string;
-    serverId?: string;
-    description?: string;
-    title?: string;
-    category?: string;
-    tools?: Record<string, ToolImplementation>;
-    configuration?: Record<string, unknown>;
-}
 export type ToolExecutionResult = ToolResult;
 /**
  * Tool execution options
@@ -39,15 +31,17 @@ export declare class MCPToolRegistry extends MCPRegistry {
     private tools;
     private toolImpls;
     private toolExecutionStats;
+    private builtInServerInfos;
     constructor();
     /**
      * Register all direct tools from directAgentTools
      */
     private registerDirectTools;
     /**
-     * Register a server with its tools (updated signature)
+     * Register a server with its tools - ONLY accepts MCPServerInfo (zero conversions)
      */
-    registerServer(serverOrId: string | ServerRegistration, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
+    registerServer(serverInfo: MCPServerInfo, context?: ExecutionContext): Promise<void>;
+    registerServer(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
     /**
      * Execute a tool with enhanced context
      */
@@ -89,6 +83,11 @@ export declare class MCPToolRegistry extends MCPRegistry {
      * Clear execution statistics
      */
     clearStats(): void;
+    /**
+     * Get built-in servers
+     * @returns Array of MCPServerInfo for built-in tools
+     */
+    getBuiltInServerInfos(): MCPServerInfo[];
     /**
      * Get tools by category
      */
@@ -97,6 +96,11 @@ export declare class MCPToolRegistry extends MCPRegistry {
      * Check if tool exists
      */
     hasTool(toolName: string): boolean;
+    /**
+     * Register a tool with implementation directly
+     * This is used for external MCP server tools
+     */
+    registerTool(toolId: string, toolInfo: ToolInfo, toolImpl: ToolImplementation): void;
     /**
      * Remove a tool
      */

package/dist/mcp/toolRegistry.js

@@ -7,10 +7,12 @@ import { registryLogger } from "../utils/logger.js";
 import { randomUUID } from "crypto";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { directAgentTools } from "../agent/directTools.js";
+import { detectCategory, createMCPServerInfo } from "../utils/mcpDefaults.js";
 export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();
     toolImpls = new Map(); // Store actual tool implementations
     toolExecutionStats = new Map();
+    builtInServerInfos = []; // DIRECT storage for MCPServerInfo
     constructor() {
         super();
         // 🔧 CONDITIONAL: Only auto-register direct tools if not disabled via configuration
@@ -33,7 +35,7 @@ export class MCPToolRegistry extends MCPRegistry {
                 description: toolDef.description || `Direct tool: ${toolName}`,
                 inputSchema: {},
                 serverId: "direct",
-                category: "built-in",
+                category: detectCategory({ isBuiltIn: true, serverId: "direct" }),
             };
             this.tools.set(toolId, toolInfo);
             this.toolImpls.set(toolId, {
@@ -75,69 +77,109 @@ export class MCPToolRegistry extends MCPRegistry {
         }
         registryLogger.debug(`Auto-registered ${Object.keys(directAgentTools).length} direct tools`);
     }
-    /**
-     * Register a server with its tools (updated signature)
-     */
-    async registerServer(serverOrId, serverConfig, context) {
-        let serverId;
-        let plugin;
-        if (typeof serverOrId === "string") {
-            // Original behavior: register by ID and config
-            serverId = serverOrId;
-            registryLogger.info(`Registering server by ID: ${serverId}`);
-            plugin = {
-                metadata: {
-                    name: serverId,
-                    description: typeof serverConfig === "object" && serverConfig
-                        ? serverConfig.description ||
-                            "No description"
-                        : "No description",
-                },
-                tools: typeof serverConfig === "object" && serverConfig
-                    ? serverConfig.tools
-                    : {},
-                configuration: typeof serverConfig === "object" && serverConfig
-                    ? serverConfig
-                    : {},
-            };
+    async registerServer(serverInfoOrId, serverConfigOrContext, context) {
+        // Handle both signatures for backward compatibility
+        let serverInfo;
+        let finalContext;
+        if (typeof serverInfoOrId === "string") {
+            // Legacy signature: registerServer(serverId, serverConfig, context)
+            const serverId = serverInfoOrId;
+            finalContext = context;
+            // Convert legacy call to MCPServerInfo format using smart defaults
+            serverInfo = createMCPServerInfo({
+                id: serverId,
+                name: serverId,
+                tools: [],
+                isExternal: true,
+            });
         }
         else {
-            // New behavior: register server object
-            const server = serverOrId;
-            serverId = String(server.id || server.serverId || "unknown-server");
-            registryLogger.info(`Registering server object: ${serverId}`);
-            plugin = {
-                metadata: {
-                    name: serverId,
-                    description: String(server.description || server.title || "No description"),
-                    category: String(server.category || ""),
-                },
-                tools: server.tools || {},
-                configuration: server.configuration ||
-                    {},
+            // New signature: registerServer(serverInfo, context)
+            serverInfo = serverInfoOrId;
+            finalContext = serverConfigOrContext;
+        }
+        const serverId = serverInfo.id;
+        registryLogger.info(`Registering MCPServerInfo directly: ${serverId}`);
+        // Use MCPServerInfo.tools array directly - ZERO conversions!
+        const toolsObject = {};
+        for (const tool of serverInfo.tools) {
+            toolsObject[tool.name] = {
+                execute: tool.execute ||
+                    (async () => {
+                        throw new Error(`Tool ${tool.name} has no execute function`);
+                    }),
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                category: detectCategory({
+                    existingCategory: serverInfo.metadata?.category,
+                    serverId: serverInfo.id,
+                }),
             };
         }
+        const plugin = {
+            metadata: {
+                name: serverInfo.name,
+                description: serverInfo.description,
+                category: detectCategory({
+                    existingCategory: serverInfo.metadata?.category,
+                    serverId: serverInfo.id,
+                }),
+            },
+            tools: toolsObject,
+            configuration: {},
+        };
         // Call the parent register method
         this.register(plugin);
-        // Extract tools from server info if available
-        const tools = plugin.tools || {};
-        registryLogger.debug(`Registering ${Object.keys(tools).length} tools for server ${serverId}:`, Object.keys(tools));
-        for (const [toolName, toolDef] of Object.entries(tools)) {
-            const toolId = `${serverId}.${toolName}`;
+        // Use MCPServerInfo.tools array directly - ZERO conversions!
+        const tools = serverInfo.tools;
+        registryLogger.debug(`Registering ${tools.length} tools for server ${serverId}:`, tools.map((t) => t.name));
+        for (const tool of tools) {
+            // For custom tools, use just the tool name to avoid redundant serverId.toolName format
+            // For other tools, use fully-qualified serverId.toolName to avoid collisions
+            const isCustomTool = serverId.startsWith("custom-tool-");
+            const toolId = isCustomTool ? tool.name : `${serverId}.${tool.name}`;
             const toolInfo = {
-                name: toolName,
-                description: toolDef?.description,
-                inputSchema: toolDef?.inputSchema,
-                outputSchema: toolDef?.outputSchema,
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                outputSchema: undefined, // MCPServerInfo.tools doesn't have outputSchema
                 serverId,
-                category: toolDef?.category || "general",
-                permissions: toolDef?.permissions || [],
+                category: detectCategory({
+                    existingCategory: serverInfo.metadata?.category,
+                    serverId: serverInfo.id,
+                }),
+                permissions: [], // MCPServerInfo.tools doesn't have permissions
             };
             // Register only with fully-qualified toolId to avoid collisions
             this.tools.set(toolId, toolInfo);
             // Store the actual tool implementation for execution using toolId as key
-            this.toolImpls.set(toolId, toolDef);
-            registryLogger.debug(`Registered tool '${toolName}' with execute function:`, typeof toolDef?.execute);
+            this.toolImpls.set(toolId, {
+                execute: tool.execute ||
+                    (async () => {
+                        throw new Error(`Tool ${tool.name} has no execute function`);
+                    }),
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                category: detectCategory({
+                    existingCategory: serverInfo.metadata?.category,
+                    serverId: serverInfo.id,
+                }),
+            });
+            registryLogger.debug(`Registered tool '${tool.name}' with execute function:`, typeof tool.execute);
+        }
+        // Store MCPServerInfo directly - NO recreation needed!
+        if (tools.length > 0) {
+            const category = detectCategory({
+                existingCategory: serverInfo.metadata?.category,
+                serverId: serverInfo.id,
+            });
+            // Only store in builtInServerInfos if it's a real in-memory MCP server
+            // Do NOT create fake servers for built-in direct tools
+            if (category === "in-memory") {
+                // Use the original MCPServerInfo directly - ZERO conversions!
+                this.builtInServerInfos.push(serverInfo);
+                registryLogger.debug(`Added ${category} server to builtInServerInfos: ${serverId} with ${tools.length} tools`);
+            }
         }
     }
     /**
@@ -323,6 +365,13 @@ export class MCPToolRegistry extends MCPRegistry {
     clearStats() {
         this.toolExecutionStats.clear();
     }
+    /**
+     * Get built-in servers
+     * @returns Array of MCPServerInfo for built-in tools
+     */
+    getBuiltInServerInfos() {
+        return this.builtInServerInfos;
+    }
     /**
      * Get tools by category
      */
@@ -340,7 +389,7 @@ export class MCPToolRegistry extends MCPRegistry {
      * Check if tool exists
      */
     hasTool(toolName) {
-        // Check by fully-qualified name first, then fallback to any matching tool name
+        // Check by fully-qualified name first, then fallback to first matching tool name
         if (this.tools.has(toolName)) {
             return true;
         }
@@ -351,11 +400,21 @@ export class MCPToolRegistry extends MCPRegistry {
         }
         return false;
     }
+    /**
+     * Register a tool with implementation directly
+     * This is used for external MCP server tools
+     */
+    registerTool(toolId, toolInfo, toolImpl) {
+        registryLogger.debug(`Registering tool: ${toolId}`);
+        this.tools.set(toolId, toolInfo);
+        this.toolImpls.set(toolId, toolImpl);
+        registryLogger.debug(`Successfully registered tool: ${toolId}`);
+    }
     /**
      * Remove a tool
      */
     removeTool(toolName) {
-        // Remove by fully-qualified name first, then fallback to any matching tool name
+        // Remove by fully-qualified name first, then fallback to first matching tool name
         let removed = false;
         if (this.tools.has(toolName)) {
             this.tools.delete(toolName);
@@ -420,9 +479,13 @@ export class MCPToolRegistry extends MCPRegistry {
                 removedTools.push(toolId);
             }
         }
+        // Remove from builtInServerInfos storage
+        const originalLength = this.builtInServerInfos.length;
+        this.builtInServerInfos = this.builtInServerInfos.filter((server) => server.id !== serverId);
+        const removedFromBuiltIn = originalLength > this.builtInServerInfos.length;
         // Remove from parent registry
         const removed = this.unregister(serverId);
-        registryLogger.info(`Unregistered server ${serverId}, removed ${removedTools.length} tools`);
+        registryLogger.info(`Unregistered server ${serverId}, removed ${removedTools.length} tools${removedFromBuiltIn ? " and server from builtInServerInfos" : ""}`);
         return removed;
     }
 }

package/dist/models/modelResolver.js

@@ -294,7 +294,7 @@ export class ModelResolver {
         }
         // Base relevance score
         if (score === 0) {
-            score = 1; // Minimal relevance for any model
+            score = 1; // Minimal relevance for model
             matchReasons.push("Basic match");
         }
         return { model, score, matchReasons };

package/dist/neurolink.d.ts

@@ -8,11 +8,10 @@
 import type { TextGenerationOptions, TextGenerationResult } from "./core/types.js";
 import type { GenerateOptions, GenerateResult } from "./types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
-import type { SimpleTool } from "./sdk/toolRegistration.js";
-import type { InMemoryMCPServerConfig } from "./types/mcpTypes.js";
+import type { MCPServerInfo, MCPExecutableTool } from "./types/mcpTypes.js";
 import { EventEmitter } from "events";
 import type { ConversationMemoryConfig } from "./types/conversationTypes.js";
-import type { ExternalMCPServerConfig, ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
+import type { ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
 export interface ProviderStatus {
     provider: string;
     status: "working" | "failed" | "not-configured";
@@ -38,21 +37,12 @@ export interface MCPStatus {
     error?: string;
     [key: string]: unknown;
 }
-export interface MCPServerInfo {
-    id: string;
-    name: string;
-    source: string;
-    status: "connected" | "discovered" | "failed";
-    hasServer: boolean;
-    metadata?: unknown;
-}
 import type { ContextManagerConfig } from "./context/types.js";
 export declare class NeuroLink {
     private mcpInitialized;
     private emitter;
     private contextManager;
-    private customTools;
-    private inMemoryServers;
+    private autoDiscoveredServerInfos;
     private externalServerManager;
     private toolCircuitBreakers;
     private toolExecutionMetrics;
@@ -148,19 +138,19 @@ export declare class NeuroLink {
     /**
      * Register a custom tool that will be available to all AI providers
      * @param name - Unique name for the tool
-     * @param tool - Tool configuration
+     * @param tool - Tool in MCPExecutableTool format (unified MCP protocol type)
      */
-    registerTool(name: string, tool: SimpleTool): void;
+    registerTool(name: string, tool: MCPExecutableTool): void;
     /**
      * Register multiple tools at once - Supports both object and array formats
-     * @param tools - Object mapping tool names to configurations OR Array of tools with names
+     * @param tools - Object mapping tool names to MCPExecutableTool format OR Array of tools with names
      *
-     * Object format (existing): { toolName: SimpleTool, ... }
-     * Array format (Lighthouse compatible): [{ name: string, tool: SimpleTool }, ...]
+     * Object format (existing): { toolName: MCPExecutableTool, ... }
+     * Array format (Lighthouse compatible): [{ name: string, tool: MCPExecutableTool }, ...]
      */
-    registerTools(tools: Record<string, SimpleTool> | Array<{
+    registerTools(tools: Record<string, MCPExecutableTool> | Array<{
         name: string;
-        tool: SimpleTool;
+        tool: MCPExecutableTool;
     }>): void;
     /**
      * Unregister a custom tool
@@ -170,21 +160,32 @@ export declare class NeuroLink {
     unregisterTool(name: string): boolean;
     /**
      * Get all registered custom tools
-     * @returns Map of tool names to configurations
+     * @returns Map of tool names to MCPExecutableTool format
      */
-    getCustomTools(): Map<string, SimpleTool>;
+    getCustomTools(): Map<string, MCPExecutableTool>;
     /**
      * Add an in-memory MCP server (from git diff)
      * Allows registration of pre-instantiated server objects
      * @param serverId - Unique identifier for the server
-     * @param config - Server configuration
+     * @param serverInfo - Server configuration
      */
-    addInMemoryMCPServer(serverId: string, config: InMemoryMCPServerConfig): Promise<void>;
+    addInMemoryMCPServer(serverId: string, serverInfo: MCPServerInfo): Promise<void>;
     /**
      * Get all registered in-memory servers
-     * @returns Map of server IDs to configurations
+     * @returns Map of server IDs to MCPServerInfo
+     */
+    getInMemoryServers(): Map<string, MCPServerInfo>;
+    /**
+     * Get in-memory servers as MCPServerInfo - ZERO conversion needed
+     * Now fetches from centralized tool registry instead of local duplication
+     * @returns Array of MCPServerInfo
      */
-    getInMemoryServers(): Map<string, InMemoryMCPServerConfig>;
+    getInMemoryServerInfos(): MCPServerInfo[];
+    /**
+     * Get auto-discovered servers as MCPServerInfo - ZERO conversion needed
+     * @returns Array of MCPServerInfo
+     */
+    getAutoDiscoveredServerInfos(): MCPServerInfo[];
     /**
      * Execute a specific tool by name with robust error handling
      * Supports both custom tools and MCP server tools with timeout, retry, and circuit breaker patterns
@@ -360,7 +361,7 @@ export declare class NeuroLink {
      * Get comprehensive tool health report
      * @returns Detailed health report for all tools
      */
-    getToolHealthReport(): {
+    getToolHealthReport(): Promise<{
         totalTools: number;
         healthyTools: number;
         unhealthyTools: number;
@@ -380,7 +381,7 @@ export declare class NeuroLink {
             issues: string[];
             recommendations: string[];
         }>;
-    };
+    }>;
     /**
      * Get conversation memory statistics (public API)
      */
@@ -400,7 +401,7 @@ export declare class NeuroLink {
      * @param config - External MCP server configuration
      * @returns Operation result with server instance
      */
-    addExternalMCPServer(serverId: string, config: ExternalMCPServerConfig): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
+    addExternalMCPServer(serverId: string, config: MCPServerInfo): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
     /**
      * Remove an external MCP server
      * Stops the server and removes all its tools
@@ -418,7 +419,7 @@ export declare class NeuroLink {
         toolCount: number;
         uptime: number;
         isHealthy: boolean;
-        config: ExternalMCPServerConfig;
+        config: MCPServerInfo;
     }>;
     /**
      * Get external MCP server status
@@ -453,7 +454,7 @@ export declare class NeuroLink {
      * @param config - Server configuration to test
      * @returns Test result with connection status
      */
-    testExternalMCPConnection(config: ExternalMCPServerConfig): Promise<{
+    testExternalMCPConnection(config: MCPServerInfo): Promise<{
         success: boolean;
         error?: string;
         toolCount?: number;