@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/core/constants.js

@@ -1,140 +0,0 @@
-/**
- * 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

@@ -1,141 +0,0 @@
-/**
- * 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

@@ -1,128 +0,0 @@
-/**
- * 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;
-    }
-}