@juspay/neurolink 7.29.2 → 7.30.0

package/dist/mcp/servers/aiProviders/aiAnalysisTools.js

@@ -78,7 +78,7 @@ const OptimizeParametersSchema = z.object({
  * AI Usage Analysis Tool
  * Analyzes AI usage patterns, token consumption, and cost optimization opportunities
  */
-const analyzeAIUsageTool = {
+const _analyzeAIUsageTool = {
     name: "analyze-ai-usage",
     description: "Analyze AI usage patterns, token consumption, and cost optimization opportunities",
     category: "ai-analysis",
@@ -163,7 +163,7 @@ const analyzeAIUsageTool = {
  * Provider Performance Benchmarking Tool
  * Benchmarks AI provider performance across latency, quality, and cost metrics
  */
-const benchmarkProviderPerformanceTool = {
+const _benchmarkProviderPerformanceTool = {
     name: "benchmark-provider-performance",
     description: "Benchmark AI provider performance across latency, quality, and cost metrics",
     category: "ai-analysis",
@@ -199,7 +199,7 @@ const benchmarkProviderPerformanceTool = {
                         });
                         if (result && result.usage) {
                             totalLatency += Date.now() - testStartTime;
-                            totalTokens += result.usage.totalTokens || 0;
+                            totalTokens += result.usage.total || 0;
                             successfulTests++;
                         }
                     }
@@ -210,7 +210,7 @@ const benchmarkProviderPerformanceTool = {
                         avgLatency: successfulTests > 0
                             ? Math.round(totalLatency / successfulTests)
                             : 0,
-                        totalTokens: totalTokens,
+                        total: totalTokens,
                         successRate: (successfulTests /
                             (testPrompts.length * typedParams.iterations)) *
                             100,
@@ -259,7 +259,7 @@ const benchmarkProviderPerformanceTool = {
  * Prompt Parameter Optimization Tool
  * Optimizes prompt parameters (temperature, max tokens) for better AI output quality and efficiency
  */
-const optimizePromptParametersTool = {
+const _optimizePromptParametersTool = {
     name: "optimize-prompt-parameters",
     description: "Optimize prompt parameters (temperature, max tokens) for better AI output quality and efficiency",
     category: "ai-optimization",

package/dist/mcp/servers/aiProviders/aiWorkflowTools.js

@@ -99,7 +99,7 @@ const debugAIOutputSchema = z.object({
 /**
  * Generate test cases for code functions
  */
-const generateTestCasesTool = {
+const _generateTestCasesTool = {
     name: "generate-test-cases",
     description: "Generate comprehensive test cases for code functions with various test types and frameworks",
     category: "ai-workflow",
@@ -203,7 +203,7 @@ Generate 3-5 comprehensive test cases covering the requested types.`;
 /**
  * Refactor code for improved quality
  */
-const refactorCodeTool = {
+const _refactorCodeTool = {
     name: "refactor-code",
     description: "AI-powered code refactoring for improved readability, performance, and maintainability",
     category: "ai-workflow",
@@ -316,7 +316,7 @@ Focus on real, actionable improvements based on the specified objectives.`;
 /**
  * Generate documentation from code
  */
-const generateDocumentationTool = {
+const _generateDocumentationTool = {
     name: "generate-documentation",
     description: "Automatically generate comprehensive documentation from code",
     category: "ai-workflow",
@@ -427,7 +427,7 @@ Focus on creating accurate, useful documentation that explains the code's purpos
 /**
  * Debug AI-generated output
  */
-const debugAIOutputTool = {
+const _debugAIOutputTool = {
     name: "debug-ai-output",
     description: "Analyze and debug AI-generated output to identify issues and suggest improvements",
     category: "ai-workflow",
@@ -549,13 +549,13 @@ Provide thorough, actionable analysis focused on improving AI output quality.`;
     },
 };
 // Helper functions
-function extractFunctionName(code) {
+function _extractFunctionName(code) {
     const match = code.match(/function\s+(\w+)|const\s+(\w+)\s*=|(\w+)\s*\(/);
     return match
         ? match[1] || match[2] || match[3] || "processData"
         : "processData";
 }
-function simulateRefactoring(code, objectives, styleGuide) {
+function _simulateRefactoring(code, objectives, _styleGuide) {
     // Simulate basic refactoring
     let refactored = code;
     if (objectives.includes("readability")) {

package/dist/mcp/servers/utilities/utilityServer.js

@@ -61,7 +61,7 @@ utilityServer.registerTool({
                     });
                     resultData.actualTimezone = timezone;
                 }
-                catch (tzError) {
+                catch {
                     const fallbackTimezone = "Asia/Kolkata";
                     logger.warn(`[Utility] Invalid timezone '${timezone}', falling back to ${fallbackTimezone}`);
                     resultData.localTime = now.toLocaleString("en-US", {

package/dist/mcp/toolDiscoveryService.js

@@ -6,7 +6,7 @@
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
 import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
-import { isObject, isNullish, } from "../utils/typeUtils.js";
+import { isObject, isNullish } from "../utils/typeUtils.js";
 import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
 /**
  * ToolDiscoveryService
@@ -133,6 +133,9 @@ export class ToolDiscoveryService extends EventEmitter {
                     this.serverToolStorage.set(serverId, []);
                 }
                 const serverTools = this.serverToolStorage.get(serverId);
+                if (!serverTools) {
+                    throw new Error(`Server tools storage not found for ${serverId}`);
+                }
                 // Add tool if not already present
                 if (!serverTools.find((t) => t.name === tool.name)) {
                     serverTools.push({
@@ -145,7 +148,10 @@ export class ToolDiscoveryService extends EventEmitter {
                 if (!this.serverTools.has(serverId)) {
                     this.serverTools.set(serverId, new Set());
                 }
-                this.serverTools.get(serverId).add(tool.name);
+                const serverToolSet = this.serverTools.get(serverId);
+                if (serverToolSet) {
+                    serverToolSet.add(tool.name);
+                }
                 registeredTools.push(toolInfo);
                 // Emit tool registered event
                 this.emit("toolRegistered", {

package/dist/mcp/toolRegistry.js

@@ -81,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,
@@ -97,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}`);
@@ -348,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);
                 });
             }
         }

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

@@ -39,11 +39,9 @@ export interface MCPStatus {
     error?: string;
     [key: string]: unknown;
 }
-import type { ContextManagerConfig } from "./context/types.js";
 export declare class NeuroLink {
     private mcpInitialized;
     private emitter;
-    private contextManager;
     private autoDiscoveredServerInfos;
     private externalServerManager;
     private toolCircuitBreakers;
@@ -90,11 +88,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
@@ -107,13 +165,6 @@ export declare class NeuroLink {
      * @returns The original prompt text as a string.
      */
     private _extractOriginalPrompt;
-    /**
-     * Enables automatic context summarization for the NeuroLink instance.
-     * Once enabled, the instance will maintain conversation history and
-     * automatically summarize it when it exceeds token limits.
-     * @param config Optional configuration to override default summarization settings.
-     */
-    enableContextSummarization(config?: Partial<ContextManagerConfig>): void;
     /**
      * Generate AI content using the best available provider with MCP tool integration.
      * This is the primary method for text generation with full feature support.
@@ -179,6 +230,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)
      */
@@ -257,6 +328,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,