Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-Elderly HealthWatch AI Backend (FastAPI) - Refactored with Qwen2.5-VL
-Updated to use Qwen2.5-VL with multiple space options and fallback
+Elderly HealthWatch AI Backend (FastAPI) - With GCS Support
+Simplified: Just upload gcs-credentials.json to repository root
 """
 
 import io
@@ -12,7 +12,7 @@ import logging
 import traceback
 import re
 from typing import Dict, Any, Optional, Tuple
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
@@ -20,6 +20,15 @@ from PIL import Image
 import numpy as np
 import cv2
 
+# Google Cloud Storage
+try:
+    from google.cloud import storage
+    from google.oauth2 import service_account
+    GCS_AVAILABLE = True
+except Exception:
+    GCS_AVAILABLE = False
+    logging.warning("Google Cloud Storage not available")
+
 try:
     from gradio_client import Client, handle_file
     GRADIO_AVAILABLE = True
@@ -32,36 +41,18 @@ except Exception:
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("elderly_healthwatch")
 
-# Multiple VLM options - will try in order until one works
-VLM_SPACES = [
-    {
-        "space": "Qwen/Qwen2.5-VL-7B-Instruct",
-        "model_id": "Qwen/Qwen2.5-VL-7B-Instruct",
-        "api_name": "/model_chat",
-        "type": "official"
-    },
-    {
-        "space": "mrdbourke/Qwen2.5-VL-Instruct-Demo",
-        "model_id": "Qwen/Qwen2.5-VL-7B-Instruct",
-        "api_name": "/run_example",
-        "type": "demo"
-    }
-]
-
-GRADIO_VLM_SPACE = os.getenv("GRADIO_SPACE", VLM_SPACES[0]["space"])
-VLM_MODEL_ID = os.getenv("VLM_MODEL_ID", "Qwen/Qwen2.5-VL-7B-Instruct")
+GRADIO_VLM_SPACE = os.getenv("GRADIO_SPACE", "developer0hye/Qwen3-VL-8B-Instruct")
 LLM_GRADIO_SPACE = os.getenv("LLM_GRADIO_SPACE", "Tonic/med-gpt-oss-20b-demo")
 HF_TOKEN = os.getenv("HF_TOKEN", None)
 
+# GCS Configuration - Simple!
+GCS_BUCKET_NAME = "elderly-healthwatch-images"
+GCS_CREDENTIALS_FILE = "gcs-credentials.json"
+
 DEFAULT_VLM_PROMPT = (
-    "Analyze this person's face and eyes carefully. Look for signs of: "
-    "1) Pallor (pale skin indicating possible anemia), "
-    "2) Sclera yellowness (yellowing of eye whites indicating possible jaundice), "
-    "3) Eye redness or irritation, "
-    "4) Skin hydration and texture. "
-    "Provide your analysis in JSON format with these keys: "
-    "pallor_score (0-1), sclera_yellowness (0-1), redness (0-1), "
-    "hydration_issue (0-1), overall_quality (0-1), notes."
+    "From the provided face/eye images, compute the required screening features "
+    "(pallor, sclera yellowness, redness, mobility metrics, quality checks) "
+    "and output a clean JSON feature vector only."
 )
 
 LLM_SYSTEM_PROMPT = (
@@ -82,26 +73,70 @@ os.makedirs(TMP_DIR, exist_ok=True)
 # In-memory database
 screenings_db: Dict[str, Dict[str, Any]] = {}
 
-# Track which VLM space is working
-active_vlm_config = None
+# ============================================================================
+# Google Cloud Storage Setup
+# ============================================================================
+def setup_gcs_client():
+    """Initialize GCS client from credentials file"""
+    if not GCS_AVAILABLE:
+        logger.warning("GCS libraries not installed")
+        return None, None
+    
+    try:
+        if os.path.exists(GCS_CREDENTIALS_FILE):
+            logger.info("Found GCS credentials file: %s", GCS_CREDENTIALS_FILE)
+            credentials = service_account.Credentials.from_service_account_file(GCS_CREDENTIALS_FILE)
+            client = storage.Client(credentials=credentials)
+            bucket = client.bucket(GCS_BUCKET_NAME)
+            logger.info("✅ GCS initialized successfully for bucket: %s", GCS_BUCKET_NAME)
+            return client, bucket
+        else:
+            logger.warning("⚠️ GCS credentials file not found at: %s", GCS_CREDENTIALS_FILE)
+            logger.warning("VLM will use file handles instead of URLs")
+            return None, None
+    
+    except Exception as e:
+        logger.exception("Failed to initialize GCS: %s", str(e))
+        return None, None
+
+gcs_client, gcs_bucket = setup_gcs_client()
+
+def upload_to_gcs(local_path: str, blob_name: str) -> Optional[str]:
+    """Upload file to GCS and return public URL"""
+    if gcs_bucket is None:
+        return None
+    
+    try:
+        blob = gcs_bucket.blob(blob_name)
+        blob.upload_from_filename(local_path, content_type='image/jpeg')
+        blob.make_public()
+        public_url = blob.public_url
+        logger.info("✅ Uploaded to GCS: %s -> %s", blob_name, public_url[:60])
+        return public_url
+    except Exception as e:
+        logger.exception("Failed to upload to GCS: %s", str(e))
+        return None
 
 # ============================================================================
 # Face Detection Setup
 # ============================================================================
 def setup_face_detector():
     """Initialize face detector (MTCNN or OpenCV fallback)"""
+    # Try facenet-pytorch MTCNN
     try:
         from facenet_pytorch import MTCNN
         return MTCNN(keep_all=False, device="cpu"), "facenet_pytorch"
     except Exception:
         pass
     
+    # Try classic MTCNN
     try:
         from mtcnn import MTCNN
         return MTCNN(), "mtcnn"
     except Exception:
         pass
     
+    # OpenCV Haar cascade fallback
     try:
         face_path = os.path.join(cv2.data.haarcascades, "haarcascade_frontalface_default.xml")
         eye_path = os.path.join(cv2.data.haarcascades, "haarcascade_eye.xml")
@@ -158,6 +193,7 @@ def detect_face_and_eyes(pil_img: Image.Image) -> Dict[str, Any]:
     
     img_arr = np.asarray(pil_img)
     
+    # Facenet-pytorch MTCNN
     if detector_type == "facenet_pytorch":
         try:
             boxes, probs, landmarks = face_detector.detect(pil_img, landmarks=True)
@@ -185,6 +221,7 @@ def detect_face_and_eyes(pil_img: Image.Image) -> Dict[str, Any]:
             return {"face_detected": False, "face_confidence": 0.0, "eye_openness_score": 0.0,
                     "left_eye": None, "right_eye": None}
     
+    # Classic MTCNN
     elif detector_type == "mtcnn":
         try:
             detections = face_detector.detect_faces(img_arr)
@@ -208,6 +245,7 @@ def detect_face_and_eyes(pil_img: Image.Image) -> Dict[str, Any]:
             return {"face_detected": False, "face_confidence": 0.0, "eye_openness_score": 0.0,
                     "left_eye": None, "right_eye": None}
     
+    # OpenCV fallback
     elif detector_type == "opencv":
         try:
             gray = cv2.cvtColor(img_arr, cv2.COLOR_RGB2GRAY)
@@ -299,7 +337,7 @@ def extract_json_from_llm_output(raw_text: str) -> Dict[str, Any]:
     }
 
 # ============================================================================
-# VLM & LLM Integration - UPDATED FOR QWEN2.5-VL with Fallback
+# VLM Integration - WITH GCS URL SUPPORT
 # ============================================================================
 def get_gradio_client(space: str) -> Client:
     """Get Gradio client with optional auth"""
@@ -307,128 +345,194 @@ def get_gradio_client(space: str) -> Client:
         raise RuntimeError("gradio_client not installed")
     return Client(space, hf_token=HF_TOKEN) if HF_TOKEN else Client(space)
 
-def call_vlm_single_image(client: Client, image_path: str, prompt: str, config: Dict) -> str:
-    """Call VLM with a single image using appropriate API"""
-    try:
-        if config["type"] == "demo":
-            # mrdbourke style API
-            result = client.predict(
-                image=handle_file(image_path),
-                text_input=prompt,
-                model_id=config["model_id"],
-                api_name=config["api_name"]
-            )
-            # Extract text from tuple response
-            if isinstance(result, (list, tuple)) and len(result) > 0:
-                return str(result[0])
-            return str(result)
-        else:
-            # Try official Qwen space API (if it exists)
-            result = client.predict(
-                query=prompt,
-                image=handle_file(image_path),
-                api_name=config["api_name"]
-            )
-            if isinstance(result, (list, tuple)) and len(result) > 0:
-                return str(result[0])
-            return str(result)
-    except Exception as e:
-        logger.error("VLM single image call failed with config %s: %s", config, str(e))
-        raise
-
-def call_vlm(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Tuple[Optional[Dict], str]:
-    """
-    Call Qwen2.5-VL and return (parsed_features, raw_text)
-    Tries multiple VLM spaces until one works
-    """
-    global active_vlm_config
-    
+def call_vlm_with_urls(face_url: str, eye_url: str, prompt: Optional[str] = None) -> Tuple[Optional[Dict], str]:
+    """Call VLM using image URLs instead of file handles"""
     prompt = prompt or DEFAULT_VLM_PROMPT
     
-    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 URL: %s", face_url[:80])
+    logger.info("🔗 VLM Input - Eye URL: %s", eye_url[:80])
     
-    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)
     
-    # Try active config first if we have one that worked before
-    configs_to_try = []
-    if active_vlm_config:
-        configs_to_try.append(active_vlm_config)
-    configs_to_try.extend([c for c in VLM_SPACES if c != active_vlm_config])
+    # Try different message formats that VLM spaces commonly accept
+    message_formats = [
+        # Format 1: URLs in files array
+        {"text": prompt, "files": [face_url, eye_url]},
+        # Format 2: Separate image fields
+        {"prompt": prompt, "image1": face_url, "image2": eye_url},
+        # Format 3: Single message with URLs
+        {"message": f"{prompt}\n\nFace image: {face_url}\nEye image: {eye_url}"},
+        # Format 4: Images array
+        {"text": prompt, "images": [face_url, eye_url]},
+    ]
     
     last_error = None
-    for config in configs_to_try:
+    
+    for idx, message in enumerate(message_formats, 1):
         try:
-            logger.info("Trying VLM Space: %s with api_name=%s", config["space"], config["api_name"])
-            client = get_gradio_client(config["space"])
+            logger.info("Trying VLM message format %d/%d: %s", idx, len(message_formats), list(message.keys()))
+            result = client.predict(message=message, history=[], api_name="/chat_fn")
             
-            # Call VLM twice - once for face, once for eyes
-            face_text = call_vlm_single_image(
-                client, face_path, 
-                prompt + " Focus on the face and overall skin condition.",
-                config
-            )
+            logger.info("✅ VLM call succeeded with format %d", idx)
+            logger.info("VLM raw result type: %s", type(result))
             
-            eye_text = call_vlm_single_image(
-                client, eye_path,
-                prompt + " Focus on the eyes, sclera color, and eye health.",
-                config
-            )
+            # Process the result
+            if isinstance(result, (list, tuple)):
+                logger.info("VLM returned list/tuple with %d elements", len(result))
+                out = result[0] if len(result) > 0 else {}
+            elif isinstance(result, dict):
+                logger.info("VLM returned dict with keys: %s", list(result.keys()))
+                out = result
+            else:
+                logger.info("VLM returned type: %s, converting to string", type(result))
+                out = {"text": str(result)}
+            
+            # 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") or out.get("response")
+            
+            if not text_out:
+                if isinstance(result, str):
+                    text_out = result
+                else:
+                    text_out = json.dumps(out)
             
-            # Success! Save this config
-            active_vlm_config = config
+            logger.info("VLM extracted text (first 300 chars): %s", text_out[:300] if text_out else "EMPTY")
             
-            # Combine both analyses
-            combined_text = f"Face Analysis:\n{face_text}\n\nEye Analysis:\n{eye_text}"
-            logger.info("VLM combined text (first 500 chars): %s", combined_text[:500])
+            if not text_out or len(text_out.strip()) == 0:
+                logger.warning("VLM returned empty text, trying next format...")
+                last_error = "Empty response"
+                continue
             
             # Try to parse JSON
             parsed = None
             try:
-                parsed = json.loads(combined_text)
+                parsed = json.loads(text_out)
                 if not isinstance(parsed, dict):
+                    logger.warning("VLM JSON parsed but not a dict: %s", type(parsed))
                     parsed = None
                 else:
-                    logger.info("VLM successfully parsed JSON with keys: %s", list(parsed.keys()))
+                    logger.info("✅ VLM successfully parsed JSON with keys: %s", list(parsed.keys()))
             except Exception:
+                # Try to extract JSON from text
                 try:
-                    first = combined_text.find("{")
-                    last = combined_text.rfind("}")
+                    first = text_out.find("{")
+                    last = text_out.rfind("}")
                     if first != -1 and last != -1 and last > first:
-                        json_str = combined_text[first:last+1]
+                        json_str = text_out[first:last+1]
                         parsed = json.loads(json_str)
-                        if not isinstance(parsed, dict):
-                            parsed = None
+                        if isinstance(parsed, dict):
+                            logger.info("✅ Successfully extracted JSON from text with keys: %s", list(parsed.keys()))
                         else:
-                            logger.info("Successfully extracted JSON from text with keys: %s", list(parsed.keys()))
+                            parsed = None
                 except Exception as extract_err:
-                    logger.warning("Could not extract JSON from VLM text: %s", str(extract_err))
+                    logger.info("Could not extract JSON from VLM text: %s", str(extract_err))
                     parsed = None
             
-            # If no JSON found, create structured data from text
-            if parsed is None:
-                logger.info("No JSON found, creating structured data from text analysis")
-                parsed = {
-                    "face_analysis": face_text[:500],
-                    "eye_analysis": eye_text[:500],
-                    "combined_analysis": combined_text[:1000]
-                }
-            
-            return parsed, combined_text
+            # Success! Return the result
+            return parsed, text_out
             
         except Exception as e:
-            logger.warning("VLM space %s failed: %s", config["space"], str(e))
-            last_error = e
+            logger.warning("VLM format %d failed: %s", idx, str(e))
+            last_error = str(e)
             continue
     
-    # All configs failed
-    logger.error("All VLM spaces failed. Last error: %s", str(last_error))
-    raise RuntimeError(f"All VLM spaces failed. Last error: {last_error}")
+    # All formats failed
+    raise RuntimeError(f"All VLM message formats failed. Last error: {last_error}")
 
+def call_vlm(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Tuple[Optional[Dict], str]:
+    """
+    Call VLM - wrapper that handles both local files and GCS URLs
+    Strategy: Try GCS first (if available), fallback to file handles
+    """
+    
+    # Strategy 1: Try GCS URLs (if GCS is set up)
+    if gcs_bucket is not None:
+        logger.info("🌐 GCS is available, uploading images and using URLs for VLM")
+        
+        try:
+            # Generate unique blob names
+            unique_id = str(uuid.uuid4())
+            face_blob_name = f"vlm_temp/{unique_id}_face.jpg"
+            eye_blob_name = f"vlm_temp/{unique_id}_eye.jpg"
+            
+            # Upload to GCS
+            face_url = upload_to_gcs(face_path, face_blob_name)
+            eye_url = upload_to_gcs(eye_path, eye_blob_name)
+            
+            if face_url and eye_url:
+                logger.info("✅ Successfully uploaded to GCS, calling VLM with URLs")
+                return call_vlm_with_urls(face_url, eye_url, prompt)
+            else:
+                logger.warning("⚠️ GCS upload failed, falling back to file handles")
+        except Exception as e:
+            logger.warning("⚠️ GCS error, falling back to file handles: %s", str(e))
+    else:
+        logger.info("ℹ️ GCS not available, using file handles for VLM")
+    
+    # Strategy 2: Fallback to file handles (original method)
+    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 file: %s (size: %d bytes)", face_path, os.path.getsize(face_path))
+    logger.info("📁 VLM Input - Eye file: %s (size: %d bytes)", eye_path, os.path.getsize(eye_path))
+    
+    prompt = prompt or DEFAULT_VLM_PROMPT
+    client = get_gradio_client(GRADIO_VLM_SPACE)
+    message = {"text": prompt, "files": [handle_file(face_path), handle_file(eye_path)]}
+    
+    try:
+        logger.info("Calling VLM with file handles")
+        result = client.predict(message=message, history=[], api_name="/chat_fn")
+        logger.info("VLM raw result: %s", str(result)[:500])
+    except Exception as e:
+        logger.exception("VLM call with file handles failed")
+        raise RuntimeError(f"VLM call failed: {e}")
+    
+    # Process result (same as in call_vlm_with_urls)
+    if isinstance(result, (list, tuple)):
+        out = result[0] if len(result) > 0 else {}
+    elif isinstance(result, dict):
+        out = result
+    else:
+        out = {"text": str(result)}
+    
+    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 isinstance(result, str):
+            text_out = result
+        else:
+            text_out = json.dumps(out)
+    
+    if not text_out or len(text_out.strip()) == 0:
+        logger.warning("VLM returned empty text")
+        text_out = "{}"
+    
+    parsed = None
+    try:
+        parsed = json.loads(text_out)
+        if not isinstance(parsed, dict):
+            parsed = None
+    except Exception:
+        try:
+            first = text_out.find("{")
+            last = text_out.rfind("}")
+            if first != -1 and last != -1:
+                parsed = json.loads(text_out[first:last+1])
+                if not isinstance(parsed, dict):
+                    parsed = None
+        except Exception:
+            pass
+    
+    return parsed, text_out
+
+# ============================================================================
+# LLM Integration
+# ============================================================================
 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)
@@ -540,7 +644,7 @@ def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, A
         )
         
         text_out = json.dumps(result) if isinstance(result, (dict, list)) else str(result)
-        logger.info("LLM raw output:\n%s", text_out)
+        logger.info("LLM raw output:\n%s", text_out[:1000])
         
         parsed = extract_json_from_llm_output(text_out)
         logger.info("LLM parsed JSON:\n%s", json.dumps(parsed, indent=2))
@@ -564,12 +668,11 @@ def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, A
         
         error_msg = str(e).lower()
         if "quota" in error_msg or "gpu" in error_msg:
-            logger.warning("GPU quota exceeded, using fallback assessment")
+            logger.warning("GPU quota exceeded, using fallback")
             if use_fallback_on_error:
                 return get_fallback_risk_assessment(vlm_output, reason="gpu_quota_exceeded")
         
         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}")
@@ -591,6 +694,7 @@ async def process_screening(screening_id: str):
         face_path = entry["face_image_path"]
         eye_path = entry["eye_image_path"]
         
+        # Load images and get quality metrics
         face_img = Image.open(face_path).convert("RGB")
         detection_result = detect_face_and_eyes(face_img)
         
@@ -607,13 +711,14 @@ async def process_screening(screening_id: str):
         }
         screenings_db[screening_id]["quality_metrics"] = quality_metrics
         
-        # Call VLM
+        # Call VLM (will use GCS URLs if available)
         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, use_fallback_on_error=True)
         
+        # Store results
         screenings_db[screening_id]["ai_results"] = {
             "vlm_features": vlm_features,
             "vlm_raw": vlm_raw,
@@ -621,6 +726,7 @@ async def process_screening(screening_id: str):
             "processing_time_ms": 1200
         }
         
+        # Build disease predictions
         disease_predictions = [
             {
                 "condition": "Anemia-like-signs",
@@ -657,7 +763,7 @@ async def process_screening(screening_id: str):
             screenings_db[screening_id]["error"] = str(e)
 
 # ============================================================================
-# FastAPI App & Routes (REST OF THE CODE REMAINS THE SAME)
+# FastAPI App & Routes
 # ============================================================================
 app = FastAPI(title="Elderly HealthWatch AI Backend")
 app.add_middleware(
@@ -671,14 +777,14 @@ app.add_middleware(
 @app.get("/")
 async def read_root():
     return {
-        "message": "Elderly HealthWatch AI Backend - Using Qwen2.5-VL",
-        "active_vlm": active_vlm_config["space"] if active_vlm_config else "Not yet determined",
-        "available_vlm_spaces": [c["space"] for c in VLM_SPACES]
+        "message": "Elderly HealthWatch AI Backend",
+        "gcs_enabled": gcs_bucket is not None,
+        "version": "1.0.0-gcs"
     }
 
 @app.get("/health")
 async def health_check():
-    """Health check with LLM availability status"""
+    """Health check with GCS and LLM status"""
     llm_status = "available"
     llm_message = None
     
@@ -690,23 +796,24 @@ async def health_check():
             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."
+                llm_message = "GPU quota exceeded. Using fallback."
             else:
                 llm_status = "error"
                 llm_message = "LLM temporarily unavailable"
     else:
         llm_status = "not_installed"
-        llm_message = "Gradio client not available"
+        llm_message = "Gradio not available"
     
     return {
         "status": "healthy",
         "detector": detector_type or "none",
         "vlm_available": GRADIO_AVAILABLE,
-        "active_vlm_space": active_vlm_config["space"] if active_vlm_config else "Not yet determined",
-        "available_vlm_spaces": [c["space"] for c in VLM_SPACES],
+        "vlm_space": GRADIO_VLM_SPACE,
         "llm_space": LLM_GRADIO_SPACE,
         "llm_status": llm_status,
         "llm_message": llm_message,
+        "gcs_available": gcs_bucket is not None,
+        "gcs_bucket": GCS_BUCKET_NAME if gcs_bucket else None,
         "fallback_enabled": True
     }
 
@@ -766,10 +873,13 @@ async def upload_images(
         face_path = os.path.join(TMP_DIR, f"{screening_id}_face.jpg")
         eye_path = os.path.join(TMP_DIR, f"{screening_id}_eye.jpg")
         
+        face_bytes = await face_image.read()
+        eye_bytes = await eye_image.read()
+        
         with open(face_path, "wb") as f:
-            f.write(await face_image.read())
+            f.write(face_bytes)
         with open(eye_path, "wb") as f:
-            f.write(await eye_image.read())
+            f.write(eye_bytes)
         
         screenings_db[screening_id] = {
             "id": screening_id,
@@ -830,52 +940,16 @@ 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_spaces": [],
-        "llm": {"available": False, "error": None}
-    }
-    
-    # Test each VLM space
-    if GRADIO_AVAILABLE:
-        for config in VLM_SPACES:
-            space_result = {"space": config["space"], "available": False, "error": None}
-            try:
-                client = get_gradio_client(config["space"])
-                space_result["available"] = True
-                space_result["config"] = config
-            except Exception as e:
-                space_result["error"] = str(e)
-            results["vlm_spaces"].append(space_result)
-    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"
-    
-    results["active_vlm"] = active_vlm_config
-    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 with graceful fallback"""
+    """Synchronous VLM + LLM pipeline with GCS support"""
     if not GRADIO_AVAILABLE:
         raise HTTPException(
             status_code=503, 
-            detail="AI services temporarily unavailable. Please try again later."
+            detail="AI services temporarily unavailable."
         )
     
     try:
