@juspay/neurolink 7.33.3 → 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
@@ -168,6 +176,31 @@ export class BaseProvider {
                     ...(options.tools || {}), // Include external tools passed from NeuroLink
                 }
                 : {};
+            // DEBUG: Log detailed tool information for generate
+            logger.debug("BaseProvider Generate - Tool Loading Debug", {
+                provider: this.providerName,
+                shouldUseTools,
+                baseToolsProvided: !!baseTools,
+                baseToolCount: baseTools ? Object.keys(baseTools).length : 0,
+                finalToolCount: tools ? Object.keys(tools).length : 0,
+                toolNames: tools ? Object.keys(tools).slice(0, 10) : [],
+                disableTools: options.disableTools,
+                supportsTools: this.supportsTools(),
+                externalToolsCount: options.tools
+                    ? Object.keys(options.tools).length
+                    : 0,
+            });
+            if (tools && Object.keys(tools).length > 0) {
+                logger.debug("BaseProvider Generate - First 5 Tools Detail", {
+                    provider: this.providerName,
+                    tools: Object.keys(tools)
+                        .slice(0, 5)
+                        .map((name) => ({
+                        name,
+                        description: tools[name]?.description?.substring(0, 100),
+                    })),
+                });
+            }
             logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}:`, {
                 directTools: getKeyCount(baseTools),
                 directToolNames: getKeysAsString(baseTools),
@@ -187,13 +220,19 @@ export class BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || 8192,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
             });
             // 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/constants.d.ts

@@ -2,7 +2,7 @@
  * Central configuration constants for NeuroLink
  * Single source of truth for all default values
  */
-export declare const DEFAULT_MAX_TOKENS = 8192;
+export declare const DEFAULT_MAX_TOKENS: undefined;
 export declare const DEFAULT_TEMPERATURE = 0.7;
 export declare const DEFAULT_TIMEOUT = 30000;
 export declare const DEFAULT_MAX_STEPS = 5;
@@ -67,6 +67,15 @@ export declare const PROVIDER_MAX_TOKENS: {
         "anthropic.claude-3-5-sonnet-20240620-v1:0": number;
         default: number;
     };
+    azure: {
+        "gpt-4o": number;
+        "gpt-4o-mini": number;
+        "gpt-4.1": number;
+        "gpt-3.5-turbo": number;
+        "gpt-4": number;
+        "gpt-4-turbo": number;
+        default: number;
+    };
     ollama: {
         default: number;
     };
@@ -79,7 +88,7 @@ export declare const CLI_LIMITS: {
     maxTokens: {
         min: number;
         max: number;
-        default: number;
+        default: undefined;
     };
     temperature: {
         min: number;
@@ -99,6 +108,6 @@ export declare const SYSTEM_LIMITS: {
     DEFAULT_BACKOFF_MULTIPLIER: number;
 };
 export declare const ENV_DEFAULTS: {
-    maxTokens: number;
+    maxTokens: number | undefined;
     temperature: number;
 };

package/dist/core/constants.js

@@ -3,7 +3,7 @@
  * Single source of truth for all default values
  */
 // Core AI Generation Defaults
-export const DEFAULT_MAX_TOKENS = 8192; // Changed from 10000 to fix Anthropic error
+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 = 30000;
 export const DEFAULT_MAX_STEPS = 5; // Default multi-turn tool execution steps
@@ -72,6 +72,15 @@ export const PROVIDER_MAX_TOKENS = {
         "anthropic.claude-3-5-sonnet-20240620-v1:0": 4096,
         default: 4096,
     },
+    azure: {
+        "gpt-4o": 16384,
+        "gpt-4o-mini": 16384,
+        "gpt-4.1": 16384,
+        "gpt-3.5-turbo": 4096,
+        "gpt-4": 8192,
+        "gpt-4-turbo": 4096,
+        default: 8192, // Azure OpenAI generally supports similar limits to OpenAI
+    },
     ollama: {
         default: 8192, // Ollama typically supports higher limits
     },
@@ -85,7 +94,7 @@ export const CLI_LIMITS = {
     maxTokens: {
         min: 1,
         max: 50000,
-        default: DEFAULT_MAX_TOKENS,
+        default: undefined, // No default limit - unlimited by default
     },
     temperature: {
         min: 0,
@@ -112,10 +121,17 @@ export const SYSTEM_LIMITS = {
 };
 // Environment Variable Support (for future use)
 export const ENV_DEFAULTS = {
-    maxTokens: process.env.NEUROLINK_DEFAULT_MAX_TOKENS
-        ? parseInt(process.env.NEUROLINK_DEFAULT_MAX_TOKENS, 10)
-        : DEFAULT_MAX_TOKENS,
+    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
-        ? parseFloat(process.env.NEUROLINK_DEFAULT_TEMPERATURE)
+        ? (() => {
+            const t = parseFloat(process.env.NEUROLINK_DEFAULT_TEMPERATURE);
+            return Number.isFinite(t) ? t : DEFAULT_TEMPERATURE;
+        })()
         : DEFAULT_TEMPERATURE,
 };

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;
+    }
+}