@juspay/neurolink 7.33.4 → 7.34.0

package/dist/lib/core/conversationMemoryFactory.js

@@ -0,0 +1,144 @@
+/**
+ * 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,
+            maxTurnsPerSession: config.maxTurnsPerSession,
+            enableSummarization: config.enableSummarization,
+            summarizationThresholdTurns: config.summarizationThresholdTurns,
+            summarizationTargetTurns: config.summarizationTargetTurns,
+            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/lib/core/conversationMemoryInitializer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Conversation Memory Initializer
+ * Provides integration with Redis storage for conversation memory
+ */
+import type { ConversationMemoryConfig } from "../types/conversation.js";
+import type { ConversationMemoryManager } from "./conversationMemoryManager.js";
+import type { RedisConversationMemoryManager } from "./redisConversationMemoryManager.js";
+/**
+ * Initialize conversation memory for NeuroLink
+ * This function decides whether to use in-memory or Redis storage
+ */
+export declare function initializeConversationMemory(config?: {
+    conversationMemory?: Partial<ConversationMemoryConfig>;
+}): Promise<ConversationMemoryManager | RedisConversationMemoryManager | null>;

package/dist/lib/core/conversationMemoryInitializer.js

@@ -0,0 +1,127 @@
+/**
+ * Conversation Memory Initializer
+ * Provides integration with Redis storage for conversation memory
+ */
+import { createConversationMemoryManager, getStorageType, getRedisConfigFromEnv, } from "./conversationMemoryFactory.js";
+import { applyConversationMemoryDefaults } from "../utils/conversationMemory.js";
+import { logger } from "../utils/logger.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 from environment
+        const storageType = getStorageType();
+        logger.debug("[conversationMemoryInitializer] Storage type determined", {
+            storageType,
+            fromEnv: !!process.env.STORAGE_TYPE,
+        });
+        if (storageType === "redis") {
+            logger.info("[conversationMemoryInitializer] Initializing Redis-based conversation memory manager");
+            // Get Redis configuration from environment
+            logger.debug("[conversationMemoryInitializer] Getting Redis configuration from environment");
+            const redisConfig = getRedisConfigFromEnv();
+            logger.debug("[conversationMemoryInitializer] Redis configuration retrieved", {
+                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", {
+                host: redisConfig.host || "localhost",
+                port: redisConfig.port || 6379,
+                maxSessions: memoryConfig.maxSessions,
+                maxTurnsPerSession: memoryConfig.maxTurnsPerSession,
+                managerType: redisMemoryManager?.constructor?.name,
+            });
+            // 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;
+    }
+}

package/dist/lib/core/conversationMemoryManager.d.ts

@@ -2,7 +2,7 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage } from "../types/conversationTypes.js";
+import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage } from "../types/conversation.js";
 export declare class ConversationMemoryManager {
     private sessions;
     config: ConversationMemoryConfig;
@@ -20,8 +20,9 @@ export declare class ConversationMemoryManager {
     /**
      * Build context messages for AI prompt injection (ULTRA-OPTIMIZED)
      * Returns pre-stored message array with zero conversion overhead
+     * Now consistently async to match Redis implementation
      */
-    buildContextMessages(sessionId: string): ChatMessage[];
+    buildContextMessages(sessionId: string): Promise<ChatMessage[]>;
     getSession(sessionId: string): SessionMemory | undefined;
     createSummarySystemMessage(content: string): ChatMessage;
     private _summarizeSession;

package/dist/lib/core/conversationMemoryManager.js

@@ -2,8 +2,8 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import { ConversationMemoryError } from "../types/conversationTypes.js";
-import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemoryConfig.js";
+import { ConversationMemoryError } from "../types/conversation.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemory.js";
 import { logger } from "../utils/logger.js";
 import { NeuroLink } from "../neurolink.js";
 export class ConversationMemoryManager {
@@ -74,8 +74,9 @@ export class ConversationMemoryManager {
     /**
      * Build context messages for AI prompt injection (ULTRA-OPTIMIZED)
      * Returns pre-stored message array with zero conversion overhead
+     * Now consistently async to match Redis implementation
      */
-    buildContextMessages(sessionId) {
+    async buildContextMessages(sessionId) {
         const session = this.sessions.get(sessionId);
         return session ? session.messages : [];
     }

package/dist/lib/core/redisConversationMemoryManager.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Redis Conversation Memory Manager for NeuroLink
+ * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
+ */
+import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage, RedisStorageConfig } from "../types/conversation.js";
+/**
+ * Redis-based implementation of the ConversationMemoryManager
+ * Uses the same interface but stores data in Redis
+ */
+export declare class RedisConversationMemoryManager {
+    config: ConversationMemoryConfig;
+    private isInitialized;
+    private redisConfig;
+    private redisClient;
+    constructor(config: ConversationMemoryConfig, redisConfig?: RedisStorageConfig);
+    /**
+     * Initialize the memory manager with Redis connection
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store a conversation turn for a session
+     */
+    storeConversationTurn(sessionId: string, userId: string | undefined, userMessage: string, aiResponse: string): Promise<void>;
+    /**
+     * Build context messages for AI prompt injection
+     */
+    buildContextMessages(sessionId: string): Promise<ChatMessage[]>;
+    /**
+     * Get session data
+     */
+    getSession(sessionId: string): Promise<SessionMemory | undefined>;
+    /**
+     * Create summary system message
+     */
+    createSummarySystemMessage(content: string): ChatMessage;
+    /**
+     * Close Redis connection
+     */
+    close(): Promise<void>;
+    /**
+     * Get statistics about conversation storage
+     */
+    getStats(): Promise<ConversationMemoryStats>;
+    /**
+     * Clear a specific session
+     */
+    clearSession(sessionId: string): Promise<boolean>;
+    /**
+     * Clear all sessions
+     */
+    clearAllSessions(): Promise<void>;
+    /**
+     * Summarize messages for a session
+     */
+    private _summarizeMessages;
+    /**
+     * Create summarization prompt
+     */
+    private _createSummarizationPrompt;
+    /**
+     * Ensure Redis client is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Enforce session limit
+     *
+     * NOTE: This function is maintained only for backward compatibility with the
+     * in-memory implementation. In Redis, we do not actually delete sessions based on
+     * a global limit, as this could cause race conditions in a distributed environment.
+     * Each session is managed independently with its own TTL.
+     */
+    private enforceSessionLimit;
+}