Update main.py

main.py

@@ -165,7 +165,7 @@ analyst = ChatGroq(
     temperature=0,
     model_name=DEFAULT_MODEL,
     groq_api_key=GROQ_API_KEY,
-    request_timeout=30.0,
+    request_timeout=35.0,
     max_retries=2
 )
 print(f"[OK] Analyst Model Configured: {DEFAULT_MODEL}", flush=True)
@@ -252,23 +252,29 @@ Task:
 
 async def generate_dynamic_questions_groq(text: str, max_items: int = 6) -> list[dict]:
     """
-    PRIMARY TRACK: Uses Groq to generate single-subject factual questions.
-    Returns: [{"id": 0, "question": "...", "party_a_fact": "..."}, ...]
+    Extracts OBJECTIVE, THIRD-PERSON factual questions from Party A's text.
+    Focuses strictly on observable shared facts: Times, Doors, Aisles, Exits, Parking.
     """
-    system_prompt = """You are a senior forensic legal cross-examiner.
-Analyze Party A's testimony. Extract 4 to 6 concrete, single-subject factual assertions.
+    system_prompt = """You are a senior forensic legal interrogator.
+Analyze Party A's testimony. Extract 4 to 6 OBJECTIVE, THIRD-PERSON factual assertions.
 
 STRICT CRITERIA:
-1. Questions MUST focus on single, atomic facts (e.g., exact time/date, specific location, named companion, specific item or physical action).
-2. NEVER ask broad, vague, or summary questions (e.g., do NOT ask "What happened?", "What is the accusation?", "Can you describe the event?").
-3. For each question, extract the EXACT verbatim sentence from Party A's testimony that provides the answer as 'party_a_fact'.
-4. Respond ONLY with a valid JSON object with a root key "queries" containing the list:
+1. NEVER write questions in the first person ("I", "me", "my bag", "my wallet"). 
+   Always refer to the parties as "the complainant", "Party A", or "the accused".
+2. Focus ONLY on observable, external facts that both parties or security could witness:
+   - Arrival time and entrance door used
+   - In-store location, movements, and observations of the other party (e.g., electronics aisle, pharmacy, registers)
+   - Departure time and exit door used
+   - Parking lot location
+3. NEVER ask about private internal actions (e.g., do NOT ask about checking phone prices or private thoughts).
+4. For each question, extract the EXACT verbatim sentence from Party A's testimony answering it as 'party_a_fact'.
+5. Respond ONLY with a valid JSON object matching this structure:
 {
   "queries": [
     {
       "id": 0,
-      "question": "What specific time did Party A arrive at the store?",
-      "party_a_fact": "On March 14, I arrived at the store around 6:15 PM to buy groceries."
+      "question": "At what time and through which door did the accused allegedly exit the store?",
+      "party_a_fact": "Security reviewed footage and pointed me toward the accused, who had exited through the side door near the pharmacy at approximately 6:35 PM."
     }
   ]
 }"""
@@ -282,22 +288,35 @@ STRICT CRITERIA:
     response = await chain.ainvoke({"text": text})
     raw_content = response.content.strip()
 
+    # 1. Clean reasoning tags (<think>...</think>) if present
+    raw_content = re.sub(r"<think>.*?</think>", "", raw_content, flags=re.DOTALL).strip()
+    
+    # 2. Clean markdown code block markers
+    if "```" in raw_content:
+        raw_content = re.sub(r"```(?:json)?", "", raw_content).replace("```", "").strip()
+
+    # 3. Extract JSON object
     json_match = re.search(r"\{.*\}", raw_content, re.DOTALL)
     if json_match:
-        data = json.loads(json_match.group(0))
-        items = data.get("queries", []) if isinstance(data, dict) else data
-        valid_items = []
-        for idx, item in enumerate(items[:max_items]):
-            if "question" in item and "party_a_fact" in item:
-                valid_items.append({
-                    "id": idx,
-                    "question": str(item["question"]).strip(),
-                    "party_a_fact": str(item["party_a_fact"]).strip()
-                })
-        if valid_items:
-            return valid_items
-
-    raise ValueError("Groq returned unparseable JSON for Party A questions.")
+        try:
+            data = json.loads(json_match.group(0))
+            items = data.get("queries", []) if isinstance(data, dict) else data
+            valid_items = []
+            for idx, item in enumerate(items[:max_items]):
+                q_text = str(item.get("question", "")).strip()
+                fact_text = str(item.get("party_a_fact", "")).strip()
+                if q_text and fact_text:
+                    valid_items.append({
+                        "id": idx,
+                        "question": q_text,
+                        "party_a_fact": fact_text
+                    })
+            if valid_items:
+                return valid_items
+        except Exception as parse_err:
+            print(f"[PARSER ERROR] {parse_err} | Raw: {raw_content[:150]}", flush=True)
+
+    raise ValueError(f"Groq output could not be parsed: {raw_content[:150]}")
 
 def generate_dynamic_questions_local_t5(text: str, max_items: int = 5) -> list[dict]:
     """
