@juspay/neurolink 3.0.0 → 4.0.0

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

@@ -44,10 +44,9 @@ export declare enum VertexModels {
  * Supported Models for Google AI Studio
  */
 export declare enum GoogleAIModels {
-    GEMINI_1_5_PRO_LATEST = "gemini-1.5-pro-latest",
-    GEMINI_1_5_FLASH_LATEST = "gemini-1.5-flash-latest",
-    GEMINI_2_0_FLASH_EXP = "gemini-2.0-flash-exp",
-    GEMINI_1_0_PRO = "gemini-1.0-pro"
+    GEMINI_2_5_PRO = "gemini-2.5-pro",
+    GEMINI_2_5_FLASH = "gemini-2.5-flash",
+    GEMINI_1_5_FLASH_LITE = "gemini-2.5-flash-lite"
 }
 /**
  * Union type of all supported model names
@@ -81,6 +80,15 @@ export interface TextGenerationOptions {
     schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
     tools?: Record<string, Tool>;
     timeout?: number | string;
+    enableEvaluation?: boolean;
+    enableAnalytics?: boolean;
+    context?: Record<string, any>;
+    evaluationDomain?: string;
+    toolUsageContext?: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
 }
 /**
  * Stream text options interface
@@ -94,13 +102,164 @@ export interface StreamTextOptions {
     schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
     tools?: Record<string, Tool>;
     timeout?: number | string;
+    enableEvaluation?: boolean;
+    enableAnalytics?: boolean;
+    context?: Record<string, any>;
+    evaluationDomain?: string;
+    toolUsageContext?: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+/**
+ * Analytics data for usage tracking
+ */
+export interface AnalyticsData {
+    provider: string;
+    model: string;
+    tokens: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    cost?: number;
+    responseTime: number;
+    timestamp: string;
+    context?: Record<string, any>;
+}
+/**
+ * Response quality evaluation scores (Lighthouse-Compatible Schema)
+ * Updated to match Lighthouse's exact evaluation interface for consistency
+ */
+export interface EvaluationData {
+    relevanceScore: number;
+    accuracyScore: number;
+    completenessScore: number;
+    overall: number;
+    isOffTopic: boolean;
+    alertSeverity: "low" | "medium" | "high" | "none";
+    reasoning: string;
+    suggestedImprovements?: string;
+    evaluationModel: string;
+    evaluationTime: number;
+    evaluationProvider?: string;
+    evaluationAttempt?: number;
+    evaluationConfig?: {
+        mode: string;
+        fallbackUsed: boolean;
+        costEstimate: number;
+    };
+}
+/**
+ * BACKWARD COMPATIBILITY: Legacy evaluation interface
+ * Maintains existing field names for backward compatibility
+ */
+export interface LegacyEvaluationData {
+    relevance: number;
+    accuracy: number;
+    completeness: number;
+    overall: number;
+    isOffTopic: boolean;
+    alertSeverity: "low" | "medium" | "high" | "none";
+    reasoning: string;
+    suggestedImprovements?: string;
+    evaluationModel: string;
+    evaluationTime: number;
+}
+/**
+ * Evaluation system configuration for multi-provider support
+ */
+export interface EvaluationConfig {
+    provider: string;
+    model: string;
+    mode: "fast" | "balanced" | "quality";
+    fallbackEnabled: boolean;
+    fallbackProviders: string[];
+    timeout: number;
+    maxTokens: number;
+    temperature: number;
+    preferCheap: boolean;
+    maxCostPerEval: number;
+    retryAttempts: number;
+}
+/**
+ * Provider model configuration for evaluation
+ */
+export interface ProviderModelConfig {
+    provider: string;
+    models: {
+        fast: string;
+        balanced: string;
+        quality: string;
+    };
+    costPerToken: {
+        input: number;
+        output: number;
+    };
+    requiresApiKey: string[];
+    performance: {
+        speed: number;
+        quality: number;
+        cost: number;
+    };
+}
+/**
+ * Enhanced result interfaces with optional analytics/evaluation
+ */
+export interface EnhancedGenerateTextResult extends GenerateTextResult<ToolSet, unknown> {
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+}
+export interface EnhancedStreamTextResult extends StreamTextResult<ToolSet, unknown> {
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+}
+/**
+ * Phase 2: Enhanced Streaming Infrastructure
+ * Progress tracking and metadata for streaming operations
+ */
+export interface StreamingProgressData {
+    chunkCount: number;
+    totalBytes: number;
+    chunkSize: number;
+    elapsedTime: number;
+    estimatedRemaining?: number;
+    streamId?: string;
+    phase: "initializing" | "streaming" | "processing" | "complete" | "error";
+}
+export interface StreamingMetadata {
+    startTime: number;
+    endTime?: number;
+    totalDuration?: number;
+    averageChunkSize: number;
+    maxChunkSize: number;
+    minChunkSize: number;
+    throughputBytesPerSecond?: number;
+    streamingProvider: string;
+    modelUsed: string;
+}
+export type ProgressCallback = (progress: StreamingProgressData) => void;
+export interface EnhancedStreamTextOptions extends StreamTextOptions {
+    enableProgressTracking?: boolean;
+    progressCallback?: ProgressCallback;
+    includeStreamingMetadata?: boolean;
+    streamingBufferSize?: number;
+    enableStreamingHeaders?: boolean;
+    customStreamingConfig?: {
+        chunkDelayMs?: number;
+        maxConcurrentChunks?: number;
+        compressionEnabled?: boolean;
+    };
 }
 /**
  * AI Provider interface with flexible parameter support
  */
 export interface AIProvider {
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
-    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedStreamTextResult | null>;
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
 }
 /**
  * Provider attempt result for iteration tracking

package/dist/lib/core/types.js

@@ -47,10 +47,9 @@ export var VertexModels;
  */
 export var GoogleAIModels;
 (function (GoogleAIModels) {
-    GoogleAIModels["GEMINI_1_5_PRO_LATEST"] = "gemini-1.5-pro-latest";
-    GoogleAIModels["GEMINI_1_5_FLASH_LATEST"] = "gemini-1.5-flash-latest";
-    GoogleAIModels["GEMINI_2_0_FLASH_EXP"] = "gemini-2.0-flash-exp";
-    GoogleAIModels["GEMINI_1_0_PRO"] = "gemini-1.0-pro";
+    GoogleAIModels["GEMINI_2_5_PRO"] = "gemini-2.5-pro";
+    GoogleAIModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash";
+    GoogleAIModels["GEMINI_1_5_FLASH_LITE"] = "gemini-2.5-flash-lite";
 })(GoogleAIModels || (GoogleAIModels = {}));
 /**
  * Default provider configurations

package/dist/lib/index.d.ts

@@ -22,7 +22,7 @@ export declare const VERSION = "1.0.0";
  *
  * @example
  * ```typescript
- * import { createAIProvider } from 'neurolink';
+ * import { createAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createAIProvider('bedrock');
  * const result = await provider.streamText('Hello, AI!');
@@ -34,7 +34,7 @@ export declare function createAIProvider(providerName?: string, modelName?: stri
  *
  * @example
  * ```typescript
- * import { createAIProviderWithFallback } from 'neurolink';
+ * import { createAIProviderWithFallback } from '@juspay/neurolink';
  *
  * const { primary, fallback } = await createAIProviderWithFallback('bedrock', 'vertex');
  * ```
@@ -48,7 +48,7 @@ export declare function createAIProviderWithFallback(primaryProvider?: string, f
  *
  * @example
  * ```typescript
- * import { createBestAIProvider } from 'neurolink';
+ * import { createBestAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createBestAIProvider();
  * ```
@@ -62,7 +62,7 @@ export declare function createBestAIProvider(requestedProvider?: string, modelNa
  *
  * @example
  * ```typescript
- * import { mcpEcosystem, readFile, writeFile } from 'neurolink';
+ * import { mcpEcosystem, readFile, writeFile } from '@juspay/neurolink';
  *
  * // Initialize the ecosystem
  * await mcpEcosystem.initialize();
@@ -77,3 +77,8 @@ export declare function createBestAIProvider(requestedProvider?: string, modelNa
  */
 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";
+export declare function initializeTelemetry(): Promise<boolean>;
+export declare function getTelemetryStatus(): {
+    enabled: boolean;
+    initialized: boolean;
+};

package/dist/lib/index.js

@@ -25,7 +25,7 @@ export const VERSION = "1.0.0";
  *
  * @example
  * ```typescript
- * import { createAIProvider } from 'neurolink';
+ * import { createAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createAIProvider('bedrock');
  * const result = await provider.streamText('Hello, AI!');
@@ -39,7 +39,7 @@ export async function createAIProvider(providerName, modelName) {
  *
  * @example
  * ```typescript
- * import { createAIProviderWithFallback } from 'neurolink';
+ * import { createAIProviderWithFallback } from '@juspay/neurolink';
  *
  * const { primary, fallback } = await createAIProviderWithFallback('bedrock', 'vertex');
  * ```
@@ -52,7 +52,7 @@ export async function createAIProviderWithFallback(primaryProvider, fallbackProv
  *
  * @example
  * ```typescript
- * import { createBestAIProvider } from 'neurolink';
+ * import { createBestAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createBestAIProvider();
  * ```
@@ -71,7 +71,7 @@ export async function createBestAIProvider(requestedProvider, modelName) {
  *
  * @example
  * ```typescript
- * import { mcpEcosystem, readFile, writeFile } from 'neurolink';
+ * import { mcpEcosystem, readFile, writeFile } from '@juspay/neurolink';
  *
  * // Initialize the ecosystem
  * await mcpEcosystem.initialize();
@@ -95,3 +95,24 @@ readFile, writeFile, listFiles, createDirectory,
 MCP, SecurityManager, mcpLogger, 
 // Core plugins
 FileSystemMCP, } from "./mcp/index.js";
+// ============================================================================
+// REAL-TIME SERVICES & TELEMETRY - Enterprise Platform Features
+// ============================================================================
+// Real-time Services (Phase 1) - Basic SSE functionality only
+// export { createEnhancedChatService } from './chat/index.js';
+// export type * from './services/types.js';
+// Optional Telemetry (Phase 2) - Conditional export based on feature flag
+export async function initializeTelemetry() {
+    if (process.env.NEUROLINK_TELEMETRY_ENABLED === "true") {
+        const { initializeTelemetry: init } = await import("./telemetry/index.js");
+        const result = await init();
+        return !!result; // Convert TelemetryService to boolean
+    }
+    return Promise.resolve(false);
+}
+export function getTelemetryStatus() {
+    if (process.env.NEUROLINK_TELEMETRY_ENABLED === "true") {
+        return { enabled: true, initialized: false };
+    }
+    return { enabled: false, initialized: false };
+}

package/dist/lib/mcp/contracts/mcpContract.d.ts

@@ -0,0 +1,118 @@
+/**
+ * MCP Contract - Core Type Definitions
+ * Industry standard camelCase interfaces for maximum flexibility
+ */
+/**
+ * Generic execution context for MCP operations
+ * All properties optional for maximum flexibility
+ */
+export interface ExecutionContext<T = Record<string, unknown>> {
+    sessionId?: string;
+    userId?: string;
+    config?: T;
+    metadata?: Record<string, unknown>;
+    cacheOptions?: CacheOptions;
+    fallbackOptions?: FallbackOptions;
+    timeoutMs?: number;
+    startTime?: number;
+}
+/**
+ * Cache configuration options
+ */
+export interface CacheOptions {
+    enabled?: boolean;
+    ttlMs?: number;
+    strategy?: "memory" | "writeThrough" | "cacheAside";
+}
+/**
+ * Fallback configuration options
+ */
+export interface FallbackOptions {
+    enabled?: boolean;
+    maxAttempts?: number;
+    delayMs?: number;
+    circuitBreaker?: boolean;
+}
+/**
+ * Tool information with extensibility
+ */
+export interface ToolInfo {
+    name: string;
+    description?: string;
+    category?: string;
+    serverId?: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Discovered MCP server/plugin definition
+ */
+export interface DiscoveredMcp<TTools = Record<string, unknown>> {
+    metadata: McpMetadata;
+    tools?: TTools;
+    capabilities?: string[];
+    version?: string;
+    configuration?: Record<string, string | number | boolean>;
+    [key: string]: unknown;
+}
+/**
+ * MCP server metadata
+ */
+export interface McpMetadata {
+    name: string;
+    description?: string;
+    version?: string;
+    author?: string;
+    homepage?: string;
+    repository?: string;
+}
+/**
+ * Tool definition schema
+ */
+export interface ToolDefinition {
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    category?: string;
+    examples?: Array<{
+        input: Record<string, unknown>;
+        output: Record<string, unknown>;
+        description?: string;
+    }>;
+}
+/**
+ * Tool execution result
+ */
+export interface ToolExecutionResult<T = unknown> {
+    result: T;
+    context?: ExecutionContext;
+    performance?: {
+        duration: number;
+        tokensUsed?: number;
+        cost?: number;
+    };
+    validation?: ValidationResult;
+    cached?: boolean;
+    fallback?: boolean;
+}
+/**
+ * Validation result for runtime checks
+ */
+export interface ValidationResult {
+    valid: boolean;
+    missing: string[];
+    warnings: string[];
+    recommendations: string[];
+}
+/**
+ * Provider status information
+ */
+export interface ProviderStatus {
+    available: boolean;
+    lastCheck: number;
+    reason?: string;
+    model?: string;
+    cost?: number;
+    latencyMs?: number;
+}

package/dist/lib/mcp/contracts/mcpContract.js

@@ -0,0 +1,5 @@
+/**
+ * MCP Contract - Core Type Definitions
+ * Industry standard camelCase interfaces for maximum flexibility
+ */
+export {};

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

@@ -156,7 +156,10 @@ export async function getAvailableFunctionTools() {
                         let functionName;
                         let originalFunctionName;
                         // Convert server name to underscore format to check if it's embedded in tool name
-                        const sanitizedServerCheck = (toolInfo.server || "unknown").replace(/[^a-zA-Z0-9_]/g, "_");
+                        const serverName = typeof toolInfo.serverId === "string"
+                            ? toolInfo.serverId
+                            : "unknown";
+                        const sanitizedServerCheck = serverName.replace(/[^a-zA-Z0-9_]/g, "_");
                         if (toolInfo.name.includes(sanitizedServerCheck) ||
                             toolInfo.name.endsWith("-tools") ||
                             toolInfo.name.startsWith("github_com_") ||
@@ -206,7 +209,10 @@ export async function getAvailableFunctionTools() {
                         }
                         else {
                             // Tool name doesn't include server info, create compound name
-                            const sanitizedServerName = (toolInfo.server || "unknown").replace(/[^a-zA-Z0-9_]/g, "_");
+                            const serverName = typeof toolInfo.serverId === "string"
+                                ? toolInfo.serverId
+                                : "unknown";
+                            const sanitizedServerName = serverName.replace(/[^a-zA-Z0-9_]/g, "_");
                             const sanitizedToolName = toolInfo.name.replace(/[^a-zA-Z0-9_]/g, "_");
                             // Check if it's a filesystem tool from MCP
                             if (sanitizedServerName.includes("modelcontextprotocol") &&
@@ -277,7 +283,9 @@ export async function getAvailableFunctionTools() {
                         tools.push(aiTool);
                         // Store mapping for execution - CRITICAL: Use sanitized functionName as key
                         toolMap.set(functionName, {
-                            serverId: toolInfo.server || "unknown",
+                            serverId: typeof toolInfo.serverId === "string"
+                                ? toolInfo.serverId
+                                : "unknown",
                             toolName: toolInfo.name,
                         });
                         mcpLogger.debug(`[${functionTag}] Converted tool: ${functionName} (original: ${originalFunctionName})`);

package/dist/lib/mcp/logging.js

@@ -17,6 +17,11 @@ class MCPLogger {
         this.logLevel = level;
     }
     shouldLog(level) {
+        // CRITICAL: Respect CLI debug flag - hide all logs except errors unless debugging
+        const isDebugMode = process.argv.includes("--debug");
+        if (!isDebugMode && level !== "error") {
+            return false;
+        }
         const levels = ["debug", "info", "warn", "error"];
         return levels.indexOf(level) >= levels.indexOf(this.logLevel);
     }

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

@@ -6,6 +6,7 @@
 import { EventEmitter } from "events";
 import { logger } from "../utils/logger.js";
 import { v4 as uuidv4 } from "uuid";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 /**
  * NeuroLink MCP Client with Automatic Tool Detection
  */
@@ -381,7 +382,7 @@ Please provide a natural response based on the tool results.`;
         const response = await this.provider.generateText({
             prompt: enhancedPrompt,
             temperature: 0.7,
-            maxTokens: 1000,
+            maxTokens: DEFAULT_MAX_TOKENS,
         });
         return response?.text || toolResultsText;
     }

package/dist/lib/mcp/orchestrator.js

@@ -26,7 +26,10 @@ export class MCPOrchestrator {
     async initializeDefaultServers() {
         try {
             await this.registry.registerServer(aiCoreServer.id, aiCoreServer);
-            console.log("[Orchestrator] Initialized with AI Core Server");
+            // Only log in debug mode
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                console.log("[Orchestrator] Initialized with AI Core Server");
+            }
         }
         catch (error) {
             console.warn("[Orchestrator] Failed to register AI Core Server:", error);
@@ -44,10 +47,14 @@ export class MCPOrchestrator {
     async executeTool(toolName, params, contextRequest = {}, options = {}) {
         // Create execution context
         const context = this.contextManager.createContext(contextRequest);
-        console.log(`[Orchestrator] Executing tool '${toolName}' in session ${context.sessionId}`);
+        if (process.env.NEUROLINK_DEBUG === "true") {
+            console.log(`[Orchestrator] Executing tool '${toolName}' in session ${context.sessionId}`);
+        }
         // Execute tool through registry
         const result = await this.registry.executeTool(toolName, params, context);
-        console.log(`[Orchestrator] Tool '${toolName}' execution ${result.success ? "completed" : "failed"}`);
+        if (process.env.NEUROLINK_DEBUG === "true") {
+            console.log(`[Orchestrator] Tool '${toolName}' execution ${result.success ? "completed" : "failed"}`);
+        }
         return result;
     }
     /**
@@ -92,9 +99,10 @@ export class MCPOrchestrator {
                         results.set(stepId, stepResult);
                         stepsExecuted++;
                         if (!stepResult.success) {
-                            const errorMessage = stepResult.error instanceof Error
-                                ? stepResult.error.message
-                                : stepResult.error || "Unknown error";
+                            const error = stepResult.error;
+                            const errorMessage = error instanceof Error
+                                ? error.message
+                                : String(error) || "Unknown error";
                             errors.set(stepId, errorMessage);
                             if (stopOnError) {
                                 console.error(`[Orchestrator] Pipeline ${pipelineId} stopped due to error in step ${stepId}`);
@@ -301,9 +309,10 @@ export class MCPOrchestrator {
                     const result = await this.registry.executeTool(step.toolName, step.params, context);
                     results.set(stepId, result);
                     if (!result.success) {
-                        const errorMessage = result.error instanceof Error
-                            ? result.error.message
-                            : result.error || "Unknown error";
+                        const error = result.error;
+                        const errorMessage = error instanceof Error
+                            ? error.message
+                            : String(error) || "Unknown error";
                         errors.set(stepId, errorMessage);
                     }
                 }

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

@@ -1,16 +1,25 @@
 /**
- * MCP Registry - Plugin Registration and Management
+ * MCP Registry - Industry Standard Interface with camelCase
  */
-import type { DiscoveredMCP } from "./contracts/mcp-contract.js";
+import type { DiscoveredMcp, ExecutionContext, ToolInfo } from "./contracts/mcpContract.js";
+/**
+ * MCP Registry interface with optional methods for maximum flexibility
+ */
+export interface McpRegistry {
+    registerServer?(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
+    executeTool?<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
+    listTools?(context?: ExecutionContext): Promise<ToolInfo[]>;
+}
 /**
  * Simple MCP registry for plugin management
+ * Maintains backward compatibility with existing code
  */
-export declare class MCPRegistry {
+export declare class MCPRegistry implements McpRegistry {
     private plugins;
     /**
      * Register a plugin
      */
-    register(plugin: DiscoveredMCP): void;
+    register(plugin: DiscoveredMcp): void;
     /**
      * Unregister a plugin
      */
@@ -18,11 +27,11 @@ export declare class MCPRegistry {
     /**
      * Get a plugin
      */
-    get(name: string): DiscoveredMCP | undefined;
+    get(name: string): DiscoveredMcp | undefined;
     /**
      * List all plugins
      */
-    list(): DiscoveredMCP[];
+    list(): DiscoveredMcp[];
     /**
      * Check if plugin exists
      */
@@ -31,17 +40,41 @@ export declare class MCPRegistry {
      * Clear all plugins
      */
     clear(): void;
+    /**
+     * Register a server (compatible with new interface)
+     */
+    registerServer(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
+    /**
+     * Execute a tool (mock implementation for tests)
+     */
+    executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
+    /**
+     * List all tools (compatible with new interface)
+     */
+    listTools(context?: ExecutionContext): Promise<ToolInfo[]>;
+    /**
+     * Register a server (legacy sync version)
+     */
+    registerServerSync(plugin: DiscoveredMcp): void;
+    /**
+     * Execute a tool (legacy sync version)
+     */
+    executeToolSync(toolName: string, args?: unknown): any;
+    /**
+     * List all tools (legacy sync version)
+     */
+    listToolsSync(): Array<{
+        name: string;
+        description?: string;
+    }>;
 }
 /**
- * Default registry instance
+ * Enhanced MCP Registry implementation with config integration
+ * Will be implemented in Phase 3.2
  */
-export declare const mcpRegistry: MCPRegistry;
-export type MCPToolRegistry = MCPRegistry;
-export declare const defaultToolRegistry: MCPRegistry;
-export { mcpRegistry as defaultMCPRegistry };
-export interface ToolExecutionOptions {
-    preferredSource?: string;
-    fallbackEnabled?: boolean;
-    validateBeforeExecution?: boolean;
-    timeoutMs?: number;
+export declare class McpRegistryImpl implements McpRegistry {
+    private baseRegistry;
+    registerServer(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
+    executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
+    listTools(context?: ExecutionContext): Promise<ToolInfo[]>;
 }