@juspay/neurolink 6.1.0 → 6.2.0

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

@@ -1,115 +0,0 @@
-/**
- * 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";
-import type { UnknownRecord } from "../types/common.js";
-import { ErrorManager } from "./error-manager.js";
-import type { MCPToolRegistry } from "./tool-registry.js";
-import type { ContextManager } from "./context-manager.js";
-import type { SemaphoreManager } from "./semaphore-manager.js";
-import type { SessionManager } from "./session-manager.js";
-/**
- * Tool decision made by AI
- */
-export interface ToolDecision {
-    toolName: string;
-    args: UnknownRecord;
-    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?: MCPToolRegistry, contextManager?: ContextManager, semaphoreManager?: SemaphoreManager, sessionManager?: SessionManager, errorManager?: ErrorManager);
-    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: UnknownRecord;
-        context: UnknownRecord;
-        session: UnknownRecord;
-        error: UnknownRecord;
-        health?: UnknownRecord;
-        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: MCPToolRegistry, contextManager: ContextManager, semaphoreManager?: SemaphoreManager, sessionManager?: SessionManager, errorManager?: ErrorManager): DynamicOrchestrator;

package/dist/mcp/dynamic-orchestrator.js

@@ -1,351 +0,0 @@
-/**
- * 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 { createExecutionContext } from "./context-manager.js";
-import { ErrorCategory, ErrorSeverity, ErrorManager } from "./error-manager.js";
-import { aiCoreServer } from "./servers/ai-providers/ai-core-server.js";
-/**
- * AI prompt templates for tool selection
- */
-const TOOL_SELECTION_PROMPT = `You are an intelligent tool orchestrator. Analyze the user's request and available tools to determine the best tool to use next.
-
-User Request: {prompt}
-
-Available Tools:
-{tools}
-
-Previous Results:
-{previousResults}
-
-Based on the request and previous results, select the most appropriate tool to use next.
-Respond with a JSON object containing:
-- toolName: The exact name of the tool to use
-- args: An object containing the arguments for the tool
-- reasoning: Brief explanation of why this tool was chosen
-- confidence: A number between 0 and 1 indicating your confidence in this choice
-- shouldContinue: Boolean indicating if more tools should be executed after this one
-
-Example response:
-{
-  "toolName": "search-code",
-  "args": {"query": "function calculateTotal", "path": "/src"},
-  "reasoning": "Need to find the calculateTotal function to understand the calculation logic",
-  "confidence": 0.9,
-  "shouldContinue": true
-}`;
-/**
- * Dynamic orchestrator with AI-driven tool selection
- */
-export class DynamicOrchestrator extends MCPOrchestrator {
-    constructor(registry, contextManager, semaphoreManager, sessionManager, errorManager) {
-        super(registry, contextManager, semaphoreManager, sessionManager, errorManager);
-    }
-    defaultOptions = {
-        maxIterations: 10,
-        requireConfidence: 0.7,
-        includeReasoning: true,
-        allowParallel: false,
-    };
-    /**
-     * 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
-     */
-    async executeDynamicToolChain(prompt, contextRequest = {}, options = {}) {
-        const startTime = Date.now();
-        const mergedOptions = { ...this.defaultOptions, ...options };
-        const results = [];
-        const decisions = [];
-        let error;
-        let iterations = 0;
-        let session;
-        try {
-            // Create or get session
-            const context = await this.contextManager.createContext(contextRequest);
-            session = await this.sessionManager.createSession(context);
-            // Get available tools
-            const availableTools = await this.registry.listTools(context);
-            const toolsDescription = availableTools
-                .map((tool) => `- ${tool.name}: ${tool.description || "No description"}`)
-                .join("\n");
-            let shouldContinue = true;
-            while (shouldContinue &&
-                iterations < (mergedOptions.maxIterations || 10)) {
-                iterations++;
-                // Prepare context for AI decision
-                const previousResultsSummary = results
-                    .slice(-3) // Last 3 results for context
-                    .map((r, i) => {
-                    const resultData = r.success && r.data ? JSON.stringify(r.data) : "No data";
-                    const summary = resultData.length > 200
-                        ? resultData.slice(0, 200) + "..."
-                        : resultData;
-                    return `Result ${i + 1}: ${summary}`;
-                })
-                    .join("\n");
-                // Get AI decision on next tool
-                const decision = await this.getAIToolDecision(prompt, toolsDescription, previousResultsSummary, mergedOptions.customSystemPrompt);
-                // Add decision to array if includeReasoning is true
-                if (mergedOptions.includeReasoning) {
-                    decisions.push(decision);
-                }
-                // Validate confidence threshold
-                if (decision.confidence < (mergedOptions.requireConfidence || 0.7)) {
-                    if (process.env.NEUROLINK_DEBUG === "true") {
-                        console.log(`[DynamicOrchestrator] Low confidence (${decision.confidence}), stopping execution`);
-                    }
-                    shouldContinue = false;
-                    break;
-                }
-                shouldContinue = decision.shouldContinue;
-                // Execute the selected tool
-                try {
-                    const toolResult = await this.registry.executeTool(decision.toolName, decision.args, context);
-                    results.push({
-                        success: true,
-                        data: toolResult,
-                        metadata: {
-                            toolName: decision.toolName,
-                            executionTime: Date.now() - startTime,
-                        },
-                    });
-                    // Update session with tool result
-                    session.toolHistory.push({
-                        success: true,
-                        data: toolResult,
-                        metadata: {
-                            toolName: decision.toolName,
-                            executionTime: Date.now() - startTime,
-                        },
-                    });
-                }
-                catch (toolError) {
-                    const errorResult = {
-                        success: false,
-                        error: toolError instanceof Error
-                            ? toolError
-                            : new Error(String(toolError)),
-                        metadata: {
-                            toolName: decision.toolName,
-                            executionTime: Date.now() - startTime,
-                        },
-                    };
-                    results.push(errorResult);
-                    session.toolHistory.push(errorResult);
-                    // Let AI decide if it should continue after error
-                    if (!decision.shouldContinue) {
-                        break;
-                    }
-                }
-                // Safety check for infinite loops
-                if (iterations >= (mergedOptions.maxIterations || 10)) {
-                    if (process.env.NEUROLINK_DEBUG === "true") {
-                        console.log(`[DynamicOrchestrator] Reached max iterations (${mergedOptions.maxIterations})`);
-                    }
-                    break;
-                }
-            }
-            // Generate final output based on all results
-            const finalOutput = await this.generateFinalOutput(prompt, results, decisions);
-            return {
-                success: true,
-                iterations,
-                results,
-                decisions: mergedOptions.includeReasoning ? decisions : [],
-                finalOutput,
-                totalDuration: Date.now() - startTime,
-            };
-        }
-        catch (err) {
-            error = err instanceof Error ? err : new Error(String(err));
-            // Record error
-            this.errorManager.recordError(error, {
-                category: ErrorCategory.TOOL_ERROR,
-                severity: ErrorSeverity.HIGH,
-                toolName: "dynamic-orchestrator",
-                sessionId: session?.id,
-            });
-            return {
-                success: false,
-                iterations,
-                results,
-                decisions: mergedOptions.includeReasoning ? decisions : [],
-                error,
-                totalDuration: Date.now() - startTime,
-            };
-        }
-        finally {
-            // Update session activity if session was created
-            if (session) {
-                session.lastActivity = Date.now();
-            }
-        }
-    }
-    /**
-     * Get AI decision on which tool to use next
-     *
-     * @private
-     */
-    async getAIToolDecision(prompt, toolsDescription, previousResults, customSystemPrompt) {
-        const systemPrompt = customSystemPrompt ||
-            TOOL_SELECTION_PROMPT.replace("{prompt}", prompt)
-                .replace("{tools}", toolsDescription)
-                .replace("{previousResults}", previousResults || "None yet");
-        try {
-            // Use AI Core Server to get tool decision
-            const generateTool = aiCoreServer.tools["generate"];
-            if (!generateTool) {
-                throw new Error("generate tool not found");
-            }
-            const aiResponse = await generateTool.execute({
-                prompt: "Select the next tool to execute based on the context provided.",
-                systemPrompt,
-                provider: "google-ai", // Use fast model for decisions
-                model: "gemini-2.5-flash",
-                temperature: 0.3, // Lower temperature for more consistent decisions
-                maxTokens: 500,
-            }, createExecutionContext());
-            // Parse AI response
-            if (!aiResponse.success) {
-                throw new Error(String(aiResponse.error || "AI generation failed"));
-            }
-            const responseText = aiResponse.data?.text || "";
-            // Extract JSON from response (handle markdown code blocks)
-            const jsonMatch = responseText.match(/```json\n?([\s\S]*?)\n?```/) ||
-                responseText.match(/\{[\s\S]*\}/);
-            if (!jsonMatch) {
-                throw new Error("AI response did not contain valid JSON");
-            }
-            const decision = JSON.parse(jsonMatch[1] || jsonMatch[0]);
-            // Validate decision structure
-            if (!decision.toolName || !decision.args) {
-                throw new Error("Invalid tool decision structure");
-            }
-            return {
-                toolName: decision.toolName,
-                args: decision.args || {},
-                reasoning: decision.reasoning || "No reasoning provided",
-                confidence: decision.confidence || 0.8,
-                shouldContinue: decision.shouldContinue !== false,
-            };
-        }
-        catch (error) {
-            // Fallback decision on error
-            if (process.env.NEUROLINK_DEBUG === "true") {
-                console.error("[DynamicOrchestrator] Error getting AI decision:", error);
-            }
-            return {
-                toolName: "list-tools", // Safe default
-                args: {},
-                reasoning: "Error in AI decision, falling back to tool listing",
-                confidence: 0.5,
-                shouldContinue: false,
-            };
-        }
-    }
-    /**
-     * Generate final output based on all execution results
-     *
-     * @private
-     */
-    async generateFinalOutput(prompt, results, decisions) {
-        // Prepare summary of execution
-        const executionSummary = results
-            .map((r, i) => {
-            const decision = decisions[i];
-            const toolName = r.metadata?.toolName || "unknown";
-            const resultData = r.success && r.data ? JSON.stringify(r.data) : "No data";
-            const resultSummary = resultData.length > 300
-                ? resultData.slice(0, 300) + "..."
-                : resultData;
-            return `Step ${i + 1}: ${toolName}
-Reasoning: ${decision?.reasoning || "N/A"}
-Result: ${r.success ? resultSummary : "Error: " + (r.error instanceof Error ? r.error.message : String(r.error))}`;
-        })
-            .join("\n\n");
-        const summaryPrompt = `Based on the following tool execution results, provide a comprehensive answer to the user's request.
-
-User Request: ${prompt}
-
-Execution Summary:
-${executionSummary}
-
-Provide a clear, concise answer that addresses the user's request based on the tool results.`;
-        try {
-            // Use AI to generate final summary
-            const generateTool = aiCoreServer.tools["generate"];
-            if (!generateTool) {
-                throw new Error("generate tool not found");
-            }
-            const aiResponse = await generateTool.execute({
-                prompt: summaryPrompt,
-                provider: "google-ai",
-                model: "gemini-2.5-pro",
-                temperature: 0.7,
-                maxTokens: 1000,
-            }, createExecutionContext());
-            if (!aiResponse.success) {
-                throw new Error(String(aiResponse.error || "AI generation failed"));
-            }
-            return aiResponse.data?.text || "";
-        }
-        catch (error) {
-            // Fallback to simple summary
-            return `Executed ${results.length} tools to address your request. ${results.filter((r) => r.success).length} succeeded, ${results.filter((r) => !r.success).length} failed.`;
-        }
-    }
-    /**
-     * 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
-     */
-    async executeParallelDynamicChains(prompts, contextRequest = {}, options = {}) {
-        if (!options.allowParallel) {
-            throw new Error("Parallel execution not enabled in options");
-        }
-        // Execute all chains in parallel
-        const promises = prompts.map((prompt) => this.executeDynamicToolChain(prompt, contextRequest, options));
-        return Promise.all(promises);
-    }
-    /**
-     * Get statistics including dynamic execution metrics
-     */
-    getStats() {
-        const baseStats = super.getStats();
-        // Add dynamic orchestrator specific stats
-        return {
-            ...baseStats,
-            dynamicOrchestrator: {
-                // Additional metrics can be added here
-                features: {
-                    aiToolSelection: true,
-                    iterativeExecution: true,
-                    parallelSupport: true,
-                    reasoningCapture: true,
-                },
-            },
-        };
-    }
-}
-/**
- * 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 function createDynamicOrchestrator(registry, contextManager, semaphoreManager, sessionManager, errorManager) {
-    return new DynamicOrchestrator(registry, contextManager, semaphoreManager, sessionManager, errorManager);
-}

package/dist/mcp/ecosystem.d.ts

@@ -1,75 +0,0 @@
-/**
- * MCP Ecosystem Integration - Bridge Between Research Blueprint and NeuroLink
- * Provides unified interface for plugin management and execution
- */
-import { MCP } from "./contracts/mcp-contract.js";
-import type { MCPMetadata, ExecutionContext } from "./contracts/mcp-contract.js";
-/**
- * MCP Ecosystem - Main Interface for Plugin Operations
- */
-export declare class MCPEcosystem {
-    private static instance;
-    private securityManager;
-    private initialized;
-    private constructor();
-    static getInstance(): MCPEcosystem;
-    /**
-     * Initialize the MCP ecosystem
-     */
-    initialize(): Promise<void>;
-    /**
-     * List all available MCPs
-     */
-    list(): Promise<MCPMetadata[]>;
-    /**
-     * Get metadata for a specific MCP
-     */
-    getMetadata(name: string): Promise<MCPMetadata | null>;
-    /**
-     * Create and execute an MCP instance
-     */
-    execute<T = unknown>(name: string, config: unknown, args: unknown, context?: {
-        sessionId?: string;
-        userId?: string;
-    }): Promise<T>;
-    /**
-     * Execute filesystem operations using FileSystemMCP
-     */
-    filesystem(operation: {
-        action: "readFile" | "writeFile" | "listFiles" | "createDir";
-        path: string;
-        content?: string;
-        basePath?: string;
-    }): Promise<unknown>;
-    /**
-     * Get ecosystem statistics
-     */
-    getStats(): Promise<{
-        initialized: boolean;
-        pluginsDiscovered: number;
-        pluginsBySource: Record<string, number>;
-        availablePlugins: string[];
-    }>;
-    /**
-     * Create an MCP instance for direct use
-     */
-    createInstance<T extends MCP>(name: string, config: unknown): Promise<T>;
-    /**
-     * Create execution context for manual MCP usage
-     */
-    createExecutionContext(sessionId: string, userId: string, permissions: string[], basePath?: string): ExecutionContext;
-    /**
-     * Ensure ecosystem is initialized
-     */
-    private ensureInitialized;
-    /**
-     * Get all tools formatted for AI providers
-     */
-    getToolsForAI(): Promise<Record<string, unknown>>;
-    /**
-     * Dispose of all resources
-     */
-    dispose(): Promise<void>;
-}
-export declare const mcpEcosystem: MCPEcosystem;
-export type { MCPMetadata, ExecutionContext, } from "./contracts/mcp-contract.js";