@juspay/neurolink 4.1.1 → 4.2.0

package/dist/lib/utils/providerUtils.js

@@ -3,17 +3,48 @@
  */
 import { logger } from "./logger.js";
 /**
- * Get the best available provider based on preferences and availability
+ * Get the best available provider based on preferences and availability (async)
  * @param requestedProvider - Optional preferred provider name
  * @returns The best provider name to use
  */
-export function getBestProviderSync(requestedProvider) {
-    // If a specific provider is requested, return it
-    if (requestedProvider) {
+export async function getBestProvider(requestedProvider) {
+    // If a specific provider is requested, return it (existing logic)
+    if (requestedProvider && requestedProvider !== "auto") {
         return requestedProvider;
     }
-    // Default fallback order - Google AI (Gemini) first as primary provider
-    // Ollama last since it requires local setup
+    // 🔧 FIX: Check for explicit default provider in env
+    if (process.env.DEFAULT_PROVIDER &&
+        isProviderConfigured(process.env.DEFAULT_PROVIDER)) {
+        return process.env.DEFAULT_PROVIDER;
+    }
+    // 🔧 FIX: Special case for Ollama when explicitly configured
+    if (process.env.OLLAMA_BASE_URL && process.env.OLLAMA_MODEL) {
+        // Quick connectivity check for Ollama (non-blocking)
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 2000);
+            let res;
+            try {
+                res = await fetch("http://localhost:11434/api/tags", {
+                    method: "GET",
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (res.ok) {
+                    return "ollama"; // Prioritize working local AI
+                }
+            }
+            catch {
+                clearTimeout(timeout);
+                // Fall through to cloud providers
+            }
+            // Removed redundant if (res.ok) block here
+        }
+        catch {
+            // Fall through to cloud providers
+        }
+    }
+    // Existing provider priority logic...
     const providers = [
         "google-ai",
         "anthropic",
@@ -23,7 +54,7 @@ export function getBestProviderSync(requestedProvider) {
         "azure",
         "huggingface",
         "bedrock",
-        "ollama",
+        "ollama", // Keep as fallback
     ];
     // Check which providers have their required environment variables
     for (const provider of providers) {

package/dist/lib/utils/timeout-manager.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Centralized Timeout Manager for NeuroLink
+ *
+ * Provides consistent timeout handling across all operations with proper cleanup,
+ * abort controller integration, and graceful degradation.
+ */
+export interface TimeoutConfig {
+    operation: string;
+    timeout?: number | string;
+    gracefulShutdown?: boolean;
+    retryOnTimeout?: boolean;
+    maxRetries?: number;
+    abortSignal?: AbortSignal;
+}
+export interface TimeoutResult<T> {
+    success: boolean;
+    data?: T;
+    error?: Error;
+    timedOut: boolean;
+    executionTime: number;
+    retriesUsed: number;
+}
+/**
+ * Enhanced timeout manager with proper cleanup and abort controller integration
+ */
+export declare class TimeoutManager {
+    private activeTimeouts;
+    /**
+     * Execute operation with timeout and proper cleanup
+     */
+    executeWithTimeout<T>(operation: () => Promise<T>, config: TimeoutConfig): Promise<TimeoutResult<T>>;
+    /**
+     * Execute single operation with timeout
+     */
+    private performSingleOperation;
+    /**
+     * Execute operation with abort signal support
+     */
+    private executeWithAbortSignal;
+    /**
+     * Get timeout in milliseconds from config
+     */
+    private getTimeoutMs;
+    /**
+     * Generate unique operation ID
+     */
+    private generateOperationId;
+    /**
+     * Cleanup specific operation
+     */
+    cleanup(operationId: string): void;
+    /**
+     * Cleanup all active timeouts (call on shutdown)
+     */
+    cleanupAll(): void;
+    /**
+     * Get current active timeout count (for debugging)
+     */
+    getActiveTimeoutCount(): number;
+    /**
+     * Create a timeout wrapper for child process operations
+     */
+    wrapChildProcess<T>(processFactory: () => Promise<T>, config: TimeoutConfig): Promise<TimeoutResult<T>>;
+    /**
+     * Create a timeout wrapper for MCP server operations
+     */
+    wrapMCPOperation<T>(operation: () => Promise<T>, operationName: string, timeoutMs?: number): Promise<TimeoutResult<T>>;
+    /**
+     * Create a timeout wrapper for CLI operations
+     */
+    wrapCLIOperation<T>(operation: () => Promise<T>, operationName: string, timeoutMs?: number): Promise<TimeoutResult<T>>;
+}
+export declare function createTimeoutManager(): TimeoutManager;
+export declare function getDefaultTimeoutManager(): TimeoutManager;
+export declare const defaultTimeoutManager: TimeoutManager;

package/dist/lib/utils/timeout-manager.js

@@ -0,0 +1,244 @@
+/**
+ * Centralized Timeout Manager for NeuroLink
+ *
+ * Provides consistent timeout handling across all operations with proper cleanup,
+ * abort controller integration, and graceful degradation.
+ */
+import { parseTimeout, TimeoutError, DEFAULT_TIMEOUTS } from "./timeout.js";
+/**
+ * Enhanced timeout manager with proper cleanup and abort controller integration
+ */
+export class TimeoutManager {
+    activeTimeouts = new Map();
+    /**
+     * Execute operation with timeout and proper cleanup
+     */
+    async executeWithTimeout(operation, config) {
+        const startTime = Date.now();
+        const operationId = this.generateOperationId(config.operation);
+        let retriesUsed = 0;
+        const maxRetries = config.retryOnTimeout ? (config.maxRetries ?? 1) : 0;
+        while (retriesUsed <= maxRetries) {
+            try {
+                const result = await this.performSingleOperation(operation, config, operationId);
+                return {
+                    success: true,
+                    data: result,
+                    timedOut: false,
+                    executionTime: Date.now() - startTime,
+                    retriesUsed,
+                };
+            }
+            catch (error) {
+                // Clean up any active timeouts for this operation
+                this.cleanup(operationId);
+                if (error instanceof TimeoutError && retriesUsed < maxRetries) {
+                    retriesUsed++;
+                    continue;
+                }
+                return {
+                    success: false,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    timedOut: error instanceof TimeoutError,
+                    executionTime: Date.now() - startTime,
+                    retriesUsed,
+                };
+            }
+        }
+        // This should never be reached, but TypeScript needs it
+        return {
+            success: false,
+            error: new Error("Maximum retries exceeded"),
+            timedOut: true,
+            executionTime: Date.now() - startTime,
+            retriesUsed,
+        };
+    }
+    /**
+     * Execute single operation with timeout
+     */
+    async performSingleOperation(operation, config, operationId) {
+        const timeoutMs = this.getTimeoutMs(config);
+        if (!timeoutMs) {
+            // No timeout specified, execute directly
+            return await operation();
+        }
+        // Create abort controller for this operation
+        const controller = new AbortController();
+        const existingSignal = config.abortSignal;
+        // Merge with existing abort signal if provided
+        if (existingSignal) {
+            existingSignal.addEventListener("abort", () => {
+                controller.abort(existingSignal.reason);
+            });
+            if (existingSignal.aborted) {
+                throw new Error("Operation aborted before execution");
+            }
+        }
+        // Set up timeout
+        const timer = setTimeout(() => {
+            controller.abort(new TimeoutError(`Operation '${config.operation}' timed out after ${timeoutMs}ms`, timeoutMs, "timeout-manager", "generate"));
+        }, timeoutMs);
+        // Cleanup function
+        const cleanup = () => {
+            clearTimeout(timer);
+            this.activeTimeouts.delete(operationId);
+        };
+        // Store active timeout for potential cleanup
+        this.activeTimeouts.set(operationId, {
+            timer,
+            controller,
+            cleanup,
+        });
+        try {
+            // Execute operation with abort signal
+            const result = await this.executeWithAbortSignal(operation, controller.signal);
+            cleanup();
+            return result;
+        }
+        catch (error) {
+            cleanup();
+            // Convert abort errors to timeout errors if appropriate
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new TimeoutError(`Operation '${config.operation}' was aborted`, timeoutMs, "timeout-manager", "generate");
+            }
+            throw error;
+        }
+    }
+    /**
+     * Execute operation with abort signal support
+     */
+    async executeWithAbortSignal(operation, signal) {
+        // Check if already aborted
+        if (signal.aborted) {
+            throw new Error("Operation aborted");
+        }
+        // Race between operation and abort signal
+        return new Promise((resolve, reject) => {
+            // Listen for abort
+            signal.addEventListener("abort", () => {
+                reject(signal.reason || new Error("Operation aborted"));
+            });
+            // Execute operation
+            operation().then(resolve).catch(reject);
+        });
+    }
+    /**
+     * Get timeout in milliseconds from config
+     */
+    getTimeoutMs(config) {
+        if (config.timeout !== undefined) {
+            return parseTimeout(config.timeout);
+        }
+        // Use default timeout based on operation type
+        const operation = config.operation.toLowerCase();
+        // MCP operations
+        if (operation.includes("mcp") || operation.includes("server")) {
+            return parseTimeout(DEFAULT_TIMEOUTS.tools.network);
+        }
+        // File operations
+        if (operation.includes("file") ||
+            operation.includes("read") ||
+            operation.includes("write")) {
+            return parseTimeout(DEFAULT_TIMEOUTS.tools.filesystem);
+        }
+        // Network operations
+        if (operation.includes("network") ||
+            operation.includes("http") ||
+            operation.includes("fetch")) {
+            return parseTimeout(DEFAULT_TIMEOUTS.tools.network);
+        }
+        // Default
+        return parseTimeout(DEFAULT_TIMEOUTS.tools.default);
+    }
+    /**
+     * Generate unique operation ID
+     */
+    generateOperationId(operation) {
+        return `${operation}-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    }
+    /**
+     * Cleanup specific operation
+     */
+    cleanup(operationId) {
+        const timeout = this.activeTimeouts.get(operationId);
+        if (timeout) {
+            timeout.cleanup();
+        }
+    }
+    /**
+     * Cleanup all active timeouts (call on shutdown)
+     */
+    cleanupAll() {
+        for (const [id, timeout] of this.activeTimeouts) {
+            timeout.cleanup();
+        }
+        this.activeTimeouts.clear();
+    }
+    /**
+     * Get current active timeout count (for debugging)
+     */
+    getActiveTimeoutCount() {
+        return this.activeTimeouts.size;
+    }
+    /**
+     * Create a timeout wrapper for child process operations
+     */
+    wrapChildProcess(processFactory, config) {
+        return this.executeWithTimeout(processFactory, {
+            ...config,
+            gracefulShutdown: true,
+            timeout: config.timeout || DEFAULT_TIMEOUTS.tools.network,
+        });
+    }
+    /**
+     * Create a timeout wrapper for MCP server operations
+     */
+    wrapMCPOperation(operation, operationName, timeoutMs) {
+        return this.executeWithTimeout(operation, {
+            operation: `mcp-${operationName}`,
+            timeout: timeoutMs || parseTimeout(DEFAULT_TIMEOUTS.tools.network),
+            retryOnTimeout: false,
+            gracefulShutdown: true,
+        });
+    }
+    /**
+     * Create a timeout wrapper for CLI operations
+     */
+    wrapCLIOperation(operation, operationName, timeoutMs) {
+        return this.executeWithTimeout(operation, {
+            operation: `cli-${operationName}`,
+            timeout: timeoutMs || 120000, // 2 minutes default for CLI
+            retryOnTimeout: false,
+            gracefulShutdown: true,
+        });
+    }
+}
+// Factory function to create a new TimeoutManager instance
+export function createTimeoutManager() {
+    return new TimeoutManager();
+}
+// Lazy-loaded default timeout manager instance
+let _defaultTimeoutManager = null;
+export function getDefaultTimeoutManager() {
+    if (!_defaultTimeoutManager) {
+        _defaultTimeoutManager = createTimeoutManager();
+    }
+    return _defaultTimeoutManager;
+}
+// Export default instance for backwards compatibility
+export const defaultTimeoutManager = getDefaultTimeoutManager();
+// Cleanup on process exit
+if (typeof process !== "undefined") {
+    process.once("exit", () => {
+        getDefaultTimeoutManager().cleanupAll();
+    });
+    process.once("SIGINT", () => {
+        getDefaultTimeoutManager().cleanupAll();
+        process.exit(0);
+    });
+    process.once("SIGTERM", () => {
+        getDefaultTimeoutManager().cleanupAll();
+        process.exit(0);
+    });
+}

package/dist/mcp/context-manager.d.ts

@@ -79,6 +79,12 @@ export declare class ContextManager {
      * @param updates Partial context updates
      */
     updateContext(sessionId: string, updates: Partial<NeuroLinkExecutionContext>): void;
+    /**
+     * Store context directly (used when session ID changes)
+     *
+     * @param context Complete execution context to store
+     */
+    storeContext(context: NeuroLinkExecutionContext): void;
     /**
      * Remove context from active tracking
      *

package/dist/mcp/context-manager.js

@@ -196,6 +196,14 @@ export class ContextManager {
             this.activeContexts.set(sessionId, updatedContext);
         }
     }
+    /**
+     * Store context directly (used when session ID changes)
+     *
+     * @param context Complete execution context to store
+     */
+    storeContext(context) {
+        this.activeContexts.set(context.sessionId, context);
+    }
     /**
      * Remove context from active tracking
      *

package/dist/mcp/contracts/mcpContract.d.ts

@@ -66,6 +66,7 @@ export interface McpMetadata {
     author?: string;
     homepage?: string;
     repository?: string;
+    category?: string;
 }
 /**
  * Tool definition schema

package/dist/mcp/external-client.js

@@ -40,6 +40,10 @@ export class ExternalMCPClient extends EventEmitter {
                 stdio: ["pipe", "pipe", "pipe"],
                 env: { ...process.env, ...this.config.env },
             });
+            // 🔧 FIX: Register for cleanup
+            process.once("beforeExit", () => this.disconnect());
+            process.once("SIGINT", () => this.disconnect());
+            process.once("SIGTERM", () => this.disconnect());
             if (!this.process.stdout || !this.process.stdin || !this.process.stderr) {
                 throw new Error("Failed to create stdio pipes");
             }
@@ -279,7 +283,7 @@ export class ExternalMCPClient extends EventEmitter {
             pending.reject(new Error("Connection closed"));
         }
         this.pendingRequests.clear();
-        // Close process
+        // 🔧 FIX: Enhanced process cleanup
         if (this.process) {
             this.process.kill("SIGTERM");
             // Force kill after timeout
@@ -287,7 +291,7 @@ export class ExternalMCPClient extends EventEmitter {
                 if (this.process && !this.process.killed) {
                     this.process.kill("SIGKILL");
                 }
-            }, 5000);
+            }, 1000); // Reduced from 5000ms to 1000ms
             this.process = null;
         }
         this.isConnected = false;

package/dist/mcp/initialize.d.ts

@@ -3,10 +3,11 @@
  * Automatically registers built-in NeuroLink servers with the default registry
  * Ensures built-in tools are always available without manual configuration
  */
+import { type MCPToolRegistry } from "./tool-registry.js";
 /**
  * Initialize NeuroLink MCP system by registering built-in servers
  */
-export declare function initializeNeuroLinkMCP(): Promise<void>;
+export declare function initializeNeuroLinkMCP(targetRegistry?: MCPToolRegistry): Promise<void>;
 /**
  * Get initialization status
  */

package/dist/mcp/initialize.js

@@ -3,13 +3,13 @@
  * Automatically registers built-in NeuroLink servers with the default registry
  * Ensures built-in tools are always available without manual configuration
  */
-import { toolRegistry, defaultToolRegistry } from "./tool-registry.js";
+import { toolRegistry, defaultToolRegistry, } from "./tool-registry.js";
 import { mcpLogger } from "./logging.js";
 let isInitialized = false;
 /**
  * Initialize NeuroLink MCP system by registering built-in servers
  */
-export async function initializeNeuroLinkMCP() {
+export async function initializeNeuroLinkMCP(targetRegistry) {
     if (isInitialized) {
         return;
     }
@@ -18,14 +18,15 @@ export async function initializeNeuroLinkMCP() {
         // Import utility server dynamically to avoid circular dependencies
         // Note: AI core server temporarily disabled due to circular dependency issues
         const { utilityServer } = await import("./servers/utilities/utility-server.js");
-        // Register built-in NeuroLink servers with default registry
-        await toolRegistry.registerServer(utilityServer.id, utilityServer);
-        mcpLogger.debug("Registered neurolink-utility server with built-in tools");
+        // Register built-in NeuroLink servers with specified registry (or default)
+        const registry = targetRegistry || toolRegistry;
+        await registry.registerServer(utilityServer.id, utilityServer);
+        mcpLogger.debug(`Registered neurolink-utility server with built-in tools in ${targetRegistry ? "target" : "default"} registry`);
         // TODO: Re-enable AI core server once circular dependencies are resolved
         // const { aiCoreServer } = await import('./servers/ai-providers/ai-core-server.js');
-        // await toolRegistry.registerServer(aiCoreServer.id, aiCoreServer);
+        // await registry.registerServer(aiCoreServer.id, aiCoreServer);
         // mcpLogger.debug('Registered neurolink-ai-core server with AI tools');
-        const stats = await toolRegistry.getStats();
+        const stats = await registry.getStats();
         mcpLogger.info(`Initialization complete: ${stats.totalServers} server, ${stats.totalTools} tools available`);
         isInitialized = true;
     }

package/dist/mcp/orchestrator.js

@@ -70,7 +70,14 @@ export class MCPOrchestrator {
             // Create new session with options
             session = await this.sessionManager.createSession(context, options.sessionOptions);
             // Update context with new session ID
+            const oldSessionId = context.sessionId;
             context.sessionId = session.id;
+            // Remove old context and store updated context in context manager
+            if (oldSessionId) {
+                this.contextManager.removeContext(oldSessionId);
+            }
+            // Store the updated context with the new session ID
+            this.contextManager.storeContext(context);
         }
         if (process.env.NEUROLINK_DEBUG === "true") {
             console.log(`[Orchestrator] Executing tool '${toolName}' in session ${context.sessionId}`);
@@ -80,6 +87,8 @@ export class MCPOrchestrator {
         const semaphoreKey = `tool:${toolName}`;
         const semaphoreResult = await this.semaphoreManager.acquire(semaphoreKey, async () => {
             try {
+                // Add tool to the execution chain
+                this.contextManager.addToToolChain(context, toolName);
                 // Execute tool through registry
                 const result = await this.registry.executeTool(toolName, params, context);
                 if (process.env.NEUROLINK_DEBUG === "true") {

package/dist/mcp/registry.d.ts

@@ -15,7 +15,7 @@ export interface McpRegistry {
  * Maintains backward compatibility with existing code
  */
 export declare class MCPRegistry implements McpRegistry {
-    private plugins;
+    plugins: Map<string, DiscoveredMcp<Record<string, unknown>>>;
     /**
      * Register a plugin
      */

package/dist/mcp/servers/ai-providers/ai-analysis-tools.js

@@ -5,7 +5,7 @@
  */
 import { z } from "zod";
 import { AIProviderFactory } from "../../../core/factory.js";
-import { getBestProviderSync as getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
+import { getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
 /**
  * Input Schemas for AI Analysis Tools
  */

package/dist/mcp/servers/ai-providers/ai-core-server.js

@@ -6,7 +6,7 @@
 import { z } from "zod";
 import { createMCPServer } from "../../factory.js";
 import { AIProviderFactory } from "../../../core/factory.js";
-import { getBestProviderSync as getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
+import { getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
 import { logger } from "../../../utils/logger.js";
 import { analyzeAIUsageTool, benchmarkProviderPerformanceTool, optimizePromptParametersTool, } from "./ai-analysis-tools.js";
 import { generateTestCasesTool, refactorCodeTool, generateDocumentationTool, debugAIOutputTool, } from "./ai-workflow-tools.js";
@@ -85,7 +85,7 @@ aiCoreServer.registerTool({
         try {
             logger.debug(`[AI-Core] Starting text generation: "${params.prompt.substring(0, 50)}..."`);
             // Use existing AIProviderFactory with best provider selection
-            const selectedProvider = params.provider || getBestProvider(params.provider);
+            const selectedProvider = params.provider || (await getBestProvider(params.provider));
             const provider = await AIProviderFactory.createBestProvider(selectedProvider);
             // Generate text using existing NeuroLink patterns
             const result = await provider.generateText({
@@ -157,7 +157,7 @@ aiCoreServer.registerTool({
             logger.debug(`[AI-Core] Selecting provider with requirements:`, params.requirements);
             // Use existing provider selection logic
             const availableProviders = getAvailableProviders();
-            const selectedProvider = getBestProvider(params.preferred);
+            const selectedProvider = await getBestProvider(params.preferred);
             // Get provider capabilities
             const getProviderCapabilities = (provider) => ({
                 multimodal: provider === "openai" ||

package/dist/mcp/servers/ai-providers/ai-workflow-tools.d.ts

@@ -30,13 +30,13 @@ export declare const workflowToolSchemas: {
         includeAsyncTests: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         codeFunction: string;
-        testTypes: ("integration" | "unit" | "performance" | "edge-cases" | "security")[];
+        testTypes: ("integration" | "performance" | "unit" | "edge-cases" | "security")[];
         framework: "jest" | "mocha" | "vitest" | "pytest" | "unittest" | "rspec";
         coverageTarget: number;
         includeAsyncTests: boolean;
     }, {
         codeFunction: string;
-        testTypes?: ("integration" | "unit" | "performance" | "edge-cases" | "security")[] | undefined;
+        testTypes?: ("integration" | "performance" | "unit" | "edge-cases" | "security")[] | undefined;
         framework?: "jest" | "mocha" | "vitest" | "pytest" | "unittest" | "rspec" | undefined;
         coverageTarget?: number | undefined;
         includeAsyncTests?: boolean | undefined;

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

@@ -4,7 +4,7 @@
  */
 import { z } from "zod";
 import { AIProviderFactory } from "../../../core/factory.js";
-import { getBestProviderSync as getBestProvider } from "../../../utils/providerUtils.js";
+import { getBestProvider } from "../../../utils/providerUtils.js";
 import { DEFAULT_MAX_TOKENS } from "../../../core/constants.js";
 // Tool-specific schemas with comprehensive validation
 const generateTestCasesSchema = z.object({

package/dist/mcp/session-manager.js

@@ -94,7 +94,7 @@ export class SessionManager {
      * @returns Session if found and not expired
      */
     getSession(sessionId, extend = true) {
-        let session = this.sessions.get(sessionId) || null;
+        const session = this.sessions.get(sessionId) || null;
         // For sync compatibility, skip disk loading in getSession
         // Use async getSessionAsync() for full persistence features
         if (!session) {

package/dist/mcp/session-persistence.js

@@ -61,7 +61,7 @@ export class SessionPersistence {
             ...session,
             state: Array.from(session.state.entries()),
         };
-        let fileData = {
+        const fileData = {
             session: sessionData,
             checksum: "",
             version: "1.0",