@juspay/neurolink 5.2.0 → 6.0.0

package/dist/lib/core/base-provider.js

@@ -1,9 +1,18 @@
 import { logger } from "../utils/logger.js";
 import { directAgentTools } from "../agent/direct-tools.js";
-// Dynamic imports to break circular dependency
-// import { evaluateResponse } from "../core/evaluation.js";
-// import { getAvailableFunctionTools } from "../mcp/function-calling.js";
-// Analytics helper will be dynamically imported when needed
+/**
+ * Validates if a result contains a valid toolsObject structure
+ * @param result - The result object to validate
+ * @returns true if the result contains a valid toolsObject, false otherwise
+ */
+function isValidToolsObject(result) {
+    return (result !== null &&
+        typeof result === "object" &&
+        "toolsObject" in result &&
+        result.toolsObject !== null &&
+        typeof result.toolsObject === "object" &&
+        Object.keys(result.toolsObject).length > 0);
+}
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -89,7 +98,16 @@ export class BaseProvider {
                         parameters: call.args,
                         id: call.toolCallId,
                     })),
-                    toolResults: result?.toolResults,
+                    toolResults: result?.toolResults
+                        ? result.toolResults.map((tr) => ({
+                            toolName: tr.toolName || "unknown",
+                            status: (tr.status === "error"
+                                ? "failure"
+                                : "success"),
+                            result: tr.result,
+                            error: tr.error,
+                        }))
+                        : undefined,
                 };
             }
             catch (error) {
@@ -142,7 +160,19 @@ export class BaseProvider {
                 },
                 provider: this.providerName,
                 model: this.modelName,
-                toolCalls: result.toolCalls,
+                toolCalls: result.toolCalls
+                    ? result.toolCalls.map((tc) => ({
+                        toolCallId: tc.toolCallId ||
+                            tc.id ||
+                            "unknown",
+                        toolName: tc.toolName ||
+                            tc.name ||
+                            "unknown",
+                        args: tc.args ||
+                            tc.parameters ||
+                            {},
+                    }))
+                    : [],
                 toolResults: result.toolResults,
             };
             // Enhanced result with analytics and evaluation
