@juspay/neurolink 9.29.1 → 9.31.0

package/dist/client/core/constants.js

@@ -0,0 +1,140 @@
+/**
+ * Central configuration constants for NeuroLink
+ * Single source of truth for all default values
+ */
+// Image Generation Model Identifiers
+// Used to detect if a model is an image generation model (not text generation)
+export const IMAGE_GENERATION_MODELS = [
+    "gemini-3-pro-image-preview",
+    "gemini-2.5-flash-image",
+    "gemini-3.1-flash-image-preview",
+];
+// PDF Image Generation Models
+// Models that support generating images from PDFs
+export const PDF_IMAGE_GENERATION_MODELS = [
+    "gemini-3-pro-image-preview",
+    "gemini-3.1-flash-image-preview",
+];
+// Global Location Models
+// Models that require global location configuration (uses aiplatform.googleapis.com instead of region-specific endpoints)
+export const GLOBAL_LOCATION_MODELS = [
+    "gemini-3-pro-image-preview",
+    "gemini-2.5-flash-image",
+    "gemini-3.1-flash-image-preview",
+];
+// 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 = 60000;
+export const DEFAULT_MAX_STEPS = 200;
+export const DEFAULT_TOOL_MAX_RETRIES = 2; // Maximum retries per tool before permanently failing
+// Step execution limits
+export const STEP_LIMITS = {
+    min: 1,
+    max: 500,
+    default: DEFAULT_MAX_STEPS,
+};
+// Specialized Use Case Defaults
+export const DEFAULT_EVALUATION_MAX_TOKENS = 500; // Keep evaluation fast
+export const DEFAULT_ANALYSIS_MAX_TOKENS = 800; // For analysis tools
+export const DEFAULT_DOCUMENTATION_MAX_TOKENS = 12000; // For documentation generation
+// Provider-specific configurations
+export const PROVIDER_CONFIG = {
+    evaluation: {
+        maxTokens: DEFAULT_EVALUATION_MAX_TOKENS,
+        model: "gemini-2.5-flash",
+        temperature: 0.3, // Lower temperature for consistent evaluation
+    },
+    analysis: {
+        maxTokens: DEFAULT_ANALYSIS_MAX_TOKENS,
+        temperature: 0.5,
+    },
+    documentation: {
+        maxTokens: DEFAULT_DOCUMENTATION_MAX_TOKENS,
+        temperature: 0.4,
+    },
+};
+// Provider-specific maxTokens limits
+export const PROVIDER_MAX_TOKENS = {
+    anthropic: {
+        default: 64000,
+    },
+    openai: {
+        default: 128000,
+    },
+    "google-ai": {
+        default: 64000,
+    },
+    vertex: {
+        default: 64000,
+    },
+    bedrock: {
+        default: 64000,
+    },
+    azure: {
+        default: 128000,
+    },
+    mistral: {
+        default: 128000,
+    },
+    ollama: {
+        default: 64000,
+    },
+    litellm: {
+        default: 128000,
+    },
+    default: 64000,
+};
+// CLI Validation Limits
+export const CLI_LIMITS = {
+    maxTokens: {
+        min: 1,
+        max: 64000,
+        default: DEFAULT_MAX_TOKENS,
+    },
+    temperature: {
+        min: 0,
+        max: 2,
+        default: DEFAULT_TEMPERATURE,
+    },
+};
+// PDF Processing Limits
+export const PDF_LIMITS = {
+    // Maximum PDF size for image conversion (20MB)
+    MAX_SIZE_MB: 20,
+    // Default maximum pages for image conversion
+    DEFAULT_MAX_PAGES: 20,
+};
+// Performance and System Limits
+export const SYSTEM_LIMITS = {
+    // Prompt size limits (baseProvider.ts magic number fix)
+    MAX_PROMPT_LENGTH: 1000000, // 1M characters - prevents memory issues
+    // Memory monitoring thresholds (performance.ts)
+    HIGH_MEMORY_THRESHOLD: 100, // MB - when to warn about memory usage
+    // Timeout warnings (baseProvider.ts)
+    LONG_TIMEOUT_WARNING: 300000, // 5 minutes - when to warn about long timeouts
+    // Concurrency control (neurolink.ts provider testing)
+    DEFAULT_CONCURRENCY_LIMIT: 3, // Max parallel provider tests
+    MAX_CONCURRENCY_LIMIT: 5, // Upper bound for concurrency
+    // Retry system defaults (retryHandler.ts)
+    DEFAULT_RETRY_ATTEMPTS: 3,
+    DEFAULT_INITIAL_DELAY: 1000, // 1 second
+    DEFAULT_MAX_DELAY: 30000, // 30 seconds
+    DEFAULT_BACKOFF_MULTIPLIER: 2,
+};
+// Environment Variable Support (for future use)
+export const ENV_DEFAULTS = {
+    maxTokens: (() => {
+        if (!process.env.NEUROLINK_DEFAULT_MAX_TOKENS) {
+            return undefined;
+        }
+        const n = parseInt(process.env.NEUROLINK_DEFAULT_MAX_TOKENS, 10);
+        return Number.isFinite(n) ? n : undefined;
+    })(),
+    temperature: process.env.NEUROLINK_DEFAULT_TEMPERATURE
+        ? (() => {
+            const t = parseFloat(process.env.NEUROLINK_DEFAULT_TEMPERATURE);
+            return Number.isFinite(t) ? t : DEFAULT_TEMPERATURE;
+        })()
+        : DEFAULT_TEMPERATURE,
+};

