@juspay/neurolink 7.33.3 → 7.34.0

package/dist/lib/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/lib/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/lib/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/lib/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/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/factory.js

@@ -111,6 +111,25 @@ export class AIProviderFactory {
                         logger.debug(`[${functionTag}] No Vertex environment variables found (VERTEX_MODEL)`);
                     }
                 }
+                else if (providerName.toLowerCase().includes("azure")) {
+                    const envModel = process.env.AZURE_OPENAI_MODEL ||
+                        process.env.AZURE_OPENAI_DEPLOYMENT ||
+                        process.env.AZURE_OPENAI_DEPLOYMENT_ID;
+                    if (envModel) {
+                        resolvedModelName = envModel;
+                        logger.debug(`[${functionTag}] Environment variable found for Azure`, {
+                            envVariable: process.env.AZURE_OPENAI_MODEL
+                                ? "AZURE_OPENAI_MODEL"
+                                : process.env.AZURE_OPENAI_DEPLOYMENT
+                                    ? "AZURE_OPENAI_DEPLOYMENT"
+                                    : "AZURE_OPENAI_DEPLOYMENT_ID",
+                            resolvedModel: envModel,
+                        });
+                    }
+                    else {
+                        logger.debug(`[${functionTag}] No Azure environment variables found (AZURE_OPENAI_MODEL, AZURE_OPENAI_DEPLOYMENT, AZURE_OPENAI_DEPLOYMENT_ID)`);
+                    }
+                }
                 else {
                     logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
                 }

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