@juspay/neurolink 3.0.0 → 4.0.0

package/dist/lib/mcp/registry.js

@@ -1,9 +1,10 @@
 /**
- * MCP Registry - Plugin Registration and Management
+ * MCP Registry - Industry Standard Interface with camelCase
  */
 import { registryLogger } from "./logging.js";
 /**
  * Simple MCP registry for plugin management
+ * Maintains backward compatibility with existing code
  */
 export class MCPRegistry {
     plugins = new Map();
@@ -49,11 +50,84 @@ export class MCPRegistry {
         this.plugins.clear();
         registryLogger.info("Registry cleared");
     }
+    /**
+     * Register a server (compatible with new interface)
+     */
+    async registerServer(serverId, serverConfig, context) {
+        const 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
+                : {},
+        };
+        this.register(plugin);
+    }
+    /**
+     * Execute a tool (mock implementation for tests)
+     */
+    async executeTool(toolName, args, context) {
+        registryLogger.info(`Executing tool: ${toolName}`);
+        return { result: `Mock execution of ${toolName}`, args };
+    }
+    /**
+     * List all tools (compatible with new interface)
+     */
+    async listTools(context) {
+        const tools = this.list().map((plugin) => ({
+            name: plugin.metadata.name,
+            description: plugin.metadata.description || "No description",
+            serverId: plugin.metadata.name,
+            category: "general",
+        }));
+        return tools;
+    }
+    // Legacy methods for backward compatibility
+    /**
+     * Register a server (legacy sync version)
+     */
+    registerServerSync(plugin) {
+        this.register(plugin);
+    }
+    /**
+     * Execute a tool (legacy sync version)
+     */
+    executeToolSync(toolName, args) {
+        registryLogger.info(`Executing tool (sync): ${toolName}`);
+        return { result: `Mock execution of ${toolName}`, args };
+    }
+    /**
+     * List all tools (legacy sync version)
+     */
+    listToolsSync() {
+        const tools = this.list().map((plugin) => ({
+            name: plugin.metadata.name,
+            description: plugin.metadata.description || "No description",
+        }));
+        return tools;
+    }
 }
 /**
- * Default registry instance
+ * Enhanced MCP Registry implementation with config integration
+ * Will be implemented in Phase 3.2
  */
-export const mcpRegistry = new MCPRegistry();
-export const defaultToolRegistry = mcpRegistry;
-// Additional exports for compatibility
-export { mcpRegistry as defaultMCPRegistry };
+export class McpRegistryImpl {
+    baseRegistry = new MCPRegistry();
+    // Additional implementation will be added in Phase 3.2
+    async registerServer(serverId, serverConfig, context) {
+        return this.baseRegistry.registerServer(serverId, serverConfig, context);
+    }
+    async executeTool(toolName, args, context) {
+        return this.baseRegistry.executeTool(toolName, args, context);
+    }
+    async listTools(context) {
+        return this.baseRegistry.listTools(context);
+    }
+}

package/dist/lib/mcp/servers/ai-providers/ai-workflow-tools.js

@@ -5,6 +5,7 @@
 import { z } from "zod";
 import { AIProviderFactory } from "../../../core/factory.js";
 import { getBestProviderSync as getBestProvider } from "../../../utils/providerUtils.js";
