@juspay/neurolink 7.29.1 → 7.29.3

package/dist/mcp/toolRegistry.js

@@ -8,9 +8,10 @@ import { randomUUID } from "crypto";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { directAgentTools } from "../agent/directTools.js";
 import { detectCategory, createMCPServerInfo } from "../utils/mcpDefaults.js";
+import { FlexibleToolValidator } from "./flexibleToolValidator.js";
 export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();
-    toolImpls = new Map(); // Store actual tool implementations
+    toolImplementations = new Map(); // Store actual tool implementations
     toolExecutionStats = new Map();
     builtInServerInfos = []; // DIRECT storage for MCPServerInfo
     constructor() {
@@ -38,7 +39,7 @@ export class MCPToolRegistry extends MCPRegistry {
                 category: detectCategory({ isBuiltIn: true, serverId: "direct" }),
             };
             this.tools.set(toolId, toolInfo);
-            this.toolImpls.set(toolId, {
+            this.toolImplementations.set(toolId, {
                 execute: async (params, context) => {
                     try {
                         // Direct tools from AI SDK expect their specific parameter structure
@@ -80,11 +81,11 @@ export class MCPToolRegistry extends MCPRegistry {
     async registerServer(serverInfoOrId, serverConfigOrContext, context) {
         // Handle both signatures for backward compatibility
         let serverInfo;
-        let finalContext;
+        let _finalContext;
         if (typeof serverInfoOrId === "string") {
             // Legacy signature: registerServer(serverId, serverConfig, context)
             const serverId = serverInfoOrId;
-            finalContext = context;
+            _finalContext = context;
             // Convert legacy call to MCPServerInfo format using smart defaults
             serverInfo = createMCPServerInfo({
                 id: serverId,
@@ -96,7 +97,7 @@ export class MCPToolRegistry extends MCPRegistry {
         else {
             // New signature: registerServer(serverInfo, context)
             serverInfo = serverInfoOrId;
-            finalContext = serverConfigOrContext;
+            _finalContext = serverConfigOrContext;
         }
         const serverId = serverInfo.id;
         registryLogger.info(`Registering MCPServerInfo directly: ${serverId}`);
@@ -153,7 +154,7 @@ export class MCPToolRegistry extends MCPRegistry {
             // 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, {
+            this.toolImplementations.set(toolId, {
                 execute: tool.execute ||
                     (async () => {
                         throw new Error(`Tool ${tool.name} has no execute function`);
@@ -234,9 +235,9 @@ export class MCPToolRegistry extends MCPRegistry {
                 ...context,
             };
             // Get the tool implementation using the resolved toolId
-            const toolImpl = this.toolImpls.get(toolId);
+            const toolImpl = this.toolImplementations.get(toolId);
             registryLogger.debug(`Looking for tool '${toolName}' (toolId: '${toolId}'), found: ${!!toolImpl}, type: ${typeof toolImpl?.execute}`);
-            registryLogger.debug(`Available tools:`, Array.from(this.toolImpls.keys()));
+            registryLogger.debug(`Available tools:`, Array.from(this.toolImplementations.keys()));
             if (!toolImpl || typeof toolImpl?.execute !== "function") {
                 throw new Error(`Tool '${toolName}' implementation not found or not executable`);
             }
@@ -347,7 +348,7 @@ export class MCPToolRegistry extends MCPRegistry {
             if (filter.permissions && filter.permissions.length > 0) {
                 result = result.filter((tool) => {
                     const toolPermissions = tool.permissions || [];
-                    return filter.permissions.some((perm) => toolPermissions.includes(perm));
+                    return (filter.permissions?.some((perm) => toolPermissions.includes(perm)) ?? false);
                 });
             }
         }
@@ -450,55 +451,25 @@ export class MCPToolRegistry extends MCPRegistry {
      * Register a tool with implementation directly
      * This is used for external MCP server tools
      */
-    registerTool(toolId, toolInfo, toolImpl) {
+    async registerTool(toolId, toolInfo, toolImpl) {
         registryLogger.debug(`Registering tool: ${toolId}`);
-        // Import validation functions synchronously - they are pure functions
-        let validateTool;
-        let isToolNameAvailable;
-        let suggestToolNames;
-        try {
-            // Try ES module import first
-            const toolRegistrationModule = require("../sdk/toolRegistration.js");
-            ({ validateTool, isToolNameAvailable, suggestToolNames } =
-                toolRegistrationModule);
-        }
-        catch (error) {
-            // Fallback: skip validation if import fails (graceful degradation)
-            registryLogger.warn("Tool validation module not available, skipping advanced validation", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            // Create minimal validation functions
-            validateTool = () => { }; // No-op
-            isToolNameAvailable = () => true; // Allow all names
-            suggestToolNames = () => ["alternative_tool"];
-        }
-        // Check if tool name is available (not reserved)
-        if (!isToolNameAvailable(toolId)) {
-            const suggestions = suggestToolNames(toolId);
-            registryLogger.error(`Tool registration failed for ${toolId}: Name not available`);
-            throw new Error(`Tool name '${toolId}' is not available (reserved or invalid format). ` +
-                `Suggested alternatives: ${suggestions.slice(0, 3).join(", ")}`);
+        // Universal safety validation using FlexibleToolValidator
+        // Only blocks truly dangerous cases to support maximum MCP tool compatibility
+        const validation = FlexibleToolValidator.validateToolInfo(toolId, {
+            description: toolInfo.description,
+            serverId: toolInfo.serverId,
+        });
+        if (!validation.isValid) {
+            registryLogger.error(`Tool registration failed for ${toolId}: ${validation.error}`);
+            throw new Error(`Tool validation failed: ${validation.error}`);
         }
-        // Create a simplified tool object for validation
-        const toolForValidation = {
-            description: toolInfo.description || "",
-            execute: async () => "",
-            parameters: undefined,
-            metadata: {
-                category: toolInfo.category,
-                serverId: toolInfo.serverId,
-            },
-        };
-        // Use comprehensive validation logic
-        try {
-            validateTool(toolId, toolForValidation);
-        }
-        catch (error) {
-            registryLogger.error(`Tool registration failed for ${toolId}:`, error instanceof Error ? error.message : String(error));
-            throw error;
+        // Log any warnings but allow registration to proceed
+        if (validation.warnings && validation.warnings.length > 0) {
+            registryLogger.warn(`Tool registration warnings for ${toolId}:`, validation.warnings);
         }
+        registryLogger.debug(`✅ Tool '${toolId}' passed flexible validation - registration proceeding`);
         this.tools.set(toolId, toolInfo);
-        this.toolImpls.set(toolId, toolImpl);
+        this.toolImplementations.set(toolId, toolImpl);
         registryLogger.debug(`Successfully registered tool: ${toolId}`);
     }
     /**
@@ -509,6 +480,7 @@ export class MCPToolRegistry extends MCPRegistry {
         let removed = false;
         if (this.tools.has(toolName)) {
             this.tools.delete(toolName);
+            this.toolImplementations.delete(toolName); // Fix memory leak
             this.toolExecutionStats.delete(toolName);
             registryLogger.info(`Removed tool: ${toolName}`);
             removed = true;
@@ -518,6 +490,7 @@ export class MCPToolRegistry extends MCPRegistry {
             for (const [toolId, tool] of Array.from(this.tools.entries())) {
                 if (tool.name === toolName) {
                     this.tools.delete(toolId);
+                    this.toolImplementations.delete(toolId); // Fix memory leak
                     this.toolExecutionStats.delete(toolId);
                     registryLogger.info(`Removed tool: ${toolId}`);
                     removed = true;
@@ -567,6 +540,8 @@ export class MCPToolRegistry extends MCPRegistry {
         for (const [toolId, tool] of this.tools.entries()) {
             if (tool.serverId === serverId) {
                 this.tools.delete(toolId);
+                this.toolImplementations.delete(toolId); // Fix memory leak
+                this.toolExecutionStats.delete(toolId); // Fix memory leak
                 removedTools.push(toolId);
             }
         }

package/dist/middleware/builtin/analytics.js

@@ -30,10 +30,10 @@ export function createAnalyticsMiddleware() {
                     responseTime,
                     timestamp: new Date().toISOString(),
                     usage: {
-                        inputTokens: result.usage?.promptTokens || 0,
-                        outputTokens: result.usage?.completionTokens || 0,
-                        totalTokens: (result.usage?.promptTokens || 0) +
-                            (result.usage?.completionTokens || 0),
+                        input: result.usage?.promptTokens ?? 0,
+                        output: result.usage?.completionTokens ?? 0,
+                        total: (result.usage?.promptTokens ?? 0) +
+                            (result.usage?.completionTokens ?? 0),
                     },
                 };
                 // Store metrics for potential retrieval

package/dist/middleware/builtin/guardrails.js

@@ -13,7 +13,7 @@ export function createGuardrailsMiddleware(config = {}) {
         defaultEnabled: true,
     };
     const middleware = {
-        wrapGenerate: async ({ doGenerate, params }) => {
+        wrapGenerate: async ({ doGenerate, params: _params }) => {
             logger.debug(`[GuardrailsMiddleware] Applying to generate call.`, {
                 badWordsEnabled: !!config.badWords?.enabled,
                 modelFilterEnabled: !!config.modelFilter?.enabled,
@@ -53,7 +53,7 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             return result;
         },
-        wrapStream: async ({ doStream, params }) => {
+        wrapStream: async ({ doStream, params: _params }) => {
             logger.debug(`[GuardrailsMiddleware] Applying to stream call.`, {
                 badWordsEnabled: !!config.badWords?.enabled,
             });

package/dist/middleware/registry.js

@@ -135,9 +135,9 @@ export class MiddlewareRegistry {
     /**
      * Configure middleware with runtime configuration
      */
-    configureMiddleware(middleware, config, globalConfig, context) {
+    configureMiddleware(middleware, config, globalConfig, _context) {
         // Merge configurations: global < middleware config < runtime config
-        const mergedConfig = {
+        const _mergedConfig = {
             ...globalConfig,
             ...config?.config,
         };
@@ -149,6 +149,9 @@ export class MiddlewareRegistry {
             wrappedMiddleware.transformParams = async (args) => {
                 const startTime = Date.now();
                 try {
+                    if (!middleware.transformParams) {
+                        throw new Error("transformParams method is required");
+                    }
                     const result = await middleware.transformParams(args);
                     this.recordExecution(middleware.metadata.id, startTime, true);
                     return result;
@@ -163,6 +166,9 @@ export class MiddlewareRegistry {
             wrappedMiddleware.wrapGenerate = async (args) => {
                 const startTime = Date.now();
                 try {
+                    if (!middleware.wrapGenerate) {
+                        throw new Error("wrapGenerate method is required");
+                    }
                     const result = await middleware.wrapGenerate(args);
                     this.recordExecution(middleware.metadata.id, startTime, true);
                     return result;
@@ -177,6 +183,9 @@ export class MiddlewareRegistry {
             wrappedMiddleware.wrapStream = async (args) => {
                 const startTime = Date.now();
                 try {
+                    if (!middleware.wrapStream) {
+                        throw new Error("wrapStream method is required");
+                    }
                     const result = await middleware.wrapStream(args);
                     this.recordExecution(middleware.metadata.id, startTime, true);
                     return result;

package/dist/models/modelRegistry.d.ts

@@ -125,7 +125,7 @@ export declare function getAvailableProviders(): AIProviderName[];
 /**
  * Calculate estimated cost for a request
  */
-export declare function calculateCost(model: ModelInfo, inputTokens: number, outputTokens: number): number;
+export declare function calculateCost(model: ModelInfo, input: number, output: number): number;
 /**
  * Format model for display
  */

package/dist/models/modelRegistry.js

@@ -445,9 +445,9 @@ export function getAvailableProviders() {
 /**
  * Calculate estimated cost for a request
  */
-export function calculateCost(model, inputTokens, outputTokens) {
-    const inputCost = (inputTokens / 1000) * model.pricing.inputCostPer1K;
-    const outputCost = (outputTokens / 1000) * model.pricing.outputCostPer1K;
+export function calculateCost(model, input, output) {
+    const inputCost = (input / 1000) * model.pricing.inputCostPer1K;
+    const outputCost = (output / 1000) * model.pricing.outputCostPer1K;
     return inputCost + outputCost;
 }
 /**

package/dist/models/modelResolver.d.ts

@@ -76,7 +76,7 @@ export declare class ModelResolver {
     /**
      * Calculate cost comparison for models
      */
-    static calculateCostComparison(models: ModelInfo[], inputTokens?: number, outputTokens?: number): Array<{
+    static calculateCostComparison(models: ModelInfo[], input?: number, output?: number): Array<{
         model: ModelInfo;
         cost: number;
         costPer1K: number;

package/dist/models/modelResolver.js

@@ -160,11 +160,11 @@ export class ModelResolver {
     /**
      * Calculate cost comparison for models
      */
-    static calculateCostComparison(models, inputTokens = 1000, outputTokens = 500) {
+    static calculateCostComparison(models, input = 1000, output = 500) {
         return models
             .map((model) => ({
             model,
-            cost: calculateCost(model, inputTokens, outputTokens),
+            cost: calculateCost(model, input, output),
             costPer1K: model.pricing.inputCostPer1K + model.pricing.outputCostPer1K,
         }))
             .sort((a, b) => a.cost - b.cost);

package/dist/neurolink.d.ts

@@ -54,6 +54,8 @@ export declare class NeuroLink {
      * @param toolName - Name of the tool
      * @param startTime - Timestamp when tool execution started
      * @param success - Whether the tool execution was successful
+     * @param result - The result of the tool execution (optional)
+     * @param error - The error if execution failed (optional)
      */
     private emitToolEndEvent;
     private conversationMemory?;
@@ -88,11 +90,71 @@ export declare class NeuroLink {
     constructor(config?: {
         conversationMemory?: Partial<ConversationMemoryConfig>;
     });
+    /**
+     * Log constructor start with comprehensive environment analysis
+     */
+    private logConstructorStart;
+    /**
+     * Initialize provider registry with security settings
+     */
+    private initializeProviderRegistry;
+    /**
+     * Initialize conversation memory if enabled
+     */
+    private initializeConversationMemory;
+    /**
+     * Initialize external server manager with event handlers
+     */
+    private initializeExternalServerManager;
+    /**
+     * Setup event handlers for external server manager
+     */
+    private setupExternalServerEventHandlers;
+    /**
+     * Log constructor completion with final state summary
+     */
+    private logConstructorComplete;
     /**
      * Initialize MCP registry with enhanced error handling and resource cleanup
      * Uses isolated async context to prevent hanging
      */
     private initializeMCP;
+    /**
+     * Log MCP initialization start
+     */
+    private logMCPInitStart;
+    /**
+     * Log MCP already initialized
+     */
+    private logMCPAlreadyInitialized;
+    /**
+     * Import performance manager with error handling
+     */
+    private importPerformanceManager;
+    /**
+     * Perform main MCP initialization logic
+     */
+    private performMCPInitialization;
+    /**
+     * Initialize tool registry with timeout protection
+     */
+    private initializeToolRegistryInternal;
+    /**
+     * Initialize provider registry
+     */
+    private initializeProviderRegistryInternal;
+    /**
+     * Register direct tools server
+     */
+    private registerDirectToolsServerInternal;
+    /**
+     * Load MCP configuration from .mcp-config.json
+     */
+    private loadMCPConfigurationInternal;
+    /**
+     * Log MCP initialization completion
+     */
+    private logMCPInitComplete;
     /**
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods
@@ -177,6 +239,26 @@ export declare class NeuroLink {
      * 5. Store conversation turn for future context
      */
     private generateTextInternal;
+    /**
+     * Log generateTextInternal start with comprehensive analysis
+     */
+    private logGenerateTextInternalStart;
+    /**
+     * Emit generation start events
+     */
+    private emitGenerationStartEvents;
+    /**
+     * Initialize conversation memory for generation
+     */
+    private initializeConversationMemoryForGeneration;
+    /**
+     * Attempt MCP generation with retry logic
+     */
+    private attemptMCPGeneration;
+    /**
+     * Perform MCP generation with retry logic
+     */
+    private performMCPGenerationRetries;
     /**
      * Try MCP-enhanced generation (no fallback recursion)
      */
@@ -255,6 +337,42 @@ export declare class NeuroLink {
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     stream(options: StreamOptions): Promise<StreamResult>;
+    /**
+     * Log stream entry point with comprehensive analysis
+     */
+    private logStreamEntryPoint;
+    /**
+     * Log performance baseline
+     */
+    private logPerformanceBaseline;
+    /**
+     * Validate stream input with comprehensive error reporting
+     */
+    private validateStreamInput;
+    /**
+     * Emit stream start events
+     */
+    private emitStreamStartEvents;
+    /**
+     * Create MCP stream
+     */
+    private createMCPStream;
+    /**
+     * Process stream result
+     */
+    private processStreamResult;
+    /**
+     * Emit stream end events
+     */
+    private emitStreamEndEvents;
+    /**
+     * Create stream response
+     */
+    private createStreamResponse;
+    /**
+     * Handle stream error with fallback
+     */
+    private handleStreamError;
     /**
      * Get the EventEmitter instance to listen to NeuroLink events for real-time monitoring and debugging.
      * This method provides access to the internal event system that emits events during AI generation,