@juspay/neurolink 4.0.0 → 4.1.0

package/dist/lib/neurolink.js

@@ -472,6 +472,94 @@ Note: Tool integration is currently in development. Please provide helpful respo
             })),
         };
     }
+    /**
+     * Add a new MCP server programmatically
+     *
+     * Allows dynamic registration of MCP servers at runtime for enhanced
+     * tool ecosystem management. Perfect for integrating external services
+     * like Bitbucket, Slack, databases, etc.
+     *
+     * @param serverId - Unique identifier for the server (e.g., 'bitbucket', 'slack-api')
+     * @param config - Server configuration with command and execution parameters
+     * @returns Promise that resolves when server is successfully added and connected
+     *
+     * @example
+     * ```typescript
+     * // Add Bitbucket MCP server
+     * await neurolink.addMCPServer('bitbucket', {
+     *   command: 'npx',
+     *   args: ['-y', '@nexus2520/bitbucket-mcp-server'],
+     *   env: {
+     *     BITBUCKET_USERNAME: 'your-username',
+     *     BITBUCKET_APP_PASSWORD: 'your-app-password'
+     *   }
+     * });
+     *
+     * // Add custom database connector
+     * await neurolink.addMCPServer('database', {
+     *   command: 'node',
+     *   args: ['./custom-db-mcp-server.js'],
+     *   env: { DB_CONNECTION_STRING: 'postgresql://...' }
+     * });
+     * ```
+     */
+    async addMCPServer(serverId, config) {
+        const functionTag = "NeuroLink.addMCPServer";
+        mcpLogger.info(`[${functionTag}] Adding MCP server: ${serverId}`, {
+            command: config.command,
+            argsCount: config.args?.length || 0,
+            hasEnv: Object.keys(config.env || {}).length > 0,
+        });
+        try {
+            // Ensure MCP is initialized
+            await this.initializeMCP();
+            // Add server to unified registry with configurable transport type
+            const transportType = config.type || "stdio";
+            // Validate URL requirement for non-stdio transports
+            if ((transportType === "sse" || transportType === "http") &&
+                !config.url) {
+                throw new Error(`URL is required for ${transportType} transport. Please provide config.url for server '${serverId}'.`);
+            }
+            const transportConfig = {
+                type: transportType,
+                ...(transportType === "stdio" && {
+                    command: config.command,
+                    args: config.args || [],
+                    env: config.env || {},
+                    cwd: config.cwd,
+                }),
+                ...(transportType === "sse" && {
+                    url: config.url,
+                    headers: config.headers,
+                    timeout: config.timeout,
+                }),
+                ...(transportType === "http" && {
+                    url: config.url,
+                    headers: config.headers,
+                    timeout: config.timeout,
+                }),
+            };
+            await unifiedRegistry.addExternalServer(serverId, transportConfig);
+            // Check if server is actually connected vs just registered
+            const isConnected = unifiedRegistry.isConnected(serverId);
+            if (isConnected) {
+                mcpLogger.info(`[${functionTag}] Successfully connected to MCP server: ${serverId}`);
+            }
+            else {
+                mcpLogger.info(`[${functionTag}] MCP server registered: ${serverId} (connection failed, but server available for retry)`);
+            }
+        }
+        catch (error) {
+            mcpLogger.error(`[${functionTag}] Failed to add MCP server: ${serverId}`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            const newError = new Error(`Failed to add MCP server '${serverId}': ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error && error.stack) {
+                newError.stack = `${newError.stack}\nCaused by: ${error.stack}`;
+            }
+            throw newError;
+        }
+    }
     /**
      * Alias for generateText() - CLI-SDK consistency
      * @param options - Text generation options
@@ -488,4 +576,20 @@ Note: Tool integration is currently in development. Please provide helpful respo
     async gen(options) {
         return this.generateText(options);
     }
+    /**
+     * Get the connection client for a specific MCP server
+     * @param serverId - The ID of the server to get connection for
+     * @returns Client connection object or undefined if not connected
+     */
+    getConnection(serverId) {
+        return unifiedRegistry.getConnection(serverId);
+    }
+    /**
+     * Check if a specific MCP server is currently connected
+     * @param serverId - The ID of the server to check
+     * @returns True if server is connected, false otherwise
+     */
+    isConnected(serverId) {
+        return unifiedRegistry.isConnected(serverId);
+    }
 }

package/dist/mcp/dynamic-chain-executor.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Dynamic AI Tool Chain Executor
+ * Allows AI to dynamically decide tool execution sequences based on context and results
+ */
+import type { MCPOrchestrator } from "./orchestrator.js";
+import type { MCPRegistry } from "./registry.js";
+import type { NeuroLinkExecutionContext } from "./factory.js";
+import { ErrorManager } from "./error-manager.js";
+/**
+ * Tool execution result with metadata
+ */
+export interface ToolExecutionResult {
+    toolName: string;
+    success: boolean;
+    result?: any;
+    error?: Error;
+    timestamp: number;
+    executionTime: number;
+    context?: Record<string, any>;
+}
+/**
+ * Chain execution step
+ */
+export interface ChainStep {
+    stepId: string;
+    toolName: string;
+    parameters: any;
+    reasoning: string;
+    confidence: number;
+    expectedOutcome: string;
+}
+/**
+ * Chain execution context
+ */
+export interface ChainExecutionContext {
+    goal: string;
+    currentStep: number;
+    totalSteps?: number;
+    executionHistory: ToolExecutionResult[];
+    accumulatedContext: Record<string, any>;
+    userContext?: NeuroLinkExecutionContext;
+    maxSteps: number;
+    aiModel?: string;
+}
+/**
+ * Chain execution result
+ */
+export interface ChainExecutionResult {
+    success: boolean;
+    goal: string;
+    totalSteps: number;
+    executionTime: number;
+    results: ToolExecutionResult[];
+    finalResult?: any;
+    reasoning: string;
+    error?: Error;
+    metadata: {
+        toolsUsed: string[];
+        averageConfidence: number;
+        contextEvolution: Record<string, any>[];
+    };
+}
+/**
+ * AI Tool Chain Planner interface
+ */
+export interface AIChainPlanner {
+    name: string;
+    planNextStep(goal: string, availableTools: Array<{
+        name: string;
+        description: string;
+        inputSchema: any;
+    }>, executionHistory: ToolExecutionResult[], accumulatedContext: Record<string, any>): Promise<ChainStep | null>;
+    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<{
+        goalAchieved: boolean;
+        confidence: number;
+        nextAction: "continue" | "retry" | "abort" | "complete";
+        reasoning: string;
+    }>;
+}
+/**
+ * Simple AI Chain Planner using heuristics
+ */
+export declare class HeuristicChainPlanner implements AIChainPlanner {
+    name: string;
+    planNextStep(goal: string, availableTools: Array<{
+        name: string;
+        description: string;
+        inputSchema: any;
+    }>, executionHistory: ToolExecutionResult[], accumulatedContext: Record<string, any>): Promise<ChainStep | null>;
+    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<{
+        goalAchieved: boolean;
+        confidence: number;
+        nextAction: "continue" | "retry" | "abort" | "complete";
+        reasoning: string;
+    }>;
+    private generateParameters;
+}
+/**
+ * Advanced AI Chain Planner using actual AI model
+ */
+export declare class AIModelChainPlanner implements AIChainPlanner {
+    name: string;
+    private aiModel;
+    constructor(aiModel?: string);
+    planNextStep(goal: string, availableTools: Array<{
+        name: string;
+        description: string;
+        inputSchema: any;
+    }>, executionHistory: ToolExecutionResult[], accumulatedContext: Record<string, any>): Promise<ChainStep | null>;
+    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<{
+        goalAchieved: boolean;
+        confidence: number;
+        nextAction: "continue" | "retry" | "abort" | "complete";
+        reasoning: string;
+    }>;
+    private buildPlanningPrompt;
+    private buildEvaluationPrompt;
+    private callAIModel;
+    private parseAIResponse;
+    private parseEvaluationResponse;
+}
+/**
+ * Dynamic Chain Executor
+ */
+export declare class DynamicChainExecutor {
+    private orchestrator;
+    private registry;
+    private errorManager;
+    private planner;
+    constructor(orchestrator: MCPOrchestrator, registry: MCPRegistry, errorManager: ErrorManager, planner?: AIChainPlanner);
+    /**
+     * Execute dynamic tool chain to achieve a goal
+     *
+     * @param goal The goal to achieve
+     * @param initialContext Initial context data
+     * @param userContext User execution context
+     * @param options Execution options
+     * @returns Chain execution result
+     */
+    executeChain(goal: string, initialContext?: Record<string, any>, userContext?: NeuroLinkExecutionContext, options?: {
+        maxSteps?: number;
+        aiModel?: string;
+        timeout?: number;
+    }): Promise<ChainExecutionResult>;
+    /**
+     * Execute chain steps iteratively
+     *
+     * @private
+     */
+    private executeChainSteps;
+    /**
+     * Execute a single step
+     *
+     * @private
+     */
+    private executeStep;
+    /**
+     * Update accumulated context with new result
+     *
+     * @private
+     */
+    private updateAccumulatedContext;
+    /**
+     * Calculate average confidence across execution history
+     *
+     * @private
+     */
+    private calculateAverageConfidence;
+    /**
+     * Track context evolution through execution
+     *
+     * @private
+     */
+    private trackContextEvolution;
+    /**
+     * Set AI planner
+     *
+     * @param planner AI chain planner instance
+     */
+    setPlanner(planner: AIChainPlanner): void;
+    /**
+     * Get current planner
+     *
+     * @returns Current AI chain planner
+     */
+    getPlanner(): AIChainPlanner;
+}
+/**
+ * Default dynamic chain executor instance
+ */
+export declare let defaultDynamicChainExecutor: DynamicChainExecutor | null;
+/**
+ * Initialize default dynamic chain executor
+ *
+ * @param orchestrator MCP orchestrator
+ * @param registry Tool registry
+ * @param errorManager Error manager
+ * @param planner Optional AI planner
+ * @returns Dynamic chain executor instance
+ */
+export declare function initializeDynamicChainExecutor(orchestrator: MCPOrchestrator, registry: MCPRegistry, errorManager: ErrorManager, planner?: AIChainPlanner): DynamicChainExecutor;