@juspay/neurolink 6.1.0 → 6.2.0

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

@@ -1,225 +0,0 @@
-/**
- * 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 type { JsonValue, UnknownRecord } from "../types/common.js";
-import { ErrorManager } from "./error-manager.js";
-/**
- * Tool input schema structure
- */
-export interface ToolInputSchema {
-    type?: string;
-    properties?: Record<string, unknown>;
-    required?: string[];
-    [key: string]: unknown;
-}
-/**
- * Tool execution parameters
- */
-export interface ToolExecutionParameters extends Record<string, JsonValue> {
-}
-/**
- * Context evolution entry tracking data changes
- */
-export interface ContextEvolutionEntry {
-    step: string;
-    timestamp: number;
-    dataKeys: string[];
-    [key: string]: JsonValue;
-}
-/**
- * AI model planning response structure
- */
-export interface AIPlanningResponse {
-    toolName: string | null;
-    parameters?: ToolExecutionParameters;
-    reasoning?: string;
-    confidence?: number;
-    expectedOutcome?: string;
-}
-/**
- * AI model evaluation response structure
- */
-export interface AIEvaluationResponse {
-    goalAchieved: boolean;
-    confidence: number;
-    nextAction: "continue" | "retry" | "abort" | "complete";
-    reasoning: string;
-}
-/**
- * Available tool descriptor
- */
-export interface AvailableToolDescriptor {
-    name: string;
-    description: string;
-    inputSchema: ToolInputSchema;
-}
-/**
- * Tool execution result with metadata
- */
-export interface ToolExecutionResult {
-    toolName: string;
-    success: boolean;
-    result?: JsonValue;
-    error?: Error;
-    timestamp: number;
-    executionTime: number;
-    context?: UnknownRecord;
-}
-/**
- * Chain execution step
- */
-export interface ChainStep {
-    stepId: string;
-    toolName: string;
-    parameters: ToolExecutionParameters;
-    reasoning: string;
-    confidence: number;
-    expectedOutcome: string;
-}
-/**
- * Chain execution context
- */
-export interface ChainExecutionContext {
-    goal: string;
-    currentStep: number;
-    totalSteps?: number;
-    executionHistory: ToolExecutionResult[];
-    accumulatedContext: UnknownRecord;
-    userContext?: NeuroLinkExecutionContext;
-    maxSteps: number;
-    aiModel?: string;
-}
-/**
- * Chain execution result
- */
-export interface ChainExecutionResult {
-    success: boolean;
-    goal: string;
-    totalSteps: number;
-    executionTime: number;
-    results: ToolExecutionResult[];
-    finalResult?: JsonValue;
-    reasoning: string;
-    error?: Error;
-    metadata: {
-        toolsUsed: string[];
-        averageConfidence: number;
-        contextEvolution: ContextEvolutionEntry[];
-    };
-}
-/**
- * AI Tool Chain Planner interface
- */
-export interface AIChainPlanner {
-    name: string;
-    planNextStep(goal: string, availableTools: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
-}
-/**
- * Simple AI Chain Planner using heuristics
- */
-export declare class HeuristicChainPlanner implements AIChainPlanner {
-    name: string;
-    planNextStep(goal: string, availableTools: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
-    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: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
-    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?: UnknownRecord, 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;

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

@@ -1,489 +0,0 @@
-/**
- * Dynamic AI Tool Chain Executor
- * Allows AI to dynamically decide tool execution sequences based on context and results
- */
-import { ErrorManager, 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" && lastResult.result !== null) {
-                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: 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" && result.result !== null
-                        ? 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;
-}