@juspay/neurolink 7.13.0 → 7.14.1

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,10 +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 { ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
 export interface ProviderStatus {
     provider: string;
     status: "working" | "failed" | "not-configured";
@@ -30,24 +30,20 @@ export interface MCPStatus {
     autoDiscoveredServers: MCPServerInfo[];
     customToolsCount: number;
     inMemoryServersCount: number;
+    externalMCPServersCount?: number;
+    externalMCPConnectedCount?: number;
+    externalMCPFailedCount?: number;
+    externalMCPServers?: MCPServerInfo[];
     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;
     /**
@@ -142,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
@@ -164,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
@@ -200,22 +207,7 @@ export declare class NeuroLink {
      * Get all available tools including custom and in-memory ones
      * @returns Array of available tools with metadata
      */
-    getAllAvailableTools(): Promise<({
-        toolName: string;
-        serverId: string | undefined;
-        name: string;
-        description?: string;
-        category?: string;
-        inputSchema?: Record<string, unknown>;
-        outputSchema?: Record<string, unknown>;
-    } | {
-        name: string;
-        toolName: string;
-        description: string;
-        serverId: string;
-        category: string;
-        inputSchema: {};
-    })[]>;
+    getAllAvailableTools(): Promise<any[]>;
     /**
      * Get comprehensive status of all AI providers
      * Primary method for provider health checking and diagnostics
@@ -369,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;
@@ -389,7 +381,7 @@ export declare class NeuroLink {
             issues: string[];
             recommendations: string[];
         }>;
-    };
+    }>;
     /**
      * Get conversation memory statistics (public API)
      */
@@ -402,6 +394,110 @@ export declare class NeuroLink {
      * Clear all conversation history (public API)
      */
     clearAllConversations(): Promise<void>;
+    /**
+     * Add an external MCP server
+     * Automatically discovers and registers tools from the server
+     * @param serverId - Unique identifier for the server
+     * @param config - External MCP server configuration
+     * @returns Operation result with server instance
+     */
+    addExternalMCPServer(serverId: string, config: MCPServerInfo): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
+    /**
+     * Remove an external MCP server
+     * Stops the server and removes all its tools
+     * @param serverId - ID of the server to remove
+     * @returns Operation result
+     */
+    removeExternalMCPServer(serverId: string): Promise<ExternalMCPOperationResult<void>>;
+    /**
+     * List all external MCP servers
+     * @returns Array of server health information
+     */
+    listExternalMCPServers(): Array<{
+        serverId: string;
+        status: string;
+        toolCount: number;
+        uptime: number;
+        isHealthy: boolean;
+        config: MCPServerInfo;
+    }>;
+    /**
+     * Get external MCP server status
+     * @param serverId - ID of the server
+     * @returns Server instance or undefined if not found
+     */
+    getExternalMCPServer(serverId: string): ExternalMCPServerInstance | undefined;
+    /**
+     * Execute a tool from an external MCP server
+     * @param serverId - ID of the server
+     * @param toolName - Name of the tool
+     * @param parameters - Tool parameters
+     * @param options - Execution options
+     * @returns Tool execution result
+     */
+    executeExternalMCPTool(serverId: string, toolName: string, parameters: Record<string, any>, options?: {
+        timeout?: number;
+    }): Promise<any>;
+    /**
+     * Get all tools from external MCP servers
+     * @returns Array of external tool information
+     */
+    getExternalMCPTools(): ExternalMCPToolInfo[];
+    /**
+     * Get tools from a specific external MCP server
+     * @param serverId - ID of the server
+     * @returns Array of tool information for the server
+     */
+    getExternalMCPServerTools(serverId: string): ExternalMCPToolInfo[];
+    /**
+     * Test connection to an external MCP server
+     * @param config - Server configuration to test
+     * @returns Test result with connection status
+     */
+    testExternalMCPConnection(config: MCPServerInfo): Promise<{
+        success: boolean;
+        error?: string;
+        toolCount?: number;
+    }>;
+    /**
+     * Get external MCP server manager statistics
+     * @returns Statistics about external servers and tools
+     */
+    getExternalMCPStatistics(): {
+        totalServers: number;
+        connectedServers: number;
+        failedServers: number;
+        totalTools: number;
+        totalConnections: number;
+        totalErrors: number;
+    };
+    /**
+     * Shutdown all external MCP servers
+     * Called automatically on process exit
+     */
+    shutdownExternalMCPServers(): Promise<void>;
+    /**
+     * Convert external MCP tools to Vercel AI SDK tool format
+     * This allows AI providers to use external tools directly
+     */
+    private convertExternalMCPToolsToAISDKFormat;
+    /**
+     * Convert JSON Schema to AI SDK compatible format
+     * For now, we'll skip schema validation and let the AI SDK handle parameters dynamically
+     */
+    private convertJSONSchemaToAISDKFormat;
+    /**
+     * Unregister external MCP tools from a specific server
+     */
+    private unregisterExternalMCPToolsFromRegistry;
+    /**
+     * Unregister a specific external MCP tool from the main registry
+     */
+    private unregisterExternalMCPToolFromRegistry;
+    /**
+     * Unregister all external MCP tools from the main registry
+     */
+    private unregisterAllExternalMCPToolsFromRegistry;
 }
 export declare const neurolink: NeuroLink;
 export default neurolink;