Update app.py

app.py

@@ -23,42 +23,36 @@ regular_servers = [
     "https://rajhuggingface4253-compressor3pro.hf.space"
 ]
 
-# Models to warm - SIMPLE and CLEAN
+# Models to warm - SIMPLE prompts like frontend
 models_to_warm = [
     {
         "name": "Qwen 1",
         "url": "https://rajhuggingface4253-qwen.hf.space",
         "endpoint": "/chat",
-        "type": "streaming_chat",
+        "type": "sse_streaming",
         "timeout": 30.0,
         "payload": {
-            "prompt": "Hello, respond with OK if ready",
-            "max_new_tokens": 10,
-            "temperature": 0.1
+            "prompt": "Hello, respond with OK if ready"
         }
     },
     {
         "name": "Qwen 2", 
         "url": "https://rajhuggingface4253-qwen2.hf.space",
         "endpoint": "/chat",
-        "type": "streaming_chat",
+        "type": "sse_streaming",
         "timeout": 30.0,
         "payload": {
-            "prompt": "Hello, respond with OK if ready",
-            "max_new_tokens": 10,
-            "temperature": 0.1
+            "prompt": "Hello, respond with OK if ready"
         }
     },
     {
         "name": "Qwen 3",
         "url": "https://rajhuggingface4253-qwen3.hf.space",
         "endpoint": "/chat",
-        "type": "streaming_chat",
+        "type": "sse_streaming",
         "timeout": 30.0,
         "payload": {
-            "prompt": "Hello, respond with OK if ready",
-            "max_new_tokens": 10,
-            "temperature": 0.1
+            "prompt": "Hello, respond with OK if ready"
         }
     },
     {
@@ -98,8 +92,8 @@ async def ping_server(url: str) -> Dict:
             'timestamp': datetime.now().isoformat()
         }
 
-async def warmup_streaming_model(model_config: Dict) -> Dict:
-    """Warm up streaming models - SIMPLE and EFFECTIVE"""
+async def warmup_sse_streaming_model(model_config: Dict) -> Dict:
+    """Warm up models using PROPER SSE streaming (same as frontend)"""
     try:
         start_time = time.time()
         async with httpx.AsyncClient(timeout=model_config.get('timeout', 30.0)) as client:
@@ -107,7 +101,7 @@ async def warmup_streaming_model(model_config: Dict) -> Dict:
             payload = model_config['payload']
             api_url = f"{model_config['url']}{model_config['endpoint']}"
             
-            # Simple POST request to chat endpoint
+            # Make the SSE streaming request (same as frontend)
             response = await client.post(api_url, json=payload)
             
             if response.status_code != 200:
@@ -120,32 +114,45 @@ async def warmup_streaming_model(model_config: Dict) -> Dict:
                     'timestamp': datetime.now().isoformat()
                 }
             
-            # Read streaming response
+            # PROPER SSE STREAMING READING (same as frontend logic)
             collected_response = ""
-            async for chunk in response.aiter_text():
-                if chunk.strip():
-                    collected_response += chunk
+            
+            # Read the stream exactly like frontend does
+            async for chunk in response.aiter_bytes():
+                if chunk:
+                    try:
+                        text_chunk = chunk.decode('utf-8')
+                        collected_response += text_chunk
+                    except UnicodeDecodeError:
+                        # Skip binary chunks, focus on text
+                        continue
             
             response_time = round((time.time() - start_time) * 1000, 1)
             
-            # Success if we got any response
+            # Check if we got a valid AI response
             if collected_response:
+                # Simple validation - check if we got actual text content
+                is_ai_response = any(keyword in collected_response.lower() for keyword in 
+                                   ['hello', 'hi', 'ok', 'ready', 'yes', 'sure', 'pong'])
+                
                 return {
-                    'status': 'success',
+                    'status': 'success' if is_ai_response else 'error',
                     'response_time_ms': response_time,
                     'status_code': response.status_code,
-                    'model_response': collected_response[:100],
+                    'model_response': collected_response[:150],
                     'response_length': len(collected_response),
                     'got_response': True,
+                    'is_ai_response': is_ai_response,
                     'timestamp': datetime.now().isoformat()
                 }
             else:
                 return {
                     'status': 'error',
-                    'error': 'No response received',
+                    'error': 'Empty streaming response',
                     'response_time_ms': response_time,
                     'status_code': response.status_code,
                     'got_response': False,
+                    'is_ai_response': False,
                     'timestamp': datetime.now().isoformat()
                 }
                 
@@ -155,6 +162,7 @@ async def warmup_streaming_model(model_config: Dict) -> Dict:
             'error': 'Request timeout',
             'response_time_ms': round((time.time() - start_time) * 1000, 1),
             'got_response': False,
+            'is_ai_response': False,
             'timestamp': datetime.now().isoformat()
         }
     except Exception as e:
@@ -163,6 +171,7 @@ async def warmup_streaming_model(model_config: Dict) -> Dict:
             'error': str(e),
             'response_time_ms': round((time.time() - start_time) * 1000, 1),
             'got_response': False,
