Update app.py

app.py

@@ -20,7 +20,7 @@ import spaces
 # ============================================================
 
 APP_NAME = "X-RUDRA"
-VERSION = "3.1.0"
+VERSION = "3.2.0"   # bumped version
 
 M1_REPO = os.getenv("M1_REPO", "Shrijanagain/M1")
 M2_REPO = os.getenv("M2_REPO", "Shrijanagain/M2")
@@ -62,24 +62,74 @@ def safe_dict(value):
 
 
 # ============================================================
-# FORMATTERS (same as before, but shortened for brevity)
+# FORMATTERS (unchanged)
 # ============================================================
 
 def format_sources(sources):
     if not sources:
         return "## 📚 Sources\n\nNo sources were returned."
-    # ... (keep your existing implementation) ...
-    # (I'll include the full code in the final answer)
+    output = ["## 📚 Sources", ""]
+    for idx, src in enumerate(sources, 1):
+        if not isinstance(src, dict):
+            continue
+        title = src.get("title", "Untitled")
+        url = src.get("url", "")
+        method = src.get("fetch_method", "web")
+        score = src.get("source_score", src.get("score", "N/A"))
+        snippet = src.get("snippet", src.get("description", ""))
+        if url:
+            output.append(f"### {idx}. [{title}]({url})")
+        else:
+            output.append(f"### {idx}. {title}")
+        output.append(f"**Fetcher:** `{method}`")
+        output.append(f"**Source score:** `{score}`")
+        if snippet:
+            output.append(f"\n> {snippet}")
+        output.append("")
+    return "\n".join(output)
+
 
 def format_evidence(claims):
     if not claims:
         return "## 🧠 Evidence\n\nNo structured evidence was returned."
-    # ...
+    output = ["## 🧠 Evidence", ""]
+    for idx, claim in enumerate(claims, 1):
+        if not isinstance(claim, dict):
+            continue
+        text = claim.get("claim", claim.get("text", ""))
+        score = claim.get("support_score", claim.get("score", "N/A"))
+        source = claim.get("source_url", claim.get("url", ""))
+        output.append(f"### Evidence {idx}")
+        output.append(str(text))
+        output.append(f"**Support:** `{score}`")
+        if source:
+            output.append(f"**Source:** {source}")
+        output.append("---")
+    return "\n\n".join(output)
+
 
 def format_verification(contradictions):
     if not contradictions:
-        return "## ⚖️ Verification\n\n✅ No contradictions detected."
-    # ...
+        return "## ⚖️ Verification\n\n✅ No major contradictions detected."
+    output = ["## ⚖️ Verification", "", "⚠️ Potential contradictions detected:", ""]
+    for idx, item in enumerate(contradictions, 1):
+        if not isinstance(item, dict):
+            continue
+        claim_a = item.get("claim_a", "")
+        claim_b = item.get("claim_b", "")
+        source_a = item.get("source_a", "")
+        source_b = item.get("source_b", "")
+        output.append(f"### Contradiction {idx}")
+        output.append(f"**A:** {claim_a}")
+        if source_a:
+            output.append(f"Source A: `{source_a}`")
+        output.append("")
+        output.append(f"**B:** {claim_b}")
+        if source_b:
+            output.append(f"Source B: `{source_b}`")
+        output.append("---")
+    return "\n\n".join(output)
+
 
 def extract_answer(data):
     # Try common fields
@@ -87,31 +137,50 @@ def extract_answer(data):
         val = data.get(key)
         if isinstance(val, str) and val.strip():
             return val.strip()
-    # Fallback to claims
-    claims = data.get("claims", [])
-    if claims:
-        parts = []
-        for claim in claims:
-            if isinstance(claim, dict):
-                text = claim.get("claim", claim.get("text", ""))
-                if text:
-                    parts.append(str(text).strip())
-        if parts:
-            return "\n\n".join(parts[:10])
-    return None  # No answer found
+    # If no answer, we'll build one from results in the caller
+    return None
+
 
 def build_activity(data, elapsed_ms):
