Fix HF endpoint URL parsing and add scale-to-zero handling

app.py

@@ -105,18 +105,35 @@ with st.sidebar:
         except Exception as e:
             st.warning(f"🦙 Ollama: Status check failed")
         
-        # HF Endpoint Status
+        # Enhanced HF Status Display
+        st.subheader("HF Endpoint Status")
         try:
             from services.hf_endpoint_monitor import hf_monitor
-            hf_status = hf_monitor.get_status_summary()
-            if "🟢" in hf_status:
-                st.success(f"🤗 HF Endpoint: {hf_status.replace('🟢 ', '')}")
-            elif "🟡" in hf_status:
-                st.warning(f"🤗 HF Endpoint: {hf_status.replace('🟡 ', '')}")
+            
+            # Show current status
+            status_summary = hf_monitor.get_status_summary()
+            if "🟢" in status_summary:
+                st.success(status_summary)
+            elif "🟡" in status_summary:
+                st.warning(status_summary)
+                if st.button("⚡ Wake Up HF Endpoint"):
+                    with st.spinner("Waking up HF endpoint... (this may take 2-4 minutes)"):
+                        success = hf_monitor.handle_scale_to_zero()
+                        if success:
+                            st.success("✅ HF endpoint is now awake!")
+                        else:
+                            st.error("❌ Failed to wake up HF endpoint. Please try again.")
             else:
-                st.error(f"🤗 HF Endpoint: {hf_status.replace('🔴 ', '')}")
+                st.error(status_summary)
+                if st.button("🚀 Initialize HF Endpoint"):
+                    with st.spinner("Initializing HF endpoint... (this may take 2-4 minutes)"):
+                        success = hf_monitor.handle_scale_to_zero()
+                        if success:
+                            st.success("✅ HF endpoint initialized successfully!")
+                        else:
+                            st.error("❌ Failed to initialize HF endpoint.")
         except Exception as e:
-            st.warning("🤗 HF Endpoint: Status check failed")
+            st.error(f"❌ HF Monitor Error: {str(e)}")
         
         # Redis Status
         redis_healthy = check_redis_health()

services/hf_endpoint_monitor.py

@@ -10,57 +10,183 @@ class HFEndpointMonitor:
     """Monitor Hugging Face endpoint status and health"""
     
     def __init__(self):
-        self.endpoint_url = config.hf_api_url
+        # Clean the endpoint URL
+        raw_url = config.hf_api_url or ""
+        self.endpoint_url = self._clean_endpoint_url(raw_url)
         self.hf_token = config.hf_token
         self.is_initialized = False
         self.last_check = 0
         self.check_interval = 60  # Check every minute
-        self.warmup_count = 0
-        self.successful_requests = 0
-        self.failed_requests = 0
-        self.avg_response_time = 0
+        self.warmup_attempts = 0
+        self.max_warmup_attempts = 3
+        
+        logger.info(f"Initialized HF Monitor with URL: {self.endpoint_url}")
+
+    def _clean_endpoint_url(self, url: str) -> str:
+        """Clean and validate endpoint URL"""
+        if not url:
+            return ""
+            
+        # Remove environment variable names if present
+        url = url.replace('hf_api_endpoint_url=', '')
+        url = url.replace('HF_API_ENDPOINT_URL=', '')
+        
+        # Strip whitespace
+        url = url.strip()
+        
+        # Ensure it starts with https://
+        if url and not url.startswith(('http://', 'https://')):
+            if 'huggingface.cloud' in url:
+                url = 'https://' + url
+            else:
+                url = 'https://' + url
+        
+        # Remove trailing slashes but keep /v1 if present
+        if url.endswith('/'):
+            url = url.rstrip('/')
+            
+        return url
 
     def check_endpoint_status(self) -> Dict:
         """Check if HF endpoint is available and initialized"""
         try:
-            # Check if endpoint exists and is responsive
+            if not self.endpoint_url or not self.hf_token:
+                return {
+                    'available': False,
+                    'status_code': None,
+                    'initialized': False,
+                    'error': 'URL or token not configured',
+                    'timestamp': time.time()
+                }
+            
+            # Properly construct the models endpoint URL
+            models_url = f"{self.endpoint_url.rstrip('/')}/models"
+            logger.info(f"Checking HF endpoint at: {models_url}")
+            
             headers = {"Authorization": f"Bearer {self.hf_token}"}
             
-            # Simple model list check (doesn't trigger initialization)
             response = requests.get(
-                f"{self.endpoint_url}/models",
+                models_url,
                 headers=headers,
-                timeout=10
+                timeout=15
             )
             
             status_info = {
-                'available': response.status_code == 200,
+                'available': response.status_code in [200, 201],
                 'status_code': response.status_code,
                 'initialized': self._is_endpoint_initialized(response),
+                'response_time': response.elapsed.total_seconds(),
                 'timestamp': time.time()
             }
             
