@juspay/neurolink 7.29.1 → 7.29.3

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

@@ -1,17 +1,21 @@
 import type { AnalyticsData } from "./types.js";
 import type { TokenUsage } from "../types/providers.js";
 import type { ToolCall, ToolResult } from "../types/streamTypes.js";
+/**
+ * Raw usage data from Vercel AI SDK (uses different field names)
+ */
+interface AISDKUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
 /**
  * Stream analytics result from Vercel AI SDK streamText
  */
 export interface StreamTextResult {
     textStream: AsyncIterable<string>;
     text: Promise<string>;
-    usage: Promise<{
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    } | undefined>;
+    usage: Promise<AISDKUsage | undefined>;
     response: Promise<{
         id?: string;
         model?: string;
@@ -63,3 +67,4 @@ export declare class BaseStreamAnalyticsCollector implements StreamAnalyticsColl
  * Global instance of stream analytics collector
  */
 export declare const streamAnalyticsCollector: BaseStreamAnalyticsCollector;
+export {};

package/dist/lib/core/streamAnalytics.js

@@ -13,24 +13,24 @@ export class BaseStreamAnalyticsCollector {
             if (!usage) {
                 logger.debug("No usage data available from stream result");
                 return {
-                    inputTokens: 0,
-                    outputTokens: 0,
-                    totalTokens: 0,
+                    input: 0,
+                    output: 0,
+                    total: 0,
                 };
             }
             return {
-                inputTokens: usage.promptTokens || 0,
-                outputTokens: usage.completionTokens || 0,
-                totalTokens: usage.totalTokens ||
+                input: usage.promptTokens || 0,
+                output: usage.completionTokens || 0,
+                total: usage.totalTokens ||
                     (usage.promptTokens || 0) + (usage.completionTokens || 0),
             };
         }
         catch (error) {
             logger.warn("Failed to collect usage from stream result", { error });
             return {
-                inputTokens: 0,
-                outputTokens: 0,
-                totalTokens: 0,
+                input: 0,
+                output: 0,
+                total: 0,
             };
         }
     }
@@ -100,7 +100,7 @@ export class BaseStreamAnalyticsCollector {
                 error: error instanceof Error ? error.message : String(error),
             });
             // Return minimal analytics on error
