@juspay/neurolink 7.37.0 → 7.37.1

package/dist/lib/utils/schemaConversion.d.ts

@@ -0,0 +1,14 @@
+import type { ZodUnknownSchema } from "../types/tools.js";
+/**
+ * Convert Zod schema to JSON Schema format for Claude AI
+ */
+export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
+/**
+ * Check if a value is a Zod schema
+ */
+export declare function isZodSchema(value: unknown): boolean;
+/**
+ * Convert JSON Schema to Zod schema format using official json-schema-to-zod library
+ * This ensures complete preservation of all schema structure and validation rules
+ */
+export declare function convertJsonSchemaToZod(jsonSchema: Record<string, unknown>): ZodUnknownSchema;

package/dist/lib/utils/schemaConversion.js

@@ -0,0 +1,140 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { jsonSchemaToZod } from "json-schema-to-zod";
+import { z } from "zod";
+import { logger } from "./logger.js";
+/**
+ * Convert Zod schema to JSON Schema format for Claude AI
+ */
+export function convertZodToJsonSchema(zodSchema) {
+    try {
+        // Use a type assertion that bypasses the infinite recursion check
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const jsonSchema = zodToJsonSchema(zodSchema, {
+            name: "ToolParameters",
+            target: "jsonSchema7",
+            errorMessages: true,
+        });
+        // CRITICAL FIX: Ensure schema always has a proper type field for Google Vertex AI
+        if (!jsonSchema.type) {
+            // Default to "object" type if not specified, as most tool schemas are objects
+            jsonSchema.type = "object";
+            // If no properties, ensure it's at least an empty object schema
+            if (!jsonSchema.properties) {
+                jsonSchema.properties = {};
+            }
+            logger.info(`[SCHEMA-TYPE-FIX] Added missing type field to JSON Schema`, {
+                originalType: undefined,
+                fixedType: jsonSchema.type,
+                hasProperties: !!jsonSchema.properties,
+                addedEmptyProperties: !jsonSchema.properties,
+            });
+        }
+        logger.debug("Converted Zod schema to JSON Schema", {
+            hasProperties: !!jsonSchema.properties,
+            propertiesCount: Object.keys(jsonSchema.properties || {}).length,
+            schemaType: jsonSchema.type,
+            hasTypeField: !!jsonSchema.type,
+        });
+        return jsonSchema;
+    }
+    catch (error) {
+        logger.warn("Failed to convert Zod schema to JSON Schema", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Return a valid empty object schema instead of empty object
+        return {
+            type: "object",
+            properties: {},
+        };
+    }
+}
+/**
+ * Check if a value is a Zod schema
+ */
+export function isZodSchema(value) {
+    return !!(value &&
+        typeof value === "object" &&
+        "_def" in value &&
+        typeof value.parse === "function");
+}
+/**
+ * Convert JSON Schema to Zod schema format using official json-schema-to-zod library
+ * This ensures complete preservation of all schema structure and validation rules
+ */
+export function convertJsonSchemaToZod(jsonSchema) {
+    const startTime = Date.now();
+    try {
+        // Handle empty or invalid schemas
+        if (!jsonSchema || typeof jsonSchema !== "object") {
+            logger.debug("🔍 [SCHEMA-CONVERSION] Invalid or empty JSON schema, using fallback");
+            return z.object({}).passthrough();
+        }
+        // Log detailed input schema for debugging
+        logger.debug("🔍 [SCHEMA-CONVERSION] ===== STARTING OFFICIAL LIBRARY CONVERSION =====");
+        logger.debug("🔍 [SCHEMA-CONVERSION] Input JSON Schema:", {
+            type: jsonSchema.type,
+            hasProperties: !!jsonSchema.properties,
+            propertiesCount: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).length
+                : 0,
+            requiredCount: Array.isArray(jsonSchema.required)
+                ? jsonSchema.required.length
+                : 0,
+            required: jsonSchema.required,
+            sampleProperties: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).slice(0, 5)
+                : [],
+        });
+        // Use official library to convert JSON Schema to Zod code
+        const zodCodeResult = jsonSchemaToZod(jsonSchema, {
+            module: "esm",
+            name: "schema",
+        });
+        logger.debug("🔍 [SCHEMA-CONVERSION] Generated Zod code:", {
+            codeLength: zodCodeResult.length,
+            codePreview: zodCodeResult.substring(0, 200) + "...",
+        });
+        // Extract the actual Zod schema expression from the generated code
+        // Generated code looks like: "import { z } from "zod"\n\nexport const schema = z.object({...})\n"
+        const schemaMatch = zodCodeResult.match(/export const schema = (z\..+?)(?:\n|$)/s);
+        if (!schemaMatch) {
+            throw new Error("Could not extract Zod schema from generated code");
+        }
+        const schemaExpression = schemaMatch[1].trim();
+        logger.debug("🔍 [SCHEMA-CONVERSION] Extracted schema expression:", {
+            expression: schemaExpression.substring(0, 300) + "...",
+        });
+        // Use Function constructor instead of eval for better scope control
+        const createZodSchema = new Function("z", `return ${schemaExpression}`);
+        const zodSchema = createZodSchema(z);
+        const conversionTime = Date.now() - startTime;
+        logger.debug("🔍 [SCHEMA-CONVERSION] ===== CONVERSION SUCCESSFUL =====", {
+            inputType: jsonSchema.type,
+            propertiesCount: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).length
+                : 0,
+            requiredCount: Array.isArray(jsonSchema.required)
+                ? jsonSchema.required.length
+                : 0,
+            conversionSuccess: true,
+            conversionTimeMs: conversionTime,
+            libraryUsed: "json-schema-to-zod-official",
+            zodSchemaType: zodSchema?.constructor?.name || "unknown",
+        });
+        return zodSchema;
+    }
+    catch (error) {
+        const conversionTime = Date.now() - startTime;
+        logger.warn("🚨 [SCHEMA-CONVERSION] Official library conversion failed, using passthrough fallback", {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error,
+            inputSchemaType: jsonSchema?.type,
+            inputSchemaKeys: jsonSchema && typeof jsonSchema === "object"
+                ? Object.keys(jsonSchema)
+                : [],
+            conversionTimeMs: conversionTime,
+            libraryUsed: "json-schema-to-zod-official-FAILED",
+        });
+        return z.object({}).passthrough();
+    }
+}

