@juspay/neurolink 7.49.0 → 7.51.0

package/dist/mcp/servers/agent/directToolsServer.js

@@ -2,6 +2,7 @@
  * NeuroLink Direct Tools Server
  * Wraps the agent direct tools as an MCP server for proper registration
  */
+import { z } from "zod";
 import { createMCPServer } from "../../factory.js";
 import { directAgentTools } from "../../../agent/directTools.js";
 import { logger } from "../../../utils/logger.js";

package/dist/models/modelResolver.js

@@ -3,6 +3,7 @@
  * Provides model resolution, search, and recommendation functionality
  * Part of Phase 4.1 - Models Command System
  */
+import { AIProviderName } from "../types/index.js";
 import { MODEL_REGISTRY, MODEL_ALIASES, USE_CASE_RECOMMENDATIONS, getAllModels, getModelById, getModelsByProvider, getAvailableProviders, calculateCost, formatModelForDisplay, } from "./modelRegistry.js";
 import { isNonNullObject } from "../utils/typeUtils.js";
 /**

package/dist/neurolink.d.ts

@@ -19,6 +19,17 @@ import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import type { HITLConfig } from "./hitl/types.js";
 import type { ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
+import type { ObservabilityConfig } from "./types/observability.js";
+/**
+ * Configuration object for NeuroLink constructor.
+ */
+export interface NeurolinkConstructorConfig {
+    conversationMemory?: Partial<ConversationMemoryConfig>;
+    enableOrchestration?: boolean;
+    hitl?: HITLConfig;
+    toolRegistry?: MCPToolRegistry;
+    observability?: ObservabilityConfig;
+}
 export interface ProviderStatus {
     provider: string;
     status: "working" | "failed" | "not-configured";
@@ -138,12 +149,8 @@ export declare class NeuroLink {
      * @throws {Error} When external server manager initialization fails
      * @throws {Error} When HITL configuration is invalid (if enabled)
      */
-    constructor(config?: {
-        conversationMemory?: Partial<ConversationMemoryConfig>;
-        enableOrchestration?: boolean;
-        hitl?: HITLConfig;
-        toolRegistry?: MCPToolRegistry;
-    });
+    private observabilityConfig?;
+    constructor(config?: NeurolinkConstructorConfig);
     /**
      * Initialize provider registry with security settings
      */
@@ -170,6 +177,10 @@ export declare class NeuroLink {
      * Setup event handlers for external server manager
      */
     private setupExternalServerEventHandlers;
+    /**
+     * Initialize Langfuse observability for AI operations tracking
+     */
+    private initializeLangfuse;
     /**
      * Log constructor completion with final state summary
      */
@@ -279,6 +290,24 @@ export declare class NeuroLink {
      * @throws {Error} When all providers fail to generate content
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
+    /**
+     * Get observability configuration
+     */
+    getObservabilityConfig(): ObservabilityConfig | undefined;
+    /**
+     * Check if Langfuse telemetry is enabled
+     * Centralized utility to avoid duplication across providers
+     */
+    isTelemetryEnabled(): boolean;
+    /**
+     * Public method to initialize Langfuse observability
+     * This method can be called externally to ensure Langfuse is properly initialized
+     */
+    initializeLangfuseObservability(): Promise<void>;
+    /**
+     * Gracefully shutdown NeuroLink and all MCP connections
+     */
+    shutdown(): Promise<void>;
     generate(optionsOrPrompt: GenerateOptions | string): Promise<GenerateResult>;
     /**
      * BACKWARD COMPATIBILITY: Legacy generateText method
@@ -1047,6 +1076,12 @@ export declare class NeuroLink {
      * Unregister all external MCP tools from the main registry
      */
     private unregisterAllExternalMCPToolsFromRegistry;
+    /**
+     * Dispose of all resources and cleanup connections
+     * Call this method when done using the NeuroLink instance to prevent resource leaks
+     * Especially important in test environments where multiple instances are created
+     */
+    dispose(): Promise<void>;
 }
 export declare const neurolink: NeuroLink;
 export default neurolink;

package/dist/neurolink.js

@@ -31,6 +31,8 @@ import { transformToolExecutions, transformToolExecutionsForMCP, transformAvaila
 // Enhanced error handling imports
 import { ErrorFactory, NeuroLinkError, withTimeout, withRetry, isRetriableError, logStructuredError, CircuitBreaker, } from "./utils/errorHandling.js";
 import { EventEmitter } from "events";
+import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
+import { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { getConversationMessages, storeConversationTurn, } from "./utils/conversationMemory.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { HITLManager } from "./hitl/hitlManager.js";
@@ -39,6 +41,7 @@ import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
 // Import orchestration components
 import { ModelRouter } from "./utils/modelRouter.js";
 import { BinaryTaskClassifier } from "./utils/taskClassifier.js";
+import { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, } from "./services/server/ai/observability/instrumentation.js";
 import { isNonNullObject } from "./utils/typeUtils.js";
 import { isZodSchema } from "./utils/schemaConversion.js";
 // Core types imported from "./types/index.js"
@@ -178,8 +181,10 @@ export class NeuroLink {
      * @throws {Error} When external server manager initialization fails
      * @throws {Error} When HITL configuration is invalid (if enabled)
      */
+    observabilityConfig;
     constructor(config) {
         this.toolRegistry = config?.toolRegistry || new MCPToolRegistry();
+        this.observabilityConfig = config?.observability;
         // Initialize orchestration setting
         this.enableOrchestration = config?.enableOrchestration ?? false;
         // Read tool cache duration from environment variables, with a default
@@ -194,6 +199,7 @@ export class NeuroLink {
         this.initializeConversationMemory(config, constructorId, constructorStartTime, constructorHrTimeStart);
         this.initializeExternalServerManager(constructorId, constructorStartTime, constructorHrTimeStart);
         this.initializeHITL(config, constructorId, constructorStartTime, constructorHrTimeStart);
+        this.initializeLangfuse(constructorId, constructorStartTime, constructorHrTimeStart);
         this.logConstructorComplete(constructorId, constructorStartTime, constructorHrTimeStart);
     }
     /**
@@ -494,6 +500,81 @@ export class NeuroLink {
             this.unregisterExternalMCPToolFromRegistry(event.toolName);
         });
     }
+    /**
+     * Initialize Langfuse observability for AI operations tracking
+     */
+    initializeLangfuse(constructorId, constructorStartTime, constructorHrTimeStart) {
+        const langfuseInitStartTime = process.hrtime.bigint();
+        try {
+            const langfuseConfig = this.observabilityConfig?.langfuse;
+            if (langfuseConfig?.enabled) {
+                logger.debug(`[NeuroLink] 📊 LOG_POINT_C019_LANGFUSE_INIT_START`, {
+                    logPoint: "C019_LANGFUSE_INIT_START",
+                    constructorId,
+                    timestamp: new Date().toISOString(),
+                    elapsedMs: Date.now() - constructorStartTime,
+                    elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                    langfuseInitStartTimeNs: langfuseInitStartTime.toString(),
+                    message: "Starting Langfuse observability initialization",
+                });
+                // Initialize OpenTelemetry FIRST (required for Langfuse v4)
+                initializeOpenTelemetry(langfuseConfig);
+                const healthStatus = getLangfuseHealthStatus();
+                const langfuseInitDurationNs = process.hrtime.bigint() - langfuseInitStartTime;
+                if (healthStatus.initialized &&
+                    healthStatus.hasProcessor &&
+                    healthStatus.isHealthy) {
+                    logger.debug(`[NeuroLink] ✅ LOG_POINT_C020_LANGFUSE_INIT_SUCCESS`, {
+                        logPoint: "C020_LANGFUSE_INIT_SUCCESS",
+                        constructorId,
+                        timestamp: new Date().toISOString(),
+                        elapsedMs: Date.now() - constructorStartTime,
+                        elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                        langfuseInitDurationNs: langfuseInitDurationNs.toString(),
+                        langfuseInitDurationMs: Number(langfuseInitDurationNs) / 1_000_000,
+                        healthStatus,
+                        message: "Langfuse observability initialized successfully",
+                    });
+                }
+                else {
+                    logger.warn(`[NeuroLink] ⚠️ LOG_POINT_C021_LANGFUSE_INIT_WARNING`, {
+                        logPoint: "C021_LANGFUSE_INIT_WARNING",
+                        constructorId,
+                        timestamp: new Date().toISOString(),
+                        elapsedMs: Date.now() - constructorStartTime,
+                        elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                        langfuseInitDurationNs: langfuseInitDurationNs.toString(),
+                        healthStatus,
+                        message: "Langfuse initialized but not healthy",
+                    });
+                }
+            }
+            else {
+                logger.debug(`[NeuroLink] 🚫 LOG_POINT_C022_LANGFUSE_DISABLED`, {
+                    logPoint: "C022_LANGFUSE_DISABLED",
+                    constructorId,
+                    timestamp: new Date().toISOString(),
+                    elapsedMs: Date.now() - constructorStartTime,
+                    elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                    message: "Langfuse observability not enabled - skipping initialization",
+                });
+            }
+        }
+        catch (error) {
+            const langfuseInitErrorDurationNs = process.hrtime.bigint() - langfuseInitStartTime;
+            logger.error(`[NeuroLink] ❌ LOG_POINT_C023_LANGFUSE_INIT_ERROR`, {
+                logPoint: "C023_LANGFUSE_INIT_ERROR",
+                constructorId,
+                timestamp: new Date().toISOString(),
+                elapsedMs: Date.now() - constructorStartTime,
+                elapsedNs: (process.hrtime.bigint() - constructorHrTimeStart).toString(),
+                langfuseInitDurationNs: langfuseInitErrorDurationNs.toString(),
+                errorMessage: error instanceof Error ? error.message : String(error),
+                errorStack: error instanceof Error ? error.stack : undefined,
+                message: "Langfuse observability initialization failed",
+            });
+        }
+    }
     /**
      * Log constructor completion with final state summary
      */
@@ -992,6 +1073,68 @@ export class NeuroLink {
      * @throws {Error} When all providers fail to generate content
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
+    /**
+     * Get observability configuration
+     */
+    getObservabilityConfig() {
+        return this.observabilityConfig;
+    }
+    /**
+     * Check if Langfuse telemetry is enabled
+     * Centralized utility to avoid duplication across providers
+     */
+    isTelemetryEnabled() {
+        return this.observabilityConfig?.langfuse?.enabled || false;
+    }
+    /**
+     * Public method to initialize Langfuse observability
+     * This method can be called externally to ensure Langfuse is properly initialized
+     */
+    async initializeLangfuseObservability() {
+        try {
+            const langfuseConfig = this.observabilityConfig?.langfuse;
+            if (langfuseConfig?.enabled) {
+                initializeOpenTelemetry(langfuseConfig);
+                logger.debug("[NeuroLink] Langfuse observability initialized via public method");
+            }
+            else {
+                logger.debug("[NeuroLink] Langfuse not enabled, skipping initialization");
+            }
+        }
+        catch (error) {
+            logger.warn("[NeuroLink] Failed to initialize Langfuse observability:", error);
+        }
+    }
+    /**
+     * Gracefully shutdown NeuroLink and all MCP connections
+     */
+    async shutdown() {
+        try {
+            logger.debug("[NeuroLink] Starting graceful shutdown");
+            try {
+                await flushOpenTelemetry();
+                await shutdownOpenTelemetry();
+                logger.debug("[NeuroLink] OpenTelemetry shutdown completed");
+            }
+            catch (error) {
+                logger.warn("[NeuroLink] OpenTelemetry shutdown failed:", error);
+            }
+            if (this.externalServerManager) {
+                try {
+                    await this.externalServerManager.shutdown();
+                    logger.debug("[NeuroLink] MCP servers shutdown completed");
+                }
+                catch (error) {
+                    logger.warn("[NeuroLink] MCP servers shutdown failed:", error);
+                }
+            }
+            logger.debug("[NeuroLink] Graceful shutdown completed");
+        }
+        catch (error) {
+            logger.error("[NeuroLink] Shutdown failed:", error);
+            throw error;
+        }
+    }
     async generate(optionsOrPrompt) {
         const originalPrompt = this._extractOriginalPrompt(optionsOrPrompt);
         // Convert string prompt to full options
@@ -1910,15 +2053,16 @@ export class NeuroLink {
             customTools: this.getCustomTools(),
             executeTool: this.executeTool.bind(this),
         }, "NeuroLink.createMCPStream");
-        // Get conversation messages for context by creating a minimal TextGenerationOptions object
+        // Get conversation messages for context
         const conversationMessages = await getConversationMessages(this.conversationMemory, {
             prompt: options.input.text,
             context: options.context,
         });
-        // Pass conversation history to stream just like in generate method
+        // Let provider handle tools and system prompt automatically via Vercel AI SDK
+        // This ensures proper tool integration in stream mode
         const streamResult = await provider.stream({
             ...options,
-            conversationMessages, // Inject conversation history
+            conversationMessages,
         });
         return { stream: streamResult.stream, provider: providerName };
     }
@@ -1979,7 +2123,7 @@ export class NeuroLink {
         const originalPrompt = options.input.text;
         const responseTime = Date.now() - startTime;
         const providerName = await getBestProvider(options.provider);
-        const provider = await AIProviderFactory.createProvider(providerName, options.model, false);
+        const provider = await AIProviderFactory.createProvider(providerName, options.model);
         const fallbackStreamResult = await provider.stream({
             input: { text: options.input.text },
             model: options.model,
@@ -3189,7 +3333,7 @@ export class NeuroLink {
      */
     async testProviderConnection(providerName) {
         const { AIProviderFactory } = await import("./core/factory.js");
-        const provider = await AIProviderFactory.createProvider(providerName, null, false);
+        const provider = await AIProviderFactory.createProvider(providerName, null);
         await provider.generate({
             prompt: "test",
             maxTokens: 1,
@@ -3991,6 +4135,132 @@ export class NeuroLink {
             mcpLogger.error("[NeuroLink] Failed to unregister all external MCP tools from registry:", error);
         }
     }
+    /**
+     * Dispose of all resources and cleanup connections
+     * Call this method when done using the NeuroLink instance to prevent resource leaks
+     * Especially important in test environments where multiple instances are created
+     */
+    async dispose() {
+        logger.debug("[NeuroLink] Starting disposal of resources...");
+        const cleanupErrors = [];
+        try {
+            // 1. Flush and shutdown OpenTelemetry
+            try {
+                logger.debug("[NeuroLink] Flushing and shutting down OpenTelemetry...");
+                await flushOpenTelemetry();
+                await shutdownOpenTelemetry();
+                logger.debug("[NeuroLink] OpenTelemetry shutdown successfully");
+            }
+            catch (error) {
+                const err = error instanceof Error
+                    ? error
+                    : new Error(`OpenTelemetry shutdown error: ${String(error)}`);
+                cleanupErrors.push(err);
+                logger.warn("[NeuroLink] Error shutting down OpenTelemetry:", error);
+            }
+            // 2. Shutdown external MCP server connections
+            if (this.externalServerManager) {
+                try {
+                    logger.debug("[NeuroLink] Shutting down external MCP servers...");
+                    await this.externalServerManager.shutdown();
+                    logger.debug("[NeuroLink] External MCP servers shutdown successfully");
+                }
+                catch (error) {
+                    const err = error instanceof Error
+                        ? error
+                        : new Error(`External server shutdown error: ${String(error)}`);
+                    cleanupErrors.push(err);
+                    logger.warn("[NeuroLink] Error shutting down external MCP servers:", error);
+                }
+            }
+            // 3. Clear all event listeners to prevent memory leaks
+            if (this.emitter) {
+                try {
+                    logger.debug("[NeuroLink] Removing all event listeners...");
+                    this.emitter.removeAllListeners();
+                    logger.debug("[NeuroLink] Event listeners removed successfully");
+                }
+                catch (error) {
+                    const err = error instanceof Error
+                        ? error
+                        : new Error(`Event emitter cleanup error: ${String(error)}`);
+                    cleanupErrors.push(err);
+                    logger.warn("[NeuroLink] Error removing event listeners:", error);
+                }
+            }
+            // 4. Clear all circuit breakers
+            if (this.toolCircuitBreakers && this.toolCircuitBreakers.size > 0) {
+                try {
+                    logger.debug(`[NeuroLink] Clearing ${this.toolCircuitBreakers.size} circuit breakers...`);
+                    this.toolCircuitBreakers.clear();
+                    logger.debug("[NeuroLink] Circuit breakers cleared successfully");
+                }
+                catch (error) {
+                    const err = error instanceof Error
+                        ? error
+                        : new Error(`Circuit breaker cleanup error: ${String(error)}`);
+                    cleanupErrors.push(err);
+                    logger.warn("[NeuroLink] Error clearing circuit breakers:", error);
+                }
+            }
+            // 5. Clear all Maps and caches
+            try {
+                logger.debug("[NeuroLink] Clearing maps and caches...");
+                if (this.toolExecutionMetrics) {
+                    this.toolExecutionMetrics.clear();
+                }
+                if (this.activeToolExecutions) {
+                    this.activeToolExecutions.clear();
+                }
+                if (this.currentStreamToolExecutions) {
+                    this.currentStreamToolExecutions.length = 0;
+                }
+                if (this.toolExecutionHistory) {
+                    this.toolExecutionHistory.length = 0;
+                }
+                // Clear tool cache
+                if (this.toolCache) {
+                    this.toolCache.tools = [];
+                    this.toolCache.timestamp = 0;
+                }
+                logger.debug("[NeuroLink] Maps and caches cleared successfully");
+            }
+            catch (error) {
+                const err = error instanceof Error
+                    ? error
+                    : new Error(`Cache cleanup error: ${String(error)}`);
+                cleanupErrors.push(err);
+                logger.warn("[NeuroLink] Error clearing caches:", error);
+            }
+            // 6. Reset initialization flags
+            try {
+                logger.debug("[NeuroLink] Resetting initialization state...");
+                this.mcpInitialized = false;
+                this.conversationMemoryNeedsInit = false;
+                logger.debug("[NeuroLink] Initialization state reset successfully");
+            }
+            catch (error) {
+                const err = error instanceof Error
+                    ? error
+                    : new Error(`State reset error: ${String(error)}`);
+                cleanupErrors.push(err);
+                logger.warn("[NeuroLink] Error resetting state:", error);
+            }
+            // 6. Log completion
+            if (cleanupErrors.length === 0) {
+                logger.debug("[NeuroLink] ✅ Resource disposal completed successfully");
+            }
+            else {
+                logger.warn(`[NeuroLink] ⚠️ Resource disposal completed with ${cleanupErrors.length} errors`, {
+                    errors: cleanupErrors.map((e) => e.message),
+                });
+            }
+        }
+        catch (error) {
+            logger.error("[NeuroLink] Critical error during disposal:", error);
+            throw error;
+        }
+    }
 }
 // Create default instance
 export const neurolink = new NeuroLink();

package/dist/providers/amazonBedrock.d.ts

@@ -24,6 +24,7 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     private executeSingleTool;
     private convertAISDKToolsToToolDefinitions;
     private formatToolsForBedrock;
+    private convertToBedrockMessages;
     getBedrockClient(): BedrockRuntimeClient;
     protected executeStream(options: StreamOptions): Promise<StreamResult>;
     private streamingConversationLoop;