Integrate initialization into app.py, add quantum emotion service, JSON emotion persistence, and improve rate limit handling

.gitignore

@@ -16,4 +16,5 @@ ENV/
 *.log
 chroma_db/
 memory.json
+emotions.json
 "import random.md"

agents/emotional_agent.py

@@ -1,6 +1,7 @@
 """Emotional State Agent - responsible for managing and updating emotional state"""
 import os
 import sys
+import json
 import random
 import logging
 import requests
@@ -14,11 +15,50 @@ class EmotionalStateAgent:
     
     def __init__(self, initial_state=None, config=None):
         self.config = config or MODEL_CONFIG or {}
-        self.emotional_state = initial_state or {"joy": 0.2, "sadness": 0.2, "anger": 0.2, "fear": 0.2, "curiosity": 0.2}
-        self.learning_rate = 0.05
+        
+        # Get JSON file path from config
+        emotions_config = self.config.get('emotions', {}) if self.config else {}
+        self.json_path = emotions_config.get('json_path', './emotions.json')
+        
+        # Load emotional state from JSON file if it exists, otherwise use initial_state or defaults
+        self.emotional_state = self._load_from_json() or initial_state or {"joy": 0.2, "sadness": 0.2, "anger": 0.2, "fear": 0.2, "curiosity": 0.2}
+        
+        # Slower learning rate for more gradual emotion changes
+        self.learning_rate = 0.03
         self.quantum_random_available = False
         self.quantum_api_key = None
         self._initialize_quantum()
+        
+        # Save initial state to JSON
+        self._save_to_json()
+    
+    def _load_from_json(self):
+        """Load emotional state from JSON file"""
+        try:
+            if os.path.exists(self.json_path):
+                with open(self.json_path, 'r', encoding='utf-8') as f:
+                    state = json.load(f)
+                    # Validate state structure
+                    required_emotions = ["joy", "sadness", "anger", "fear", "curiosity"]
+                    if all(emotion in state for emotion in required_emotions):
+                        logging.info(f"[EmotionalStateAgent] Loaded emotional state from {self.json_path}")
+                        return state
+                    else:
+                        logging.warning(f"[EmotionalStateAgent] Invalid state structure in {self.json_path}, using defaults")
+            else:
+                logging.info(f"[EmotionalStateAgent] No existing emotional state file found, starting fresh")
+        except Exception as e:
+            logging.warning(f"[EmotionalStateAgent] Error loading emotional state from JSON: {e}")
+        return None
+    
+    def _save_to_json(self):
+        """Save emotional state to JSON file"""
+        try:
+            with open(self.json_path, 'w', encoding='utf-8') as f:
+                json.dump(self.emotional_state, f, indent=2, ensure_ascii=False)
+            logging.debug(f"[EmotionalStateAgent] Saved emotional state to {self.json_path}")
+        except Exception as e:
+            logging.error(f"[EmotionalStateAgent] Error saving emotional state to JSON: {e}")
     
     def _initialize_quantum(self):
         """Initialize quantum randomness availability"""
@@ -55,37 +95,50 @@ class EmotionalStateAgent:
     
     def update_with_sentiment(self, sentiment_score):
         """Update emotional state based on sentiment"""
-        # Enhanced Emotion Update (decay and normalization with quantum randomness)
-        decay_factor = 0.9
+        # Slower decay factor to prevent emotions from crashing to minimum too fast
+        # Changed from 0.9 to 0.97 (only 3% decay per interaction instead of 10%)
+        decay_factor = 0.97
         if self.quantum_random_available:
-            quantum_decay_variation = self.get_quantum_random_float(0.85, 0.95)
+            quantum_decay_variation = self.get_quantum_random_float(0.95, 0.99)
             decay_factor = quantum_decay_variation
         
         for emotion in self.emotional_state:
-            # Decay emotions (more realistic fading with quantum variation)
+            # Decay emotions more slowly (preserves emotional state longer)
             self.emotional_state[emotion] *= decay_factor
-            # Normalize
+            # Clamp to valid range
             self.emotional_state[emotion] = max(0.0, min(1.0, self.emotional_state[emotion]))
 
-        # Apply sentiment with quantum-enhanced learning rate variation
+        # Apply sentiment with slower learning rate for gradual changes
         learning_rate = self.learning_rate
         if self.quantum_random_available:
-            quantum_lr_variation = self.get_quantum_random_float(0.03, 0.07)
+            quantum_lr_variation = self.get_quantum_random_float(0.02, 0.04)
             learning_rate = quantum_lr_variation
         
+        # Update emotions based on sentiment (slower, more gradual)
         self.emotional_state["joy"] += sentiment_score * learning_rate
         self.emotional_state["sadness"] -= sentiment_score * learning_rate
         
         # Add quantum randomness to curiosity (making responses more unpredictable)
         if self.quantum_random_available:
-            quantum_curiosity_boost = self.get_quantum_random_float(-0.05, 0.05)
+            quantum_curiosity_boost = self.get_quantum_random_float(-0.03, 0.03)
             self.emotional_state["curiosity"] = max(0.0, min(1.0, 
                 self.emotional_state["curiosity"] + quantum_curiosity_boost))
 
-        # Re-normalize
+        # Soft normalization - only normalize if emotions get too extreme
+        # This prevents emotions from being forced to equal values
         total_emotion = sum(self.emotional_state.values())
-        for emotion in self.emotional_state:
-            self.emotional_state[emotion] = self.emotional_state[emotion] / total_emotion if total_emotion > 0 else 0.2
+        if total_emotion > 1.5 or total_emotion < 0.5:
+            # Only normalize if emotions are way out of balance
+            for emotion in self.emotional_state:
+                self.emotional_state[emotion] = self.emotional_state[emotion] / total_emotion if total_emotion > 0 else 0.2
+        else:
+            # Just ensure no emotion goes below minimum threshold
+            for emotion in self.emotional_state:
+                if self.emotional_state[emotion] < 0.05:
+                    self.emotional_state[emotion] = 0.05
+        
+        # Save to JSON after update
+        self._save_to_json()
         
         logging.info(f"[EmotionalStateAgent] Updated emotional state: {self.emotional_state}")
         return self.emotional_state

app.py

@@ -1,10 +1,14 @@
 from flask import Flask, render_template, request, jsonify, url_for
 import os
+import sys
 import time
+import json
 from dotenv import load_dotenv
 import logging
 from threading import Thread
+from concurrent.futures import ThreadPoolExecutor, as_completed
 import nltk
+import requests
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -71,13 +75,12 @@ app = Flask(__name__, static_folder='static', template_folder='templates')
 galatea_ai = None
 dialogue_engine = None
 avatar_engine = None