+import { DEFAULT_MAX_TOKENS } from "../../../core/constants.js";
 // Tool-specific schemas with comprehensive validation
 const generateTestCasesSchema = z.object({
     codeFunction: z
@@ -145,7 +146,7 @@ Return ONLY a valid JSON object with this exact structure:
 Generate 3-5 comprehensive test cases covering the requested types.`;
             const result = await provider.generateText({
                 prompt,
-                maxTokens: 1200,
+                maxTokens: Math.floor(DEFAULT_MAX_TOKENS * 1.2),
                 temperature: 0.3, // Lower temperature for more consistent structured output
             });
             if (!result || !result.text) {
@@ -251,7 +252,7 @@ Return ONLY a valid JSON object with this exact structure:
 Focus on real, actionable improvements based on the specified objectives.`;
             const result = await provider.generateText({
                 prompt,
-                maxTokens: 1000,
+                maxTokens: DEFAULT_MAX_TOKENS,
                 temperature: 0.2, // Very low temperature for consistent refactoring
             });
             if (!result || !result.text) {
@@ -359,7 +360,7 @@ Return ONLY a valid JSON object with this exact structure:
 Focus on creating accurate, useful documentation that explains the code's purpose, parameters, return values, and usage patterns.`;
             const result = await provider.generateText({
                 prompt,
-                maxTokens: 1200,
+                maxTokens: Math.floor(DEFAULT_MAX_TOKENS * 1.2),
                 temperature: 0.3, // Moderate temperature for creative but structured documentation
             });
             if (!result || !result.text) {
@@ -484,7 +485,7 @@ Return ONLY a valid JSON object with this exact structure:
 Provide thorough, actionable analysis focused on improving AI output quality.`;
             const result = await provider.generateText({
                 prompt,
-                maxTokens: 1000,
+                maxTokens: DEFAULT_MAX_TOKENS,
                 temperature: 0.4, // Moderate temperature for analytical thinking
             });
             if (!result || !result.text) {

package/dist/lib/mcp/tool-integration.js

@@ -93,7 +93,7 @@ export class MCPToolIntegration {
                 results.push({
                     name: toolInfo.name,
                     description: toolInfo.description || "No description available",
-                    serverId: toolInfo.server || "unknown",
+                    serverId: toolInfo.serverId || "unknown",
                     relevance,
                 });
             }

package/dist/lib/mcp/tool-registry.d.ts

@@ -1,40 +1,38 @@
 /**
  * MCP Tool Registry - Extended Registry with Tool Management
+ * Updated to match industry standard camelCase interfaces
  */
-import type { ExecutionContext } from "./contracts/mcp-contract.js";
+import type { ExecutionContext, ToolInfo } from "./contracts/mcpContract.js";
 import type { ToolResult } from "./factory.js";
 import { MCPRegistry } from "./registry.js";
-export interface ToolInfo {
-    id: string;
-    name: string;
-    description?: string;
-    inputSchema?: any;
-    outputSchema?: any;
-    serverId: string;
-    source: "manual" | "auto" | "default";
-    isImplemented?: boolean;
-    server?: string;
-}
 export type ToolExecutionResult = ToolResult;
+/**
+ * Tool execution options
+ */
+export interface ToolExecutionOptions {
+    timeout?: number;
+    retries?: number;
+    context?: ExecutionContext;
+    preferredSource?: string;
+    fallbackEnabled?: boolean;
+    validateBeforeExecution?: boolean;
+    timeoutMs?: number;
+}
 export declare class MCPToolRegistry extends MCPRegistry {
     private tools;
     private toolExecutionStats;
     /**
-     * Register a server with its tools
-     */
-    registerServer(serverId: string, serverInfo: any): Promise<void>;
-    /**
-     * Unregister a server and its tools
+     * Register a server with its tools (updated signature)
      */
-    unregisterServer(serverId: string): Promise<void>;
+    registerServer(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
     /**
-     * Execute a tool
+     * Execute a tool with enhanced context
      */
-    executeTool(toolName: string, args: any, context: ExecutionContext): Promise<ToolExecutionResult>;
+    executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
     /**
-     * List all available tools
+     * List all available tools (updated signature)
      */
-    listTools(): Promise<ToolInfo[]>;
+    listTools(context?: ExecutionContext): Promise<ToolInfo[]>;
     /**
      * Get tool information
      */
@@ -44,23 +42,46 @@ export declare class MCPToolRegistry extends MCPRegistry {
      */
     private updateStats;
     /**
-     * Get tool execution statistics
+     * Get execution statistics
      */
-    getToolStats(toolName?: string): any;
+    getExecutionStats(): Record<string, {
+        count: number;
+        averageTime: number;
+        totalTime: number;
+    }>;
     /**
-     * Get tool execution statistics
+     * Clear execution statistics
      */
-    getStats(): Promise<any>;
+    clearStats(): void;
     /**
-     * Clear all tools and stats
+     * Get tools by category
      */
-    clear(): void;
+    getToolsByCategory(category: string): ToolInfo[];
+    /**
+     * Check if tool exists
+     */
+    hasTool(toolName: string): boolean;
+    /**
+     * Remove a tool
+     */
+    removeTool(toolName: string): boolean;
+    /**
+     * Get tool count
+     */
+    getToolCount(): number;
+    /**
+     * Get statistics (alias for getExecutionStats)
+     */
+    getStats(): Record<string, {
+        count: number;
+        averageTime: number;
+        totalTime: number;
+    }>;
+    /**
+     * Unregister a server
+     */
+    unregisterServer(serverId: string): boolean;
 }
 export declare const toolRegistry: MCPToolRegistry;
 export declare const defaultToolRegistry: MCPToolRegistry;
-export interface ToolExecutionOptions {
-    preferredSource?: string;
-    fallbackEnabled?: boolean;
-    validateBeforeExecution?: boolean;
-    timeoutMs?: number;
-}
+export type { ToolInfo } from "./contracts/mcpContract.js";

package/dist/lib/mcp/tool-registry.js

@@ -1,5 +1,6 @@
 /**
  * MCP Tool Registry - Extended Registry with Tool Management
+ * Updated to match industry standard camelCase interfaces
  */
 import { MCPRegistry } from "./registry.js";
 import { registryLogger } from "./logging.js";
@@ -7,91 +8,74 @@ export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();
     toolExecutionStats = new Map();
     /**
-     * Register a server with its tools
+     * Register a server with its tools (updated signature)
      */
-    async registerServer(serverId, serverInfo) {
+    async registerServer(serverId, serverConfig, context) {
         registryLogger.info(`Registering server: ${serverId}`);
+        // Convert to DiscoveredMcp format for compatibility
+        const 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
+                : {},
+        };
+        // Call the parent register method
+        this.register(plugin);
         // Extract tools from server info if available
-        if (serverInfo.tools) {
-            for (const [toolName, toolDef] of Object.entries(serverInfo.tools)) {
-                const toolId = `${serverId}.${toolName}`;
-                this.tools.set(toolId, {
-                    id: toolId,
-                    name: toolName,
-                    description: toolDef.description,
-                    inputSchema: toolDef.inputSchema,
-                    outputSchema: toolDef.outputSchema,
-                    serverId,
-                    server: serverId, // Backward compatibility alias
-                    source: "manual",
-                    isImplemented: true,
-                });
-            }
-        }
-    }
-    /**
-     * Unregister a server and its tools
-     */
-    async unregisterServer(serverId) {
-        registryLogger.info(`Unregistering server: ${serverId}`);
-        // Remove all tools for this server
-        for (const [toolId, toolInfo] of this.tools) {
-            if (toolInfo.serverId === serverId) {
-                this.tools.delete(toolId);
-                this.toolExecutionStats.delete(toolId);
-            }
+        const tools = plugin.tools || {};
+        for (const [toolName, toolDef] of Object.entries(tools)) {
+            const toolId = `${serverId}.${toolName}`;
+            this.tools.set(toolId, {
+                name: toolName,
+                description: toolDef?.description,
+                inputSchema: toolDef?.inputSchema,
+                outputSchema: toolDef?.outputSchema,
+                serverId,
+                category: toolDef?.category || "general",
+            });
         }
     }
     /**
-     * Execute a tool
+     * Execute a tool with enhanced context
      */
     async executeTool(toolName, args, context) {
         const startTime = Date.now();
         try {
-            const toolInfo = this.getToolInfo(toolName);
-            if (!toolInfo) {
-                throw new Error(`Tool not found: ${toolName}`);
-            }
             registryLogger.info(`Executing tool: ${toolName}`);
-            // Get the plugin that provides this tool
-            const plugin = this.get(toolInfo.serverId);
-            if (!plugin) {
-                throw new Error(`Plugin not found for tool: ${toolName}`);
-            }
-            // Execute through the plugin (stub implementation)
-            const result = {
-                success: true,
-                data: `Tool ${toolInfo.name} executed with args: ${JSON.stringify(args)}`,
+            // Create execution context if not provided
+            const execContext = {
+                sessionId: context?.sessionId || crypto.randomUUID(),
+                userId: context?.userId,
+                ...context,
             };
-            const executionTime = Date.now() - startTime;
-            this.updateStats(toolName, executionTime);
-            return {
-                success: true,
-                data: result,
-                metadata: {
-                    toolName,
-                    executionTime,
-                    timestamp: Date.now(),
-                },
+            // Mock execution for now
+            const result = {
+                result: `Mock execution of ${toolName}`,
+                args,
+                context: execContext,
             };
+            // Update statistics
+            const duration = Date.now() - startTime;
+            this.updateStats(toolName, duration);
+            return result;
         }
         catch (error) {
             registryLogger.error(`Tool execution failed: ${toolName}`, error);
-            return {
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-                metadata: {
-                    toolName,
-                    executionTime: Date.now() - startTime,
-                    timestamp: Date.now(),
-                },
-            };
+            throw error;
         }
     }
     /**
-     * List all available tools
+     * List all available tools (updated signature)
      */
-    async listTools() {
+    async listTools(context) {
         return Array.from(this.tools.values());
     }
     /**
@@ -108,53 +92,83 @@ export class MCPToolRegistry extends MCPRegistry {
             count: 0,
             totalTime: 0,
         };
-        stats.count++;
+        stats.count += 1;
         stats.totalTime += executionTime;
         this.toolExecutionStats.set(toolName, stats);
     }
     /**
-     * Get tool execution statistics
+     * Get execution statistics
      */
-    getToolStats(toolName) {
-        if (toolName) {
-            const stats = this.toolExecutionStats.get(toolName);
-            return stats
-                ? {
-                    ...stats,
-                    averageTime: stats.totalTime / stats.count,
-                }
-                : null;
-        }
-        // Return all stats
-        const allStats = {};
-        for (const [tool, stats] of this.toolExecutionStats) {
-            allStats[tool] = {
-                ...stats,
+    getExecutionStats() {
+        const result = {};
+        for (const [toolName, stats] of this.toolExecutionStats.entries()) {
+            result[toolName] = {
+                count: stats.count,
+                totalTime: stats.totalTime,
                 averageTime: stats.totalTime / stats.count,
             };
         }
-        return allStats;
+        return result;
     }
     /**
-     * Get tool execution statistics
+     * Clear execution statistics
      */
-    async getStats() {
-        const tools = await this.listTools();
-        return {
-            totalTools: tools.length,
-            totalExecutions: Array.from(this.toolExecutionStats.values()).reduce((acc, stats) => acc + stats.count, 0),
-        };
+    clearStats() {
+        this.toolExecutionStats.clear();
     }
     /**
-     * Clear all tools and stats
+     * Get tools by category
      */
-    clear() {
-        super.clear();
-        this.tools.clear();
-        this.toolExecutionStats.clear();
+    getToolsByCategory(category) {
+        return Array.from(this.tools.values()).filter((tool) => tool.category === category);
+    }
+    /**
+     * Check if tool exists
+     */
+    hasTool(toolName) {
+        return this.tools.has(toolName);
+    }
+    /**
+     * Remove a tool
+     */
+    removeTool(toolName) {
+        const removed = this.tools.delete(toolName);
+        if (removed) {
+            this.toolExecutionStats.delete(toolName);
+            registryLogger.info(`Removed tool: ${toolName}`);
+        }
+        return removed;
+    }
+    /**
+     * Get tool count
+     */
+    getToolCount() {
+        return this.tools.size;
+    }
+    /**
+     * Get statistics (alias for getExecutionStats)
+     */
+    getStats() {
+        return this.getExecutionStats();
+    }
+    /**
+     * Unregister a server
+     */
+    unregisterServer(serverId) {
+        // Remove all tools for this server
+        const removedTools = [];
+        for (const [toolId, tool] of this.tools.entries()) {
+            if (tool.serverId === serverId) {
+                this.tools.delete(toolId);
+                removedTools.push(toolId);
+            }
+        }
+        // Remove from parent registry
+        const removed = this.unregister(serverId);
+        registryLogger.info(`Unregistered server ${serverId}, removed ${removedTools.length} tools`);
+        return removed;
     }
 }
-// Export singleton instance
+// Create default instance
 export const toolRegistry = new MCPToolRegistry();
-// Additional exports for backward compatibility
 export const defaultToolRegistry = toolRegistry;

package/dist/lib/mcp/unified-mcp.js

@@ -139,6 +139,11 @@ export class UnifiedMCPSystem {
         const registryStats = await this.registry.getStats();
         const externalStatus = this.externalManager.getStatus();
         const internalToolCount = this.internalServers.reduce((sum, server) => sum + Object.keys(server.tools).length, 0);
+        // Calculate total tools from registry
+        const registryToolCount = this.registry.getToolCount
+            ? this.registry.getToolCount()
+            : 0;
+        const totalTools = internalToolCount + externalStatus.totalTools + registryToolCount;
         return {
             isInitialized: this.isInitialized,
             internalServers: {
@@ -150,7 +155,7 @@ export class UnifiedMCPSystem {
                 connected: externalStatus.connected,
                 tools: externalStatus.totalTools,
             },
-            totalTools: registryStats.totalTools,
+            totalTools,
             registryStats,
         };
     }

package/dist/lib/mcp/unified-registry.d.ts

@@ -3,7 +3,7 @@
  */
 import type { DiscoveredMCP, ExecutionContext } from "./contracts/mcp-contract.js";
 import type { DiscoveryOptions } from "./auto-discovery.js";
-import { MCPToolRegistry, type ToolInfo, type ToolExecutionResult } from "./tool-registry.js";
+import { MCPToolRegistry, type ToolInfo } from "./tool-registry.js";
 /**
  * Unified registry combining multiple sources
  */
@@ -47,7 +47,7 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
     /**
      * Execute a tool through the registry
      */
-    executeTool(toolName: string, args: any, context: ExecutionContext): Promise<ToolExecutionResult>;
+    executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
     /**
      * Lazily activate a server by ID
      */
@@ -57,9 +57,17 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
      */
     registerManualServer(id: string, server: any): void;
     /**
-     * Get registry statistics
+     * Get registry statistics (override parent method)
      */
-    getStats(): Promise<{
+    getStats(): Record<string, {
+        count: number;
+        averageTime: number;
+        totalTime: number;
+    }>;
+    /**
+     * Get detailed registry statistics
+     */
+    getDetailedStats(): Promise<{
         total: number;
         bySource: Record<string, number>;
         byType: Record<string, number>;

package/dist/lib/mcp/unified-registry.js

@@ -78,7 +78,12 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
             try {
                 // Get tools from plugin metadata if available
                 const tools = await this.listTools();
-                allTools.push(...tools);
+                allTools.push(...tools.map((tool) => ({
+                    ...tool,
+                    id: tool.name,
+                    serverId: tool.serverId || plugin.metadata.name,
+                    source: "unified",
+                })));
             }
             catch (error) {
                 unifiedRegistryLogger.warn(`Failed to get tools from ${plugin.metadata.name}:`, error);
@@ -124,14 +129,22 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
         this.availableServers.add(id);
     }
     /**
-     * Get registry statistics
+     * Get registry statistics (override parent method)
      */
-    async getStats() {
+    getStats() {
+        // Return execution stats in the expected format
+        return super.getStats();
+    }
+    /**
+     * Get detailed registry statistics
+     */
+    async getDetailedStats() {
         const plugins = this.list();
         const bySource = {};
         const byType = {};
         for (const plugin of plugins) {
-            bySource[plugin.source] = (bySource[plugin.source] || 0) + 1;
+            const source = plugin.source || "unknown";
+            bySource[source] = (bySource[source] || 0) + 1;
             // Extract type from name or metadata
             const type = plugin.metadata.name.split("/")[1]?.split("-")[0] || "unknown";
             byType[type] = (byType[type] || 0) + 1;