Handle GPT refusal paths and preserve assessment status

app.py

@@ -147,9 +147,10 @@ async def _enrich_first_frame_gpt(
                 info = gpt_results[obj_id]
                 det.update(info)
                 det["gpt_raw"] = info
-            # Mark ASSESSED regardless of whether GPT returned data for this object
-            det["assessment_frame_index"] = 0
-            det["assessment_status"] = "ASSESSED"
+                det.setdefault("assessment_frame_index", 0)
+                det["assessment_status"] = info.get("assessment_status", "ASSESSED")
+            else:
+                det.setdefault("assessment_status", "UNASSESSED")
 
         for det in detections:
             if "assessment_status" not in det:

inference.py

@@ -1126,10 +1126,13 @@ def run_inference(
                     for d in gpt_dets:
                         oid = d.get('track_id')
                         if oid and oid in gpt_res:
-                            d.update(gpt_res[oid])
-                            d["gpt_raw"] = gpt_res[oid]
+                            gpt_payload = gpt_res[oid]
+                            d.update(gpt_payload)
+                            d["gpt_raw"] = gpt_payload
                             d["assessment_frame_index"] = frame_idx
-                            d["assessment_status"] = "ASSESSED"
+                            d["assessment_status"] = gpt_payload.get(
+                                "assessment_status", "ASSESSED"
+                            )
 
                     # Push GPT data back into tracker's internal STrack objects
                     tracker_ref.inject_metadata(gpt_dets)
@@ -2080,7 +2083,9 @@ def run_grounded_sam2_tracking(
                                 merged = dict(gpt_res[tid])
                                 merged["gpt_raw"] = gpt_res[tid]
                                 merged["assessment_frame_index"] = frame_idx
-                                merged["assessment_status"] = "ASSESSED"
+                                merged["assessment_status"] = merged.get(
+                                    "assessment_status", "ASSESSED"
+                                )
                                 with gpt_data_lock:
                                     gpt_data_by_track[tid] = merged
                         logging.info("GSAM2 enrichment: GPT results stored for %d tracks", len(gpt_data_by_track))

utils/gpt_reasoning.py

@@ -32,6 +32,34 @@ _DOMAIN_ROLES = {
     "GENERIC": "Tactical Surveillance Analyst",
 }
 
+_HUMAN_LABEL_HINTS = frozenset({
+    "person", "people", "human", "pedestrian",
+    "man", "woman", "boy", "girl", "child",
+    "civilian", "soldier", "infantry", "troop", "trooper",
+})
+
+
+def _is_human_label(label: str) -> bool:
+    label_l = (label or "").lower().strip()
+    if not label_l:
+        return False
+    parts = [p for p in re.split(r"[^a-z0-9]+", label_l) if p]
+    return any(part in _HUMAN_LABEL_HINTS for part in parts)
+
+
+def _build_status_fallback(
+    object_ids: List[str],
+    status: str,
+    reason: str,
+) -> Dict[str, Dict[str, Any]]:
+    return {
+        obj_id: {
+            "assessment_status": status,
+            "gpt_reason": reason,
+        }
+        for obj_id in object_ids
+    }
+
 _UNIVERSAL_SCHEMA = (
     "RESPONSE SCHEMA (JSON):\n"
     "{\n"
@@ -144,17 +172,37 @@ def estimate_threat_gpt(
         logger.error("OPENAI_API_KEY not set. Skipping GPT threat assessment.")
         return {}
 
-    # 1. Prepare detections summary for prompt
-    det_summary = []
+    # 1. Prepare detections summary for prompt.
+    # Human/person classes are explicitly skipped to avoid refusal paths.
+    prompt_items = []
+    skipped_human_ids: List[str] = []
     for i, det in enumerate(detections):
-        obj_id = det.get("track_id") or det.get("id") or f"T{str(i+1).zfill(2)}"
+        obj_id = str(det.get("track_id") or det.get("id") or f"T{str(i+1).zfill(2)}")
         bbox = det.get("bbox", [])
-        label = det.get("label", "object")
-        det_summary.append(f"- ID: {obj_id}, Classification Hint: {label}, BBox: {bbox}")
-
-    det_text = "\n".join(det_summary)
+        label = str(det.get("label", "object"))
+        if _is_human_label(label):
+            skipped_human_ids.append(obj_id)
+            continue
+        prompt_items.append({"obj_id": obj_id, "label": label, "bbox": bbox})
+
+    det_text = "\n".join(
+        [
+            f"- ID: {it['obj_id']}, Classification Hint: {it['label']}, BBox: {it['bbox']}"
+            for it in prompt_items
+        ]
+    )
 
     if not det_text:
+        if skipped_human_ids:
+            logger.warning(
+                "Skipping GPT threat assessment for %d human/person detections due policy constraints.",
+                len(skipped_human_ids),
+            )
+            return _build_status_fallback(
+                skipped_human_ids,
+                "SKIPPED_POLICY",
+                "Human/person analysis skipped due policy constraints.",
+            )
         return {}
 
     # 2. Encode image (prefer pre-encoded b64 to avoid disk I/O)
@@ -231,17 +279,68 @@ def estimate_threat_gpt(
         with urllib.request.urlopen(req, timeout=30) as response:
             resp_data = json.loads(response.read().decode('utf-8'))
             
-        content = resp_data['choices'][0]['message'].get('content')
+        choice_msg = resp_data.get("choices", [{}])[0].get("message", {})
+        content = choice_msg.get("content")
         if not content:
-            logger.warning("GPT returned empty content. Full response: %s", resp_data)
-            return {}
+            refusal = choice_msg.get("refusal")
+            if refusal:
+                logger.warning("GPT refused threat assessment: %s", refusal)
+            else:
+                logger.warning(
+                    "GPT returned empty content. response_id=%s finish_reason=%s",
+                    resp_data.get("id"),
+                    resp_data.get("choices", [{}])[0].get("finish_reason"),
+                )
+            fallback = _build_status_fallback(
+                [it["obj_id"] for it in prompt_items],
+                "REFUSED",
+                refusal or "GPT returned empty content.",
+            )
+            fallback.update(
+                _build_status_fallback(
+                    skipped_human_ids,
+                    "SKIPPED_POLICY",
+                    "Human/person analysis skipped due policy constraints.",
+                )
+            )
+            return fallback
 
         result_json = json.loads(content)
         
         objects = result_json.get("objects", {})
+        if not isinstance(objects, dict):
+            logger.warning(
+                "GPT response 'objects' field is not a dict (got %s); using fallback.",
+                type(objects).__name__,
+            )
+            objects = {}
+
+        # Ensure every requested object receives an explicit assessment state.
+        for it in prompt_items:
+            oid = it["obj_id"]
+            if oid not in objects:
+                objects[oid] = {
+                    "assessment_status": "NO_RESPONSE",
+                    "gpt_reason": "No structured assessment returned for object.",
+                }
+        for oid in skipped_human_ids:
+            objects.setdefault(
+                oid,
+                {
+                    "assessment_status": "SKIPPED_POLICY",
+                    "gpt_reason": "Human/person analysis skipped due policy constraints.",
+                },
+            )
 
         # Polyfill legacy fields for frontend compatibility
         for obj_id, data in objects.items():
+            if not isinstance(data, dict):
+                data = {
+                    "assessment_status": "NO_RESPONSE",
+                    "gpt_reason": "Malformed object payload from GPT.",
+                }
+                objects[obj_id] = data
+
             # 1. Distance: parse free-text range_estimate to meters
             range_m = _parse_range_to_meters(data.get("range_estimate", ""))
             if range_m is not None:
@@ -272,4 +371,16 @@ def estimate_threat_gpt(
 
     except Exception as e:
         logger.error("GPT API call failed: %s", e, exc_info=True)
-        return {}
+        fallback = _build_status_fallback(
+            [it["obj_id"] for it in prompt_items],
+            "ERROR",
+            f"GPT API call failed: {e.__class__.__name__}",
+        )
+        fallback.update(
+            _build_status_fallback(
+                skipped_human_ids,
+                "SKIPPED_POLICY",
+                "Human/person analysis skipped due policy constraints.",
+            )
+        )
+        return fallback