+quantum_emotion_service = None
 is_initialized = False
 initializing = False
 gemini_initialized = False
 max_init_retries = 3
 current_init_retry = 0
-init_script_running = False
-init_script_complete = False
 
 # Check for required environment variables
 required_env_vars = ['GEMINI_API_KEY']
@@ -120,70 +123,324 @@ def initialize_gemini():
         logging.error(f"Error initializing Gemini API: {e}")
         return False
 
-def run_init_script():
-    """Run the initialization script in parallel"""
-    global init_script_running, init_script_complete
+# Global status tracking for parallel initialization
+init_status = {
+    'json_memory': {'ready': False, 'error': None},
+    'sentiment_analyzer': {'ready': False, 'error': None},
+    'gemini_api': {'ready': False, 'error': None},
+    'inflection_api': {'ready': False, 'error': None},
+    'quantum_api': {'ready': False, 'error': None},
+}
+
+def initialize_json_memory():
+    """Initialize JSON memory database"""
+    try:
+        logging.info("🔄 [JSON Memory] Initializing...")
+        print("🔄 [JSON Memory] Initializing...")
+        json_path = "./memory.json"
+        if os.path.exists(json_path):
+            with open(json_path, 'r', encoding='utf-8') as f:
+                memory = json.load(f)
+            logging.info(f"✓ [JSON Memory] Loaded {len(memory)} entries")
+            print(f"✓ [JSON Memory] Loaded {len(memory)} entries")
+        else:
+            with open(json_path, 'w', encoding='utf-8') as f:
+                json.dump({}, f)
+            logging.info("✓ [JSON Memory] Created new database")
+            print("✓ [JSON Memory] Created new database")
+        init_status['json_memory']['ready'] = True
+        return True
+    except Exception as e:
+        error_msg = f"JSON memory initialization failed: {e}"
+        logging.error(f"✗ [JSON Memory] {error_msg}")
+        print(f"✗ [JSON Memory] {error_msg}")
+        init_status['json_memory']['error'] = str(e)
+        return False
+
+def initialize_sentiment_analyzer():
+    """Initialize sentiment analyzer"""
+    try:
+        logging.info("🔄 [Sentiment Analyzer] Starting initialization...")
+        print("🔄 [Sentiment Analyzer] Starting initialization...")
+        try:
+            from transformers import pipeline
+            analyzer = pipeline(
+                "sentiment-analysis",
+                model="distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+            )
+            result = analyzer("test")
+            logging.info("✓ [Sentiment Analyzer] Hugging Face model loaded")
+            print("✓ [Sentiment Analyzer] Hugging Face model loaded")
+            init_status['sentiment_analyzer']['ready'] = True
+            return True
+        except ImportError:
+            logging.info("✓ [Sentiment Analyzer] Using fallback (NLTK VADER)")
+            print("✓ [Sentiment Analyzer] Using fallback (NLTK VADER)")
+            init_status['sentiment_analyzer']['ready'] = True
+            return True
+        except Exception as e:
+            error_msg = str(e)
+            if 'np.float_' in error_msg or 'NumPy 2' in error_msg or '_ARRAY_API' in error_msg:
+                logging.warning(f"⚠ [Sentiment Analyzer] NumPy compatibility issue - using fallback")
+                print("⚠ [Sentiment Analyzer] NumPy compatibility issue - using fallback")
+                init_status['sentiment_analyzer']['ready'] = True
+                return True
+            else:
+                raise
+    except Exception as e:
+        error_msg = f"Sentiment analyzer initialization failed: {e}"
+        logging.warning(f"⚠ [Sentiment Analyzer] {error_msg} - using fallback")
+        print(f"⚠ [Sentiment Analyzer] Using fallback")
+        init_status['sentiment_analyzer']['error'] = str(e)
+        init_status['sentiment_analyzer']['ready'] = True
+        return True
+
+def validate_gemini_api():
+    """Validate Gemini API key"""
+    try:
+        logging.info("🔄 [Gemini API] Validating API key...")
+        print("🔄 [Gemini API] Validating API key...")
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            logging.warning("⚠ [Gemini API] API key not found")
+            print("⚠ [Gemini API] API key not found")
+            init_status['gemini_api']['ready'] = False
+            return False
+        try:
+            from llm_wrapper import LLMWrapper
+            from config import MODEL_CONFIG
+            
+            # Get model from config
+            gemini_config = MODEL_CONFIG.get('gemini', {}) if MODEL_CONFIG else {}
+            gemini_model = gemini_config.get('model', 'gemini-2.0-flash-exp')
+            
+            wrapper = LLMWrapper(gemini_model=gemini_model)
+            response = wrapper.call_gemini(
+                messages=[{"role": "user", "content": "test"}],
+                max_tokens=5
+            )
+            if response:
+                logging.info("✓ [Gemini API] API key validated")
+                print("✓ [Gemini API] API key validated")
+                init_status['gemini_api']['ready'] = True
+                return True
+            else:
+                logging.warning("⚠ [Gemini API] Validation failed - no response")
+                print("⚠ [Gemini API] Validation failed - key exists, may be network issue")
+                return False
+        except Exception as e:
+            error_msg = str(e)
+            # Check status code from exception if available
+            status_code = getattr(e, 'status_code', None)
+            response_text = getattr(e, 'response_text', error_msg)
+            
+            # Check if it's a 404 (model not found) - this is a real error
+            if status_code == 404 or '404' in error_msg or 'NOT_FOUND' in error_msg:
+                logging.error(f"✗ [Gemini API] Model not found: {error_msg}")
+                print(f"✗ [Gemini API] Model not found - check models.yaml configuration")
+                init_status['gemini_api']['error'] = error_msg
+                return False
+            # Check if it's a 429 (rate limit/quota exceeded) - API key is valid, just quota issue
+            elif status_code == 429 or '429' in error_msg or 'RESOURCE_EXHAUSTED' in error_msg or 'quota' in response_text.lower():
+                logging.info("ℹ️  [Gemini API] Rate limit/quota exceeded (API key is valid)")
+                print("ℹ️  [Gemini API] Rate limit/quota exceeded (API key is valid, will work when quota resets)")
+                init_status['gemini_api']['ready'] = True  # Key is valid, just quota issue
+                init_status['gemini_api']['error'] = "Rate limit/quota exceeded"
+                return True  # Don't fail initialization - key is valid
+            else:
+                logging.warning(f"⚠ [Gemini API] Validation failed: {e}")
+                print("⚠ [Gemini API] Validation failed - key exists, may be network issue")
+                init_status['gemini_api']['ready'] = True
+                return True
+    except Exception as e:
+        error_msg = f"Gemini API validation failed: {e}"
+        logging.error(f"✗ [Gemini API] {error_msg}")
+        print(f"✗ [Gemini API] {error_msg}")
+        init_status['gemini_api']['error'] = str(e)
+        return False
+
+def validate_inflection_api():
+    """Validate Inflection AI API key"""
+    try:
+        logging.info("🔄 [Inflection AI] Validating API key...")
+        print("🔄 [Inflection AI] Validating API key...")
+        api_key = os.getenv("INFLECTION_AI_API_KEY")
+        if not api_key:
+            logging.warning("⚠ [Inflection AI] API key not found")
+            print("⚠ [Inflection AI] API key not found")
+            init_status['inflection_api']['ready'] = False
+            return False
+        url = "https://api.inflection.ai/external/api/inference"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        data = {
+            "context": [{"text": "test", "type": "Human"}],
+            "config": "Pi-3.1"
+        }
+        response = requests.post(url, headers=headers, json=data, timeout=10)
+        if response.status_code == 200:
+            logging.info("✓ [Inflection AI] API key validated")
+            print("✓ [Inflection AI] API key validated")
+            init_status['inflection_api']['ready'] = True
+            return True
+        else:
+            logging.warning(f"⚠ [Inflection AI] Validation failed: {response.status_code}")
+            print(f"⚠ [Inflection AI] Validation failed: {response.status_code}")
+            init_status['inflection_api']['ready'] = False
+            return False
+    except Exception as e:
+        error_msg = f"Inflection AI validation failed: {e}"
+        logging.warning(f"⚠ [Inflection AI] {error_msg}")
+        print(f"⚠ [Inflection AI] {error_msg}")
+        init_status['inflection_api']['ready'] = False
+        return False
+
+def validate_quantum_api():
+    """Validate Quantum Random Numbers API key (optional component)"""
+    try:
+        logging.info("🔄 [Quantum API] Validating API key...")
+        print("🔄 [Quantum API] Validating API key...")
+        api_key = os.getenv("ANU_QUANTUM_API_KEY")
+        if not api_key:
+            logging.info("ℹ️  [Quantum API] API key not found (optional - will use pseudo-random)")
+            print("ℹ️  [Quantum API] API key not found (optional - will use pseudo-random)")
+            init_status['quantum_api']['ready'] = False
+            return True  # Not an error - optional component
+        url = "https://api.quantumnumbers.anu.edu.au"
+        headers = {"x-api-key": api_key}
+        params = {"length": 1, "type": "uint8"}
+        response = requests.get(url, headers=headers, params=params, timeout=10)
+        if response.status_code == 200:
+            logging.info("✓ [Quantum API] API key validated")
+            print("✓ [Quantum API] API key validated")
+            init_status['quantum_api']['ready'] = True
+            return True
+        elif response.status_code == 429:
+            # Rate limit - not an error, just unavailable temporarily
+            logging.info("ℹ️  [Quantum API] Rate limited (optional - will use pseudo-random)")
+            print("ℹ️  [Quantum API] Rate limited (optional - will use pseudo-random)")
+            init_status['quantum_api']['ready'] = False
+            return True  # Not an error - optional component
+        else:
+            logging.info(f"ℹ️  [Quantum API] Validation failed: {response.status_code} (optional - will use pseudo-random)")
+            print(f"ℹ️  [Quantum API] Validation failed: {response.status_code} (optional - will use pseudo-random)")
+            init_status['quantum_api']['ready'] = False
+            return True  # Not an error - optional component
+    except Exception as e:
+        # Any exception is not critical - quantum randomness is optional
+        logging.info(f"ℹ️  [Quantum API] Unavailable: {e} (optional - will use pseudo-random)")
+        print(f"ℹ️  [Quantum API] Unavailable: {e} (optional - will use pseudo-random)")
+        init_status['quantum_api']['ready'] = False
+        return True  # Not an error - optional component
+
+def run_parallel_initialization():
+    """Run all initialization steps in parallel"""
+    start_time = time.time()
     
-    if init_script_running or init_script_complete:
-        return
+    logging.info("=" * 70)
+    logging.info("GALATEA AI PARALLEL INITIALIZATION")
+    logging.info("=" * 70)
+    logging.info("Starting parallel initialization of all components...")
+    logging.info("")
+    print("=" * 70)
+    print("GALATEA AI PARALLEL INITIALIZATION")
+    print("=" * 70)
+    print("Starting parallel initialization of all components...")
+    print("")
+    
+    tasks = [
+        ("JSON Memory", initialize_json_memory),
+        ("Sentiment Analyzer", initialize_sentiment_analyzer),
+        ("Gemini API", validate_gemini_api),
+        ("Inflection AI", validate_inflection_api),
+        ("Quantum API", validate_quantum_api),
+    ]
+    
+    completed_count = 0
+    total_tasks = len(tasks)
+    
+    with ThreadPoolExecutor(max_workers=5) as executor:
+        futures = {executor.submit(task[1]): task[0] for task in tasks}
+        
+        for future in as_completed(futures):
+            task_name = futures[future]
+            completed_count += 1
+            try:
+                result = future.result()
+                if result:
+                    logging.info(f"✅ [{task_name}] Completed successfully ({completed_count}/{total_tasks})")
+                    print(f"✅ [{task_name}] Completed successfully ({completed_count}/{total_tasks})")
+                else:
+                    logging.warning(f"⚠️  [{task_name}] Completed with warnings ({completed_count}/{total_tasks})")
+                    print(f"⚠️  [{task_name}] Completed with warnings ({completed_count}/{total_tasks})")
+            except Exception as e:
+                logging.error(f"❌ [{task_name}] Failed: {e} ({completed_count}/{total_tasks})")
+                print(f"❌ [{task_name}] Failed: {e} ({completed_count}/{total_tasks})")
+    
+    elapsed_time = time.time() - start_time
     
-    init_script_running = True
+    logging.info("")
     logging.info("=" * 70)
-    logging.info("RUNNING PARALLEL INITIALIZATION SCRIPT")
+    logging.info("INITIALIZATION SUMMARY")
     logging.info("=" * 70)
+    print("")
+    print("=" * 70)
+    print("INITIALIZATION SUMMARY")
+    print("=" * 70)
     
-    try:
-        import subprocess
-        import sys
+    all_ready = True
+    critical_ready = True
+    
+    for component, status in init_status.items():
+        status_icon = "✓" if status['ready'] else "✗"
+        error_info = f" - {status['error']}" if status['error'] else ""
+        status_msg = f"{status_icon} {component.upper()}: {'READY' if status['ready'] else 'FAILED'}{error_info}"
+        logging.info(status_msg)
+        print(status_msg)
         
-        # Run the initialization script
-        script_path = os.path.join(os.path.dirname(__file__), 'initialize_galatea.py')
-        result = subprocess.run(
-            [sys.executable, script_path],
-            capture_output=True,
-            text=True,
-            timeout=300  # 5 minute timeout
-        )
+        if component in ['json_memory', 'sentiment_analyzer', 'gemini_api']:
+            if not status['ready']:
+                critical_ready = False
         
-        if result.returncode == 0:
-            logging.info("✓ Initialization script completed successfully")
-            init_script_complete = True
+        if not status['ready']:
+            all_ready = False
+    
+    logging.info("")
+    logging.info(f"⏱️  Total initialization time: {elapsed_time:.2f} seconds")
+    logging.info("")
+    print("")
+    print(f"⏱️  Total initialization time: {elapsed_time:.2f} seconds")
+    print("")
+    
+    if critical_ready:
+        if all_ready:
+            logging.info("✅ ALL COMPONENTS INITIALIZED SUCCESSFULLY")
+            logging.info("🎉 Galatea AI is ready to use!")
+            print("✅ ALL COMPONENTS INITIALIZED SUCCESSFULLY")
+            print("🎉 Galatea AI is ready to use!")
+            return True
         else:
-            logging.error(f"✗ Initialization script failed with code {result.returncode}")
-            logging.error(f"Error output: {result.stderr}")
-            # Still mark as complete to allow app to continue
-            init_script_complete = True
-    except subprocess.TimeoutExpired:
-        logging.error("✗ Initialization script timed out")
-        init_script_complete = True
-    except Exception as e:
-        logging.error(f"✗ Error running initialization script: {e}")
-        init_script_complete = True
-    finally:
-        init_script_running = False
-        logging.info("=" * 70)
+            logging.info("⚠️  CRITICAL COMPONENTS READY (some optional components failed)")
+            logging.info("✅ Galatea AI is ready to use (with limited features)")
+            print("⚠️  CRITICAL COMPONENTS READY (some optional components failed)")
+            print("✅ Galatea AI is ready to use (with limited features)")
+            return True
+    else:
+        logging.error("❌ CRITICAL COMPONENTS FAILED")
+        logging.error("⚠️  Galatea AI may not function properly")
+        print("❌ CRITICAL COMPONENTS FAILED")
+        print("⚠️  Galatea AI may not function properly")
+        return False
 
 def initialize_components():
-    """Initialize Galatea components (runs after init script completes)"""
+    """Initialize Galatea components"""
     global galatea_ai, dialogue_engine, avatar_engine, is_initialized, initializing
-    global current_init_retry, gemini_initialized, init_script_complete
+    global current_init_retry, gemini_initialized
     
     if initializing or is_initialized:
         return
-    
-    # Wait for initialization script to complete (poll every 2 seconds)
-    max_wait_time = 300  # 5 minutes
-    wait_start = time.time()
-    while not init_script_complete:
-        elapsed = time.time() - wait_start
-        if elapsed > max_wait_time:
-            logging.warning("Initialization script timeout - proceeding anyway")
-            break
-        logging.info(f"Waiting for initialization script to complete... ({elapsed:.0f}s)")
-        time.sleep(2)
-    
-    if not init_script_complete:
-        logging.warning("Proceeding with component initialization despite init script not completing")
 
     if missing_gemini_key:
         logging.error("Initialization aborted: GEMINI_API_KEY missing")
@@ -208,6 +465,19 @@ def initialize_components():
         avatar_engine = AvatarEngine()
         avatar_engine.update_avatar(galatea_ai.emotional_state)
         
+        # Start quantum emotion service (background thread)
+        global quantum_emotion_service
+        try:
+            from quantum_emotion_service import QuantumEmotionService
+            quantum_emotion_service = QuantumEmotionService(galatea_ai.emotional_agent)
+            if quantum_emotion_service.start():
+                logging.info("✓ Quantum Emotion Service started")
+            else:
+                logging.info("ℹ️  Quantum Emotion Service not started (no API key or unavailable)")
+        except Exception as e:
+            logging.warning(f"⚠ Could not start Quantum Emotion Service: {e}")
+            quantum_emotion_service = None
+        
         # Check if all components are fully initialized
         init_status = galatea_ai.get_initialization_status()
         
@@ -264,11 +534,7 @@ def initialize_components():
 def home():
     # Add error handling for template rendering
     try:
-        # Start initialization script in background if not already started
-        if not init_script_complete and not init_script_running:
-            Thread(target=run_init_script, daemon=True).start()
-        
-        # Start component initialization after init script (will wait if script not done)
+        # Start component initialization if not already started
         if not is_initialized and not initializing and not missing_gemini_key:
             Thread(target=initialize_components, daemon=True).start()
             
@@ -557,8 +823,6 @@ def availability():
 @app.route('/api/is_initialized')
 def is_initialized_endpoint():
     """Lightweight endpoint for polling initialization progress"""
-    global init_script_running, init_script_complete
-    
     # Determine current initialization state
     if missing_gemini_key:
         return jsonify({
@@ -569,16 +833,6 @@ def is_initialized_endpoint():
             'status': 'missing_api_key'
         })
     
-    # Check if init script is still running
-    if init_script_running:
-        return jsonify({
-            'is_initialized': False,
-            'initializing': True,
-            'missing_gemini_key': False,
-            'status': 'running_init_script',
-            'message': 'Running parallel initialization...'
-        })
-    
     # Check if components are initializing
     if initializing:
         return jsonify({
@@ -626,20 +880,48 @@ def error_page():
 
 if __name__ == '__main__':
     print("Starting Galatea Web Interface...")
-    print("Initialization will begin automatically when the app starts.")
     
-    # Start initialization script immediately when app starts
+    # Run parallel initialization BEFORE starting Flask app
     logging.info("=" * 70)
     logging.info("STARTING GALATEA AI APPLICATION")
     logging.info("=" * 70)
-    logging.info("Launching parallel initialization script...")
+    logging.info("Running parallel initialization...")
+    print("=" * 70)
+    print("STARTING GALATEA AI APPLICATION")
+    print("=" * 70)
+    print("Running parallel initialization...")
+    print("")
     
-    # Start initialization script in background thread
-    Thread(target=run_init_script, daemon=True).start()
+    # Run parallel initialization synchronously
+    init_success = run_parallel_initialization()
+    
+    if not init_success:
+        logging.error("=" * 70)
+        logging.error("CRITICAL: Parallel initialization failed")
+        logging.error("Application will exit")
+        logging.error("=" * 70)
+        print("=" * 70)
+        print("CRITICAL: Parallel initialization failed")
+        print("Application will exit")
+        print("=" * 70)
+        sys.exit(1)
+    
+    # Now initialize Galatea components
+    logging.info("Initializing Galatea AI components...")
+    print("Initializing Galatea AI components...")
+    initialize_components()
+    
+    if not is_initialized:
+        logging.error("=" * 70)
+        logging.error("CRITICAL: Component initialization failed")
+        logging.error("Application will exit")
+        logging.error("=" * 70)
+        print("=" * 70)
+        print("CRITICAL: Component initialization failed")
+        print("Application will exit")
+        print("=" * 70)
+        sys.exit(1)
     
-    # Start component initialization (will wait for init script)
-    Thread(target=initialize_components, daemon=True).start()
-
     # Add debug logs for avatar shape changes
     logging.info("Avatar system initialized with default shape.")
 
@@ -648,6 +930,8 @@ if __name__ == '__main__':
 
     logging.info(f"Flask server starting on port {port}...")
     logging.info("Frontend will poll /api/is_initialized for status")
+    print(f"\nFlask server starting on port {port}...")
+    print("Frontend will poll /api/is_initialized for status\n")
     
     # Bind to 0.0.0.0 for external access (required for Hugging Face Spaces)
     app.run(host='0.0.0.0', port=port, debug=True)

initialize_galatea.py

@@ -1,400 +0,0 @@
-#!/usr/bin/env python3
-"""
-Galatea AI Initialization Script
-Handles parallel initialization of all components
-"""
-
-import os
-import sys
-import time
-import logging
-import threading
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from dotenv import load_dotenv
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(sys.stdout),
-        logging.FileHandler('initialization.log')
-    ]
-)
-
-# Check NumPy version before proceeding
-try:
-    import numpy as np
-    np_version = np.__version__
-    if np_version.startswith('2.'):
-        logging.error("=" * 70)
-        logging.error("NUM PY COMPATIBILITY ERROR")
-        logging.error("=" * 70)
-        logging.error(f"NumPy {np_version} is installed, but required libraries need NumPy < 2.0")
-        logging.error("")
-        logging.error("SOLUTION:")
-        logging.error("  Option 1: Run the fix script:")
-        logging.error("    python fix_numpy.py")
-        logging.error("")
-        logging.error("  Option 2: Manually downgrade:")
-        logging.error("    pip install 'numpy<2.0.0'")
-        logging.error("")
-        logging.error("  Option 3: Reinstall all dependencies:")
-        logging.error("    pip install -r requirements.txt")
-        logging.error("")
-        logging.error("This will downgrade NumPy to a compatible version.")
-        logging.error("=" * 70)
-        logging.warning("⚠ Continuing with initialization, but some components may fail...")
-        logging.warning("⚠ Please fix NumPy version for full functionality")
-    else:
-        logging.info(f"✓ NumPy version check passed: {np_version}")
-except ImportError:
-    logging.warning("NumPy not installed - will be installed as dependency")
-except Exception as e:
-    logging.warning(f"Could not check NumPy version: {e}")
-
-# Load environment variables
-load_dotenv()
-
-# Global status tracking
-init_status = {
-    'json_memory': {'ready': False, 'error': None},
-    'sentiment_analyzer': {'ready': False, 'error': None},
-    'gemini_api': {'ready': False, 'error': None},
-    'inflection_api': {'ready': False, 'error': None},
-    'quantum_api': {'ready': False, 'error': None},
-}
-
-# ChromaDB and embedding model removed - using JSON-only memory
-
-def initialize_sentiment_analyzer():
-    """Initialize sentiment analyzer"""
-    try:
-        logging.info("🔄 [Sentiment Analyzer] Starting initialization...")
-        print("🔄 [Sentiment Analyzer] Starting initialization...")
-        try:
-            from transformers import pipeline
-            analyzer = pipeline(
-                "sentiment-analysis",
-                model="distilbert/distilbert-base-uncased-finetuned-sst-2-english"
-            )
-            # Test it
-            result = analyzer("test")
-            logging.info("✓ [Sentiment Analyzer] Hugging Face model loaded")
-            print("✓ [Sentiment Analyzer] Hugging Face model loaded")
-            init_status['sentiment_analyzer']['ready'] = True
-            return True
-        except ImportError:
-            logging.info("✓ [Sentiment Analyzer] Using fallback (NLTK VADER)")
-            print("✓ [Sentiment Analyzer] Using fallback (NLTK VADER)")
-            init_status['sentiment_analyzer']['ready'] = True
-            return True
-        except Exception as e:
-            error_msg = str(e)
-            # Check for NumPy compatibility issues
-            if 'np.float_' in error_msg or 'NumPy 2' in error_msg or '_ARRAY_API' in error_msg:
-                logging.warning(f"⚠ [Sentiment Analyzer] NumPy compatibility issue - using fallback")
-                print("⚠ [Sentiment Analyzer] NumPy compatibility issue - using fallback")
-                init_status['sentiment_analyzer']['ready'] = True  # Fallback available
-                return True
-            else:
-                raise
-    except Exception as e:
-        error_msg = f"Sentiment analyzer initialization failed: {e}"
-        logging.warning(f"⚠ [Sentiment Analyzer] {error_msg} - using fallback")
-        print(f"⚠ [Sentiment Analyzer] Using fallback")
-        init_status['sentiment_analyzer']['error'] = str(e)
-        # Still mark as ready since we have fallback
-        init_status['sentiment_analyzer']['ready'] = True
-        return True
-
-def validate_gemini_api():
-    """Validate Gemini API key"""
-    try:
-        logging.info("🔄 [Gemini API] Validating API key...")
-        print("🔄 [Gemini API] Validating API key...")
-        api_key = os.getenv("GEMINI_API_KEY")
-        
-        if not api_key:
-            logging.warning("⚠ [Gemini API] API key not found")
-            print("⚠ [Gemini API] API key not found")
-            init_status['gemini_api']['ready'] = False
-            return False
-        
-        # Try to use custom LLM wrapper to validate
-        try:
-            from llm_wrapper import LLMWrapper
-            # Initialize wrapper with test model
-            wrapper = LLMWrapper(gemini_model="gemini-1.5-flash")
-            response = wrapper.call_gemini(
-                messages=[{"role": "user", "content": "test"}],
-                max_tokens=5
-            )
-            if response:
-                logging.info("✓ [Gemini API] API key validated")
-                print("✓ [Gemini API] API key validated")
-                init_status['gemini_api']['ready'] = True
-                return True
-            else:
-                logging.warning("⚠ [Gemini API] Validation failed - no response")
-                print("⚠ [Gemini API] Validation failed - key exists, may be network issue")
-                return False
-        except Exception as e:
-            logging.warning(f"⚠ [Gemini API] Validation failed: {e}")
-            print("⚠ [Gemini API] Validation failed - key exists, may be network issue")
-            # Still mark as available if key exists (might be network issue)
-            init_status['gemini_api']['ready'] = True
-            return True
-    except Exception as e:
-        error_msg = f"Gemini API validation failed: {e}"
-        logging.error(f"✗ [Gemini API] {error_msg}")
-        print(f"✗ [Gemini API] {error_msg}")
-        init_status['gemini_api']['error'] = str(e)
-        return False
-
-def validate_inflection_api():
-    """Validate Inflection AI API key"""
-    try:
-        logging.info("🔄 [Inflection AI] Validating API key...")
-        print("🔄 [Inflection AI] Validating API key...")
-        api_key = os.getenv("INFLECTION_AI_API_KEY")
-        
-        if not api_key:
-            logging.warning("⚠ [Inflection AI] API key not found")
-            print("⚠ [Inflection AI] API key not found")
-            init_status['inflection_api']['ready'] = False
-            return False
-        
-        # Test API key by making a simple request
-        import requests
-        url = "https://api.inflection.ai/external/api/inference"
-        headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json"
-        }
-        data = {
-            "context": [{"text": "test", "type": "Human"}],
-            "config": "Pi-3.1"
-        }
-        
-        response = requests.post(url, headers=headers, json=data, timeout=10)
-        if response.status_code == 200:
-            logging.info("✓ [Inflection AI] API key validated")
-            print("✓ [Inflection AI] API key validated")
-            init_status['inflection_api']['ready'] = True
-            return True
-        else:
-            logging.warning(f"⚠ [Inflection AI] Validation failed: {response.status_code}")
-            print(f"⚠ [Inflection AI] Validation failed: {response.status_code}")
-            init_status['inflection_api']['ready'] = False
-            return False
-    except Exception as e:
-        error_msg = f"Inflection AI validation failed: {e}"
-        logging.warning(f"⚠ [Inflection AI] {error_msg}")
-        print(f"⚠ [Inflection AI] {error_msg}")
-        # Don't fail initialization if this fails
-        init_status['inflection_api']['ready'] = False
-        return False
-
-def validate_quantum_api():
-    """Validate Quantum Random Numbers API key"""
-    try:
-        logging.info("🔄 [Quantum API] Validating API key...")
-        print("🔄 [Quantum API] Validating API key...")
-        api_key = os.getenv("ANU_QUANTUM_API_KEY")
-        
-        if not api_key:
-            logging.warning("⚠ [Quantum API] API key not found")
-            print("⚠ [Quantum API] API key not found")
-            init_status['quantum_api']['ready'] = False
-            return False
-        
-        # Test API key
-        import requests
-        url = "https://api.quantumnumbers.anu.edu.au"
-        headers = {"x-api-key": api_key}
-        params = {"length": 1, "type": "uint8"}
-        
-        response = requests.get(url, headers=headers, params=params, timeout=10)
-        if response.status_code == 200:
-            logging.info("✓ [Quantum API] API key validated")
-            print("✓ [Quantum API] API key validated")
-            init_status['quantum_api']['ready'] = True
-            return True
-        else:
-            logging.warning(f"⚠ [Quantum API] Validation failed: {response.status_code}")
-            print(f"⚠ [Quantum API] Validation failed: {response.status_code}")
-            init_status['quantum_api']['ready'] = False
-            return False
-    except Exception as e:
-        error_msg = f"Quantum API validation failed: {e}"
-        logging.warning(f"⚠ [Quantum API] {error_msg}")
-        print(f"⚠ [Quantum API] {error_msg}")
-        init_status['quantum_api']['ready'] = False
-        return False
-
-def initialize_json_memory():
-    """Initialize JSON memory database"""
-    try:
-        logging.info("🔄 [JSON Memory] Initializing...")
-        print("🔄 [JSON Memory] Initializing...")
-        import json
-        
-        json_path = "./memory.json"
-        if os.path.exists(json_path):
-            with open(json_path, 'r', encoding='utf-8') as f:
-                memory = json.load(f)
-            logging.info(f"✓ [JSON Memory] Loaded {len(memory)} entries")
-            print(f"✓ [JSON Memory] Loaded {len(memory)} entries")
-        else:
-            with open(json_path, 'w', encoding='utf-8') as f:
-                json.dump({}, f)
-            logging.info("✓ [JSON Memory] Created new database")
-            print("✓ [JSON Memory] Created new database")
-        
-        init_status['json_memory']['ready'] = True
-        return True
-    except Exception as e:
-        error_msg = f"JSON memory initialization failed: {e}"
-        logging.error(f"✗ [JSON Memory] {error_msg}")
-        print(f"✗ [JSON Memory] {error_msg}")
-        init_status['json_memory']['error'] = str(e)
-        return False
-
-def run_initialization():
-    """Run all initialization steps in parallel"""
-    start_time = time.time()
-    
-    logging.info("=" * 70)
-    logging.info("GALATEA AI PARALLEL INITIALIZATION")
-    logging.info("=" * 70)
-    logging.info("Starting parallel initialization of all components...")
-    logging.info("")
-    
-    # Define initialization tasks
-    tasks = [
-        ("JSON Memory", initialize_json_memory),
-        ("Sentiment Analyzer", initialize_sentiment_analyzer),
-        ("Gemini API", validate_gemini_api),
-        ("Inflection AI", validate_inflection_api),
-        ("Quantum API", validate_quantum_api),
-    ]
-    
-    # Run tasks in parallel
-    completed_count = 0
-    total_tasks = len(tasks)
-    
-    with ThreadPoolExecutor(max_workers=5) as executor:
-        futures = {executor.submit(task[1]): task[0] for task in tasks}
-        
-        for future in as_completed(futures):
-            task_name = futures[future]
-            completed_count += 1
-            try:
-                result = future.result()
-                if result:
-                    logging.info(f"✅ [{task_name}] Completed successfully ({completed_count}/{total_tasks})")
-                    print(f"✅ [{task_name}] Completed successfully ({completed_count}/{total_tasks})")
-                else:
-                    logging.warning(f"⚠️  [{task_name}] Completed with warnings ({completed_count}/{total_tasks})")
-                    print(f"⚠️  [{task_name}] Completed with warnings ({completed_count}/{total_tasks})")
-            except Exception as e:
-                logging.error(f"❌ [{task_name}] Failed: {e} ({completed_count}/{total_tasks})")
-                print(f"❌ [{task_name}] Failed: {e} ({completed_count}/{total_tasks})")
-    
-    elapsed_time = time.time() - start_time
-    
-    # Print summary
-    logging.info("")
-    logging.info("=" * 70)
-    logging.info("INITIALIZATION SUMMARY")
-    logging.info("=" * 70)
-    print("")
-    print("=" * 70)
-    print("INITIALIZATION SUMMARY")
-    print("=" * 70)
-    
-    all_ready = True
-    critical_ready = True
-    
-    for component, status in init_status.items():
-        status_icon = "✓" if status['ready'] else "✗"
-        error_info = f" - {status['error']}" if status['error'] else ""
-        status_msg = f"{status_icon} {component.upper()}: {'READY' if status['ready'] else 'FAILED'}{error_info}"
-        logging.info(status_msg)
-        print(status_msg)
-        
-        # Critical components (must be ready)
-        if component in ['json_memory', 'sentiment_analyzer', 'gemini_api']:
-            if not status['ready']:
-                critical_ready = False
-        
-        if not status['ready']:
-            all_ready = False
-    
-    logging.info("")
-    logging.info(f"⏱️  Total initialization time: {elapsed_time:.2f} seconds")
-    logging.info("")
-    print("")
-    print(f"⏱️  Total initialization time: {elapsed_time:.2f} seconds")
-    print("")
-    
-    # Check for NumPy compatibility issues
-    numpy_issue = False
-    for component, status in init_status.items():
-        if status.get('error') and ('np.float_' in str(status['error']) or 'NumPy 2' in str(status['error']) or '_ARRAY_API' in str(status['error'])):
-            numpy_issue = True
-            break
-    
-    if numpy_issue:
-        logging.error("")
-        logging.error("=" * 70)
-        logging.error("NUM PY COMPATIBILITY ISSUE DETECTED")
-        logging.error("=" * 70)
-        logging.error("Some components failed due to NumPy 2.0 incompatibility.")
-        logging.error("")
-        logging.error("TO FIX:")
-        logging.error("  1. Run: python fix_numpy.py")
-        logging.error("  2. Or: pip install 'numpy<2.0.0'")
-        logging.error("  3. Then restart the application")
-        logging.error("=" * 70)
-        logging.error("")
-    
-    # Determine final status
-    if critical_ready:
-        if all_ready:
-            logging.info("✅ ALL COMPONENTS INITIALIZED SUCCESSFULLY")
-            logging.info("🎉 Galatea AI is ready to use!")
-            print("✅ ALL COMPONENTS INITIALIZED SUCCESSFULLY")
-            print("🎉 Galatea AI is ready to use!")
-            return True
-        else:
-            logging.info("⚠️  CRITICAL COMPONENTS READY (some optional components failed)")
-            if numpy_issue:
-                logging.warning("⚠️  Some failures due to NumPy compatibility - fix NumPy for full functionality")
-            logging.info("✅ Galatea AI is ready to use (with limited features)")
-            print("⚠️  CRITICAL COMPONENTS READY (some optional components failed)")
-            print("✅ Galatea AI is ready to use (with limited features)")
-            return True
-    else:
-        logging.error("❌ CRITICAL COMPONENTS FAILED")
-        if numpy_issue:
-            logging.error("⚠️  Failures likely due to NumPy 2.0 - run 'python fix_numpy.py' to fix")
-        logging.error("⚠️  Galatea AI may not function properly")
-        print("❌ CRITICAL COMPONENTS FAILED")
-        print("⚠️  Galatea AI may not function properly")
-        return False
-
-if __name__ == "__main__":
-    try:
-        success = run_initialization()
-        sys.exit(0 if success else 1)
-    except KeyboardInterrupt:
-        logging.info("\n⚠️  Initialization interrupted by user")
-        sys.exit(1)
-    except Exception as e:
-        logging.error(f"\n❌ Fatal error during initialization: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-

llm_wrapper.py

@@ -126,10 +126,24 @@ class LLMWrapper:
                 logging.error(f"[LLMWrapper] Unexpected Gemini response format: {result}")
                 return None
             else:
-                logging.error(f"[LLMWrapper] Gemini API returned status {response.status_code}: {response.text}")
-                return None
+                # Raise exception with status code and response text so validation can catch it
+                error_text = response.text
+                logging.error(f"[LLMWrapper] Gemini API returned status {response.status_code}: {error_text}")
+                # Create exception with status code info for validation to catch
+                api_error = Exception(f"Gemini API status {response.status_code}: {error_text}")
+                api_error.status_code = response.status_code
+                api_error.response_text = error_text
+                raise api_error
                 
+        except requests.RequestException as e:
+            # Network/request errors - log and return None
+            logging.error(f"[LLMWrapper] Network error calling Gemini API: {e}")
+            return None
         except Exception as e:
+            # Re-raise status code errors so validation can catch them
+            if hasattr(e, 'status_code'):
+                raise
+            # Other errors - log and return None
             logging.error(f"[LLMWrapper] Error calling Gemini API: {e}")
             return None
     

models.yaml

@@ -41,6 +41,11 @@ memory:
   retrieval:
     max_retrieved_memories: 5
 
+# Emotional State Configuration
+emotions:
+  # JSON file path for emotional state persistence
+  json_path: "./emotions.json"
+
 # Conversation Configuration
 conversation:
   max_history_length: 20  # Number of messages to keep (user + assistant pairs)

nltk-stubs/__init__.pyi

@@ -0,0 +1,12 @@
+"""Type stubs for nltk"""
+from typing import Any
+
+class data:
+    @staticmethod
+    def find(resource_name: str, paths: list[str] = ...]) -> str: ...
+
+def download(info_or_id: str, download_dir: str = ..., quiet: bool = ..., force: bool = ...,
+             raise_on_error: bool = ..., halt_on_error: bool = ...) -> bool: ...
+
+def word_tokenize(text: str) -> list[str]: ...
+

