@juspay/neurolink 4.0.0 → 4.1.1

package/dist/lib/mcp/dynamic-chain-executor.js

@@ -0,0 +1,489 @@
+/**
+ * Dynamic AI Tool Chain Executor
+ * Allows AI to dynamically decide tool execution sequences based on context and results
+ */
+import { ErrorCategory, ErrorSeverity } from "./error-manager.js";
+/**
+ * Simple AI Chain Planner using heuristics
+ */
+export class HeuristicChainPlanner {
+    name = "heuristic";
+    async planNextStep(goal, availableTools, executionHistory, accumulatedContext) {
+        // Simple heuristic-based planning
+        const usedTools = new Set(executionHistory.map((h) => h.toolName));
+        const availableUnused = availableTools.filter((t) => !usedTools.has(t.name));
+        if (availableUnused.length === 0) {
+            return null; // No more tools to try
+        }
+        // Select tool based on goal keywords and context
+        const goalLower = goal.toLowerCase();
+        let selectedTool = availableUnused[0];
+        let confidence = 0.3;
+        // Keyword-based tool selection
+        for (const tool of availableUnused) {
+            const toolDesc = tool.description.toLowerCase();
+            let toolConfidence = 0.3;
+            // Check for keyword matches
+            if (goalLower.includes("fetch") && toolDesc.includes("fetch")) {
+                toolConfidence += 0.4;
+            }
+            if (goalLower.includes("process") && toolDesc.includes("process")) {
+                toolConfidence += 0.4;
+            }
+            if (goalLower.includes("analyze") && toolDesc.includes("analy")) {
+                toolConfidence += 0.4;
+            }
+            if (goalLower.includes("data") && toolDesc.includes("data")) {
+                toolConfidence += 0.3;
+            }
+            if (toolConfidence > confidence) {
+                confidence = toolConfidence;
+                selectedTool = tool;
+            }
+        }
+        // Generate parameters based on context and previous results
+        const parameters = this.generateParameters(selectedTool, accumulatedContext, executionHistory);
+        return {
+            stepId: `step-${Date.now()}`,
+            toolName: selectedTool.name,
+            parameters,
+            reasoning: `Selected ${selectedTool.name} based on goal keywords and available context`,
+            confidence: Math.min(confidence, 0.8),
+            expectedOutcome: `Execute ${selectedTool.name} to progress towards: ${goal}`,
+        };
+    }
+    async evaluateResult(step, result, goal) {
+        if (!result.success) {
+            return {
+                goalAchieved: false,
+                confidence: 0.1,
+                nextAction: "retry",
+                reasoning: `Tool ${step.toolName} failed: ${result.error?.message}"`,
+            };
+        }
+        // Simple goal completion heuristic
+        const goalKeywords = goal.toLowerCase().split(" ");
+        const resultString = JSON.stringify(result.result || {}).toLowerCase();
+        const matchedKeywords = goalKeywords.filter((keyword) => resultString.includes(keyword) || keyword.length < 3);
+        const completionRatio = matchedKeywords.length / goalKeywords.length;
+        const goalAchieved = completionRatio > 0.6;
+        return {
+            goalAchieved,
+            confidence: completionRatio,
+            nextAction: goalAchieved ? "complete" : "continue",
+            reasoning: goalAchieved
+                ? `Goal appears achieved based on result content`
+                : `Goal not yet achieved (${Math.round(completionRatio * 100)}% match), continuing`,
+        };
+    }
+    generateParameters(tool, context, history) {
+        const params = {};
+        // Extract useful data from previous results
+        const lastResult = history[history.length - 1];
+        if (lastResult?.result) {
+            // Pass relevant data from previous step
+            if (typeof lastResult.result === "object") {
+                Object.assign(params, lastResult.result);
+            }
+            else if (typeof lastResult.result === "string") {
+                params.input = lastResult.result;
+            }
+        }
+        // Add context data
+        Object.assign(params, context);
+        return params;
+    }
+}
+/**
+ * Advanced AI Chain Planner using actual AI model
+ */
+export class AIModelChainPlanner {
+    name = "ai-model";
+    aiModel;
+    constructor(aiModel = "gpt-4") {
+        this.aiModel = aiModel;
+    }
+    async planNextStep(goal, availableTools, executionHistory, accumulatedContext) {
+        const prompt = this.buildPlanningPrompt(goal, availableTools, executionHistory, accumulatedContext);
+        try {
+            // This would integrate with actual AI service
+            // For now, return a structured response format
+            const aiResponse = await this.callAIModel(prompt);
+            return this.parseAIResponse(aiResponse);
+        }
+        catch (error) {
+            // Fallback to heuristic planning
+            console.warn("AI planning failed, falling back to heuristic", error);
+            const fallback = new HeuristicChainPlanner();
+            return fallback.planNextStep(goal, availableTools, executionHistory, accumulatedContext);
+        }
+    }
+    async evaluateResult(step, result, goal) {
+        const prompt = this.buildEvaluationPrompt(step, result, goal);
+        try {
+            const aiResponse = await this.callAIModel(prompt);
+            return this.parseEvaluationResponse(aiResponse);
+        }
+        catch (error) {
+            // Fallback to heuristic evaluation
+            const fallback = new HeuristicChainPlanner();
+            return fallback.evaluateResult(step, result, goal);
+        }
+    }
+    buildPlanningPrompt(goal, availableTools, executionHistory, accumulatedContext) {
+        return `
+You are an AI tool chain planner. Your job is to select the next tool to execute towards achieving a goal.
+
+GOAL: ${goal}
+
+AVAILABLE TOOLS:
+${availableTools.map((t) => `- ${t.name}: ${t.description}`).join("\n")}
+
+EXECUTION HISTORY:
+${executionHistory.map((h) => `${h.toolName}: ${h.success ? "SUCCESS" : "FAILED"} - ${JSON.stringify(h.result || h.error?.message)}`).join("\n")}
+
+ACCUMULATED CONTEXT:
+${JSON.stringify(accumulatedContext, null, 2)}
+
+Select the next tool to execute, or return null if the goal is achieved or no progress can be made.
+
+Respond in JSON format:
+{
+  "toolName": "tool-name",
+  "parameters": { /* tool parameters */ },
+  "reasoning": "why this tool was selected",
+  "confidence": 0.8,
+  "expectedOutcome": "what this step should achieve"
+}
+
+If no tool should be executed, return: {"toolName": null}
+`;
+    }
+    buildEvaluationPrompt(step, result, goal) {
+        return `
+Evaluate whether the goal has been achieved after executing a tool.
+
+GOAL: ${goal}
+
+EXECUTED STEP:
+Tool: ${step.toolName}
+Reasoning: ${step.reasoning}
+Expected: ${step.expectedOutcome}
+
+ACTUAL RESULT:
+Success: ${result.success}
+Result: ${JSON.stringify(result.result || result.error?.message)}
+
+Respond in JSON format:
+{
+  "goalAchieved": true/false,
+  "confidence": 0.8,
+  "nextAction": "continue"|"retry"|"abort"|"complete",
+  "reasoning": "explanation of evaluation"
+}
+`;
+    }
+    async callAIModel(prompt) {
+        // Mock AI response for now
+        // In real implementation, this would call the actual AI service
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // Return mock structured response
+        if (prompt.includes("Select the next tool")) {
+            return JSON.stringify({
+                toolName: "mock-tool",
+                parameters: { input: "mock" },
+                reasoning: "Mock AI selection",
+                confidence: 0.7,
+                expectedOutcome: "Mock execution",
+            });
+        }
+        else {
+            return JSON.stringify({
+                goalAchieved: false,
+                confidence: 0.6,
+                nextAction: "continue",
+                reasoning: "Mock AI evaluation",
+            });
+        }
+    }
+    parseAIResponse(response) {
+        try {
+            const parsed = JSON.parse(response);
+            if (!parsed.toolName) {
+                return null;
+            }
+            return {
+                stepId: `ai-step-${Date.now()}`,
+                toolName: parsed.toolName,
+                parameters: parsed.parameters || {},
+                reasoning: parsed.reasoning || "AI selected tool",
+                confidence: parsed.confidence || 0.5,
+                expectedOutcome: parsed.expectedOutcome || "Execute tool",
+            };
+        }
+        catch (error) {
+            console.warn("Failed to parse AI response", error);
+            return null;
+        }
+    }
+    parseEvaluationResponse(response) {
+        try {
+            const parsed = JSON.parse(response);
+            return {
+                goalAchieved: parsed.goalAchieved || false,
+                confidence: parsed.confidence || 0.5,
+                nextAction: parsed.nextAction || "continue",
+                reasoning: parsed.reasoning || "AI evaluation",
+            };
+        }
+        catch (error) {
+            return {
+                goalAchieved: false,
+                confidence: 0.3,
+                nextAction: "continue",
+                reasoning: "Failed to parse AI evaluation",
+            };
+        }
+    }
+}
+/**
+ * Dynamic Chain Executor
+ */
+export class DynamicChainExecutor {
+    orchestrator;
+    registry;
+    errorManager;
+    planner;
+    constructor(orchestrator, registry, errorManager, planner) {
+        this.orchestrator = orchestrator;
+        this.registry = registry;
+        this.errorManager = errorManager;
+        this.planner = planner || new HeuristicChainPlanner();
+    }
+    /**
+     * 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
+     */
+    async executeChain(goal, initialContext = {}, userContext, options = {}) {
+        const startTime = Date.now();
+        const maxSteps = options.maxSteps || 10;
+        const executionContext = {
+            goal,
+            currentStep: 0,
+            executionHistory: [],
+            accumulatedContext: { ...initialContext },
+            userContext,
+            maxSteps,
+            aiModel: options.aiModel,
+        };
+        try {
+            const result = await this.executeChainSteps(executionContext);
+            return {
+                success: true,
+                goal,
+                totalSteps: result.executionHistory.length,
+                executionTime: Date.now() - startTime,
+                results: result.executionHistory,
+                finalResult: result.executionHistory[result.executionHistory.length - 1]?.result,
+                reasoning: "Chain execution completed",
+                metadata: {
+                    toolsUsed: [
+                        ...new Set(result.executionHistory.map((h) => h.toolName)),
+                    ],
+                    averageConfidence: this.calculateAverageConfidence(result.executionHistory),
+                    contextEvolution: this.trackContextEvolution(result.executionHistory),
+                },
+            };
+        }
+        catch (error) {
+            await this.errorManager.recordError(error, {
+                category: ErrorCategory.TOOL_ERROR,
+                severity: ErrorSeverity.HIGH,
+                toolName: "dynamic-chain-executor",
+                executionContext: userContext,
+            });
+            return {
+                success: false,
+                goal,
+                totalSteps: executionContext.executionHistory.length,
+                executionTime: Date.now() - startTime,
+                results: executionContext.executionHistory,
+                error: error instanceof Error ? error : new Error(String(error)),
+                reasoning: `Chain execution failed: ${error}`,
+                metadata: {
+                    toolsUsed: [
+                        ...new Set(executionContext.executionHistory.map((h) => h.toolName)),
+                    ],
+                    averageConfidence: this.calculateAverageConfidence(executionContext.executionHistory),
+                    contextEvolution: this.trackContextEvolution(executionContext.executionHistory),
+                },
+            };
+        }
+    }
+    /**
+     * Execute chain steps iteratively
+     *
+     * @private
+     */
+    async executeChainSteps(context) {
+        const availableTools = await this.registry.listTools();
+        while (context.currentStep < context.maxSteps) {
+            // Plan next step
+            const nextStep = await this.planner.planNextStep(context.goal, availableTools.map((tool) => ({
+                name: tool.name,
+                description: tool.description || "No description available",
+                inputSchema: tool.inputSchema || {},
+            })), context.executionHistory, context.accumulatedContext);
+            if (!nextStep) {
+                // No more steps to execute
+                break;
+            }
+            // Execute the planned step
+            const stepResult = await this.executeStep(nextStep, context);
+            context.executionHistory.push(stepResult);
+            // Update accumulated context
+            if (stepResult.success && stepResult.result) {
+                this.updateAccumulatedContext(context.accumulatedContext, stepResult.result);
+            }
+            // Evaluate if goal is achieved
+            const evaluation = await this.planner.evaluateResult(nextStep, stepResult, context.goal);
+            if (evaluation.goalAchieved || evaluation.nextAction === "complete") {
+                break;
+            }
+            else if (evaluation.nextAction === "abort") {
+                throw new Error(`Chain execution aborted: ${evaluation.reasoning}`);
+            }
+            else if (evaluation.nextAction === "retry" && context.currentStep > 0) {
+                // Retry logic could be implemented here
+                console.warn(`Step retry suggested: ${evaluation.reasoning}`);
+            }
+            context.currentStep++;
+        }
+        return context;
+    }
+    /**
+     * Execute a single step
+     *
+     * @private
+     */
+    async executeStep(step, context) {
+        const startTime = Date.now();
+        try {
+            const result = await this.orchestrator.executeTool(step.toolName, step.parameters, context.userContext);
+            return {
+                toolName: step.toolName,
+                success: true,
+                result,
+                timestamp: Date.now(),
+                executionTime: Date.now() - startTime,
+                context: {
+                    stepId: step.stepId,
+                    reasoning: step.reasoning,
+                    confidence: step.confidence,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                toolName: step.toolName,
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: Date.now(),
+                executionTime: Date.now() - startTime,
+                context: {
+                    stepId: step.stepId,
+                    reasoning: step.reasoning,
+                    confidence: step.confidence,
+                },
+            };
+        }
+    }
+    /**
+     * Update accumulated context with new result
+     *
+     * @private
+     */
+    updateAccumulatedContext(context, result) {
+        if (typeof result === "object" && result !== null) {
+            Object.assign(context, result);
+        }
+        else {
+            context.lastResult = result;
+        }
+        context.lastUpdated = Date.now();
+    }
+    /**
+     * Calculate average confidence across execution history
+     *
+     * @private
+     */
+    calculateAverageConfidence(history) {
+        if (history.length === 0) {
+            return 0;
+        }
+        const confidences = history
+            .map((h) => h.context?.confidence || 0.5)
+            .filter((c) => typeof c === "number");
+        return confidences.length > 0
+            ? confidences.reduce((sum, c) => sum + c, 0) / confidences.length
+            : 0.5;
+    }
+    /**
+     * Track context evolution through execution
+     *
+     * @private
+     */
+    trackContextEvolution(history) {
+        const evolution = [];
+        history.forEach((result) => {
+            if (result.success && result.result) {
+                evolution.push({
+                    step: result.toolName,
+                    timestamp: result.timestamp,
+                    dataKeys: typeof result.result === "object"
+                        ? Object.keys(result.result)
+                        : ["primitive"],
+                });
+            }
+        });
+        return evolution;
+    }
+    /**
+     * Set AI planner
+     *
+     * @param planner AI chain planner instance
+     */
+    setPlanner(planner) {
+        this.planner = planner;
+    }
+    /**
+     * Get current planner
+     *
+     * @returns Current AI chain planner
+     */
+    getPlanner() {
+        return this.planner;
+    }
+}
+/**
+ * Default dynamic chain executor instance
+ */
+export let defaultDynamicChainExecutor = 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 function initializeDynamicChainExecutor(orchestrator, registry, errorManager, planner) {
+    defaultDynamicChainExecutor = new DynamicChainExecutor(orchestrator, registry, errorManager, planner);
+    return defaultDynamicChainExecutor;
+}

package/dist/lib/mcp/dynamic-orchestrator.d.ts

@@ -0,0 +1,109 @@
+/**
+ * NeuroLink Dynamic AI-Driven Tool Orchestrator
+ * Enables AI to dynamically select and execute tools based on task requirements
+ * Based on patterns from reference implementations
+ */
+import { MCPOrchestrator } from "./orchestrator.js";
+import type { ToolResult } from "./factory.js";
+import type { ContextRequest } from "./context-manager.js";
+/**
+ * Tool decision made by AI
+ */
+export interface ToolDecision {
+    toolName: string;
+    args: Record<string, any>;
+    reasoning: string;
+    confidence: number;
+    shouldContinue: boolean;
+}
+/**
+ * Dynamic tool chain execution options
+ */
+export interface DynamicToolChainOptions {
+    maxIterations?: number;
+    requireConfidence?: number;
+    includeReasoning?: boolean;
+    allowParallel?: boolean;
+    customSystemPrompt?: string;
+}
+/**
+ * Dynamic tool chain result
+ */
+export interface DynamicToolChainResult {
+    success: boolean;
+    iterations: number;
+    results: ToolResult[];
+    decisions: ToolDecision[];
+    finalOutput?: string;
+    error?: Error;
+    totalDuration: number;
+}
+/**
+ * Dynamic orchestrator with AI-driven tool selection
+ */
+export declare class DynamicOrchestrator extends MCPOrchestrator {
+    constructor(registry?: any, contextManager?: any, semaphoreManager?: any, sessionManager?: any, errorManager?: any);
+    private defaultOptions;
+    /**
+     * Execute a dynamic tool chain where AI decides which tools to use
+     *
+     * @param prompt User's task or request
+     * @param contextRequest Context creation request
+     * @param options Dynamic execution options
+     * @returns Dynamic tool chain result
+     */
+    executeDynamicToolChain(prompt: string, contextRequest?: ContextRequest, options?: DynamicToolChainOptions): Promise<DynamicToolChainResult>;
+    /**
+     * Get AI decision on which tool to use next
+     *
+     * @private
+     */
+    private getAIToolDecision;
+    /**
+     * Generate final output based on all execution results
+     *
+     * @private
+     */
+    private generateFinalOutput;
+    /**
+     * Execute parallel dynamic tool chains for complex tasks
+     *
+     * @param prompts Multiple prompts to execute in parallel
+     * @param contextRequest Shared context request
+     * @param options Dynamic execution options
+     * @returns Array of dynamic tool chain results
+     */
+    executeParallelDynamicChains(prompts: string[], contextRequest?: ContextRequest, options?: DynamicToolChainOptions): Promise<DynamicToolChainResult[]>;
+    /**
+     * Get statistics including dynamic execution metrics
+     */
+    getStats(): {
+        dynamicOrchestrator: {
+            features: {
+                aiToolSelection: boolean;
+                iterativeExecution: boolean;
+                parallelSupport: boolean;
+                reasoningCapture: boolean;
+            };
+        };
+        registry: any;
+        context: any;
+        session: any;
+        error: any;
+        health?: any;
+        orchestrator: {
+            pipelinesExecuted: number;
+        };
+    };
+}
+/**
+ * Create a dynamic orchestrator instance
+ *
+ * @param registry Tool registry
+ * @param contextManager Context manager
+ * @param semaphoreManager Semaphore manager (optional)
+ * @param sessionManager Session manager (optional)
+ * @param errorManager Error manager (optional)
+ * @returns Dynamic orchestrator instance
+ */
+export declare function createDynamicOrchestrator(registry: any, contextManager: any, semaphoreManager?: any, sessionManager?: any, errorManager?: any): DynamicOrchestrator;