Update app.py

app.py

@@ -295,69 +295,189 @@ def call_vlm(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Tup
     if not os.path.exists(face_path) or not os.path.exists(eye_path):
         raise FileNotFoundError("Face or eye image path missing")
     
+    logger.info("VLM Input - Face: %s (exists: %s, size: %d bytes)", 
+                face_path, os.path.exists(face_path), os.path.getsize(face_path))
+    logger.info("VLM Input - Eye: %s (exists: %s, size: %d bytes)", 
+                eye_path, os.path.exists(eye_path), os.path.getsize(eye_path))
+    logger.info("VLM Prompt: %s", prompt[:100])
+    
     client = get_gradio_client(GRADIO_VLM_SPACE)
     message = {"text": prompt, "files": [handle_file(face_path), handle_file(eye_path)]}
     
     try:
-        logger.info("Calling VLM Space: %s", GRADIO_VLM_SPACE)
+        logger.info("Calling VLM Space: %s with api_name=/chat_fn", GRADIO_VLM_SPACE)
         result = client.predict(message=message, history=[], api_name="/chat_fn")
+        logger.info("VLM raw result type: %s", type(result))
+        logger.info("VLM raw result: %s", str(result)[:500])
     except Exception as e:
         logger.exception("VLM call failed")
         raise RuntimeError(f"VLM call failed: {e}")
     
-    # Normalize result
+    # Normalize result - handle different return formats
     if isinstance(result, (list, tuple)):
-        out = result[0]
+        logger.info("VLM returned list/tuple with %d elements", len(result))
+        if len(result) > 0:
+            out = result[0]
+        else:
+            out = {}
     elif isinstance(result, dict):
+        logger.info("VLM returned dict with keys: %s", list(result.keys()))
         out = result
     else:
+        logger.info("VLM returned unknown type, converting to string")
         out = {"text": str(result)}
     
-    text_out = out.get("text") or out.get("output") or json.dumps(out)
+    # Extract text from various possible formats
+    text_out = None
+    if isinstance(out, dict):
+        text_out = out.get("text") or out.get("output") or out.get("content")
+    
+    if not text_out:
+        # If still no text, try the whole result
+        if isinstance(result, str):
+            text_out = result
+        else:
+            text_out = json.dumps(out)
+    
+    logger.info("VLM extracted text (first 300 chars): %s", text_out[:300] if text_out else "EMPTY")
+    
+    if not text_out or len(text_out.strip()) == 0:
+        logger.warning("VLM returned empty text output!")
+        text_out = "{}"  # Provide empty JSON as fallback
     
     # Try to parse JSON
     parsed = None
     try:
         parsed = json.loads(text_out)
         if not isinstance(parsed, dict):
+            logger.warning("VLM JSON parsed but not a dict: %s", type(parsed))
             parsed = None
-    except Exception:
+        else:
+            logger.info("VLM successfully parsed JSON with keys: %s", list(parsed.keys()))
+    except Exception as parse_err:
+        logger.info("VLM text is not direct JSON: %s", str(parse_err))
         # Try to extract JSON from text
         try:
             first = text_out.find("{")
             last = text_out.rfind("}")
             if first != -1 and last != -1 and last > first:
-                parsed = json.loads(text_out[first:last+1])
+                json_str = text_out[first:last+1]
+                parsed = json.loads(json_str)
                 if not isinstance(parsed, dict):
+                    logger.warning("Extracted JSON is not a dict")
                     parsed = None
-        except Exception:
+                else:
+                    logger.info("Successfully extracted JSON from text with keys: %s", list(parsed.keys()))
+        except Exception as extract_err:
+            logger.warning("Could not extract JSON from VLM text: %s", str(extract_err))
             parsed = None
     
     return parsed, text_out
 
-def call_llm(vlm_output: Any) -> Dict[str, Any]:
+def get_fallback_risk_assessment(vlm_output: Any, reason: str = "LLM unavailable") -> Dict[str, Any]:
+    """Generate basic risk assessment from VLM output when LLM is unavailable"""
+    logger.warning("Using fallback risk assessment: %s", reason)
+    
+    # Try to extract basic info from VLM output
+    vlm_dict = {}
+    if isinstance(vlm_output, dict):
+        vlm_dict = vlm_output
+    elif isinstance(vlm_output, str):
+        try:
+            vlm_dict = json.loads(vlm_output)
+        except Exception:
+            pass
+    
+    # Check if VLM data is empty/invalid
+    has_data = bool(vlm_dict and any(vlm_dict.values()))
+    
+    if not has_data:
+        logger.warning("VLM output is empty or invalid, returning minimal assessment")
+        return {
+            "risk_score": 0.0,
+            "jaundice_probability": 0.0,
+            "anemia_probability": 0.0,
+            "hydration_issue_probability": 0.0,
+            "neurological_issue_probability": 0.0,
+            "confidence": 0.1,
+            "summary": "Unable to analyze images. Please ensure photos are clear and well-lit.",
+            "recommendation": "Retake photos with better lighting and clearer view of face and eyes.",
+            "fallback_mode": True,
+            "fallback_reason": "no_vlm_data"
+        }
+    
+    # Basic heuristic risk scoring based on VLM features
+    risk_score = 20.0  # Conservative default
+    jaundice_prob = 0.0
+    anemia_prob = 0.0
+    hydration_prob = 0.0
+    neuro_prob = 0.0
+    
+    # Extract VLM features if available
+    # Look for color indicators
+    sclera_yellow = vlm_dict.get("sclera_yellowness", 0)
+    pallor = vlm_dict.get("pallor_score", 0)
+    redness = vlm_dict.get("redness", 0)
+    
+    if isinstance(sclera_yellow, (int, float)) and sclera_yellow > 0.3:
+        jaundice_prob = min(0.6, sclera_yellow)
+        risk_score += 15
+    
+    if isinstance(pallor, (int, float)) and pallor > 0.4:
+        anemia_prob = min(0.7, pallor)
+        risk_score += 20
+    
+    if isinstance(redness, (int, float)) and redness > 0.5:
+        hydration_prob = min(0.5, redness * 0.8)
+        risk_score += 10
+    
+    return {
+        "risk_score": round(min(100.0, risk_score), 2),
+        "jaundice_probability": round(jaundice_prob, 4),
+        "anemia_probability": round(anemia_prob, 4),
+        "hydration_issue_probability": round(hydration_prob, 4),
+        "neurological_issue_probability": round(neuro_prob, 4),
+        "confidence": 0.4,  # Low confidence for fallback
+        "summary": "Basic screening completed. Advanced AI analysis temporarily unavailable.",
+        "recommendation": "Consider consulting a healthcare professional for a comprehensive assessment.",
+        "fallback_mode": True,
+        "fallback_reason": reason
+    }
+
+def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, Any]:
     """Call LLM with VLM output and return structured risk assessment"""
     if not GRADIO_AVAILABLE:
