@juspay/neurolink 7.12.0 → 7.14.0

package/dist/lib/core/baseProvider.js

@@ -157,10 +157,20 @@ export class BaseProvider {
         try {
             // Import generateText dynamically to avoid circular dependencies
             const { generateText } = await import("ai");
-            // Get ALL available tools (direct + MCP when available)
+            // Get ALL available tools (direct + MCP + external from options)
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? await this.getAllTools() : {};
-            logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}: ${Object.keys(tools).join(", ")}`);
+            const baseTools = shouldUseTools ? await this.getAllTools() : {};
+            const tools = shouldUseTools
+                ? {
+                    ...baseTools,
+                    ...(options.tools || {}), // Include external tools passed from NeuroLink
+                }
+                : {};
+            logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}:`, {
+                directTools: Object.keys(baseTools),
+                externalTools: Object.keys(options.tools || {}),
+                totalTools: Object.keys(tools),
+            });
             // EVERY provider uses Vercel AI SDK - no exceptions
             const model = await this.getAISDKModel(); // This method is now REQUIRED
             // Build proper message array with conversation history
@@ -201,22 +211,66 @@ export class BaseProvider {
             const uniqueToolsUsed = [...new Set(toolsUsed)];
             // ✅ Extract tool executions from AI SDK result
             const toolExecutions = [];
+            // Create a map of tool calls to their arguments for matching with results
+            const toolCallArgsMap = new Map();
             // Extract tool executions from AI SDK result steps
-            // Extract tool executions from steps (where tool results are stored)
             if (result.steps &&
                 Array.isArray(result.steps)) {
                 for (const step of result.steps ||
                     []) {
-                    // Focus only on tool results (which have complete execution data)
-                    // Tool calls are just the requests, tool results contain the actual execution data
+                    // First, collect tool calls and their arguments
+                    if (step?.toolCalls && Array.isArray(step.toolCalls)) {
+                        for (const toolCall of step.toolCalls) {
+                            const tcRecord = toolCall;
+                            const toolName = tcRecord.toolName ||
+                                tcRecord.name ||
+                                "unknown";
+                            const toolId = tcRecord.toolCallId ||
+                                tcRecord.id ||
+                                toolName;
+                            // Extract arguments from tool call
+                            let callArgs = {};
+                            if (tcRecord.args) {
+                                callArgs = tcRecord.args;
+                            }
+                            else if (tcRecord.arguments) {
+                                callArgs = tcRecord.arguments;
+                            }
+                            else if (tcRecord.parameters) {
+                                callArgs = tcRecord.parameters;
+                            }
+                            toolCallArgsMap.set(toolId, callArgs);
+                            toolCallArgsMap.set(toolName, callArgs); // Also map by name as fallback
+                        }
+                    }
+                    // Then, process tool results and match with call arguments
                     if (step?.toolResults && Array.isArray(step.toolResults)) {
                         for (const toolResult of step.toolResults) {
                             const trRecord = toolResult;
+                            const toolName = trRecord.toolName || "unknown";
+                            const toolId = trRecord.toolCallId || trRecord.id;
+                            // Try to get arguments from the tool result first
+                            let toolArgs = {};
+                            if (trRecord.args) {
+                                toolArgs = trRecord.args;
+                            }
+                            else if (trRecord.arguments) {
+                                toolArgs = trRecord.arguments;
+                            }
+                            else if (trRecord.parameters) {
+                                toolArgs = trRecord.parameters;
+                            }
+                            else if (trRecord.input) {
+                                toolArgs = trRecord.input;
+                            }
+                            else {
+                                // Fallback: get arguments from the corresponding tool call
+                                toolArgs = toolCallArgsMap.get(toolId || toolName) || {};
+                            }
                             toolExecutions.push({
-                                name: trRecord.toolName || "unknown",
-                                input: trRecord.args || {},
+                                name: toolName,
+                                input: toolArgs,
                                 output: trRecord.result || "success",
-                                duration: 0, // AI SDK doesn't track duration
                             });
                         }
                     }
@@ -248,6 +302,12 @@ export class BaseProvider {
                 toolResults: result.toolResults,
                 toolsUsed: uniqueToolsUsed,
                 toolExecutions, // ✅ Add extracted tool executions
+                availableTools: Object.keys(tools).map((name) => ({
+                    name,
+                    description: tools[name].description || "No description available",
+                    parameters: tools[name].parameters || {},
+                    server: tools[name].serverId || "direct",
+                })),
             };
             // Enhanced result with analytics and evaluation
             return await this.enhanceResult(enhancedResult, options, startTime);
@@ -339,6 +399,71 @@ export class BaseProvider {
                 // Not an error - custom tools are optional
             }
         }
+        // ✅ CRITICAL FIX: Add external MCP tools if SDK has external server manager
+        if (this.sdk &&
+            this.sdk.externalServerManager &&
+            typeof this.sdk.externalServerManager.getAllTools === "function") {
+            try {
+                logger.debug(`[BaseProvider] Loading external MCP tools from SDK via externalServerManager`);
+                const externalTools = this.sdk.externalServerManager.getAllTools();
+                logger.debug(`[BaseProvider] Found ${externalTools.length} external MCP tools`, {
+                    tools: externalTools.map((t) => ({
+                        name: t.name,
+                        available: t.isAvailable,
+                        server: t.serverId,
+                    })),
+                });
+                for (const externalTool of externalTools) {
+                    if (externalTool.isAvailable) {
+                        logger.debug(`[BaseProvider] Converting external MCP tool: ${externalTool.name} from ${externalTool.serverId}`);
+                        // Convert to AI SDK tool format
+                        const { tool: createAISDKTool } = await import("ai");
+                        const { z } = await import("zod");
+                        tools[externalTool.name] = createAISDKTool({
+                            description: externalTool.description ||
+                                `External MCP tool ${externalTool.name}`,
+                            parameters: await this.convertMCPSchemaToZod(externalTool.inputSchema),
+                            execute: async (args) => {
+                                logger.debug(`[BaseProvider] Executing external MCP tool: ${externalTool.name}`, { args });
+                                // Execute via SDK's external server manager
+                                if (this.sdk &&
+                                    this.sdk.externalServerManager &&
+                                    typeof this.sdk.externalServerManager.executeTool ===
+                                        "function") {
+                                    return await this.sdk.externalServerManager.executeTool(externalTool.serverId, externalTool.name, args);
+                                }
+                                else {
+                                    throw new Error(`Cannot execute external MCP tool: SDK externalServerManager.executeTool not available`);
+                                }
+                            },
+                        });
+                        logger.debug(`[BaseProvider] Successfully added external MCP tool: ${externalTool.name}`);
+                    }
+                    else {
+                        logger.debug(`[BaseProvider] Skipping unavailable external MCP tool: ${externalTool.name}`);
+                    }
+                }
+                logger.debug(`[BaseProvider] External MCP tools loading complete`, {
+                    totalExternalTools: externalTools.length,
+                    availableExternalTools: externalTools.filter((t) => t.isAvailable)
+                        .length,
+                    addedToTools: externalTools.filter((t) => t.isAvailable).length,
+                });
+            }
+            catch (error) {
+                logger.error(`[BaseProvider] Failed to load external MCP tools for ${this.providerName}:`, error);
+                // Not an error - external tools are optional
+            }
+        }
+        else {
+            logger.debug(`[BaseProvider] No external MCP tools interface available`, {
+                hasSDK: !!this.sdk,
+                hasExternalServerManager: this.sdk && !!this.sdk.externalServerManager,
+                hasGetAllTools: this.sdk &&
+                    this.sdk.externalServerManager &&
+                    typeof this.sdk.externalServerManager.getAllTools === "function",
+            });
+        }
         // MCP tools loading simplified - removed functionCalling dependency
         if (!this.mcpTools) {
             // Set empty tools object - MCP tools are handled at a higher level
@@ -351,6 +476,80 @@ export class BaseProvider {
         logger.debug(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
         return tools;
     }
+    /**
+     * Convert MCP JSON Schema to Zod schema for AI SDK tools
+     * Handles common MCP schema patterns safely
+     */
+    async convertMCPSchemaToZod(inputSchema) {
+        const { z } = await import("zod");
+        if (!inputSchema || typeof inputSchema !== "object") {
+            return z.object({});
+        }
+        try {
+            const schema = inputSchema;
+            const zodFields = {};
+            // Handle JSON Schema properties
+            if (schema.properties && typeof schema.properties === "object") {
+                const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+                for (const [propName, propDef] of Object.entries(schema.properties)) {
+                    const prop = propDef;
+                    let zodType;
+                    // Convert based on JSON Schema type
+                    switch (prop.type) {
+                        case "string":
+                            zodType = z.string();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "number":
+                        case "integer":
+                            zodType = z.number();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "boolean":
+                            zodType = z.boolean();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "array":
+                            zodType = z.array(z.unknown());
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "object":
+                            zodType = z.object({});
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        default:
+                            // Unknown type, use string as fallback
+                            zodType = z.string();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                    }
+                    // Make optional if not required
+                    if (!required.has(propName)) {
+                        zodType = zodType.optional();
+                    }
+                    zodFields[propName] = zodType;
+                }
+            }
+            return Object.keys(zodFields).length > 0
+                ? z.object(zodFields)
+                : z.object({});
+        }
+        catch (error) {
+            logger.warn(`Failed to convert MCP schema to Zod, using empty schema:`, error);
+            return z.object({});
+        }
+    }
     /**
      * Set session context for MCP tools
      */

package/dist/lib/core/conversationMemoryManager.js

@@ -3,7 +3,7 @@
  * Handles in-memory conversation storage, session management, and context injection
  */
 import { ConversationMemoryError } from "../types/conversationTypes.js";
-import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN } from "../config/conversationMemoryConfig.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemoryConfig.js";
 import { logger } from "../utils/logger.js";
 export class ConversationMemoryManager {
     sessions = new Map();
@@ -49,7 +49,8 @@ export class ConversationMemoryManager {
             session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
             session.lastActivity = Date.now();
             // Enforce per-session turn limit (each turn = MESSAGES_PER_TURN messages: user + assistant)
-            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) * MESSAGES_PER_TURN;
+            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) *
+                MESSAGES_PER_TURN;
             if (session.messages.length > maxMessages) {
                 session.messages = session.messages.slice(-maxMessages);
             }

package/dist/lib/core/factory.js

@@ -109,13 +109,24 @@ export class AIProviderFactory {
             const finalModelName = resolvedModelName === "default" || resolvedModelName === null
                 ? undefined
                 : resolvedModelName;
-            const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, sdk);
+            // ✅ CRITICAL FIX: Pass external MCP tools interface to BaseProvider
+            let finalSdk = sdk;
+            if (sdk && typeof sdk.getExternalMCPTools === "function") {
+                finalSdk = {
+                    ...sdk,
+                    externalServerManager: {
+                        getAllTools: () => sdk.getExternalMCPTools(),
+                        executeTool: (serverId, toolName, params) => sdk.executeExternalMCPTool(serverId, toolName, params),
+                    },
+                };
+            }
+            // Create provider with enhanced SDK
+            const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, finalSdk);
             logger.debug(componentIdentifier, "Pure factory pattern provider created", {
                 providerName: normalizedName,
                 modelName: finalModelName,
                 factoryUsed: true,
             });
-            // PURE FACTORY PATTERN: All providers handled by ProviderFactory - no switch statements needed
             // Wrap with MCP if enabled
             if (enableMCP) {
                 try {

package/dist/lib/factories/providerFactory.js

@@ -46,22 +46,16 @@ export class ProviderFactory {
             model = model || registration.defaultModel;
         }
         try {
-            // Try calling as factory function first, then fallback to constructor
             let result;
             try {
-                // Try as factory function
-                result = registration.constructor(model, providerName, sdk);
+                // Try as async factory function first (most providers are async functions)
+                result = await registration.constructor(model, providerName, sdk);
             }
-            catch (factoryError) {
-                // Fallback to constructor
+            catch (functionError) {
+                // Fallback to constructor - ensure parameters are maintained
                 result = new registration.constructor(model, providerName, sdk);
             }
-            // Only await if result is actually a Promise
-            if (result &&
-                typeof result === "object" &&
-                typeof result.then === "function") {
-                result = await result;
-            }
+            // Return result (no need to await again if already awaited in try block)
             return result;
         }
         catch (error) {

package/dist/lib/factories/providerRegistry.js

@@ -52,9 +52,9 @@ export class ProviderRegistry {
                 process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
                 "gpt-4o-mini", ["azure", "azureOpenai"]);
             // Register Google Vertex AI provider
-            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk) => {
                 const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
-                return new GoogleVertexProvider(modelName);
+                return new GoogleVertexProvider(modelName, providerName, sdk);
             }, "claude-sonnet-4@20250514", ["vertex", "googleVertex"]);
             // Register Hugging Face provider (Unified Router implementation)
             ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {

package/dist/lib/mcp/externalServerManager.d.ts

@@ -0,0 +1,115 @@
+/**
+ * External MCP Server Manager
+ * Handles lifecycle management of external MCP servers including:
+ * - Process spawning and management
+ * - Health monitoring and automatic restart
+ * - Connection management and cleanup
+ * - Tool discovery and registration
+ */
+import { EventEmitter } from "events";
+import { ToolDiscoveryService } from "./toolDiscoveryService.js";
+import type { ExternalMCPServerConfig, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPManagerConfig, ExternalMCPToolInfo } from "../types/externalMcp.js";
+/**
+ * ExternalServerManager
+ * Core class for managing external MCP servers
+ */
+export declare class ExternalServerManager extends EventEmitter {
+    private servers;
+    private config;
+    private isShuttingDown;
+    private toolDiscovery;
+    constructor(config?: ExternalMCPManagerConfig);
+    /**
+     * Validate external MCP server configuration
+     */
+    validateConfig(config: ExternalMCPServerConfig): ExternalMCPConfigValidation;
+    /**
+     * Add a new external MCP server
+     */
+    addServer(serverId: string, config: ExternalMCPServerConfig): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
+    /**
+     * Remove an external MCP server
+     */
+    removeServer(serverId: string): Promise<ExternalMCPOperationResult<void>>;
+    /**
+     * Start an external MCP server
+     */
+    private startServer;
+    /**
+     * Stop an external MCP server
+     */
+    private stopServer;
+    /**
+     * Update server status and emit events
+     */
+    private updateServerStatus;
+    /**
+     * Handle server errors
+     */
+    private handleServerError;
+    /**
+     * Handle server disconnection
+     */
+    private handleServerDisconnection;
+    /**
+     * Schedule server restart with exponential backoff
+     */
+    private scheduleRestart;
+    /**
+     * Start health monitoring for a server
+     */
+    private startHealthMonitoring;
+    /**
+     * Perform health check on a server
+     */
+    private performHealthCheck;
+    /**
+     * Get server instance
+     */
+    getServer(serverId: string): ExternalMCPServerInstance | undefined;
+    /**
+     * Get all servers
+     */
+    getAllServers(): Map<string, ExternalMCPServerInstance>;
+    /**
+     * Get server statuses
+     */
+    getServerStatuses(): ExternalMCPServerHealth[];
+    /**
+     * Shutdown all servers
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get manager statistics
+     */
+    getStatistics(): {
+        totalServers: number;
+        connectedServers: number;
+        failedServers: number;
+        totalTools: number;
+        totalConnections: number;
+        totalErrors: number;
+    };
+    /**
+     * Discover tools from a server
+     */
+    private discoverServerTools;
+    /**
+     * Execute a tool on a specific server
+     */
+    executeTool(serverId: string, toolName: string, parameters: Record<string, any>, options?: {
+        timeout?: number;
+    }): Promise<any>;
+    /**
+     * Get all tools from all servers
+     */
+    getAllTools(): ExternalMCPToolInfo[];
+    /**
+     * Get tools for a specific server
+     */
+    getServerTools(serverId: string): ExternalMCPToolInfo[];
+    /**
+     * Get tool discovery service
+     */
+    getToolDiscovery(): ToolDiscoveryService;
+}