@juspay/neurolink 1.6.0 → 1.9.0

package/dist/neurolink.d.ts

@@ -1,21 +1,23 @@
 /**
- * NeuroLink - Unified AI Interface
+ * NeuroLink - Unified AI Interface with Real MCP Tool Integration
  *
- * Simple wrapper around the AI provider system to provide a clean API
- * for CLI and other consumers.
+ * Enhanced AI provider system with natural MCP tool access.
+ * Uses real MCP infrastructure for    // Initialize MCP with enhanced error handling
+    await this.initializeMCP();tool discovery and execution.
  */
-import type { AIProviderName } from './core/types.js';
+import type { AIProviderName } from "./core/types.js";
 export interface TextGenerationOptions {
     prompt: string;
-    provider?: 'openai' | 'bedrock' | 'vertex' | 'anthropic' | 'azure' | 'google-ai' | 'huggingface' | 'ollama' | 'mistral' | 'auto';
+    provider?: "openai" | "bedrock" | "vertex" | "anthropic" | "azure" | "google-ai" | "huggingface" | "ollama" | "mistral" | "auto";
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
     schema?: any;
+    disableTools?: boolean;
 }
 export interface StreamTextOptions {
     prompt: string;
-    provider?: 'openai' | 'bedrock' | 'vertex' | 'anthropic' | 'azure' | 'google-ai' | 'huggingface' | 'ollama' | 'mistral' | 'auto';
+    provider?: "openai" | "bedrock" | "vertex" | "anthropic" | "azure" | "google-ai" | "huggingface" | "ollama" | "mistral" | "auto";
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
@@ -30,12 +32,51 @@ export interface TextGenerationResult {
         totalTokens?: number;
     };
     responseTime?: number;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        toolName: string;
+        executionTime: number;
+        success: boolean;
+        serverId?: string;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+        server: string;
+        category?: string;
+    }>;
 }
 export declare class NeuroLink {
+    private mcpInitialized;
+    private contextManager;
+    constructor();
+    /**
+     * Initialize MCP registry with enhanced error handling and resource cleanup
+     * Uses isolated async context to prevent hanging
+     */
+    private initializeMCP;
+    /**
+     * Isolated MCP initialization to prevent context-dependent hanging
+     */
+    private doIsolatedMCPInitialization;
     /**
      * Generate text using the best available AI provider with automatic fallback
+     * Tools are ENABLED BY DEFAULT for natural AI behavior
      */
     generateText(options: TextGenerationOptions): Promise<TextGenerationResult>;
+    /**
+     * Generate text with real MCP tool integration using automatic detection
+     */
+    private generateTextWithTools;
+    /**
+     * Regular text generation (existing logic)
+     */
+    private generateTextRegular;
+    /**
+     * Create tool-aware system prompt that informs AI about available tools
+     */
+    private createToolAwareSystemPrompt;
     /**
      * Generate streaming text using the best available AI provider with automatic fallback
      */
@@ -50,4 +91,25 @@ export declare class NeuroLink {
      * Test a specific provider
      */
     testProvider(providerName: AIProviderName, testPrompt?: string): Promise<boolean>;
+    /**
+     * Get access to the unified MCP registry for tool inspection and management
+     */
+    getUnifiedRegistry(): import("./mcp/unified-registry.js").UnifiedMCPRegistry;
+    /**
+     * Initialize MCP and return discovery statistics
+     */
+    getMCPStatus(): Promise<{
+        mcpInitialized: boolean;
+        totalServers: number;
+        availableServers: number;
+        autoDiscoveredCount: number;
+        totalTools: number;
+        autoDiscoveredServers: {
+            id: string;
+            name: string;
+            source: import("./mcp/unified-registry.js").ServerSource;
+            status: "unknown" | "available" | "unavailable" | "activated";
+            hasServer: boolean;
+        }[];
+    }>;
 }

package/dist/neurolink.js

@@ -1,61 +1,253 @@
 /**
- * NeuroLink - Unified AI Interface
+ * NeuroLink - Unified AI Interface with Real MCP Tool Integration
  *
- * Simple wrapper around the AI provider system to provide a clean API
- * for CLI and other consumers.
+ * Enhanced AI provider system with natural MCP tool access.
+ * Uses real MCP infrastructure for    // Initialize MCP with enhanced error handling
+    await this.initializeMCP();tool discovery and execution.
  */
-import { AIProviderFactory, createBestAIProvider } from './index.js';
-import { getBestProvider } from './utils/providerUtils.js';
-import { logger } from './utils/logger.js';
+import { AIProviderFactory } from "./index.js";
+import { ContextManager } from "./mcp/context-manager.js";
+import { mcpLogger } from "./mcp/logging.js";
+import { defaultToolRegistry } from "./mcp/registry.js";
+import { defaultUnifiedRegistry } from "./mcp/unified-registry.js";
+import { logger } from "./utils/logger.js";
+import { getBestProvider } from "./utils/providerUtils.js";
 export class NeuroLink {
+    mcpInitialized = false;
+    contextManager;
+    constructor() {
+        this.contextManager = new ContextManager();
+    }
+    /**
+     * Initialize MCP registry with enhanced error handling and resource cleanup
+     * Uses isolated async context to prevent hanging
+     */
+    async initializeMCP() {
+        if (this.mcpInitialized) {
+            return;
+        }
+        try {
+            mcpLogger.debug("[NeuroLink] Starting isolated MCP initialization...");
+            // Use Promise.race with aggressive timeout and isolated context
+            const initTimeout = 3000; // 3 seconds max (reduced from 5)
+            const mcpInitPromise = Promise.race([
+                this.doIsolatedMCPInitialization(),
+                new Promise((_, reject) => {
+                    const timer = setTimeout(() => {
+                        reject(new Error("MCP initialization timeout after 3s"));
+                    }, initTimeout);
+                    timer.unref(); // Don't keep process alive
+                }),
+            ]);
+            await mcpInitPromise;
+            this.mcpInitialized = true;
+            mcpLogger.debug("[NeuroLink] MCP tool integration initialized successfully");
+        }
+        catch (error) {
+            mcpLogger.warn("[NeuroLink] MCP initialization failed, continuing without tools:", error);
+            // Mark as initialized to prevent infinite retries
+            this.mcpInitialized = true;
+        }
+    }
+    /**
+     * Isolated MCP initialization to prevent context-dependent hanging
+     */
+    async doIsolatedMCPInitialization() {
+        try {
+            // Initialize only the essential built-in tools without complex registry
+            mcpLogger.debug("[NeuroLink] Initializing essential MCP tools...");
+            // Use dynamic import in isolated context to avoid circular dependencies
+            const { initializeNeuroLinkMCP, isNeuroLinkMCPInitialized } = await import("./mcp/initialize.js");
+            // Only initialize if not already done
+            if (!isNeuroLinkMCPInitialized()) {
+                await initializeNeuroLinkMCP();
+            }
+            mcpLogger.debug("[NeuroLink] Essential MCP tools initialized successfully");
+        }
+        catch (error) {
+            mcpLogger.warn("[NeuroLink] Isolated MCP initialization failed:", error);
+            throw error;
+        }
+    }
     /**
      * Generate text using the best available AI provider with automatic fallback
+     * Tools are ENABLED BY DEFAULT for natural AI behavior
      */
     async generateText(options) {
+        // Tools are DEFAULT behavior unless explicitly disabled
+        if (options.disableTools === true) {
+            return this.generateTextRegular(options);
+        }
+        // Default: Generate with tools (natural AI behavior)
+        return this.generateTextWithTools(options);
+    }
+    /**
+     * Generate text with real MCP tool integration using automatic detection
+     */
+    async generateTextWithTools(options) {
+        const startTime = Date.now();
+        const functionTag = "NeuroLink.generateTextWithTools";
+        // Initialize MCP if needed
+        await this.initializeMCP();
+        // Create execution context for tool operations
+        const context = this.contextManager.createContext({
+            sessionId: `neurolink-${Date.now()}`,
+            userId: "neurolink-user",
+            aiProvider: options.provider || "auto",
+        });
+        // Determine provider to use
+        const providerName = options.provider === "auto" || !options.provider
+            ? await getBestProvider()
+            : options.provider;
+        try {
+            mcpLogger.debug(`[${functionTag}] Starting MCP-enabled generation`, {
+                provider: providerName,
+                prompt: options.prompt.substring(0, 100) + "...",
+                contextId: context.sessionId,
+            });
+            // Get available tools from default registry (simplified approach)
+            let availableTools = [];
+            try {
+                // Use defaultToolRegistry directly instead of unified registry to avoid hanging
+                const allTools = defaultToolRegistry.listTools();
+                availableTools = allTools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description || "No description available",
+                    server: tool.server,
+                    category: tool.category,
+                }));
+                mcpLogger.debug(`[${functionTag}] Found ${availableTools.length} available tools from default registry`, {
+                    tools: availableTools.map((t) => t.name),
+                });
+            }
+            catch (error) {
+                mcpLogger.warn(`[${functionTag}] Failed to get available tools`, {
+                    error,
+                });
+            }
+            // Create tool-aware system prompt
+            const enhancedSystemPrompt = this.createToolAwareSystemPrompt(options.systemPrompt, availableTools);
+            // Create provider with MCP enabled using best provider function
+            const provider = await AIProviderFactory.createBestProvider(providerName, undefined, true);
+            // Generate text with automatic tool detection
+            const result = await provider.generateText({
+                prompt: options.prompt,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: enhancedSystemPrompt,
+            }, options.schema);
+            if (!result) {
+                throw new Error("No response received from AI provider");
+            }
+            const responseTime = Date.now() - startTime;
+            // Extract MCP metadata if available
+            const metadata = result.metadata || {};
+            mcpLogger.debug(`[${functionTag}] MCP-enabled generation completed`, {
+                responseTime,
+                toolsUsed: metadata.toolsUsed || [],
+                enhancedWithTools: metadata.enhancedWithTools || false,
+                availableToolsCount: availableTools.length,
+            });
+            // Check if we actually got content
+            if (!result.text || result.text.trim() === "") {
+                mcpLogger.warn(`[${functionTag}] Empty response from provider, attempting fallback`, {
+                    provider: providerName,
+                    hasText: !!result.text,
+                    textLength: result.text?.length || 0,
+                });
+                // Fall back to regular generation if MCP generation returns empty
+                return this.generateTextRegular(options);
+            }
+            return {
+                content: result.text,
+                provider: providerName,
+                usage: result.usage,
+                responseTime,
+                toolsUsed: metadata.toolsUsed || [],
+                enhancedWithTools: metadata.enhancedWithTools || false,
+                availableTools: availableTools.length > 0 ? availableTools : undefined,
+            };
+        }
+        catch (error) {
+            // Fall back to regular generation if MCP fails
+            mcpLogger.warn(`[${functionTag}] MCP generation failed, falling back to regular`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return this.generateTextRegular(options);
+        }
+    }
+    /**
+     * Regular text generation (existing logic)
+     */
+    async generateTextRegular(options) {
         const startTime = Date.now();
-        const functionTag = 'NeuroLink.generateText';
+        const functionTag = "NeuroLink.generateTextRegular";
         // Define fallback provider priority order
-        const providerPriority = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama'];
-        const requestedProvider = options.provider === 'auto' ? undefined : options.provider;
+        const providerPriority = [
+            "openai",
+            "vertex",
+            "bedrock",
+            "anthropic",
+            "azure",
+            "google-ai",
+            "huggingface",
+            "ollama",
+        ];
+        const requestedProvider = options.provider === "auto" ? undefined : options.provider;
         // Local providers that should not fall back when explicitly requested
-        const localProviders = ['ollama'];
+        const localProviders = ["ollama"];
         // If specific provider requested, check if we should allow fallback
         const tryProviders = requestedProvider
-            ? (localProviders.includes(requestedProvider)
+            ? localProviders.includes(requestedProvider)
                 ? [requestedProvider] // No fallback for local providers
-                : [requestedProvider, ...providerPriority.filter(p => p !== requestedProvider)])
+                : [
+                    requestedProvider,
+                    ...providerPriority.filter((p) => p !== requestedProvider),
+                ]
             : providerPriority;
         logger.debug(`[${functionTag}] Starting text generation`, {
-            requestedProvider: requestedProvider || 'auto',
+            requestedProvider: requestedProvider || "auto",
             tryProviders,
             allowFallback: !requestedProvider || !localProviders.includes(requestedProvider),
-            promptLength: options.prompt.length
+            promptLength: options.prompt.length,
         });
         let lastError = null;
         for (const providerName of tryProviders) {
             try {
-                logger.debug(`[${functionTag}] Attempting provider`, { provider: providerName });
-                const provider = AIProviderFactory.createProvider(providerName);
+                logger.debug(`[${functionTag}] Attempting provider`, {
+                    provider: providerName,
+                });
+                const provider = await AIProviderFactory.createProvider(providerName);
                 const result = await provider.generateText({
                     prompt: options.prompt,
                     temperature: options.temperature,
                     maxTokens: options.maxTokens,
-                    systemPrompt: options.systemPrompt
+                    systemPrompt: options.systemPrompt,
                 }, options.schema);
                 if (!result) {
-                    throw new Error('No response received from AI provider');
+                    throw new Error("No response received from AI provider");
+                }
+                // Check if we actually got content
+                if (!result.text || result.text.trim() === "") {
+                    logger.warn(`[${functionTag}] Empty response from provider`, {
+                        provider: providerName,
+                        hasText: !!result.text,
+                        textLength: result.text?.length || 0,
+                    });
+                    // Continue to next provider if available
+                    throw new Error(`Empty response from ${providerName}`);
                 }
                 const responseTime = Date.now() - startTime;
                 logger.debug(`[${functionTag}] Provider succeeded`, {
                     provider: providerName,
                     responseTime,
-                    usage: result.usage
+                    usage: result.usage,
                 });
                 return {
-                    content: result.text || '',
+                    content: result.text,
                     provider: providerName,
                     usage: result.usage,
-                    responseTime
+                    responseTime,
                 };
             }
             catch (error) {
@@ -64,7 +256,7 @@ export class NeuroLink {
                 logger.debug(`[${functionTag}] Provider failed, trying next`, {
                     provider: providerName,
                     error: errorMessage,
-                    remainingProviders: tryProviders.slice(tryProviders.indexOf(providerName) + 1)
+                    remainingProviders: tryProviders.slice(tryProviders.indexOf(providerName) + 1),
                 });
                 // Continue to next provider
                 continue;
@@ -73,47 +265,87 @@ export class NeuroLink {
         // All providers failed
         logger.debug(`[${functionTag}] All providers failed`, {
             triedProviders: tryProviders,
-            lastError: lastError?.message
+            lastError: lastError?.message,
         });
-        throw new Error(`Failed to generate text with all providers. Last error: ${lastError?.message || 'Unknown error'}`);
+        throw new Error(`Failed to generate text with all providers. Last error: ${lastError?.message || "Unknown error"}`);
+    }
+    /**
+     * Create tool-aware system prompt that informs AI about available tools
+     */
+    createToolAwareSystemPrompt(originalSystemPrompt, availableTools) {
+        const basePrompt = originalSystemPrompt || "You are a helpful AI assistant.";
+        if (availableTools.length === 0) {
+            return basePrompt;
+        }
+        const toolDescriptions = availableTools
+            .map((tool) => `- ${tool.name}: ${tool.description}`)
+            .join("\n");
+        return `${basePrompt}
+
+Available tools that can be used when relevant:
+
+${toolDescriptions}
+
+You can mention these capabilities when they're relevant to user questions. For example:
+- For time questions: "I can get the current time"
+- For provider questions: "I can check AI provider status"
+- For tool questions: "I can list available tools"
+
+Note: Tool integration is currently in development. Please provide helpful responses based on your knowledge while mentioning tool capabilities when relevant.`;
     }
     /**
      * Generate streaming text using the best available AI provider with automatic fallback
      */
     async generateTextStream(options) {
-        const functionTag = 'NeuroLink.generateTextStream';
+        const functionTag = "NeuroLink.generateTextStream";
         // Define fallback provider priority order
-        const providerPriority = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama'];
-        const requestedProvider = options.provider === 'auto' ? undefined : options.provider;
+        const providerPriority = [
+            "openai",
+            "vertex",
+            "bedrock",
+            "anthropic",
+            "azure",
+            "google-ai",
+            "huggingface",
+            "ollama",
+        ];
+        const requestedProvider = options.provider === "auto" ? undefined : options.provider;
         // Local providers that should not fall back when explicitly requested
-        const localProviders = ['ollama'];
+        const localProviders = ["ollama"];
         // If specific provider requested, check if we should allow fallback
         const tryProviders = requestedProvider
-            ? (localProviders.includes(requestedProvider)
+            ? localProviders.includes(requestedProvider)
                 ? [requestedProvider] // No fallback for local providers
-                : [requestedProvider, ...providerPriority.filter(p => p !== requestedProvider)])
+                : [
+                    requestedProvider,
+                    ...providerPriority.filter((p) => p !== requestedProvider),
+                ]
             : providerPriority;
         logger.debug(`[${functionTag}] Starting stream generation`, {
-            requestedProvider: requestedProvider || 'auto',
+            requestedProvider: requestedProvider || "auto",
             tryProviders,
             allowFallback: !requestedProvider || !localProviders.includes(requestedProvider),
-            promptLength: options.prompt.length
+            promptLength: options.prompt.length,
         });
         let lastError = null;
         for (const providerName of tryProviders) {
             try {
-                logger.debug(`[${functionTag}] Attempting provider`, { provider: providerName });
-                const provider = AIProviderFactory.createProvider(providerName);
+                logger.debug(`[${functionTag}] Attempting provider`, {
+                    provider: providerName,
+                });
+                const provider = await AIProviderFactory.createProvider(providerName);
                 const result = await provider.streamText({
                     prompt: options.prompt,
                     temperature: options.temperature,
                     maxTokens: options.maxTokens,
-                    systemPrompt: options.systemPrompt
+                    systemPrompt: options.systemPrompt,
                 });
                 if (!result) {
-                    throw new Error('No stream response received from AI provider');
+                    throw new Error("No stream response received from AI provider");
                 }
-                logger.debug(`[${functionTag}] Provider succeeded`, { provider: providerName });
+                logger.debug(`[${functionTag}] Provider succeeded`, {
+                    provider: providerName,
+                });
                 // Convert the AI SDK stream to our expected format
                 async function* convertStream() {
                     if (result && result.textStream) {
@@ -130,7 +362,7 @@ export class NeuroLink {
                 logger.debug(`[${functionTag}] Provider failed, trying next`, {
                     provider: providerName,
                     error: errorMessage,
-                    remainingProviders: tryProviders.slice(tryProviders.indexOf(providerName) + 1)
+                    remainingProviders: tryProviders.slice(tryProviders.indexOf(providerName) + 1),
                 });
                 // Continue to next provider
                 continue;
@@ -139,9 +371,9 @@ export class NeuroLink {
         // All providers failed
         logger.debug(`[${functionTag}] All providers failed`, {
             triedProviders: tryProviders,
-            lastError: lastError?.message
+            lastError: lastError?.message,
         });
-        throw new Error(`Failed to stream text with all providers. Last error: ${lastError?.message || 'Unknown error'}`);
+        throw new Error(`Failed to stream text with all providers. Last error: ${lastError?.message || "Unknown error"}`);
     }
     /**
      * Get the best available AI provider
@@ -152,9 +384,9 @@ export class NeuroLink {
     /**
      * Test a specific provider
      */
-    async testProvider(providerName, testPrompt = 'test') {
+    async testProvider(providerName, testPrompt = "test") {
         try {
-            const provider = AIProviderFactory.createProvider(providerName);
+            const provider = await AIProviderFactory.createProvider(providerName);
             await provider.generateText(testPrompt);
             return true;
         }
@@ -162,4 +394,34 @@ export class NeuroLink {
             return false;
         }
     }
+    /**
+     * Get access to the unified MCP registry for tool inspection and management
+     */
+    getUnifiedRegistry() {
+        return defaultUnifiedRegistry;
+    }
+    /**
+     * Initialize MCP and return discovery statistics
+     */
+    async getMCPStatus() {
+        await this.initializeMCP();
+        const totalServers = defaultUnifiedRegistry.getTotalServerCount();
+        const availableServers = defaultUnifiedRegistry.getAvailableServerCount();
+        const autoDiscoveredServers = defaultUnifiedRegistry.getAutoDiscoveredServers();
+        const allTools = await defaultUnifiedRegistry.listAllTools();
+        return {
+            mcpInitialized: this.mcpInitialized,
+            totalServers,
+            availableServers,
+            autoDiscoveredCount: autoDiscoveredServers.size,
+            totalTools: allTools.length,
+            autoDiscoveredServers: Array.from(autoDiscoveredServers.entries()).map(([id, server]) => ({
+                id: server.id,
+                name: server.config?.name || id,
+                source: server.source,
+                status: server.status,
+                hasServer: !!server.server,
+            })),
+        };
+    }
 }

package/dist/providers/agent-enhanced-provider.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Agent-Enhanced Provider for NeuroLink CLI
+ * Integrates direct tools with AI providers for true agent functionality
+ */
+import { type GenerateTextResult, type StreamTextResult, type ToolSet } from "ai";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+/**
+ * Agent configuration options
+ */
+interface AgentConfig {
+    provider: "openai" | "google-ai" | "anthropic";
+    model?: string;
+    toolCategory?: "basic" | "filesystem" | "utility" | "all";
+    maxSteps?: number;
+    enableTools?: boolean;
+}
+/**
+ * Agent-Enhanced Provider Class
+ * Provides AI generation with tool calling capabilities
+ */
+export declare class AgentEnhancedProvider implements AIProvider {
+    private config;
+    private model;
+    constructor(config: AgentConfig);
+    private createModel;
+    generateText(optionsOrPrompt: TextGenerationOptions | string): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    streamText(optionsOrPrompt: StreamTextOptions | string): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    /**
+     * Determine if we should force tool usage based on prompt patterns
+     */
+    private shouldForceToolUsage;
+    getCapabilities(): string[];
+    getProviderName(): string;
+    getModelName(): string;
+    /**
+     * Test agent functionality
+     */
+    testAgentCapabilities(): Promise<{
+        success: boolean;
+        results: any[];
+    }>;
+    /**
+     * Create agent-enhanced provider factory
+     */
+    static createAgent(config: AgentConfig): AgentEnhancedProvider;
+    /**
+     * Create multiple agent providers for comparison
+     */
+    static createMultiProviderAgents(): Record<string, AgentEnhancedProvider>;
+}
+/**
+ * Helper function to create agent provider
+ */
+export declare function createAgentProvider(provider: "openai" | "google-ai" | "anthropic", options?: Partial<AgentConfig>): AgentEnhancedProvider;
+/**
+ * Test all available agent providers
+ */
+export declare function testAllAgentProviders(): Promise<void>;
+export {};