Update main.py

main.py

@@ -45,7 +45,75 @@ bucket = storage.bucket()
 
 # --- Gemini Client ---
 client = genai.Client(api_key=os.getenv("Gemini"))
-model_name = "gemini-2.0-flash-thinking-exp"
+model_name = "gemini-2.0-flash"
+
+import logging
+import uuid
+import time
+from flask import g, request, jsonify
+
+# ---------- Logging setup ----------
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+
+logging.basicConfig(
+    level=LOG_LEVEL,
+    format="%(asctime)s %(levelname)s %(name)s %(message)s",
+)
+logger = logging.getLogger("api")
+
+# ---------- Request/Response hooks ----------
+@app.before_request
+def _start_timer():
+    g.request_id = request.headers.get("X-Request-Id", str(uuid.uuid4()))
+    g.t0 = time.time()
+
+    # Minimal safe logging (avoid dumping full participantInfo / bank statements)
+    body_preview = None
+    try:
+        if request.is_json:
+            j = request.get_json(silent=True)
+            if isinstance(j, dict):
+                body_preview = {"keys": list(j.keys())}
+            else:
+                body_preview = {"type": str(type(j))}
+        else:
+            body_preview = {"content_type": request.content_type}
+    except Exception:
+        body_preview = {"parse": "failed"}
+
+    logger.info(
+        "REQ id=%s %s %s ip=%s ua=%s body=%s",
+        g.request_id,
+        request.method,
+        request.path,
+        request.headers.get("X-Forwarded-For", request.remote_addr),
+        request.user_agent.string,
+        body_preview,
+    )
+
+@app.after_request
+def _log_response(resp):
+    dt_ms = int((time.time() - getattr(g, "t0", time.time())) * 1000)
+    logger.info(
+        "RES id=%s %s %s status=%s ms=%s",
+        getattr(g, "request_id", "-"),
+        request.method,
+        request.path,
+        resp.status_code,
+        dt_ms,
+    )
+    resp.headers["X-Request-Id"] = getattr(g, "request_id", "-")
+    return resp
+
+@app.errorhandler(Exception)
+def _unhandled_exception(err):
+    # This is the big one: logs stack trace
+    logger.exception("UNHANDLED id=%s path=%s", getattr(g, "request_id", "-"), request.path)
+    return jsonify({
+        "status": "error",
+        "message": "Internal server error",
+        "requestId": getattr(g, "request_id", "-"),
+    }), 500
 
 interventions_offered = {
   "Marketing Support": [
@@ -897,36 +965,90 @@ def get_shortlist():
 
 
 # Lepharo AI Screening endpoint
-@app.route('/api/lepharo_evaluate', methods=['POST'])
-def lepharo_evaluate_participant():
-    try:
-        data = request.json
-        participant_id = data.get("participantId")
-        participant_info = data.get("participantInfo", {})
+from google.api_core import exceptions as gexc  # optional, if installed
 
-        evaluator = LepharoEvaluator()
+@app.route("/api/evaluate", methods=["POST"])
+def evaluate_participant():
+    # Validate JSON early (bad JSON should be 400, not 500)
+    if not request.is_json:
+        return jsonify({
+            "status": "error",
+            "message": "Content-Type must be application/json",
+            "requestId": getattr(g, "request_id", "-"),
+        }), 400
+
+    data = request.get_json(silent=True)
+    if not isinstance(data, dict):
+        return jsonify({
+            "status": "error",
+            "message": "Invalid JSON body",
+            "requestId": getattr(g, "request_id", "-"),
+        }), 400
+
+    participant_id = data.get("participantId")
+    participant_info = data.get("participantInfo") or {}
+
+    if not participant_id:
+        return jsonify({"status": "error", "message": "Missing participantId"}), 400
+    if not isinstance(participant_info, dict):
+        return jsonify({"status": "error", "message": "participantInfo must be an object"}), 400
+
+    try:
+        evaluator = GenericEvaluator()
         prompt = evaluator.generate_prompt(participant_info)
 
+        logger.info("EVAL id=%s participantId=%s prompt_chars=%s",
+                    getattr(g, "request_id", "-"),
+                    participant_id,
+                    len(prompt))
+
         response = client.models.generate_content(
             model=model_name,
             contents=prompt
         )
 
-        evaluation = evaluator.parse_gemini_response(response.text)
+        txt = getattr(response, "text", "") or ""
+        logger.info("EVAL id=%s participantId=%s gemini_text_chars=%s",
+                    getattr(g, "request_id", "-"),
+                    participant_id,
+                    len(txt))
+
+        evaluation = evaluator.parse_gemini_response(txt)
+
+        # If Gemini returned something you couldn't parse, don’t hide it.
+        # Return 502 so you can see it's an upstream/model-output problem.
+        if isinstance(evaluation, dict) and evaluation.get("error"):
+            logger.warning("EVAL_PARSE_FAIL id=%s participantId=%s err=%s",
+                           getattr(g, "request_id", "-"),
+                           participant_id,
+                           evaluation.get("error"))
+            return jsonify({
+                "status": "error",
+                "participantId": participant_id,
+                "message": "Model output could not be parsed/validated",
+                "details": evaluation,   # contains error + raw_response/parsed_data
+                "requestId": getattr(g, "request_id", "-"),
+            }), 502
 
         return jsonify({
             "status": "success",
             "participantId": participant_id,
-            "evaluation": evaluation
-        })
+            "evaluation": evaluation,
+            "requestId": getattr(g, "request_id", "-"),
+        }), 200
 
     except Exception as e:
+        # Logs full traceback, but response stays safe
+        logger.exception("EVAL_FAIL id=%s participantId=%s",
+                         getattr(g, "request_id", "-"),
+                         participant_id)
         return jsonify({
             "status": "error",
-            "message": str(e)
+            "participantId": participant_id,
+            "message": "Evaluation failed",
+            "requestId": getattr(g, "request_id", "-"),
         }), 500
 
-
 @app.route('/api/lepharo_batch-evaluate', methods=['POST'])
 def lepharo_batch_evaluate():
     try: