@juspay/neurolink 5.1.0 → 5.3.0

package/dist/lib/factories/provider-registry.js

@@ -0,0 +1,107 @@
+import { ProviderFactory } from "./provider-factory.js";
+// ✅ FINAL CIRCULAR DEPENDENCY FIX: Lazy loading all providers
+// Removed all static imports - providers loaded dynamically when needed
+// This breaks the circular dependency chain completely
+import { AIProviderName, GoogleAIModels, OpenAIModels } from "../core/types.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Provider Registry - registers all providers with the factory
+ * This is where we migrate providers one by one to the new pattern
+ */
+export class ProviderRegistry {
+    static registered = false;
+    static options = {
+        enableManualMCP: false, // Default to disabled for safety
+    };
+    /**
+     * Register all providers with the factory
+     */
+    static async registerAllProviders() {
+        if (this.registered) {
+            return;
+        }
+        try {
+            // ✅ LAZY LOADING: Register providers with dynamic import factory functions
+            const { ProviderFactory } = await import("./provider-factory.js");
+            // Register Google AI Studio Provider (our validated baseline)
+            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, providerName, sdk) => {
+                const { GoogleAIStudioProvider } = await import("../providers/google-ai-studio.js");
+                return new GoogleAIStudioProvider(modelName, sdk);
+            }, GoogleAIModels.GEMINI_2_5_FLASH, ["google-ai-studio", "google", "gemini", "google-ai"]);
+            // Register OpenAI provider
+            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, providerName, sdk) => {
+                const { OpenAIProvider } = await import("../providers/openAI.js");
+                return new OpenAIProvider(modelName);
+            }, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"]);
+            // Register Anthropic provider
+            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, providerName, sdk) => {
+                const { AnthropicProvider } = await import("../providers/anthropic.js");
+                return new AnthropicProvider(modelName, sdk);
+            }, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
+            // Register Amazon Bedrock provider
+            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName) => {
+                const { AmazonBedrockProvider } = await import("../providers/amazon-bedrock.js");
+                return new AmazonBedrockProvider(modelName);
+            }, undefined, // Let provider read BEDROCK_MODEL from .env
+            ["bedrock", "aws"]);
+            // Register Azure OpenAI provider
+            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName) => {
+                const { AzureOpenAIProvider } = await import("../providers/azure-openai.js");
+                return new AzureOpenAIProvider(modelName);
+            }, "gpt-4o-mini", ["azure", "azure-openai"]);
+            // Register Google Vertex AI provider
+            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName) => {
+                const { GoogleVertexProvider } = await import("../providers/google-vertex.js");
+                return new GoogleVertexProvider(modelName);
+            }, "gemini-2.5-pro", ["vertex", "google-vertex"]);
+            // Register Hugging Face provider (Unified Router implementation)
+            ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {
+                const { HuggingFaceProvider } = await import("../providers/huggingFace.js");
+                return new HuggingFaceProvider(modelName);
+            }, process.env.HUGGINGFACE_MODEL || "microsoft/DialoGPT-medium", ["huggingface", "hf"]);
+            // Register Mistral AI provider
+            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, providerName, sdk) => {
+                const { MistralProvider } = await import("../providers/mistral.js");
+                return new MistralProvider(modelName, sdk);
+            }, "mistral-large-latest", ["mistral"]);
+            // Register Ollama provider
+            ProviderFactory.registerProvider(AIProviderName.OLLAMA, async (modelName) => {
+                const { OllamaProvider } = await import("../providers/ollama.js");
+                return new OllamaProvider(modelName);
+            }, process.env.OLLAMA_MODEL || "llama3.1:8b", ["ollama", "local"]);
+            logger.debug("All providers registered successfully");
+            this.registered = true;
+        }
+        catch (error) {
+            logger.error("Failed to register providers:", error);
+            throw error;
+        }
+    }
+    /**
+     * Check if providers are registered
+     */
+    static isRegistered() {
+        return this.registered;
+    }
+    /**
+     * Clear registrations (for testing)
+     */
+    static clearRegistrations() {
+        ProviderFactory.clearRegistrations();
+        this.registered = false;
+    }
+    /**
+     * Set registry options (should be called before initialization)
+     */
+    static setOptions(options) {
+        this.options = { ...this.options, ...options };
+        logger.debug("Provider registry options updated:", this.options);
+    }
+    /**
+     * Get current registry options
+     */
+    static getOptions() {
+        return { ...this.options };
+    }
+}
+// Note: Providers are registered explicitly when needed to avoid circular dependencies

