sync: 155 file da Baida98/AI@1db7f191 (2026-08-15 12:08 UTC) [deploy-all]

api/telegram_webhook.py

@@ -1588,209 +1588,110 @@ async def _cmd_score(chat_id: int) -> None:
         await _tg_reply(chat_id, det[_TG_MAX:_TG_MAX*2][:_TG_MAX], keyboard=_BENCH_ACTION_KB)
 
 
+def _format_live_quality_benchmark(report: dict) -> str:
+    """Formatta solo risultati prodotti dal benchmark quality corrente."""
+    timestamp = str(report.get("timestamp") or "")[:19].replace("T", " ")
+    score = report.get("total_score", "N/A")
+    results = report.get("results") if isinstance(report.get("results"), list) else []
+    errors = report.get("errors") if isinstance(report.get("errors"), list) else []
+    outcome = "✅" if report.get("ok") else "⚠️"
+    lines = [
+        f"📊 <b>Benchmark live Quality</b> — {outcome}",
+        f"🕐 <code>{html.escape(timestamp or 'ora non disponibile')}</code>",
+        f"📈 <b>Score live:</b> <code>{html.escape(str(score))}/100</code>",
+        f"🧪 Categorie eseguite: <code>{len(results)}</code>",
+    ]
+    if results:
+        lines.append("\n<b>Risultati della run corrente:</b>")
+        for item in results[:12]:
+            label = html.escape(str(item.get("label") or item.get("id") or "categoria")[:42])
+            value = item.get("score", "N/A")
+            try:
+                icon = "🟢" if float(value) >= 75 else "🟡" if float(value) >= 50 else "🔴"
+            except (TypeError, ValueError):
+                icon = "⚪"
+            lines.append(f"{icon} <code>{str(value):>5}</code>  {label}")
+    if errors:
+        lines.append(f"\n⚠️ <b>Errori della run:</b> <code>{len(errors)}</code>")
+        for error in errors[:2]:
+            lines.append("<i>" + html.escape(str(error)[:180]) + "</i>")
+    lines.append("\n<i>Misura live del backend: nessun report storico o workflow GitHub è stato usato.</i>")
+    return "\n".join(lines)[:3900]
+
+
 async def _cmd_bench(chat_id: int, mode: str = "default") -> None:
-    """📊 Benchmark via bench.yml (benchmark-extended.mjs) + quickchart.io.
+    """Esegue il benchmark quality live del backend senza dipendere da GitHub Actions.
 