+            if response.status_code not in [200, 201]:
+                status_info['error'] = f"HTTP {response.status_code}: {response.text[:200]}"
+            
             logger.info(f"HF Endpoint Status: {status_info}")
             return status_info
             
         except Exception as e:
-            logger.error(f"HF endpoint check failed: {e}")
+            error_msg = str(e)
+            logger.error(f"HF endpoint check failed: {error_msg}")
             return {
                 'available': False,
                 'status_code': None,
                 'initialized': False,
-                'error': str(e),
+                'error': error_msg,
                 'timestamp': time.time()
             }
 
+    def _is_endpoint_initialized(self, response) -> bool:
+        """Determine if endpoint is fully initialized"""
+        try:
+            data = response.json()
+            return 'data' in data or 'models' in data
+        except:
+            return response.status_code in [200, 201]
+
+    def warm_up_endpoint(self) -> bool:
+        """Send a warm-up request to initialize the endpoint"""
+        try:
+            if not self.endpoint_url or not self.hf_token:
+                logger.warning("Cannot warm up HF endpoint - URL or token not configured")
+                return False
+            
+            self.warmup_attempts += 1
+            logger.info(f"Warming up HF endpoint (attempt {self.warmup_attempts})...")
+            
+            headers = {
+                "Authorization": f"Bearer {self.hf_token}",
+                "Content-Type": "application/json"
+            }
+            
+            # Construct proper chat completions URL
+            chat_url = f"{self.endpoint_url.rstrip('/')}/chat/completions"
+            logger.info(f"Sending warm-up request to: {chat_url}")
+            
+            payload = {
+                "model": "DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf",
+                "messages": [{"role": "user", "content": "Hello"}],
+                "max_tokens": 10,
+                "stream": False
+            }
+            
+            response = requests.post(
+                chat_url,
+                headers=headers,
+                json=payload,
+                timeout=45  # Longer timeout for cold start
+            )
+            
+            success = response.status_code in [200, 201]
+            if success:
+                self.is_initialized = True
+                self.warmup_attempts = 0  # Reset on success
+                logger.info("✅ HF endpoint warmed up successfully")
+            else:
+                logger.warning(f"⚠️ HF endpoint warm-up response: {response.status_code}")
+                logger.debug(f"Response body: {response.text[:500]}")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"HF endpoint warm-up failed: {e}")
+            return False
+
+    def get_status_summary(self) -> str:
+        """Get human-readable status summary"""
+        status = self.check_endpoint_status()
+        if status['available']:
+            if status.get('initialized', False):
+                return "🟢 HF Endpoint: Available and Initialized"
+            else:
+                return "🟡 HF Endpoint: Available but Initializing"
+        else:
+            return "🔴 HF Endpoint: Unavailable"
+
+    def handle_scale_to_zero(self) -> bool:
+        """Handle scale-to-zero behavior with user feedback"""
+        logger.info("HF endpoint appears to be scaled to zero. Attempting to wake it up...")
+        
+        # Try to warm up the endpoint
+        for attempt in range(self.max_warmup_attempts):
+            logger.info(f"Wake-up attempt {attempt + 1}/{self.max_warmup_attempts}")
+            if self.warm_up_endpoint():
+                logger.info("✅ HF endpoint successfully woken up!")
+                return True
+            time.sleep(10)  # Wait between attempts
+        
+        logger.error("❌ Failed to wake up HF endpoint after all attempts")
+        return False
+
     def get_detailed_status(self) -> Dict:
         """Get detailed HF endpoint status with metrics"""
         try:
             headers = {"Authorization": f"Bearer {self.hf_token}"}
             
             # Get model info
+            models_url = f"{self.endpoint_url.rstrip('/')}/models"
             model_response = requests.get(
-                f"{self.endpoint_url}/models",
+                models_url,
                 headers=headers,
                 timeout=10
             )
@@ -68,8 +194,9 @@ class HFEndpointMonitor:
             # Get endpoint info if available
             endpoint_info = {}
             try:
+                info_url = f"{self.endpoint_url.rstrip('/')}/info"
                 info_response = requests.get(
-                    f"{self.endpoint_url}/info",
+                    info_url,
                     headers=headers,
                     timeout=10
                 )
@@ -108,63 +235,5 @@ class HFEndpointMonitor:
             'average_response_time': getattr(self, 'avg_response_time', 0)
         }
 
