@juspay/neurolink 7.12.0 → 7.14.0

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,
     };
 }

package/dist/lib/context/ContextManager.d.ts

@@ -0,0 +1,28 @@
+import type { TextGenerationOptions, TextGenerationResult } from "../core/types.js";
+import type { ContextManagerConfig } from "./types.js";
+type InternalGenerator = (options: TextGenerationOptions) => Promise<TextGenerationResult>;
+/**
+ * Manages conversation context, automatically summarizing it when it
+ * exceeds a specified word count limit.
+ */
+export declare class ContextManager {
+    private static readonly SUMMARIZATION_FAILED_WARNING;
+    private static readonly SUMMARIZATION_EMPTY_WARNING;
+    private history;
+    private wordCount;
+    private readonly internalGenerator;
+    private readonly config;
+    constructor(generatorFunction: InternalGenerator, config: ContextManagerConfig, initialContext?: string);
+    addTurn(role: "user" | "assistant", message: string): Promise<void>;
+    /**
+     * Formats the history including the latest user turn for the prompt, without modifying the permanent history.
+     */
+    getContextForPrompt(role: "user", message: string): string;
+    getCurrentContext(): string;
+    private _summarize;
+    /**
+     * Truncates the history to a specific word count, preserving the most recent messages.
+     */
+    private _truncateHistory;
+}
+export {};

package/dist/lib/context/ContextManager.js

@@ -0,0 +1,113 @@
+import { logger } from "../utils/logger.js";
+import { formatHistoryToString } from "./utils.js";
+/**
+ * Manages conversation context, automatically summarizing it when it
+ * exceeds a specified word count limit.
+ */
+export class ContextManager {
+    static SUMMARIZATION_FAILED_WARNING = "[System Warning: Context summarization failed. Conversation history has been truncated.]";
+    static SUMMARIZATION_EMPTY_WARNING = "[System Warning: Context summarization failed to return valid content. Conversation history has been truncated.]";
+    history;
+    wordCount;
+    internalGenerator;
+    config;
+    constructor(generatorFunction, config, initialContext = "This is the start of the conversation.") {
+        this.internalGenerator = generatorFunction;
+        this.config = config;
+        const initialMessage = {
+            role: "system",
+            content: initialContext,
+        };
+        initialMessage.wordCount = this.config.estimateWordCount([initialMessage]);
+        this.history = [initialMessage];
+        this.wordCount = initialMessage.wordCount;
+    }
+    async addTurn(role, message) {
+        const newMessage = { role, content: message };
+        newMessage.wordCount = this.config.estimateWordCount([newMessage]);
+        this.history.push(newMessage);
+        this.wordCount += newMessage.wordCount;
+        logger.info(`[ContextManager] Current word count: ${this.wordCount} / ${this.config.highWaterMarkWords}`);
+        if (this.wordCount > this.config.highWaterMarkWords) {
+            await this._summarize();
+        }
+    }
+    /**
+     * Formats the history including the latest user turn for the prompt, without modifying the permanent history.
+     */
+    getContextForPrompt(role, message) {
+        const tempHistory = [...this.history, { role, content: message }];
+        return formatHistoryToString(tempHistory);
+    }
+    getCurrentContext() {
+        // Format the history into a single string for the provider prompt
+        return formatHistoryToString(this.history);
+    }
+    async _summarize() {
+        try {
+            const prompt = this.config.getSummarizationPrompt(this.history, this.config.lowWaterMarkWords);
+            // Construct options for the internal method, bypassing the main 'generate' entry point
+            const textOptions = {
+                prompt,
+                provider: this.config.summarizationProvider,
+                model: this.config.summarizationModel,
+                // Ensure summarization does not trigger more context management or tools
+                disableTools: true,
+            };
+            // Call the internal generation function directly to avoid recursion
+            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 },
+                ];
+                this.history = newHistory;
+                this.wordCount = this.config.estimateWordCount(this.history);
+                logger.info(`[ContextManager] Summarization complete. New history length: ${this.wordCount} words.`);
+            }
+            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.wordCount = this.config.estimateWordCount(this.history);
+            }
+            logger.debug(`[ContextManager] New history: ${JSON.stringify(this.history)}`);
+        }
+        catch (error) {
+            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.wordCount = this.config.estimateWordCount(this.history);
+        }
+    }
+    /**
+     * Truncates the history to a specific word count, preserving the most recent messages.
+     */
+    _truncateHistory(wordLimit) {
+        if (this.wordCount <= wordLimit) {
+            return;
+        }
+        let runningCount = 0;
+        let sliceIndex = this.history.length;
+        for (let i = this.history.length - 1; i >= 0; i--) {
+            let wordCount = this.history[i].wordCount;
+            if (wordCount === undefined) {
+                logger.warn(`[ContextManager] Word count cache missing for message at index ${i}. Recalculating.`);
+                wordCount = this.config.estimateWordCount([this.history[i]]);
+            }
+            runningCount += wordCount;
+            if (runningCount > wordLimit) {
+                sliceIndex = i + 1;
+                break;
+            }
+        }
+        this.history = this.history.slice(sliceIndex);
+    }
+}