-    GAP-TGB: workflow_dispatch su bench.yml — usa benchmark-extended.mjs
-    (20 categorie, seed canonico 1337, tutte le fix v5).
-    Risultati inviati via Telegram da ab-bench.mjs --notify al completamento.
+    Il workflow storico ``bench.yml`` e il relativo runner non esistono più su main;
+    usare il loro report come fallback produceva un falso "benchmark avviato". Il
+    backend espone invece ``/api/benchmark/run-self``: è autenticato, restituisce la
+    run corrente e non richiede CI o billing GitHub.
     """
-    gh_token = os.getenv("GITHUB_TOKEN", "").strip()
-
-    # ── Tenta fetch ultimo run completato da GitHub Actions artifact ─────────
-    last_report: dict | None = None
-    if gh_token:
-        try:
-            import httpx as _hx
-            async with _hx.AsyncClient(timeout=8.0) as _c:
-                _r = await _c.get(
-                    "https://api.github.com/repos/Baida98/AI/actions/workflows/bench.yml/runs"
-                    "?status=completed&per_page=1",
-                    headers={"Authorization": f"Bearer {gh_token}",
-                             "Accept": "application/vnd.github.v3+json",
-                             "User-Agent": "AgenteAI-Bot"},
-                )
-                if _r.status_code == 200:
-                    _runs = _r.json().get("workflow_runs", [])
-                    if _runs:
-                        last_report = {
-                            "run_id":    _runs[0]["id"],
-                            "run_url":   _runs[0]["html_url"],
-                            "conclusion":_runs[0].get("conclusion","?"),
-                            "updated":   _runs[0].get("updated_at",""),
-                        }
-        except Exception as _exc:
-            _logger.debug("bench fetch last run: %s", _exc)
-
-    # ── Trigger nuovo run via workflow_dispatch ───────────────────────────────
-    run_url = "https://github.com/Baida98/AI/actions/workflows/bench.yml"
-    if gh_token:
-        try:
-            import httpx as _hx
-            async with _hx.AsyncClient(timeout=10.0) as _c:
-                _r = await _c.post(
-                    "https://api.github.com/repos/Baida98/AI/actions/workflows/bench.yml/dispatches",
-                    json={"ref": "main", "inputs": {
-                        "mode": mode,
-                        "run_improve": "false",
-                        "force_update_baseline": "false",
-                    }},
-                    headers={"Authorization": f"Bearer {gh_token}",
-                             "Accept": "application/vnd.github.v3+json",
-                             "User-Agent": "AgenteAI-Bot"},
-                )
-                if _r.status_code == 204:
-                    _logger.info("[bench] workflow_dispatch OK (mode=%s)", mode)
-                    # Attendi 2s e leggi il run ID appena creato
-                    await asyncio.sleep(2.0)
-                    async with _hx.AsyncClient(timeout=8.0) as _c2:
-                        _r2 = await _c2.get(
-                            "https://api.github.com/repos/Baida98/AI/actions/workflows/"
-                            "bench.yml/runs?per_page=1",
-                            headers={"Authorization": f"Bearer {gh_token}",
-                                     "Accept": "application/vnd.github.v3+json",
-                                     "User-Agent": "AgenteAI-Bot"},
-                        )
-                        if _r2.status_code == 200:
-                            _rr = _r2.json().get("workflow_runs", [])
-                            if _rr:
-                                run_url = _rr[0]["html_url"]
-                else:
-                    _logger.warning("[bench] workflow_dispatch status=%d", _r.status_code)
-        except Exception as _exc:
-            _logger.warning("[bench] workflow_dispatch error: %s", _exc)
+    internal_token = os.getenv("INTERNAL_TOKEN", "").strip()
+    if not internal_token:
+        await _tg_reply(
+            chat_id,
+            "⚠️ <b>Benchmark live non configurato.</b>\n"
+            "Manca il token interno del backend: nessun report storico verrà mostrato.",
+            keyboard=_BACK_KB,
+        )
+        return
 
-    # ── Costruisci messaggio con quickchart dell'ultimo run (se disponibile) ──
-    _BENCH_CACHE[chat_id] = {"mode": mode, "run_url": run_url}
+    base_url = (
+        os.getenv("BENCHMARK_SELF_URL")
+        or os.getenv("BENCHMARK_BASE_URL")
+        or os.getenv("BACKEND_URL")
+        or "http://127.0.0.1:7860"
+    ).rstrip("/")
+    await _tg_reply(
+        chat_id,
+        "🚀 <b>Benchmark live Quality avviato</b>\n"
+        "<i>Misuro ora il backend corrente; attesa tipica 20–30 secondi.</i>",
+        keyboard=_BACK_KB,
+    )
 
-    # ── Fetch benchmark-report.json dal repo per quickchart reale ──────────────
-    bench_report: dict | None = None
-    if gh_token:
+    try:
+        timeout = httpx.Timeout(connect=5.0, read=90.0, write=15.0, pool=5.0)
+        async with httpx.AsyncClient(timeout=timeout, trust_env=False) as client:
+            response = await client.post(
+                f"{base_url}/api/benchmark/run-self",
+                headers={"X-Internal-Token": internal_token},
+                json={},
+            )
         try:
-            import httpx as _hx, base64 as _b64, json as _json
-            async with _hx.AsyncClient(timeout=8.0) as _c:
-                _br = await _c.get(
-                    "https://api.github.com/repos/Baida98/AI/contents/benchmark-report.json?ref=main",
-                    headers={"Authorization": f"Bearer {gh_token}",
-                             "Accept": "application/vnd.github.v3+json",
-                             "User-Agent": "AgenteAI-Bot"},
-                )
-                if _br.status_code == 200:
-                    _content = _b64.b64decode(_br.json()["content"]).decode()
-                    bench_report = _json.loads(_content)
-        except Exception as _exc:
-            _logger.debug("bench fetch benchmark-report.json: %s", _exc)
-
-    chart_url: str | None = None
-
-    def _build_quickchart(report: dict) -> str:
-        """Costruisce URL quickchart.io da benchmark-report.json."""
-        import json as _j, urllib.parse as _ul
-        tasks    = report.get("tasks", [])
-        summary  = report.get("summary", {})
-        avg_ai   = summary.get("avgScore", 0)
-        avg_rpl  = summary.get("avgReplit", 57.9)
-        avg_mns  = summary.get("avgManus",  71.2)
-        cat_map: dict[str, list[float]] = {}
-        for t in tasks:
-            cat = (t.get("cat") or "other").replace("_", " ")[:14]
-            cat_map.setdefault(cat, []).append(t.get("score", 0))
-        if not cat_map:
-            return ""
-        labels = list(cat_map.keys())
-        scores = [round(sum(v)/len(v)) for v in cat_map.values()]
-        colors = ["#4CAF50" if s >= avg_rpl else "#FF9800" if s >= 50 else "#F44336" for s in scores]
-        cfg = {
-            "type": "horizontalBar",
-            "data": {
-                "labels": labels,
-                "datasets": [
-                    {"label": "Agente AI", "data": scores,
-                     "backgroundColor": colors, "borderColor": colors, "borderWidth": 1},
-                    {"label": f"Replit {avg_rpl}",
-                     "data": [avg_rpl]*len(labels),
-                     "type": "line", "borderColor": "#2196F3", "borderDash": [5,3],
-                     "pointRadius": 0, "fill": False, "borderWidth": 2},
-                    {"label": f"Manus {avg_mns}",
-                     "data": [avg_mns]*len(labels),
-                     "type": "line", "borderColor": "#9C27B0", "borderDash": [5,3],
-                     "pointRadius": 0, "fill": False, "borderWidth": 2},
-                ],
-            },
-            "options": {
-                "title": {"display": True,
-                          "text": f"Agente AI {avg_ai}% | Replit {avg_rpl}% | Manus {avg_mns}%"},
-                "scales": {"xAxes": [{"ticks": {"min": 0, "max": 100, "stepSize": 20}}]},
-                "legend": {"display": True, "position": "bottom"},
-                "plugins": {"datalabels": {"display": False}},
-            },
-        }
-        return ("https://quickchart.io/chart?c=" +
-                _ul.quote(_j.dumps(cfg, separators=(",",":"))) +
-                "&width=720&height=420&backgroundColor=white")
-
-    if bench_report:
-        chart_url = _build_quickchart(bench_report)
-
-    summary    = (bench_report or {}).get("summary", {})
-    avg_ai     = summary.get("avgScore")
-    avg_rpl    = summary.get("avgReplit")
-    avg_mns    = summary.get("avgManus")
-    # ── Tabella ASCII con barre per caption Telegram ──────────────────────────
-    def _text_table_bench(report: dict, rpl: float) -> str:
-        tasks = report.get("tasks", [])
-        cat_map: dict[str, list[float]] = {}
-        for t in tasks:
-            cat = (t.get("cat") or "other").replace("_", " ")[:12]
-            cat_map.setdefault(cat, []).append(float(t.get("score", 0)))
-        if not cat_map:
-            return ""
-        rows = []
-        for cat, vals in sorted(cat_map.items(), key=lambda x: -sum(x[1]) / len(x[1])):
-            sc = round(sum(vals) / len(vals))
-            bar = "█" * round(sc / 10) + "░" * (10 - round(sc / 10))
-            delta_rpl = sc - rpl
-            vs = ("+" if delta_rpl >= 0 else "") + str(round(delta_rpl)) + "vsRpl"
-            rows.append(f"{cat:<12} {bar} {sc:>3}% {vs}")
-        return "\n".join(rows)
-
-    text_table = ""
-    if bench_report and avg_rpl is not None:
-        text_table = _text_table_bench(bench_report, float(avg_rpl))
-
-    score_line = ""
-    if avg_ai is not None:
-        score_line = (
-            f"\n📈 <b>Score:</b> AI <b>{avg_ai}%</b>"
-            + (f" | Replit {avg_rpl}%" if avg_rpl else "")
-            + (f" | Manus {avg_mns}%" if avg_mns else "")
-            + "\n"
+            report = response.json()
+        except ValueError:
+            report = {}
+        if response.status_code >= 400:
+            detail = str(report.get("detail") or report.get("error") or response.text[:180] or "errore non specificato")
+            await _tg_reply(
+                chat_id,
+                "❌ <b>Benchmark live non completato.</b>\n"
+                f"HTTP <code>{response.status_code}</code>: <code>{html.escape(detail[:220])}</code>\n"
+                "<i>Nessun report storico è stato usato come sostituto.</i>",
+                keyboard=_BACK_KB,
+            )
+            return
+        if not isinstance(report, dict):
+            raise ValueError("Risposta benchmark non valida")
+    except Exception as exc:
+        _logger.warning("[bench-live] request error: %s", exc)
+        await _tg_reply(
+            chat_id,
+            "❌ <b>Benchmark live non raggiungibile.</b>\n"
+            f"<code>{html.escape(str(exc)[:220])}</code>\n"
+            "<i>Nessun report storico è stato usato come sostituto.</i>",
+            keyboard=_BACK_KB,
         )
+        return
 
-    def _build_bench_caption(header: str) -> str:
-        tbl = ("\n<code>" + text_table + "</code>") if text_table else ""
-        link = f'\n🔗 <a href="{html.escape(run_url)}">GitHub Actions</a>'
-        full = header + score_line + tbl + link
-        if len(full) > 1020 and text_table:
-            avail = max(0, 1020 - len(header) - len(score_line) - len(link) - 14)
-            tbl = "\n<code>" + text_table[:avail] + "…</code>"
-            full = header + score_line + tbl + link
-        return full[:1024]
-
-    if last_report:
-        _conclusion = last_report.get("conclusion", "?")
-        _em = "✅" if _conclusion == "success" else ("❌" if _conclusion == "failure" else "⚠️")
-        _upd = last_report.get("updated", "")[:16].replace("T", " ")
-        header = f"📊 <b>Benchmark avviato</b> — {_em} {_conclusion}\n🕐 {_upd} UTC"
-    else:
-        header = "📊 <b>Benchmark avviato</b> (benchmark-extended.mjs)"
-
-    caption = _build_bench_caption(header)
-
-    if chart_url:
-        await _tg_photo(chat_id, chart_url, caption=caption, keyboard=_BENCH_ACTION_KB)
-    else:
-        await _tg_reply(chat_id, caption, keyboard=_BENCH_ACTION_KB)
+    _BENCH_CACHE[chat_id] = {
+        "mode": "quality-live",
+        "requested_mode": mode,
+        "run_url": "",
+        "timestamp": report.get("timestamp"),
+    }
+    await _tg_reply(chat_id, _format_live_quality_benchmark(report), keyboard=_BENCH_ACTION_KB)
 
 
 

tests/test_telegram_benchmark_live.py

@@ -0,0 +1,83 @@
+import os
+import unittest
+from unittest.mock import AsyncMock, patch
+
+from api.telegram_webhook import _cmd_bench
+
+
+class _Response:
+    def __init__(self, status_code=200, payload=None, text=""):
+        self.status_code = status_code
+        self._payload = payload if payload is not None else {}
+        self.text = text
+
+    def json(self):
+        return self._payload
+
+
+class _Client:
+    last_post = None
+    response = _Response()
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *_args):
+        return False
+
+    async def post(self, *args, **kwargs):
+        type(self).last_post = (args, kwargs)
+        return type(self).response
+
+
+class TelegramLiveBenchmarkTests(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        _Client.last_post = None
+
+    async def test_bench_uses_authenticated_self_benchmark_and_only_live_result(self):
+        _Client.response = _Response(payload={
+            "ok": True,
+            "total_score": 73,
+            "timestamp": "2026-08-15T12:00:00Z",
+            "results": [{"id": "DA", "label": "Data analysis", "score": 80}],
+            "errors": [],
+        })
+        replies = AsyncMock()
+        with patch.dict(
+            os.environ,
+            {"INTERNAL_TOKEN": "internal-test", "BENCHMARK_SELF_URL": "http://backend"},
+            clear=False,
+        ), patch("httpx.AsyncClient", _Client), patch("api.telegram_webhook._tg_reply", replies):
+            await _cmd_bench(123)
+
+        args, kwargs = _Client.last_post
+        self.assertEqual(args[0], "http://backend/api/benchmark/run-self")
+        self.assertEqual(kwargs["headers"], {"X-Internal-Token": "internal-test"})
+        self.assertEqual(kwargs["json"], {})
+        self.assertEqual(replies.await_count, 2)
+        final_text = replies.await_args_list[-1].args[1]
+        self.assertIn("Benchmark live Quality", final_text)
+        self.assertIn("73/100", final_text)
+        self.assertNotIn("GitHub Actions", final_text)
+
+    async def test_bench_does_not_substitute_historical_report_after_live_failure(self):
+        _Client.response = _Response(status_code=503, payload={"detail": "unavailable"})
+        replies = AsyncMock()
+        with patch.dict(
+            os.environ,
+            {"INTERNAL_TOKEN": "internal-test", "BENCHMARK_SELF_URL": "http://backend"},
+            clear=False,
+        ), patch("httpx.AsyncClient", _Client), patch("api.telegram_webhook._tg_reply", replies):
+            await _cmd_bench(123)
+
+        final_text = replies.await_args_list[-1].args[1]
+        self.assertIn("Benchmark live non completato", final_text)
+        self.assertIn("Nessun report storico", final_text)
+        self.assertNotIn("Score: AI", final_text)
+
+
+if __name__ == "__main__":
+    unittest.main()