@juspay/neurolink 5.3.0 → 6.1.0

package/dist/lib/mcp/contracts/mcp-contract.d.ts

@@ -38,8 +38,14 @@ export interface ExecutionContext {
         readFile: (path: string, encoding?: string) => Promise<string | Buffer>;
         writeFile: (path: string, content: string | Buffer) => Promise<void>;
         readdir: (path: string) => Promise<string[]>;
-        stat: (path: string) => Promise<any>;
-        mkdir: (path: string, options?: any) => Promise<void>;
+        stat: (path: string) => Promise<{
+            size: number;
+            isFile: () => boolean;
+            isDirectory: () => boolean;
+        }>;
+        mkdir: (path: string, options?: {
+            recursive?: boolean;
+        }) => Promise<void>;
         exists: (path: string) => Promise<boolean>;
     };
     /** Sandboxed path operations */
@@ -52,20 +58,20 @@ export interface ExecutionContext {
     };
     /** Sandboxed network operations (future) */
     secureNet?: {
-        fetch: (url: string, options?: any) => Promise<Response>;
+        fetch: (url: string, options?: RequestInit) => Promise<Response>;
     };
     /** Plugin-specific permissions granted */
     grantedPermissions: string[];
     /** Log function for debugging */
-    log: (level: "debug" | "info" | "warn" | "error", message: string, data?: any) => void;
+    log: (level: "debug" | "info" | "warn" | "error", message: string, data?: unknown) => void;
     /** Plugin instance reference (for plugin bridge compatibility) */
-    plugin?: any;
+    plugin?: unknown;
 }
 /**
  * MCP Abstract Class - The Core Contract for All Plugins
  * Uses TypeScript generics for type-safe configuration
  */
