myavana-bot-test-core 2.0.2 → 2.0.3

package/index.js

@@ -1,54 +1,142 @@
-// Re-export all shared modules
-module.exports = {
+// packages/core/index.js - Fixed exports with proper module loading
+const path = require('path');
+
+// Helper function to safely load modules
+function safeRequire(modulePath, moduleName) {
+    try {
+        const module = require(modulePath);
+        console.log(`✅ Successfully loaded ${moduleName}`);
+        return module;
+    } catch (error) {
+        console.error(`❌ Failed to load ${moduleName}:`, error.message);
+        return null;
+    }
+}
+
+// Load all modules with error handling
+const modules = {
     // Database and utilities (Enhanced)
-    connectDatabases: require('./src/database').connectDatabases,
-    pgClient: require('./src/database').pgClient,
-    redisClient: require('./src/database').redisClient,
+    connectDatabases: safeRequire('./src/database', 'database').connectDatabases,
+    pgClient: safeRequire('./src/database', 'database').pgClient,
+    redisClient: safeRequire('./src/database', 'database').redisClient,
     
     // Enhanced database management
-    DatabaseManager: require('./src/enhancedDatabase').DatabaseManager,
-    createDatabaseManager: require('./src/enhancedDatabase').createDatabaseManager,
-    getDatabaseManager: require('./src/enhancedDatabase').getDatabaseManager,
+    DatabaseManager: safeRequire('./src/enhancedDatabase', 'DatabaseManager')?.DatabaseManager,
+    createDatabaseManager: safeRequire('./src/enhancedDatabase', 'DatabaseManager')?.createDatabaseManager,
+    getDatabaseManager: safeRequire('./src/enhancedDatabase', 'DatabaseManager')?.getDatabaseManager,
   
     // AI and session management
-    ai: require('./src/ai'),
-    DatabaseSessionStore: require('./src/session'),
+    ai: safeRequire('./src/ai', 'ai'),
+    DatabaseSessionStore: safeRequire('./src/session', 'DatabaseSessionStore'),
   
     // User and conversation management
-    getUserDetails: require('./src/user').getUserDetails,
-    getAllConversationsSummary: require('./src/conversation').getAllConversationsSummary,
-    getConversationHistory: require('./src/conversation').getConversationHistory,
-    saveConversation: require('./src/conversation').saveConversation,
-    generateConversationSummary: require('./src/conversation').generateConversationSummary,
+    getUserDetails: safeRequire('./src/user', 'user')?.getUserDetails,
+    getAllConversationsSummary: safeRequire('./src/conversation', 'conversation')?.getAllConversationsSummary,
+    getConversationHistory: safeRequire('./src/conversation', 'conversation')?.getConversationHistory,
+    saveConversation: safeRequire('./src/conversation', 'conversation')?.saveConversation,
+    generateConversationSummary: safeRequire('./src/conversation', 'conversation')?.generateConversationSummary,
   
     // Post-processing and hair issues
-    postProcessConversation: require('./src/postResponseProcessing').postProcessConversation,
-    postResponseProcessing: require('./src/postResponseProcessing').postResponseProcessing,
-    updateUserProfile: require('./src/postResponseProcessing').updateUserProfile, 
-    saveHairIssue: require('./src/hairIssues').saveHairIssue,
-    getHairIssuesForUser: require('./src/hairIssues').getHairIssuesForUser,
-    postResponseProductCheck: require('./src/postResponseProcessing').postResponseProductCheck,
+    postProcessConversation: safeRequire('./src/postResponseProcessing', 'postResponseProcessing')?.postProcessConversation,
+    postResponseProcessing: safeRequire('./src/postResponseProcessing', 'postResponseProcessing')?.postResponseProcessing,
+    updateUserProfile: safeRequire('./src/postResponseProcessing', 'postResponseProcessing')?.updateUserProfile,
+    saveHairIssue: safeRequire('./src/hairIssues', 'hairIssues')?.saveHairIssue,
+    getHairIssuesForUser: safeRequire('./src/hairIssues', 'hairIssues')?.getHairIssuesForUser,
+    postResponseProductCheck: safeRequire('./src/postResponseProcessing', 'postResponseProcessing')?.postResponseProductCheck,
   
     // Utilities
-    getAllProducts: require('./src/utils').getAllProducts,
-    getAllFaqs: require('./src/utils').getAllFaqs,
-    getAllYoutubeVideos: require('./src/utils').getAllYoutubeVideos,
-    getAllTestimonials: require('./src/utils').getAllTestimonials,
-    getAdditionalInstructions: require('./src/utils').getAdditionalInstructions,
-
-    // Smart systems (Existing)
-    SmartPromptManager: require('./src/smartPromptManager'),
-    ResponseCache: require('./src/responseCache'),
-    ConversationAnalytics: require('./src/conversationAnalytics'),
-    ErrorRecoveryManager: require('./src/errorRecovery'),
-    PersonalizationEngine: require('./src/personalizationEngine'),
-    
-    // New enhanced systems
-    UnifiedChatHandler: require('./src/unifiedChatHandler'),
-    Logger: require('./src/logger').Logger,
-    createLogger: require('./src/logger').createLogger,
-    getLogger: require('./src/logger').getLogger,
-    Validator: require('./src/validation'),
-    ErrorHandler: require('./src/errorHandler'),
-    HealthMonitor: require('./src/healthMonitor')
-  };
+    getAllProducts: safeRequire('./src/utils', 'utils')?.getAllProducts,
+    getAllFaqs: safeRequire('./src/utils', 'utils')?.getAllFaqs,
+    getAllYoutubeVideos: safeRequire('./src/utils', 'utils')?.getAllYoutubeVideos,
+    getAllTestimonials: safeRequire('./src/utils', 'utils')?.getAllTestimonials,
+    getAdditionalInstructions: safeRequire('./src/utils', 'utils')?.getAdditionalInstructions,
+};
+
+// Smart systems - Load with proper error handling and fallbacks
+const smartModules = {
+    SmartPromptManager: null,
+    ResponseCache: null,
+    ConversationAnalytics: null,
+    ErrorRecoveryManager: null,
+    PersonalizationEngine: null,
+    UnifiedChatHandler: null
+};
+
+// Try to load smart modules
+const smartModulePaths = {
+    SmartPromptManager: './src/smartPromptManager',
+    ResponseCache: './src/responseCache',
+    ConversationAnalytics: './src/conversationAnalytics',
+    ErrorRecoveryManager: './src/errorRecovery',
+    PersonalizationEngine: './src/personalizationEngine',
+    UnifiedChatHandler: './src/unifiedChatHandler'
+};
+
+// Load each smart module with fallback
+for (const [moduleName, modulePath] of Object.entries(smartModulePaths)) {
+    try {
+        const loadedModule = require(modulePath);
+        
+        // Check if it's a constructor or needs default export
+        if (typeof loadedModule === 'function') {
+            smartModules[moduleName] = loadedModule;
+            console.log(`✅ Loaded ${moduleName} as constructor`);
+        } else if (loadedModule.default && typeof loadedModule.default === 'function') {
+            smartModules[moduleName] = loadedModule.default;
+            console.log(`✅ Loaded ${moduleName} from default export`);
+        } else if (loadedModule[moduleName] && typeof loadedModule[moduleName] === 'function') {
+            smartModules[moduleName] = loadedModule[moduleName];
+            console.log(`✅ Loaded ${moduleName} from named export`);
+        } else {
+            throw new Error(`Module ${moduleName} is not a constructor`);
+        }
+    } catch (error) {
+        console.error(`❌ Failed to load ${moduleName}:`, error.message);
+        
+        // Create fallback classes
+        switch (moduleName) {
+            case 'SmartPromptManager':
+                smartModules[moduleName] = require('./src/fallbacks/smartPromptManagerFallback');
+                break;
+            case 'ResponseCache':
+                smartModules[moduleName] = require('./src/fallbacks/responseCacheFallback');
+                break;
+            case 'ConversationAnalytics':
+                smartModules[moduleName] = require('./src/fallbacks/conversationAnalyticsFallback');
+                break;
+            case 'ErrorRecoveryManager':
+                smartModules[moduleName] = require('./src/fallbacks/errorRecoveryFallback');
+                break;
+            case 'PersonalizationEngine':
+                smartModules[moduleName] = require('./src/fallbacks/personalizationEngineFallback');
+                break;
+            case 'UnifiedChatHandler':
+                smartModules[moduleName] = require('./src/fallbacks/unifiedChatHandlerFallback');
+                break;
+        }
+        console.log(`⚠️ Using fallback for ${moduleName}`);
+    }
+}
+
+// Enhanced systems
+const enhancedModules = {
+    Logger: safeRequire('./src/logger', 'Logger')?.Logger,
+    createLogger: safeRequire('./src/logger', 'Logger')?.createLogger,
+    getLogger: safeRequire('./src/logger', 'Logger')?.getLogger,
+    Validator: safeRequire('./src/validation', 'Validator'),
+    ErrorHandler: safeRequire('./src/errorHandler', 'ErrorHandler'),
+    HealthMonitor: safeRequire('./src/healthMonitor', 'HealthMonitor')
+};
+
+// Export all modules
+module.exports = {
+    ...modules,
+    ...smartModules,
+    ...enhancedModules
+};
+
+// Log export summary
+console.log('📦 Core module exports summary:');
+console.log(`- Basic modules: ${Object.keys(modules).filter(k => modules[k] !== null).length}/${Object.keys(modules).length}`);
+console.log(`- Smart modules: ${Object.keys(smartModules).filter(k => smartModules[k] !== null).length}/${Object.keys(smartModules).length}`);
+console.log(`- Enhanced modules: ${Object.keys(enhancedModules).filter(k => enhancedModules[k] !== null).length}/${Object.keys(enhancedModules).length}`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myavana-bot-test-core",
-    "version": "2.0.2",
+    "version": "2.0.3",
     "description": "Shared bot functionality with enhanced features",
     "main": "index.js",
     "scripts": {

package/src/fallbacks/conversationAnalyticsFallback.js

@@ -0,0 +1,105 @@
+// conversationAnalyticsFallback.js - Minimal analytics tracking
+class ConversationAnalyticsFallback {
+    constructor() {
+        console.log('⚠️ Using ConversationAnalytics fallback implementation');
+        this.events = [];
+    }
+
+    async trackWelcomeEvent(userId) {
+        this.logEvent('welcome', userId, { timestamp: new Date() });
+    }
+
+    async trackUserMessage(userId, conversationId, message, contextAnalysis) {
+        this.logEvent('user_message', userId, {
+            conversationId,
+            messageLength: message.length,
+            timestamp: new Date()
+        });
+    }
+
+    async trackAIResponse(userId, conversationId, response, model, responseTime, cached) {
+        this.logEvent('ai_response', userId, {
+            conversationId,
+            model,
+            responseTime,
+            cached,
+            timestamp: new Date()
+        });
+        
+        // Log warnings for xAI usage
+        if (model.includes('xai')) {
+            console.warn('⚠️ xAI model used - this should be rare!');
+        }
+    }
+
+    async trackImageAnalysis(userId, conversationId, imageUrl, result, processingTime) {
+        this.logEvent('image_analysis', userId, {
+            conversationId,
+            processingTime,
+            success: !!result,
+            timestamp: new Date()
+        });
+    }
+
+    async trackConversionEvent(userId, conversationId, eventType, data) {
+        this.logEvent('conversion', userId, {
+            conversationId,
+            eventType,
+            ...data,
+            timestamp: new Date()
+        });
+    }
+
+    async trackUserSatisfaction(userId, conversationId, score, feedback) {
+        this.logEvent('satisfaction', userId, {
+            conversationId,
+            score,
+            feedback,
+            timestamp: new Date()
+        });
+    }
+
+    async trackModelFailure(model, error, responseTime) {
+        console.error(`🚨 Model failure: ${model} - ${error.message}`);
+        this.logEvent('model_failure', 'system', {
+            model,
+            error: error.message,
+            responseTime,
+            timestamp: new Date()
+        });
+    }
+
+    logEvent(type, userId, data) {
+        const event = { type, userId, data, timestamp: new Date() };
+        this.events.push(event);
+        
+        // Keep only last 1000 events in memory
+        if (this.events.length > 1000) {
+            this.events = this.events.slice(-1000);
+        }
+        
+        console.log(`📊 Event tracked (fallback): ${type}`);
+    }
+
+    async getUserAnalytics(userId, days = 30) {
+        const relevantEvents = this.events.filter(e => e.userId === userId);
+        return {
+            totalEvents: relevantEvents.length,
+            eventTypes: [...new Set(relevantEvents.map(e => e.type))]
+        };
+    }
+
+    detectHairJourneyStage(message) {
+        // Simple stage detection
+        const content = message.toLowerCase();
+        if (content.includes('new') || content.includes('starting')) return 'Stage 1: Something New';
+        if (content.includes('love') || content.includes('happy')) return 'Stage 2: I\'m Rocking This!';
+        if (content.includes('experiment') || content.includes('try')) return 'Stage 3: Experimenting';
+        if (content.includes('bored')) return 'Stage 4: Boredom';
+        if (content.includes('desperate') || content.includes('help')) return 'Stage 5: Desperation';
+        if (content.includes('damage') || content.includes('repair')) return 'Stage 6: Damage or Protection';
+        return 'Unknown';
+    }
+}
+
+module.exports = ConversationAnalyticsFallback;

package/src/fallbacks/errorRecoveryFallback.js

@@ -0,0 +1,154 @@
+// errorRecoveryFallback.js - Critical error recovery fallback
+class ErrorRecoveryManagerFallback {
+    constructor() {
+        console.log('⚠️ Using ErrorRecoveryManager fallback implementation');
+        
+        this.modelFailures = {
+            'gemini20FlashExp': 0,
+            'gemini15Flash': 0,
+            'gemini15Pro': 0,
+            'xai-grok-3-mini-fast': 0
+        };
+        
+        this.failureThreshold = 3;
+        this.resetInterval = 300000; // 5 minutes
+        
+        // Reset failure counts periodically
+        setInterval(() => this.resetFailureCounts(), this.resetInterval);
+    }
+
+    classifyError(error) {
+        const message = (error.message || '').toLowerCase();
+        
+        if (message.includes('rate limit') || message.includes('quota')) {
+            return 'rate_limit';
+        }
+        if (message.includes('timeout')) {
+            return 'timeout';
+        }
+        if (message.includes('context') || message.includes('token')) {
+            return 'context_too_large';
+        }
+        if (message.includes('json') || message.includes('parse')) {
+            return 'parsing_error';
+        }
+        return 'unknown';
+    }
+
+    canMakeRequest(modelName) {
+        return this.modelFailures[modelName] < this.failureThreshold;
+    }
+
+    recordSuccess(modelName) {
+        if (this.modelFailures[modelName] > 0) {
+            this.modelFailures[modelName]--;
+            console.log(`✅ ${modelName} success recorded, failures: ${this.modelFailures[modelName]}`);
+        }
+    }
+
+    recordFailure(modelName) {
+        this.modelFailures[modelName]++;
+        console.warn(`❌ ${modelName} failure recorded, total: ${this.modelFailures[modelName]}`);
+        
+        if (this.modelFailures[modelName] >= this.failureThreshold) {
+            console.error(`🚨 ${modelName} has reached failure threshold!`);
+        }
+    }
+
+    async attemptRecovery(error, operation, modelName, attempt = 1) {
+        const errorType = this.classifyError(error);
+        console.log(`🔄 Recovery attempt ${attempt} for ${errorType} error on ${modelName}`);
+        
+        this.recordFailure(modelName);
+        
+        // Simple retry logic
+        if (attempt > 2) {
+            console.error(`Max retries exceeded for ${modelName}`);
+            return null;
+        }
+        
+        // Wait before retry based on error type
+        const delays = {
+            rate_limit: 60000,
+            timeout: 5000,
+            context_too_large: 0,
+            parsing_error: 1000,
+            unknown: 2000
+        };
+        
+        const delay = delays[errorType] || 2000;
+        
+        if (delay > 0) {
+            console.log(`⏳ Waiting ${delay}ms before retry...`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        
+        return null; // Let caller handle retry
+    }
+
+    getEmergencyResponse() {
+        return {
+            messageType: 'html',
+            message: '<html><head><style>body{font-family:\'Archivo\',sans-serif;background-color:#f5f5f7;color:#222323;font-size:15px;line-height:1.5;}.highlight{font-family:\'Archivo Expanded Black\',sans-serif;font-size:14px;text-transform:uppercase;background-color:#fce5d7;color:#222323;padding:2px 6px;border-radius:4px;}</style></head><body><p>I\'m experiencing some technical difficulties. Let me connect you with a MYAVANA expert!</p><p>Try our <span class="highlight">HairAI™</span> analysis or book a consultation.</p></body></html>',
+            metadata: {
+                contentType: '300',
+                templateId: '12',
+                payload: [
+                    { title: 'Connect to expert', message: 'Connect me to a human expert' },
+                    { title: 'Learn about HairAI™', message: 'Tell me about HairAI™' },
+                    { title: 'Book consultation', message: 'I want to book a consultation' }
+                ]
+            },
+            emergency: true
+        };
+    }
+
+    getReducedContext(chatHistory, maxMessages = 3) {
+        if (!chatHistory || chatHistory.length <= maxMessages) {
+            return chatHistory;
+        }
+        return chatHistory.slice(-maxMessages);
+    }
+
+    getSimplifiedPrompt(prompt) {
+        // Extract essential parts only
+        const lines = prompt.split('\n');
+        const essential = lines.filter(line => {
+            const lower = line.toLowerCase();
+            return lower.includes('you are mya') ||
+                   lower.includes('critical') ||
+                   lower.includes('json') ||
+                   lower.includes('user:');
+        });
+        return essential.join('\n');
+    }
+
+    getAvailableModels() {
+        return Object.entries(this.modelFailures)
+            .filter(([model, failures]) => failures < this.failureThreshold)
+            .map(([model]) => model);
+    }
+
+    resetFailureCounts() {
+        for (const model in this.modelFailures) {
+            if (this.modelFailures[model] > 0) {
+                this.modelFailures[model] = Math.max(0, this.modelFailures[model] - 1);
+            }
+        }
+        console.log('🔄 Model failure counts decremented');
+    }
+
+    getHealthStatus() {
+        const status = {};
+        for (const [model, failures] of Object.entries(this.modelFailures)) {
+            status[model] = {
+                available: failures < this.failureThreshold,
+                failures,
+                health: failures === 0 ? 'healthy' : failures < this.failureThreshold ? 'degraded' : 'unhealthy'
+            };
+        }
+        return status;
+    }
+}
+
+module.exports = ErrorRecoveryManagerFallback;

package/src/fallbacks/personalizationEngineFallback.js

@@ -0,0 +1,149 @@
+// personalizationEngineFallback.js - Basic personalization fallback
+class PersonalizationEngineFallback {
+    constructor() {
+        console.log('⚠️ Using PersonalizationEngine fallback implementation');
+        this.userProfiles = new Map();
+    }
+
+    async analyzeUserPersona(userId) {
+        // Simple persona detection based on recent interactions
+        const profile = this.userProfiles.get(userId) || { 
+            messageCount: 0, 
+            topics: [],
+            persona: 'hair_journey_beginner' 
+        };
+        
+        // Basic persona assignment
+        if (profile.messageCount > 20) {
+            profile.persona = 'hair_enthusiast';
+        } else if (profile.topics.includes('quick') || profile.topics.includes('simple')) {
+            profile.persona = 'busy_professional';
+        } else if (profile.topics.includes('problem') || profile.topics.includes('issue')) {
+            profile.persona = 'problem_solver';
+        }
+        
+        return {
+            persona: profile.persona,
+            confidence: 0.7,
+            details: this.getPersonaDetails(profile.persona)
+        };
+    }
+
+    getPersonaDetails(persona) {
+        const personas = {
+            'hair_enthusiast': {
+                name: 'Hair Enthusiast',
+                response_style: 'detailed_technical'
+            },
+            'busy_professional': {
+                name: 'Busy Professional',
+                response_style: 'concise_actionable'
+            },
+            'hair_journey_beginner': {
+                name: 'Hair Journey Beginner',
+                response_style: 'educational_supportive'
+            },
+            'problem_solver': {
+                name: 'Problem Solver',
+                response_style: 'problem_solution_focused'
+            }
+        };
+        
+        return personas[persona] || personas['hair_journey_beginner'];
+    }
+
+    async getPersonalizedResponse(userId, query, baseResponse, context = {}) {
+        try {
+            // Track user interaction
+            const profile = this.userProfiles.get(userId) || { 
+                messageCount: 0, 
+                topics: [],
+                persona: 'hair_journey_beginner' 
+            };
+            
+            profile.messageCount++;
+            
+            // Simple topic tracking
+            const queryLower = query.toLowerCase();
+            if (queryLower.includes('product')) profile.topics.push('product');
+            if (queryLower.includes('routine')) profile.topics.push('routine');
+            if (queryLower.includes('problem')) profile.topics.push('problem');
+            
+            this.userProfiles.set(userId, profile);
+            
+            // For fallback, just return the base response
+            // Real personalization would modify the response based on persona
+            return baseResponse;
+            
+        } catch (error) {
+            console.error('Personalization fallback error:', error);
+            return baseResponse;
+        }
+    }
+
+    async getPersonalizationContext(userId) {
+        const profile = this.userProfiles.get(userId) || {
+            messageCount: 0,
+            topics: [],
+            persona: 'hair_journey_beginner',
+            lastActive: new Date()
+        };
+        
+        return {
+            messageCount: profile.messageCount,
+            topicsDiscussed: profile.topics,
+            persona: profile.persona,
+            isNewUser: profile.messageCount < 5
+        };
+    }
+
+    async trackPersonalizationMetrics(userId, persona, query, response) {
+        console.log(`📊 Personalization tracked (fallback): ${persona} for user ${userId}`);
+    }
+
+    // Helper methods for basic personalization
+    shouldUseDetailedResponse(persona) {
+        return persona === 'hair_enthusiast';
+    }
+
+    shouldUseConciseResponse(persona) {
+        return persona === 'busy_professional';
+    }
+
+    shouldIncludeEducation(persona) {
+        return persona === 'hair_journey_beginner';
+    }
+
+    getRecommendedSuggestions(persona) {
+        const suggestions = {
+            'hair_enthusiast': [
+                { title: 'Latest hair science', message: 'Tell me about the latest hair science' },
+                { title: 'Ingredient analysis', message: 'Analyze ingredients in my products' },
+                { title: 'Advanced techniques', message: 'What are advanced hair care techniques?' }
+            ],
+            'busy_professional': [
+                { title: 'Quick routine', message: 'Give me a 5-minute hair routine' },
+                { title: 'Time-saving tips', message: 'What are time-saving hair tips?' },
+                { title: 'Low maintenance', message: 'Suggest low maintenance styles' }
+            ],
+            'hair_journey_beginner': [
+                { title: 'Hair type', message: 'What\'s my hair type?' },
+                { title: 'Basic routine', message: 'Help me create a basic hair routine' },
+                { title: 'Learn about HairAI™', message: 'What is HairAI™?' }
+            ],
+            'problem_solver': [
+                { title: 'Diagnose issue', message: 'Help diagnose my hair problem' },
+                { title: 'Treatment options', message: 'What treatments do you recommend?' },
+                { title: 'Expert consultation', message: 'Should I book a consultation?' }
+            ]
+        };
+        
+        return suggestions[persona] || suggestions['hair_journey_beginner'];
+    }
+
+    clearUserProfile(userId) {
+        this.userProfiles.delete(userId);
+    }
+}
+
+module.exports = PersonalizationEngineFallback;

package/src/fallbacks/responseCacheFallback.js

@@ -0,0 +1,48 @@
+// responseCacheFallback.js - Minimal fallback for ResponseCache
+class ResponseCacheFallback {
+    constructor() {
+        console.log('⚠️ Using ResponseCache fallback implementation');
+        this.cache = new Map();
+        this.maxCacheSize = 100;
+        this.ttl = 300000; // 5 minutes
+    }
+
+    async getCachedResponse(userId, query) {
+        const key = `${userId}:${query.toLowerCase().trim()}`;
+        const cached = this.cache.get(key);
+        
+        if (cached && Date.now() - cached.timestamp < this.ttl) {
+            console.log('📦 Cache hit (fallback)');
+            return cached.response;
+        }
+        
+        return null;
+    }
+
+    async cacheResponse(userId, query, response) {
+        // Don't cache emergency responses or errors
+        if (response.emergency || response.error) return;
+        
+        const key = `${userId}:${query.toLowerCase().trim()}`;
+        
+        // Simple LRU - remove oldest if at capacity
+        if (this.cache.size >= this.maxCacheSize) {
+            const firstKey = this.cache.keys().next().value;
+            this.cache.delete(firstKey);
+        }
+        
+        this.cache.set(key, {
+            response,
+            timestamp: Date.now()
+        });
+        
+        console.log('💾 Response cached (fallback)');
+    }
+
+    clearCache() {
+        this.cache.clear();
+        console.log('🧹 Cache cleared (fallback)');
+    }
+}
+
+module.exports = ResponseCacheFallback;