package/dist/lib/utils/transformationUtils.js

@@ -2,6 +2,7 @@
  * Object Transformation Utilities
  * Centralizes repeated object transformation patterns to improve code reuse and maintainability
  */
+import { logger } from "./logger.js";
 // ============================================================================
 // TOOL EXECUTION TRANSFORMATIONS
 // ============================================================================
@@ -43,22 +44,109 @@ export function transformToolExecutions(toolExecutions) {
         if (!toolName) {
             toolName = `tool_execution_${index}`;
         }
+        // Enhanced tool parameter extraction with structured logging
+        const parameterExtractionData = {
+            executionIndex: index,
+            toolNameExtracted: toolName,
+            primarySources: {
+                hasInput: !!teRecord.input,
+                hasParameters: !!teRecord.parameters,
+                hasArgs: !!teRecord.args,
+                inputType: typeof teRecord.input,
+                parametersType: typeof teRecord.parameters,
+                argsType: typeof teRecord.args,
+            },
+            rawRecordKeys: Object.keys(teRecord),
+        };
+        logger.debug("[TransformationUtils] Tool parameter extraction analysis", parameterExtractionData);
         // Enhanced input extraction
         let input = teRecord.input ||
             teRecord.parameters ||
             teRecord.args ||
             {};
+        const primaryExtractionResult = {
+            keysCount: Object.keys(input).length,
+            keys: Object.keys(input),
+            extractionSuccessful: Object.keys(input).length > 0,
+            extractionSource: teRecord.input
+                ? "input"
+                : teRecord.parameters
+                    ? "parameters"
+                    : teRecord.args
+                        ? "args"
+                        : "empty",
+        };
+        logger.debug("[TransformationUtils] Primary parameter extraction result", primaryExtractionResult);
         // Extract input from nested toolCall if available
         if (Object.keys(input).length === 0 &&
             teRecord.toolCall &&
             typeof teRecord.toolCall === "object") {
             const toolCall = teRecord.toolCall;
+            const nestedExtractionData = {
+                reason: "Primary extraction failed, checking nested toolCall",
+                nestedSources: {
+                    hasInput: !!toolCall.input,
+                    hasParameters: !!toolCall.parameters,
+                    hasArgs: !!toolCall.args,
+                },
+                toolCallKeys: Object.keys(toolCall),
+            };
+            logger.debug("[TransformationUtils] Nested parameter extraction attempt", nestedExtractionData);
             input =
                 toolCall.input ||
                     toolCall.parameters ||
                     toolCall.args ||
                     {};
+            const nestedExtractionResult = {
+                keysCount: Object.keys(input).length,
+                keys: Object.keys(input),
+                extractionSuccessful: Object.keys(input).length > 0,
+                extractionSource: toolCall.input
+                    ? "toolCall.input"
+                    : toolCall.parameters
+                        ? "toolCall.parameters"
+                        : toolCall.args
+                            ? "toolCall.args"
+                            : "empty",
+            };
+            logger.debug("[TransformationUtils] Nested parameter extraction result", nestedExtractionResult);
+        }
+        // Target tool parameter analysis for critical tools
+        if (toolName &&
+            (toolName.includes("SuccessRateSRByTime") ||
+                toolName.includes("juspay-analytics"))) {
+            const targetToolAnalysis = {
+                toolName,
+                inputKeys: Object.keys(input),
+                keysCount: Object.keys(input).length,
+                hasStartTime: "startTime" in input,
+                hasEndTime: "endTime" in input,
+                startTimeValue: input.startTime || "MISSING",
+                endTimeValue: input.endTime || "MISSING",
+                extractionStatus: Object.keys(input).length === 0 ? "FAILED" : "SUCCESS",
+            };
+            logger.debug("[TransformationUtils] Target tool parameter analysis", targetToolAnalysis);
+            if (Object.keys(input).length === 0) {
+                logger.error("[TransformationUtils] Critical: Target tool parameter extraction failed", {
+                    toolName,
+                    reason: "Both primary and nested extraction returned empty parameters",
+                    impact: "AI response did not contain expected parameter structure",
+                });
+            }
         }
+        // Final parameter extraction summary
+        const finalExtractionSummary = {
+            toolName,
+            inputKeysCount: Object.keys(input).length,
+            inputKeys: Object.keys(input),
+            hasParameters: Object.keys(input).length > 0,
+            duration: teRecord.duration ??
+                teRecord.executionTime ??
+                teRecord.responseTime ??
+                0,
+            hasOutput: !!(teRecord.output || teRecord.result || teRecord.response),
+        };
+        logger.debug("[TransformationUtils] Final parameter extraction result", finalExtractionSummary);
         // Enhanced output extraction with success indication
         const output = teRecord.output ||
             teRecord.result ||
@@ -169,14 +257,61 @@ export function transformAvailableTools(availableTools) {
     }
     return availableTools.map((tool) => {
         const toolRecord = tool;
+        let extractedParameters = {};
+        const inputSchema = toolRecord.inputSchema;
+        const directParameters = toolRecord.parameters;
+        const fallbackSchema = toolRecord.schema;
+        if (inputSchema && typeof inputSchema === "object") {
+            if (inputSchema.$ref && inputSchema.definitions) {
+                const definitions = inputSchema.definitions;
+                const refValue = inputSchema.$ref;
+                if (typeof refValue === "string") {
+                    const refKey = refValue.replace("#/definitions/", "");
+                    if (definitions[refKey] && typeof definitions[refKey] === "object") {
+                        const resolvedSchema = definitions[refKey];
+                        extractedParameters = {
+                            type: resolvedSchema.type || "object",
+                            properties: resolvedSchema.properties || {},
+                            required: resolvedSchema.required || [],
+                            ...resolvedSchema, // Include all schema metadata
+                        };
+                    }
+                }
+            }
+            else if (inputSchema.properties) {
+                extractedParameters = {
+                    type: inputSchema.type || "object",
+                    properties: inputSchema.properties,
+                    required: inputSchema.required || [],
+                    ...inputSchema,
+                };
+            }
+            else if (inputSchema.type === "object") {
+                extractedParameters = inputSchema;
+            }
+            else {
+                extractedParameters = inputSchema;
+            }
+        }
+        else if (directParameters && typeof directParameters === "object") {
+            extractedParameters = directParameters;
+        }
+        else if (fallbackSchema && typeof fallbackSchema === "object") {
+            extractedParameters = fallbackSchema;
+        }
+        if (!extractedParameters || typeof extractedParameters !== "object") {
+            extractedParameters = {};
+        }
+        if (extractedParameters &&
+            !extractedParameters.type &&
+            extractedParameters.properties) {
+            extractedParameters.type = "object";
+        }
         return {
             name: tool.name || "",
             description: tool.description || "",
             server: tool.server || "",
-            parameters: toolRecord.inputSchema ||
-                toolRecord.parameters ||
-                toolRecord.schema ||
-                {},
+            parameters: extractedParameters,
         };
     });
 }