-    def _is_endpoint_initialized(self, response) -> bool:
-        """Determine if endpoint is fully initialized"""
-        # If we get a model list, it's likely initialized
-        try:
-            data = response.json()
-            return 'data' in data or 'models' in data
-        except:
-            return False
-
-    def warm_up_endpoint(self) -> bool:
-        """Send a warm-up request to initialize the endpoint"""
-        try:
-            logger.info("Warming up HF endpoint...")
-            headers = {
-                "Authorization": f"Bearer {self.hf_token}",
-                "Content-Type": "application/json"
-            }
-            
-            # Simple test request to trigger initialization
-            payload = {
-                "model": "meta-llama/Llama-2-7b-chat-hf",  # Adjust as needed
-                "messages": [{"role": "user", "content": "Hello"}],
-                "max_tokens": 10
-            }
-            
-            response = requests.post(
-                f"{self.endpoint_url}/chat/completions",
-                headers=headers,
-                json=payload,
-                timeout=30
-            )
-            
-            success = response.status_code in [200, 201]
-            if success:
-                self.is_initialized = True
-                self.warmup_count += 1
-                logger.info("✅ HF endpoint warmed up successfully")
-            else:
-                logger.warning(f"⚠️ HF endpoint warm-up response: {response.status_code}")
-            
-            return success
-            
-        except Exception as e:
-            logger.error(f"HF endpoint warm-up failed: {e}")
-            self.failed_requests += 1
-            return False
-
-    def get_status_summary(self) -> str:
-        """Get human-readable status summary"""
-        status = self.check_endpoint_status()
-        if status['available']:
-            if status.get('initialized', False):
-                return "🟢 HF Endpoint: Available and Initialized"
-            else:
-                return "🟡 HF Endpoint: Available but Initializing"
-        else:
-            return "🔴 HF Endpoint: Unavailable"
-
 # Global instance
 hf_monitor = HFEndpointMonitor()

test_hf_url_fix.py

@@ -0,0 +1,53 @@
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+from utils.config import config
+from services.hf_endpoint_monitor import hf_monitor
+
+def test_hf_url_fix():
+    """Test the HF endpoint URL fix"""
+    print("=== HF Endpoint URL Fix Test ===")
+    print()
+    
+    # Test configuration parsing
+    print("1. Testing Configuration Parsing:")
+    print(f"   Raw HF_API_ENDPOINT_URL: {config.hf_api_url}")
+    print(f"   Parsed endpoint URL: {getattr(hf_monitor, 'endpoint_url', 'Not initialized')}")
+    print()
+    
+    # Test URL cleaning
+    print("2. Testing URL Cleaning:")
+    test_urls = [
+        "https://zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/",
+        "hf_api_endpoint_url=https://zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/",
+        "HF_API_ENDPOINT_URL=https://zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/",
+        "zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/"
+    ]
+    
+    for url in test_urls:
+        cleaned = hf_monitor._clean_endpoint_url(url) if hasattr(hf_monitor, '_clean_endpoint_url') else "Method not available"
+        print(f"   Input:  {url}")
+        print(f"   Output: {cleaned}")
+        print()
+    
+    # Test HF endpoint status (if token is available)
+    print("3. Testing HF Endpoint Status:")
+    try:
+        status = hf_monitor.check_endpoint_status()
+        print(f"   Available: {status.get('available', 'Unknown')}")
+        print(f"   Status Code: {status.get('status_code', 'Unknown')}")
+        print(f"   Initialized: {status.get('initialized', 'Unknown')}")
+        if 'error' in status:
+            print(f"   Error: {status['error']}")
+    except Exception as e:
+        print(f"   Error checking status: {e}")
+    
+    print()
+    print("🎉 HF Endpoint URL Fix Test Completed!")
+
+if __name__ == "__main__":
+    test_hf_url_fix()

utils/config.py

@@ -39,16 +39,29 @@ class Config:
         # Remove any trailing URL encoding artifacts
         url = url.rstrip('%0a').rstrip('%0d')
         
-        # Validate URL format - if it looks like a URL but missing scheme
-        if url and not re.match(r'^https?://', url):
+        # Handle the specific case where environment variable name is included
+        if 'hf_api_endpoint_url=' in url.lower():
+            # Extract the actual URL part
+            url = url.split('=')[-1]
+        
+        # Remove any protocol prefix issues
+        url = url.replace('hf_api_endpoint_url=', '')
+        url = url.replace('HF_API_ENDPOINT_URL=', '')
+        
+        # Ensure proper URL format
+        if url and not url.startswith(('http://', 'https://')):
             # Check if it looks like a domain
-            if re.match(r'^[a-zA-Z0-9.-]+(?:\.[a-zA-Z]{2,})+', url) or 'ngrok' in url:
-                # Assume https for ngrok and domains
+            if re.match(r'^[a-zA-Z0-9.-]+(?:\.[a-zA-Z]{2,})+', url) or 'huggingface.cloud' in url:
                 url = 'https://' + url
             else:
-                # Otherwise default to http
-                url = 'http://' + url
-                
+                url = 'https://' + url
+        
+        # Remove double slashes (but keep ://)
+        if '://' in url:
+            protocol, rest = url.split('://', 1)
+            rest = re.sub(r'//+', '/', rest)
+            url = protocol + '://' + rest
+            
         return url
         
     def _sanitize_host(self, host: str) -> str: