@juspay/neurolink 5.0.0 → 5.2.0

package/dist/mcp/initialize.js

@@ -5,6 +5,7 @@
  */
 import { toolRegistry, defaultToolRegistry, } from "./tool-registry.js";
 import { mcpLogger } from "./logging.js";
+import { ServiceRegistry } from "../core/service-registry.js";
 let isInitialized = false;
 /**
  * Initialize NeuroLink MCP system by registering built-in servers
@@ -15,19 +16,28 @@ export async function initializeNeuroLinkMCP(targetRegistry) {
     }
     mcpLogger.debug("Initializing built-in MCP servers...");
     try {
+        // First, register AIProviderFactory in ServiceRegistry to break circular dependencies
+        ServiceRegistry.register("AIProviderFactory", async () => {
+            const { AIProviderFactory } = await import("../core/factory.js");
+            return AIProviderFactory;
+        });
+        mcpLogger.debug("Registered AIProviderFactory in ServiceRegistry");
         // 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 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 registry.registerServer(aiCoreServer.id, aiCoreServer);
-        // mcpLogger.debug('Registered neurolink-ai-core server with AI tools');
+        // Now safe to import and register AI core server
+        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
+        await registry.registerServer(aiCoreServer.id, aiCoreServer);
+        mcpLogger.debug("Registered neurolink-ai-core server with AI tools");
+        // Register direct tools server
+        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
+        await registry.registerServer(directToolsServer.id, directToolsServer);
+        mcpLogger.debug("Registered neurolink-direct server with direct tools");
         const stats = await registry.getStats();
-        mcpLogger.info(`Initialization complete: ${stats.totalServers} server, ${stats.totalTools} tools available`);
+        mcpLogger.info(`Initialization complete: ${stats.totalServers} servers, ${stats.totalTools} tools available`);
         isInitialized = true;
     }
     catch (error) {

package/dist/mcp/neurolink-mcp-client.js

@@ -94,14 +94,14 @@ Examples:
 
 Response (JSON object only):`;
         try {
-            const response = await this.provider.generateText({
+            const response = await this.provider.generate({
                 prompt: extractionPrompt,
                 temperature: 0,
                 maxTokens: 200,
             });
-            if (response?.text) {
+            if (response?.content) {
                 // Extract JSON object from response
-                const match = response.text.match(/\{([^}]*)\}/);
+                const match = response.content.match(/\{([^}]*)\}/);
                 if (match) {
                     try {
                         const params = JSON.parse(match[0]);
@@ -153,14 +153,14 @@ Examples:
 
 Response (JSON array only):`;
             try {
-                const response = await this.provider.generateText({
+                const response = await this.provider.generate({
                     prompt: analysisPrompt,
                     temperature: 0,
                     maxTokens: 200,
                 });
-                if (response?.text) {
+                if (response?.content) {
                     // Extract JSON array from response
-                    const match = response.text.match(/\[([^\]]*)\]/);
+                    const match = response.content.match(/\[([^\]]*)\]/);
                     if (match) {
                         try {
                             const toolNames = JSON.parse(match[0]);
@@ -317,8 +317,8 @@ Response (JSON array only):`;
     async generateResponse(prompt, toolResults) {
         // If no tools were used, generate regular response
         if (toolResults.length === 0) {
-            const response = await this.provider.generateText({ prompt });
-            return response?.text || "";
+            const response = await this.provider.generate({ prompt });
+            return response?.content || "";
         }
         // Extract human-readable results from tool executions
         const toolResultsText = toolResults
@@ -379,12 +379,12 @@ Tool results: ${toolResultsText}
 
 Please provide a natural response based on the tool results.`;
         // Generate final response
-        const response = await this.provider.generateText({
+        const response = await this.provider.generate({
             prompt: enhancedPrompt,
             temperature: 0.7,
             maxTokens: DEFAULT_MAX_TOKENS,
         });
-        return response?.text || toolResultsText;
+        return response?.content || toolResultsText;
     }
     /**
      * Send a prompt and automatically execute any needed tools

package/dist/mcp/orchestrator.js

@@ -303,8 +303,8 @@ export class MCPOrchestrator {
             }
             // Step 2: Text generation
             steps.push({
-                stepId: "generate-text",
-                toolName: "generate-text",
+                stepId: "generate",
+                toolName: "generate",
                 params: {
                     prompt,
                     provider: options.provider,
@@ -324,7 +324,7 @@ export class MCPOrchestrator {
                         params: {
                         /* tool-specific params */
                         },