+        if use_fallback_on_error:
+            return get_fallback_risk_assessment(vlm_output, reason="gradio_not_available")
         raise RuntimeError("gradio_client not installed")
     
-    client = get_gradio_client(LLM_GRADIO_SPACE)
-    
-    # Prepare input
+    # Check if VLM output is empty/useless
     vlm_text = vlm_output if isinstance(vlm_output, str) else json.dumps(vlm_output, default=str)
     
+    # Detect empty or minimal VLM output
+    if not vlm_text or vlm_text.strip() in ["{}", "[]", ""]:
+        logger.warning("VLM output is empty, using fallback assessment")
+        if use_fallback_on_error:
+            return get_fallback_risk_assessment(vlm_output, reason="empty_vlm_output")
+        raise RuntimeError("VLM output is empty")
+    
+    # Prepare input
     instruction = (
         "\n\nSTRICT INSTRUCTIONS:\n"
         "1) OUTPUT ONLY a single valid JSON object — no prose, no code fences.\n"
         "2) Include keys: risk_score, jaundice_probability, anemia_probability, "
         "hydration_issue_probability, neurological_issue_probability, summary, recommendation, confidence.\n"
         "3) Use numeric values for probabilities (0-1) and risk_score (0-100).\n"
-        "4) Use neutral wording in summary/recommendation.\n\n"
+        "4) Use neutral wording in summary/recommendation.\n"
+        "5) If VLM data is minimal or unclear, set low probabilities and low confidence.\n\n"
         "VLM Output:\n" + vlm_text + "\n"
     )
     
     # Call with safe defaults
     try:
+        client = get_gradio_client(LLM_GRADIO_SPACE)
         logger.info("Calling LLM Space: %s", LLM_GRADIO_SPACE)