package/dist/lib/index.d.ts

@@ -12,12 +12,13 @@ export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, Prov
 export type { GenerateOptions, GenerateResult, EnhancedProvider, } from "./types/generate-types.js";
 export { CompatibilityConversionFactory } from "./factories/compatibility-factory.js";
 export { ProviderGenerateFactory } from "./factories/provider-generate-factory.js";
+export type { SimpleTool, ToolContext } from "./sdk/tool-registration.js";
+export { createTool, createTypedTool, validateTool, } from "./sdk/tool-registration.js";
+export type { InMemoryMCPServerConfig, InMemoryToolInfo, InMemoryToolResult, } from "./types/mcp-types.js";
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
-export { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, } from "./providers/index.js";
-export type { ProviderName } from "./providers/index.js";
-export { PROVIDERS, AVAILABLE_PROVIDERS } from "./providers/index.js";
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { NeuroLink } from "./neurolink.js";
+export type { ProviderStatus, MCPStatus, MCPServerInfo } from "./neurolink.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function

package/dist/lib/index.js

@@ -11,14 +11,12 @@ import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
 export { CompatibilityConversionFactory } from "./factories/compatibility-factory.js";
 export { ProviderGenerateFactory } from "./factories/provider-generate-factory.js";
+export { createTool, createTypedTool, validateTool, } from "./sdk/tool-registration.js";
 // Model enums
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
-// Provider exports
-export { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, } from "./providers/index.js";
-export { PROVIDERS, AVAILABLE_PROVIDERS } from "./providers/index.js";
 // Utility exports
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
-// Main NeuroLink wrapper class
+// Main NeuroLink wrapper class and diagnostic types
 export { NeuroLink } from "./neurolink.js";
 // Version
 export const VERSION = "1.0.0";

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