-            return createAnalytics(provider, model, { usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 } }, responseTime, {
+            return createAnalytics(provider, model, { usage: { input: 0, output: 0, total: 0 } }, responseTime, {
                 ...metadata,
                 streamingMode: true,
                 analyticsError: true,

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

@@ -4,16 +4,14 @@ import type { GenerateResult } from "../types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { JsonValue } from "../types/common.js";
 import type { ChatMessage } from "../types/conversationTypes.js";
-import type { AnalyticsData } from "./analytics.js";
+import type { TokenUsage, AnalyticsData } from "../types/providers.js";
+import type { EvaluationData } from "../index.js";
+export type { EvaluationData };
 export interface TextGenerationResult {
     content: string;
     provider?: string;
     model?: string;
-    usage?: {
-        promptTokens?: number;
-        completionTokens?: number;
-        totalTokens?: number;
-    };
+    usage?: TokenUsage;
     responseTime?: number;
     toolsUsed?: string[];
     toolExecutions?: Array<{
@@ -30,13 +28,7 @@ export interface TextGenerationResult {
         category?: string;
     }>;
     analytics?: AnalyticsData;
-    evaluation?: {
-        relevance: number;
-        accuracy: number;
-        completeness: number;
-        overall: number;
-        reasoning?: string;
-    };
+    evaluation?: EvaluationData;
 }
 /**
  * Supported AI Provider Names
@@ -105,10 +97,20 @@ export declare enum GoogleAIModels {
     GEMINI_1_5_FLASH = "gemini-1.5-flash",
     GEMINI_1_5_FLASH_LITE = "gemini-1.5-flash-lite"
 }
+/**
+ * Supported Models for Anthropic (Direct API)
+ */
+export declare enum AnthropicModels {
+    CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20241022",
+    CLAUDE_3_5_HAIKU = "claude-3-5-haiku-20241022",
+    CLAUDE_3_SONNET = "claude-3-sonnet-20240229",
+    CLAUDE_3_OPUS = "claude-3-opus-20240229",
+    CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
+}
 /**
  * Union type of all supported model names
  */
-export type SupportedModelName = BedrockModels | OpenAIModels | VertexModels | GoogleAIModels;
+export type SupportedModelName = BedrockModels | OpenAIModels | VertexModels | GoogleAIModels | AnthropicModels;
 /**
  * Provider configuration specifying provider and its available models
  */
@@ -153,102 +155,10 @@ export interface TextGenerationOptions {
         content: string;
     }>;
     conversationMessages?: ChatMessage[];
+    expectedOutcome?: string;
+    evaluationCriteria?: string[];
 }
-export type { AnalyticsData };
-/**
- * Response quality evaluation scores
- * Comprehensive evaluation interface for response quality assessment
- */
-export interface EvaluationData {
-    relevance: number;
-    accuracy: number;
-    completeness: number;
-    overall: number;
-    domainAlignment?: number;
-    terminologyAccuracy?: number;
-    toolEffectiveness?: number;
-    isOffTopic: boolean;
-    alertSeverity: "low" | "medium" | "high" | "none";
-    reasoning: string;
-    suggestedImprovements?: string;
-    evaluationModel: string;
-    evaluationTime: number;
-    evaluationDomain?: string;
-    evaluationProvider?: string;
-    evaluationAttempt?: number;
-    evaluationConfig?: {
-        mode: string;
-        fallbackUsed: boolean;
-        costEstimate: number;
-    };
-    domainConfig?: {
-        domainName: string;
-        domainDescription: string;
-        keyTerms: string[];
-        failurePatterns: string[];
-        successPatterns: string[];
-        evaluationCriteria?: Record<string, unknown>;
-    };
-    domainEvaluation?: {
-        domainRelevance: number;
-        terminologyAccuracy: number;
-        domainExpertise: number;
-        domainSpecificInsights: string[];
-    };
-}
-/**
- * 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;
-    };
-}
+export type { AnalyticsData } from "../types/providers.js";
 /**
  * Enhanced result interfaces with optional analytics/evaluation
  */

package/dist/lib/core/types.js

@@ -79,6 +79,19 @@ export var GoogleAIModels;
     GoogleAIModels["GEMINI_1_5_FLASH"] = "gemini-1.5-flash";
     GoogleAIModels["GEMINI_1_5_FLASH_LITE"] = "gemini-1.5-flash-lite";
 })(GoogleAIModels || (GoogleAIModels = {}));
+/**
+ * Supported Models for Anthropic (Direct API)
+ */
+export var AnthropicModels;
+(function (AnthropicModels) {
+    // Claude 3.5 Series (Latest)
+    AnthropicModels["CLAUDE_3_5_SONNET"] = "claude-3-5-sonnet-20241022";
+    AnthropicModels["CLAUDE_3_5_HAIKU"] = "claude-3-5-haiku-20241022";
+    // Claude 3 Series (Legacy support)
+    AnthropicModels["CLAUDE_3_SONNET"] = "claude-3-sonnet-20240229";
+    AnthropicModels["CLAUDE_3_OPUS"] = "claude-3-opus-20240229";
+    AnthropicModels["CLAUDE_3_HAIKU"] = "claude-3-haiku-20240307";
+})(AnthropicModels || (AnthropicModels = {}));
 /**
  * Default provider configurations
  */

package/dist/lib/factories/providerFactory.js

@@ -42,6 +42,9 @@ export class ProviderFactory {
             if (providerName.toLowerCase().includes("vertex")) {
                 model = process.env.VERTEX_MODEL;
             }
+            else if (providerName.toLowerCase().includes("bedrock")) {
+                model = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+            }
             // Fallback to registry default if no env var
             model = model || registration.defaultModel;
         }
@@ -51,7 +54,7 @@ export class ProviderFactory {
                 // Try as async factory function first (most providers are async functions)
                 result = await registration.constructor(model, providerName, sdk);
             }
-            catch (functionError) {
+            catch {
                 // Fallback to constructor - ensure parameters are maintained
                 result = new registration.constructor(model, providerName, sdk);
             }

package/dist/lib/factories/providerRegistry.js

@@ -39,9 +39,9 @@ export class ProviderRegistry {
                 return new AnthropicProvider(modelName, sdk);
             }, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
             // Register Amazon Bedrock provider
-            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk) => {
                 const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
-                return new AmazonBedrockProvider(modelName);
+                return new AmazonBedrockProvider(modelName, undefined, sdk);
             }, undefined, // Let provider read BEDROCK_MODEL from .env
             ["bedrock", "aws"]);
             // Register Azure OpenAI provider