+        
         result = client.predict(
             input_data=instruction,
             max_new_tokens=1024.0,
@@ -378,10 +498,36 @@ def call_llm(vlm_output: Any) -> Dict[str, Any]:
         parsed = extract_json_from_llm_output(text_out)
         logger.info("LLM parsed JSON:\n%s", json.dumps(parsed, indent=2))
         
+        # Check if LLM returned essentially empty results (all zeros)
+        all_zero = all(
+            parsed.get(k, 0) == 0 
+            for k in ["jaundice_probability", "anemia_probability", 
+                     "hydration_issue_probability", "neurological_issue_probability"]
+        )
+        
+        if all_zero and parsed.get("risk_score", 0) == 0:
+            logger.warning("LLM returned all-zero assessment, likely due to poor VLM input")
+            parsed["summary"] = "Image analysis incomplete. Please ensure photos are clear and well-lit."
+            parsed["recommendation"] = "Retake photos with face clearly visible and eyes open."
+            parsed["confidence"] = 0.1
+        
         return parsed
         
     except Exception as e:
-        logger.exception("LLM call failed")
+        logger.exception("LLM call failed: %s", str(e))
+        
+        # Check if it's a quota error
+        error_msg = str(e).lower()
+        if "quota" in error_msg or "gpu" in error_msg:
+            logger.warning("GPU quota exceeded, using fallback assessment")
+            if use_fallback_on_error:
+                return get_fallback_risk_assessment(vlm_output, reason="gpu_quota_exceeded")
+        
+        # For other errors, also use fallback if enabled
+        if use_fallback_on_error:
+            logger.warning("LLM error, using fallback assessment")
+            return get_fallback_risk_assessment(vlm_output, reason=f"llm_error: {str(e)[:100]}")
+        
         raise RuntimeError(f"LLM call failed: {e}")
 
 # ============================================================================
@@ -421,9 +567,9 @@ async def process_screening(screening_id: str):
         # Call VLM
         vlm_features, vlm_raw = await asyncio.to_thread(call_vlm, face_path, eye_path)
         
-        # Call LLM
+        # Call LLM with fallback enabled
         llm_input = vlm_raw if vlm_raw else (vlm_features if vlm_features else "{}")
-        structured_risk = await asyncio.to_thread(call_llm, llm_input)
+        structured_risk = await asyncio.to_thread(call_llm, llm_input, use_fallback_on_error=True)
         
         # Store results
         screenings_db[screening_id]["ai_results"] = {
@@ -487,12 +633,37 @@ async def read_root():
 
 @app.get("/health")
 async def health_check():
+    """Health check with LLM availability status"""
+    llm_status = "available"
+    llm_message = None
+    
+    # Quick test of LLM availability
+    if GRADIO_AVAILABLE:
+        try:
+            client = get_gradio_client(LLM_GRADIO_SPACE)
+            # Just checking if we can connect, not running inference
+            llm_status = "available"
+        except Exception as e:
+            error_msg = str(e).lower()
+            if "quota" in error_msg or "gpu" in error_msg:
+                llm_status = "quota_exceeded"
+                llm_message = "GPU quota exceeded. Using fallback assessments."
+            else:
+                llm_status = "error"
+                llm_message = "LLM temporarily unavailable"
+    else:
+        llm_status = "not_installed"
+        llm_message = "Gradio client not available"
+    
     return {
         "status": "healthy",
         "detector": detector_type or "none",
         "vlm_available": GRADIO_AVAILABLE,
         "vlm_space": GRADIO_VLM_SPACE,
-        "llm_space": LLM_GRADIO_SPACE
+        "llm_space": LLM_GRADIO_SPACE,
+        "llm_status": llm_status,
+        "llm_message": llm_message,
+        "fallback_enabled": True
     }
 
 @app.post("/api/v1/validate-eye-photo")
@@ -615,14 +786,49 @@ async def get_history(user_id: str):
     history = [s for s in screenings_db.values() if s.get("user_id") == user_id]
     return {"screenings": history}
 
+@app.get("/api/v1/debug/spaces")
+async def debug_spaces():
+    """Debug endpoint to test VLM and LLM spaces"""
+    results = {
+        "vlm": {"available": False, "error": None},
+        "llm": {"available": False, "error": None}
+    }
+    
+    # Test VLM
+    if GRADIO_AVAILABLE:
+        try:
+            client = get_gradio_client(GRADIO_VLM_SPACE)
+            results["vlm"]["available"] = True
+            results["vlm"]["space"] = GRADIO_VLM_SPACE
+        except Exception as e:
+            results["vlm"]["error"] = str(e)
+    else:
+        results["vlm"]["error"] = "Gradio not installed"
+    
+    # Test LLM
+    if GRADIO_AVAILABLE:
+        try:
+            client = get_gradio_client(LLM_GRADIO_SPACE)
+            results["llm"]["available"] = True
+            results["llm"]["space"] = LLM_GRADIO_SPACE
+        except Exception as e:
+            results["llm"]["error"] = str(e)
+    else:
+        results["llm"]["error"] = "Gradio not installed"
+    
+    return results
+
 @app.post("/api/v1/get-vitals")
 async def get_vitals_from_upload(
     face_image: UploadFile = File(...),
     eye_image: UploadFile = File(...)
 ):
-    """Synchronous VLM + LLM pipeline"""
+    """Synchronous VLM + LLM pipeline with graceful fallback"""
     if not GRADIO_AVAILABLE:
-        raise HTTPException(status_code=500, detail="VLM/LLM not available")
+        raise HTTPException(
+            status_code=503, 
+            detail="AI services temporarily unavailable. Please try again later."
+        )
     
     try:
         uid = str(uuid.uuid4())
@@ -634,23 +840,38 @@ async def get_vitals_from_upload(
         with open(eye_path, "wb") as f:
             f.write(await eye_image.read())
         
+        # Call VLM
         vlm_features, vlm_raw = await asyncio.to_thread(call_vlm, face_path, eye_path)
+        
+        # Call LLM with fallback enabled
         llm_input = vlm_raw if vlm_raw else (vlm_features if vlm_features else "{}")
-        structured_risk = await asyncio.to_thread(call_llm, llm_input)
+        structured_risk = await asyncio.to_thread(call_llm, llm_input, use_fallback_on_error=True)
         
         return {
             "vlm_features": vlm_features,
             "vlm_raw": vlm_raw,
-            "structured_risk": structured_risk
+            "structured_risk": structured_risk,
+            "using_fallback": structured_risk.get("fallback_mode", False)
         }
         
     except Exception as e:
         logger.exception("Get vitals failed")
-        raise HTTPException(status_code=500, detail=str(e))
+        error_msg = str(e).lower()
+        
+        if "quota" in error_msg or "gpu" in error_msg:
+            raise HTTPException(
+                status_code=503,
+                detail="AI service is currently at capacity. Please try again in a few minutes."
+            )
+        
+        raise HTTPException(
+            status_code=500, 
+            detail="Unable to process images. Please ensure images are clear and try again."
+        )
 
 @app.post("/api/v1/get-vitals/{screening_id}")
 async def get_vitals_for_screening(screening_id: str):
-    """Re-run VLM + LLM on existing screening"""
+    """Re-run VLM + LLM on existing screening with fallback support"""
     if screening_id not in screenings_db:
         raise HTTPException(status_code=404, detail="Screening not found")
     
@@ -659,31 +880,44 @@ async def get_vitals_for_screening(screening_id: str):
     eye_path = entry.get("eye_image_path")
     
     if not (face_path and os.path.exists(face_path) and eye_path and os.path.exists(eye_path)):
-        raise HTTPException(status_code=400, detail="Images missing")
+        raise HTTPException(status_code=400, detail="Images missing for this screening")
     
     try:
         vlm_features, vlm_raw = await asyncio.to_thread(call_vlm, face_path, eye_path)
         llm_input = vlm_raw if vlm_raw else (vlm_features if vlm_features else "{}")
-        structured_risk = await asyncio.to_thread(call_llm, llm_input)
+        structured_risk = await asyncio.to_thread(call_llm, llm_input, use_fallback_on_error=True)
         
         entry.setdefault("ai_results", {}).update({
             "vlm_features": vlm_features,
             "vlm_raw": vlm_raw,
             "structured_risk": structured_risk,
-            "last_vitals_run": datetime.utcnow().isoformat() + "Z"
+            "last_vitals_run": datetime.utcnow().isoformat() + "Z",
+            "using_fallback": structured_risk.get("fallback_mode", False)
         })
         
         return {
             "screening_id": screening_id,
             "vlm_features": vlm_features,
             "vlm_raw": vlm_raw,
-            "structured_risk": structured_risk
+            "structured_risk": structured_risk,
+            "using_fallback": structured_risk.get("fallback_mode", False)
         }
         
     except Exception as e:
         logger.exception("Get vitals for screening failed")
-        raise HTTPException(status_code=500, detail=str(e))
+        error_msg = str(e).lower()
+        
+        if "quota" in error_msg or "gpu" in error_msg:
+            raise HTTPException(
+                status_code=503,
+                detail="AI service is currently at capacity. Please try again in a few minutes."
+            )
+        
+        raise HTTPException(
+            status_code=500,
+            detail="Unable to re-process screening. Please try again."
+        )
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=