@juspay/neurolink 6.1.0 → 6.2.1

package/dist/lib/utils/providerUtils.js

@@ -1,50 +1,33 @@
 /**
  * Utility functions for AI provider management
+ * Consolidated from providerUtils-fixed.ts
  */
+import { AIProviderFactory } from "../core/factory.js";
 import { logger } from "./logger.js";
 /**
- * Get the best available provider based on preferences and availability (async)
+ * Get the best available provider based on real-time availability checks
+ * Enhanced version consolidated from providerUtils-fixed.ts
  * @param requestedProvider - Optional preferred provider name
  * @returns The best provider name to use
  */
 export async function getBestProvider(requestedProvider) {
-    // If a specific provider is requested, return it (existing logic)
-    if (requestedProvider && requestedProvider !== "auto") {
-        return requestedProvider;
-    }
     // 🔧 FIX: Check for explicit default provider in env
     if (process.env.DEFAULT_PROVIDER &&
-        isProviderConfigured(process.env.DEFAULT_PROVIDER)) {
+        (await isProviderAvailable(process.env.DEFAULT_PROVIDER))) {
         return process.env.DEFAULT_PROVIDER;
     }
-    // 🔧 FIX: Special case for Ollama when explicitly configured
+    // 🔧 FIX: Special case for Ollama - prioritize local when available
     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
+            if (await isProviderAvailable("ollama")) {
+                logger.debug(`[getBestProvider] Prioritizing working local Ollama`);
+                return "ollama"; // Prioritize working local AI
             }
-            // Removed redundant if (res.ok) block here
         }
         catch {
             // Fall through to cloud providers
         }
     }