-    sources = data.get("sources", [])
+    sources = data.get("sources", []) or data.get("results", [])
     claims = data.get("claims", [])
     contradictions = data.get("contradictions", [])
     rounds = data.get("rounds", data.get("research_rounds", "N/A"))
     return f"""
 ## ⚡ X-RUDRA Research
-...
+
+| Stage | Status |
+|---|---|
+| Task analysis | ✅ Complete |
+| M1 research | {"✅ Enabled" if data.get("m1") is not None else "⚙️ Pipeline"} |
+| M2 research | {"✅ Enabled" if data.get("m2") is not None else "⚙️ Pipeline"} |
+| Web discovery | ✅ Complete |
+| Evidence extraction | {"✅" if data.get("claims") else "⚙️"} |
+| Source verification | ✅ Complete |
+| Contradiction check | {"⚠️ Found" if contradictions else "✅ Clear"} |
+| Final synthesis | {"✅" if extract_answer(data) else "⚙️"} |
+
+**Sources:** `{len(sources)}`  
+**Claims:** `{len(claims)}`  
+**Rounds:** `{rounds}`  
+**Time:** `{elapsed_ms} ms`
+
+### Engine
+
+`M1` → `{M1_REPO}`
+
+`M2` → `{M2_REPO}`
+
+`Web` → `DuckDuckGo`
+
+`Fetcher` → `Scrapling`
+
+`Browser` → `Playwright`
 """
 
+
 # ============================================================
-# RESEARCH FUNCTION
+# RESEARCH FUNCTION – FIXED TO HANDLE ENGINE OUTPUT
 # ============================================================
 
 async def do_research(question, max_results, max_rounds, use_models, freshness):
@@ -133,34 +202,61 @@ async def do_research(question, max_results, max_rounds, use_models, freshness):
         data = safe_dict(report)
         elapsed_ms = int((time.perf_counter() - started) * 1000)
 
-        # Debug: print raw data to logs
+        # Debug: print raw data to logs (helps with debugging)
         print("\n" + "="*60)
         print("RAW ENGINE DATA:")
-        print(json.dumps(data, indent=2, default=str)[:2000])  # print first 2000 chars
+        print(json.dumps(data, indent=2, default=str)[:3000])  # first 3000 chars
         print("="*60 + "\n")
 
-        # Extract answer
+        # ------------------------------------------------------------
+        # 1. EXTRACT SOURCES – convert 'results' to 'sources' if needed
+        # ------------------------------------------------------------
+        sources = data.get("sources", [])
+        if not sources:
+            # Engine uses 'results' – convert each to source format
+            results = data.get("results", [])
+            for res in results:
+                if isinstance(res, dict):
+                    sources.append({
+                        "title": res.get("title", ""),
+                        "url": res.get("url", ""),
+                        "snippet": res.get("snippet", ""),
+                        "fetch_method": "web",
+                        "source_score": res.get("rank", "N/A"),
+                        "description": res.get("snippet", ""),
+                    })
+            # Store back for activity and formatters
+            data["sources"] = sources
+
+        # ------------------------------------------------------------
+        # 2. EXTRACT ANSWER – if missing, synthesize from sources
+        # ------------------------------------------------------------
         answer = extract_answer(data)
         if answer is None:
-            # No answer found – build a fallback message
-            sources_count = len(data.get("sources", []))
-            claims_count = len(data.get("claims", []))
-            if sources_count == 0 and claims_count == 0:
-                answer = (
-                    "❌ **No information found.**\n\n"
-                    "The research engine did not return any sources or evidence. "
-                    "Possible reasons:\n"
-                    "- The M1 or M2 Spaces are not responding (check their API endpoints).\n"
-                    "- The web search failed to extract results.\n"
-                    "- The query might be too specific or ambiguous.\n\n"
-                    "Try rephrasing your question or check the M1/M2 Spaces' logs."
-                )
+            # Build a simple answer from the top sources
+            if sources:
+                top = sources[:5]
+                parts = [f"Based on the top results:"]
+                for i, src in enumerate(top, 1):
+                    title = src.get("title", "Untitled")
+                    snippet = src.get("snippet", src.get("description", ""))
+                    parts.append(f"{i}. **{title}** – {snippet[:200]}..." if snippet else f"{i}. **{title}**")
+                answer = "\n\n".join(parts)
             else:
-                answer = "Research completed, but no synthesized answer was generated."
-
-        # Build outputs
-        sources_md = format_sources(data.get("sources", []))
-        evidence_md = format_evidence(data.get("claims", []))
+                answer = "No information found. Try rephrasing your question."
+
+        # ------------------------------------------------------------
+        # 3. CLAIMS – if missing, we can keep empty or derive from snippets
+        # ------------------------------------------------------------
+        claims = data.get("claims", [])
+        # (Optional) You could generate simple claims from each source's snippet,
+        # but we'll leave it empty for now.
+
+        # ------------------------------------------------------------
+        # 4. BUILD OUTPUTS
+        # ------------------------------------------------------------
+        sources_md = format_sources(sources)
+        evidence_md = format_evidence(claims)
         verification_md = format_verification(data.get("contradictions", []))
         activity_md = build_activity(data, elapsed_ms)
 
@@ -208,7 +304,7 @@ def health_check():
 
 
 # ============================================================
-# CSS AND UI
+# CSS AND UI (unchanged)
 # ============================================================
 
 CSS = """