@juspay/neurolink 7.38.1 → 7.40.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [7.40.0](https://github.com/juspay/neurolink/compare/v7.39.0...v7.40.0) (2025-09-17)
+
+### Features
+
+- **(envsetup):** Added env setup test ([d08917e](https://github.com/juspay/neurolink/commit/d08917e69675aedd468c25697250c24fbfa21372))
+
+## [7.39.0](https://github.com/juspay/neurolink/compare/v7.38.1...v7.39.0) (2025-09-16)
+
+### Features
+
+- **(hitl):** Implemented human in the loop for sdk ([1a66f53](https://github.com/juspay/neurolink/commit/1a66f533d4d92fb33d203947a4c6648a72db631c))
+
 ## [7.38.1](https://github.com/juspay/neurolink/compare/v7.38.0...v7.38.1) (2025-09-16)
 
 ### Bug Fixes

package/README.md

@@ -307,6 +307,18 @@ echo 'GOOGLE_VERTEX_LOCATION="us-central1"' >> .env
 
 # Test configuration
 npx @juspay/neurolink status
+
+# SDK Env Provider Check - Advanced provider testing with fallback detection
+pnpm run test:providers
+```
+
+#### 🔍 SDK Env Provider Check Output
+
+```bash
+# Example output:
+✅ Google AI: Working (197 tokens)
+⚠️  OpenAI: Failed (Fallback to google-ai)
+⚠️  AWS Bedrock: Failed (Fallback to google-ai)
 ```
 
 ### JSON Format Support (Complete)

package/dist/hitl/hitlErrors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * HITL (Human-in-the-Loop) Error Classes
+ *
+ * Provides structured error handling for HITL safety mechanisms.
+ * These errors allow applications to distinguish between different
+ * types of HITL failures and handle them appropriately.
+ */
+/**
+ * Base class for all HITL-related errors
+ */
+export declare class HITLError extends Error {
+    readonly confirmationId?: string | undefined;
+    constructor(message: string, confirmationId?: string | undefined);
+}
+/**
+ * Thrown when a user explicitly rejects a tool execution request
+ * This indicates the HITL system worked correctly - the user saw the request
+ * and made a conscious decision to deny it.
+ */
+export declare class HITLUserRejectedError extends HITLError {
+    readonly toolName: string;
+    readonly reason?: string | undefined;
+    constructor(message: string, toolName: string, reason?: string | undefined, confirmationId?: string);
+}
+/**
+ * Thrown when a confirmation request times out without user response
+ * This indicates the user didn't respond within the configured timeout period.
+ */
+export declare class HITLTimeoutError extends HITLError {
+    readonly timeout: number;
+    constructor(message: string, confirmationId: string, timeout: number);
+}
+/**
+ * Thrown when HITL configuration is invalid or missing required properties
+ */
+export declare class HITLConfigurationError extends HITLError {
+    constructor(message: string);
+}

package/dist/hitl/hitlErrors.js

@@ -0,0 +1,54 @@
+/**
+ * HITL (Human-in-the-Loop) Error Classes
+ *
+ * Provides structured error handling for HITL safety mechanisms.
+ * These errors allow applications to distinguish between different
+ * types of HITL failures and handle them appropriately.
+ */
+/**
+ * Base class for all HITL-related errors
+ */
+export class HITLError extends Error {
+    confirmationId;
+    constructor(message, confirmationId) {
+        super(message);
+        this.confirmationId = confirmationId;
+        this.name = "HITLError";
+    }
+}
+/**
+ * Thrown when a user explicitly rejects a tool execution request
+ * This indicates the HITL system worked correctly - the user saw the request
+ * and made a conscious decision to deny it.
+ */
+export class HITLUserRejectedError extends HITLError {
+    toolName;
+    reason;
+    constructor(message, toolName, reason, confirmationId) {
+        super(message, confirmationId);
+        this.toolName = toolName;
+        this.reason = reason;
+        this.name = "HITLUserRejectedError";
+    }
+}
+/**
+ * Thrown when a confirmation request times out without user response
+ * This indicates the user didn't respond within the configured timeout period.
+ */
+export class HITLTimeoutError extends HITLError {
+    timeout;
+    constructor(message, confirmationId, timeout) {
+        super(message, confirmationId);
+        this.timeout = timeout;
+        this.name = "HITLTimeoutError";
+    }
+}
+/**
+ * Thrown when HITL configuration is invalid or missing required properties
+ */
+export class HITLConfigurationError extends HITLError {
+    constructor(message) {
+        super(message);
+        this.name = "HITLConfigurationError";
+    }
+}

package/dist/hitl/hitlManager.d.ts

@@ -0,0 +1,100 @@
+/**
+ * HITL (Human-in-the-Loop) Manager
+ *
+ * Central orchestrator for all HITL confirmation workflows.
+ * Manages user confirmation requests, timeouts, and argument modifications
+ * for enterprise-grade AI safety.
+ */
+import { EventEmitter } from "events";
+import type { HITLConfig, ConfirmationResult, HITLStatistics } from "./types.js";
+/**
+ * HITLManager - Central orchestrator for Human-in-the-Loop safety mechanisms
+ *
+ * Features:
+ * - Real-time user confirmation via events
+ * - Configurable dangerous action detection
+ * - Custom rule engine for complex scenarios
+ * - Argument modification support
+ * - Comprehensive audit logging
+ * - Timeout handling with cleanup
+ */
+export declare class HITLManager extends EventEmitter {
+    private config;
+    private pendingConfirmations;
+    private statistics;
+    constructor(config: HITLConfig);
+    /**
+     * Validate HITL configuration and apply defaults
+     */
+    private validateConfig;
+    /**
+     * Check if a tool requires confirmation based on configuration
+     */
+    requiresConfirmation(toolName: string, args?: unknown): boolean;
+    /**
+     * Request confirmation for a tool execution
+     */
+    requestConfirmation(toolName: string, arguments_: unknown, context?: {
+        serverId?: string;
+        sessionId?: string;
+        userId?: string;
+    }): Promise<ConfirmationResult>;
+    /**
+     * Process user response to confirmation request
+     */
+    processUserResponse(confirmationId: string, response: {
+        approved: boolean;
+        reason?: string;
+        modifiedArguments?: unknown;
+        responseTime?: number;
+        userId?: string;
+    }): void;
+    /**
+     * Handle confirmation timeout
+     */
+    private handleTimeout;
+    /**
+     * Set up event handlers for processing responses
+     */
+    private setupEventHandlers;
+    /**
+     * Generate unique confirmation ID
+     */
+    private generateConfirmationId;
+    /**
+     * Generate human-readable action description
+     */
+    private generateActionDescription;
+    /**
+     * Get keywords that triggered HITL
+     */
+    private getTriggeredKeywords;
+    /**
+     * Log audit events for compliance and debugging
+     */
+    private logAuditEvent;
+    /**
+     * Get current HITL usage statistics
+     */
+    getStatistics(): HITLStatistics;
+    /**
+     * Get current configuration
+     */
+    getConfig(): HITLConfig;
+    /**
+     * Update configuration (for dynamic reconfiguration)
+     */
+    updateConfig(newConfig: Partial<HITLConfig>): void;
+    /**
+     * Clean up resources and reject pending confirmations
+     */
+    cleanup(): void;
+    /**
+     * Check if manager is currently enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get count of pending confirmations
+     */
+    getPendingCount(): number;
+}

package/dist/hitl/hitlManager.js

@@ -0,0 +1,457 @@
+/**
+ * HITL (Human-in-the-Loop) Manager
+ *
+ * Central orchestrator for all HITL confirmation workflows.
+ * Manages user confirmation requests, timeouts, and argument modifications
+ * for enterprise-grade AI safety.
+ */
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+import { HITLTimeoutError, HITLConfigurationError } from "./hitlErrors.js";
+import { logger } from "../utils/logger.js";
+/**
+ * HITLManager - Central orchestrator for Human-in-the-Loop safety mechanisms
+ *
+ * Features:
+ * - Real-time user confirmation via events
+ * - Configurable dangerous action detection
+ * - Custom rule engine for complex scenarios
+ * - Argument modification support
+ * - Comprehensive audit logging
+ * - Timeout handling with cleanup
+ */
+export class HITLManager extends EventEmitter {
+    config;
+    pendingConfirmations = new Map();
+    statistics = {
+        totalRequests: 0,
+        pendingRequests: 0,
+        averageResponseTime: 0,
+        approvedRequests: 0,
+        rejectedRequests: 0,
+        timedOutRequests: 0,
+    };
+    constructor(config) {
+        super();
+        this.config = this.validateConfig(config);
+        this.setupEventHandlers();
+    }
+    /**
+     * Validate HITL configuration and apply defaults
+     */
+    validateConfig(config) {
+        // Apply defaults for optional fields
+        const configWithDefaults = {
+            enabled: config.enabled,
+            dangerousActions: config.dangerousActions,
+            timeout: config.timeout ?? 30000, // Default: 30 seconds
+            confirmationMethod: config.confirmationMethod ?? "event", // Default: "event"
+            allowArgumentModification: config.allowArgumentModification ?? true, // Default: true
+            autoApproveOnTimeout: config.autoApproveOnTimeout ?? false, // Default: false (safe)
+            auditLogging: config.auditLogging ?? false, // Default: false
+            customRules: config.customRules ?? [], // Default: empty array
+        };
+        if (!configWithDefaults.enabled) {
+            return configWithDefaults; // If disabled, don't validate other fields
+        }
+        if (!Array.isArray(configWithDefaults.dangerousActions)) {
+            throw new HITLConfigurationError("dangerousActions must be an array of strings");
+        }
+        if (typeof configWithDefaults.timeout !== "number" ||
+            configWithDefaults.timeout <= 0) {
+            throw new HITLConfigurationError("timeout must be a positive number (milliseconds)");
+        }
+        if (configWithDefaults.confirmationMethod !== "event") {
+            throw new HITLConfigurationError("confirmationMethod must be 'event' (only supported method)");
+        }
+        if (typeof configWithDefaults.allowArgumentModification !== "boolean") {
+            throw new HITLConfigurationError("allowArgumentModification must be a boolean");
+        }
+        return configWithDefaults;
+    }
+    /**
+     * Check if a tool requires confirmation based on configuration
+     */
+    requiresConfirmation(toolName, args) {
+        if (!this.config.enabled) {
+            return false;
+        }
+        // Check dangerous actions keywords
+        const lowerToolName = toolName.toLowerCase();
+        for (const action of this.config.dangerousActions) {
+            if (lowerToolName.includes(action.toLowerCase())) {
+                return true;
+            }
+        }
+        // Check custom rules
+        if (this.config.customRules) {
+            for (const rule of this.config.customRules) {
+                if (rule.requiresConfirmation) {
+                    try {
+                        if (rule.condition(toolName, args)) {
+                            return true;
+                        }
+                    }
+                    catch (error) {
+                        // Log rule evaluation error but don't fail
+                        this.logAuditEvent("rule-evaluation-error", {
+                            ruleName: rule.name,
+                            toolName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Request confirmation for a tool execution
+     */
+    async requestConfirmation(toolName, arguments_, context) {
+        const confirmationId = this.generateConfirmationId();
+        const startTime = Date.now();
+        // Update statistics
+        this.statistics.totalRequests++;
+        this.statistics.pendingRequests++;
+        return new Promise((resolve, reject) => {
+            // Set up timeout
+            const timeoutHandle = setTimeout(() => {
+                this.handleTimeout(confirmationId);
+            }, this.config.timeout);
+            // Store pending confirmation
+            const request = {
+                confirmationId,
+                toolName,
+                arguments: arguments_,
+                timestamp: startTime,
+                timeoutHandle,
+                resolve,
+                reject,
+            };
+            this.pendingConfirmations.set(confirmationId, request);
+            // Create confirmation request event
+            const requestEvent = {
+                type: "hitl:confirmation-request",
+                payload: {
+                    confirmationId,
+                    toolName,
+                    serverId: context?.serverId,
+                    actionType: this.generateActionDescription(toolName, arguments_),
+                    arguments: arguments_,
+                    metadata: {
+                        timestamp: new Date(startTime).toISOString(),
+                        sessionId: context?.sessionId,
+                        userId: context?.userId,
+                        dangerousKeywords: this.getTriggeredKeywords(toolName, arguments_),
+                    },
+                    timeoutMs: this.config.timeout,
+                    allowModification: this.config.allowArgumentModification,
+                },
+            };
+            // Emit confirmation request event
+            this.emit("hitl:confirmation-request", requestEvent);
+            // Log audit trail if enabled
+            if (this.config.auditLogging) {
+                this.logAuditEvent("confirmation-requested", {
+                    confirmationId,
+                    toolName,
+                    userId: context?.userId,
+                    sessionId: context?.sessionId,
+                    timestamp: startTime,
+                    arguments: arguments_,
+                });
+            }
+        });
+    }
+    /**
+     * Process user response to confirmation request
+     */
+    processUserResponse(confirmationId, response) {
+        const request = this.pendingConfirmations.get(confirmationId);
+        if (!request) {
+            logger.warn(`No pending confirmation found for ID: ${confirmationId}`);
+            return;
+        }
+        // Clear timeout
+        clearTimeout(request.timeoutHandle);
+        // Remove from pending
+        this.pendingConfirmations.delete(confirmationId);
+        this.statistics.pendingRequests--;
+        // Calculate response time
+        const responseTime = response.responseTime || Date.now() - request.timestamp;
+        // Update statistics
+        if (response.approved) {
+            this.statistics.approvedRequests++;
+        }
+        else {
+            this.statistics.rejectedRequests++;
+        }
+        // Update average response time
+        const totalResponses = this.statistics.approvedRequests + this.statistics.rejectedRequests;
+        this.statistics.averageResponseTime =
+            (this.statistics.averageResponseTime * (totalResponses - 1) +
+                responseTime) /
+                totalResponses;
+        // Create result
+        const result = {
+            approved: response.approved,
+            reason: response.reason,
+            modifiedArguments: response.modifiedArguments,
+            responseTime,
+        };
+        // Log audit trail if enabled
+        if (this.config.auditLogging) {
+            this.logAuditEvent(response.approved ? "confirmation-approved" : "confirmation-rejected", {
+                confirmationId,
+                toolName: request.toolName,
+                approved: response.approved,
+                reason: response.reason,
+                userId: response.userId,
+                responseTime,
+                arguments: request.arguments,
+            });
+        }
+        // Resolve the promise
+        request.resolve(result);
+    }
+    /**
+     * Handle confirmation timeout
+     */
+    handleTimeout(confirmationId) {
+        const request = this.pendingConfirmations.get(confirmationId);
+        if (!request) {
+            return;
+        }
+        // Remove from pending
+        this.pendingConfirmations.delete(confirmationId);
+        this.statistics.pendingRequests--;
+        this.statistics.timedOutRequests++;
+        // Calculate response time (timeout duration)
+        const responseTime = Date.now() - request.timestamp;
+        // Check if auto-approve on timeout is enabled
+        const shouldAutoApprove = this.config.autoApproveOnTimeout === true;
+        // Log audit trail if enabled
+        if (this.config.auditLogging) {
+            this.logAuditEvent("confirmation-timeout", {
+                confirmationId,
+                toolName: request.toolName,
+                timeout: this.config.timeout,
+                arguments: request.arguments,
+                autoApproved: shouldAutoApprove,
+            });
+        }
+        // Create timeout event
+        const timeoutEvent = {
+            type: "hitl:timeout",
+            payload: {
+                confirmationId,
+                toolName: request.toolName,
+                timeout: this.config.timeout,
+            },
+        };
+        // Emit timeout event
+        this.emit("hitl:timeout", timeoutEvent);
+        if (shouldAutoApprove) {
+            // Auto-approve the request
+            this.statistics.approvedRequests++;
+            // Update average response time
+            const totalResponses = this.statistics.approvedRequests + this.statistics.rejectedRequests;
+            this.statistics.averageResponseTime =
+                (this.statistics.averageResponseTime * (totalResponses - 1) +
+                    responseTime) /
+                    totalResponses;
+            // Log auto-approval if enabled
+            if (this.config.auditLogging) {
+                this.logAuditEvent("confirmation-auto-approved", {
+                    confirmationId,
+                    toolName: request.toolName,
+                    reason: "Auto-approved due to timeout",
+                    responseTime,
+                    arguments: request.arguments,
+                });
+            }
+            // Resolve with auto-approval
+            const result = {
+                approved: true,
+                reason: "Auto-approved due to timeout",
+                responseTime,
+            };
+            request.resolve(result);
+        }
+        else {
+            // Reject with timeout error (original behavior)
+            request.reject(new HITLTimeoutError(`Confirmation timeout for tool: ${request.toolName}`, confirmationId, this.config.timeout));
+        }
+    }
+    /**
+     * Set up event handlers for processing responses
+     */
+    setupEventHandlers() {
+        this.on("hitl:confirmation-response", (event) => {
+            if (event.payload?.confirmationId) {
+                this.processUserResponse(event.payload.confirmationId, {
+                    approved: event.payload.approved,
+                    reason: event.payload.reason,
+                    modifiedArguments: event.payload.modifiedArguments,
+                    responseTime: event.payload.metadata?.responseTime,
+                    userId: event.payload.metadata?.userId,
+                });
+            }
+        });
+    }
+    /**
+     * Generate unique confirmation ID
+     */
+    generateConfirmationId() {
+        return `hitl-${Date.now()}-${randomUUID()}`;
+    }
+    /**
+     * Generate human-readable action description
+     */
+    generateActionDescription(toolName, args) {
+        const lowerToolName = toolName.toLowerCase();
+        // Check for specific action types
+        if (lowerToolName.includes("delete")) {
+            return "Delete Operation";
+        }
+        if (lowerToolName.includes("remove")) {
+            return "Remove Operation";
+        }
+        if (lowerToolName.includes("update")) {
+            return "Update Operation";
+        }
+        if (lowerToolName.includes("create")) {
+            return "Create Operation";
+        }
+        if (lowerToolName.includes("drop")) {
+            return "Drop Operation";
+        }
+        if (lowerToolName.includes("truncate")) {
+            return "Truncate Operation";
+        }
+        if (lowerToolName.includes("restart")) {
+            return "Restart Operation";
+        }
+        if (lowerToolName.includes("stop")) {
+            return "Stop Operation";
+        }
+        if (lowerToolName.includes("kill")) {
+            return "Kill Operation";
+        }
+        // Check custom rules for custom messages
+        if (this.config.customRules) {
+            for (const rule of this.config.customRules) {
+                try {
+                    if (rule.condition(toolName, args) && rule.customMessage) {
+                        return rule.customMessage;
+                    }
+                }
+                catch {
+                    // Ignore rule evaluation errors
+                }
+            }
+        }
+        return `Execute ${toolName}`;
+    }
+    /**
+     * Get keywords that triggered HITL
+     */
+    getTriggeredKeywords(toolName, args) {
+        const triggered = [];
+        const lowerToolName = toolName.toLowerCase();
+        // Check dangerous actions
+        for (const action of this.config.dangerousActions) {
+            if (lowerToolName.includes(action.toLowerCase())) {
+                triggered.push(action);
+            }
+        }
+        // Check custom rules
+        if (this.config.customRules) {
+            for (const rule of this.config.customRules) {
+                try {
+                    if (rule.requiresConfirmation && rule.condition(toolName, args)) {
+                        triggered.push(rule.name);
+                    }
+                }
+                catch {
+                    // Ignore rule evaluation errors
+                }
+            }
+        }
+        return triggered;
+    }
+    /**
+     * Log audit events for compliance and debugging
+     */
+    logAuditEvent(eventType, data) {
+        const auditLog = {
+            timestamp: new Date().toISOString(),
+            eventType: eventType,
+            toolName: data.toolName,
+            userId: data.userId,
+            sessionId: data.sessionId,
+            arguments: data.arguments,
+            reason: data.reason,
+            responseTime: data.responseTime,
+            ...data,
+        };
+        logger.info(`[HITL Audit] ${eventType}:`, auditLog);
+        // Emit audit event for external logging systems
+        this.emit("hitl:audit", auditLog);
+    }
+    /**
+     * Get current HITL usage statistics
+     */
+    getStatistics() {
+        return { ...this.statistics };
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration (for dynamic reconfiguration)
+     */
+    updateConfig(newConfig) {
+        const updatedConfig = { ...this.config, ...newConfig };
+        this.config = this.validateConfig(updatedConfig);
+        if (this.config.auditLogging) {
+            this.logAuditEvent("configuration-updated", {
+                oldConfig: this.config,
+                newConfig: updatedConfig,
+            });
+        }
+    }
+    /**
+     * Clean up resources and reject pending confirmations
+     */
+    cleanup() {
+        // Clear all pending confirmations
+        for (const [confirmationId, request] of this.pendingConfirmations) {
+            clearTimeout(request.timeoutHandle);
+            request.reject(new Error(`HITL cleanup: confirmation ${confirmationId} cancelled`));
+        }
+        this.pendingConfirmations.clear();
+        this.statistics.pendingRequests = 0;
+        if (this.config.auditLogging) {
+            this.logAuditEvent("manager-cleanup", {
+                clearedConfirmations: this.pendingConfirmations.size,
+            });
+        }
+    }
+    /**
+     * Check if manager is currently enabled
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Get count of pending confirmations
+     */
+    getPendingCount() {
+        return this.pendingConfirmations.size;
+    }
+}

package/dist/hitl/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HITL (Human-in-the-Loop) Module
+ *
+ * Simple barrel export for HITL components.
+ */
+export { HITLManager } from "./hitlManager.js";
+export type { HITLConfig, HITLRule, ConfirmationRequest, ConfirmationResult, ConfirmationRequestEvent, ConfirmationResponseEvent, ConfirmationTimeoutEvent, HITLStatistics, HITLAuditLog, } from "./types.js";
+export { HITLError, HITLUserRejectedError, HITLTimeoutError, HITLConfigurationError, } from "./hitlErrors.js";