+            'is_ai_response': False,
             'timestamp': datetime.now().isoformat()
         }
 
@@ -204,8 +213,8 @@ async def warmup_model_health(model_config: Dict) -> Dict:
 
 async def warmup_single_model(model_config: Dict) -> Dict:
     """Route to appropriate warming method"""
-    if model_config.get('type') == 'streaming_chat':
-        return await warmup_streaming_model(model_config)
+    if model_config.get('type') == 'sse_streaming':
+        return await warmup_sse_streaming_model(model_config)
     else:
         return await warmup_model_health(model_config)
 
@@ -251,7 +260,9 @@ async def warmup_all_models():
         if result['status'] == 'success':
             response_time = result['response_time_ms']
             if result.get('got_response'):
-                print(f"✅ {model_name}: {response_time}ms")
+                ai_indicator = "✓AI" if result.get('is_ai_response') else "✗AI"
+                preview = result.get('model_response', '')[:50].replace('\n', ' ')
+                print(f"✅ {model_name}: {response_time}ms {ai_indicator} - '{preview}...'")
             else:
                 print(f"✅ {model_name}: {response_time}ms")
         else:
@@ -261,7 +272,8 @@ async def warmup_all_models():
     last_model_warmup = datetime.now()
     
     success_count = sum(1 for result in results if result['status'] == 'success')
-    print(f"🤖 {datetime.now().strftime('%H:%M:%S')} - Models: {success_count}/{len(models_to_warm)} Healthy")
+    ai_success_count = sum(1 for result in results if result.get('is_ai_response'))
+    print(f"🤖 {datetime.now().strftime('%H:%M:%S')} - Models: {success_count}/{len(models_to_warm)} Healthy ({ai_success_count} AI responding)")
     
     return results
 
@@ -346,6 +358,7 @@ async def home():
     regular_success = sum(1 for r in ping_results.values() if r.get('status') == 'success')
     model_success = sum(1 for r in model_warmup_results.values() if r['health_check'].get('status') == 'success')
     health_success = sum(1 for r in health_results.values() if r.get('status') == 'success')
+    ai_success = sum(1 for r in model_warmup_results.values() if r['health_check'].get('is_ai_response'))
     
     # Get model details for display
     model_statuses = []
@@ -354,18 +367,22 @@ async def home():
         health = data['health_check']
         
         status_display = "success" if health['status'] == 'success' else "error"
+        ai_indicator = " ✓AI" if health.get('is_ai_response') else ""
         error_display = f" - {health['error']}" if health.get('error') else ""
+        preview = f" - '{health.get('model_response', '')[:50]}...'" if health.get('model_response') else ""
         
         model_statuses.append({
             'name': model_info['name'],
             'type': model_info.get('type', 'health_check'),
             'status_display': status_display,
             'response_time': health.get('response_time_ms', 0),
-            'error_display': error_display
+            'ai_indicator': ai_indicator,
+            'error_display': error_display,
+            'preview': preview
         })
     
     model_status_html = "".join([
-        f"<li>{m['name']} ({m['type']}): <span class='{m['status_display']}'>{m['status_display']}</span> ({m['response_time']}ms){m['error_display']}</li>" 
+        f"<li>{m['name']} ({m['type']}): <span class='{m['status_display']}'>{m['status_display']}</span> ({m['response_time']}ms){m['ai_indicator']}{m['error_display']}{m['preview']}</li>" 
         for m in model_statuses
     ])
     
@@ -377,7 +394,7 @@ async def home():
                 body {{ font-family: Arial, sans-serif; margin: 40px; }}
                 .success {{ color: green; font-weight: bold; }}
                 .error {{ color: red; font-weight: bold; }}
-                .container {{ max-width: 1000px; margin: 0 auto; }}
+                .container {{ max-width: 1200px; margin: 0 auto; }}
                 .model-list {{ background: #f5f5f5; padding: 15px; border-radius: 5px; }}
             </style>
         </head>
@@ -393,6 +410,7 @@ async def home():
                     <div style="background: #e3f2fd; padding: 15px; border-radius: 8px;">
                         <h3>🤖 AI Models</h3>
                         <p><strong>{model_success}/{len(models_to_warm)} Healthy</strong></p>
+                        <p><strong>{ai_success}/{len(models_to_warm)} AI Responding</strong></p>
                     </div>
                     <div style="background: #fff3e0; padding: 15px; border-radius: 8px;">
                         <h3>🔗 Pinger Network</h3>
@@ -442,10 +460,12 @@ async def ping_now():
     """Manually trigger immediate warming"""
     results = await warmup_all_models()
     success_count = sum(1 for result in results if result['status'] == 'success')
+    ai_success_count = sum(1 for result in results if result.get('is_ai_response'))
     
     return JSONResponse({
         "message": "Manual warming completed",
         "models_healthy": f"{success_count}/{len(models_to_warm)}",
+        "ai_responding": f"{ai_success_count}/{len(models_to_warm)}",
         "timestamp": datetime.now().isoformat()
     })