@juspay/neurolink 7.29.1 → 7.29.3

package/dist/lib/mcp/registry.js

@@ -53,7 +53,7 @@ export class MCPRegistry {
     /**
      * Register a server (compatible with new interface)
      */
-    async registerServer(serverId, serverConfig, context) {
+    async registerServer(serverId, serverConfig, _context) {
         const plugin = {
             metadata: {
                 name: serverId,
@@ -74,14 +74,14 @@ export class MCPRegistry {
     /**
      * Execute a tool (mock implementation for tests)
      */
-    async executeTool(toolName, args, context) {
+    async executeTool(toolName, args, _context) {
         registryLogger.info(`Executing tool: ${toolName}`);
         return { result: `Mock execution of ${toolName}`, args };
     }
     /**
      * List all tools (compatible with new interface)
      */
-    async listTools(context) {
+    async listTools(_context) {
         const tools = this.list().map((plugin) => ({
             name: plugin.metadata.name,
             description: plugin.metadata.description || "No description",

package/dist/lib/mcp/servers/aiProviders/aiAnalysisTools.js

@@ -78,7 +78,7 @@ const OptimizeParametersSchema = z.object({
  * AI Usage Analysis Tool
  * Analyzes AI usage patterns, token consumption, and cost optimization opportunities
  */
-const analyzeAIUsageTool = {
+const _analyzeAIUsageTool = {
     name: "analyze-ai-usage",
     description: "Analyze AI usage patterns, token consumption, and cost optimization opportunities",
     category: "ai-analysis",
@@ -163,7 +163,7 @@ const analyzeAIUsageTool = {
  * Provider Performance Benchmarking Tool
  * Benchmarks AI provider performance across latency, quality, and cost metrics
  */
-const benchmarkProviderPerformanceTool = {
+const _benchmarkProviderPerformanceTool = {
     name: "benchmark-provider-performance",
     description: "Benchmark AI provider performance across latency, quality, and cost metrics",
     category: "ai-analysis",
@@ -199,7 +199,7 @@ const benchmarkProviderPerformanceTool = {
                         });
                         if (result && result.usage) {
                             totalLatency += Date.now() - testStartTime;
-                            totalTokens += result.usage.totalTokens || 0;
+                            totalTokens += result.usage.total || 0;
                             successfulTests++;
                         }
                     }
@@ -210,7 +210,7 @@ const benchmarkProviderPerformanceTool = {
                         avgLatency: successfulTests > 0
                             ? Math.round(totalLatency / successfulTests)
                             : 0,
-                        totalTokens: totalTokens,
+                        total: totalTokens,
                         successRate: (successfulTests /
                             (testPrompts.length * typedParams.iterations)) *
                             100,
@@ -259,7 +259,7 @@ const benchmarkProviderPerformanceTool = {
  * Prompt Parameter Optimization Tool
  * Optimizes prompt parameters (temperature, max tokens) for better AI output quality and efficiency
  */
-const optimizePromptParametersTool = {
+const _optimizePromptParametersTool = {
     name: "optimize-prompt-parameters",
     description: "Optimize prompt parameters (temperature, max tokens) for better AI output quality and efficiency",
     category: "ai-optimization",

package/dist/lib/mcp/servers/aiProviders/aiWorkflowTools.js

@@ -99,7 +99,7 @@ const debugAIOutputSchema = z.object({
 /**
  * Generate test cases for code functions
  */
-const generateTestCasesTool = {
+const _generateTestCasesTool = {
     name: "generate-test-cases",
     description: "Generate comprehensive test cases for code functions with various test types and frameworks",
     category: "ai-workflow",
@@ -203,7 +203,7 @@ Generate 3-5 comprehensive test cases covering the requested types.`;
 /**
  * Refactor code for improved quality
  */
-const refactorCodeTool = {
+const _refactorCodeTool = {
     name: "refactor-code",
     description: "AI-powered code refactoring for improved readability, performance, and maintainability",
     category: "ai-workflow",
@@ -316,7 +316,7 @@ Focus on real, actionable improvements based on the specified objectives.`;
 /**
  * Generate documentation from code
  */
-const generateDocumentationTool = {
+const _generateDocumentationTool = {
     name: "generate-documentation",
     description: "Automatically generate comprehensive documentation from code",
     category: "ai-workflow",
@@ -427,7 +427,7 @@ Focus on creating accurate, useful documentation that explains the code's purpos
 /**
  * Debug AI-generated output
  */
-const debugAIOutputTool = {
+const _debugAIOutputTool = {
     name: "debug-ai-output",
     description: "Analyze and debug AI-generated output to identify issues and suggest improvements",
     category: "ai-workflow",
@@ -549,13 +549,13 @@ Provide thorough, actionable analysis focused on improving AI output quality.`;
     },
 };
 // Helper functions
-function extractFunctionName(code) {
+function _extractFunctionName(code) {
     const match = code.match(/function\s+(\w+)|const\s+(\w+)\s*=|(\w+)\s*\(/);
     return match
         ? match[1] || match[2] || match[3] || "processData"
         : "processData";
 }
-function simulateRefactoring(code, objectives, styleGuide) {
+function _simulateRefactoring(code, objectives, _styleGuide) {
     // Simulate basic refactoring
     let refactored = code;
     if (objectives.includes("readability")) {

package/dist/lib/mcp/servers/utilities/utilityServer.js

@@ -61,7 +61,7 @@ utilityServer.registerTool({
                     });
                     resultData.actualTimezone = timezone;
                 }
-                catch (tzError) {
+                catch {
                     const fallbackTimezone = "Asia/Kolkata";
                     logger.warn(`[Utility] Invalid timezone '${timezone}', falling back to ${fallbackTimezone}`);
                     resultData.localTime = now.toLocaleString("en-US", {

package/dist/lib/mcp/toolDiscoveryService.js

@@ -6,7 +6,7 @@
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
 import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
-import { isObject, isNullish, } from "../utils/typeUtils.js";
+import { isObject, isNullish } from "../utils/typeUtils.js";
 import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
 /**
  * ToolDiscoveryService
@@ -133,6 +133,9 @@ export class ToolDiscoveryService extends EventEmitter {
                     this.serverToolStorage.set(serverId, []);
                 }
                 const serverTools = this.serverToolStorage.get(serverId);
+                if (!serverTools) {
+                    throw new Error(`Server tools storage not found for ${serverId}`);
+                }
                 // Add tool if not already present
                 if (!serverTools.find((t) => t.name === tool.name)) {
                     serverTools.push({
@@ -145,7 +148,10 @@ export class ToolDiscoveryService extends EventEmitter {
                 if (!this.serverTools.has(serverId)) {
                     this.serverTools.set(serverId, new Set());
                 }
-                this.serverTools.get(serverId).add(tool.name);
+                const serverToolSet = this.serverTools.get(serverId);
+                if (serverToolSet) {
+                    serverToolSet.add(tool.name);
+                }
                 registeredTools.push(toolInfo);
                 // Emit tool registered event
                 this.emit("toolRegistered", {

package/dist/lib/mcp/toolRegistry.d.ts

@@ -29,7 +29,7 @@ export interface ToolExecutionOptions {
 }
 export declare class MCPToolRegistry extends MCPRegistry {
     private tools;
-    private toolImpls;
+    private toolImplementations;
     private toolExecutionStats;
     private builtInServerInfos;
     constructor();
@@ -122,7 +122,7 @@ export declare class MCPToolRegistry extends MCPRegistry {
      * Register a tool with implementation directly
      * This is used for external MCP server tools
      */
-    registerTool(toolId: string, toolInfo: ToolInfo, toolImpl: ToolImplementation): void;
+    registerTool(toolId: string, toolInfo: ToolInfo, toolImpl: ToolImplementation): Promise<void>;
     /**
      * Remove a tool
      */

package/dist/lib/mcp/toolRegistry.js

@@ -8,9 +8,10 @@ import { randomUUID } from "crypto";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { directAgentTools } from "../agent/directTools.js";
 import { detectCategory, createMCPServerInfo } from "../utils/mcpDefaults.js";
+import { FlexibleToolValidator } from "./flexibleToolValidator.js";
 export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();
-    toolImpls = new Map(); // Store actual tool implementations
+    toolImplementations = new Map(); // Store actual tool implementations
     toolExecutionStats = new Map();
     builtInServerInfos = []; // DIRECT storage for MCPServerInfo
     constructor() {
@@ -38,7 +39,7 @@ export class MCPToolRegistry extends MCPRegistry {
                 category: detectCategory({ isBuiltIn: true, serverId: "direct" }),
             };
             this.tools.set(toolId, toolInfo);
-            this.toolImpls.set(toolId, {
+            this.toolImplementations.set(toolId, {
                 execute: async (params, context) => {
                     try {
                         // Direct tools from AI SDK expect their specific parameter structure
@@ -80,11 +81,11 @@ export class MCPToolRegistry extends MCPRegistry {
     async registerServer(serverInfoOrId, serverConfigOrContext, context) {
         // Handle both signatures for backward compatibility
         let serverInfo;
-        let finalContext;
+        let _finalContext;
         if (typeof serverInfoOrId === "string") {
             // Legacy signature: registerServer(serverId, serverConfig, context)
             const serverId = serverInfoOrId;
-            finalContext = context;
+            _finalContext = context;
             // Convert legacy call to MCPServerInfo format using smart defaults
             serverInfo = createMCPServerInfo({
                 id: serverId,
@@ -96,7 +97,7 @@ export class MCPToolRegistry extends MCPRegistry {
         else {
             // New signature: registerServer(serverInfo, context)
             serverInfo = serverInfoOrId;
-            finalContext = serverConfigOrContext;
+            _finalContext = serverConfigOrContext;
         }
         const serverId = serverInfo.id;
         registryLogger.info(`Registering MCPServerInfo directly: ${serverId}`);
@@ -153,7 +154,7 @@ export class MCPToolRegistry extends MCPRegistry {
             // Register only with fully-qualified toolId to avoid collisions
             this.tools.set(toolId, toolInfo);
             // Store the actual tool implementation for execution using toolId as key
-            this.toolImpls.set(toolId, {
+            this.toolImplementations.set(toolId, {
                 execute: tool.execute ||
                     (async () => {
                         throw new Error(`Tool ${tool.name} has no execute function`);
@@ -234,9 +235,9 @@ export class MCPToolRegistry extends MCPRegistry {
                 ...context,
             };
             // Get the tool implementation using the resolved toolId
-            const toolImpl = this.toolImpls.get(toolId);
+            const toolImpl = this.toolImplementations.get(toolId);
             registryLogger.debug(`Looking for tool '${toolName}' (toolId: '${toolId}'), found: ${!!toolImpl}, type: ${typeof toolImpl?.execute}`);
-            registryLogger.debug(`Available tools:`, Array.from(this.toolImpls.keys()));
+            registryLogger.debug(`Available tools:`, Array.from(this.toolImplementations.keys()));
             if (!toolImpl || typeof toolImpl?.execute !== "function") {
                 throw new Error(`Tool '${toolName}' implementation not found or not executable`);
             }
@@ -347,7 +348,7 @@ export class MCPToolRegistry extends MCPRegistry {
             if (filter.permissions && filter.permissions.length > 0) {
                 result = result.filter((tool) => {
                     const toolPermissions = tool.permissions || [];
-                    return filter.permissions.some((perm) => toolPermissions.includes(perm));
+                    return (filter.permissions?.some((perm) => toolPermissions.includes(perm)) ?? false);
                 });
             }
         }
@@ -450,55 +451,25 @@ export class MCPToolRegistry extends MCPRegistry {
      * Register a tool with implementation directly
      * This is used for external MCP server tools
      */
-    registerTool(toolId, toolInfo, toolImpl) {
+    async registerTool(toolId, toolInfo, toolImpl) {
         registryLogger.debug(`Registering tool: ${toolId}`);
-        // Import validation functions synchronously - they are pure functions
-        let validateTool;
-        let isToolNameAvailable;
-        let suggestToolNames;
-        try {
-            // Try ES module import first
-            const toolRegistrationModule = require("../sdk/toolRegistration.js");
-            ({ validateTool, isToolNameAvailable, suggestToolNames } =
-                toolRegistrationModule);
-        }
-        catch (error) {
-            // Fallback: skip validation if import fails (graceful degradation)
-            registryLogger.warn("Tool validation module not available, skipping advanced validation", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            // Create minimal validation functions
-            validateTool = () => { }; // No-op
-            isToolNameAvailable = () => true; // Allow all names
-            suggestToolNames = () => ["alternative_tool"];
-        }
-        // Check if tool name is available (not reserved)
-        if (!isToolNameAvailable(toolId)) {
-            const suggestions = suggestToolNames(toolId);
-            registryLogger.error(`Tool registration failed for ${toolId}: Name not available`);
-            throw new Error(`Tool name '${toolId}' is not available (reserved or invalid format). ` +
-                `Suggested alternatives: ${suggestions.slice(0, 3).join(", ")}`);
+        // Universal safety validation using FlexibleToolValidator
+        // Only blocks truly dangerous cases to support maximum MCP tool compatibility
+        const validation = FlexibleToolValidator.validateToolInfo(toolId, {
+            description: toolInfo.description,
+            serverId: toolInfo.serverId,
+        });
+        if (!validation.isValid) {
+            registryLogger.error(`Tool registration failed for ${toolId}: ${validation.error}`);
+            throw new Error(`Tool validation failed: ${validation.error}`);
         }
-        // Create a simplified tool object for validation
-        const toolForValidation = {
-            description: toolInfo.description || "",
-            execute: async () => "",
-            parameters: undefined,
-            metadata: {
-                category: toolInfo.category,
-                serverId: toolInfo.serverId,
-            },
-        };
-        // Use comprehensive validation logic
-        try {
-            validateTool(toolId, toolForValidation);
-        }
-        catch (error) {
-            registryLogger.error(`Tool registration failed for ${toolId}:`, error instanceof Error ? error.message : String(error));
-            throw error;
+        // Log any warnings but allow registration to proceed
+        if (validation.warnings && validation.warnings.length > 0) {
+            registryLogger.warn(`Tool registration warnings for ${toolId}:`, validation.warnings);
         }
+        registryLogger.debug(`✅ Tool '${toolId}' passed flexible validation - registration proceeding`);
         this.tools.set(toolId, toolInfo);
-        this.toolImpls.set(toolId, toolImpl);
+        this.toolImplementations.set(toolId, toolImpl);
         registryLogger.debug(`Successfully registered tool: ${toolId}`);
     }
     /**
@@ -509,6 +480,7 @@ export class MCPToolRegistry extends MCPRegistry {
         let removed = false;
         if (this.tools.has(toolName)) {
             this.tools.delete(toolName);
+            this.toolImplementations.delete(toolName); // Fix memory leak
             this.toolExecutionStats.delete(toolName);
             registryLogger.info(`Removed tool: ${toolName}`);
             removed = true;
@@ -518,6 +490,7 @@ export class MCPToolRegistry extends MCPRegistry {
             for (const [toolId, tool] of Array.from(this.tools.entries())) {
                 if (tool.name === toolName) {
                     this.tools.delete(toolId);
+                    this.toolImplementations.delete(toolId); // Fix memory leak
                     this.toolExecutionStats.delete(toolId);
                     registryLogger.info(`Removed tool: ${toolId}`);
                     removed = true;
@@ -567,6 +540,8 @@ export class MCPToolRegistry extends MCPRegistry {
         for (const [toolId, tool] of this.tools.entries()) {
             if (tool.serverId === serverId) {
                 this.tools.delete(toolId);
+                this.toolImplementations.delete(toolId); // Fix memory leak
+                this.toolExecutionStats.delete(toolId); // Fix memory leak
                 removedTools.push(toolId);
             }
         }

package/dist/lib/middleware/builtin/analytics.js

@@ -30,10 +30,10 @@ export function createAnalyticsMiddleware() {
                     responseTime,
                     timestamp: new Date().toISOString(),
                     usage: {
-                        inputTokens: result.usage?.promptTokens || 0,
-                        outputTokens: result.usage?.completionTokens || 0,
-                        totalTokens: (result.usage?.promptTokens || 0) +
-                            (result.usage?.completionTokens || 0),
+                        input: result.usage?.promptTokens ?? 0,
+                        output: result.usage?.completionTokens ?? 0,
+                        total: (result.usage?.promptTokens ?? 0) +
+                            (result.usage?.completionTokens ?? 0),
                     },
                 };
                 // Store metrics for potential retrieval

package/dist/lib/middleware/builtin/guardrails.js

@@ -13,7 +13,7 @@ export function createGuardrailsMiddleware(config = {}) {
         defaultEnabled: true,
     };
     const middleware = {
-        wrapGenerate: async ({ doGenerate, params }) => {
+        wrapGenerate: async ({ doGenerate, params: _params }) => {
             logger.debug(`[GuardrailsMiddleware] Applying to generate call.`, {
                 badWordsEnabled: !!config.badWords?.enabled,
                 modelFilterEnabled: !!config.modelFilter?.enabled,
@@ -53,7 +53,7 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             return result;
         },
-        wrapStream: async ({ doStream, params }) => {
+        wrapStream: async ({ doStream, params: _params }) => {
             logger.debug(`[GuardrailsMiddleware] Applying to stream call.`, {
                 badWordsEnabled: !!config.badWords?.enabled,
             });

package/dist/lib/middleware/registry.js

@@ -135,9 +135,9 @@ export class MiddlewareRegistry {
     /**
      * Configure middleware with runtime configuration
      */
-    configureMiddleware(middleware, config, globalConfig, context) {
+    configureMiddleware(middleware, config, globalConfig, _context) {
         // Merge configurations: global < middleware config < runtime config
-        const mergedConfig = {
+        const _mergedConfig = {
             ...globalConfig,
             ...config?.config,
         };
@@ -149,6 +149,9 @@ export class MiddlewareRegistry {
             wrappedMiddleware.transformParams = async (args) => {
                 const startTime = Date.now();
                 try {
+                    if (!middleware.transformParams) {
+                        throw new Error("transformParams method is required");
+                    }
                     const result = await middleware.transformParams(args);
                     this.recordExecution(middleware.metadata.id, startTime, true);
                     return result;
@@ -163,6 +166,9 @@ export class MiddlewareRegistry {
             wrappedMiddleware.wrapGenerate = async (args) => {
                 const startTime = Date.now();
                 try {
+                    if (!middleware.wrapGenerate) {
+                        throw new Error("wrapGenerate method is required");
+                    }
                     const result = await middleware.wrapGenerate(args);
                     this.recordExecution(middleware.metadata.id, startTime, true);
                     return result;
@@ -177,6 +183,9 @@ export class MiddlewareRegistry {
             wrappedMiddleware.wrapStream = async (args) => {
                 const startTime = Date.now();
                 try {
+                    if (!middleware.wrapStream) {
+                        throw new Error("wrapStream method is required");
+                    }
                     const result = await middleware.wrapStream(args);
                     this.recordExecution(middleware.metadata.id, startTime, true);
                     return result;

package/dist/lib/models/modelRegistry.d.ts

@@ -125,7 +125,7 @@ export declare function getAvailableProviders(): AIProviderName[];
 /**
  * Calculate estimated cost for a request
  */
-export declare function calculateCost(model: ModelInfo, inputTokens: number, outputTokens: number): number;
+export declare function calculateCost(model: ModelInfo, input: number, output: number): number;
 /**
  * Format model for display
  */

package/dist/lib/models/modelRegistry.js

@@ -445,9 +445,9 @@ export function getAvailableProviders() {
 /**
  * Calculate estimated cost for a request
  */
-export function calculateCost(model, inputTokens, outputTokens) {
-    const inputCost = (inputTokens / 1000) * model.pricing.inputCostPer1K;
-    const outputCost = (outputTokens / 1000) * model.pricing.outputCostPer1K;
+export function calculateCost(model, input, output) {
+    const inputCost = (input / 1000) * model.pricing.inputCostPer1K;
+    const outputCost = (output / 1000) * model.pricing.outputCostPer1K;
     return inputCost + outputCost;
 }
 /**

package/dist/lib/models/modelResolver.d.ts

@@ -76,7 +76,7 @@ export declare class ModelResolver {
     /**
      * Calculate cost comparison for models
      */
-    static calculateCostComparison(models: ModelInfo[], inputTokens?: number, outputTokens?: number): Array<{
+    static calculateCostComparison(models: ModelInfo[], input?: number, output?: number): Array<{
         model: ModelInfo;
         cost: number;
         costPer1K: number;

package/dist/lib/models/modelResolver.js

@@ -160,11 +160,11 @@ export class ModelResolver {
     /**
      * Calculate cost comparison for models
      */
-    static calculateCostComparison(models, inputTokens = 1000, outputTokens = 500) {
+    static calculateCostComparison(models, input = 1000, output = 500) {
         return models
             .map((model) => ({
             model,
-            cost: calculateCost(model, inputTokens, outputTokens),
+            cost: calculateCost(model, input, output),
             costPer1K: model.pricing.inputCostPer1K + model.pricing.outputCostPer1K,
         }))
             .sort((a, b) => a.cost - b.cost);

package/dist/lib/neurolink.d.ts

@@ -54,6 +54,8 @@ export declare class NeuroLink {
      * @param toolName - Name of the tool
      * @param startTime - Timestamp when tool execution started
      * @param success - Whether the tool execution was successful
+     * @param result - The result of the tool execution (optional)
+     * @param error - The error if execution failed (optional)
      */
     private emitToolEndEvent;
     private conversationMemory?;
@@ -88,11 +90,71 @@ export declare class NeuroLink {
     constructor(config?: {
         conversationMemory?: Partial<ConversationMemoryConfig>;
     });
+    /**
+     * Log constructor start with comprehensive environment analysis
+     */
+    private logConstructorStart;
+    /**
+     * Initialize provider registry with security settings
+     */
+    private initializeProviderRegistry;
+    /**
+     * Initialize conversation memory if enabled
+     */
+    private initializeConversationMemory;
+    /**
+     * Initialize external server manager with event handlers
+     */
+    private initializeExternalServerManager;
+    /**
+     * Setup event handlers for external server manager
+     */
+    private setupExternalServerEventHandlers;
+    /**
+     * Log constructor completion with final state summary
+     */
+    private logConstructorComplete;
     /**
      * Initialize MCP registry with enhanced error handling and resource cleanup
      * 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
+     */
+    private importPerformanceManager;
+    /**
+     * Perform main MCP initialization logic
+     */
+    private performMCPInitialization;
+    /**
+     * Initialize tool registry with timeout protection
+     */
+    private initializeToolRegistryInternal;
+    /**
+     * Initialize provider registry
+     */
+    private initializeProviderRegistryInternal;
+    /**
+     * Register direct tools server
+     */
+    private registerDirectToolsServerInternal;
+    /**
+     * Load MCP configuration from .mcp-config.json
+     */
+    private loadMCPConfigurationInternal;
+    /**
+     * Log MCP initialization completion
+     */
+    private logMCPInitComplete;
     /**
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods
@@ -177,6 +239,26 @@ export declare class NeuroLink {
      * 5. Store conversation turn for future context
      */
     private generateTextInternal;
+    /**
+     * Log generateTextInternal start with comprehensive analysis
+     */
+    private logGenerateTextInternalStart;
+    /**
+     * Emit generation start events
+     */
+    private emitGenerationStartEvents;
+    /**
+     * Initialize conversation memory for generation
+     */
+    private initializeConversationMemoryForGeneration;
+    /**
+     * Attempt MCP generation with retry logic
+     */
+    private attemptMCPGeneration;
+    /**
+     * Perform MCP generation with retry logic
+     */
+    private performMCPGenerationRetries;
     /**
      * Try MCP-enhanced generation (no fallback recursion)
      */
@@ -255,6 +337,42 @@ 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
+     */
+    private validateStreamInput;
+    /**
+     * Emit stream start events
+     */
+    private emitStreamStartEvents;
+    /**
+     * Create MCP stream
+     */
+    private createMCPStream;
+    /**
+     * Process stream result
+     */
+    private processStreamResult;
+    /**
+     * Emit stream end events
+     */
+    private emitStreamEndEvents;
+    /**
+     * Create stream response
+     */
+    private createStreamResponse;
+    /**
+     * Handle stream error with fallback
+     */
+    private handleStreamError;
     /**
      * Get the EventEmitter instance to listen to NeuroLink events for real-time monitoring and debugging.
      * This method provides access to the internal event system that emits events during AI generation,