-    // Existing provider priority logic...
     const providers = [
         "google-ai",
         "anthropic",
@@ -56,24 +39,58 @@ export async function getBestProvider(requestedProvider) {
         "bedrock",
         "ollama", // Keep as fallback
     ];
-    // Check which providers have their required environment variables
+    if (requestedProvider && requestedProvider !== "auto") {
+        if (await isProviderAvailable(requestedProvider)) {
+            logger.debug(`[getBestProvider] Using requested provider: ${requestedProvider}`);
+            return requestedProvider;
+        }
+        else {
+            logger.warn(`[getBestProvider] Requested provider '${requestedProvider}' is not available. Falling back to auto-selection.`);
+        }
+    }
     for (const provider of providers) {
-        if (isProviderConfigured(provider)) {
+        if (await isProviderAvailable(provider)) {
             logger.debug(`[getBestProvider] Selected provider: ${provider}`);
             return provider;
         }
     }
-    // Default to bedrock if nothing is configured
-    logger.warn("[getBestProvider] No providers configured, defaulting to bedrock");
-    return "bedrock";
+    throw new Error("No available AI providers. Please check your configurations.");
 }
 /**
- * Check if a provider has the minimum required configuration
- * @param provider - Provider name to check
- * @returns True if the provider appears to be configured
+ * Check if a provider is truly available by performing a quick authentication test.
+ * Enhanced function consolidated from providerUtils-fixed.ts
+ * @param providerName - The name of the provider to check.
+ * @returns True if the provider is available and authenticated.
  */
-function isProviderConfigured(provider) {
-    return hasProviderEnvVars(provider);
+async function isProviderAvailable(providerName) {
+    if (!hasProviderEnvVars(providerName) && providerName !== "ollama") {
+        return false;
+    }
+    if (providerName === "ollama") {
+        try {
+            const response = await fetch("http://localhost:11434/api/tags", {
+                method: "GET",
+                signal: AbortSignal.timeout(2000),
+            });
+            if (response.ok) {
+                const { models } = await response.json();
+                const defaultOllamaModel = "llama3.2:latest";
+                return models.some((m) => m.name === defaultOllamaModel);
+            }
+            return false;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    try {
+        const provider = await AIProviderFactory.createProvider(providerName);
+        await provider.generate({ prompt: "test", maxTokens: 1 });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
 }
 /**
  * Check if a provider has the minimum required environment variables

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

@@ -66,4 +66,75 @@ export declare function getDefaultTimeout(provider: string, operation?: "generat
  * @returns Promise that rejects with TimeoutError
  */
 export declare function createTimeoutPromise(timeout: number | string | undefined, provider: string, operation: "generate" | "stream"): Promise<never> | null;
-export { createTimeoutController } from "../providers/timeout-wrapper.js";
+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
+ * Consolidated from timeout-manager.ts
+ */
+export declare class TimeoutManager {
+    private activeTimeouts;
+    /**
+     * Execute operation with timeout and proper cleanup
+     */
+    executeWithTimeout<T>(operation: () => Promise<T>, config: TimeoutConfig): Promise<TimeoutResult<T>>;
+    private performSingleOperation;
+    private getTimeoutMs;
+    private generateOperationId;
+    private createTimeoutPromise;
+    private registerTimeout;
+    cleanup(operationId: string): void;
+    gracefulShutdown(): void;
+}
+/**
+ * Wrapper functions consolidated from timeout-wrapper.ts
+ */
+/**
+ * Wrap a promise with timeout
+ * @param promise - The promise to wrap
+ * @param timeout - Timeout duration (number in ms or string with unit)
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type (generate or stream)
+ * @returns The result of the promise or throws TimeoutError
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeout: number | string | undefined, provider: string, operation: "generate" | "stream"): Promise<T>;
+/**
+ * Wrap a streaming async generator with timeout
+ * @param generator - The async generator to wrap
+ * @param timeout - Timeout duration for the entire stream
+ * @param provider - Provider name for error messages
+ * @returns Wrapped async generator that respects timeout
+ */
+export declare function withStreamingTimeout<T>(generator: AsyncGenerator<T>, timeout: number | string | undefined, provider: string): AsyncGenerator<T>;
+/**
+ * Create an abort controller with timeout
+ * @param timeout - Timeout duration
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type
+ * @returns AbortController and cleanup function
+ */
+export declare function createTimeoutController(timeout: number | string | undefined, provider: string, operation: "generate" | "stream"): {
+    controller: AbortController;
+    cleanup: () => void;
+    timeoutMs: number;
+} | null;
+/**
+ * Merge abort signals (for combining user abort with timeout)
+ * @param signals - Array of abort signals to merge
+ * @returns Combined abort controller
+ */
+export declare function mergeAbortSignals(signals: (AbortSignal | undefined)[]): AbortController;

package/dist/lib/utils/timeout.js

@@ -134,5 +134,206 @@ export function createTimeoutPromise(timeout, provider, operation) {
         }
     });
 }
-// Re-export createTimeoutController from timeout-wrapper for convenience
-export { createTimeoutController } from "../providers/timeout-wrapper.js";
+/**
+ * Enhanced timeout manager with proper cleanup and abort controller integration
+ * Consolidated from timeout-manager.ts
+ */
+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) {
+                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,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: new Error("Maximum retries exceeded"),
+            timedOut: true,
+            executionTime: Date.now() - startTime,
+            retriesUsed,
+        };
+    }
+    async performSingleOperation(operation, config, operationId) {
+        const timeoutMs = this.getTimeoutMs(config);
+        if (!timeoutMs) {
+            return await operation();
+        }
+        const controller = new AbortController();
+        const existingSignal = config.abortSignal;
+        if (existingSignal) {
+            existingSignal.addEventListener("abort", () => {
+                controller.abort(existingSignal.reason);
+            });
+            if (existingSignal.aborted) {
+                throw new Error("Operation aborted before execution");
+            }
+        }
+        const timeoutPromise = this.createTimeoutPromise(timeoutMs, operationId);
+        this.registerTimeout(operationId, timeoutPromise.timer, controller, () => {
+            clearTimeout(timeoutPromise.timer);
+        });
+        try {
+            return await Promise.race([operation(), timeoutPromise.promise]);
+        }
+        finally {
+            this.cleanup(operationId);
+        }
+    }
+    getTimeoutMs(config) {
+        return parseTimeout(config.timeout);
+    }
+    generateOperationId(operation) {
+        return `${operation}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    createTimeoutPromise(timeoutMs, operationId) {
+        let timer;
+        const promise = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                reject(new TimeoutError(`Operation timeout after ${timeoutMs}ms`, timeoutMs));
+            }, timeoutMs);
+        });
+        return { promise, timer: timer };
+    }
+    registerTimeout(operationId, timer, controller, cleanup) {
+        this.activeTimeouts.set(operationId, { timer, controller, cleanup });
+    }
+    cleanup(operationId) {
+        const timeoutInfo = this.activeTimeouts.get(operationId);
+        if (timeoutInfo) {
+            timeoutInfo.cleanup();
+            this.activeTimeouts.delete(operationId);
+        }
+    }
+    gracefulShutdown() {
+        for (const [operationId] of this.activeTimeouts) {
+            this.cleanup(operationId);
+        }
+    }
+}
+/**
+ * Wrapper functions consolidated from timeout-wrapper.ts
+ */
+/**
+ * Wrap a promise with timeout
+ * @param promise - The promise to wrap
+ * @param timeout - Timeout duration (number in ms or string with unit)
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type (generate or stream)
+ * @returns The result of the promise or throws TimeoutError
+ */
+export async function withTimeout(promise, timeout, provider, operation) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        return promise;
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new TimeoutError(`${provider} ${operation} operation timed out after ${timeoutMs}ms`, timeoutMs, provider, operation));
+        }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+}
+/**
+ * Wrap a streaming async generator with timeout
+ * @param generator - The async generator to wrap
+ * @param timeout - Timeout duration for the entire stream
+ * @param provider - Provider name for error messages
+ * @returns Wrapped async generator that respects timeout
+ */
+export async function* withStreamingTimeout(generator, timeout, provider) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        yield* generator;
+        return;
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new TimeoutError(`${provider} streaming operation timed out after ${timeoutMs}ms`, timeoutMs, provider, "stream"));
+        }, timeoutMs);
+    });
+    try {
+        for await (const item of generator) {
+            const raceResult = await Promise.race([
+                Promise.resolve(item),
+                timeoutPromise,
+            ]);
+            yield raceResult;
+        }
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Create an abort controller with timeout
+ * @param timeout - Timeout duration
+ * @param provider - Provider name for error messages
+ * @param operation - Operation type
+ * @returns AbortController and cleanup function
+ */
+export function createTimeoutController(timeout, provider, operation) {
+    const timeoutMs = parseTimeout(timeout);
+    if (!timeoutMs) {
+        return null;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+        controller.abort(new TimeoutError(`${provider} ${operation} operation timed out after ${timeout}`, timeoutMs, provider, operation));
+    }, timeoutMs);
+    const cleanup = () => {
+        clearTimeout(timer);
+    };
+    return { controller, cleanup, timeoutMs };
+}
+/**
+ * Merge abort signals (for combining user abort with timeout)
+ * @param signals - Array of abort signals to merge
+ * @returns Combined abort controller
+ */
+export function mergeAbortSignals(signals) {
+    const controller = new AbortController();
+    for (const signal of signals) {
+        if (signal && !signal.aborted) {
+            signal.addEventListener("abort", () => {
+                if (!controller.signal.aborted) {
+                    controller.abort(signal.reason);
+                }
+            });
+        }
+        if (signal?.aborted) {
+            controller.abort(signal.reason);
+            break;
+        }
+    }
+    return controller;
+}

package/dist/mcp/factory.d.ts

@@ -4,7 +4,7 @@
  * Compatible with Lighthouse MCP patterns for seamless migration
  */
 import { z } from "zod";
-import type { ExecutionContext } from "./contracts/mcp-contract.js";
+import type { ExecutionContext } from "./contracts/mcpContract.js";
 /**
  * MCP Server Categories for organization and discovery
  */

package/dist/mcp/index.d.ts

@@ -3,39 +3,27 @@
  * Universal AI Development Platform with Extensible Plugin Architecture
  * Implementation based on research blueprint
  */
-export { MCP } from "./contracts/mcp-contract.js";
-export type { MCPMetadata, ExecutionContext, MCPConstructor, MCPInstance, DiscoveredMCP, } from "./contracts/mcp-contract.js";
-export { MCPEcosystem, mcpEcosystem } from "./ecosystem.js";
-export { PluginManager, pluginManager } from "./plugin-manager.js";
-export { SecurityManager } from "./security-manager.js";
-export { mcpLogger } from "./logging.js";
-export type { LogLevel } from "./logging.js";
-export { FileSystemMCP } from "./plugins/core/filesystem-mcp.js";
-import type { MCPMetadata } from "./contracts/mcp-contract.js";
+export type { McpMetadata, ExecutionContext, DiscoveredMcp, ToolInfo, ToolExecutionResult, } from "./contracts/mcpContract.js";
+export { mcpLogger } from "../utils/logger.js";
+export type { LogLevel } from "../utils/logger.js";
+import type { McpMetadata } from "./contracts/mcpContract.js";
 /**
- * Initialize the MCP ecosystem
+ * Initialize the MCP ecosystem - simplified
  */
 export declare function initializeMCPEcosystem(): Promise<void>;
 /**
- * List available MCPs
+ * List available MCPs - simplified
  */
-export declare function listMCPs(): Promise<MCPMetadata[]>;
+export declare function listMCPs(): Promise<McpMetadata[]>;
 /**
- * Execute an MCP operation
+ * Execute an MCP operation - simplified
  */
 export declare function executeMCP<T = unknown>(name: string, config: unknown, args: unknown, context?: {
     sessionId?: string;
     userId?: string;
 }): Promise<T>;
 /**
- * Quick filesystem operations
- */
-export declare function readFile(path: string, basePath?: string): Promise<string | Buffer>;
-export declare function writeFile(path: string, content: string, basePath?: string): Promise<void>;
-export declare function listFiles(path: string, basePath?: string): Promise<string[]>;
-export declare function createDirectory(path: string, basePath?: string): Promise<void>;
-/**
- * Get MCP ecosystem statistics
+ * Get MCP ecosystem statistics - simplified
  */
 export declare function getMCPStats(): Promise<{
     initialized: boolean;

package/dist/mcp/index.js

@@ -3,76 +3,35 @@
  * Universal AI Development Platform with Extensible Plugin Architecture
  * Implementation based on research blueprint
  */
-// Core contracts and types
-export { MCP } from "./contracts/mcp-contract.js";
-// Main ecosystem interface
-export { MCPEcosystem, mcpEcosystem } from "./ecosystem.js";
-// Plugin management
-export { PluginManager, pluginManager } from "./plugin-manager.js";
-// Security
-export { SecurityManager } from "./security-manager.js";
-// Logging
-export { mcpLogger } from "./logging.js";
-// Core plugins
-export { FileSystemMCP } from "./plugins/core/filesystem-mcp.js";
+// Core functionality exports
+export { mcpLogger } from "../utils/logger.js";
 /**
- * Quick access functions for common MCP operations
- */
-// Import the ecosystem singleton
-import { mcpEcosystem } from "./ecosystem.js";
-/**
- * Initialize the MCP ecosystem
+ * Initialize the MCP ecosystem - simplified
  */
 export async function initializeMCPEcosystem() {
-    return mcpEcosystem.initialize();
+    // Simplified initialization - no complex ecosystem needed
+    return Promise.resolve();
 }
 /**
- * List available MCPs
+ * List available MCPs - simplified
  */
 export async function listMCPs() {
-    return mcpEcosystem.list();
+    return [];
 }
 /**
- * Execute an MCP operation
+ * Execute an MCP operation - simplified
  */
 export async function executeMCP(name, config, args, context) {
-    return mcpEcosystem.execute(name, config, args, context);
-}
-/**
- * Quick filesystem operations
- */
-export async function readFile(path, basePath) {
-    return mcpEcosystem.filesystem({
-        action: "readFile",
-        path,
-        basePath,
-    });
-}
-export async function writeFile(path, content, basePath) {
-    return mcpEcosystem.filesystem({
-        action: "writeFile",
-        path,
-        content,
-        basePath,
-    });
-}
-export async function listFiles(path, basePath) {
-    return mcpEcosystem.filesystem({
-        action: "listFiles",
-        path,
-        basePath,
-    });
-}
-export async function createDirectory(path, basePath) {
-    return mcpEcosystem.filesystem({
-        action: "createDir",
-        path,
-        basePath,
-    });
+    throw new Error("MCP execution not available - ecosystem removed");
 }
 /**
- * Get MCP ecosystem statistics
+ * Get MCP ecosystem statistics - simplified
  */
 export async function getMCPStats() {
-    return mcpEcosystem.getStats();
+    return {
+        initialized: false,
+        pluginsDiscovered: 0,
+        pluginsBySource: {},
+        availablePlugins: [],
+    };
 }

package/dist/mcp/registry.js

@@ -1,7 +1,7 @@
 /**
  * MCP Registry - Industry Standard Interface with camelCase
  */
-import { registryLogger } from "./logging.js";
+import { registryLogger } from "../utils/logger.js";
 /**
  * Simple MCP registry for plugin management
  * Maintains backward compatibility with existing code

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

@@ -6,6 +6,7 @@
 import { z } from "zod";
 import { AIProviderFactory } from "../../../core/factory.js";
 import { getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
+import { logger } from "../../../utils/logger.js";
 /**
  * Input Schemas for AI Analysis Tools
  */
@@ -89,7 +90,7 @@ const analyzeAIUsageTool = {
         const typedParams = params;
         const startTime = Date.now();
         try {
-            console.log(`[AI-Analysis] Starting real AI-powered usage analysis for timeRange: ${typedParams.timeRange}`);
+            logger.debug(`[AI-Analysis] Starting real AI-powered usage analysis for timeRange: ${typedParams.timeRange}`);
             const providerName = await getBestProvider();
             const provider = await AIProviderFactory.createProvider(providerName);
             if (!provider) {

package/dist/mcp/tool-registry.js

@@ -3,7 +3,7 @@
  * Updated to match industry standard camelCase interfaces
  */
 import { MCPRegistry } from "./registry.js";
-import { registryLogger } from "./logging.js";
+import { registryLogger } from "../utils/logger.js";
 import { randomUUID } from "crypto";
 export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();

package/dist/neurolink.d.ts

@@ -40,7 +40,6 @@ export interface MCPServerInfo {
 }
 export declare class NeuroLink {
     private mcpInitialized;
-    private contextManager;
     private customTools;
     private inMemoryServers;
     constructor();
@@ -139,14 +138,7 @@ export declare class NeuroLink {
      * Get all available tools including custom and in-memory ones
      * @returns Array of available tools with metadata
      */
-    getAllAvailableTools(): Promise<{
-        serverId: string;
-        serverTitle: string;
-        toolName: string;
-        namespacedName: string;
-        description: string;
-        isImplemented: boolean;
-    }[]>;
+    getAllAvailableTools(): Promise<import("./mcp/tool-registry.js").ToolInfo[]>;
     /**
      * Get comprehensive status of all AI providers
      * Primary method for provider health checking and diagnostics