@@ -33,6 +33,7 @@ export declare class NeuroLinkMCPClient extends EventEmitter {
      * Get all registered tools
      */
     getTools(): Record<string, {
+        name: string;
         description?: string;
         inputSchema?: unknown;
     }>;

package/dist/lib/mcp/client.js

@@ -130,6 +130,7 @@ export class NeuroLinkMCPClient extends EventEmitter {
         const tools = {};
         for (const [name, tool] of this.tools) {
             tools[name] = {
+                name: name, // Include the tool name as a property
                 description: tool.description,
                 inputSchema: tool.inputSchema,
             };

package/dist/lib/mcp/config.js

@@ -3,15 +3,36 @@
  * Central registry for all MCP servers following Lighthouse patterns
  * Handles built-in servers only - auto-discovery handled by unified registry
  */
-import { aiCoreServer } from "./servers/ai-providers/ai-core-server.js";
 import { utilityServer } from "./servers/utilities/utility-server.js";
 import { logger } from "../utils/logger.js";
+/**
+ * Lazy-loaded AI Core Server to avoid circular dependencies
+ */
+let aiCoreServerCache = null;
+async function getAICoreServer() {
+    if (!aiCoreServerCache) {
+        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
+        aiCoreServerCache = aiCoreServer;
+    }
+    return aiCoreServerCache;
+}
+/**
+ * Lazy-loaded Direct Tools Server to avoid circular dependencies
+ */
+let directToolsServerCache = null;
+async function getDirectToolsServer() {
+    if (!directToolsServerCache) {
+        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
+        directToolsServerCache = directToolsServer;
+    }
+    return directToolsServerCache;
+}
 /**
  * Built-in MCP servers (kept for backward compatibility)
  * Add new servers here as they are created
  */
 export const allServers = [
-    aiCoreServer,
+    // aiCoreServer will be added dynamically in getServers()
     utilityServer,
     // Add more servers as they are created
 ];
@@ -25,8 +46,12 @@ export const mcpConfig = {
      */
     getServers: async () => {
         const activeServers = [];
+        // Get all servers including dynamically loaded ones
+        const aiCoreServer = await getAICoreServer();
+        const directToolsServer = await getDirectToolsServer();
+        const servers = [aiCoreServer, directToolsServer, ...allServers];
         // Include built-in servers with filtering
-        for (const server of allServers) {
+        for (const server of servers) {
             const implementedTools = {};
             let hasImplementedTools = false;
             for (const toolName in server.tools) {

package/dist/lib/mcp/context-manager.d.ts

@@ -29,6 +29,7 @@ export interface ContextRequest {
 export declare class ContextManager {
     private sessionCounter;
     private activeContexts;
+    private static cachedLogger;
     /**
      * Create a new execution context with rich information
      *

package/dist/lib/mcp/context-manager.js

@@ -10,6 +10,7 @@
 export class ContextManager {
     sessionCounter = 0;
     activeContexts = new Map();
+    static cachedLogger = null;
     /**
      * Create a new execution context with rich information
      *
@@ -64,6 +65,7 @@ export class ContextManager {
             },
             path: {
                 join: (...paths) => {
+                    // Use dynamic require for synchronous path operations
                     const path = require("path");
                     return path.join(...paths);
                 },
@@ -85,11 +87,13 @@ export class ContextManager {
                 },
             },
             grantedPermissions: request.permissions || [],
-            log: (level, message, data) => {
-                // Use logger if available, otherwise console
+            log: async (level, message, data) => {
+                // Use cached logger if available, otherwise import and cache
                 try {
-                    const { logger } = require("../utils/logger.js");
-                    logger[level](message, data);
+                    if (!ContextManager.cachedLogger) {
+                        ContextManager.cachedLogger = await import("../utils/logger.js").then(({ logger }) => logger);
+                    }
+                    ContextManager.cachedLogger[level](message, data);
                 }
                 catch {
                     console[level === "debug" ? "log" : level](message, data);

package/dist/lib/mcp/function-calling.d.ts

@@ -14,6 +14,7 @@ export declare function mcpToolToAISDKTool(tool: NeuroLinkMCPTool, serverId: str
  */
 export declare function getAvailableFunctionTools(): Promise<{
     tools: Tool[];
+    toolsObject: Record<string, Tool>;
     toolMap: Map<string, {
         serverId: string;
         toolName: string;
@@ -49,3 +50,15 @@ export declare function getFunctionToolsForCategory(category?: string, maxTools?
  * Check if function calling is available
  */
 export declare function isFunctionCallingAvailable(): Promise<boolean>;
+/**
+ * Utility function to create a named tool object for debugging
+ */
+export declare function createNamedTool(name: string, toolDef: any): any & {
+    name: string;
+};
+/**
+ * Get tools with proper name properties for debugging
+ */
+export declare function getToolsWithNames(): Promise<Record<string, any & {
+    name: string;
+}>>;

package/dist/lib/mcp/function-calling.js

@@ -8,6 +8,100 @@ import { z } from "zod";
 import { unifiedRegistry } from "./unified-registry.js";
 import { createExecutionContext } from "./context-manager.js";
 import { mcpLogger } from "./logging.js";
+/**
+ * Parses neurolink-specific function name patterns to extract the server ID and tool name.
+ *
+ * @param {string[]} parts - An array of strings representing parts of a function name,
+ * typically obtained by splitting the function name on underscores.
+ * @returns {{ serverId: string; toolName: string } | null} An object containing the `serverId`
+ * and `toolName` if the input matches a neurolink-specific pattern, or `null` if no match is found.
+ *
+ * @example
+ * // Returns { serverId: "neurolink_ai_core", toolName: "generate" }
+ * parseNeuroLinkPattern(["neurolink", "ai", "core", "generate"]);
+ *
+ * @example
+ * // Returns { serverId: "neurolink_utility", toolName: "format_number" }
+ * parseNeuroLinkPattern(["neurolink", "utility", "format_number"]);
+ *
+ * @example
+ * // Returns null
+ * parseNeuroLinkPattern(["other", "pattern"]);
+ */
+function parseNeuroLinkPattern(parts) {
+    if (parts.length >= 3 &&
+        parts[0] === "neurolink" &&
+        (parts[1] === "ai" || parts[1] === "utility")) {
+        // neurolink_ai_core_generate -> serverId: "neurolink_ai_core", toolName: "generate"
+        // neurolink_utility_format_number -> serverId: "neurolink_utility", toolName: "format_number"
+        if (parts[1] === "ai" && parts[2] === "core") {
+            return {
+                serverId: "neurolink_ai_core",
+                toolName: parts.slice(3).join("_"),
+            };
+        }
+        else if (parts[1] === "utility") {
+            return {
+                serverId: "neurolink_utility",
+                toolName: parts.slice(2).join("_"),
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Parse underscore-separated function name format
+ */
+function parseUnderscoreFormat(functionName) {
+    const parts = functionName.split("_");
+    if (parts.length >= 2) {
+        // Try neurolink-specific patterns first
+        const neurolinkResult = parseNeuroLinkPattern(parts);
+        if (neurolinkResult) {
+            return neurolinkResult;
+        }
+        // Default underscore parsing
+        return {
+            serverId: parts[0],
+            toolName: parts.slice(1).join("_"),
+        };
+    }
+    return null;
+}
+/**
+ * Parse dot-separated function name format (legacy support)
+ */
+function parseDotFormat(functionName) {
+    const parts = functionName.split(".");
+    if (parts.length >= 2) {
+        return {
+            serverId: parts[0],
+            toolName: parts.slice(1).join("."),
+        };
+    }
+    return null;
+}
+/**
+ * Parse function name to extract server ID and tool name
+ * Handles various naming patterns including neurolink server patterns
+ */
+function parseFunctionName(functionName) {
+    // Try underscore format first (most common)
+    const underscoreResult = parseUnderscoreFormat(functionName);
+    if (underscoreResult) {
+        return underscoreResult;
+    }
+    // Fallback to dot format for backward compatibility
+    const dotResult = parseDotFormat(functionName);
+    if (dotResult) {
+        return dotResult;
+    }
+    // Final fallback - return as-is with unknown server
+    return {
+        serverId: "unknown",
+        toolName: functionName,
+    };
+}
 /**
  * Convert MCP tool to AI SDK function definition
  */
@@ -55,10 +149,11 @@ export function mcpToolToAISDKTool(tool, serverId) {
 export async function getAvailableFunctionTools() {
     const functionTag = "getAvailableFunctionTools";
     const tools = [];
+    const toolsObject = {};
     const toolMap = new Map();
     try {
         // Add overall timeout for the entire function
-        const overallTimeoutMs = 5000; // 5 seconds max for everything
+        const overallTimeoutMs = process.env.NODE_ENV === "test" ? 30000 : 15000; // 30s for tests, 15s for production
         let overallTimeoutId;
         const overallTimeoutPromise = new Promise((_, reject) => {
             overallTimeoutId = setTimeout(() => {
@@ -281,6 +376,8 @@ export async function getAvailableFunctionTools() {
                             },
                         });
                         tools.push(aiTool);
+                        // Store tool with proper name association
+                        toolsObject[functionName] = aiTool;
                         // Store mapping for execution - CRITICAL: Use sanitized functionName as key
                         toolMap.set(functionName, {
                             serverId: typeof toolInfo.serverId === "string"
@@ -302,7 +399,7 @@ export async function getAvailableFunctionTools() {
                 if (overallTimeoutId) {
                     clearTimeout(overallTimeoutId);
                 }
-                return { tools, toolMap };
+                return { tools, toolsObject, toolMap };
             }
             catch (error) {
                 if (overallTimeoutId) {
@@ -315,7 +412,7 @@ export async function getAvailableFunctionTools() {
     }
     catch (error) {
         mcpLogger.error(`[${functionTag}] Error getting function tools:`, error);
-        return { tools: [], toolMap: new Map() };
+        return { tools: [], toolsObject: {}, toolMap: new Map() };
     }
 }
 /**
@@ -345,38 +442,12 @@ export async function executeFunctionCall(functionName, parameters, context) {
             });
         }
         // Parse server and tool name from function name
-        // First try underscore format (sanitized), then fallback to dot format
-        let parts = functionName.split("_");
-        let serverId = "unknown";
-        let toolName = functionName;
-        if (parts.length >= 2) {
-            // Handle underscore format (sanitized names)
-            const firstPart = parts[0];
-            if (firstPart && typeof firstPart === "string" && firstPart.length > 0) {
-                serverId = firstPart;
-            }
-            else {
-                serverId = "unknown";
-            }
-            toolName = parts.slice(1).join("_"); // Rejoin in case tool name had underscores
-        }
-        else {
-            // Fallback to dot format for backward compatibility
-            parts = functionName.split(".");
-            if (parts.length === 2) {
-                const parsedServerId = parts[0];
-                const parsedToolName = parts[1];
-                if (parsedServerId && parsedToolName) {
-                    serverId = parsedServerId;
-                    toolName = parsedToolName;
-                }
-            }
-            else {
-                // Can't parse - try executing as-is through unified registry
-                mcpLogger.debug(`[${functionTag}] Cannot parse function name format: ${functionName}, trying unified registry`);
-                const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
-                return result;
-            }
+        const { serverId, toolName } = parseFunctionName(functionName);
+        if (serverId === "unknown") {
+            // Can't parse - try executing as-is through unified registry
+            mcpLogger.debug(`[${functionTag}] Cannot parse function name format: ${functionName}, trying unified registry`);
+            const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
+            return result;
         }
         // Handle built-in NeuroLink servers directly
         if (serverId === "neurolink-utility" ||
@@ -541,3 +612,31 @@ export async function isFunctionCallingAvailable() {
         return false;
     }
 }
+/**
+ * Utility function to create a named tool object for debugging
+ */
+export function createNamedTool(name, toolDef) {
+    return {
+        name,
+        description: toolDef.description,
+        parameters: toolDef.parameters,
+        execute: toolDef.execute,
+    };
+}
+/**
+ * Get tools with proper name properties for debugging
+ */
+export async function getToolsWithNames() {
+    try {
+        const { toolsObject } = await getAvailableFunctionTools();
+        const namedTools = {};
+        for (const [name, tool] of Object.entries(toolsObject)) {
+            namedTools[name] = createNamedTool(name, tool);
+        }
+        return namedTools;
+    }
+    catch (error) {
+        mcpLogger.warn("[getToolsWithNames] Failed to get tools with names:", error);
+        return {};
+    }
+}

package/dist/lib/mcp/initialize-tools.d.ts

@@ -13,7 +13,7 @@ export declare const initializeMCPTools: (sessionId: string, client: NeuroLinkMC
  * Get all available tools across all servers
  * Useful for documentation and discovery
  */
-export declare function getAllAvailableTools(): Promise<Array<{
+export declare function getAllAvailableTools(inMemoryServers?: Map<string, any>): Promise<Array<{
     serverId: string;
     serverTitle: string;
     toolName: string;

package/dist/lib/mcp/initialize-tools.js

@@ -139,8 +139,52 @@ export const initializeMCPTools = async (sessionId, client, context) => {
  * Get all available tools across all servers
  * Useful for documentation and discovery
  */
-export async function getAllAvailableTools() {
+export async function getAllAvailableTools(inMemoryServers) {
     const tools = [];
+    // Add in-memory server tools first
+    if (inMemoryServers) {
+        for (const [serverId, serverConfig] of inMemoryServers) {
+            const server = serverConfig.server;
+            if (server && server.tools) {
+                // Handle both Map and object formats
+                const toolEntries = server.tools instanceof Map
+                    ? Array.from(server.tools.entries())
+                    : Object.entries(server.tools || {});
+                for (const [toolName, toolInfo] of toolEntries) {
+                    const prefix = `${serverId}_`;
+                    const finalToolName = toolName.length > 64 - prefix.length
+                        ? toolName.substring(0, 64 - prefix.length)
+                        : toolName;
+                    const namespacedName = sanitizeToolName(`${prefix}${finalToolName}`);
+                    // Handle different tool info structures
+                    let description = `Tool from ${serverId}`;
+                    let isImplemented = true;
+                    if (toolInfo) {
+                        // Check if it's a tool info object with description
+                        if (typeof toolInfo.description === "string") {
+                            description = toolInfo.description;
+                        }
+                        else if (typeof toolInfo === "function") {
+                            // It's a raw function, no description available
+                            description = `${toolName} from ${serverId}`;
+                        }
+                        // Check implementation status
+                        if (typeof toolInfo.isImplemented === "boolean") {
+                            isImplemented = toolInfo.isImplemented;
+                        }
+                    }
+                    tools.push({
+                        serverId,
+                        serverTitle: server.title || serverId,
+                        toolName,
+                        namespacedName,
+                        description,
+                        isImplemented,
+                    });
+                }
+            }
+        }
+    }
     const servers = await mcpConfig.getServers();
     servers.forEach((server) => {
         Object.entries(server.tools).forEach(([toolName, tool]) => {

package/dist/lib/mcp/initialize.js

@@ -5,6 +5,7 @@
  */
 import { toolRegistry, defaultToolRegistry, } from "./tool-registry.js";
 import { mcpLogger } from "./logging.js";
+import { ServiceRegistry } from "../core/service-registry.js";
 let isInitialized = false;
 /**
  * Initialize NeuroLink MCP system by registering built-in servers
@@ -15,19 +16,28 @@ export async function initializeNeuroLinkMCP(targetRegistry) {
     }
     mcpLogger.debug("Initializing built-in MCP servers...");
     try {
+        // First, register AIProviderFactory in ServiceRegistry to break circular dependencies
+        ServiceRegistry.register("AIProviderFactory", async () => {
+            const { AIProviderFactory } = await import("../core/factory.js");
+            return AIProviderFactory;
+        });
+        mcpLogger.debug("Registered AIProviderFactory in ServiceRegistry");
         // Import utility server dynamically to avoid circular dependencies
-        // Note: AI core server temporarily disabled due to circular dependency issues
         const { utilityServer } = await import("./servers/utilities/utility-server.js");
         // Register built-in NeuroLink servers with specified registry (or default)
         const registry = targetRegistry || toolRegistry;
         await registry.registerServer(utilityServer.id, utilityServer);
         mcpLogger.debug(`Registered neurolink-utility server with built-in tools in ${targetRegistry ? "target" : "default"} registry`);
-        // TODO: Re-enable AI core server once circular dependencies are resolved
-        // const { aiCoreServer } = await import('./servers/ai-providers/ai-core-server.js');
-        // await registry.registerServer(aiCoreServer.id, aiCoreServer);
-        // mcpLogger.debug('Registered neurolink-ai-core server with AI tools');
+        // Now safe to import and register AI core server
+        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
+        await registry.registerServer(aiCoreServer.id, aiCoreServer);
+        mcpLogger.debug("Registered neurolink-ai-core server with AI tools");
+        // Register direct tools server
+        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
+        await registry.registerServer(directToolsServer.id, directToolsServer);
+        mcpLogger.debug("Registered neurolink-direct server with direct tools");
         const stats = await registry.getStats();
-        mcpLogger.info(`Initialization complete: ${stats.totalServers} server, ${stats.totalTools} tools available`);
+        mcpLogger.info(`Initialization complete: ${stats.totalServers} servers, ${stats.totalTools} tools available`);
         isInitialized = true;
     }
     catch (error) {

package/dist/lib/mcp/neurolink-mcp-client.d.ts

@@ -70,6 +70,7 @@ export declare class NeuroLinkMCPClient extends EventEmitter {
      * Get registered tools
      */
     getTools(): Record<string, {
+        name: string;
         description?: string;
         inputSchema?: unknown;
     }>;

package/dist/lib/mcp/neurolink-mcp-client.js

@@ -244,11 +244,26 @@ Response (JSON array only):`;
                     exists: async () => false,
                 },
                 path: {
-                    join: (...paths) => require("path").join(...paths),
-                    resolve: (...paths) => require("path").resolve(...paths),
-                    relative: (from, to) => require("path").relative(from, to),
-                    dirname: (path) => require("path").dirname(path),
-                    basename: (path, ext) => require("path").basename(path, ext),
+                    join: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.join(...paths);
+                    },
+                    resolve: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.resolve(...paths);
+                    },
+                    relative: (from, to) => {
+                        const pathModule = require("path");
+                        return pathModule.relative(from, to);
+                    },
+                    dirname: (pathArg) => {
+                        const pathModule = require("path");
+                        return pathModule.dirname(pathArg);
+                    },
+                    basename: (pathArg, ext) => {
+                        const pathModule = require("path");
+                        return pathModule.basename(pathArg, ext);
+                    },
                 },
                 grantedPermissions: [],
                 log: console.log,
@@ -409,6 +424,7 @@ Please provide a natural response based on the tool results.`;
         const tools = {};
         for (const [name, tool] of this.tools) {
             tools[name] = {
+                name: name, // Include the tool name as a property
                 description: tool.description,
                 inputSchema: tool.inputSchema,
             };