package/dist/lib/index.d.ts

@@ -83,7 +83,8 @@ export declare function getTelemetryStatus(): {
     enabled: boolean;
     initialized: boolean;
 };
-export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, EvaluationData, } from "./core/types.js";
+export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, } from "./core/types.js";
+export type { EvaluationData } from "./types/providers.js";
 /**
  * BACKWARD COMPATIBILITY: Legacy generateText function
  * Provides standalone generateText function for existing code that uses it

package/dist/lib/mcp/externalServerManager.js

@@ -357,6 +357,9 @@ export class ExternalServerManager extends EventEmitter {
             // Start the server
             await this.startServer(serverId);
             const finalInstance = this.servers.get(serverId);
+            if (!finalInstance) {
+                throw new Error(`Server ${serverId} not found after registration`);
+            }
             // Convert RuntimeMCPServerInfo to ExternalMCPServerInstance for return
             const convertedInstance = {
                 config: finalInstance.config,
@@ -664,6 +667,9 @@ export class ExternalServerManager extends EventEmitter {
         const delay = Math.min(1000 *
             Math.pow(this.config.restartBackoffMultiplier, instance.reconnectAttempts - 1), 30000);
         mcpLogger.info(`[ExternalServerManager] Scheduling restart for ${serverId} in ${delay}ms (attempt ${instance.reconnectAttempts})`);
+        if (instance.restartTimer) {
+            return;
+        } // already scheduled
         instance.restartTimer = setTimeout(async () => {
             try {
                 await this.stopServer(serverId);
@@ -914,6 +920,7 @@ export class ExternalServerManager extends EventEmitter {
         }
         try {
             mcpLogger.debug(`[ExternalServerManager] Registering ${instance.toolsMap.size} tools with main registry for server: ${serverId}`);
+            const registrations = [];
             for (const [toolName, tool] of instance.toolsMap.entries()) {
                 const toolId = `${serverId}.${toolName}`;
                 const toolInfo = {
@@ -923,21 +930,23 @@ export class ExternalServerManager extends EventEmitter {
                     serverId: serverId,
                     category: detectCategory({ isExternal: true, serverId }),
                 };
-                // Register with main tool registry
                 try {
-                    toolRegistry.registerTool(toolId, toolInfo, {
-                        execute: async (params, context) => {
+                    registrations.push(toolRegistry.registerTool(toolId, toolInfo, {
+                        execute: async (params, _context) => {
                             // Execute tool via ExternalServerManager for proper lifecycle management
                             return await this.executeTool(serverId, toolName, params, { timeout: this.config.defaultTimeout });
                         },
-                    });
+                    }));
                     mcpLogger.debug(`[ExternalServerManager] Registered tool with main registry: ${toolId}`);
                 }
                 catch (registrationError) {
                     mcpLogger.warn(`[ExternalServerManager] Failed to register tool ${toolId} with main registry:`, registrationError);
                 }
             }
-            mcpLogger.info(`[ExternalServerManager] Successfully registered ${instance.toolsMap.size} tools with main registry for ${serverId}`);
+            const results = await Promise.allSettled(registrations);
+            const ok = results.filter((r) => r.status === "fulfilled").length;
+            const failed = results.length - ok;
+            mcpLogger.info(`[ExternalServerManager] Registered ${ok}/${results.length} tools with main registry for ${serverId}${failed ? ` (${failed} failed)` : ""}`);
         }
         catch (error) {
             mcpLogger.error(`[ExternalServerManager] Failed to register tools with main registry for ${serverId}:`, error);
@@ -1010,7 +1019,6 @@ export class ExternalServerManager extends EventEmitter {
             }
         }
         catch (error) {
-            const duration = Date.now() - startTime;
             instance.metrics.totalErrors++;
             mcpLogger.error(`[ExternalServerManager] Tool execution failed: ${toolName} on ${serverId}`, error);
             throw error;

package/dist/lib/mcp/factory.js

@@ -116,7 +116,7 @@ export function validateTool(tool) {
         const validation = validateMCPTool(tool);
         return validation.isValid;
     }
-    catch (error) {
+    catch {
         return false;
     }
 }

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

@@ -0,0 +1,50 @@
+/**
+ * FlexibleToolValidator - Universal Safety Checks Only
+ *
+ * Following Anthropic's MCP specification which intentionally leaves tool naming flexible,
+ * this validator only blocks truly dangerous cases to support maximum MCP tool compatibility.
+ *
+ * Phase 1 Implementation:
+ * - Universal safety checks only (empty names, control characters, excessive length)
+ * - No context-specific validation or arbitrary pattern restrictions
+ * - Designed to support ALL legitimate MCP tools (github.create_repo, filesystem.read_file, etc.)
+ */
+export interface FlexibleValidationResult {
+    isValid: boolean;
+    error?: string;
+    warnings?: string[];
+}
+export declare class FlexibleToolValidator {
+    private static readonly MAX_TOOL_NAME_LENGTH;
+    private static readonly MIN_TOOL_NAME_LENGTH;
+    /**
+     * Validate tool name with universal safety checks only
+     *
+     * This method only blocks truly dangerous cases:
+     * 1. Empty or whitespace-only names
+     * 2. Control characters that could break systems
+     * 3. Excessively long names that could cause memory issues
+     *
+     * Everything else is allowed to support maximum MCP tool compatibility.
+     */
+    static validateToolName(toolId: string): FlexibleValidationResult;
+    /**
+     * Validate tool information with minimal safety checks
+     */
+    static validateToolInfo(toolId: string, toolInfo: {
+        description?: string;
+        serverId?: string;
+    }): FlexibleValidationResult;
+    /**
+     * Get information about what this validator checks
+     */
+    static getValidationInfo(): {
+        philosophy: string;
+        checks: string[];
+        whatIsAllowed: string[];
+        examples: {
+            valid: string[];
+            invalid: string[];
+        };
+    };
+}

