@juspay/neurolink 7.37.0 → 7.38.0

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,10 +10,12 @@ 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 { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
+import { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import type { ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
 export interface ProviderStatus {
     provider: string;
@@ -49,6 +51,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
@@ -59,10 +64,15 @@ export declare class NeuroLink {
      * @param error - The error if execution failed (optional)
      */
     private emitToolEndEvent;
-    private conversationMemory?;
+    conversationMemory?: ConversationMemoryManager | RedisConversationMemoryManager | null;
     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 +111,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 +136,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 +291,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 +348,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 +550,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 +652,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)
@@ -813,6 +850,12 @@ export declare class NeuroLink {
             recommendations: string[];
         }>;
     }>;
+    /**
+     * Initialize conversation memory if enabled (public method for explicit initialization)
+     * This is useful for testing or when you want to ensure conversation memory is ready
+     * @returns Promise resolving to true if initialization was successful, false otherwise
+     */
+    ensureConversationMemoryInitialized(): Promise<boolean>;
     /**
      * Get conversation memory statistics (public API)
      */
@@ -831,6 +874,30 @@ export declare class NeuroLink {
      * Clear all conversation history (public API)
      */
     clearAllConversations(): Promise<void>;
+    /**
+     * Store tool executions in conversation memory if enabled and Redis is configured
+     * @param sessionId - Session identifier
+     * @param userId - User identifier (optional)
+     * @param toolCalls - Array of tool calls
+     * @param toolResults - Array of tool results
+     * @returns Promise resolving when storage is complete
+     */
+    storeToolExecutions(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>): Promise<void>;
+    /**
+     * Check if tool execution storage is available
+     * @returns boolean indicating if Redis storage is configured and available
+     */
+    isToolExecutionStorageAvailable(): boolean;
     /**
      * Add an external MCP server
      * Automatically discovers and registers tools from the server