nltk-stubs/sentiment/__init__.pyi

@@ -0,0 +1,2 @@
+"""Type stubs for nltk.sentiment"""
+

nltk-stubs/sentiment/vader.pyi

@@ -0,0 +1,6 @@
+"""Type stubs for nltk.sentiment.vader"""
+
+class SentimentIntensityAnalyzer:
+    def __init__(self, lexicon_file: str = ..., emoji_lexicon: str = ...) -> None: ...
+    def polarity_scores(self, text: str) -> dict[str, float]: ...
+

quantum_emotion_service.py

@@ -0,0 +1,185 @@
+"""Quantum Emotion Service - Background service for quantum-influenced emotion updates"""
+import os
+import sys
+import time
+import logging
+import requests
+import threading
+from collections import deque
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from config import MODEL_CONFIG
+
+class QuantumEmotionService:
+    """Background service that collects quantum random numbers and applies them to emotions"""
+    
+    def __init__(self, emotional_agent, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.emotional_agent = emotional_agent
+        self.quantum_api_key = os.getenv("ANU_QUANTUM_API_KEY")
+        self.running = False
+        self.thread = None
+        self.quantum_numbers = deque(maxlen=6)  # Store last 6 numbers
+        self.last_update_time = time.time()
+        self.update_interval = 10.0  # Update emotions every 10 seconds
+        self.call_interval = 1.0  # Call API once per second
+        
+        if not self.quantum_api_key:
+            logging.info("[QuantumEmotionService] Quantum API key not found - service will not run")
+            return
+        
+        quantum_config = self.config.get('quantum', {}) if self.config else {}
+        self.api_endpoint = quantum_config.get('api_endpoint', 'https://api.quantumnumbers.anu.edu.au')
+        
+        logging.info("[QuantumEmotionService] Initialized - will call API once per second")
+    
+    def _fetch_quantum_number(self):
+        """Fetch a single quantum random number from the API"""
+        if not self.quantum_api_key:
+            return None
+        
+        try:
+            headers = {"x-api-key": self.quantum_api_key}
+            params = {"length": 1, "type": "uint8"}
+            
+            response = requests.get(self.api_endpoint, headers=headers, params=params, timeout=5)
+            
+            if response.status_code == 200:
+                result = response.json()
+                if result.get('success') and 'data' in result and len(result['data']) > 0:
+                    # Normalize to 0-1 range
+                    normalized = result['data'][0] / 255.0
+                    return normalized
+            elif response.status_code == 429:
+                # Rate limited - return None, will use pseudo-random
+                logging.debug("[QuantumEmotionService] Rate limited, using pseudo-random")
+                return None
+            else:
+                logging.debug(f"[QuantumEmotionService] API returned {response.status_code}")
+                return None
+        except Exception as e:
+            logging.debug(f"[QuantumEmotionService] API call failed: {e}")
+            return None
+        
+        return None
+    
+    def _apply_quantum_emotions(self):
+        """Apply the collected 6 quantum numbers to influence emotion state"""
+        if len(self.quantum_numbers) < 6:
+            logging.debug(f"[QuantumEmotionService] Not enough numbers yet ({len(self.quantum_numbers)}/6)")
+            return
+        
+        # Convert deque to list
+        numbers = list(self.quantum_numbers)
+        
+        # Map 6 numbers to 5 emotions + overall variation
+        # numbers[0] -> joy
+        # numbers[1] -> sadness
+        # numbers[2] -> anger
+        # numbers[3] -> fear
+        # numbers[4] -> curiosity
+        # numbers[5] -> overall variation factor
+        
+        emotions = ["joy", "sadness", "anger", "fear", "curiosity"]
+        current_state = self.emotional_agent.get_state()
+        
+        # Apply quantum influence (subtle changes, -0.05 to +0.05 range)
+        for i, emotion in enumerate(emotions):
+            if i < len(numbers) and numbers[i] is not None:
+                # Convert 0-1 to -0.05 to +0.05 influence
+                influence = (numbers[i] - 0.5) * 0.1  # Scale to ±0.05
+                
+                # Apply with overall variation factor
+                if len(numbers) > 5 and numbers[5] is not None:
+                    variation = (numbers[5] - 0.5) * 0.02  # Additional ±0.01 variation
+                    influence += variation
+                
+                # Update emotion
+                new_value = current_state[emotion] + influence
+                current_state[emotion] = max(0.05, min(1.0, new_value))
+        
+        # Soft normalization to keep emotions balanced (only if they get too extreme)
+        total = sum(current_state.values())
+        if total > 1.5 or total < 0.5:
+            # Only normalize if emotions are way out of balance
+            for emotion in emotions:
+                current_state[emotion] = current_state[emotion] / total if total > 0 else 0.2
+        else:
+            # Just ensure no emotion goes below minimum threshold
+            for emotion in emotions:
+                if current_state[emotion] < 0.05:
+                    current_state[emotion] = 0.05
+        
+        # Update the emotional agent's state
+        self.emotional_agent.emotional_state = current_state
+        
+        # Save to JSON after quantum update
+        self.emotional_agent._save_to_json()
+        
+        logging.info(f"[QuantumEmotionService] Applied quantum influence: {current_state}")
+    
+    def _service_loop(self):
+        """Main service loop - calls API once per second, updates emotions every 10 seconds"""
+        logging.info("[QuantumEmotionService] Service started")
+        
+        while self.running:
+            try:
+                # Fetch quantum number (once per second)
+                quantum_num = self._fetch_quantum_number()
+                
+                if quantum_num is not None:
+                    self.quantum_numbers.append(quantum_num)
+                    logging.debug(f"[QuantumEmotionService] Collected quantum number: {quantum_num:.4f}")
+                else:
+                    # Use pseudo-random as fallback
+                    import random
+                    pseudo_random = random.random()
+                    self.quantum_numbers.append(pseudo_random)
+                    logging.debug(f"[QuantumEmotionService] Using pseudo-random: {pseudo_random:.4f}")
+                
+                # Check if it's time to update emotions (every 10 seconds)
+                current_time = time.time()
+                if current_time - self.last_update_time >= self.update_interval:
+                    if len(self.quantum_numbers) >= 6:
+                        self._apply_quantum_emotions()
+                        self.last_update_time = current_time
+                        logging.info(f"[QuantumEmotionService] Updated emotions with {len(self.quantum_numbers)} quantum numbers")
+                
+                # Wait 1 second before next call
+                time.sleep(self.call_interval)
+                
+            except Exception as e:
+                logging.error(f"[QuantumEmotionService] Error in service loop: {e}")
+                time.sleep(self.call_interval)  # Wait before retrying
+    
+    def start(self):
+        """Start the background service"""
+        if not self.quantum_api_key:
+            logging.info("[QuantumEmotionService] Cannot start - no API key")
+            return False
+        
+        if self.running:
+            logging.warning("[QuantumEmotionService] Already running")
+            return False
+        
+        self.running = True
+        self.thread = threading.Thread(target=self._service_loop, daemon=True)
+        self.thread.start()
+        logging.info("[QuantumEmotionService] Background service started")
+        return True
+    
+    def stop(self):
+        """Stop the background service"""
+        if not self.running:
+            return
+        
+        self.running = False
+        if self.thread:
+            self.thread.join(timeout=2.0)
+        logging.info("[QuantumEmotionService] Background service stopped")
+    
+    def is_running(self):
+        """Check if service is running"""
+        return self.running
+