@juspay/neurolink 7.14.0 → 7.14.2

package/dist/lib/utils/mcpDefaults.js

@@ -0,0 +1,125 @@
+/**
+ * Smart Defaults for MCPServerInfo Creation
+ * Eliminates boilerplate manual object creation
+ */
+/**
+ * Smart category detection based on context
+ */
+export function detectCategory(context) {
+    // If category is already provided, validate and use it
+    if (context.existingCategory) {
+        const validCategories = [
+            "external",
+            "in-memory",
+            "built-in",
+            "user-defined",
+        ];
+        if (validCategories.includes(context.existingCategory)) {
+            return context.existingCategory;
+        }
+    }
+    // Smart detection based on context
+    if (context.isCustomTool) {
+        return "user-defined";
+    }
+    if (context.isBuiltIn) {
+        return "built-in";
+    }
+    if (context.isExternal) {
+        return "external";
+    }
+    if (context.serverId?.startsWith("custom-tool-")) {
+        return "user-defined";
+    }
+    if (context.serverId?.includes("external")) {
+        return "external";
+    }
+    if (context.serverId === "direct") {
+        return "built-in";
+    }
+    // Default to in-memory for most cases
+    return "in-memory";
+}
+/**
+ * Generate smart description based on name and category
+ */
+function generateDescription(name, category) {
+    // Generate descriptions based on category for better context
+    switch (category) {
+        case "external":
+            return `External MCP server: ${name}`;
+        case "built-in":
+            return `Built-in tool server: ${name}`;
+        case "custom":
+        case "user-defined":
+            return `Custom tool server: ${name}`;
+        case "in-memory":
+            return `In-memory MCP server: ${name}`;
+        default:
+            return name;
+    }
+}
+/**
+ * Create MCPServerInfo with smart defaults
+ * Eliminates manual boilerplate object creation
+ */
+export function createMCPServerInfo(options) {
+    const id = options.id || `server-${options.name}`;
+    const category = options.category ||
+        detectCategory({
+            isCustomTool: options.isCustomTool,
+            isExternal: options.isExternal,
+            isBuiltIn: options.isBuiltIn,
+            serverId: id,
+        });
+    const tools = options.tools || (options.tool ? [options.tool] : []);
+    return {
+        id,
+        name: options.name,
+        transport: options.transport || "stdio",
+        status: options.status || "connected",
+        tools,
+        description: options.description || generateDescription(options.name, category),
+        ...(options.command && { command: options.command }),
+        ...(options.args && { args: options.args }),
+        ...(options.env && { env: options.env }),
+        metadata: {
+            category: category,
+            toolCount: tools.length,
+        },
+    };
+}
+/**
+ * Create MCPServerInfo for custom tool registration
+ * Specialized version with smart defaults for registerTool usage
+ */
+export function createCustomToolServerInfo(toolName, tool) {
+    return createMCPServerInfo({
+        id: `custom-tool-${toolName}`,
+        name: toolName,
+        tool: {
+            name: toolName,
+            description: tool.description || toolName,
+            inputSchema: tool.inputSchema || {},
+            execute: tool.execute,
+        },
+        isCustomTool: true,
+    });
+}
+/**
+ * Create MCPServerInfo for external servers
+ * Specialized version with smart defaults for external server usage
+ */
+export function createExternalServerInfo(options) {
+    return createMCPServerInfo({
+        id: options.id,
+        name: options.name || options.id,
+        tools: options.tools || [],
+        transport: options.transport || "stdio",
+        description: options.description || options.name || options.id,
+        isExternal: true,
+        command: options.command,
+        args: options.args,
+        env: options.env,
+    });
+}

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