@@ -371,15 +390,21 @@ RULES:
     })
     
     raw_content = response.content.strip()
+    raw_content = re.sub(r"<think>.*?</think>", "", raw_content, flags=re.DOTALL).strip()
+    if "```" in raw_content:
+        raw_content = re.sub(r"```(?:json)?", "", raw_content).replace("```", "").strip()
+
     json_match = re.search(r"\{.*\}", raw_content, re.DOTALL)
-    
     results_map = {}
     if json_match:
-        data = json.loads(json_match.group(0))
-        items = data.get("answers", []) if isinstance(data, dict) else data
-        for entry in items:
-            if "id" in entry and "answer" in entry:
-                results_map[int(entry["id"])] = str(entry["answer"]).strip()
+        try:
+            data = json.loads(json_match.group(0))
+            items = data.get("answers", []) if isinstance(data, dict) else data
+            for entry in items:
+                if "id" in entry and "answer" in entry:
+                    results_map[int(entry["id"])] = str(entry["answer"]).strip()
+        except Exception as e:
+            print(f"[PARTY B PARSE WARNING] {e}", flush=True)
 
     for item in factual_pairs:
         idx = item["id"]
@@ -403,14 +428,14 @@ async def health_check():
     diagnostic["key_length"] = len(GROQ_API_KEY) if GROQ_API_KEY else 0
     diagnostic["key_format_valid"] = (GROQ_API_KEY.startswith("gsk_") and len(GROQ_API_KEY) > 20) if GROQ_API_KEY else False
 
-    # 2. DNS Check (Can container resolve api.groq.com?)
+    # 2. DNS Check
     try:
         ip = socket.gethostbyname("api.groq.com")
         diagnostic["dns_resolution"] = f"SUCCESS ({ip})"
     except Exception as dns_err:
         diagnostic["dns_resolution"] = f"FAILED: {str(dns_err)}"
 
-    # 3. Direct HTTPS Ping (Tests whether Groq accepts this exact key without LangChain)
+    # 3. Direct HTTPS Ping
     if GROQ_API_KEY:
         try:
             req = urllib.request.Request(
@@ -543,10 +568,10 @@ async def stream_compare_testimonies(
 ):
     """
     Symmetric Streaming Testimony Validator (SSE).
-    1. Primary: Groq isolates single-subject questions and pairs with Party A's facts.
-    2. Fast Fallback: Local T5 (greedy) executes in ~1.5s if Groq is unavailable.
+    1. Primary: Groq dynamically isolates single-subject, third-person questions.
+    2. Fast Fallback: Local T5 takes over in ~1.5s if Groq is unavailable.
     3. Cross-examines Party B on identical queries using integer indexes.
-    4. Streams real-time events without proxy buffering.
+    4. Anti-buffering headers flush SSE chunks to Vercel instantly.
     """
     async def resolve_input(file: UploadFile, text: str) -> str:
         if file and file.filename:
@@ -572,7 +597,7 @@ async def stream_compare_testimonies(
             try:
                 factual_pairs = await generate_dynamic_questions_groq(c_content, max_items=6)
                 mode_label = "Groq LPU"
-                print(f"[SUCCESS] Groq generated {len(factual_pairs)} questions.", flush=True)
+                print(f"[SUCCESS] Groq generated {len(factual_pairs)} objective questions.", flush=True)
             except Exception as qg_err:
                 print(f"[NOTICE] Groq QG failed ({qg_err}). Engaging Fast T5 Fallback...", flush=True)
                 factual_pairs = generate_dynamic_questions_local_t5(c_content, max_items=5)