@@ -170,16 +200,15 @@ export class BaseProvider {
         const tools = {
             ...this.directTools, // Always include direct tools
         };
-        logger.info(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
-        console.log(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
+        logger.debug(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
+        logger.debug(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
         // Add custom tools from SDK if available
-        console.log(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
-        if (this.sdk &&
-            typeof this.sdk.getInMemoryServers === "function") {
-            console.log(`[BaseProvider] SDK check passed, loading custom tools`);
+        logger.debug(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
+        if (this.sdk && typeof this.sdk.getInMemoryServers === "function") {
+            logger.debug(`[BaseProvider] SDK check passed, loading custom tools`);
             try {
                 const inMemoryServers = this.sdk.getInMemoryServers();
-                console.log(`[BaseProvider] Got servers:`, inMemoryServers.size);
+                logger.debug(`[BaseProvider] Got servers:`, inMemoryServers.size);
                 logger.debug(`[BaseProvider] Loading custom tools from SDK, found ${inMemoryServers.size} servers`);
                 if (inMemoryServers && inMemoryServers.size > 0) {
                     // Convert in-memory server tools to AI SDK format
@@ -192,7 +221,7 @@ export class BaseProvider {
                                 : Object.entries(server.tools || {});
                             for (const [toolName, toolInfo] of toolEntries) {
                                 if (toolInfo && typeof toolInfo.execute === "function") {
-                                    console.log(`[BaseProvider] Converting custom tool: ${toolName}`);
+                                    logger.debug(`[BaseProvider] Converting custom tool: ${toolName}`);
                                     // Convert to AI SDK tool format
                                     const { tool: createAISDKTool } = await import("ai");
                                     const { z } = await import("zod");
@@ -211,7 +240,10 @@ export class BaseProvider {
                                                     return result.data;
                                                 }
                                                 else {
-                                                    throw new Error(result.error || "Tool execution failed");
+                                                    const errorMsg = typeof result.error === "string"
+                                                        ? result.error
+                                                        : "Tool execution failed";
+                                                    throw new Error(errorMsg);
                                                 }
                                             }
                                             return result;
@@ -233,12 +265,13 @@ export class BaseProvider {
             try {
                 const { getAvailableFunctionTools } = await import("../mcp/function-calling.js");
                 const result = await getAvailableFunctionTools();
-                if (result.tools && result.tools.length > 0) {
-                    this.mcpTools = {};
-                    for (const tool of result.tools) {
-                        const toolName = tool.name || "unknown";
-                        this.mcpTools[toolName] = tool;
-                    }
+                if (isValidToolsObject(result)) {
+                    this.mcpTools = result.toolsObject;
+                }
+                else {
+                    logger.debug(`Invalid or empty toolsObject for ${this.providerName}: Expected an object with at least one key, but got ${typeof result?.toolsObject} with ${result?.toolsObject
+                        ? Object.keys(result.toolsObject).length
+                        : 0} keys. Full result:`, result);
                 }
             }
             catch (error) {
@@ -250,7 +283,7 @@ export class BaseProvider {
         if (this.mcpTools) {
             Object.assign(tools, this.mcpTools);
         }
-        console.log(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
+        logger.debug(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
         return tools;
     }
     /**
@@ -325,7 +358,8 @@ export class BaseProvider {
     }
     async createEvaluation(result, options) {
         const { evaluateResponse } = await import("../core/evaluation.js");
-        return evaluateResponse(result.content, options.prompt);
+        const evaluation = await evaluateResponse(result.content, options.prompt);
+        return evaluation;
     }
     validateOptions(options) {
         if (!options.prompt || options.prompt.trim().length === 0) {

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

@@ -5,6 +5,7 @@
 export declare const DEFAULT_MAX_TOKENS = 8192;
 export declare const DEFAULT_TEMPERATURE = 0.7;
 export declare const DEFAULT_TIMEOUT = 30000;
+export declare const DEFAULT_MAX_STEPS = 5;
 export declare const DEFAULT_EVALUATION_MAX_TOKENS = 500;
 export declare const DEFAULT_ANALYSIS_MAX_TOKENS = 800;
 export declare const DEFAULT_DOCUMENTATION_MAX_TOKENS = 12000;

package/dist/lib/core/constants.js

@@ -6,6 +6,7 @@
 export const DEFAULT_MAX_TOKENS = 8192; // Changed from 10000 to fix Anthropic error
 export const DEFAULT_TEMPERATURE = 0.7;
 export const DEFAULT_TIMEOUT = 30000;
+export const DEFAULT_MAX_STEPS = 5; // Default multi-turn tool execution steps
 // Specialized Use Case Defaults
 export const DEFAULT_EVALUATION_MAX_TOKENS = 500; // Keep evaluation fast
 export const DEFAULT_ANALYSIS_MAX_TOKENS = 800; // For analysis tools

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

@@ -2,11 +2,12 @@
  * Default value helper functions for NeuroLink
  * Centralized logic for applying defaults across the system
  */
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Apply default values to options object
  * User-provided values take precedence over defaults
  */
-export declare function applyDefaults(options: any): any;
+export declare function applyDefaults(options: UnknownRecord): UnknownRecord;
 /**
  * Get default max tokens for a specific provider
  * Can be extended for provider-specific overrides in the future

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

@@ -23,7 +23,7 @@ export interface UnifiedEvaluationResult extends EvaluationData {
 export interface UnifiedEvaluationContext {
     userQuery: string;
     aiResponse: string;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
     primaryDomain?: string;
     assistantRole?: string;
     conversationHistory?: Array<{
@@ -33,8 +33,8 @@ export interface UnifiedEvaluationContext {
     }>;
     toolUsage?: Array<{
         toolName: string;
-        input: any;
-        output: any;
+        input: unknown;
+        output: unknown;
         executionTime: number;
     }>;
     expectedOutcome?: string;
@@ -52,5 +52,5 @@ declare function parseUnifiedEvaluationResult(response: string, context: Unified
  * Main unified evaluation function
  */
 export declare function generateUnifiedEvaluation(context: UnifiedEvaluationContext): Promise<UnifiedEvaluationResult>;
-export declare function evaluateResponse(responseOrContext: any, contextOrUserQuery?: any, userQuery?: any, providedContexts?: any, options?: any, additionalArgs?: any): Promise<any>;
+export declare function evaluateResponse(responseOrContext: unknown, contextOrUserQuery?: unknown, userQuery?: unknown, providedContexts?: unknown, options?: unknown, additionalArgs?: unknown): Promise<unknown>;
 export { getDefaultUnifiedEvaluation, parseUnifiedEvaluationResult };

package/dist/lib/core/evaluation.js

@@ -90,7 +90,19 @@ function parseUnifiedEvaluationResult(response, context) {
             if (match) {
                 const value = parseFloat(match[1]);
                 if (value >= 1 && value <= 10) {
-                    result[key] = Math.round(value);
+                    const roundedValue = Math.round(value);
+                    if (key === "relevance") {
+                        result.relevance = roundedValue;
+                    }
+                    else if (key === "accuracy") {
+                        result.accuracy = roundedValue;
+                    }
+                    else if (key === "completeness") {
+                        result.completeness = roundedValue;
+                    }
+                    else if (key === "overall") {
+                        result.overall = roundedValue;
+                    }
                 }
             }
         }
@@ -163,9 +175,7 @@ Overall: [score]
             return getDefaultUnifiedEvaluation("no-response", Date.now() - startTime, context);
         }
         // Extract text from result
-        const response = typeof result === "string"
-            ? result
-            : result.text || String(result);
+        const response = typeof result === "string" ? result : result?.content || String(result);
         // Parse evaluation result
         const parsed = parseUnifiedEvaluationResult(response, context);
         // Validate and enhance result
@@ -216,12 +226,12 @@ export async function evaluateResponse(responseOrContext, contextOrUserQuery, us
                 String(contextOrUserQuery || "");
     }
     const evalContext = {
-        userQuery: userQuery ||
+        userQuery: (typeof userQuery === "string" ? userQuery : "") ||
             context?.userQuery ||
-            contextOrUserQuery ||
+            (typeof contextOrUserQuery === "string" ? contextOrUserQuery : "") ||
             "Generated response",
         aiResponse,
-        context,
+        context: context,
     };
     return generateUnifiedEvaluation(evalContext);
 }

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

@@ -1,4 +1,5 @@
 import type { AIProvider, AIProviderName, SupportedModelName } from "./types.js";
+import type { UnknownRecord } from "../types/common.js";
 declare const componentIdentifier = "aiProviderFactory";
 /**
  * Factory for creating AI provider instances with centralized configuration
@@ -15,7 +16,7 @@ export declare class AIProviderFactory {
      * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
     /**
      * Create a provider instance with specific provider enum and model
      * @param provider - Provider enum value
@@ -30,7 +31,7 @@ export declare class AIProviderFactory {
      * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createBestProvider(requestedProvider?: string, modelName?: string | null, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+    static createBestProvider(requestedProvider?: string, modelName?: string | null, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
     /**
      * Create primary and fallback provider instances
      * @param primaryProvider - Primary provider name

package/dist/lib/core/service-registry.d.ts

@@ -2,13 +2,13 @@
  * Service Registry for Dependency Injection
  * Breaks circular dependencies by providing lazy loading and centralized service management
  */
-export interface ServiceFactory<T = any> {
+export interface ServiceFactory<T = unknown> {
     (): T | Promise<T>;
 }
-export interface ServiceRegistration {
-    factory: ServiceFactory;
+export interface ServiceRegistration<T = unknown> {
+    factory: ServiceFactory<T>;
     singleton: boolean;
-    instance?: any;
+    instance?: T;
 }
 export declare class ServiceRegistry {
     private static services;

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

@@ -2,6 +2,7 @@ import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema, Tool } from "ai";
 import type { GenerateResult } from "../types/generate-types.js";
 import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import type { JsonValue } from "../types/common.js";
 export interface TextGenerationResult {
     content: string;
     provider?: string;
@@ -26,8 +27,14 @@ export interface TextGenerationResult {
         server: string;
         category?: string;
     }>;
-    analytics?: any;
-    evaluation?: any;
+    analytics?: AnalyticsData;
+    evaluation?: {
+        relevance: number;
+        accuracy: number;
+        completeness: number;
+        overall: number;
+        reasoning?: string;
+    };
 }
 /**
  * Supported AI Provider Names
@@ -118,7 +125,7 @@ export interface TextGenerationOptions {
     maxSteps?: number;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
-    context?: Record<string, any>;
+    context?: Record<string, JsonValue>;
     evaluationDomain?: string;
     toolUsageContext?: string;
     conversationHistory?: Array<{
@@ -140,7 +147,7 @@ export interface AnalyticsData {
     cost?: number;
     responseTime: number;
     timestamp: string;
-    context?: Record<string, any>;
+    context?: Record<string, JsonValue>;
 }
 /**
  * Response quality evaluation scores (Lighthouse-Compatible Schema)

package/dist/lib/factories/compatibility-factory.d.ts

@@ -12,7 +12,22 @@ export declare class CompatibilityConversionFactory {
     /**
      * Convert GenerateResult to legacy TextGenerationResult format
      */
-    static convertGenerateToText(result: GenerateResult): any;
+    static convertGenerateToText(result: GenerateResult): {
+        content: string;
+        provider?: string;
+        model?: string;
+        usage?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        };
+        responseTime?: number;
+        toolsUsed?: number;
+        toolExecutions?: unknown[];
+        analytics?: unknown;
+        evaluation?: unknown;
+        [key: string]: unknown;
+    };
     /**
      * Convert GenerateOptions to TextGenerationOptions
      */

package/dist/lib/factories/compatibility-factory.js

@@ -37,7 +37,9 @@ export class CompatibilityConversionFactory {
             model: result.model,
             usage: result.usage,
             responseTime: result.responseTime,
-            toolsUsed: result.toolsUsed,
+            toolsUsed: Array.isArray(result.toolsUsed)
+                ? result.toolsUsed.length
+                : result.toolsUsed,
             toolExecutions: result.toolExecutions,
             enhancedWithTools: result.enhancedWithTools,
             availableTools: result.availableTools,

package/dist/lib/factories/provider-factory.d.ts

@@ -1,10 +1,11 @@
 import type { AIProvider, AIProviderName } from "../core/types.js";
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Provider constructor interface - supports both sync constructors and async factory functions
  */
 type ProviderConstructor = {
-    new (modelName?: string, providerName?: any, sdk?: any): AIProvider;
-} | ((modelName?: string, providerName?: any, sdk?: any) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: UnknownRecord): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord) => Promise<AIProvider>);
 /**
  * Provider registration entry
  */
@@ -29,7 +30,7 @@ export declare class ProviderFactory {
     /**
      * Create a provider instance
      */
-    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: any): Promise<AIProvider>;
+    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: UnknownRecord): Promise<AIProvider>;
     /**
      * Check if a provider is registered
      */
@@ -63,7 +64,7 @@ export declare class ProviderFactory {
      * Create the best available provider for the given name
      * Used by NeuroLink SDK for streaming and generation
      */
-    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
 }
 /**
  * Helper function to create providers with backward compatibility

package/dist/lib/factories/provider-factory.js

@@ -37,32 +37,23 @@ export class ProviderFactory {
         }
         const model = modelName || registration.defaultModel;
         try {
-            // Check if constructor is an async factory function or a class constructor
-            if (typeof registration.constructor === "function") {
-                // Check if it has a prototype (class constructor) or not (factory function)
-                if (registration.constructor.prototype &&
-                    registration.constructor.prototype.constructor ===
-                        registration.constructor) {
-                    // It's a class constructor
-                    return new registration.constructor(model, providerName, sdk);
-                }
-                else {
-                    // It's a factory function - call it and await if it returns a promise
-                    const result = registration.constructor(model, providerName, sdk);
-                    if (result && typeof result.then === "function") {
-                        // It's a Promise (async factory)
-                        return await result;
-                    }
-                    else {
-                        // It's a sync result, return it
-                        return result;
-                    }
-                }
+            // Try calling as factory function first, then fallback to constructor
+            let result;
+            try {
+                // Try as factory function
+                result = registration.constructor(model, providerName, sdk);
             }
-            else {
-                // Fallback - use as class constructor
-                return new registration.constructor(model, sdk);
+            catch (factoryError) {
+                // Fallback to constructor
+                result = new registration.constructor(model, providerName, sdk);
             }
+            // Only await if result is actually a Promise
+            if (result &&
+                typeof result === "object" &&
+                typeof result.then === "function") {
+                return await result;
+            }
+            return result;
         }
         catch (error) {
             logger.error(`Failed to create provider ${providerName}:`, error);

package/dist/lib/factories/provider-generate-factory.js

@@ -37,35 +37,41 @@ export class ProviderGenerateFactory {
             try {
                 // Use existing generate method for identical performance
                 const textResult = await provider.generate(textOptions);
+                if (!textResult) {
+                    throw new Error("Generate method returned null result");
+                }
                 // Convert back to GenerateResult format with type safety
                 const generateResult = {
-                    content: textResult?.content || "",
-                    outputs: { text: textResult?.content || "" },
-                    provider: textResult?.provider,
-                    model: textResult?.model,
-                    usage: textResult?.usage
+                    content: textResult.content || "",
+                    outputs: { text: textResult.content || "" },
+                    provider: textResult.provider,
+                    model: textResult.model,
+                    usage: textResult.usage
                         ? {
-                            inputTokens: textResult.usage?.promptTokens || 0,
-                            outputTokens: textResult.usage?.completionTokens || 0,
-                            totalTokens: textResult.usage?.totalTokens || 0,
+                            inputTokens: textResult.usage.inputTokens || 0,
+                            outputTokens: textResult.usage.outputTokens || 0,
+                            totalTokens: textResult.usage.totalTokens || 0,
                         }
                         : undefined,
-                    responseTime: textResult?.responseTime,
-                    toolsUsed: textResult?.toolsUsed,
-                    toolExecutions: textResult?.toolExecutions?.map((te) => ({
-                        name: te.toolName || te.name || "",
-                        input: te.input || {},
-                        output: te.output || te.result,
-                        duration: te.executionTime || te.duration || 0,
-                    })),
-                    enhancedWithTools: textResult?.enhancedWithTools,
-                    availableTools: textResult?.availableTools?.map((at) => ({
+                    responseTime: textResult.responseTime,
+                    toolsUsed: textResult.toolsUsed,
+                    toolExecutions: textResult.toolExecutions?.map((te) => {
+                        const toolExecution = te;
+                        return {
+                            name: toolExecution.toolName || toolExecution.name || "",
+                            input: toolExecution.input || {},
+                            output: toolExecution.output || toolExecution.result,
+                            duration: toolExecution.executionTime || toolExecution.duration || 0,
+                        };
+                    }),
+                    enhancedWithTools: textResult.enhancedWithTools,
+                    availableTools: textResult.availableTools?.map((at) => ({
                         name: at.name || "",
                         description: at.description || "",
                         parameters: at.parameters || {},
                     })),
-                    analytics: textResult?.analytics,
-                    evaluation: textResult?.evaluation,
+                    analytics: textResult.analytics,
+                    evaluation: textResult.evaluation,
                 };
                 return generateResult;
             }

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

@@ -3,6 +3,7 @@
  * Provides compatibility layer for existing MCP integrations
  */
 import type { ExecutionContext } from "../contracts/mcp-contract.js";
+import type { JsonValue, UnknownRecord, Unknown } from "../../types/common.js";
 /**
  * Bridge interface for legacy MCP compatibility
  */
@@ -22,18 +23,18 @@ export declare function enhanceExecutionContext(context: ExecutionContext): Exec
 /**
  * Utility function to adapt legacy MCP calls
  */
-export declare function adaptLegacyMCPCall(context: ExecutionContext, operation: string, ...args: any[]): Promise<any>;
+export declare function adaptLegacyMCPCall(context: ExecutionContext, operation: string, ...args: JsonValue[]): Promise<Unknown>;
 /**
  * Quick plugin factory for simple plugin creation
  */
 export declare class QuickPluginFactory {
-    static create(name: string, config: any): Promise<{
+    static create(name: string, config: UnknownRecord): Promise<{
         name: string;
-        config: any;
+        config: UnknownRecord;
         initialized: boolean;
     }>;
 }
 /**
  * Execute plugin with enhanced context
  */
-export declare function executePlugin(plugin: any, context: ExecutionContext, operation: string, ...args: any[]): Promise<any>;
+export declare function executePlugin(plugin: UnknownRecord, context: ExecutionContext, operation: string, ...args: JsonValue[]): Promise<Unknown>;

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

@@ -46,12 +46,19 @@ export function enhanceExecutionContext(context) {
 export async function adaptLegacyMCPCall(context, operation, ...args) {
     const bridge = createLegacyBridge(context);
     switch (operation) {
-        case "writeFile":
-            return bridge.writeFile(args[0], args[1]);
-        case "readFile":
-            return bridge.readFile(args[0]);
-        case "listFiles":
-            return bridge.listFiles(args[0]);
+        case "writeFile": {
+            const filePath = typeof args[0] === "string" ? args[0] : String(args[0]);
+            const content = typeof args[1] === "string" ? args[1] : String(args[1]);
+            return bridge.writeFile(filePath, content);
+        }
+        case "readFile": {
+            const readPath = typeof args[0] === "string" ? args[0] : String(args[0]);
+            return bridge.readFile(readPath);
+        }
+        case "listFiles": {
+            const listPath = typeof args[0] === "string" ? args[0] : String(args[0]);
+            return bridge.listFiles(listPath);
+        }
         default:
             throw new Error(`Unsupported legacy operation: ${operation}`);
     }

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

@@ -4,6 +4,7 @@
  */
 import { EventEmitter } from "events";
 import type { ToolResult, NeuroLinkExecutionContext } from "./factory.js";
+import type { Unknown } from "../types/common.js";
 /**
  * MCP Client Configuration
  */
@@ -28,11 +29,12 @@ export declare class NeuroLinkMCPClient extends EventEmitter {
      * Register a tool with the MCP client
      * Following Lighthouse's pattern of namespacing tools with server ID
      */
-    registerTool(toolName: string, execute: (name: string, params: Record<string, unknown>) => Promise<any>, description?: string, inputSchema?: unknown): void;
+    registerTool(toolName: string, execute: (name: string, params: Record<string, unknown>) => Promise<Unknown>, description?: string, inputSchema?: unknown): void;
     /**
      * Get all registered tools
      */
     getTools(): Record<string, {
+        name: string;
         description?: string;
         inputSchema?: unknown;
     }>;