@juspay/neurolink 7.37.0 → 7.37.1

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

@@ -4,8 +4,8 @@
  */
 export declare const DEFAULT_MAX_TOKENS: undefined;
 export declare const DEFAULT_TEMPERATURE = 0.7;
-export declare const DEFAULT_TIMEOUT = 30000;
-export declare const DEFAULT_MAX_STEPS = 5;
+export declare const DEFAULT_TIMEOUT = 60000;
+export declare const DEFAULT_MAX_STEPS = 200;
 export declare const STEP_LIMITS: {
     min: number;
     max: number;
@@ -31,49 +31,21 @@ export declare const PROVIDER_CONFIG: {
 };
 export declare const PROVIDER_MAX_TOKENS: {
     anthropic: {
-        "claude-3-haiku-20240307": number;
-        "claude-3-5-sonnet-20241022": number;
-        "claude-3-opus-20240229": number;
-        "claude-3-5-sonnet-20240620": number;
         default: number;
     };
     openai: {
-        "gpt-4o": number;
-        "gpt-4o-mini": number;
-        "gpt-3.5-turbo": number;
-        "gpt-4": number;
-        "gpt-4-turbo": number;
         default: number;
     };
     "google-ai": {
-        "gemini-1.5-pro": number;
-        "gemini-1.5-flash": number;
-        "gemini-2.5-pro": number;
-        "gemini-2.5-flash": number;
-        "gemini-pro": number;
         default: number;
     };
     vertex: {
-        "gemini-1.5-pro": number;
-        "gemini-1.5-flash": number;
-        "gemini-2.5-pro": number;
-        "gemini-2.5-flash": number;
-        "claude-4.0-sonnet": number;
         default: number;
     };
     bedrock: {
-        "anthropic.claude-3-sonnet-20240229-v1:0": number;
-        "anthropic.claude-3-haiku-20240307-v1:0": number;
-        "anthropic.claude-3-5-sonnet-20240620-v1:0": number;
         default: number;
     };
     azure: {
-        "gpt-4o": number;
-        "gpt-4o-mini": number;
-        "gpt-4.1": number;
-        "gpt-3.5-turbo": number;
-        "gpt-4": number;
-        "gpt-4-turbo": number;
         default: number;
     };
     ollama: {

package/dist/lib/core/constants.js

@@ -5,12 +5,12 @@
 // Core AI Generation Defaults
 export const DEFAULT_MAX_TOKENS = undefined; // Unlimited by default - let providers decide their own limits
 export const DEFAULT_TEMPERATURE = 0.7;
-export const DEFAULT_TIMEOUT = 30000;
-export const DEFAULT_MAX_STEPS = 5; // Default multi-turn tool execution steps
+export const DEFAULT_TIMEOUT = 60000;
+export const DEFAULT_MAX_STEPS = 200;
 // Step execution limits
 export const STEP_LIMITS = {
     min: 1,
-    max: 20,
+    max: 500,
     default: DEFAULT_MAX_STEPS,
 };
 // Specialized Use Case Defaults
@@ -33,68 +33,40 @@ export const PROVIDER_CONFIG = {
         temperature: 0.4,
     },
 };
-// Provider-specific maxTokens limits (discovered through testing)
+// Provider-specific maxTokens limits
 export const PROVIDER_MAX_TOKENS = {
     anthropic: {
-        "claude-3-haiku-20240307": 4096,
-        "claude-3-5-sonnet-20241022": 4096,
-        "claude-3-opus-20240229": 4096,
-        "claude-3-5-sonnet-20240620": 4096,
-        default: 4096, // Conservative default for Anthropic
+        default: 64000,
     },
     openai: {
-        "gpt-4o": 16384,
-        "gpt-4o-mini": 16384,
-        "gpt-3.5-turbo": 4096,
-        "gpt-4": 8192,
-        "gpt-4-turbo": 4096,
-        default: 8192, // OpenAI generally supports higher limits
+        default: 500000,
     },
     "google-ai": {
-        "gemini-1.5-pro": 8192,
-        "gemini-1.5-flash": 8192,
-        "gemini-2.5-pro": 8192,
-        "gemini-2.5-flash": 8192,
-        "gemini-pro": 4096,
-        default: 4096, // Conservative default due to 500 errors at high limits
+        default: 64000,
     },
     vertex: {
-        "gemini-1.5-pro": 8192,
-        "gemini-1.5-flash": 8192,
-        "gemini-2.5-pro": 8192,
-        "gemini-2.5-flash": 8192,
-        "claude-4.0-sonnet": 4096,
-        default: 4096,
+        default: 64000,
     },
     bedrock: {
-        "anthropic.claude-3-sonnet-20240229-v1:0": 4096,
-        "anthropic.claude-3-haiku-20240307-v1:0": 4096,
-        "anthropic.claude-3-5-sonnet-20240620-v1:0": 4096,
-        default: 4096,
+        default: 64000,
     },
     azure: {
-        "gpt-4o": 16384,
-        "gpt-4o-mini": 16384,
-        "gpt-4.1": 16384,
-        "gpt-3.5-turbo": 4096,
-        "gpt-4": 8192,
-        "gpt-4-turbo": 4096,
-        default: 8192, // Azure OpenAI generally supports similar limits to OpenAI
+        default: 64000,
     },
     ollama: {
-        default: 8192, // Ollama typically supports higher limits
+        default: 64000,
     },
     litellm: {
-        default: 4096, // Conservative default
+        default: 500000,
     },
-    default: 4096, // Safe default across all providers
+    default: 64000,
 };
 // CLI Validation Limits
 export const CLI_LIMITS = {
     maxTokens: {
         min: 1,
-        max: 50000,
-        default: undefined, // No default limit - unlimited by default
+        max: 64000,
+        default: DEFAULT_MAX_TOKENS,
     },
     temperature: {
         min: 0,

package/dist/lib/factories/providerFactory.js

@@ -49,16 +49,33 @@ export class ProviderFactory {
             model = model || registration.defaultModel;
         }
         try {
+            if (typeof registration.constructor !== "function") {
+                throw new Error(`Invalid constructor for provider ${providerName}: not a function`);
+            }
             let result;
             try {
-                // Try as async factory function first (most providers are async functions)
-                result = await registration.constructor(model, providerName, sdk);
+                const factoryResult = registration.constructor(model, providerName, sdk);
+                // Handle both sync and async results
+                result =
+                    factoryResult instanceof Promise
+                        ? await factoryResult
+                        : factoryResult;
             }
-            catch {
-                // Fallback to constructor - ensure parameters are maintained
-                result = new registration.constructor(model, providerName, sdk);
+            catch (factoryError) {
+                if (registration.constructor.prototype &&
+                    registration.constructor.prototype.constructor ===
+                        registration.constructor) {
+                    try {
+                        result = new registration.constructor(model, providerName, sdk);
+                    }
+                    catch (constructorError) {
+                        throw new Error(`Both factory function and constructor failed. Factory error: ${factoryError}. Constructor error: ${constructorError}`);
+                    }
+                }
+                else {
+                    throw factoryError;
+                }
             }
-            // Return result (no need to await again if already awaited in try block)
             return result;
         }
         catch (error) {

package/dist/lib/index.d.ts

@@ -17,7 +17,8 @@ export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, }
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { dynamicModelProvider } from "./core/dynamicModels.js";
 export type { DynamicModelConfig, ModelRegistry } from "./types/modelTypes.js";
-export { NeuroLink } from "./neurolink.js";
+import { NeuroLink } from "./neurolink.js";
+export { NeuroLink };
 export type { ProviderStatus, MCPStatus } from "./neurolink.js";
 export type { MCPServerInfo } from "./types/mcpTypes.js";
 export type { NeuroLinkMiddleware, MiddlewareContext, MiddlewareFactoryOptions, MiddlewarePreset, MiddlewareConfig, } from "./types/middlewareTypes.js";
@@ -102,4 +103,4 @@ export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, Evalua
  * console.log(result.content);
  * ```
  */
-export declare function generateText(options: import("./types/index.js").TextGenerationOptions): Promise<import("./types/index.js").TextGenerationResult>;
+export declare function generateText(options: import("./core/types.js").TextGenerationOptions): Promise<import("./core/types.js").TextGenerationResult>;

package/dist/lib/index.js

@@ -17,7 +17,8 @@ export { getBestProvider, getAvailableProviders, isValidProvider, } from "./util
 // Dynamic Models exports
 export { dynamicModelProvider } from "./core/dynamicModels.js";
 // Main NeuroLink wrapper class and diagnostic types
-export { NeuroLink } from "./neurolink.js";
+import { NeuroLink } from "./neurolink.js";
+export { NeuroLink };
 export { MiddlewareFactory } from "./middleware/factory.js";
 // Version
 export const VERSION = "1.0.0";
@@ -127,7 +128,7 @@ export function getTelemetryStatus() {
  * ```
  */
 export async function generateText(options) {
-    // Import neurolink instance to avoid circular dependencies
-    const { neurolink } = await import("./neurolink.js");
+    // Create instance on-demand without auto-instantiation
+    const neurolink = new NeuroLink();
     return await neurolink.generateText(options);
 }

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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)