feat: parse real tool responses in agent execution summary

app.py

@@ -112,56 +112,136 @@ def analyze_image(image_path: str) -> Optional[str]:
 
 
 def _extract_result_summary(observations: str) -> str:
-    """Extract a short summary from tool observations."""
+    """Extract a short, meaningful summary from tool observations."""
     import re
     if not observations:
         return ""
     obs_lower = observations.lower()
 
-    # Address validation - extract formatted address or borough
-    if "borough" in obs_lower or "manhattan" in obs_lower or "brooklyn" in obs_lower:
-        # Try formatted address first
-        match = re.search(r'"formatted_address"[:\s]*"([^"]+)"', observations)
-        if match:
-            addr = match.group(1)
-            lat_match = re.search(r'"lat"[:\s]*(-?\d+\.?\d*)', observations)
-            lon_match = re.search(r'"lon"[:\s]*(-?\d+\.?\d*)', observations)
-            if lat_match and lon_match:
-                return f"{addr[:30]} ({lat_match.group(1)[:6]}, {lon_match.group(1)[:7]})"
-            return addr[:40]
-        match = re.search(r'"borough"[:\s]*"([^"]+)"', observations)
-        if match:
-            return match.group(1)
-
-    # Nearby reports
-    if "nearby" in obs_lower or "similar" in obs_lower:
-        match = re.search(r'(\d+)\s*(?:similar|nearby|reports)', obs_lower)
-        if match:
-            return f"{match.group(1)} similar nearby"
-
-    # Weather
-    if "temperature" in obs_lower or "weather" in obs_lower:
-        temp_match = re.search(r'(\d+)[°]?[FCfc]', observations)
+    # Weather - extract temp + conditions + hazard level
+    if "temp_f" in obs_lower or ("conditions" in obs_lower and "hazard" in obs_lower):
+        temp_match = re.search(r"['\"]temp_f['\"]:\s*(\d+)", observations)
+        cond_match = re.search(r"['\"]conditions['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        hazard_match = re.search(r"['\"]hazard_level['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        parts = []
         if temp_match:
-            return f"{temp_match.group(1)}°F"
-
-    # Asset lookup
-    if "asset_id" in obs_lower:
-        match = re.search(r'"asset_id"[:\s]*"([^"]+)"', observations)
-        if match:
-            return f"Asset: {match.group(1)}"
+            parts.append(f"{temp_match.group(1)}°F")
+        if cond_match:
+            parts.append(cond_match.group(1)[:20])
+        if hazard_match and hazard_match.group(1) != "low":
+            parts.append(f"⚠️{hazard_match.group(1)}")
+        if parts:
+            return ", ".join(parts)
+
+    # Address validation - extract borough + formatted address
+    if "is_valid_nyc" in obs_lower or "formatted_address" in obs_lower:
+        borough_match = re.search(r"['\"]borough['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        addr_match = re.search(r"['\"]formatted_address['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        valid_match = re.search(r"['\"]is_valid_nyc['\"]:\s*(true|false)", obs_lower)
+
+        if valid_match and valid_match.group(1) == "false":
+            return "❌ Not NYC"
+        if addr_match:
+            addr = addr_match.group(1)
+            # Shorten long addresses
+            if len(addr) > 35:
+                addr = addr[:32] + "..."
+            return f"✓ {addr}"
+        if borough_match:
+            return f"✓ {borough_match.group(1)}"
+
+    # Nearby reports - extract count + pattern info
+    if "total_reports" in obs_lower or "nearby" in obs_lower:
+        total_match = re.search(r"['\"]total_reports['\"]:\s*(\d+)", observations)
+        open_match = re.search(r"['\"]open_reports['\"]:\s*(\d+)", observations)
+        pattern_match = re.search(r"['\"]pattern_detected['\"]:\s*(true|false)", obs_lower)
+
+        if total_match:
+            total = int(total_match.group(1))
+            open_count = int(open_match.group(1)) if open_match else 0
+            pattern = pattern_match and pattern_match.group(1) == "true"
+
+            if total == 0:
+                return "No similar reports"
+            result = f"{total} reports"
+            if open_count > 0:
+                result += f" ({open_count} open)"
+            if pattern:
+                result += " 🔄"
+            return result
+
+    # Asset lookup - extract asset_id + status + complaints
+    if "asset_id" in obs_lower or "asset_type" in obs_lower:
+        asset_match = re.search(r"['\"]asset_id['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        status_match = re.search(r"['\"]status['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        complaints_match = re.search(r"['\"]recent_complaints['\"]:\s*(\d+)", observations)
+
+        parts = []
+        if asset_match:
+            asset_id = asset_match.group(1)
+            if len(asset_id) > 20:
+                asset_id = asset_id[:17] + "..."
+            parts.append(asset_id)
+        if complaints_match:
+            parts.append(f"{complaints_match.group(1)} complaints")
+        elif status_match:
+            status = status_match.group(1).replace("_", " ")
+            parts.append(status[:15])
+
+        if parts:
+            return ", ".join(parts)
+
+    # PDF report - extract report_id + status
+    if "report_id" in obs_lower and ("generated" in obs_lower or "pdf" in obs_lower):
+        report_match = re.search(r"['\"]report_id['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        status_match = re.search(r"['\"]status['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        size_match = re.search(r"['\"]size_kb['\"]:\s*([\d.]+)", observations)
+
+        if report_match:
+            report_id = report_match.group(1)
+            if status_match and status_match.group(1) == "generated":
+                size_str = f" ({size_match.group(1)}KB)" if size_match else ""
+                return f"📄 {report_id}{size_str}"
+            return f"📄 {report_id}"
+
+    # Email sent - extract recipient info (demo mode - sink)
+    if "email" in obs_lower or "sendgrid" in obs_lower:
+        if "success" in obs_lower or "sent" in obs_lower or "queued" in obs_lower:
+            to_match = re.search(r"['\"]to['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+            if to_match:
+                email = to_match.group(1)
+                # Show just domain for privacy
+                if "@" in email:
+                    domain = email.split("@")[1]
+                    return f"✉️ → @{domain} (demo sink)"
+            return "✉️ Sent (demo sink)"
+        if "error" in obs_lower or "failed" in obs_lower:
+            return "❌ Email failed"
+
+    # Department info - extract name + response time
+    if "department" in obs_lower or "response_time" in obs_lower:
+        name_match = re.search(r"['\"]name['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        time_match = re.search(r"['\"]response_time['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+
+        if name_match:
+            name = name_match.group(1)[:25]
+            if time_match:
+                return f"{name} ({time_match.group(1)})"
+            return name
+
+    # Generic borough detection (fallback)
+    for borough in ["Manhattan", "Brooklyn", "Queens", "Bronx", "Staten Island"]:
+        if borough.lower() in obs_lower:
+            return f"✓ {borough}"
+
+    # Error detection
+    if "error" in obs_lower:
+        error_match = re.search(r"['\"]error['\"]:\s*['\"]([^'\"]+)['\"]", observations)
+        if error_match:
+            err = error_match.group(1)[:30]
+            return f"⚠️ {err}"
 
-    # PDF report
-    if "report_id" in obs_lower:
-        match = re.search(r'"report_id"[:\s]*"([^"]+)"', observations)
-        if match:
-            return f"Report: {match.group(1)}"
-
-    # Email
-    if "email" in obs_lower and "sent" in obs_lower:
-        return "Sent to department"
-
-    return "Done"
+    return ""
 
 
 def _extract_tool_input_preview(tool_name: str, input_str: str) -> str:
@@ -253,7 +333,7 @@ def build_agent_summary(tool_history: list, total_duration: str = "") -> str:
     """
     Build a compact summary of agent execution for final display.
 
-    Shows the agent hierarchy with completed tools (no timing indicator).
+    Shows the agent hierarchy with completed tools and meaningful results.
     """
     if not tool_history:
         return ""
@@ -263,11 +343,23 @@ def build_agent_summary(tool_history: list, total_duration: str = "") -> str:
     agent_icons = {"triage": "🎯", "research": "🔍", "report": "📋"}
     agent_names = {"triage": "Triage Agent", "research": "Research Agent", "report": "Report Agent"}
 
+    # Skip internal/meta tools that don't add value to summary
+    skip_tools = {"Finalizing Response", "📍 Map updated"}
+
     for tool in tool_history:
         agent = tool.get("agent")
         name = tool.get("display_name", tool.get("tool", "Unknown"))
         result = tool.get("result_summary", "")
 
+        # Skip meta tools unless they have meaningful results
+        if name in skip_tools and not result:
+            continue
+        # Keep map update if it has location info
+        if name == "📍 Map updated":
+            if result:
+                lines.append(f"  └─ 📍 {result}")
+            continue
+
         # Show agent header when agent changes
         if agent and agent != current_agent:
             current_agent = agent
@@ -275,7 +367,7 @@ def build_agent_summary(tool_history: list, total_duration: str = "") -> str:
             agent_name = agent_names.get(agent, agent.title())
             lines.append(f"● {icon} **{agent_name}**")
 
-        # Tool with result (compact)
+        # Tool with result (compact, meaningful)
         if result:
             lines.append(f"  └─ {name} → {result}")
         else:
@@ -742,6 +834,8 @@ with gr.Blocks(title="FixMyNeighborhood - Multi-Agent Reporter") as demo:
     - **Reasoning Trace** - See the agent's thought process in real-time
     - **Completeness Check** - Smart follow-up questions when info is missing
     - **Quality Self-Check** - Reports scored before submission
+
+    > ⚠️ **Demo Mode:** Emails are sent to a sink (not delivered to real recipients)
     """)
 
     with gr.Row():