@@ -883,15 +957,18 @@ async def get_vitals_from_upload(
         face_path = os.path.join(TMP_DIR, f"{uid}_face.jpg")
         eye_path = os.path.join(TMP_DIR, f"{uid}_eye.jpg")
         
+        face_bytes = await face_image.read()
+        eye_bytes = await eye_image.read()
+        
         with open(face_path, "wb") as f:
-            f.write(await face_image.read())
+            f.write(face_bytes)
         with open(eye_path, "wb") as f:
-            f.write(await eye_image.read())
+            f.write(eye_bytes)
         
-        # Call VLM
+        # Call VLM (will use GCS if available)
         vlm_features, vlm_raw = await asyncio.to_thread(call_vlm, face_path, eye_path)
         
-        # Call LLM with fallback enabled
+        # Call LLM
         llm_input = vlm_raw if vlm_raw else (vlm_features if vlm_features else "{}")
         structured_risk = await asyncio.to_thread(call_llm, llm_input, use_fallback_on_error=True)
         
@@ -900,7 +977,7 @@ async def get_vitals_from_upload(
             "vlm_raw": vlm_raw,
             "structured_risk": structured_risk,
             "using_fallback": structured_risk.get("fallback_mode", False),
-            "vlm_space_used": active_vlm_config["space"] if active_vlm_config else "unknown"
+            "using_gcs": gcs_bucket is not None
         }
         
     except Exception as e:
@@ -910,17 +987,17 @@ async def get_vitals_from_upload(
         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."
+                detail="AI service 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."
+            detail="Unable to process images. Please 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 with fallback support"""
+    """Re-run VLM + LLM on existing screening"""
     if screening_id not in screenings_db:
         raise HTTPException(status_code=404, detail="Screening not found")
     
@@ -929,7 +1006,7 @@ 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 for this screening")
+        raise HTTPException(status_code=400, detail="Images missing")
     
     try:
         vlm_features, vlm_raw = await asyncio.to_thread(call_vlm, face_path, eye_path)
@@ -941,8 +1018,7 @@ async def get_vitals_for_screening(screening_id: str):
             "vlm_raw": vlm_raw,
             "structured_risk": structured_risk,
             "last_vitals_run": datetime.utcnow().isoformat() + "Z",
-            "using_fallback": structured_risk.get("fallback_mode", False),
-            "vlm_space_used": active_vlm_config["space"] if active_vlm_config else "unknown"
+            "using_fallback": structured_risk.get("fallback_mode", False)
         })
         
         return {
@@ -950,24 +1026,12 @@ async def get_vitals_for_screening(screening_id: str):
             "vlm_features": vlm_features,
             "vlm_raw": vlm_raw,
             "structured_risk": structured_risk,
-            "using_fallback": structured_risk.get("fallback_mode", False),
-            "vlm_space_used": active_vlm_config["space"] if active_vlm_config else "unknown"
+            "using_fallback": structured_risk.get("fallback_mode", False)
         }
         
     except Exception as e:
         logger.exception("Get vitals for screening failed")
-        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."
-        )
+        raise HTTPException(status_code=500, detail=str(e))
 
 if __name__ == "__main__":
     import uvicorn