@juspay/neurolink 7.36.0 → 7.37.1

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
@@ -62,6 +65,12 @@ export declare class NeuroLink {
     private conversationMemory?;
     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.
      *
@@ -70,6 +79,7 @@ export declare class NeuroLink {
      * @param config.conversationMemory.enabled - Whether to enable conversation memory (default: false)
      * @param config.conversationMemory.maxSessions - Maximum number of concurrent sessions (default: 100)
      * @param config.conversationMemory.maxTurnsPerSession - Maximum conversation turns per session (default: 50)
+     * @param config.enableOrchestration - Whether to enable smart model orchestration (default: false)
      *
      * @example
      * ```typescript
@@ -84,6 +94,11 @@ export declare class NeuroLink {
      *     maxTurnsPerSession: 20
      *   }
      * });
+     *
+     * // With orchestration enabled
+     * const neurolink = new NeuroLink({
+     *   enableOrchestration: true
+     * });
      * ```
      *
      * @throws {Error} When provider registry setup fails
@@ -92,11 +107,8 @@ export declare class NeuroLink {
      */
     constructor(config?: {
         conversationMemory?: Partial<ConversationMemoryConfig>;
+        enableOrchestration?: boolean;
     });
-    /**
-     * Log constructor start with comprehensive environment analysis
-     */
-    private logConstructorStart;
     /**
      * Initialize provider registry with security settings
      */
@@ -122,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
      */
@@ -158,6 +162,18 @@ export declare class NeuroLink {
      * Log MCP initialization completion
      */
     private logMCPInitComplete;
+    /**
+     * Apply orchestration to determine optimal provider and model
+     * @param options - Original GenerateOptions
+     * @returns Modified options with orchestrated provider marked in context, or empty object if validation fails
+     */
+    private applyOrchestration;
+    /**
+     * Apply orchestration to determine optimal provider and model for streaming
+     * @param options - Original StreamOptions
+     * @returns Modified options with orchestrated provider marked in context, or empty object if validation fails
+     */
+    private applyStreamOrchestration;
     /**
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods
@@ -273,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
@@ -334,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
      */
@@ -544,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
@@ -601,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)