@@ -56,7 +56,7 @@ export declare function getProviderModel(envVar: string, defaultModel: string):
 /**
  * Checks if provider credentials are available
  * @param envVars Array of environment variable names to check
- * @returns True if any of the credentials are available
+ * @returns True if one of the credentials is available
  */
 export declare function hasProviderCredentials(envVars: string[]): boolean;
 /**

package/dist/lib/utils/providerConfig.js

@@ -135,7 +135,7 @@ export function getProviderModel(envVar, defaultModel) {
 /**
  * Checks if provider credentials are available
  * @param envVars Array of environment variable names to check
- * @returns True if any of the credentials are available
+ * @returns True if one of the credentials is available
  */
 export function hasProviderCredentials(envVars) {
     return envVars.some((envVar) => !!process.env[envVar]);
@@ -286,7 +286,7 @@ export function createOpenAICompatibleConfig() {
             "1. Set OPENAI_COMPATIBLE_BASE_URL to your endpoint (e.g., https://api.openrouter.ai/api/v1)",
             "2. Get API key from your OpenAI-compatible service:",
             "   • OpenRouter: https://openrouter.ai/keys",
-            "   • vLLM: Use any value for local deployments",
+            "   • vLLM: Use a random value for local deployments",
             "   • LiteLLM: Check your LiteLLM server configuration",
             "3. Set OPENAI_COMPATIBLE_API_KEY to your API key",
             "4. Optionally set OPENAI_COMPATIBLE_MODEL (will auto-discover if not set)",

package/dist/lib/utils/providerHealth.js

@@ -487,13 +487,13 @@ export class ProviderHealthChecker {
                 return provider;
             }
         }
-        // Fallback to any healthy provider
-        const anyHealthy = healthStatuses.find((h) => h.isHealthy);
-        if (anyHealthy) {
-            logger.info(`Using fallback healthy provider: ${anyHealthy.provider}`);
-            return anyHealthy.provider;
+        // Fallback to first healthy provider
+        const firstHealthyProvider = healthStatuses.find((h) => h.isHealthy);
+        if (firstHealthyProvider) {
+            logger.info(`Using fallback healthy provider: ${firstHealthyProvider.provider}`);
+            return firstHealthyProvider.provider;
         }
-        // Last resort: any configured provider
+        // Last resort: first configured provider
         const anyConfigured = healthStatuses.find((h) => h.isConfigured);
         if (anyConfigured) {
             logger.warn(`Using configured but potentially unhealthy provider: ${anyConfigured.provider}`);

package/dist/mcp/externalServerManager.d.ts

@@ -8,25 +8,45 @@
  */
 import { EventEmitter } from "events";
 import { ToolDiscoveryService } from "./toolDiscoveryService.js";
-import type { ExternalMCPServerConfig, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPManagerConfig, ExternalMCPToolInfo } from "../types/externalMcp.js";
-/**
- * ExternalServerManager
- * Core class for managing external MCP servers
- */
+import type { ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPManagerConfig, ExternalMCPToolInfo } from "../types/externalMcp.js";
+import type { MCPServerInfo } from "../types/mcpTypes.js";
+import type { JsonObject } from "../types/common.js";
 export declare class ExternalServerManager extends EventEmitter {
     private servers;
     private config;
     private isShuttingDown;
     private toolDiscovery;
-    constructor(config?: ExternalMCPManagerConfig);
+    private enableMainRegistryIntegration;
+    constructor(config?: ExternalMCPManagerConfig, options?: {
+        enableMainRegistryIntegration?: boolean;
+    });
+    /**
+     * Load MCP server configurations from .mcp-config.json file
+     * Automatically registers servers found in the configuration
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to number of servers loaded
+     */
+    loadMCPConfiguration(configPath?: string): Promise<{
+        serversLoaded: number;
+        errors: string[];
+    }>;
     /**
      * Validate external MCP server configuration
      */
-    validateConfig(config: ExternalMCPServerConfig): ExternalMCPConfigValidation;
+    validateConfig(config: MCPServerInfo): ExternalMCPConfigValidation;
+    /**
+     * Convert MCPServerInfo format (keeping for backward compatibility)
+     * Helper function for transitioning to zero-conversion architecture
+     */
+    private convertConfigToMCPServerInfo;
+    /**
+     * Add a new external MCP server - Backward compatibility overload
+     */
+    addServer(serverId: string, config: MCPServerInfo): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
     /**
-     * Add a new external MCP server
+     * Add a new external MCP server - Updated to accept MCPServerInfo
      */
-    addServer(serverId: string, config: ExternalMCPServerConfig): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
+    addServer(serverId: string, serverInfo: MCPServerInfo): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
     /**
      * Remove an external MCP server
      */
@@ -64,13 +84,17 @@ export declare class ExternalServerManager extends EventEmitter {
      */
     private performHealthCheck;
     /**
-     * Get server instance
+     * Get server instance - converted to ExternalMCPServerInstance for compatibility
      */
     getServer(serverId: string): ExternalMCPServerInstance | undefined;
     /**
-     * Get all servers
+     * Get all servers - converted to ExternalMCPServerInstance for compatibility
      */
     getAllServers(): Map<string, ExternalMCPServerInstance>;
+    /**
+     * List servers as MCPServerInfo - ZERO conversion needed
+     */
+    listServers(): MCPServerInfo[];
     /**
      * Get server statuses
      */
@@ -94,12 +118,21 @@ export declare class ExternalServerManager extends EventEmitter {
      * Discover tools from a server
      */
     private discoverServerTools;
+    /**
+     * Register server tools with main tool registry for unified access
+     * This enables external MCP tools to be accessed via the main toolRegistry.executeTool()
+     */
+    private registerServerToolsWithMainRegistry;
+    /**
+     * Unregister server tools from main tool registry
+     */
+    private unregisterServerToolsFromMainRegistry;
     /**
      * Execute a tool on a specific server
      */
-    executeTool(serverId: string, toolName: string, parameters: Record<string, any>, options?: {
+    executeTool(serverId: string, toolName: string, parameters: JsonObject, options?: {
         timeout?: number;
-    }): Promise<any>;
+    }): Promise<unknown>;
     /**
      * Get all tools from all servers
      */