Add initialization diagnostics and background initialization

- Add initialization tracking (attempted, error state)
- Improve /api/health endpoint with detailed diagnostics
- Add background initialization thread for Gunicorn compatibility
- Initialize orchestrator on module import (works with Gunicorn)
- Add initialization error tracking and reporting
- Better error messages in health check endpoint

flask_api_standalone.py

@@ -141,10 +141,15 @@ def set_security_headers(response):
 # Global orchestrator
 orchestrator = None
 orchestrator_available = False
+initialization_attempted = False
+initialization_error = None
 
 def initialize_orchestrator():
     """Initialize the AI orchestrator with local GPU models"""
-    global orchestrator, orchestrator_available
+    global orchestrator, orchestrator_available, initialization_attempted, initialization_error
+    
+    initialization_attempted = True
+    initialization_error = None
     
     try:
         logger.info("=" * 60)
@@ -271,6 +276,7 @@ def initialize_orchestrator():
         except Exception as fallback_error:
             logger.error(f"❌ Failed to initialize in API-only mode: {fallback_error}", exc_info=True)
             orchestrator_available = False
+            initialization_error = str(fallback_error)
             return False
     except Exception as e:
         logger.error("=" * 60)
@@ -281,6 +287,7 @@ def initialize_orchestrator():
         logger.error("=" * 60)
         logger.error("Full traceback:", exc_info=True)
         orchestrator_available = False
+        initialization_error = f"{type(e).__name__}: {str(e)}"
         return False
 
 # Root endpoint
@@ -309,11 +316,24 @@ def root():
 # Health check
 @app.route('/api/health', methods=['GET'])
 def health_check():
-    """Health check endpoint"""
-    return jsonify({
-        'status': 'healthy' if orchestrator_available else 'initializing',
-        'orchestrator_ready': orchestrator_available
-    })
+    """Health check endpoint with detailed diagnostics"""
+    status = {
+        'status': 'healthy' if orchestrator_available else 'unhealthy',
+        'orchestrator_ready': orchestrator_available,
+        'initialization_attempted': initialization_attempted,
+    }
+    
+    if not orchestrator_available:
+        if initialization_error:
+            status['error'] = initialization_error
+            status['message'] = 'Initialization failed. Check logs for details.'
+        elif initialization_attempted:
+            status['message'] = 'Initialization completed but orchestrator not available'
+        else:
+            status['message'] = 'Initialization not yet attempted'
+            status['help'] = 'Try POST /api/initialize to trigger initialization'
+    
+    return jsonify(status)
 
 # Chat endpoint
 @app.route('/api/chat', methods=['POST'])
@@ -642,14 +662,61 @@ def set_context_mode():
             'error': str(e)
         }), 500
 
-# Initialize on startup
+# Initialize orchestrator on module import (for Gunicorn compatibility)
+# This ensures initialization happens even when running via Gunicorn
+logger.info("=" * 60)
+logger.info("FLASK API MODULE LOADED")
+logger.info("=" * 60)
+logger.info("Initializing orchestrator on module import...")
+
+# Use a flag to prevent multiple simultaneous initializations
+import threading
+_init_lock = threading.Lock()
+_init_started = False
+
+def _start_initialization():
+    """Start initialization in background thread to avoid blocking"""
+    global _init_started
+    with _init_lock:
+        if _init_started:
+            return
+        _init_started = True
+    
+    def init_worker():
+        try:
+            logger.info("Background initialization thread started")
+            initialize_orchestrator()
+        except Exception as e:
+            logger.error(f"Background initialization failed: {e}", exc_info=True)
+    
+    # Start initialization in background thread
+    init_thread = threading.Thread(target=init_worker, daemon=True, name="OrchInit")
+    init_thread.start()
+    logger.info("Initialization thread started (non-blocking)")
+
+# Start initialization when module is imported
+_start_initialization()
+
+# Initialize on startup (for direct execution)
 if __name__ == '__main__':
     logger.info("=" * 60)
-    logger.info("STARTING PURE FLASK API")
+    logger.info("STARTING PURE FLASK API (Direct Execution)")
     logger.info("=" * 60)
     
-    # Initialize orchestrator
-    initialize_orchestrator()
+    # Wait a moment for background initialization if it hasn't completed
+    import time
+    if not orchestrator_available:
+        logger.info("Waiting for background initialization to complete...")
+        for i in range(30):  # Wait up to 30 seconds
+            if orchestrator_available:
+                break
+            time.sleep(1)
+            if i % 5 == 0:
+                logger.info(f"Still waiting... ({i}s)")
+    
+    if not orchestrator_available:
+        logger.warning("Orchestrator not ready after wait, attempting direct initialization...")
+        initialize_orchestrator()
     
     port = int(os.getenv('PORT', 7860))