@juspay/neurolink 1.9.0 → 1.11.0

package/dist/core/factory.js

@@ -1,5 +1,5 @@
 import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio, HuggingFace, Ollama, MistralAI, } from "../providers/index.js";
-import { getBestProvider } from "../utils/providerUtils.js";
+import { getBestProviderSync } from "../utils/providerUtils.js";
 import { logger } from "../utils/logger.js";
 import { dynamicModelProvider } from "./dynamic-models.js";
 const componentIdentifier = "aiProviderFactory";
@@ -157,16 +157,15 @@ export class AIProviderFactory {
             // Wrap with MCP if enabled
             if (enableMCP) {
                 try {
-                    // TEMPORARY: Disable MCP wrapping to test for hanging issues
-                    logger.debug(`[${functionTag}] MCP wrapping temporarily disabled for debugging`);
-                    // const { createMCPAwareProviderV3 } = await import("../providers/function-calling-provider.js");
-                    // provider = createMCPAwareProviderV3(provider, {
-                    //   providerName,
-                    //   modelName: resolvedModelName || undefined,
-                    //   enableMCP: true,
-                    //   enableFunctionCalling: true,
-                    // });
-                    // logger.debug(`[${functionTag}] Provider wrapped with MCP support`);
+                    logger.debug(`[${functionTag}] Enabling MCP wrapping for AI integration`);
+                    const { createMCPAwareProviderV3 } = await import("../providers/function-calling-provider.js");
+                    provider = createMCPAwareProviderV3(provider, {
+                        providerName,
+                        modelName: resolvedModelName || undefined,
+                        enableMCP: true,
+                        enableFunctionCalling: true,
+                    });
+                    logger.debug(`[${functionTag}] Provider wrapped with MCP support`);
                 }
                 catch (mcpError) {
                     logger.warn(`[${functionTag}] Failed to wrap with MCP, using base provider`, {
@@ -233,7 +232,7 @@ export class AIProviderFactory {
     static async createBestProvider(requestedProvider, modelName, enableMCP = true) {
         const functionTag = "AIProviderFactory.createBestProvider";
         try {
-            const bestProvider = getBestProvider(requestedProvider);
+            const bestProvider = getBestProviderSync(requestedProvider);
             logger.debug(`[${functionTag}] Best provider selected`, {
                 requestedProvider: requestedProvider || "auto",
                 selectedProvider: bestProvider,

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, }
 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 { getBestProviderSync as getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { NeuroLink } from "./neurolink.js";
 export type { TextGenerationOptions, StreamTextOptions, TextGenerationResult, } from "./neurolink.js";
 export declare const VERSION = "1.0.0";
@@ -54,3 +54,26 @@ export declare function createAIProviderWithFallback(primaryProvider?: string, f
  * ```
  */
 export declare function createBestAIProvider(requestedProvider?: string, modelName?: string): Promise<import("./core/types.js").AIProvider>;
+/**
+ * MCP (Model Context Protocol) Plugin Ecosystem
+ *
+ * Extensible plugin architecture based on research blueprint for
+ * transforming NeuroLink into a Universal AI Development Platform.
+ *
+ * @example
+ * ```typescript
+ * import { mcpEcosystem, readFile, writeFile } from 'neurolink';
+ *
+ * // Initialize the ecosystem
+ * await mcpEcosystem.initialize();
+ *
+ * // List available plugins
+ * const plugins = await mcpEcosystem.list();
+ *
+ * // Use filesystem operations
+ * const content = await readFile('README.md');
+ * await writeFile('output.txt', 'Hello from MCP!');
+ * ```
+ */
+export { MCPEcosystem, mcpEcosystem, initializeMCPEcosystem, PluginManager, pluginManager, listMCPs, executeMCP, getMCPStats, readFile, writeFile, listFiles, createDirectory, MCP, SecurityManager, mcpLogger, FileSystemMCP, } from "./mcp/index.js";
+export type { MCPMetadata, ExecutionContext, MCPConstructor, MCPInstance, DiscoveredMCP, LogLevel, } from "./mcp/index.js";

package/dist/index.js

@@ -15,7 +15,7 @@ export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, }
 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";
+export { getBestProviderSync as getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 // Main NeuroLink wrapper class
 export { NeuroLink } from "./neurolink.js";
 // Version
@@ -60,3 +60,38 @@ export async function createAIProviderWithFallback(primaryProvider, fallbackProv
 export async function createBestAIProvider(requestedProvider, modelName) {
     return await AIProviderFactory.createBestProvider(requestedProvider, modelName);
 }
+// ============================================================================
+// MCP PLUGIN ECOSYSTEM - Universal AI Development Platform
+// ============================================================================
+/**
+ * MCP (Model Context Protocol) Plugin Ecosystem
+ *
+ * Extensible plugin architecture based on research blueprint for
+ * transforming NeuroLink into a Universal AI Development Platform.
+ *
+ * @example
+ * ```typescript
+ * import { mcpEcosystem, readFile, writeFile } from 'neurolink';
+ *
+ * // Initialize the ecosystem
+ * await mcpEcosystem.initialize();
+ *
+ * // List available plugins
+ * const plugins = await mcpEcosystem.list();
+ *
+ * // Use filesystem operations
+ * const content = await readFile('README.md');
+ * await writeFile('output.txt', 'Hello from MCP!');
+ * ```
+ */
+export { 
+// Core MCP ecosystem
+MCPEcosystem, mcpEcosystem, initializeMCPEcosystem, 
+// Plugin management
+PluginManager, pluginManager, listMCPs, executeMCP, getMCPStats, 
+// Quick filesystem operations
+readFile, writeFile, listFiles, createDirectory, 
+// Core contracts and types
+MCP, SecurityManager, mcpLogger, 
+// Core plugins
+FileSystemMCP, } from "./mcp/index.js";

package/dist/lib/agent/direct-tools.d.ts

@@ -280,12 +280,12 @@ export declare const directAgentTools: {
         pattern: z.ZodString;
         recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, "strip", z.ZodTypeAny, {
-        pattern: string;
         directory: string;
+        pattern: string;
         recursive: boolean;
     }, {
-        pattern: string;
         directory: string;
+        pattern: string;
         recursive?: boolean | undefined;
     }>, {
         success: boolean;
@@ -315,8 +315,8 @@ export declare const directAgentTools: {
         count?: undefined;
     }> & {
         execute: (args: {
-            pattern: string;
             directory: string;
+            pattern: string;
             recursive: boolean;
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;
@@ -623,12 +623,12 @@ export declare function getToolsForCategory(category?: "basic" | "filesystem" |
         pattern: z.ZodString;
         recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, "strip", z.ZodTypeAny, {
-        pattern: string;
         directory: string;
+        pattern: string;
         recursive: boolean;
     }, {
-        pattern: string;
         directory: string;
+        pattern: string;
         recursive?: boolean | undefined;
     }>, {
         success: boolean;
@@ -658,8 +658,8 @@ export declare function getToolsForCategory(category?: "basic" | "filesystem" |
         count?: undefined;
     }> & {
         execute: (args: {
-            pattern: string;
             directory: string;
+            pattern: string;
             recursive: boolean;
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;
@@ -967,12 +967,12 @@ export declare function getToolsForCategory(category?: "basic" | "filesystem" |
         pattern: z.ZodString;
         recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, "strip", z.ZodTypeAny, {
-        pattern: string;
         directory: string;
+        pattern: string;
         recursive: boolean;
     }, {
-        pattern: string;
         directory: string;
+        pattern: string;
         recursive?: boolean | undefined;
     }>, {
         success: boolean;
@@ -1002,8 +1002,8 @@ export declare function getToolsForCategory(category?: "basic" | "filesystem" |
         count?: undefined;
     }> & {
         execute: (args: {
-            pattern: string;
             directory: string;
+            pattern: string;
             recursive: boolean;
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;

package/dist/lib/core/factory.js

@@ -1,5 +1,5 @@
 import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio, HuggingFace, Ollama, MistralAI, } from "../providers/index.js";
-import { getBestProvider } from "../utils/providerUtils.js";
+import { getBestProviderSync } from "../utils/providerUtils.js";
 import { logger } from "../utils/logger.js";
 import { dynamicModelProvider } from "./dynamic-models.js";
 const componentIdentifier = "aiProviderFactory";
@@ -157,16 +157,15 @@ export class AIProviderFactory {
             // Wrap with MCP if enabled
             if (enableMCP) {
                 try {
-                    // TEMPORARY: Disable MCP wrapping to test for hanging issues
-                    logger.debug(`[${functionTag}] MCP wrapping temporarily disabled for debugging`);
-                    // const { createMCPAwareProviderV3 } = await import("../providers/function-calling-provider.js");
-                    // provider = createMCPAwareProviderV3(provider, {
-                    //   providerName,
-                    //   modelName: resolvedModelName || undefined,
-                    //   enableMCP: true,
-                    //   enableFunctionCalling: true,
-                    // });
-                    // logger.debug(`[${functionTag}] Provider wrapped with MCP support`);
+                    logger.debug(`[${functionTag}] Enabling MCP wrapping for AI integration`);
+                    const { createMCPAwareProviderV3 } = await import("../providers/function-calling-provider.js");
+                    provider = createMCPAwareProviderV3(provider, {
+                        providerName,
+                        modelName: resolvedModelName || undefined,
+                        enableMCP: true,
+                        enableFunctionCalling: true,
+                    });
+                    logger.debug(`[${functionTag}] Provider wrapped with MCP support`);
                 }
                 catch (mcpError) {
                     logger.warn(`[${functionTag}] Failed to wrap with MCP, using base provider`, {
@@ -233,7 +232,7 @@ export class AIProviderFactory {
     static async createBestProvider(requestedProvider, modelName, enableMCP = true) {
         const functionTag = "AIProviderFactory.createBestProvider";
         try {
-            const bestProvider = getBestProvider(requestedProvider);
+            const bestProvider = getBestProviderSync(requestedProvider);
             logger.debug(`[${functionTag}] Best provider selected`, {
                 requestedProvider: requestedProvider || "auto",
                 selectedProvider: bestProvider,

package/dist/lib/index.d.ts

@@ -13,7 +13,7 @@ export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, }
 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 { getBestProviderSync as getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { NeuroLink } from "./neurolink.js";
 export type { TextGenerationOptions, StreamTextOptions, TextGenerationResult, } from "./neurolink.js";
 export declare const VERSION = "1.0.0";
@@ -54,3 +54,26 @@ export declare function createAIProviderWithFallback(primaryProvider?: string, f
  * ```
  */
 export declare function createBestAIProvider(requestedProvider?: string, modelName?: string): Promise<import("./index.js").AIProvider>;
+/**
+ * MCP (Model Context Protocol) Plugin Ecosystem
+ *
+ * Extensible plugin architecture based on research blueprint for
+ * transforming NeuroLink into a Universal AI Development Platform.
+ *
+ * @example
+ * ```typescript
+ * import { mcpEcosystem, readFile, writeFile } from 'neurolink';
+ *
+ * // Initialize the ecosystem
+ * await mcpEcosystem.initialize();
+ *
+ * // List available plugins
+ * const plugins = await mcpEcosystem.list();
+ *
+ * // Use filesystem operations
+ * const content = await readFile('README.md');
+ * await writeFile('output.txt', 'Hello from MCP!');
+ * ```
+ */
+export { MCPEcosystem, mcpEcosystem, initializeMCPEcosystem, PluginManager, pluginManager, listMCPs, executeMCP, getMCPStats, readFile, writeFile, listFiles, createDirectory, MCP, SecurityManager, mcpLogger, FileSystemMCP, } from "./mcp/index.js";
+export type { MCPMetadata, ExecutionContext, MCPConstructor, MCPInstance, DiscoveredMCP, LogLevel, } from "./mcp/index.js";

package/dist/lib/index.js

@@ -15,7 +15,7 @@ export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, }
 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";
+export { getBestProviderSync as getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 // Main NeuroLink wrapper class
 export { NeuroLink } from "./neurolink.js";
 // Version
@@ -60,3 +60,38 @@ export async function createAIProviderWithFallback(primaryProvider, fallbackProv
 export async function createBestAIProvider(requestedProvider, modelName) {
     return await AIProviderFactory.createBestProvider(requestedProvider, modelName);
 }
+// ============================================================================
+// MCP PLUGIN ECOSYSTEM - Universal AI Development Platform
+// ============================================================================
+/**
+ * MCP (Model Context Protocol) Plugin Ecosystem
+ *
+ * Extensible plugin architecture based on research blueprint for
+ * transforming NeuroLink into a Universal AI Development Platform.
+ *
+ * @example
+ * ```typescript
+ * import { mcpEcosystem, readFile, writeFile } from 'neurolink';
+ *
+ * // Initialize the ecosystem
+ * await mcpEcosystem.initialize();
+ *
+ * // List available plugins
+ * const plugins = await mcpEcosystem.list();
+ *
+ * // Use filesystem operations
+ * const content = await readFile('README.md');
+ * await writeFile('output.txt', 'Hello from MCP!');
+ * ```
+ */
+export { 
+// Core MCP ecosystem
+MCPEcosystem, mcpEcosystem, initializeMCPEcosystem, 
+// Plugin management
+PluginManager, pluginManager, listMCPs, executeMCP, getMCPStats, 
+// Quick filesystem operations
+readFile, writeFile, listFiles, createDirectory, 
+// Core contracts and types
+MCP, SecurityManager, mcpLogger, 
+// Core plugins
+FileSystemMCP, } from "./mcp/index.js";

package/dist/lib/mcp/adapters/plugin-bridge.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Plugin Bridge Adapter
+ * Provides compatibility layer for existing MCP integrations
+ */
+import type { ExecutionContext } from "../contracts/mcp-contract.js";
+/**
+ * Bridge interface for legacy MCP compatibility
+ */
+export interface LegacyMCPBridge {
+    writeFile: (filePath: string, content: string) => Promise<void>;
+    readFile: (filePath: string) => Promise<string>;
+    listFiles: (dirPath: string) => Promise<string[]>;
+}
+/**
+ * Create a bridge for legacy MCP integrations
+ */
+export declare function createLegacyBridge(context: ExecutionContext): LegacyMCPBridge;
+/**
+ * Enhanced execution context with bridge compatibility
+ */
+export declare function enhanceExecutionContext(context: ExecutionContext): ExecutionContext;
+/**
+ * Utility function to adapt legacy MCP calls
+ */
+export declare function adaptLegacyMCPCall(context: ExecutionContext, operation: string, ...args: any[]): Promise<any>;
+/**
+ * Quick plugin factory for simple plugin creation
+ */
+export declare class QuickPluginFactory {
+    static create(name: string, config: any): Promise<{
+        name: string;
+        config: any;
+        initialized: boolean;
+    }>;
+}
+/**
+ * Execute plugin with enhanced context
+ */
+export declare function executePlugin(plugin: any, context: ExecutionContext, operation: string, ...args: any[]): Promise<any>;

package/dist/lib/mcp/adapters/plugin-bridge.js

@@ -0,0 +1,82 @@
+/**
+ * Plugin Bridge Adapter
+ * Provides compatibility layer for existing MCP integrations
+ */
+import * as path from "path";
+/**
+ * Create a bridge for legacy MCP integrations
+ */
+export function createLegacyBridge(context) {
+    const basePath = process.cwd();
+    return {
+        async writeFile(filePath, content) {
+            const fullPath = path.resolve(basePath, filePath);
+            await context.secureFS.writeFile(fullPath, content);
+        },
+        async readFile(filePath) {
+            const fullPath = path.resolve(basePath, filePath);
+            const result = await context.secureFS.readFile(fullPath, "utf-8");
+            return typeof result === "string" ? result : result.toString();
+        },
+        async listFiles(dirPath) {
+            const fullPath = path.resolve(basePath, dirPath);
+            return await context.secureFS.readdir(fullPath);
+        },
+    };
+}
+/**
+ * Enhanced execution context with bridge compatibility
+ */
+export function enhanceExecutionContext(context) {
+    return {
+        ...context,
+        path: {
+            join: path.join,
+            resolve: path.resolve,
+            relative: path.relative,
+            dirname: path.dirname,
+            basename: path.basename,
+        },
+        plugin: createLegacyBridge(context),
+    };
+}
+/**
+ * Utility function to adapt legacy MCP calls
+ */
+export async function adaptLegacyMCPCall(context, operation, ...args) {
+    const bridge = createLegacyBridge(context);
+    switch (operation) {
+        case "writeFile":
+            return bridge.writeFile(args[0], args[1]);
+        case "readFile":
+            return bridge.readFile(args[0]);
+        case "listFiles":
+            return bridge.listFiles(args[0]);
+        default:
+            throw new Error(`Unsupported legacy operation: ${operation}`);
+    }
+}
+/**
+ * Quick plugin factory for simple plugin creation
+ */
+export class QuickPluginFactory {
+    static async create(name, config) {
+        // Simple factory implementation
+        return {
+            name,
+            config,
+            initialized: true,
+        };
+    }
+}
+/**
+ * Execute plugin with enhanced context
+ */
+export async function executePlugin(plugin, context, operation, ...args) {
+    const enhancedContext = enhanceExecutionContext(context);
+    if (typeof plugin.execute === "function") {
+        return plugin.execute(enhancedContext, { operation, args });
+    }
+    // Fallback to legacy adaptation
+    return adaptLegacyMCPCall(enhancedContext, operation, ...args);
+}

package/dist/lib/mcp/auto-discovery.d.ts

@@ -1,120 +1,62 @@
 /**
- * NeuroLink MCP Auto-Discovery System
- * Automatically discovers MCP servers from common configuration locations across different tools
- * Supports VS Code, Cursor, Claude Desktop, Windsurf, Roo Code, and generic configurations
+ * Auto-Discovery Module for MCP Plugins
+ * Handles automatic plugin discovery and registration
  */
-import { MCPToolRegistry } from "./registry.js";
+import type { DiscoveredMCP } from "./contracts/mcp-contract.js";
 /**
- * Discovered MCP server configuration
+ * Auto-discovery configuration
  */
-export interface DiscoveredMCPServer {
-    id: string;
-    title: string;
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-    source: DiscoverySource;
-    configPath: string;
-    rawConfig: any;
+interface AutoDiscoveryConfig {
+    searchPaths: string[];
+    manifestName: string;
+    maxDepth: number;
 }
 /**
- * Discovery source information
+ * Auto-discovery service for MCP plugins
  */
-export interface DiscoverySource {
-    tool: string;
-    type: "global" | "workspace" | "project";
-    priority: number;
-    description: string;
-}
-/**
- * Discovery configuration options
- */
-export interface DiscoveryOptions {
-    searchWorkspace?: boolean;
-    searchGlobal?: boolean;
-    searchCommonPaths?: boolean;
-    followSymlinks?: boolean;
-    maxDepth?: number;
-    includeInactive?: boolean;
-    preferredTools?: string[];
-}
-/**
- * Discovery result
- */
-export interface DiscoveryResult {
-    discovered: DiscoveredMCPServer[];
-    sources: DiscoverySource[];
-    errors: string[];
-    stats: {
-        configFilesFound: number;
-        serversDiscovered: number;
-        duplicatesRemoved: number;
-        executionTime: number;
-    };
-}
-/**
- * MCP Auto-Discovery Engine
- */
-export declare class MCPAutoDiscovery {
-    private parsers;
-    /**
-     * Discover MCP servers from all common locations
-     *
-     * @param options Discovery configuration options
-     * @returns Discovery result with found servers
-     */
-    discoverServers(options?: DiscoveryOptions): Promise<DiscoveryResult>;
-    /**
-     * Auto-register discovered servers with a registry
-     *
-     * @param registry Target MCP registry
-     * @param options Discovery options
-     * @returns Registration results
-     */
-    autoRegisterServers(registry: MCPToolRegistry, options?: DiscoveryOptions): Promise<{
-        registered: string[];
-        failed: string[];
-        errors: string[];
-    }>;
-    /**
-     * Get standard search paths for MCP configurations
-     */
-    private getSearchPaths;
-    /**
-     * Search a specific path for MCP configurations
-     */
-    private searchPath;
+export declare class AutoDiscovery {
+    private config;
+    constructor(config?: Partial<AutoDiscoveryConfig>);
     /**
-     * Parse JSON with resilience to common syntax issues
+     * Discover all available MCP plugins
      */
-    private parseJsonResilient;
+    discover(): Promise<DiscoveredMCP[]>;
     /**
-     * Remove duplicate servers and apply prioritization
+     * Discover plugins in a specific path
      */
-    private deduplicateServers;
+    private discoverInPath;
     /**
-     * Map tool names to valid MCP server categories
+     * Load plugin from manifest
      */
-    private mapToolToCategory;
+    private loadPlugin;
     /**
-     * Convert discovered server to NeuroLink MCP server format
+     * Determine plugin source based on path
      */
-    private convertToMCPServer;
+    private determineSource;
 }
 /**
  * Default auto-discovery instance
  */
-export declare const defaultAutoDiscovery: MCPAutoDiscovery;
+export declare const autoDiscovery: AutoDiscovery;
+/**
+ * Discovery options interface
+ */
+export interface DiscoveryOptions {
+    searchPaths?: string[];
+    manifestName?: string;
+    maxDepth?: number;
+    includeDevPlugins?: boolean;
+}
 /**
- * Utility function to discover servers with default instance
+ * Discover MCP servers using auto-discovery
  */
-export declare function discoverMCPServers(options?: DiscoveryOptions): Promise<DiscoveryResult>;
+export declare function discoverMCPServers(options?: DiscoveryOptions): Promise<DiscoveredMCP[]>;
 /**
- * Utility function to auto-register discovered servers
+ * Auto-register discovered MCP servers
  */
-export declare function autoRegisterMCPServers(registry: MCPToolRegistry, options?: DiscoveryOptions): Promise<{
-    registered: string[];
-    failed: string[];
-    errors: string[];
+export declare function autoRegisterMCPServers(options?: DiscoveryOptions): Promise<{
+    registered: number;
+    failed: number;
+    plugins: DiscoveredMCP[];
 }>;
+export {};