Upload app_risk_report.py

app_risk_report.py

@@ -1475,7 +1475,7 @@ def _build_benchmark_md(forecast_model: str, forecast_data: dict,
 # Architecture:
 #   - Python detects trigger conditions deterministically (forecast RMSE + Winkler ratio,
 #     satellite scene count) and ranks forecast alternatives from diagnostics.
-#   - Historical non-stationarity is retained as evidence, not treated as a failure.
+#   - Historical non-stationarity is retained as evidence; missing historical outputs trigger bounded retries.
 #   - Satellite retries preserve the same variable and widen the evidence window/cloud threshold.
 #   - GPT is used only for the forecast fallback judgment and final narrative.
 #   - Hard caps: MAX_LOOPS_PER_AGENT=2 (satellite), REACT_FORECAST_MAX_RUNS=3, GLOBAL_LOOP_CAP=8.
@@ -2263,36 +2263,88 @@ def _satellite_full_for_report(location, variable, days, max_cloud, spectral_ind
     return satellite_data, sat_outputs
 
 
-def _react_weather_agent(location, variable, days, openai_api_key, react_log):
-    """Historical non-stationarity is evidence, not a retry failure."""
-    current_days = int(days)
-    thought = (
-        f"Running historical climate evidence for {location} / {variable} "
-        f"with the requested {current_days}-day recent window."
-    )
-    action = f"weather_data_analyst(location={location}, variable={variable}, days={current_days})"
+def _extract_weather_anomalies(evidence: str, variable: str) -> list[dict]:
+    """Surface explicit anomaly statements without inventing thresholds or measurements."""
+    import re
+
+    signals = ("anomal", "unusual", "exceptional", "extreme", "record", "above normal",
+               "below normal", "above average", "below average", "departure", "deviation")
+    negations = ("no anomaly", "no anomalies", "no significant anomal", "without anomal",
+                 "not anomalous", "no unusual", "no extreme")
+    findings = []
+    seen = set()
+    # Interpret each sentence/line once; never repeat a remote data request.
+    for fragment in re.split(r"[\n]+|(?<=[.!?])\s+", str(evidence or "")):
+        statement = fragment.strip().lstrip("-* ")
+        lower = statement.lower()
+        if not statement or not any(token in lower for token in signals):
+            continue
+        if any(negative in lower for negative in negations):
+            continue
+        key = lower.casefold()
+        if key in seen:
+            continue
+        seen.add(key)
+        findings.append({
+            "variable": variable,
+            "finding": statement[:600],
+            "source": "NASA POWER structured climate evidence",
+            "status": "reported_signal_not_independently_verified",
+        })
+    return findings[:12]
 
-    wx_outputs = analyze_weather_ui(location, variable, current_days)
-    weather_data = _weather_data_from_ui_outputs(wx_outputs)
 
-    error = weather_data.get("error", "")
-    status_text = weather_data.get("status", "")
-    if status_text.startswith("❌") or status_text.startswith("Error:") or status_text.startswith("Failed"):
-        error = error or status_text
-    stat_conc = weather_data.get("stationarity_conclusion", "")
+def _react_weather_agent(location, variable, days, openai_api_key, react_log):
+    """Fixed-window observation followed by non-blocking anomaly interpretation."""
+    selected_days = int(days)
+    action = (f"weather_data_analyst(location={location}, variable={variable}, "
+              f"days={selected_days})")
+    wx_outputs = analyze_weather_ui(location, variable, selected_days)
+    data = _weather_data_from_ui_outputs(wx_outputs)
+    status = str(data.get("status") or "")
+    error = status if status.lstrip().startswith(("❌", "Error:", "Failed")) else ""
     if error:
-        weather_data["error"] = error
-        observation = f"Historical evidence unavailable: {error}."
-    elif _is_nonstationary(stat_conc):
-        observation = (
-            "Non-stationarity detected and retained as a genuine time-series diagnostic; "
-            "no window escalation is triggered."
-        )
-    else:
-        observation = "Historical evidence available; no retry required."
+        data["error"] = error
 
-    _react_step(react_log, "WeatherAgent", thought, action, observation)
-    return weather_data, wx_outputs, current_days
+    checks = {
+        "structured_evidence": bool(str(data.get("structured_evidence") or "").strip()),
+        "data_preview": bool(data.get("data_preview")),
+        "statistical_tests": bool(data.get("stats_table")),
+        "stationarity_diagnostic": bool(str(data.get("stationarity_conclusion") or "").strip()),
+    }
+    alerts = []
+    for name, available in checks.items():
+        if not available:
+            alerts.append(f"Unavailable diagnostic: {name}")
+    _react_step(react_log, "WeatherAgent", "Retrieve historical evidence once, keeping the requested window.",
+                action, "Historical evidence received." if not error else f"Service issue: {error}")
+
+    # Bounded local interpretation loop: identify, classify, report; no API retries.
+    anomalies = _extract_weather_anomalies(data.get("structured_evidence"), variable)
+    for finding in anomalies:
+        _react_step(react_log, "WeatherAgent", "Review explicit climate anomaly evidence.",
+                    "inspect_structured_evidence", finding["finding"])
+    if anomalies:
+        alerts.append(f"{len(anomalies)} potential weather anomaly signal(s) in structured evidence.")
+    conclusion = str(data.get("stationarity_conclusion") or "")
+    if _is_nonstationary(conclusion):
+        alerts.append("Non-stationarity reported by historical diagnostics (not itself a weather anomaly).")
+    if error:
+        alerts.append(f"Historical service unavailable: {error}")
+
+    data["weather_anomalies"] = anomalies
+    data["weather_alerts"] = alerts
+    data["evidence_quality"] = {
+        **checks,
+        "complete": all(checks.values()) and not bool(error),
+        "selected_window_days": selected_days,
+        "attempted_windows_days": [selected_days],
+        "non_blocking": True,
+        "anomaly_detection_method": "explicit statements in upstream structured evidence",
+    }
+    _react_step(react_log, "WeatherAgent", "Report anomalies and continue downstream.",
+                "report_weather_anomalies", "; ".join(alerts) if alerts else "No explicit anomaly signals; continue.")
+    return data, wx_outputs, selected_days
 
 
 def _react_satellite_agent(location, sat_variable, days, max_cloud, openai_api_key, react_log):
@@ -2543,6 +2595,141 @@ def format_react_log(react_log: list) -> str:
     ]
     return "\n".join(lines)
 
+def _report_visual_evidence(wx_outputs, sat_outputs, fc_outputs, openai_api_key):
+    """Inspect actual chart pixels with a multimodal model, not only numeric captions."""
+    import base64
+    import io
+    import requests
+    from PIL import Image
+    charts = [
+        ("Historical climate context", wx_outputs, 2),
+        ("Historical anomalies", wx_outputs, 3),
+        ("Satellite true-colour scene", sat_outputs, 2),
+        ("Satellite cloud distribution", sat_outputs, 4),
+        ("Satellite land cover", sat_outputs, 5),
+        ("Satellite spectral false-colour gallery", sat_outputs, 12),
+        ("Satellite spectral correlation", sat_outputs, 16),
+        ("Satellite spectral time series", sat_outputs, 14),
+        ("Satellite spectral deviations", sat_outputs, 15),
+        ("Forecast history and outlook", fc_outputs, 4),
+        ("Forecast backtest", fc_outputs, 7),
+    ]
+    content = [{"type": "input_text", "text": (
+        "Inspect the attached climate plots as visual evidence. For each chart, describe "
+        "the actual visual pattern (direction, timing, peaks, anomalies, intervals, gaps), "
+        "distinguish what is visually supported from uncertain interpretation, and "
+        "identify any disagreement between charts. For satellite true-colour and false-colour "
+        "imagery, distinguish visible water, vegetation, exposed soil, snow and clouds "
+        "only when supported by the image and spectral indices. Explain spatial patterns, "
+        "possible land-cover change and image-quality limitations (clouds, sampling, resolution), "
+        "without treating colour alone as a verified land-cover classification. "
+        "Do not infer flood, fire, drought, damage or a temporal change from a single scene. "
+        "Cross-check visual impressions against NDVI, NDWI, NDSI, BSI, metadata and dates. "
+        "Do not invent chart values, "
+        "geographical attribution, causal claims or official warnings. "
+        "Return concise observations with the chart titles."
+    )}]
+    included = []
+    for title, outputs, index in charts:
+        if not outputs or len(outputs) <= index:
+            continue
+        raw = outputs[index]
+        if raw is None:
+            continue
+        try:
+            import numpy as np
+            if isinstance(raw, np.ndarray):
+                img = Image.fromarray(raw.astype('uint8')).convert('RGB')
+            elif isinstance(raw, str):
+                img = Image.open(raw).convert('RGB')
+            else:
+                continue
+            img.thumbnail((1100, 750))
+            buffer = io.BytesIO()
+            img.save(buffer, format='JPEG', quality=76)
+            encoded = base64.b64encode(buffer.getvalue()).decode('ascii')
+            content.append({"type": "input_text", "text": "Chart: " + title})
+            content.append({"type": "input_image", "image_url": "data:image/jpeg;base64," + encoded})
+            included.append(title)
+        except (OSError, ValueError, TypeError):
+            continue
+    if not included:
+        return {"observations": "Visual inspection unavailable: no chart images were accessible.", "charts": []}
+    try:
+        response = requests.post(
+            'https://api.openai.com/v1/responses',
+            headers={'Authorization': f'Bearer {openai_api_key}', 'Content-Type': 'application/json'},
+            json={'model': 'gpt-4.1', 'input': [{'role': 'user', 'content': content}],
+                  'max_output_tokens': 1100}, timeout=120,
+        )
+        response.raise_for_status()
+        payload = response.json()
+        observations = '\n'.join(
+            part.get('text', '') for block in payload.get('output', [])
+            for part in block.get('content', []) if part.get('type') == 'output_text'
+        )
+        return {"observations": observations or 'Visual analysis returned no text.', "charts": included}
+    except requests.RequestException as exc:
+        return {"observations": f'Visual inspection unavailable: {exc}', "charts": included}
+
+
+def _report_react_review(draft, source_prompt, visual_evidence, alert_result, openai_api_key, react_log):
+    """Bounded ReAct editorial review: inspect, critique, revise, then stop."""
+    current = draft
+    for iteration in range(1, 3):
+        review_prompt = (
+            'Review this climate report as an independent scientific editor. Check factual '
+            'grounding, interpretation of actual figures, specific official alert sources and '
+            'dates, daily forecast alignment, uncertainty, actionable implications and all '
+            'eight requested sections. No fabricated alerts or image measurements. '
+            'Return ONLY JSON with keys verdict (accept or revise), issues (array of strings), '
+            'and priority (one string).\n'
+            'VISUAL EVIDENCE: ' + str(visual_evidence)[:6000] + '\n'
+            'WEB ALERTS: ' + str(alert_result)[:4500] + '\n'
+            'REPORT: ' + current[:18000]
+        )
+        try:
+            raw = _call_gpt(review_prompt, openai_api_key,
+                            system='You are a critical, evidence-based climate report reviewer. Return JSON only.',
+                            max_output_tokens=1300)
+            parsed = json.loads(raw.strip().removeprefix('```json').removeprefix('```').removesuffix('```').strip())
+        except (ValueError, TypeError, KeyError) as exc:
+            react_log.append({'agent': 'ReportingAgent', 'thought': 'Review response not parseable',
+                              'action': 'accept_with_review_limit', 'observation': str(exc)})
+            break
+        issues = parsed.get('issues', [])
+        verdict = parsed.get('verdict', 'revise')
+        react_log.append({'agent': 'ReportingAgent', 'thought': f'Editorial review {iteration}',
+                          'action': 'accept' if verdict == 'accept' else 'revise_draft',
+                          'observation': '; '.join(map(str, issues))[:1000] or 'No material issues found'})
+        if verdict == 'accept' or not issues:
+            break
+        revision_prompt = (
+            'Revise the following climate report to resolve the editorial findings. '
+            'Preserve the eight-section structure and all grounded quantitative values. '
+            'Explain observed visual patterns and dated web alerts only where verified; '
+            'never invent a chart value, a warning or a source URL. '
+            'Avoid merely listing numbers: explain implications and contradictions. '
+            'Return the COMPLETE revised Markdown report.\n'
+            'ISSUES: ' + json.dumps(issues, ensure_ascii=False) + '\n'
+            'VISUAL EVIDENCE: ' + str(visual_evidence)[:6000] + '\n'
+            'ALERT SOURCES: ' + str(alert_result)[:4500] + '\n'
+            'ORIGINAL SOURCE CONTEXT: ' + source_prompt[:12500] + '\n'
+            'CURRENT REPORT: ' + current[:18000]
+        )
+        try:
+            revised = _call_gpt(revision_prompt, openai_api_key,
+                                system='You are a climate-risk reporting agent. Preserve facts and citations.',
+                                max_output_tokens=5600)
+            if revised.strip():
+                current = revised
+        except Exception as exc:
+            react_log.append({'agent': 'ReportingAgent', 'thought': 'Revision failed',
+                              'action': 'retain_previous_draft', 'observation': str(exc)})
+            break
+    return current
+
+
 def generate_risk_report_ui(
     location, variable, forecast_model, days, satellite_days, max_cloud, sat_variable
 ):
@@ -2777,6 +2964,31 @@ def generate_risk_report_ui(
     forecast_evidence = forecast_data.get("structured_evidence") or "Unavailable"
     consistency = satellite_data.get("metadata_spectral_consistency", [])
 
+    # Reporting Agent tools: inspect real chart pixels and evaluate web-alert coverage.
+    status_log.append("🔎 [ReportingAgent] Inspecting charts and alert evidence…")
+    yield _emit(status_log, wx=wx_outputs, sat=sat_outputs, fc=fc_outputs)
+    visual_evidence = _report_visual_evidence(wx_outputs, sat_outputs, fc_outputs, openai_api_key)
+    react_log.append({"agent": "ReportingAgent", "thought": "Read actual plots and satellite scenes before drafting",
+                      "action": "inspect_chart_images",
+                      "observation": f"Inspected {len(visual_evidence['charts'])} charts. "
+                                     + visual_evidence['observations'][:500]})
+    alert_result = pplx_news_result
+    if pplx_api_key and not pplx_news_result.get('citations'):
+        try:
+            alert_result = _call_perplexity(
+                f"Find dated official active or recently issued severe weather alerts for {location} "
+                f"from national meteorological services, civil protection or WMO-linked agencies. "
+                "Give issuer, warning type, validity dates, exact source URLs, and distinguish "
+                "confirmed warnings from press reporting. If unverified, explicitly say so.",
+                pplx_api_key, recency='week')
+            react_log.append({"agent": "ReportingAgent", "thought": "Initial alert lookup lacked citations",
+                              "action": "search_official_weather_alerts",
+                              "observation": f"Returned {len(alert_result.get('citations', []))} citations"})
+        except Exception as exc:
+            react_log.append({"agent": "ReportingAgent", "thought": "Supplementary search unavailable",
+                              "action": "continue_without_verified_alerts", "observation": str(exc)})
+    status_log[-1] = "✅ [ReportingAgent] Visual and web evidence reviewed."
+
     synthesis_prompt = f"""
 You are a senior climate-risk analyst. Produce a concise, evidence-grounded report for **{location}**.
 
@@ -2795,6 +3007,9 @@ Recent window: {final_days} days
 {historical_evidence}
 Diagnostic stationarity note: {weather_data.get('stationarity_conclusion', 'N/A')}
 Historical data error: {weather_data.get('error', 'none')}
+Historical weather anomaly signals (unverified statements from structured evidence): {json.dumps(weather_data.get('weather_anomalies', []), ensure_ascii=False)}
+Historical evidence alerts: {json.dumps(weather_data.get('weather_alerts', []), ensure_ascii=False)}
+- Distinguish meteorological anomalies from stationarity diagnostics. Do not invent anomaly thresholds or treat unverified signals as confirmed events.
 
 ## SATELLITE INDEX GLOSSARY — PLAIN LANGUAGE
 - NDVI (Normalized Difference Vegetation Index): vegetation greenness/health; higher generally means denser, more active vegetation.
@@ -2842,6 +3057,13 @@ Each row aligns the app forecast and Open-Meteo operational reference on the sam
 Use these rows exactly in the 7-Day Outlook; do not recalculate the differences.
 {json.dumps(daily_outlook_comparison, ensure_ascii=False)}
 
+## ADDITIONAL REPORTING AGENT EVIDENCE
+Actual chart AND Sentinel-2 scene inspection (qualitative; do not invent numeric values):
+{visual_evidence['observations']}
+Charts inspected: {', '.join(visual_evidence['charts']) or 'none'}
+Official alert search and citations (unverified alerts must not be presented as confirmed):
+{json.dumps(alert_result, ensure_ascii=False)[:6500]}
+
 ## E) RECENT / UPCOMING EXTERNAL EVENT INTELLIGENCE
 {str(pplx_news_result.get('content') or 'External event intelligence unavailable.')[:1600]}
 
@@ -2980,7 +3202,11 @@ For Data Quality, Uncertainty & Scope use exactly four bullets: Forecast reliabi
             if missing_report.strip():
                 gpt_report = gpt_report.rstrip() + "\n\n---\n\n" + missing_report.strip()
 
-        status_log[-1] = "✅ [6/6] GPT synthesis complete. Hazard-focused report ready."
+        react_log.append({"agent": "ReportingAgent", "thought": "Integrate numerical, visual and external evidence",
+                          "action": "draft_report", "observation": "Initial eight-section report drafted"})
+        gpt_report = _report_react_review(
+            gpt_report, synthesis_prompt, visual_evidence, alert_result, openai_api_key, react_log)
+        status_log[-1] = "✅ [6/6] Reporting Agent ReAct review complete."
     except Exception as exc:
         status_log[-1] = f"⚠️ [6/6] GPT error: {exc}"
         gpt_report = f"GPT synthesis failed: {exc}"
@@ -3013,7 +3239,7 @@ with gr.Blocks() as iface_report:
     gr.Markdown(
         "Orchestrates Historical, Sentinel-2 and Forecast agents, compares the statistical "
         "forecast with **Open-Meteo as an operational reference forecast**, and queries "
-        "**Perplexity** for recent/upcoming extreme-event intelligence. GPT synthesises the "
+        "**Perplexity** for recent/upcoming extreme-event intelligence. The Reporting Agent reviews the "
         "already-structured evidence; it does not create numeric risk scores.\n\n"
         "_The report is hazard-focused: exposure and vulnerability are not modelled. "
         "OpenAI and Perplexity credentials are loaded server-side from Hugging Face Space Secrets._"
@@ -3078,7 +3304,7 @@ with gr.Blocks() as iface_report:
     rp_forecast_summary   = gr.State("")
 
     with gr.Tabs():
-        with gr.Tab("📋 Hazard-Focused Report (GPT)"):
+        with gr.Tab("📋 Hazard-Focused Report (ReAct Agent)"):
             rp_gpt_report = gr.Markdown(label="Full Report")
 
         with gr.Tab("📡 Operational Reference (Open-Meteo)"):