@juspay/neurolink 7.33.4 → 7.34.0

package/dist/cli/parser.js

@@ -0,0 +1,158 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import chalk from "chalk";
+import packageJson from "../../package.json" with { type: "json" };
+import { CLICommandFactory } from "./factories/commandFactory.js";
+import { globalSession } from "../lib/session/globalSessionState.js";
+import { handleError } from "./errorHandler.js";
+import { logger } from "../lib/utils/logger.js";
+// Enhanced CLI with Professional UX
+export function initializeCliParser() {
+    return (yargs(hideBin(process.argv))
+        .scriptName("neurolink")
+        .usage("Usage: $0 <command> [options]")
+        .version(packageJson.version)
+        .help()
+        .alias("h", "help")
+        .alias("V", "version")
+        .strictOptions()
+        .strictCommands()
+        .demandCommand(1, "")
+        .recommendCommands()
+        .epilogue("For more info: https://github.com/juspay/neurolink")
+        .showHelpOnFail(true, "Specify --help for available options")
+        .middleware((argv) => {
+        // Handle no-color option globally
+        if (argv.noColor || process.env.NO_COLOR || !process.stdout.isTTY) {
+            process.env.FORCE_COLOR = "0";
+        }
+        // Handle custom config file
+        if (argv.configFile) {
+            process.env.NEUROLINK_CONFIG_FILE = argv.configFile;
+        }
+        // Control SDK logging based on debug flag
+        if (argv.debug) {
+            process.env.NEUROLINK_DEBUG = "true";
+        }
+        else {
+            // Always set to false when debug is not enabled (including when not provided)
+            process.env.NEUROLINK_DEBUG = "false";
+        }
+        // Keep existing quiet middleware
+        if (process.env.NEUROLINK_QUIET === "true" &&
+            typeof argv.quiet === "undefined") {
+            argv.quiet = true;
+        }
+    })
+        .fail((msg, err, yargsInstance) => {
+        // If we are in a loop, we don't want to exit the process.
+        // Instead, we just want to display the error and help text.
+        if (globalSession.getCurrentSessionId()) {
+            if (msg) {
+                logger.error(chalk.red(msg)); // This is a yargs validation error (e.g., missing argument)
+                yargsInstance.showHelp("log");
+            }
+            else if (err) {
+                // This is an error thrown from a command handler
+                // The loop's catch block will handle this, so we just re-throw.
+                // throw err;
+                handleError(err, "CLI Error in Loop Session");
+            }
+            return;
+        }
+        // Original logic for single-command execution
+        const exitProcess = () => {
+            if (!process.exitCode) {
+                process.exit(1);
+            }
+        };
+        if (err) {
+            // Error likely from an async command handler (e.g., via _handleError)
+            // _handleError already prints and calls process.exit(1).
+            // If we're here, it means _handleError's process.exit might not have been caught by the top-level async IIFE.
+            // Or, it's a synchronous yargs error during parsing that yargs itself throws.
+            const alreadyExitedByHandleError = err?.exitCode !== undefined;
+            // A simple heuristic: if the error message doesn't look like one of our handled generic messages,
+            // it might be a direct yargs parsing error.
+            const isLikelyYargsInternalError = err.message && // Ensure err.message exists
+                !err.message.includes("Authentication error") &&
+                !err.message.includes("Network error") &&
+                !err.message.includes("Authorization error") &&
+                !err.message.includes("Permission denied") && // from config export
+                !err.message.includes("Invalid or unparseable JSON"); // from config import
+            if (!alreadyExitedByHandleError) {
+                process.stderr.write(chalk.red(`CLI Error: ${err.message || msg || "An unexpected error occurred."}\n`));
+                // If it's a yargs internal parsing error, show help.
+                if (isLikelyYargsInternalError && msg) {
+                    yargsInstance.showHelp((h) => {
+                        process.stderr.write(h + "\n");
+                        exitProcess();
+                    });
+                    return;
+                }
+                exitProcess();
+            }
+            return; // Exit was already called or error handled
+        }
+        // Yargs parsing/validation error (msg is present, err is null)
+        if (msg) {
+            let processedMsg = `Error: ${msg}\n`;
+            if (msg.includes("Not enough non-option arguments") ||
+                msg.includes("Missing required argument") ||
+                msg.includes("Unknown command")) {
+                process.stderr.write(chalk.red(processedMsg)); // Print error first
+                yargsInstance.showHelp((h) => {
+                    process.stderr.write("\n" + h + "\n");
+                    exitProcess();
+                });
+                return; // Exit happens in callback
+            }
+            else if (msg.includes("Unknown argument") ||
+                msg.includes("Invalid values")) {
+                processedMsg = `Error: ${msg}\nUse --help to see available options.\n`;
+            }
+            process.stderr.write(chalk.red(processedMsg));
+        }
+        else {
+            // No specific message, but failure occurred (e.g. demandCommand failed silently)
+            yargsInstance.showHelp((h) => {
+                process.stderr.write(h + "\n");
+                exitProcess();
+            });
+            return; // Exit happens in callback
+        }
+        exitProcess(); // Default exit
+    })
+        // Generate Command (Primary) - Using CLICommandFactory
+        .command(CLICommandFactory.createGenerateCommand())
+        // Stream Text Command - Using CLICommandFactory
+        .command(CLICommandFactory.createStreamCommand())
+        // Batch Processing Command - Using CLICommandFactory
+        .command(CLICommandFactory.createBatchCommand())
+        // Provider Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createProviderCommands())
+        // Status command alias - Using CLICommandFactory
+        .command(CLICommandFactory.createStatusCommand())
+        // Models Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createModelsCommands())
+        // MCP Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createMCPCommands())
+        // Discover Command - Using CLICommandFactory
+        .command(CLICommandFactory.createDiscoverCommand())
+        // Configuration Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createConfigCommands())
+        // Memory Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createMemoryCommands())
+        // Get Best Provider Command - Using CLICommandFactory
+        .command(CLICommandFactory.createBestProviderCommand())
+        // Validate Command (alias for config validate)
+        .command(CLICommandFactory.createValidateCommand())
+        // Completion Command - Using CLICommandFactory
+        .command(CLICommandFactory.createCompletionCommand())
+        // Ollama Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createOllamaCommands())
+        // SageMaker Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createSageMakerCommands())
+        // Loop Command - Using CLICommandFactory
+        .command(CLICommandFactory.createLoopCommand()));
+}