package/dist/client/core/conversationMemoryFactory.js

@@ -0,0 +1,141 @@
+/**
+ * Conversation Memory Factory for NeuroLink
+ * Creates appropriate conversation memory manager based on configuration
+ */
+import { ConversationMemoryManager } from "./conversationMemoryManager.js";
+import { RedisConversationMemoryManager } from "./redisConversationMemoryManager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Creates a conversation memory manager based on configuration
+ */
+export function createConversationMemoryManager(config, storageType = "memory", redisConfig) {
+    logger.debug("[conversationMemoryFactory] Creating conversation memory manager", {
+        storageType,
+        config: {
+            enabled: config.enabled,
+            maxSessions: config.maxSessions,
+            enableSummarization: config.enableSummarization,
+            summarizationProvider: config.summarizationProvider,
+            summarizationModel: config.summarizationModel,
+        },
+        hasRedisConfig: !!redisConfig,
+    });
+    // Default to memory storage
+    if (storageType === "memory" || !storageType) {
+        logger.debug("[conversationMemoryFactory] Creating in-memory conversation manager");
+        const memoryManager = new ConversationMemoryManager(config);
+        logger.debug("[conversationMemoryFactory] In-memory conversation manager created successfully", {
+            managerType: memoryManager.constructor.name,
+        });
+        return memoryManager;
+    }
+    // Redis storage
+    if (storageType === "redis") {
+        logger.debug("[conversationMemoryFactory] Creating Redis conversation manager", {
+            host: redisConfig?.host || "localhost",
+            port: redisConfig?.port || 6379,
+            keyPrefix: redisConfig?.keyPrefix || "neurolink:conversation:",
+            ttl: redisConfig?.ttl || 86400,
+            hasConnectionOptions: !!redisConfig?.connectionOptions,
+        });
+        const redisManager = new RedisConversationMemoryManager(config, redisConfig);
+        logger.debug("[conversationMemoryFactory] Redis conversation manager created successfully", {
+            managerType: redisManager.constructor.name,
+            config: {
+                maxSessions: config.maxSessions,
+                maxTurnsPerSession: config.maxTurnsPerSession,
+            },
+        });
+        return redisManager;
+    }
+    // Fallback to memory storage for unknown types
+    logger.warn(`[conversationMemoryFactory] Unknown storage type: ${storageType}, falling back to memory storage`);
+    const fallbackManager = new ConversationMemoryManager(config);
+    logger.debug("[conversationMemoryFactory] Fallback memory manager created successfully", {
+        managerType: fallbackManager.constructor.name,
+    });
+    return fallbackManager;
+}
+/**
+ * Get storage type from environment variable or configuration
+ */
+export function getStorageType() {
+    // Get the raw value from environment, or use default
+    const rawStorageType = process.env.STORAGE_TYPE;
+    // Default to "memory" if not set
+    if (!rawStorageType) {
+        logger.debug("[conversationMemoryFactory] No storage type configured, using default", {
+            storageType: "memory",
+            fromEnv: false,
+        });
+        return "memory";
+    }
+    // Normalize: trim and convert to lowercase
+    const normalizedStorageType = rawStorageType.trim().toLowerCase();
+    // Validate against allowed StorageType values
+    const validStorageTypes = ["memory", "redis"];
+    if (validStorageTypes.includes(normalizedStorageType)) {
+        logger.debug("[conversationMemoryFactory] Determined storage type", {
+            storageType: normalizedStorageType,
+            fromEnv: true,
+            envValue: rawStorageType,
+            normalized: normalizedStorageType !== rawStorageType,
+        });
+        return normalizedStorageType;
+    }
+    else {
+        // Invalid storage type, log warning and return default
+        logger.warn(`[conversationMemoryFactory] Unrecognized storage type in environment: "${rawStorageType}", falling back to "memory"`, {
+            providedValue: rawStorageType,
+            normalizedValue: normalizedStorageType,
+            validValues: validStorageTypes,
+            usingDefault: true,
+        });
+        return "memory";
+    }
+}
+/**
+ * Get Redis configuration from environment variables
+ */
+export function getRedisConfigFromEnv() {
+    logger.debug("[conversationMemoryFactory] Reading Redis configuration from environment", {
+        REDIS_HOST: process.env.REDIS_HOST || "(not set)",
+        REDIS_PORT: process.env.REDIS_PORT || "(not set)",
+        REDIS_PASSWORD: process.env.REDIS_PASSWORD ? "******" : "(not set)",
+        REDIS_DB: process.env.REDIS_DB || "(not set)",
+        REDIS_KEY_PREFIX: process.env.REDIS_KEY_PREFIX || "(not set)",
+        REDIS_TTL: process.env.REDIS_TTL || "(not set)",
+        REDIS_CONNECT_TIMEOUT: process.env.REDIS_CONNECT_TIMEOUT || "(not set)",
+        REDIS_MAX_RETRIES: process.env.REDIS_MAX_RETRIES || "(not set)",
+        REDIS_RETRY_DELAY: process.env.REDIS_RETRY_DELAY || "(not set)",
+    });
+    const config = {
+        host: process.env.REDIS_HOST,
+        port: process.env.REDIS_PORT ? Number(process.env.REDIS_PORT) : undefined,
+        password: process.env.REDIS_PASSWORD,
+        db: process.env.REDIS_DB ? Number(process.env.REDIS_DB) : undefined,
+        keyPrefix: process.env.REDIS_KEY_PREFIX,
+        ttl: process.env.REDIS_TTL ? Number(process.env.REDIS_TTL) : undefined,
+        connectionOptions: {
+            connectTimeout: process.env.REDIS_CONNECT_TIMEOUT
+                ? Number(process.env.REDIS_CONNECT_TIMEOUT)
+                : undefined,
+            maxRetriesPerRequest: process.env.REDIS_MAX_RETRIES
+                ? Number(process.env.REDIS_MAX_RETRIES)
+                : undefined,
+            retryDelayOnFailover: process.env.REDIS_RETRY_DELAY
+                ? Number(process.env.REDIS_RETRY_DELAY)
+                : undefined,
+        },
+    };
+    logger.debug("[conversationMemoryFactory] Redis configuration normalized", {
+        host: config.host || "localhost",
+        port: config.port || 6379,
+        hasPassword: !!config.password,
+        db: config.db || 0,
+        keyPrefix: config.keyPrefix || "neurolink:conversation:",
+        ttl: config.ttl || 86400,
+        hasConnectionOptions: !!config.connectionOptions,
+    });
+    return config;
+}

