@juspay/neurolink 5.2.0 → 6.0.0

package/dist/lib/mcp/client.js

@@ -49,13 +49,14 @@ export class NeuroLinkMCPClient extends EventEmitter {
                             return result;
                         }
                         // If it's in Lighthouse format with content array
-                        if (result.text &&
-                            Array.isArray(result.text) &&
-                            result.text[0]?.text) {
+                        const lightouseResult = result;
+                        if (lightouseResult.text &&
+                            Array.isArray(lightouseResult.text) &&
+                            lightouseResult.text[0]?.text) {
                             try {
-                                const data = JSON.parse(result.text[0].text);
+                                const data = JSON.parse(lightouseResult.text[0].text);
                                 return {
-                                    success: !result.isError,
+                                    success: !lightouseResult.isError,
                                     data,
                                     metadata: {
                                         toolName,
@@ -68,8 +69,8 @@ export class NeuroLinkMCPClient extends EventEmitter {
                             catch (parseError) {
                                 // If JSON parsing fails, return the text as-is
                                 return {
-                                    success: !result.isError,
-                                    data: { text: result.text[0].text },
+                                    success: !lightouseResult.isError,
+                                    data: { text: lightouseResult.text[0].text },
                                     metadata: {
                                         toolName,
                                         serverId,
@@ -80,10 +81,11 @@ export class NeuroLinkMCPClient extends EventEmitter {
                             }
                         }
                         // If it has a direct text property
-                        if (result.text) {
+                        const textResult = result;
+                        if (textResult.text) {
                             return {
                                 success: true,
-                                data: { text: result.text },
+                                data: { text: textResult.text },
                                 metadata: {
                                     toolName,
                                     serverId,
@@ -128,8 +130,9 @@ export class NeuroLinkMCPClient extends EventEmitter {
      */
     getTools() {
         const tools = {};
-        for (const [name, tool] of this.tools) {
+        for (const [name, tool] of Array.from(this.tools.entries())) {
             tools[name] = {
+                name: name, // Include the tool name as a property
                 description: tool.description,
                 inputSchema: tool.inputSchema,
             };

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

@@ -20,7 +20,7 @@ export interface ContextRequest {
     frameworkType?: "react" | "vue" | "svelte" | "next" | "nuxt" | "sveltekit";
     permissions?: string[];
     securityLevel?: "public" | "private" | "organization";
-    [key: string]: any;
+    [key: string]: unknown;
 }
 /**
  * Context manager for creating and managing execution contexts
@@ -29,6 +29,7 @@ export interface ContextRequest {
 export declare class ContextManager {
     private sessionCounter;
     private activeContexts;
+    private static cachedLogger;
     /**
      * Create a new execution context with rich information
      *

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

@@ -10,6 +10,7 @@
 export class ContextManager {
     sessionCounter = 0;
     activeContexts = new Map();
+    static cachedLogger = null;
     /**
      * Create a new execution context with rich information
      *
@@ -64,6 +65,7 @@ export class ContextManager {
             },
             path: {
                 join: (...paths) => {
+                    // Use dynamic require for synchronous path operations
                     const path = require("path");
                     return path.join(...paths);
                 },
@@ -85,11 +87,13 @@ export class ContextManager {
                 },
             },
             grantedPermissions: request.permissions || [],
-            log: (level, message, data) => {
-                // Use logger if available, otherwise console
+            log: async (level, message, data) => {
+                // Use cached logger if available, otherwise import and cache
                 try {
-                    const { logger } = require("../utils/logger.js");
-                    logger[level](message, data);
+                    if (!ContextManager.cachedLogger) {
+                        ContextManager.cachedLogger = await import("../utils/logger.js").then(({ logger }) => logger);
+                    }
+                    ContextManager.cachedLogger[level](message, data);
                 }
                 catch {
                     console[level === "debug" ? "log" : level](message, data);

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
      */