-export declare abstract class MCP<TConfig = any, TArgs = any, TResult = any> {
+export declare abstract class MCP<TConfig = unknown, TArgs = unknown, TResult = unknown> {
     /** Static metadata loaded from manifest */
     abstract readonly metadata: MCPMetadata;
     /** Configuration state - accessible to child classes */
@@ -107,7 +113,7 @@ export declare abstract class MCP<TConfig = any, TArgs = any, TResult = any> {
     /**
      * Helper method for logging with context
      */
-    protected log(context: ExecutionContext, level: "debug" | "info" | "warn" | "error", message: string, data?: any): void;
+    protected log(context: ExecutionContext, level: "debug" | "info" | "warn" | "error", message: string, data?: unknown): void;
 }
 /**
  * Type definitions for plugin registry
@@ -122,6 +128,7 @@ export interface DiscoveredMCP {
     entryPath: string;
     source: "core" | "project" | "installed";
     constructor?: MCPConstructor;
+    [key: string]: unknown;
 }
 /**
  * Plugin load result
@@ -143,7 +150,7 @@ export interface PluginDiscoveryResult {
 /**
  * Plugin execution result
  */
-export interface PluginExecutionResult<T = any> {
+export interface PluginExecutionResult<T = unknown> {
     success: boolean;
     result?: T;
     error?: string;

package/dist/lib/mcp/core/plugin-manager.d.ts

@@ -3,6 +3,7 @@
  * Enhanced plugin management with advanced lifecycle control
  */
 import type { MCP, MCPMetadata, MCPConstructor, PluginLoadResult, PluginExecutionResult, ExecutionContext } from "../contracts/mcp-contract.js";
+import type { UnknownRecord, Unknown } from "../../types/common.js";
 /**
  * Enhanced plugin manager with core functionality
  */
@@ -13,11 +14,11 @@ export declare class CorePluginManager {
     /**
      * Load a plugin from constructor
      */
-    loadPlugin(name: string, Constructor: MCPConstructor, config: any): Promise<PluginLoadResult>;
+    loadPlugin(name: string, Constructor: MCPConstructor, config: UnknownRecord): Promise<PluginLoadResult>;
     /**
      * Execute a plugin operation
      */
-    executePlugin<T = any>(name: string, context: ExecutionContext, args: any): Promise<PluginExecutionResult<T>>;
+    executePlugin<T = Unknown>(name: string, context: ExecutionContext, args: Unknown): Promise<PluginExecutionResult<T>>;
     /**
      * Get plugin instance
      */

package/dist/lib/mcp/core/plugin-manager.js

@@ -48,7 +48,7 @@ export class CorePluginManager {
             const executionTime = Date.now() - startTime;
             return {
                 success: true,
-                result,
+                result: result,
                 executionTime,
             };
         }

package/dist/lib/mcp/demo/plugin-demo.js

@@ -42,7 +42,9 @@ export class PluginDemo {
             // Try to read a file
             const fsPlugin = new FileSystemMCP();
             await fsPlugin.initialize({ basePath: process.cwd() });
-            const result = await executePlugin(fsPlugin, createMockContext(), "listFiles", ".");
+            // Cast FileSystemMCP to UnknownRecord for executePlugin compatibility
+            const pluginAsRecord = fsPlugin;
+            const result = await executePlugin(pluginAsRecord, createMockContext(), "listFiles", ".");
             mcpLogger.info("Plugin execution result:", result);
         }
         catch (error) {

package/dist/lib/mcp/dynamic-chain-executor.d.ts

@@ -5,18 +5,69 @@
 import type { MCPOrchestrator } from "./orchestrator.js";
 import type { MCPRegistry } from "./registry.js";
 import type { NeuroLinkExecutionContext } from "./factory.js";
+import type { JsonValue, UnknownRecord } from "../types/common.js";
 import { ErrorManager } from "./error-manager.js";
+/**
+ * Tool input schema structure
+ */
+export interface ToolInputSchema {
+    type?: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+/**
+ * Tool execution parameters
+ */
+export interface ToolExecutionParameters extends Record<string, JsonValue> {
+}
+/**
+ * Context evolution entry tracking data changes
+ */
+export interface ContextEvolutionEntry {
+    step: string;
+    timestamp: number;
+    dataKeys: string[];
+    [key: string]: JsonValue;
+}
+/**
+ * AI model planning response structure
+ */
+export interface AIPlanningResponse {
+    toolName: string | null;
+    parameters?: ToolExecutionParameters;
+    reasoning?: string;
+    confidence?: number;
+    expectedOutcome?: string;
+}
+/**
+ * AI model evaluation response structure
+ */
+export interface AIEvaluationResponse {
+    goalAchieved: boolean;
+    confidence: number;
+    nextAction: "continue" | "retry" | "abort" | "complete";
+    reasoning: string;
+}
+/**
+ * Available tool descriptor
+ */
+export interface AvailableToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema;
+}
 /**
  * Tool execution result with metadata
  */
 export interface ToolExecutionResult {
     toolName: string;
     success: boolean;
-    result?: any;
+    result?: JsonValue;
     error?: Error;
     timestamp: number;
     executionTime: number;
-    context?: Record<string, any>;
+    context?: UnknownRecord;
 }
 /**
  * Chain execution step
@@ -24,7 +75,7 @@ export interface ToolExecutionResult {
 export interface ChainStep {
     stepId: string;
     toolName: string;
-    parameters: any;
+    parameters: ToolExecutionParameters;
     reasoning: string;
     confidence: number;
     expectedOutcome: string;
@@ -37,7 +88,7 @@ export interface ChainExecutionContext {
     currentStep: number;
     totalSteps?: number;
     executionHistory: ToolExecutionResult[];
-    accumulatedContext: Record<string, any>;
+    accumulatedContext: UnknownRecord;
     userContext?: NeuroLinkExecutionContext;
     maxSteps: number;
     aiModel?: string;
@@ -51,13 +102,13 @@ export interface ChainExecutionResult {
     totalSteps: number;
     executionTime: number;
     results: ToolExecutionResult[];
-    finalResult?: any;
+    finalResult?: JsonValue;
     reasoning: string;
     error?: Error;
     metadata: {
         toolsUsed: string[];
         averageConfidence: number;
-        contextEvolution: Record<string, any>[];
+        contextEvolution: ContextEvolutionEntry[];
     };
 }
 /**
@@ -65,34 +116,16 @@ export interface ChainExecutionResult {
  */
 export interface AIChainPlanner {
     name: string;
-    planNextStep(goal: string, availableTools: Array<{
-        name: string;
-        description: string;
-        inputSchema: any;
-    }>, executionHistory: ToolExecutionResult[], accumulatedContext: Record<string, any>): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<{
-        goalAchieved: boolean;
-        confidence: number;
-        nextAction: "continue" | "retry" | "abort" | "complete";
-        reasoning: string;
-    }>;
+    planNextStep(goal: string, availableTools: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
+    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
 }
 /**
  * Simple AI Chain Planner using heuristics
  */
 export declare class HeuristicChainPlanner implements AIChainPlanner {
     name: string;
-    planNextStep(goal: string, availableTools: Array<{
-        name: string;
-        description: string;
-        inputSchema: any;
-    }>, executionHistory: ToolExecutionResult[], accumulatedContext: Record<string, any>): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<{
-        goalAchieved: boolean;
-        confidence: number;
-        nextAction: "continue" | "retry" | "abort" | "complete";
-        reasoning: string;
-    }>;
+    planNextStep(goal: string, availableTools: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
+    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
     private generateParameters;
 }
 /**
@@ -102,17 +135,8 @@ export declare class AIModelChainPlanner implements AIChainPlanner {
     name: string;
     private aiModel;
     constructor(aiModel?: string);
-    planNextStep(goal: string, availableTools: Array<{
-        name: string;
-        description: string;
-        inputSchema: any;
-    }>, executionHistory: ToolExecutionResult[], accumulatedContext: Record<string, any>): Promise<ChainStep | null>;
-    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<{
-        goalAchieved: boolean;
-        confidence: number;
-        nextAction: "continue" | "retry" | "abort" | "complete";
-        reasoning: string;
-    }>;
+    planNextStep(goal: string, availableTools: AvailableToolDescriptor[], executionHistory: ToolExecutionResult[], accumulatedContext: UnknownRecord): Promise<ChainStep | null>;
+    evaluateResult(step: ChainStep, result: ToolExecutionResult, goal: string): Promise<AIEvaluationResponse>;
     private buildPlanningPrompt;
     private buildEvaluationPrompt;
     private callAIModel;
@@ -137,7 +161,7 @@ export declare class DynamicChainExecutor {
      * @param options Execution options
      * @returns Chain execution result
      */
-    executeChain(goal: string, initialContext?: Record<string, any>, userContext?: NeuroLinkExecutionContext, options?: {
+    executeChain(goal: string, initialContext?: UnknownRecord, userContext?: NeuroLinkExecutionContext, options?: {
         maxSteps?: number;
         aiModel?: string;
         timeout?: number;

package/dist/lib/mcp/dynamic-chain-executor.js

@@ -82,7 +82,7 @@ export class HeuristicChainPlanner {
         const lastResult = history[history.length - 1];
         if (lastResult?.result) {
             // Pass relevant data from previous step
-            if (typeof lastResult.result === "object") {
+            if (typeof lastResult.result === "object" && lastResult.result !== null) {
                 Object.assign(params, lastResult.result);
             }
             else if (typeof lastResult.result === "string") {
@@ -378,7 +378,7 @@ export class DynamicChainExecutor {
             return {
                 toolName: step.toolName,
                 success: true,
-                result,
+                result: result,
                 timestamp: Date.now(),
                 executionTime: Date.now() - startTime,
                 context: {
@@ -445,7 +445,7 @@ export class DynamicChainExecutor {
                 evolution.push({
                     step: result.toolName,
                     timestamp: result.timestamp,
-                    dataKeys: typeof result.result === "object"
+                    dataKeys: typeof result.result === "object" && result.result !== null
                         ? Object.keys(result.result)
                         : ["primitive"],
                 });

package/dist/lib/mcp/dynamic-orchestrator.d.ts

@@ -6,12 +6,18 @@
 import { MCPOrchestrator } from "./orchestrator.js";
 import type { ToolResult } from "./factory.js";
 import type { ContextRequest } from "./context-manager.js";
+import type { UnknownRecord } from "../types/common.js";
+import { ErrorManager } from "./error-manager.js";
+import type { MCPToolRegistry } from "./tool-registry.js";
+import type { ContextManager } from "./context-manager.js";
+import type { SemaphoreManager } from "./semaphore-manager.js";
+import type { SessionManager } from "./session-manager.js";
 /**
  * Tool decision made by AI
  */
 export interface ToolDecision {
     toolName: string;
-    args: Record<string, any>;
+    args: UnknownRecord;
     reasoning: string;
     confidence: number;
     shouldContinue: boolean;
@@ -42,7 +48,7 @@ export interface DynamicToolChainResult {
  * Dynamic orchestrator with AI-driven tool selection
  */
 export declare class DynamicOrchestrator extends MCPOrchestrator {
-    constructor(registry?: any, contextManager?: any, semaphoreManager?: any, sessionManager?: any, errorManager?: any);
+    constructor(registry?: MCPToolRegistry, contextManager?: ContextManager, semaphoreManager?: SemaphoreManager, sessionManager?: SessionManager, errorManager?: ErrorManager);
     private defaultOptions;
     /**
      * Execute a dynamic tool chain where AI decides which tools to use
@@ -86,11 +92,11 @@ export declare class DynamicOrchestrator extends MCPOrchestrator {
                 reasoningCapture: boolean;
             };
         };
-        registry: any;
-        context: any;
-        session: any;
-        error: any;
-        health?: any;
+        registry: UnknownRecord;
+        context: UnknownRecord;
+        session: UnknownRecord;
+        error: UnknownRecord;
+        health?: UnknownRecord;
         orchestrator: {
             pipelinesExecuted: number;
         };
@@ -106,4 +112,4 @@ export declare class DynamicOrchestrator extends MCPOrchestrator {
  * @param errorManager Error manager (optional)
  * @returns Dynamic orchestrator instance
  */
-export declare function createDynamicOrchestrator(registry: any, contextManager: any, semaphoreManager?: any, sessionManager?: any, errorManager?: any): DynamicOrchestrator;
+export declare function createDynamicOrchestrator(registry: MCPToolRegistry, contextManager: ContextManager, semaphoreManager?: SemaphoreManager, sessionManager?: SessionManager, errorManager?: ErrorManager): DynamicOrchestrator;

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

@@ -28,7 +28,7 @@ export declare class MCPEcosystem {
     /**
      * Create and execute an MCP instance
      */
-    execute<T = any>(name: string, config: any, args: any, context?: {
+    execute<T = unknown>(name: string, config: unknown, args: unknown, context?: {
         sessionId?: string;
         userId?: string;
     }): Promise<T>;
@@ -40,7 +40,7 @@ export declare class MCPEcosystem {
         path: string;
         content?: string;
         basePath?: string;
-    }): Promise<any>;
+    }): Promise<unknown>;
     /**
      * Get ecosystem statistics
      */
@@ -53,7 +53,7 @@ export declare class MCPEcosystem {
     /**
      * Create an MCP instance for direct use
      */
-    createInstance<T extends MCP>(name: string, config: any): Promise<T>;
+    createInstance<T extends MCP>(name: string, config: unknown): Promise<T>;
     /**
      * Create execution context for manual MCP usage
      */
@@ -65,7 +65,7 @@ export declare class MCPEcosystem {
     /**
      * Get all tools formatted for AI providers
      */
-    getToolsForAI(): Promise<any>;
+    getToolsForAI(): Promise<Record<string, unknown>>;
     /**
      * Dispose of all resources
      */

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

@@ -38,7 +38,7 @@ export interface ErrorEntry {
     context: {
         sessionId?: string;
         toolName?: string;
-        parameters?: any;
+        parameters?: unknown;
         executionContext?: NeuroLinkExecutionContext;
     };
     stackTrace?: string;
@@ -103,7 +103,7 @@ export declare class ErrorManager {
         severity?: ErrorSeverity;
         sessionId?: string;
         toolName?: string;
-        parameters?: any;
+        parameters?: unknown;
         executionContext?: NeuroLinkExecutionContext;
     }): Promise<ErrorEntry>;
     /**

package/dist/lib/mcp/error-recovery.d.ts

@@ -5,6 +5,7 @@
  */
 import type { ErrorEntry, ErrorSeverity } from "./error-manager.js";
 import type { NeuroLinkExecutionContext } from "./factory.js";
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Circuit breaker states
  */
@@ -16,7 +17,7 @@ export declare enum CircuitState {
 /**
  * Retry strategy configuration
  */
-export interface RetryConfig {
+export interface RetryConfig extends UnknownRecord {
     maxAttempts: number;
     initialDelay: number;
     maxDelay: number;
@@ -26,7 +27,7 @@ export interface RetryConfig {
 /**
  * Circuit breaker configuration
  */
-export interface CircuitBreakerConfig {
+export interface CircuitBreakerConfig extends UnknownRecord {
     failureThreshold: number;
     resetTimeout: number;
     successThreshold: number;
@@ -48,7 +49,7 @@ export interface ErrorPattern {
  */
 export interface RecoveryStrategy {
     type: "retry" | "circuit-breaker" | "fallback" | "manual";
-    config?: any;
+    config?: UnknownRecord;
     action?: (context: RecoveryContext) => Promise<RecoveryResult>;
 }
 /**

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

@@ -44,7 +44,7 @@ export declare class ExternalMCPClient extends EventEmitter {
     /**
      * Execute a tool on the external server
      */
-    executeTool(toolName: string, params: any, context: NeuroLinkExecutionContext): Promise<ToolResult>;
+    executeTool(toolName: string, params: unknown, context: NeuroLinkExecutionContext): Promise<ToolResult>;
     /**
      * Get available tools as NeuroLink MCP tools
      */

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

@@ -105,13 +105,15 @@ export class ExternalMCPClient extends EventEmitter {
     async discoverTools() {
         try {
             const response = await this.sendRequest("tools/list", {});
-            if (response.tools && Array.isArray(response.tools)) {
+            const responseObj = response;
+            if (responseObj.tools && Array.isArray(responseObj.tools)) {
                 this.tools.clear();
-                for (const tool of response.tools) {
-                    this.tools.set(tool.name, {
-                        name: tool.name,
-                        description: tool.description,
-                        inputSchema: tool.inputSchema,
+                for (const tool of responseObj.tools) {
+                    const toolObj = tool;
+                    this.tools.set(toolObj.name || "unknown", {
+                        name: toolObj.name || "unknown",
+                        description: toolObj.description || "",
+                        inputSchema: toolObj.inputSchema,
                     });
                 }
                 logger.debug(`[External MCP] Discovered ${this.tools.size} tools from ${this.config.name}`);
@@ -137,9 +139,10 @@ export class ExternalMCPClient extends EventEmitter {
             });
             const executionTime = Date.now() - startTime;
             // Transform MCP response to NeuroLink format
+            const responseObj = response;
             const result = {
-                success: !response.isError,
-                data: response.text || response.result || response,
+                success: !responseObj.isError,
+                data: responseObj.text || responseObj.result || response,
                 metadata: {
                     toolName,
                     serverId: this.config.name,
@@ -149,8 +152,9 @@ export class ExternalMCPClient extends EventEmitter {
                     executionTime,
                 },
             };
-            if (response.isError) {
-                result.error = response.text?.[0]?.text || "Tool execution failed";
+            if (responseObj.isError) {
+                const textArray = responseObj.text;
+                result.error = textArray?.[0]?.text || "Tool execution failed";
             }
             logger.debug(`[External MCP] Tool ${toolName} executed in ${executionTime}ms`);
             return result;

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

@@ -11,8 +11,8 @@ import { MCPToolRegistry } from "./tool-registry.js";
  */
 interface ExternalServerInfo {
     name: string;
-    client: ExternalMCPClient;
-    server: NeuroLinkMCPServer;
+    client: ExternalMCPClient | null;
+    server: NeuroLinkMCPServer | null;
     status: "connecting" | "connected" | "disconnected" | "error";
     lastError?: string;
     toolCount: number;
@@ -61,7 +61,7 @@ export declare class ExternalMCPManager {
     /**
      * Execute a tool on any connected server
      */
-    executeTool(toolName: string, params: any, context: NeuroLinkExecutionContext): Promise<ToolResult>;
+    executeTool(toolName: string, params: unknown, context: NeuroLinkExecutionContext): Promise<ToolResult>;
     /**
      * List all available tools from external servers
      */

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

@@ -72,7 +72,7 @@ export class ExternalMCPManager {
             });
         }
         catch (error) {
-            if (error.code === "ENOENT") {
+            if (error?.code === "ENOENT") {
                 logger.warn(`[External MCP Manager] Config file not found: ${this.configPath}`);
                 this.config = { mcpServers: {} };
             }
@@ -163,6 +163,12 @@ export class ExternalMCPManager {
      */
     async registerServerTools(serverInfo) {
         try {
+            if (!serverInfo.client) {
+                throw new Error("Client is not available");
+            }
+            if (!serverInfo.server) {
+                throw new Error("Server is not available");
+            }
             const tools = serverInfo.client.getNeuroLinkTools();
             // Register each tool with the server
             for (const [toolName, tool] of Object.entries(tools)) {
@@ -198,8 +204,8 @@ export class ExternalMCPManager {
             statuses[name] = {
                 ...info,
                 // Don't include the actual client/server objects in status
-                client: undefined,
-                server: undefined,
+                client: null,
+                server: null,
             };
         }
         return statuses;

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

@@ -42,15 +42,15 @@ export interface NeuroLinkExecutionContext extends ExecutionContext {
     features?: string[];
     enableDemoMode?: boolean;
     securityLevel?: "public" | "private" | "organization";
-    metadata?: Record<string, any>;
-    [key: string]: any;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
 }
 /**
  * Tool execution result - Standardized result format
  */
 export interface ToolResult {
     success: boolean;
-    data?: any;
+    data?: unknown;
     error?: string | Error;
     usage?: {
         tokens?: number;
@@ -67,7 +67,7 @@ export interface ToolResult {
         timestamp?: number;
         executionTime?: number;
         executionId?: string;
-        [key: string]: any;
+        [key: string]: unknown;
     };
 }
 /**
@@ -83,7 +83,7 @@ export interface NeuroLinkMCPTool {
     category?: string;
     permissions?: string[];
     version?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * MCP Server Interface - Lighthouse compatible
@@ -97,7 +97,7 @@ export interface NeuroLinkMCPServer {
     visibility?: "public" | "private" | "organization";
     tools: Record<string, NeuroLinkMCPTool>;
     registerTool(tool: NeuroLinkMCPTool): NeuroLinkMCPServer;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     dependencies?: string[];
     capabilities?: string[];
 }
@@ -111,7 +111,7 @@ export interface MCPServerConfig {
     version?: string;
     category?: MCPServerCategory;
     visibility?: "public" | "private" | "organization";
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     dependencies?: string[];
     capabilities?: string[];
 }

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

@@ -5,6 +5,7 @@
  */
 import type { Tool } from "ai";
 import type { NeuroLinkMCPTool, ToolResult, NeuroLinkExecutionContext } from "./factory.js";
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Convert MCP tool to AI SDK function definition
  */
@@ -53,12 +54,12 @@ 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 & {
+export declare function createNamedTool(name: string, toolDef: Tool): Tool & {
     name: string;
 };
 /**
  * Get tools with proper name properties for debugging
  */
-export declare function getToolsWithNames(): Promise<Record<string, any & {
+export declare function getToolsWithNames(): Promise<Record<string, UnknownRecord & {
     name: string;
 }>>;

package/dist/lib/mcp/health-monitor.d.ts

@@ -4,6 +4,7 @@
  * Based on health monitoring patterns from Cline
  */
 import type { MCPRegistry } from "./registry.js";
+import type { Unknown } from "../types/common.js";
 import { ErrorManager } from "./error-manager.js";
 /**
  * Connection status states
@@ -215,7 +216,7 @@ export declare class HealthMonitor {
      * @param event Event type to subscribe to
      * @param callback Callback function
      */
-    on(event: "health-change" | "recovery-started" | "recovery-failed" | "critical-error", callback: (data: any) => void): void;
+    on(event: "health-change" | "recovery-started" | "recovery-failed" | "critical-error", callback: (data: Unknown) => void): void;
     /**
      * Get health history for trend analysis
      *