@@ -246,7 +381,10 @@ export function transformSchemaToParameterDescription(schema) {
         .map(([key, value]) => {
         const typedValue = value;
         const required = requiredParams.has(key) ? " (required)" : "";
-        return `  - ${key}: ${typedValue.type || "unknown"}${required}`;
+        const description = typedValue.description
+            ? ` - ${typedValue.description}`
+            : "";
+        return `  - ${key}: ${typedValue.type || "unknown"}${required}${description}`;
     })
         .join("\n");
 }

package/dist/mcp/externalServerManager.js

@@ -89,9 +89,9 @@ export class ExternalServerManager extends EventEmitter {
             enablePerformanceMonitoring: config.enablePerformanceMonitoring ?? true,
             logLevel: config.logLevel ?? "info",
         };
-        // Enable main tool registry integration by default
+        // Disable main tool registry integration by default to prevent automatic tool execution
         this.enableMainRegistryIntegration =
-            options.enableMainRegistryIntegration ?? true;
+            options.enableMainRegistryIntegration ?? false;
         // Initialize tool discovery service
         this.toolDiscovery = new ToolDiscoveryService();
         // Forward tool discovery events

package/dist/mcp/registry.js

@@ -13,7 +13,7 @@ export class MCPRegistry {
      */
     register(plugin) {
         this.plugins.set(plugin.metadata.name, plugin);
-        registryLogger.info(`Registered plugin: ${plugin.metadata.name}`);
+        registryLogger.debug(`Registered plugin: ${plugin.metadata.name}`);
     }
     /**
      * Unregister a plugin
@@ -21,7 +21,7 @@ export class MCPRegistry {
     unregister(name) {
         const removed = this.plugins.delete(name);
         if (removed) {
-            registryLogger.info(`Unregistered plugin: ${name}`);
+            registryLogger.debug(`Unregistered plugin: ${name}`);
         }
         return removed;
     }

package/dist/mcp/servers/agent/directToolsServer.js

@@ -46,8 +46,24 @@ if (!shouldDisableBuiltinTools()) {
             execute: async (params, context) => {
                 const startTime = Date.now();
                 try {
-                    logger.debug(`[Direct Tools] Executing ${toolName} with params:`, params);
-                    // Execute the direct tool
+                    if (Object.keys(params || {}).length === 0) {
+                        return {
+                            success: false,
+                            data: null,
+                            error: "Tool execution blocked: Empty parameters not allowed during startup",
+                            usage: {
+                                executionTime: Date.now() - startTime,
+                            },
+                            metadata: {
+                                toolName,
+                                serverId: "neurolink-direct",
+                                sessionId: context.sessionId,
+                                blocked: true,
+                                reason: "empty_parameters_startup_prevention",
+                                timestamp: Date.now(),
+                            },
+                        };
+                    }
                     if (!execute || typeof execute !== "function") {
                         throw new Error(`Tool ${toolName} has no execute function`);
                     }
@@ -104,7 +120,7 @@ if (!shouldDisableBuiltinTools()) {
     });
 }
 else {
-    logger.info("[Direct Tools] Built-in tools disabled via configuration");
+    logger.debug("Built-in tools disabled via configuration");
 }
 /**
  * Get tool category based on tool name
@@ -126,10 +142,3 @@ function getToolCategory(toolName) {
             return "utility";
     }
 }
-// Log successful registration or disable status
-if (!shouldDisableBuiltinTools()) {
-    logger.info(`[Direct Tools] Registered ${Object.keys(directAgentTools).length} direct tools`);
-}
-else {
-    logger.info("[Direct Tools] 0 direct tools registered (disabled via environment variable)");
-}

package/dist/mcp/toolRegistry.js

@@ -16,13 +16,9 @@ export class MCPToolRegistry extends MCPRegistry {
     builtInServerInfos = []; // DIRECT storage for MCPServerInfo
     constructor() {
         super();
-        // 🔧 CONDITIONAL: Only auto-register direct tools if not disabled via configuration
         if (!shouldDisableBuiltinTools()) {
             this.registerDirectTools();
         }
-        else {
-            registryLogger.debug("Built-in direct tools disabled via configuration");
-        }
     }
     /**
      * Register all direct tools from directAgentTools
@@ -100,7 +96,6 @@ export class MCPToolRegistry extends MCPRegistry {
             _finalContext = serverConfigOrContext;
         }
         const serverId = serverInfo.id;
-        registryLogger.info(`Registering MCPServerInfo directly: ${serverId}`);
         // Use MCPServerInfo.tools array directly - ZERO conversions!
         const toolsObject = {};
         for (const tool of serverInfo.tools) {
@@ -133,7 +128,6 @@ export class MCPToolRegistry extends MCPRegistry {
         this.register(plugin);
         // Use MCPServerInfo.tools array directly - ZERO conversions!
         const tools = serverInfo.tools;
-        registryLogger.debug(`Registering ${tools.length} tools for server ${serverId}:`, tools.map((t) => t.name));
         for (const tool of tools) {
             // For custom tools, use just the tool name to avoid redundant serverId.toolName format
             // For other tools, use fully-qualified serverId.toolName to avoid collisions
@@ -166,7 +160,7 @@ export class MCPToolRegistry extends MCPRegistry {
                     serverId: serverInfo.id,
                 }),
             });
-            registryLogger.debug(`Registered tool '${tool.name}' with execute function:`, typeof tool.execute);
+            // Tool registered successfully
         }
         // Store MCPServerInfo directly - NO recreation needed!
         if (tools.length > 0) {
@@ -211,9 +205,11 @@ export class MCPToolRegistry extends MCPRegistry {
     async executeTool(toolName, args, context) {
         const startTime = Date.now();
         try {
-            registryLogger.info(`Executing tool: ${toolName}`);
+            registryLogger.info(`🔧 [TOOL_EXECUTION] Starting execution: ${toolName}`);
+            registryLogger.info(`🔧 [TOOL_EXECUTION] Starting execution: ${toolName}`, { args, context });
             // Try to find the tool by fully-qualified name first
             let tool = this.tools.get(toolName);
+            registryLogger.info(`🔍 [TOOL_LOOKUP] Direct lookup result for '${toolName}':`, !!tool);
             // If not found, search for tool by name across all entries (for backward compatibility)
             let toolId = toolName;
             if (!tool) {

package/dist/neurolink.d.ts

@@ -10,9 +10,9 @@ import type { GenerateOptions, GenerateResult } from "./types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
 import type { MCPServerInfo, MCPExecutableTool } from "./types/mcpTypes.js";
 import type { ToolInfo } from "./mcp/contracts/mcpContract.js";
+import type { NeuroLinkEvents, TypedEventEmitter, ToolExecutionContext, ToolExecutionSummary } from "./types/common.js";
 import type { JsonObject } from "./types/common.js";
 import type { BatchOperationResult } from "./types/typeAliases.js";
-import { EventEmitter } from "events";
 import type { ConversationMemoryConfig, ChatMessage } from "./types/conversation.js";
 import type { ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
 export interface ProviderStatus {
@@ -49,6 +49,9 @@ export declare class NeuroLink {
     private readonly toolCacheDuration;
     private toolCircuitBreakers;
     private toolExecutionMetrics;
+    private currentStreamToolExecutions;
+    private toolExecutionHistory;
+    private activeToolExecutions;
     /**
      * Helper method to emit tool end event in a consistent way
      * Used by executeTool in both success and error paths
@@ -63,6 +66,11 @@ export declare class NeuroLink {
     private conversationMemoryNeedsInit;
     private conversationMemoryConfig?;
     private enableOrchestration;
+    /**
+     * Context storage for tool execution
+     * This context will be merged with any runtime context passed by the AI model
+     */
+    private toolExecutionContext?;
     /**
      * Creates a new NeuroLink instance for AI text generation with MCP tool integration.
      *
@@ -101,10 +109,6 @@ export declare class NeuroLink {
         conversationMemory?: Partial<ConversationMemoryConfig>;
         enableOrchestration?: boolean;
     });
-    /**
-     * Log constructor start with comprehensive environment analysis
-     */
-    private logConstructorStart;
     /**
      * Initialize provider registry with security settings
      */
@@ -130,14 +134,6 @@ export declare class NeuroLink {
      * Uses isolated async context to prevent hanging
      */
     private initializeMCP;
-    /**
-     * Log MCP initialization start
-     */
-    private logMCPInitStart;
-    /**
-     * Log MCP already initialized
-     */
-    private logMCPAlreadyInitialized;
     /**
      * Import performance manager with error handling
      */
@@ -293,10 +289,6 @@ export declare class NeuroLink {
      * Simplified approach without domain detection - relies on tool registry
      */
     private detectAndExecuteTools;
-    /**
-     * Enhance prompt with tool results (domain-agnostic)
-     */
-    private enhancePromptWithToolResults;
     /**
      * BACKWARD COMPATIBILITY: Legacy streamText method
      * Internally calls stream() and converts result format
@@ -354,14 +346,6 @@ export declare class NeuroLink {
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     stream(options: StreamOptions): Promise<StreamResult>;
-    /**
-     * Log stream entry point with comprehensive analysis
-     */
-    private logStreamEntryPoint;
-    /**
-     * Log performance baseline
-     */
-    private logPerformanceBaseline;
     /**
      * Validate stream input with comprehensive error reporting
      */
@@ -564,13 +548,58 @@ export declare class NeuroLink {
      * @see {@link NeuroLink.stream} for events related to streaming
      * @see {@link NeuroLink.executeTool} for events related to tool execution
      */
-    getEventEmitter(): EventEmitter<[never]>;
+    getEventEmitter(): TypedEventEmitter<NeuroLinkEvents>;
+    /**
+     * Emit tool start event with execution tracking
+     * @param toolName - Name of the tool being executed
+     * @param input - Input parameters for the tool
+     * @param startTime - Timestamp when execution started
+     * @returns executionId for tracking this specific execution
+     */
+    emitToolStart(toolName: string, input: unknown, startTime?: number): string;
+    /**
+     * Emit tool end event with execution summary
+     * @param toolName - Name of the tool that finished
+     * @param result - Result from the tool execution
+     * @param error - Error message if execution failed
+     * @param startTime - When execution started
+     * @param endTime - When execution finished
+     * @param executionId - Optional execution ID for tracking
+     */
+    emitToolEnd(toolName: string, result?: unknown, error?: string, startTime?: number, endTime?: number, executionId?: string): void;
+    /**
+     * Get current tool execution contexts for stream metadata
+     */
+    getCurrentToolExecutions(): ToolExecutionContext[];
+    /**
+     * Get tool execution history
+     */
+    getToolExecutionHistory(): ToolExecutionSummary[];
+    /**
+     * Clear current stream tool executions (called at stream start)
+     */
+    clearCurrentStreamExecutions(): void;
     /**
      * Register a custom tool that will be available to all AI providers
      * @param name - Unique name for the tool
      * @param tool - Tool in MCPExecutableTool format (unified MCP protocol type)
      */
     registerTool(name: string, tool: MCPExecutableTool): void;
+    /**
+     * Set the context that will be passed to tools during execution
+     * This context will be merged with any runtime context passed by the AI model
+     * @param context - Context object containing session info, tokens, shop data, etc.
+     */
+    setToolContext(context: Record<string, unknown>): void;
+    /**
+     * Get the current tool execution context
+     * @returns Current context or undefined if not set
+     */
+    getToolContext(): Record<string, unknown> | undefined;
+    /**
+     * Clear the tool execution context
+     */
+    clearToolContext(): void;
     /**
      * Register multiple tools at once - Supports both object and array formats
      * @param tools - Object mapping tool names to MCPExecutableTool format OR Array of tools with names
@@ -621,13 +650,19 @@ export declare class NeuroLink {
      * Supports both custom tools and MCP server tools with timeout, retry, and circuit breaker patterns
      * @param toolName - Name of the tool to execute
      * @param params - Parameters to pass to the tool
-     * @param options - Execution options
+     * @param options - Execution options including optional authentication context
      * @returns Tool execution result
      */
     executeTool<T = unknown>(toolName: string, params?: unknown, options?: {
         timeout?: number;
         maxRetries?: number;
         retryDelayMs?: number;
+        authContext?: {
+            userId?: string;
+            sessionId?: string;
+            user?: Record<string, unknown>;
+            [key: string]: unknown;
+        };
     }): Promise<T>;
     /**
      * Internal tool execution method (extracted for better error handling)