-                        dependsOn: ["generate-text"],
+                        dependsOn: ["generate"],
                     });
                 }
             }
@@ -336,7 +336,7 @@ export class MCPOrchestrator {
             });
             const executionTime = Date.now() - startTime;
             // Extract text generation result
-            const textResult = pipelineResult.results.get("generate-text");
+            const textResult = pipelineResult.results.get("generate");
             const providerResult = pipelineResult.results.get("select-provider");
             if (!textResult || !textResult.success) {
                 throw new Error("Text generation failed");

package/dist/mcp/servers/agent/direct-tools-server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * NeuroLink Direct Tools Server
+ * Wraps the agent direct tools as an MCP server for proper registration
+ */
+/**
+ * Direct Tools Server - Agent direct tools for immediate use
+ */
+export declare const directToolsServer: import("../../factory.js").NeuroLinkMCPServer;

package/dist/mcp/servers/agent/direct-tools-server.js

@@ -0,0 +1,109 @@
+/**
+ * NeuroLink Direct Tools Server
+ * Wraps the agent direct tools as an MCP server for proper registration
+ */
+import { createMCPServer } from "../../factory.js";
+import { directAgentTools } from "../../../agent/direct-tools.js";
+import { logger } from "../../../utils/logger.js";
+/**
+ * Direct Tools Server - Agent direct tools for immediate use
+ */
+export const directToolsServer = createMCPServer({
+    id: "neurolink-direct",
+    title: "NeuroLink Direct Tools Server",
+    description: "Provides direct agent tools for immediate execution",
+    category: "integrations",
+    version: "1.0.0",
+});
+/**
+ * Wrap each direct tool and register it with the server
+ */
+Object.entries(directAgentTools).forEach(([toolName, toolDef]) => {
+    // The toolDef is a Vercel AI SDK Tool object
+    // Extract properties from the Tool object
+    const toolSpec = toolDef._spec || toolDef;
+    const description = toolSpec.description || `Direct tool: ${toolName}`;
+    const inputSchema = toolSpec.parameters;
+    const execute = toolSpec.execute;
+    directToolsServer.registerTool({
+        name: toolName,
+        description: description,
+        category: getToolCategory(toolName),
+        inputSchema: inputSchema,
+        isImplemented: true,
+        execute: async (params, context) => {
+            const startTime = Date.now();
+            try {
+                logger.debug(`[Direct Tools] Executing ${toolName} with params:`, params);
+                // Execute the direct tool
+                const result = await execute(params);
+                // Convert direct tool result to ToolResult format
+                if (result.success) {
+                    return {
+                        success: true,
+                        data: result,
+                        usage: {
+                            executionTime: Date.now() - startTime,
+                        },
+                        metadata: {
+                            toolName,
+                            serverId: "neurolink-direct",
+                            sessionId: context.sessionId,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        success: false,
+                        data: null,
+                        error: result.error || "Unknown error",
+                        usage: {
+                            executionTime: Date.now() - startTime,
+                        },
+                        metadata: {
+                            toolName,
+                            serverId: "neurolink-direct",
+                            sessionId: context.sessionId,
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                logger.error(`[Direct Tools] Error executing ${toolName}:`, error);
+                return {
+                    success: false,
+                    data: null,
+                    error: error instanceof Error ? error.message : String(error),
+                    usage: {
+                        executionTime: Date.now() - startTime,
+                    },
+                    metadata: {
+                        toolName,
+                        serverId: "neurolink-direct",
+                        sessionId: context.sessionId,
+                    },
+                };
+            }
+        },
+    });
+});
+/**
+ * Get tool category based on tool name
+ */
+function getToolCategory(toolName) {
+    switch (toolName) {
+        case "getCurrentTime":
+            return "time";
+        case "calculateMath":
+            return "math";
+        case "readFile":
+        case "writeFile":
+        case "listDirectory":
+        case "searchFiles":
+            return "filesystem";
+        default:
+            return "utility";
+    }
+}
+// Log successful registration
+logger.info(`[Direct Tools] Registered ${Object.keys(directAgentTools).length} direct tools`);

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

@@ -108,15 +108,15 @@ export const analyzeAIUsageTool = {
         - "analysis" should contain: timeRange, totalRequests, totalTokens, and a "providers" object.
         - "insights" should contain: mostUsedProvider, avgCostPerToken, peakUsageHours, costOptimizationPotential, and an array of "recommendations".
       `;
-            const result = await provider.generateText({
+            const result = await provider.generate({
                 prompt: analysisPrompt,
                 maxTokens: 800,
                 temperature: 0.5,
             });
-            if (!result || !result.text) {
+            if (!result || !result.content) {
                 throw new Error("AI provider returned no result for usage analysis.");
             }
-            const parsedData = JSON.parse(result.text);
+            const parsedData = JSON.parse(result.content);
             const executionTime = Date.now() - startTime;
             return {
                 success: true,
@@ -190,8 +190,8 @@ export const benchmarkProviderPerformanceTool = {
                 for (const prompt of testPrompts) {
                     for (let i = 0; i < params.iterations; i++) {
                         const testStartTime = Date.now();
-                        const result = await provider.generateText({
-                            prompt,
+                        const result = await provider.generate({
+                            prompt: prompt,
                             maxTokens: params.maxTokens,
                         });
                         if (result && result.usage) {
@@ -274,7 +274,7 @@ export const optimizePromptParametersTool = {
             const optimizationResults = [];
             const temperatures = [0.2, 0.7, 1.0]; // Test a range of temperatures
             for (const temp of temperatures) {
-                const result = await provider.generateText({
+                const result = await provider.generate({
                     prompt: params.prompt,
                     temperature: temp,
                     maxTokens: params.targetLength || 250,
@@ -282,7 +282,7 @@ export const optimizePromptParametersTool = {
                 if (result) {
                     optimizationResults.push({
                         parameters: { temperature: temp },
-                        output: result.text,
+                        output: result.content,
                         usage: result.usage,
                     });
                 }
@@ -300,14 +300,14 @@ export const optimizePromptParametersTool = {
         Determine which set of parameters is optimal and provide a recommendation.
         Return a valid JSON object with keys: "optimalParameters", "reasoning", "recommendations".
       `;
-            const analysisResult = await analysisProvider.generateText({
+            const analysisResult = await analysisProvider.generate({
                 prompt: analysisPrompt,
                 maxTokens: 500,
             });
-            if (!analysisResult || !analysisResult.text) {
+            if (!analysisResult || !analysisResult.content) {
                 throw new Error("Optimization analysis failed.");
             }
-            const parsedAnalysis = JSON.parse(analysisResult.text);
+            const parsedAnalysis = JSON.parse(analysisResult.content);
             const executionTime = Date.now() - startTime;
             return {
                 success: true,

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

@@ -5,7 +5,7 @@
  */
 import { z } from "zod";
 import { createMCPServer } from "../../factory.js";
-import { AIProviderFactory } from "../../../core/factory.js";
+import { ServiceRegistry } from "../../../core/service-registry.js";
 import { getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
 import { logger } from "../../../utils/logger.js";
 import { analyzeAIUsageTool, benchmarkProviderPerformanceTool, optimizePromptParametersTool, } from "./ai-analysis-tools.js";
@@ -75,7 +75,7 @@ const ProviderSelectionSchema = z.object({
  * Core tool that leverages existing AIProviderFactory for text generation
  */
 aiCoreServer.registerTool({
-    name: "generate-text",
+    name: "generate",
     description: "Generate text using AI providers with automatic fallback and provider selection",
     category: "text-generation",
     inputSchema: TextGenerationSchema,
@@ -86,9 +86,11 @@ aiCoreServer.registerTool({
             logger.debug(`[AI-Core] Starting text generation: "${params.prompt.substring(0, 50)}..."`);
             // Use existing AIProviderFactory with best provider selection
             const selectedProvider = params.provider || (await getBestProvider(params.provider));
+            // Get AIProviderFactory from ServiceRegistry to avoid circular dependency
+            const AIProviderFactory = await ServiceRegistry.get("AIProviderFactory");
             const provider = await AIProviderFactory.createBestProvider(selectedProvider);
             // Generate text using existing NeuroLink patterns
-            const result = await provider.generateText({
+            const result = await provider.generate({
                 prompt: params.prompt,
                 model: params.model,
                 temperature: params.temperature,
@@ -103,7 +105,7 @@ aiCoreServer.registerTool({
             return {
                 success: true,
                 data: {
-                    text: result.text,
+                    text: result.content,
                     model: params.model || "default",
                     provider: selectedProvider,
                     generatedAt: new Date().toISOString(),
@@ -115,7 +117,7 @@ aiCoreServer.registerTool({
                     executionTime,
                 },
                 metadata: {
-                    toolName: "generate-text",
+                    toolName: "generate",
                     serverId: "neurolink-ai-core",
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
@@ -131,7 +133,7 @@ aiCoreServer.registerTool({
                 success: false,
                 error: errorMessage,
                 metadata: {
-                    toolName: "generate-text",
+                    toolName: "generate",
                     serverId: "neurolink-ai-core",
                     sessionId: context.sessionId,
                     timestamp: Date.now(),

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

@@ -88,14 +88,14 @@ export declare const workflowToolSchemas: {
     }, "strip", z.ZodTypeAny, {
         aiOutput: string;
         expectedBehavior: string;
-        outputType: "code" | "text" | "conversation" | "structured-data";
+        outputType: "text" | "code" | "structured-data" | "conversation";
         includeFixSuggestions: boolean;
         context?: string | undefined;
     }, {
         aiOutput: string;
         expectedBehavior: string;
         context?: string | undefined;
-        outputType?: "code" | "text" | "conversation" | "structured-data" | undefined;
+        outputType?: "text" | "code" | "structured-data" | "conversation" | undefined;
         includeFixSuggestions?: boolean | undefined;
     }>;
 };

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

@@ -144,16 +144,16 @@ Return ONLY a valid JSON object with this exact structure:
 }
 
 Generate 3-5 comprehensive test cases covering the requested types.`;
-            const result = await provider.generateText({
-                prompt,
+            const result = await provider.generate({
+                prompt: prompt,
                 maxTokens: Math.floor(DEFAULT_MAX_TOKENS * 1.2),
                 temperature: 0.3, // Lower temperature for more consistent structured output
             });
-            if (!result || !result.text) {
+            if (!result || !result.content) {
                 throw new Error("AI provider returned no result for test case generation.");
             }
             // Parse AI response
-            const aiResponse = JSON.parse(result.text);
+            const aiResponse = JSON.parse(result.content);
             const testCases = aiResponse.testCases || [];
             const executionTime = Date.now() - startTime;
             const responseData = {
@@ -250,16 +250,16 @@ Return ONLY a valid JSON object with this exact structure:
 }
 
 Focus on real, actionable improvements based on the specified objectives.`;
-            const result = await provider.generateText({
-                prompt,
+            const result = await provider.generate({
+                prompt: prompt,
                 maxTokens: DEFAULT_MAX_TOKENS,
                 temperature: 0.2, // Very low temperature for consistent refactoring
             });
-            if (!result || !result.text) {
+            if (!result || !result.content) {
                 throw new Error("AI provider returned no result for code refactoring.");
             }
             // Parse AI response
-            const aiResponse = JSON.parse(result.text);
+            const aiResponse = JSON.parse(result.content);
             const executionTime = Date.now() - startTime;
             const responseData = {
                 refactoredCode: aiResponse.refactoredCode || code,
@@ -358,16 +358,16 @@ Return ONLY a valid JSON object with this exact structure:
 }
 
 Focus on creating accurate, useful documentation that explains the code's purpose, parameters, return values, and usage patterns.`;
-            const result = await provider.generateText({
-                prompt,
+            const result = await provider.generate({
+                prompt: prompt,
                 maxTokens: Math.floor(DEFAULT_MAX_TOKENS * 1.2),
                 temperature: 0.3, // Moderate temperature for creative but structured documentation
             });
-            if (!result || !result.text) {
+            if (!result || !result.content) {
                 throw new Error("AI provider returned no result for documentation generation.");
             }
             // Parse AI response
-            const aiResponse = JSON.parse(result.text);
+            const aiResponse = JSON.parse(result.content);
             const executionTime = Date.now() - startTime;
             const responseData = {
                 documentation: aiResponse.documentation || "Documentation generated successfully",
@@ -483,16 +483,16 @@ Return ONLY a valid JSON object with this exact structure:
 }
 
 Provide thorough, actionable analysis focused on improving AI output quality.`;
-            const result = await provider.generateText({
-                prompt,
+            const result = await provider.generate({
+                prompt: prompt,
                 maxTokens: DEFAULT_MAX_TOKENS,
                 temperature: 0.4, // Moderate temperature for analytical thinking
             });
-            if (!result || !result.text) {
+            if (!result || !result.content) {
                 throw new Error("AI provider returned no result for output debugging.");
             }
             // Parse AI response
-            const aiResponse = JSON.parse(result.text);
+            const aiResponse = JSON.parse(result.content);
             const executionTime = Date.now() - startTime;
             const responseData = {
                 issues: aiResponse.issues || [],

package/dist/mcp/unified-registry.d.ts

@@ -26,6 +26,10 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
      * Load servers from .mcp-config.json
      */
     private loadManualConfig;
+    /**
+     * Connect to manually configured servers
+     */
+    private connectManualServers;
     /**
      * Enable or disable auto-discovery
      */

package/dist/mcp/unified-registry.js

@@ -4,7 +4,7 @@
 import { MCPRegistry } from "./registry.js";
 import { discoverMCPServers, autoRegisterMCPServers, } from "./auto-discovery.js";
 import { unifiedRegistryLogger } from "./logging.js";
-import { MCPToolRegistry, } from "./tool-registry.js";
+import { MCPToolRegistry, defaultToolRegistry, } from "./tool-registry.js";
 import { TransportManager, TransportConfigSchema, } from "./transport-manager.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { ErrorManager } from "./error-manager.js";
@@ -31,8 +31,18 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
      */
     async initialize(options = {}) {
         unifiedRegistryLogger.info("Initializing unified MCP registry...");
-        // Load manual configuration first
-        await this.loadManualConfig();
+        // Import ProviderRegistry to check options
+        const { ProviderRegistry } = await import("../factories/provider-registry.js");
+        const registryOptions = ProviderRegistry.getOptions();
+        // Only load manual config if explicitly enabled (CLI mode)
+        if (registryOptions.enableManualMCP) {
+            unifiedRegistryLogger.info("Manual MCP config enabled - loading .mcp-config.json");
+            await this.loadManualConfig();
+            await this.connectManualServers();
+        }
+        else {
+            unifiedRegistryLogger.debug("Manual MCP config disabled - skipping .mcp-config.json");
+        }
         if (this.autoDiscoveryEnabled) {
             const result = await autoRegisterMCPServers(options);
             unifiedRegistryLogger.info(`Auto-discovery complete: ${result.registered} registered, ${result.failed} failed`);
@@ -96,6 +106,29 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
             unifiedRegistryLogger.error("Failed to load manual config:", error instanceof Error ? error.message : String(error));
         }
     }
+    /**
+     * Connect to manually configured servers
+     */
+    async connectManualServers() {
+        for (const [serverId, serverConfig] of this.manualServers.entries()) {
+            try {
+                unifiedRegistryLogger.info(`Connecting to manual server: ${serverId}`);
+                // Use addExternalServer method which properly establishes connections
+                await this.addExternalServer(serverId, {
+                    type: "stdio",
+                    command: serverConfig.command || "npx",
+                    args: serverConfig.args || [],
+                    env: serverConfig.env,
+                });
+                unifiedRegistryLogger.info(`Successfully connected manual server: ${serverId}`);
+            }
+            catch (error) {
+                unifiedRegistryLogger.error(`Failed to connect manual server ${serverId}:`, error instanceof Error ? error.message : String(error));
+                // Remove from available servers if connection fails
+                this.availableServers.delete(serverId);
+            }
+        }
+    }
     /**
      * Enable or disable auto-discovery
      */
@@ -142,8 +175,8 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
     async listAllTools() {
         const allTools = [];
         try {
-            // FIXED: Get built-in tools from base registry
-            const builtInTools = await super.listTools();
+            // FIXED: Get built-in tools from defaultToolRegistry where they are actually registered
+            const builtInTools = await defaultToolRegistry.listTools();
             allTools.push(...builtInTools.map((tool) => ({
                 ...tool,
                 id: tool.name,
@@ -151,7 +184,7 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
                 source: "built-in",
                 isExternal: false,
             })));
-            unifiedRegistryLogger.debug(`Found ${builtInTools.length} built-in tools`);
+            unifiedRegistryLogger.debug(`Found ${builtInTools.length} built-in tools from defaultToolRegistry`);
         }
         catch (error) {
             unifiedRegistryLogger.warn("Failed to get built-in tools:", error);
@@ -195,10 +228,10 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
      */
     async executeTool(toolName, args, context) {
         unifiedRegistryLogger.info(`Executing tool: ${toolName}`);
-        // STEP 1: Try built-in tools first
+        // STEP 1: Try built-in tools first from defaultToolRegistry
         try {
-            const result = await super.executeTool(toolName, args, context);
-            unifiedRegistryLogger.info(`Tool ${toolName} executed successfully via built-in registry`);
+            const result = await defaultToolRegistry.executeTool(toolName, args, context);
+            unifiedRegistryLogger.info(`Tool ${toolName} executed successfully via defaultToolRegistry`);
             return result;
         }
         catch (builtInError) {