Update app.py

app.py

@@ -265,7 +265,7 @@ def call_space_multipart(space: str, api_name: str, prompt: str, face_path: str,
     # Many Spaces accept a "data" field which is a JSON array of inputs; we provide prompt as first arg
     # and attach the file with a 'file' key. Some Spaces expect different key names — this is a pragmatic fallback.
     files = {
-        "data": (None, json.dumps([prompt, None])),  # second element reserved for the file param; some spaces ignore it
+        "data": (None, json.dumps([prompt, None])),
         "file": (os.path.basename(face_path), open(face_path, "rb"), "image/jpeg")
     }
     try:
@@ -332,7 +332,6 @@ def run_vlm_and_get_features(face_path: str, eye_path: Optional[str] = None, pro
             out = call_space_multipart(GRADIO_VLM_SPACE, "chat_fn", prompt, face_path)
             raw_text = ""
             if isinstance(out, dict):
-                # Some spaces return {'data': [...]} or similar
                 raw_text = json.dumps(out)
             else:
                 raw_text = str(out)
@@ -377,12 +376,11 @@ def run_vlm_and_get_features(face_path: str, eye_path: Optional[str] = None, pro
                 {"message": prompt, "file": file_wrapper},
                 {"prompt": prompt, "image": file_wrapper},
                 {"prompt": prompt, "file": file_wrapper},
-                {"input_data": [prompt, None]}  # sometimes chat endpoints want a data array; we can't attach file here but we try
+                {"input_data": [prompt, None]}
             ]
             for named_args in named_attempts:
                 try:
                     logger.info("Attempting gradio_client.predict named call with args: %s", list(named_args.keys()))
-                    # always pass api_name explicitly
                     result = client.predict(api_name="/chat_fn", **named_args)
                     meta["vlm_upload_method"] = "gradio_named:" + ",".join(list(named_args.keys()))
                     tried_methods.append(f"gradio_named_{','.join(list(named_args.keys()))}")
@@ -415,7 +413,6 @@ def run_vlm_and_get_features(face_path: str, eye_path: Optional[str] = None, pro
             if isinstance(out, dict):
                 possible_text = out.get("data") or out.get("text") or out.get("output") or out.get("raw") or out.get("msg")
                 if possible_text is None:
-                    # Some Spaces return {'data': ['...']} or {'data': [{...}]}
                     if "data" in out and isinstance(out["data"], (list, tuple)) and len(out["data"]) > 0:
                         possible_text = out["data"][0]
                 if isinstance(possible_text, (dict, list)):
@@ -754,7 +751,7 @@ async def validate_eye_photo(image: UploadFile = File(...)):
             is_valid = eye_openness_score >= 0.3
             return {"valid": bool(is_valid), "face_detected": True, "eye_openness_score": round(eye_openness_score, 2),
                     "message_english": "Photo looks good! Eyes are properly open." if is_valid else "Eyes appear to be closed or partially closed. Please open your eyes wide and try again.",
-                    "message_hindi": "फोटो अच्छी है! आंखें ठीक से खुली हैं।" if is_valid else "आंखें बंद या आंशिक रूप से बंद दिखाई दे रही हैं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें।",
+                    "message_hindi": "फोटो अच्छी है! आंखें ठीक से खुली हैं।" if is_valid else "आंखें बंद या आंशिक रूप से बंद दिखाई दे रही हैं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें。",
                     "eye_landmarks": {"left_eye": left_eye, "right_eye": right_eye}}
 
         if isinstance(mtcnn, dict) and mtcnn.get("impl") == "opencv":
@@ -781,7 +778,7 @@ async def validate_eye_photo(image: UploadFile = File(...)):
                     left_eye = {"x": cx, "y": cy}
                 return {"valid": bool(is_valid), "face_detected": True, "eye_openness_score": round(eye_openness_score, 2),
                         "message_english": "Photo looks good! Eyes are detected." if is_valid else "Eyes not detected. Please open your eyes wide and try again.",
-                        "message_hindi": "फोटो अच्छी है! आंखें मिलीं।" if is_valid else "आंखें नहीं मिलीं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें।",
+                        "message_hindi": "फोटो अच्छी है! आंखें मिलीं।" if is_valid else "आंखें नहीं मिलीं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें。",
                         "eye_landmarks": {"left_eye": left_eye, "right_eye": right_eye}}
             except Exception:
                 traceback.print_exc()
@@ -797,14 +794,483 @@ async def validate_eye_photo(image: UploadFile = File(...)):
                 "message_hindi": "छवि प्रोसेस करने में त्रुटि। कृपया पुनः प्रयास करें।",
                 "error": str(e)}
 
-# ... (the rest of your endpoints remain unchanged, same as original) ...
-# For brevity, the remainder of endpoints (upload_images, analyze_screening, get_status, get_results,
-# get_history, get_vitals_from_upload, get_vitals_for_screening, get_vitals_from_urls, process_screening)
-# are unchanged from your original file. They will call the updated run_vlm_and_get_features above.
-#
-# (Paste the remaining original code for endpoints/process_screening as-is here or keep the version you had,
-# because the only functional changes required were to the VLM upload logic.)
-#
+@app.post("/api/v1/upload")
+async def upload_images(
+    background_tasks: BackgroundTasks,
+    face_image: UploadFile = File(...),
+    eye_image: UploadFile = File(...)
+):
+    """
+    Save images and enqueue background processing. VLM -> LLM runs inside process_screening.
+    """
+    try:
+        screening_id = str(uuid.uuid4())
+        now = datetime.utcnow().isoformat() + "Z"
+        tmp_dir = "/tmp/elderly_healthwatch"
+        os.makedirs(tmp_dir, exist_ok=True)
+        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(face_bytes)
+        with open(eye_path, "wb") as f:
+            f.write(eye_bytes)
+        screenings_db[screening_id] = {
+            "id": screening_id,
+            "timestamp": now,
+            "face_image_path": face_path,
+            "eye_image_path": eye_path,
+            "status": "queued",
+            "quality_metrics": {},
+            "ai_results": {},
+            "disease_predictions": [],
+            "recommendations": {}
+        }
+        background_tasks.add_task(process_screening, screening_id)
+        return {"screening_id": screening_id}
+    except Exception as e:
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Failed to upload images: {e}")
+
+@app.post("/api/v1/analyze/{screening_id}")
+async def analyze_screening(screening_id: str, background_tasks: BackgroundTasks):
+    if screening_id not in screenings_db:
+        raise HTTPException(status_code=404, detail="Screening not found")
+    if screenings_db[screening_id].get("status") == "processing":
+        return {"message": "Already processing"}
+    screenings_db[screening_id]["status"] = "queued"
+    background_tasks.add_task(process_screening, screening_id)
+    return {"message": "Analysis enqueued"}
+
+@app.get("/api/v1/status/{screening_id}")
+async def get_status(screening_id: str):
+    if screening_id not in screenings_db:
+        raise HTTPException(status_code=404, detail="Screening not found")
+    status = screenings_db[screening_id].get("status", "unknown")
+    progress = 50 if status == "processing" else (100 if status == "completed" else 0)
+    return {"screening_id": screening_id, "status": status, "progress": progress}
+
+@app.get("/api/v1/results/{screening_id}")
+async def get_results(screening_id: str):
+    if screening_id not in screenings_db:
+        raise HTTPException(status_code=404, detail="Screening not found")
+    # Ensure vlm_raw is always present in ai_results for debugging
+    entry = screenings_db[screening_id]
+    entry.setdefault("ai_results", {})
+    entry["ai_results"].setdefault("vlm_raw", entry.get("ai_results", {}).get("vlm_raw", ""))
+    return entry
+
+@app.get("/api/v1/history/{user_id}")
+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}
+
+# -----------------------
+# Immediate VLM -> LLM routes (return vitals in one call)
+# -----------------------
+@app.post("/api/v1/get-vitals")
+async def get_vitals_from_upload(
+    face_image: UploadFile = File(...),
+    eye_image: UploadFile = File(...)
+):
+    """
+    Run VLM -> LLM pipeline synchronously (but off the event loop) and return:
+      { vlm_parsed_features, vlm_raw_output, llm_structured_risk }
+    Note: VLM will receive only the face image (not the eye image).
+    """
+    if not GRADIO_AVAILABLE:
+        raise HTTPException(status_code=500, detail="VLM/LLM client not available in this deployment.")
+
+    # save files to a temp directory
+    try:
+        tmp_dir = "/tmp/elderly_healthwatch"
+        os.makedirs(tmp_dir, exist_ok=True)
+        uid = str(uuid.uuid4())
+        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(face_bytes)
+        with open(eye_path, "wb") as f:
+            f.write(eye_bytes)
+    except Exception as e:
+        logger.exception("Failed saving uploaded images")
+        raise HTTPException(status_code=500, detail=f"Failed saving images: {e}")
+
+    try:
+        # Run VLM (off the event loop) - returns (features, raw, meta)
+        vlm_features, vlm_raw, vlm_meta = await asyncio.to_thread(run_vlm_and_get_features, face_path, eye_path)
+
+        # Log VLM outputs
+        logger.info("get_vitals_from_upload - VLM raw (snippet): %s", (vlm_raw[:500] + "...") if vlm_raw else "<EMPTY>")
+        logger.info("get_vitals_from_upload - VLM parsed features: %s", json.dumps(vlm_features, indent=2, ensure_ascii=False) if vlm_features else "None")
+        logger.info("get_vitals_from_upload - VLM meta: %s", json.dumps(vlm_meta, ensure_ascii=False))
+
+        # Decide what to feed to LLM: prefer cleaned JSON if available, else raw VLM string
+        if vlm_features:
+            llm_input = json.dumps(vlm_features, ensure_ascii=False)
+            logger.info("Feeding CLEANED VLM JSON to LLM (len=%d).", len(llm_input))
+        else:
+            llm_input = vlm_raw if vlm_raw and vlm_raw.strip() else "{}"
+            logger.info("Feeding RAW VLM STRING to LLM (len=%d).", len(llm_input))
+
+        # Run LLM (off the event loop)
+        structured_risk = await asyncio.to_thread(run_llm_on_vlm, llm_input)
+
+        # Return merged result (includes raw VLM output + meta for debugging)
+        return {
+            "vlm_raw_output": vlm_raw,
+            "vlm_parsed_features": vlm_features,
+            "vlm_meta": vlm_meta,
+            "llm_structured_risk": structured_risk
+        }
+    except Exception as e:
+        logger.exception("get_vitals_from_upload pipeline failed")
+        raise HTTPException(status_code=500, detail=f"Pipeline failed: {e}")
+
+@app.post("/api/v1/get-vitals/{screening_id}")
+async def get_vitals_for_screening(screening_id: str):
+    """
+    Re-run VLM->LLM on images already stored for `screening_id` in screenings_db.
+    Useful for re-processing or debugging.
+    Note: VLM will receive only the face image (not the eye image).
+    """
+    if screening_id not in screenings_db:
+        raise HTTPException(status_code=404, detail="Screening not found")
+
+    entry = screenings_db[screening_id]
+    face_path = entry.get("face_image_path")
+    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="Stored images missing for this screening")
+
+    try:
+        # Run VLM off the event loop (returns features, raw, meta)
+        vlm_features, vlm_raw, vlm_meta = await asyncio.to_thread(run_vlm_and_get_features, face_path, eye_path)
+
+        logger.info("get_vitals_for_screening(%s) - VLM raw (snippet): %s", screening_id, (vlm_raw[:500] + "...") if vlm_raw else "<EMPTY>")
+        logger.info("get_vitals_for_screening(%s) - VLM parsed features: %s", screening_id, json.dumps(vlm_features, indent=2, ensure_ascii=False) if vlm_features else "None")
+        logger.info("get_vitals_for_screening(%s) - VLM meta: %s", screening_id, json.dumps(vlm_meta, ensure_ascii=False))
+
+        if vlm_features:
+            llm_input = json.dumps(vlm_features, ensure_ascii=False)
+            logger.info("Feeding CLEANED VLM JSON to LLM (len=%d).", len(llm_input))
+        else:
+            llm_input = vlm_raw if vlm_raw and vlm_raw.strip() else "{}"
+            logger.info("Feeding RAW VLM STRING to LLM (len=%d).", len(llm_input))
+
+        structured_risk = await asyncio.to_thread(run_llm_on_vlm, llm_input)
+
+        # Optionally store this run's outputs back into the DB for inspection
+        entry.setdefault("ai_results", {})
+        entry["ai_results"].update({
+            "vlm_parsed_features": vlm_features,
+            "vlm_raw": vlm_raw,
+            "vlm_meta": vlm_meta,
+            "structured_risk": structured_risk,
+            "last_vitals_run": datetime.utcnow().isoformat() + "Z"
+        })
+
+        return {
+            "screening_id": screening_id,
+            "vlm_raw_output": vlm_raw,
+            "vlm_parsed_features": vlm_features,
+            "vlm_meta": vlm_meta,
+            "llm_structured_risk": structured_risk
+        }
+    except Exception as e:
+        logger.exception("get_vitals_for_screening pipeline failed")
+        raise HTTPException(status_code=500, detail=f"Pipeline failed: {e}")
+
+# -----------------------
+# URL-based vitals endpoint (optional)
+# -----------------------
+class ImageUrls(BaseModel):
+    face_image_url: HttpUrl
+    eye_image_url: HttpUrl
+
+# helper: download URL to file with safety checks
+async def download_image_to_path(url: str, dest_path: str, max_bytes: int = 5_000_000, timeout_seconds: int = 10) -> None:
+    """
+    Download an image from `url` and save to dest_path.
+    Guards:
+     - timeout
+     - max bytes
+     - basic content-type check (image/*)
+    Raises HTTPException on failure.
+    """
+    try:
+        async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True) as client:
+            resp = await client.get(url, timeout=timeout_seconds)
+            resp.raise_for_status()
+
+            content_type = resp.headers.get("Content-Type", "")
+            if not content_type.startswith("image/"):
+                raise ValueError(f"URL does not appear to be an image (Content-Type={content_type})")
+
+            total = 0
+            with open(dest_path, "wb") as f:
+                async for chunk in resp.aiter_bytes():
+                    if not chunk:
+                        continue
+                    total += len(chunk)
+                    if total > max_bytes:
+                        raise ValueError(f"Image exceeds max allowed size ({max_bytes} bytes)")
+                    f.write(chunk)
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(status_code=400, detail=f"Failed to fetch image: {e.response.status_code} {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to download image: {str(e)}")
+
+@app.post("/api/v1/get-vitals-by-url")
+async def get_vitals_from_urls(payload: ImageUrls = Body(...)):
+    """
+    Download face and eye images from given URLs, then run the same VLM -> LLM pipeline and return results.
+    Note: VLM will receive only the face image (not the eye image).
+    Body: { "face_image_url": "...", "eye_image_url": "..." }
+    """
+    if not GRADIO_AVAILABLE:
+        raise HTTPException(status_code=500, detail="VLM/LLM client not available in this deployment.")
+
+    # prepare tmp paths
+    try:
+        tmp_dir = "/tmp/elderly_healthwatch"
+        os.makedirs(tmp_dir, exist_ok=True)
+        uid = str(uuid.uuid4())
+        face_path = os.path.join(tmp_dir, f"{uid}_face.jpg")
+        eye_path = os.path.join(tmp_dir, f"{uid}_eye.jpg")
+    except Exception as e:
+        logger.exception("Failed to prepare temp paths")
+        raise HTTPException(status_code=500, detail=f"Server error preparing temp files: {e}")
+
+    # download images (with guards)
+    try:
+        await download_image_to_path(str(payload.face_image_url), face_path)
+        await download_image_to_path(str(payload.eye_image_url), eye_path)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception("Downloading images failed")
+        raise HTTPException(status_code=400, detail=f"Failed to download images: {e}")
+
+    # run existing pipeline (off the event loop)
+    try:
+        vlm_features, vlm_raw, vlm_meta = await asyncio.to_thread(run_vlm_and_get_features, face_path, eye_path)
+
+        logger.info("get_vitals_from_urls - VLM raw (snippet): %s", (vlm_raw[:500] + "...") if vlm_raw else "<EMPTY>")
+        logger.info("get_vitals_from_urls - VLM parsed features: %s", json.dumps(vlm_features, indent=2, ensure_ascii=False) if vlm_features else "None")
+        logger.info("get_vitals_from_urls - VLM meta: %s", json.dumps(vlm_meta, ensure_ascii=False))
+
+        if vlm_features:
+            llm_input = json.dumps(vlm_features, ensure_ascii=False)
+            logger.info("Feeding CLEANED VLM JSON to LLM (len=%d).", len(llm_input))
+        else:
+            llm_input = vlm_raw if vlm_raw and vlm_raw.strip() else "{}"
+            logger.info("Feeding RAW VLM STRING to LLM (len=%d).", len(llm_input))
+
+        structured_risk = await asyncio.to_thread(run_llm_on_vlm, llm_input)
+
+        return {
+            "vlm_raw_output": vlm_raw,
+            "vlm_parsed_features": vlm_features,
+            "vlm_meta": vlm_meta,
+            "llm_structured_risk": structured_risk
+        }
+    except Exception as e:
+        logger.exception("get_vitals_by_url pipeline failed")
+        raise HTTPException(status_code=500, detail=f"Pipeline failed: {e}")
+
+# -----------------------
+# Main background pipeline (upload -> process_screening)
+# -----------------------
+async def process_screening(screening_id: str):
+    """
+    Main pipeline:
+     - load images
+     - quick detector-based quality metrics
+     - run VLM -> vlm_features (dict or None) + vlm_raw (string) + vlm_meta
+     - run LLM on vlm_features (preferred) or vlm_raw -> structured risk JSON
+     - merge results into ai_results and finish
+    """
+    try:
+        if screening_id not in screenings_db:
+            logger.error("[process_screening] screening %s not found", screening_id)
+            return
+        screenings_db[screening_id]["status"] = "processing"
+        logger.info("[process_screening] Starting %s", screening_id)
+
+        entry = screenings_db[screening_id]
+        face_path = entry.get("face_image_path")
+        eye_path = entry.get("eye_image_path")
+
+        if not (face_path and os.path.exists(face_path)):
+            raise RuntimeError("Face image missing")
+        if not (eye_path and os.path.exists(eye_path)):
+            raise RuntimeError("Eye image missing")
+
+        face_img = Image.open(face_path).convert("RGB")
+        eye_img = Image.open(eye_path).convert("RGB")
+
+        # Basic detection + quality metrics (facenet/mtcnn/opencv)
+        face_detected = False
+        face_confidence = 0.0
+        left_eye_coord = right_eye_coord = None
+
+        if mtcnn is not None and not isinstance(mtcnn, dict) and (_MTCNN_IMPL == "facenet_pytorch" or _MTCNN_IMPL == "mtcnn"):
+            try:
+                if _MTCNN_IMPL == "facenet_pytorch":
+                    boxes, probs, landmarks = mtcnn.detect(face_img, landmarks=True)
+                    if boxes is not None and len(boxes) > 0:
+                        face_detected = True
+                        face_confidence = float(probs[0]) if probs is not None else 0.0
+                        if landmarks is not None:
+                            lm = landmarks[0]
+                            if len(lm) >= 2:
+                                left_eye_coord = {"x": float(lm[0][0]), "y": float(lm[0][1])}
+                                right_eye_coord = {"x": float(lm[1][0]), "y": float(lm[1][1])}
+                else:
+                    arr = np.asarray(face_img)
+                    detections = mtcnn.detect_faces(arr)
+                    if detections:
+                        face_detected = True
+                        face_confidence = float(detections[0].get("confidence", 0.0))
+                        k = detections[0].get("keypoints", {})
+                        left_eye_coord = k.get("left_eye")
+                        right_eye_coord = k.get("right_eye")
+            except Exception:
+                traceback.print_exc()
+
+        if isinstance(mtcnn, dict) and mtcnn.get("impl") == "opencv":
+            try:
+                arr = np.asarray(face_img)
+                gray = cv2.cvtColor(arr, cv2.COLOR_RGB2GRAY)
+                face_cascade = mtcnn["face_cascade"]
+                eye_cascade = mtcnn["eye_cascade"]
+                faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=4, minSize=(60, 60))
+                if len(faces) > 0:
+                    face_detected = True
+                    (x, y, w, h) = faces[0]
+                    face_confidence = min(1.0, (w*h) / (arr.shape[0]*arr.shape[1]) * 4.0)
+                    roi_gray = gray[y:y+h, x:x+w]
+                    eyes = eye_cascade.detectMultiScale(roi_gray, scaleFactor=1.1, minNeighbors=5, minSize=(20, 10))
+                    if len(eyes) >= 1:
+                        ex, ey, ew, eh = eyes[0]
+                        left_eye_coord = {"x": float(x + ex + ew/2), "y": float(y + ey + eh/2)}
+            except Exception:
+                traceback.print_exc()
+
+        face_quality_score = 0.85 if face_detected and face_confidence > 0.6 else 0.45
+        quality_metrics = {
+            "face_detected": face_detected,
+            "face_confidence": round(face_confidence, 3),
+            "face_quality_score": round(face_quality_score, 2),
+            "eye_coords": {"left_eye": left_eye_coord, "right_eye": right_eye_coord},
+            "face_brightness": int(np.mean(np.asarray(face_img.convert("L")))),
+            "face_blur_estimate": int(np.var(np.asarray(face_img.convert("L"))))
+        }
+        screenings_db[screening_id]["quality_metrics"] = quality_metrics
+
+        # --------------------------
+        # RUN VLM -> get vlm_features + vlm_raw + vlm_meta
+        # --------------------------
+        vlm_features = None
+        vlm_raw = None
+        vlm_meta = {}
+        try:
+            vlm_features, vlm_raw, vlm_meta = run_vlm_and_get_features(face_path, eye_path)
+            screenings_db[screening_id].setdefault("ai_results", {})
+            screenings_db[screening_id]["ai_results"].update({
+                "vlm_parsed_features": vlm_features,
+                "vlm_raw": vlm_raw,
+                "vlm_meta": vlm_meta
+            })
+        except Exception as e:
+            logger.exception("VLM feature extraction failed")
+            screenings_db[screening_id].setdefault("ai_results", {})
+            screenings_db[screening_id]["ai_results"].update({"vlm_error": str(e)})
+            vlm_features = None
+            vlm_raw = ""
+            vlm_meta = {"error": str(e)}
+
+        # Log VLM outputs in pipeline context
+        logger.info("process_screening(%s) - VLM raw (snippet): %s", screening_id, (vlm_raw[:500] + "...") if vlm_raw else "<EMPTY>")
+        logger.info("process_screening(%s) - VLM parsed features: %s", screening_id, json.dumps(vlm_features, indent=2, ensure_ascii=False) if vlm_features else "None")
+        logger.info("process_screening(%s) - VLM meta: %s", screening_id, json.dumps(vlm_meta, ensure_ascii=False))
+
+        # --------------------------
+        # RUN LLM on vlm_parsed (preferred) or vlm_raw -> structured risk JSON
+        # --------------------------
+        structured_risk = None
+        try:
+            if vlm_features:
+                # prefer cleaned JSON
+                llm_input = json.dumps(vlm_features, ensure_ascii=False)
+            else:
+                # fallback to raw string (may be empty)
+                llm_input = vlm_raw if vlm_raw and vlm_raw.strip() else "{}"
+
+            structured_risk = run_llm_on_vlm(llm_input)
+            screenings_db[screening_id].setdefault("ai_results", {})
+            screenings_db[screening_id]["ai_results"].update({"structured_risk": structured_risk})
+        except Exception as e:
+            logger.exception("LLM processing failed")
+            screenings_db[screening_id].setdefault("ai_results", {})
+            screenings_db[screening_id]["ai_results"].update({"llm_error": str(e)})
+            structured_risk = {
+                "risk_score": 0.0,
+                "jaundice_probability": 0.0,
+                "anemia_probability": 0.0,
+                "hydration_issue_probability": 0.0,
+                "neurological_issue_probability": 0.0,
+                "summary": "",
+                "recommendation": "",
+                "confidence": 0.0
+            }
+
+        # Use structured_risk for summary recommendations & simple disease inference placeholders
+        screenings_db[screening_id].setdefault("ai_results", {})
+        screenings_db[screening_id]["ai_results"].update({
+            "processing_time_ms": 1200
+        })
+
+        disease_predictions = [
+            {
+                "condition": "Anemia-like-signs",
+                "risk_level": "Medium" if structured_risk.get("anemia_probability", 0.0) > 0.5 else "Low",
+                "probability": structured_risk.get("anemia_probability", 0.0),
+                "confidence": structured_risk.get("confidence", 0.0)
+            },
+            {
+                "condition": "Jaundice-like-signs",
+                "risk_level": "Medium" if structured_risk.get("jaundice_probability", 0.0) > 0.5 else "Low",
+                "probability": structured_risk.get("jaundice_probability", 0.0),
+                "confidence": structured_risk.get("confidence", 0.0)
+            }
+        ]
+
+        recommendations = {
+            "action_needed": "consult" if structured_risk.get("risk_score", 0.0) > 30.0 else "monitor",
+            "message_english": structured_risk.get("recommendation", "") or f"Please follow up with a health professional if concerns persist.",
+            "message_hindi": ""
+        }
+
+        screenings_db[screening_id].update({
+            "status": "completed",
+            "disease_predictions": disease_predictions,
+            "recommendations": recommendations
+        })
+
+        logger.info("[process_screening] Completed %s", screening_id)
+    except Exception as e:
+        traceback.print_exc()
+        if screening_id in screenings_db:
+            screenings_db[screening_id]["status"] = "failed"
+            screenings_db[screening_id]["error"] = str(e)
+        else:
+            logger.error("[process_screening] Failed for unknown screening %s: %s", screening_id, str(e))
+
 # -----------------------
 # Run server (for local debugging)
 # -----------------------