@juspay/neurolink 7.13.0 → 7.14.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [7.14.0](https://github.com/juspay/neurolink/compare/v7.13.0...v7.14.0) (2025-08-14)
+
+### Features
+
+- **(external-mcp):** add external MCP server integration support ([c03dee8](https://github.com/juspay/neurolink/commit/c03dee8dd7a2e06e78bc743d7b3a5cff858395de))
+
 ## [7.13.0](https://github.com/juspay/neurolink/compare/v7.12.0...v7.13.0) (2025-08-14)
 
 ### Features

package/README.md

@@ -69,7 +69,7 @@ npx @juspay/neurolink sagemaker benchmark my-endpoint  # Performance testing
 - **🛡️ Error Recovery** - Graceful failures with provider fallback and retry logic
 - **📊 Analytics & Evaluation** - Built-in usage tracking and AI-powered quality assessment
 - **🎯 Real-time Event Monitoring** - EventEmitter integration for progress tracking and debugging
-- **🔧 MCP Integration** - Model Context Protocol with 6 built-in tools and 58+ discoverable servers
+- **🔧 External MCP Integration** - Model Context Protocol with 6 built-in tools + full external MCP server support
 - **🚀 Lighthouse Integration** - Unified tool registration API supporting both object and array formats for seamless Lighthouse tool import
 
 ---
@@ -118,6 +118,28 @@ npx @juspay/neurolink status                # Check all providers
 ```bash
 # SDK Installation for using in your typescript projects
 npm install @juspay/neurolink
+
+# 🆕 NEW: External MCP Server Integration Quick Test
+node -e "
+const { NeuroLink } = require('@juspay/neurolink');
+(async () => {
+  const neurolink = new NeuroLink();
+
+  // Add external filesystem MCP server
+  await neurolink.addExternalMCPServer('filesystem', {
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-filesystem', '/tmp'],
+    transport: 'stdio'
+  });
+
+  // External tools automatically available in generate()
+  const result = await neurolink.generate({
+    input: { text: 'List files in the current directory' }
+  });
+  console.log('🎉 External MCP integration working!');
+  console.log(result.content);
+})();
+"
 ```
 
 ### Basic Usage
@@ -327,41 +349,56 @@ console.log(productData.name, productData.price, productData.features);
 - ⚡ **Automatic Fallback** - Never fail when providers are down, intelligent provider switching
 - 🖥️ **CLI + SDK** - Use from command line or integrate programmatically with TypeScript support
 - 🛡️ **Production Ready** - Enterprise-grade error handling, performance optimization, extracted from production
-- ✅ **MCP Integration** - Model Context Protocol with working built-in tools and 58+ discoverable external servers
+- ✅ **External MCP Integration** - Model Context Protocol with built-in tools + full external MCP server support
 - 🔍 **Smart Model Resolution** - Fuzzy matching, aliases, and capability-based search across all providers
 - 🏠 **Local AI Support** - Run completely offline with Ollama or through LiteLLM proxy
 - 🌍 **Universal Model Access** - Direct providers + 100,000+ models via Hugging Face + 100+ models via LiteLLM
 - 🧠 **Automatic Context Summarization** - Stateful, long-running conversations with automatic history summarization.
 - 📊 **Analytics & Evaluation** - Built-in usage tracking and AI-powered quality assessment
 
-## 🛠️ MCP Integration Status ✅ **BUILT-IN TOOLS WORKING**
+## 🛠️ External MCP Integration Status ✅ **PRODUCTION READY**
 
-| Component           | Status             | Description                                              |
-| ------------------- | ------------------ | -------------------------------------------------------- |
-| Built-in Tools      | ✅ **Working**     | 6 core tools fully functional across all providers       |
-| SDK Custom Tools    | ✅ **Working**     | Register custom tools programmatically                   |
-| External Discovery  | 🔍 **Discovery**   | 58+ MCP servers discovered from AI tools ecosystem       |
-| Tool Execution      | ✅ **Working**     | Real-time AI tool calling with built-in tools            |
-| **External Tools**  | 🚧 **Development** | Manual config needs one-line fix, activation in progress |
-| **CLI Integration** | ✅ **READY**       | **Production-ready with built-in tools**                 |
-| External Activation | 🔧 **Development** | Discovery complete, activation protocol in progress      |
+| Component              | Status         | Description                                                      |
+| ---------------------- | -------------- | ---------------------------------------------------------------- |
+| Built-in Tools         | ✅ **Working** | 6 core tools fully functional across all providers               |
+| SDK Custom Tools       | ✅ **Working** | Register custom tools programmatically                           |
+| **External MCP Tools** | ✅ **Working** | **Full external MCP server support with dynamic tool discovery** |
+| Tool Execution         | ✅ **Working** | Real-time AI tool calling with all tool types                    |
+| **Streaming Support**  | ✅ **Working** | **External MCP tools work with streaming generation**            |
+| **Multi-Provider**     | ✅ **Working** | **External tools work across all AI providers**                  |
+| **CLI Integration**    | ✅ **READY**   | **Production-ready with external MCP support**                   |
 
-### ✅ Quick MCP Test (v1.7.1)
+### ✅ External MCP Integration Demo
 
 ```bash
 # Test built-in tools (works immediately)
 npx @juspay/neurolink generate "What time is it?" --debug
 
-# Disable tools for pure text generation
-npx @juspay/neurolink generate "Write a poem" --disable-tools
+# 🆕 NEW: External MCP server integration (SDK)
+import { NeuroLink } from '@juspay/neurolink';
+
+const neurolink = new NeuroLink();
+
+// Add external MCP server (e.g., Bitbucket)
+await neurolink.addExternalMCPServer('bitbucket', {
+  command: 'npx',
+  args: ['-y', '@nexus2520/bitbucket-mcp-server'],
+  transport: 'stdio',
+  env: {
+    BITBUCKET_USERNAME: process.env.BITBUCKET_USERNAME,
+    BITBUCKET_TOKEN: process.env.BITBUCKET_TOKEN,
+    BITBUCKET_BASE_URL: 'https://bitbucket.example.com'
+  }
+});
+
+// Use external MCP tools in generation
+const result = await neurolink.generate({
+  input: { text: 'Get pull request #123 details from the main repository' },
+  disableTools: false // External MCP tools automatically available
+});
 
 # Discover available MCP servers
 npx @juspay/neurolink mcp discover --format table
-
-# Install popular MCP servers (NEW: Bitbucket support added!)
-npx @juspay/neurolink mcp install filesystem
-npx @juspay/neurolink mcp install github
-npx @juspay/neurolink mcp install bitbucket  # 🆕 NEW
 ```
 
 ### 🔧 SDK Custom Tool Registration (NEW!)
@@ -663,16 +700,43 @@ npx @juspay/neurolink generate "Hello!" --provider openai-compatible
 - **Extensibility**: Connect external tools and services via MCP protocol
 - **🆕 Dynamic Server Management**: Programmatically add MCP servers at runtime
 
-### 🔧 Programmatic MCP Server Management [Coming Soon]
+### 🔧 External MCP Server Management ✅ **AVAILABLE NOW**
 
-**Note**: External MCP server activation is in development. Currently available:
+**External MCP integration is now production-ready:**
 
 - ✅ 6 built-in tools working across all providers
 - ✅ SDK custom tool registration
-- 🔍 MCP server discovery (58+ servers found)
-- 🚧 External server activation (one-line fix pending)
+- ✅ **External MCP server management** (add, remove, list, test servers)
+- ✅ **Dynamic tool discovery** (automatic tool registration from external servers)
+- ✅ **Multi-provider support** (external tools work with all AI providers)
+- ✅ **Streaming integration** (external tools work with real-time streaming)
+- ✅ **Enhanced tool tracking** (proper parameter extraction and execution logging)
 
-Manual MCP configuration (`.mcp-config.json`) support coming soon.
+```typescript
+// Complete external MCP server API
+const neurolink = new NeuroLink();
+
+// Server management
+await neurolink.addExternalMCPServer(serverId, config);
+await neurolink.removeExternalMCPServer(serverId);
+const servers = neurolink.listExternalMCPServers();
+const server = neurolink.getExternalMCPServer(serverId);
+
+// Tool management
+const tools = neurolink.getExternalMCPTools();
+const serverTools = neurolink.getExternalMCPServerTools(serverId);
+
+// Direct tool execution
+const result = await neurolink.executeExternalMCPTool(
+  serverId,
+  toolName,
+  params,
+);
+
+// Statistics and monitoring
+const stats = neurolink.getExternalMCPStatistics();
+await neurolink.shutdownExternalMCPServers();
+```
 
 ## 🤝 Contributing
 

package/dist/config/conversationMemoryConfig.js

@@ -34,6 +34,7 @@ export function getConversationMemoryDefaults() {
     return {
         enabled: process.env.NEUROLINK_MEMORY_ENABLED === "true",
         maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
-        maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) || DEFAULT_MAX_TURNS_PER_SESSION,
+        maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) ||
+            DEFAULT_MAX_TURNS_PER_SESSION,
     };
 }

package/dist/context/ContextManager.js

@@ -14,7 +14,10 @@ export class ContextManager {
     constructor(generatorFunction, config, initialContext = "This is the start of the conversation.") {
         this.internalGenerator = generatorFunction;
         this.config = config;
-        const initialMessage = { role: "system", content: initialContext };
+        const initialMessage = {
+            role: "system",
+            content: initialContext,
+        };
         initialMessage.wordCount = this.config.estimateWordCount([initialMessage]);
         this.history = [initialMessage];
         this.wordCount = initialMessage.wordCount;
@@ -55,7 +58,9 @@ export class ContextManager {
             const result = await this.internalGenerator(textOptions);
             if (typeof result.content === "string" && result.content.length > 0) {
                 // Replace the history with a single system message containing the summary
-                const newHistory = [{ role: "system", content: result.content }];
+                const newHistory = [
+                    { role: "system", content: result.content },
+                ];
                 this.history = newHistory;
                 this.wordCount = this.config.estimateWordCount(this.history);
                 logger.info(`[ContextManager] Summarization complete. New history length: ${this.wordCount} words.`);
@@ -63,7 +68,10 @@ export class ContextManager {
             else {
                 logger.warn("[ContextManager] Summarization returned empty or non-string content; truncating history as a fallback.");
                 this._truncateHistory(this.config.lowWaterMarkWords);
-                this.history.unshift({ role: "system", content: ContextManager.SUMMARIZATION_EMPTY_WARNING });
+                this.history.unshift({
+                    role: "system",
+                    content: ContextManager.SUMMARIZATION_EMPTY_WARNING,
+                });
                 this.wordCount = this.config.estimateWordCount(this.history);
             }
             logger.debug(`[ContextManager] New history: ${JSON.stringify(this.history)}`);
@@ -72,7 +80,10 @@ export class ContextManager {
             logger.error("Context summarization failed:", { error });
             // Fallback strategy: truncate the history to the target word count.
             this._truncateHistory(this.config.lowWaterMarkWords);
-            this.history.unshift({ role: "system", content: ContextManager.SUMMARIZATION_FAILED_WARNING });
+            this.history.unshift({
+                role: "system",
+                content: ContextManager.SUMMARIZATION_FAILED_WARNING,
+            });
             this.wordCount = this.config.estimateWordCount(this.history);
         }
     }

package/dist/context/config.js

@@ -6,7 +6,11 @@ function estimateWordCount(history) {
     if (!history || history.length === 0) {
         return 0;
     }
-    return history.reduce((acc, msg) => acc + (msg.content.trim().split(/\s+/).filter(word => word.length > 0).length || 0), 0);
+    return history.reduce((acc, msg) => acc +
+        (msg.content
+            .trim()
+            .split(/\s+/)
+            .filter((word) => word.length > 0).length || 0), 0);
 }
 /**
  * Generates the default prompt for summarization.

package/dist/context/utils.js

@@ -4,5 +4,5 @@
  * @returns A formatted string representing the conversation.
  */
 export function formatHistoryToString(history) {
-    return history.map(msg => `${msg.role}: ${msg.content}`).join('\n\n');
+    return history.map((msg) => `${msg.role}: ${msg.content}`).join("\n\n");
 }

package/dist/core/baseProvider.d.ts

@@ -6,7 +6,7 @@ import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { JsonValue, UnknownRecord } from "../types/common.js";
 import type { ToolResult } from "../types/tools.js";
 /**
- * Interface for SDK with in-memory MCP servers
+ * Interface for SDK with in-memory MCP servers and external MCP support
  */
 export interface NeuroLinkSDK {
     getInMemoryServers?: () => Map<string, {
@@ -18,6 +18,16 @@ export interface NeuroLinkSDK {
         category?: string;
         metadata?: UnknownRecord;
     }>;
+    externalServerManager?: {
+        getAllTools: () => Array<{
+            name: string;
+            description: string;
+            serverId: string;
+            isAvailable: boolean;
+            inputSchema?: Record<string, unknown>;
+        }>;
+        executeTool: (serverId: string, toolName: string, params: any) => Promise<any>;
+    };
 }
 /**
  * Interface for tool information in MCP servers
@@ -86,6 +96,11 @@ export declare abstract class BaseProvider implements AIProvider {
      * MCP tools are added when available (without blocking)
      */
     protected getAllTools(): Promise<Record<string, Tool>>;
+    /**
+     * Convert MCP JSON Schema to Zod schema for AI SDK tools
+     * Handles common MCP schema patterns safely
+     */
+    private convertMCPSchemaToZod;
     /**
      * Set session context for MCP tools
      */

package/dist/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/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/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/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/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/config/conversationMemoryConfig.js

@@ -34,6 +34,7 @@ export function getConversationMemoryDefaults() {
     return {
         enabled: process.env.NEUROLINK_MEMORY_ENABLED === "true",
         maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
-        maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) || DEFAULT_MAX_TURNS_PER_SESSION,
+        maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) ||
+            DEFAULT_MAX_TURNS_PER_SESSION,
     };
 }