package/dist/lib/mcp/flexibleToolValidator.js

@@ -0,0 +1,161 @@
+/**
+ * FlexibleToolValidator - Universal Safety Checks Only
+ *
+ * Following Anthropic's MCP specification which intentionally leaves tool naming flexible,
+ * this validator only blocks truly dangerous cases to support maximum MCP tool compatibility.
+ *
+ * Phase 1 Implementation:
+ * - Universal safety checks only (empty names, control characters, excessive length)
+ * - No context-specific validation or arbitrary pattern restrictions
+ * - Designed to support ALL legitimate MCP tools (github.create_repo, filesystem.read_file, etc.)
+ */
+import { registryLogger } from "../utils/logger.js";
+export class FlexibleToolValidator {
+    // Universal safety limits (generous to support all legitimate tools)
+    static MAX_TOOL_NAME_LENGTH = 1000; // Much more generous than npm's 214
+    static MIN_TOOL_NAME_LENGTH = 1;
+    /**
+     * Validate tool name with universal safety checks only
+     *
+     * This method only blocks truly dangerous cases:
+     * 1. Empty or whitespace-only names
+     * 2. Control characters that could break systems
+     * 3. Excessively long names that could cause memory issues
+     *
+     * Everything else is allowed to support maximum MCP tool compatibility.
+     */
+    static validateToolName(toolId) {
+        const warnings = [];
+        // Safety Check 1: Empty or whitespace-only names
+        if (!toolId || typeof toolId !== "string") {
+            return {
+                isValid: false,
+                error: "Tool name is required and must be a string",
+            };
+        }
+        // Safety Check 2: Control characters that could break systems (check BEFORE trimming!)
+        // Only block truly dangerous control characters, not printable characters
+        //
+        // This regex blocks dangerous C0 control characters and DEL:
+        // - \x00-\x08: NULL, SOH, STX, ETX, EOT, ENQ, ACK, BEL, BS
+        // - \x0B: Vertical Tab (VT)
+        // - \x0C: Form Feed (FF)
+        // - \x0E-\x1F: SO, SI, DLE, DC1-4, NAK, SYN, ETB, CAN, EM, SUB, ESC, FS-US
+        // - \x7F: DEL
+        //
+        // Explicitly ALLOWS these printable control characters:
+        // - \x09: TAB (horizontal tab) - commonly used in text
+        // - \x0A: LF (line feed) - commonly used in text
+        // - \x0D: CR (carriage return) - commonly used in text
+        // eslint-disable-next-line no-control-regex
+        const hasControlCharacters = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.test(toolId);
+        if (hasControlCharacters) {
+            return {
+                isValid: false,
+                error: "Tool name contains control characters that could break systems",
+            };
+        }
+        const trimmedName = toolId.trim();
+        if (trimmedName.length === 0) {
+            return {
+                isValid: false,
+                error: "Tool name cannot be empty or whitespace-only",
+            };
+        }
+        // Safety Check 3: Length limits (very generous)
+        if (trimmedName.length < this.MIN_TOOL_NAME_LENGTH) {
+            return {
+                isValid: false,
+                error: `Tool name must be at least ${this.MIN_TOOL_NAME_LENGTH} character long`,
+            };
+        }
+        if (trimmedName.length > this.MAX_TOOL_NAME_LENGTH) {
+            return {
+                isValid: false,
+                error: `Tool name exceeds maximum length of ${this.MAX_TOOL_NAME_LENGTH} characters`,
+            };
+        }
+        // Optional warnings for unusual but not dangerous patterns
+        if (trimmedName !== toolId) {
+            warnings.push("Tool name has leading/trailing whitespace (will be trimmed)");
+        }
+        if (trimmedName.length > 200) {
+            warnings.push("Tool name is unusually long but allowed");
+        }
+        registryLogger.debug(`✅ FlexibleToolValidator: Tool '${toolId}' passed universal safety checks`);
+        return {
+            isValid: true,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    /**
+     * Validate tool information with minimal safety checks
+     */
+    static validateToolInfo(toolId, toolInfo) {
+        // First validate the tool name
+        const nameValidation = this.validateToolName(toolId);
+        if (!nameValidation.isValid) {
+            return nameValidation;
+        }
+        const warnings = [...(nameValidation.warnings || [])];
+        // Minimal safety checks for tool info
+        if (toolInfo.description && typeof toolInfo.description !== "string") {
+            return {
+                isValid: false,
+                error: "Tool description must be a string if provided",
+            };
+        }
+        if (toolInfo.serverId && typeof toolInfo.serverId !== "string") {
+            return {
+                isValid: false,
+                error: "Tool serverId must be a string if provided",
+            };
+        }
+        registryLogger.debug(`✅ FlexibleToolValidator: Tool info for '${toolId}' passed validation`);
+        return {
+            isValid: true,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    /**
+     * Get information about what this validator checks
+     */
+    static getValidationInfo() {
+        return {
+            philosophy: "Maximum flexibility with universal safety only - following Anthropic's MCP specification",
+            checks: [
+                "Empty or whitespace-only names",
+                "Excessive length (over 1000 characters)",
+                "Control characters that could break systems",
+            ],
+            whatIsAllowed: [
+                "Dots (github.create_repo, filesystem.read_file)",
+                "Hyphens and underscores (my-tool, user_helper)",
+                "Numbers (tool1, my_tool_v2)",
+                "Unicode characters (🚀_tool, café_manager)",
+                "Mixed case (createRepo, ReadFile)",
+                "Long descriptive names (enterprise_database_connection_manager)",
+                "Any legitimate MCP tool naming pattern",
+            ],
+            examples: {
+                valid: [
+                    "github.create_repo",
+                    "filesystem.read_file",
+                    "my-custom-tool",
+                    "user_helper",
+                    "tool1",
+                    "🚀_rocket_tool",
+                    "enterprise.database.connection.manager",
+                    "UPPERCASE_TOOL",
+                    "mixed_Case.Tool-Name_123",
+                ],
+                invalid: [
+                    "", // Empty
+                    "   ", // Whitespace only
+                    "tool\x00", // Control character
+                    "a".repeat(1001), // Too long
+                ],
+            },
+        };
+    }
+}

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

@@ -18,7 +18,7 @@ export declare function listMCPs(): Promise<McpMetadata[]>;
 /**
  * Execute an MCP operation - simplified
  */
-export declare function executeMCP<T = unknown>(name: string, config: unknown, args: unknown, context?: {
+export declare function executeMCP<T = unknown>(_name: string, _config: unknown, _args: unknown, _context?: {
     sessionId?: string;
     userId?: string;
 }): Promise<T>;

package/dist/lib/mcp/index.js

@@ -21,7 +21,7 @@ export async function listMCPs() {
 /**
  * Execute an MCP operation - simplified
  */
-export async function executeMCP(name, config, args, context) {
+export async function executeMCP(_name, _config, _args, _context) {
     throw new Error("MCP execution not available - ecosystem removed");
 }
 /**

package/dist/lib/mcp/mcpCircuitBreaker.js

@@ -285,7 +285,11 @@ export class CircuitBreakerManager {
             this.breakers.set(name, breaker);
             mcpLogger.debug(`[CircuitBreakerManager] Created circuit breaker: ${name}`);
         }
-        return this.breakers.get(name);
+        const breaker = this.breakers.get(name);
+        if (!breaker) {
+            throw new Error(`Circuit breaker ${name} not found after creation`);
+        }
+        return breaker;
     }
     /**
      * Remove a circuit breaker and clean up its resources

package/dist/lib/mcp/mcpClientFactory.js

@@ -192,6 +192,9 @@ export class MCPClientFactory {
             throw new Error("Process failed to start or exited immediately");
         }
         // Create transport
+        if (!config.command) {
+            throw new Error(`Command is required for stdio transport`);
+        }
         const transport = new StdioClientTransport({
             command: config.command,
             args: config.args || [],

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

@@ -44,15 +44,15 @@ export declare class MCPRegistry implements McpRegistry {
     /**
      * Register a server (compatible with new interface)
      */
-    registerServer(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
+    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>;
+    executeTool<T = unknown>(toolName: string, args?: unknown, _context?: ExecutionContext): Promise<T>;
     /**
      * List all tools (compatible with new interface)
      */
-    listTools(context?: ExecutionContext): Promise<ToolInfo[]>;
+    listTools(_context?: ExecutionContext): Promise<ToolInfo[]>;
     /**
      * Register a server (legacy sync version)
      */