package/dist/lib/context/config.d.ts

@@ -0,0 +1,5 @@
+import type { ContextManagerConfig } from "./types.js";
+/**
+ * Default configuration for the ContextManager.
+ */
+export declare const defaultContextConfig: ContextManagerConfig;

package/dist/lib/context/config.js

@@ -0,0 +1,42 @@
+import { formatHistoryToString } from "./utils.js";
+/**
+ * Estimates the word count of a conversation history.
+ */
+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);
+}
+/**
+ * Generates the default prompt for summarization.
+ */
+function getDefaultSummarizationPrompt(history, wordLimit) {
+    const formattedHistory = formatHistoryToString(history);
+    return `
+You are a context summarization AI. Your task is to condense the following conversation history for another AI assistant.
+The summary must be a concise, third-person narrative that retains all critical information. Pay special attention to retaining key entities, technical details, decisions made, and any specific dates or times mentioned.
+Ensure the summary flows logically and is ready to be used as context for the next turn in the conversation.
+Please keep the summary under ${wordLimit} words.
+
+Conversation History to Summarize:
+---
+${formattedHistory}
+---
+`.trim();
+}
+/**
+ * Default configuration for the ContextManager.
+ */
+export const defaultContextConfig = {
+    highWaterMarkWords: 3000,
+    lowWaterMarkWords: 800,
+    summarizationModel: "gemini-2.5-flash",
+    summarizationProvider: "googlevertex",
+    getSummarizationPrompt: getDefaultSummarizationPrompt,
+    estimateWordCount: estimateWordCount,
+};

package/dist/lib/context/types.d.ts

@@ -0,0 +1,20 @@
+export interface ChatMessage {
+    /** Role of the message sender */
+    role: "user" | "assistant" | "system";
+    /** Content of the message */
+    content: string;
+    /** Cached word count for performance */
+    wordCount?: number;
+}
+/**
+ * Defines the configuration for the ContextManager.
+ * This allows for easy customization of the summarization behavior.
+ */
+export interface ContextManagerConfig {
+    highWaterMarkWords: number;
+    lowWaterMarkWords: number;
+    summarizationModel: string;
+    summarizationProvider: string;
+    getSummarizationPrompt: (history: ChatMessage[], wordLimit: number) => string;
+    estimateWordCount: (history: ChatMessage[]) => number;
+}

package/dist/lib/context/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/context/utils.d.ts

@@ -0,0 +1,7 @@
+import type { ChatMessage } from "./types.js";
+/**
+ * Formats a chat history array into a single string for use in a prompt.
+ * @param history The array of ChatMessage objects.
+ * @returns A formatted string representing the conversation.
+ */
+export declare function formatHistoryToString(history: ChatMessage[]): string;

package/dist/lib/context/utils.js

@@ -0,0 +1,8 @@
+/**
+ * Formats a chat history array into a single string for use in a prompt.
+ * @param history The array of ChatMessage objects.
+ * @returns A formatted string representing the conversation.
+ */
+export function formatHistoryToString(history) {
+    return history.map((msg) => `${msg.role}: ${msg.content}`).join("\n\n");
+}

package/dist/lib/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
      */