@juspay/neurolink 7.29.2 → 7.29.3

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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/lib/neurolink.d.ts

@@ -90,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
@@ -179,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)
      */
@@ -257,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,