package/dist/client/core/conversationMemoryInitializer.js

@@ -0,0 +1,128 @@
+/**
+ * Conversation Memory Initializer
+ * Provides integration with Redis storage for conversation memory
+ */
+import { applyConversationMemoryDefaults } from "../utils/conversationMemory.js";
+import { logger } from "../utils/logger.js";
+import { createConversationMemoryManager, getRedisConfigFromEnv, getStorageType, } from "./conversationMemoryFactory.js";
+/**
+ * Initialize conversation memory for NeuroLink
+ * This function decides whether to use in-memory or Redis storage
+ */
+export async function initializeConversationMemory(config) {
+    logger.debug("[conversationMemoryInitializer] Initialize conversation memory called", {
+        hasConfig: !!config,
+        hasMemoryConfig: !!config?.conversationMemory,
+        memoryEnabled: config?.conversationMemory?.enabled || false,
+        storageType: process.env.STORAGE_TYPE || "memory",
+    });
+    if (!config?.conversationMemory?.enabled) {
+        logger.debug("[conversationMemoryInitializer] Conversation memory not enabled - skipping initialization");
+        return null;
+    }
+    try {
+        // Apply default configuration
+        logger.debug("[conversationMemoryInitializer] Applying conversation memory defaults");
+        const memoryConfig = applyConversationMemoryDefaults(config.conversationMemory);
+        logger.debug("[conversationMemoryInitializer] Memory configuration processed", {
+            enabled: memoryConfig.enabled,
+            maxSessions: memoryConfig.maxSessions,
+            maxTurnsPerSession: memoryConfig.maxTurnsPerSession,
+            enableSummarization: memoryConfig.enableSummarization,
+        });
+        // Determine storage type: if redisConfig is passed in the SDK config, use Redis
+        // regardless of STORAGE_TYPE env var. This lets consumers configure Redis via the API.
+        const hasRedisConfig = !!config.conversationMemory?.redisConfig;
+        const storageType = hasRedisConfig ? "redis" : getStorageType();
+        logger.debug("[conversationMemoryInitializer] Storage type determined", {
+            storageType,
+            fromConfig: hasRedisConfig,
+            fromEnv: !hasRedisConfig && !!process.env.STORAGE_TYPE,
+        });
+        if (storageType === "redis") {
+            logger.info("[conversationMemoryInitializer] Initializing Redis-based conversation memory manager");
+            // Get Redis configuration - prioritize passed config, fallback to environment
+            logger.debug("[conversationMemoryInitializer] Getting Redis configuration");
+            const redisConfig = config.conversationMemory?.redisConfig || getRedisConfigFromEnv();
+            const configSource = config.conversationMemory?.redisConfig
+                ? "SDK input (from Lighthouse)"
+                : "environment variables (NeuroLink)";
+            logger.debug("[conversationMemoryInitializer] Redis configuration retrieved", {
+                configSource,
+                host: redisConfig.host || "localhost",
+                port: redisConfig.port || 6379,
+                hasPassword: !!redisConfig.password,
+                db: redisConfig.db || 0,
+                keyPrefix: redisConfig.keyPrefix || "neurolink:conversation:",
+                ttl: redisConfig.ttl || 86400,
+            });
+            // Create Redis-based conversation memory manager
+            logger.debug("[conversationMemoryInitializer] Creating Redis conversation memory manager");
+            const redisMemoryManager = createConversationMemoryManager(memoryConfig, "redis", redisConfig);
+            logger.debug("[conversationMemoryInitializer] Checking Redis manager creation result", {
+                managerType: redisMemoryManager?.constructor?.name || "unknown",
+                isRedisType: redisMemoryManager?.constructor?.name ===
+                    "RedisConversationMemoryManager",
+                hasConfig: !!redisMemoryManager?.config,
+            });
+            logger.info("[conversationMemoryInitializer] Redis conversation memory manager created successfully");
+            // Perform basic validation
+            if (redisMemoryManager?.constructor?.name !==
+                "RedisConversationMemoryManager") {
+                logger.warn("[conversationMemoryInitializer] Created manager is not of RedisConversationMemoryManager type", {
+                    actualType: redisMemoryManager?.constructor?.name,
+                });
+            }
+            return redisMemoryManager;
+        }
+        else {
+            logger.info("[conversationMemoryInitializer] Initializing in-memory conversation memory manager");
+            // Create in-memory conversation memory manager
+            logger.debug("[conversationMemoryInitializer] Creating in-memory conversation memory manager");
+            const memoryManager = createConversationMemoryManager(memoryConfig);
+            logger.debug("[conversationMemoryInitializer] Checking memory manager creation result", {
+                managerType: memoryManager?.constructor?.name || "unknown",
+                isInMemoryType: memoryManager?.constructor?.name === "ConversationMemoryManager",
+                hasConfig: !!memoryManager?.config,
+            });
+            logger.info("[conversationMemoryInitializer] In-memory conversation memory manager created successfully", {
+                maxSessions: memoryConfig.maxSessions,
+                maxTurnsPerSession: memoryConfig.maxTurnsPerSession,
+                managerType: memoryManager?.constructor?.name,
+            });
+            return memoryManager;
+        }
+    }
+    catch (error) {
+        logger.error("[conversationMemoryInitializer] Failed to initialize conversation memory", {
+            error: error instanceof Error ? error.message : String(error),
+            errorName: error instanceof Error ? error.name : "UnknownError",
+            errorStack: error instanceof Error ? error.stack : undefined,
+            storageType: process.env.STORAGE_TYPE || "memory",
+            memoryConfig: {
+                enabled: config?.conversationMemory?.enabled,
+                maxSessions: config?.conversationMemory?.maxSessions,
+                maxTurnsPerSession: config?.conversationMemory?.maxTurnsPerSession,
+            },
+            redisConfig: {
+                host: process.env.REDIS_HOST || "(not set)",
+                port: process.env.REDIS_PORT || "(not set)",
+                hasPassword: !!process.env.REDIS_PASSWORD,
+                keyPrefix: process.env.REDIS_KEY_PREFIX || "(not set)",
+            },
+        });
+        // Log additional diagnostics for redis errors
+        if (process.env.STORAGE_TYPE === "redis") {
+            logger.error("[conversationMemoryInitializer] Redis configuration error details", {
+                REDIS_HOST: process.env.REDIS_HOST || "(not set)",
+                REDIS_PORT: process.env.REDIS_PORT || "(not set)",
+                REDIS_PASSWORD: process.env.REDIS_PASSWORD ? "******" : "(not set)",
+                REDIS_DB: process.env.REDIS_DB || "(not set)",
+                REDIS_KEY_PREFIX: process.env.REDIS_KEY_PREFIX || "(not set)",
+                REDIS_TTL: process.env.REDIS_TTL || "(not set)",
+                errorMessage: error instanceof Error ? error.message : String(error),
+            });
+        }
+        throw error;
+    }
+}