@juspay/neurolink 9.42.0 → 9.42.1

package/dist/lib/mcp/toolRegistry.js

@@ -9,6 +9,7 @@ import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { directAgentTools } from "../agent/directTools.js";
 import { detectCategory, createMCPServerInfo } from "../utils/mcpDefaults.js";
 import { FlexibleToolValidator } from "./flexibleToolValidator.js";
+import { ErrorFactory } from "../utils/errorHandling.js";
 import { HITLUserRejectedError, HITLTimeoutError } from "../hitl/hitlErrors.js";
 import { withSpan, tracers, ATTR } from "../telemetry/index.js";
 import { getAuthContext } from "../auth/authContext.js";
@@ -263,22 +264,7 @@ export class MCPToolRegistry extends MCPRegistry {
                     hasContext: context !== undefined,
                     sessionId: context?.sessionId,
                 });
-                // 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) {
-                    const matches = Array.from(this.tools.entries()).filter(([, toolInfo]) => toolInfo.name === toolName);
-                    if (matches.length > 1) {
-                        throw new Error(`Ambiguous tool name '${toolName}'. Use fully-qualified name 'serverId.${toolName}'.`);
-                    }
-                    if (matches.length === 1) {
-                        const [candidateToolId, toolInfo] = matches[0];
-                        tool = toolInfo;
-                        toolId = candidateToolId;
-                    }
-                }
+                const { tool, toolId } = this.resolveToolExecutionTarget(toolName);
                 if (!tool) {
                     throw new Error(`Tool '${toolName}' not found in registry`);
                 }
@@ -291,21 +277,7 @@ export class MCPToolRegistry extends MCPRegistry {
                         : "mcp";
                 span.setAttribute("tool.type", toolType);
                 span.setAttribute(ATTR.MCP_SERVER_ID, serverId);
-                // Try to get auth context if available
-                let authUserId;
-                try {
-                    const authCtx = getAuthContext();
-                    authUserId = authCtx?.user?.id;
-                }
-                catch {
-                    // Auth context not available — that's fine
-                }
-                // Create execution context if not provided
-                const execContext = {
-                    ...context,
-                    sessionId: context?.sessionId ?? randomUUID(),
-                    userId: context?.userId ?? authUserId,
-                };
+                const execContext = this.createExecutionContext(context);
                 // Get the tool implementation using the resolved toolId
                 const toolImpl = this.toolImplementations.get(toolId);
                 registryLogger.debug(`Looking for tool '${toolName}' (toolId: '${toolId}'), found: ${!!toolImpl}, type: ${typeof toolImpl?.execute}`);
@@ -504,6 +476,35 @@ export class MCPToolRegistry extends MCPRegistry {
         registryLogger.debug(`Listed ${result.length} unique tools (${filter ? "filtered" : "unfiltered"})`);
         return result;
     }
+    resolveToolExecutionTarget(toolName) {
+        let tool = this.tools.get(toolName);
+        registryLogger.info(`🔍 [TOOL_LOOKUP] Direct lookup result for '${toolName}':`, !!tool);
+        let toolId = toolName;
+        if (!tool) {
+            const matches = Array.from(this.tools.entries()).filter(([, toolInfo]) => toolInfo.name === toolName);
+            if (matches.length > 1) {
+                throw ErrorFactory.toolExecutionFailed(toolName, new Error(`Ambiguous tool name '${toolName}'. Use fully-qualified name 'serverId.${toolName}'.`));
+            }
+            if (matches.length === 1) {
+                [toolId, tool] = matches[0];
+            }
+        }
+        return { tool, toolId };
+    }
+    createExecutionContext(context) {
+        let authUserId;
+        try {
+            authUserId = getAuthContext()?.user?.id;
+        }
+        catch {
+            // Auth context not available — that's fine
+        }
+        return {
+            ...context,
+            sessionId: context?.sessionId ?? randomUUID(),
+            userId: context?.userId ?? authUserId,
+        };
+    }
     /**
      * Get tool information with server details
      */

package/dist/lib/neurolink.d.ts

@@ -81,6 +81,12 @@ export declare class NeuroLink {
      * Extract and set Langfuse context from options with proper async scoping
      */
     private setLangfuseContextFromOptions;
+    private createMetricsTraceContext;
+    private enforceSessionBudget;
+    private assertInputText;
+    private applyAuthenticatedRequestContext;
+    private applyGenerateLifecycleMiddleware;
+    private applyStreamLifecycleMiddleware;
     private initializeMemoryConfig;
     /**
      * Lazy initialization for memory — called during generate/stream.
@@ -526,6 +532,16 @@ export declare class NeuroLink {
      * @since 1.0.0
      */
     generate(optionsOrPrompt: GenerateOptions | string): Promise<GenerateResult>;
+    private executeGenerateWithMetricsContext;
+    private executeGenerateRequest;
+    private prepareGenerateRequest;
+    private maybeHandleEarlyGenerateResult;
+    private runStandardGenerateRequest;
+    private maybeApplyGenerateOrchestration;
+    private prepareGenerateAugmentations;
+    private buildGenerateTextOptions;
+    private finalizeGenerateRequestResult;
+    private emitGenerateErrorEvent;
     /**
      * Schedule non-blocking memory storage after generate completes.
      */
@@ -560,6 +576,13 @@ export declare class NeuroLink {
      * 5. Store conversation turn for future context
      */
     private generateTextInternal;
+    private executeGenerateTextInternalWithSpan;
+    private initializeGenerateTextInternalContext;
+    private runGenerateTextInternalFlow;
+    private captureOriginalConversationMessagesForRecovery;
+    private finalizeGenerateTextInternalResult;
+    private handleGenerateTextInternalFailure;
+    private tryRecoverGenerateTextOverflow;
     /**
      * Log generateTextInternal start with comprehensive analysis
      */
@@ -585,6 +608,11 @@ export declare class NeuroLink {
      * Try MCP-enhanced generation (no fallback recursion)
      */
     private tryMCPGeneration;
+    private prepareMCPGenerationContext;
+    private logMCPConversationSummary;
+    private ensureMCPGenerationBudget;
+    private compactMCPConversationForBudget;
+    private generateWithMCPProvider;
     /**
      * Direct provider generation (no MCP, no recursion)
      */
@@ -660,6 +688,10 @@ export declare class NeuroLink {
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     stream(options: StreamOptions): Promise<StreamResult>;
+    private executeStreamRequest;
+    private validateStreamRequestOptions;
+    private maybeHandleWorkflowStreamRequest;
+    private runStandardStreamRequest;
     /**
      * Prepare stream options: initialize memory, MCP, retrieval, orchestration,
      * Ollama tool auto-disable, factory processing, and tool detection.
@@ -1061,6 +1093,12 @@ export declare class NeuroLink {
             [key: string]: unknown;
         };
     }): Promise<T>;
+    private createToolExecutionContext;
+    private executeToolWithSpan;
+    private prepareToolExecutionState;
+    private runPreparedToolExecution;
+    private handleSuccessfulToolExecution;
+    private handleFailedToolExecution;
     /**
      * Internal tool execution method with MCP enhancements wired in:
      * - ToolCache: check/store cached results for non-destructive tools