package/dist/cli/utils/ollamaUtils.js

@@ -126,6 +126,9 @@ export class OllamaUtils {
                         stdio: "ignore",
                         detached: true,
                     });
+                    child.on("error", (err) => {
+                        logger.error("Error starting Ollama serve process:", err);
+                    });
                     child.unref();
                     logger.always(chalk.green("✅ Ollama service started"));
                 }
@@ -141,6 +144,9 @@ export class OllamaUtils {
                         stdio: "ignore",
                         detached: true,
                     });
+                    child.on("error", (err) => {
+                        logger.error("Error starting Ollama serve process:", err);
+                    });
                     child.unref();
                     logger.always(chalk.green("✅ Ollama service started"));
                 }

package/dist/config/{conversationMemoryConfig.d.ts → conversationMemory.d.ts}

@@ -2,7 +2,7 @@
  * Conversation Memory Configuration
  * Provides default values for conversation memory feature with environment variable support
  */
-import type { ConversationMemoryConfig } from "../types/conversationTypes.js";
+import type { ConversationMemoryConfig } from "../types/conversation.js";
 /**
  * Default maximum number of turns per session
  */

package/dist/core/baseProvider.js

@@ -100,7 +100,15 @@ export class BaseProvider {
                                         yield { content: buffer };
                                         buffer = "";
                                         // Small delay to simulate streaming (1-10ms)
-                                        await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
+                                        await new Promise((resolve, reject) => {
+                                            const timeoutId = setTimeout(resolve, Math.random() * 9 + 1);
+                                            // Handle potential timeout issues
+                                            if (!timeoutId) {
+                                                reject(new Error("Failed to create timeout"));
+                                            }
+                                        }).catch((err) => {
+                                            logger.error("Error in streaming delay:", err);
+                                        });
                                     }
                                 }
                                 // Yield all remaining content
@@ -217,8 +225,14 @@ export class BaseProvider {
             // Accumulate the streamed content
             let accumulatedContent = "";
             // Wait for the stream to complete and accumulate content
-            for await (const chunk of streamResult.textStream) {
-                accumulatedContent += chunk;
+            try {
+                for await (const chunk of streamResult.textStream) {
+                    accumulatedContent += chunk;
+                }
+            }
+            catch (streamError) {
+                logger.error(`Error reading text stream for ${this.providerName}:`, streamError);
+                throw streamError;
             }
             // Get the final result - this should include usage, toolCalls, etc.
             const usage = await streamResult.usage;

package/dist/core/conversationMemoryFactory.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Conversation Memory Factory for NeuroLink
+ * Creates appropriate conversation memory manager based on configuration
+ */
+import type { ConversationMemoryConfig, RedisStorageConfig } from "../types/conversation.js";
+import { ConversationMemoryManager } from "./conversationMemoryManager.js";
+import { RedisConversationMemoryManager } from "./redisConversationMemoryManager.js";
+/**
+ * Configuration for memory storage type
+ */
+export type StorageType = "memory" | "redis";
+/**
+ * Creates a conversation memory manager based on configuration
+ */
+export declare function createConversationMemoryManager(config: ConversationMemoryConfig, storageType?: StorageType, redisConfig?: RedisStorageConfig): ConversationMemoryManager | RedisConversationMemoryManager;
+/**
+ * Get storage type from environment variable or configuration
+ */
+export declare function getStorageType(): StorageType;
+/**
+ * Get Redis configuration from environment variables
+ */
+export declare function getRedisConfigFromEnv(): RedisStorageConfig;

package/dist/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/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/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/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/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/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;
+}