sync: 157 file da Baida98/AI@f57660fe (2026-08-15 12:26 UTC) [deploy-all]

api/benchmark_handler.py

@@ -20,64 +20,60 @@ from typing import Any
 logger = logging.getLogger("agente_ai.benchmark_handler")
 
 # ── Percorsi server Railway ────────────────────────────────────────────────────
-_REPO_ROOT     = os.getenv("REPO_ROOT", "/home/ubuntu/Baida98_AI")
+# Lo Space HF esegue il backend in /app; Railway può impostare REPO_ROOT.
+_REPO_ROOT     = os.getenv("REPO_ROOT", "/app")
 
-# v7 (GAP-BENCH-2)
-_BENCH_SCRIPT  = os.path.join(_REPO_ROOT, "scripts", "benchmark-extended.mjs")
-_REPORT_V7     = "/tmp/agente-ai/benchmark-v7-latest.json"
-_BENCH_TIMEOUT = float(os.getenv("BENCH_TIMEOUT_SECS", "720"))   # 12 min (era 360s)
+# Extended v5: 20 categorie. Il percorso è alla radice della repository.
+_BENCH_SCRIPT  = os.path.join(_REPO_ROOT, "benchmark-extended.mjs")
+_REPORT_V7     = "/tmp/agente-ai/benchmark-v5-latest.json"
+# 20 task seriali possono richiedere più di 12 minuti con provider gratuiti.
+_BENCH_TIMEOUT = float(os.getenv("BENCH_TIMEOUT_SECS", "3600"))
 
 # v6.2 — usato come fallback in get_smart_summary per compatibilità
 _REPORT_V6     = os.path.join(_REPO_ROOT, "benchmark-stress-report.json")
 
 
-async def run_benchmark_task(chat_id: int, send_reply_fn) -> None:
-    """Esegue benchmark-extended.mjs v7 con --json e invia risultati via Telegram.
+async def run_benchmark_task(chat_id: int, send_reply_fn, mode: str = "full") -> None:
+    """Esegue il benchmark Extended v5 su tutte le 20 categorie via API task moderna."""
+    if not await asyncio.to_thread(os.path.isfile, _BENCH_SCRIPT):
+        await send_reply_fn(chat_id, "❌ <b>Runner benchmark esteso non disponibile.</b>\n"
+                            "Il deployment non ha incluso <code>benchmark-extended.mjs</code>.")
+        return
 
-    Flag --json → scrive /tmp/agente-ai/benchmark-v7-latest.json.
-    Variabili env richieste (Railway): GROQ_API_KEY, INTERNAL_TOKEN.
-    """
+    flags = ["--full", "--json", f"--output={_REPORT_V7}", "--gap-analysis"]
     await send_reply_fn(
         chat_id,
-        "🚀 <b>Avvio Benchmark Extended v7…</b>\n"
-        "<i>10+ categorie · HF datasets · ref vs Replit/Cursor/Devin/Manus · ~10-12 min.</i>",
+        "🚀 <b>Benchmark Extended v5 avviato</b>\n"
+        "<i>20/20 categorie · seed 1337 · task API moderna · durata variabile fino a ~60 min.</i>",
     )
     env = {
         **os.environ,
-        "GROQ_API_KEY":   os.getenv("GROQ_API_KEY", ""),
-        "NVIDIA_API_KEY": os.getenv("NVIDIA_API_KEY", ""),
         "INTERNAL_TOKEN": os.getenv("INTERNAL_TOKEN", ""),
+        "BENCHMARK_BASE_URL": os.getenv("BENCHMARK_BASE_URL", "http://127.0.0.1:7860"),
     }
     process: asyncio.subprocess.Process | None = None
     try:
         process = await asyncio.create_subprocess_exec(
-            "node", _BENCH_SCRIPT, "--json",
+            "node", _BENCH_SCRIPT, *flags,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
             env=env,
         )
-        stdout, stderr = await asyncio.wait_for(
-            process.communicate(), timeout=_BENCH_TIMEOUT
-        )
+        _stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=_BENCH_TIMEOUT)
         if process.returncode != 0:
             err = stderr.decode(errors="replace")[:400]
-            logger.error("Benchmark v7 failed rc=%d: %s", process.returncode, err)
-            await send_reply_fn(chat_id, f"❌ <b>Errore benchmark v7:</b>\n<code>{err}</code>")
+            logger.error("Extended benchmark failed rc=%d: %s", process.returncode, err)
+            await send_reply_fn(chat_id, f"❌ <b>Errore benchmark Extended:</b>\n<code>{err}</code>")
             return
     except asyncio.TimeoutError:
-        # FIX-1: kill del processo figlio prima di notificare
         if process is not None:
             try:
                 process.kill()
                 await process.wait()
             except Exception:
                 pass
-        logger.warning("Benchmark v7 timeout (>%.0fs) — process killed", _BENCH_TIMEOUT)
-        await send_reply_fn(
-            chat_id,
-            f"⏱ <b>Timeout benchmark v7</b> (>{int(_BENCH_TIMEOUT // 60)} min) — "
-            "processo terminato, controlla log Railway.",
-        )
+        logger.warning("Extended benchmark timeout (>%.0fs) — process killed", _BENCH_TIMEOUT)
+        await send_reply_fn(chat_id, f"⏱ <b>Timeout benchmark Extended</b> (>{int(_BENCH_TIMEOUT // 60)} min) — processo terminato.")
         return
     except Exception as exc:
         if process is not None:
@@ -86,22 +82,25 @@ async def run_benchmark_task(chat_id: int, send_reply_fn) -> None:
                 await process.wait()
             except Exception:
                 pass
-        logger.error("run_benchmark_task v7 error: %s", exc, exc_info=True)
-        await send_reply_fn(chat_id, f"💥 <b>Errore critico:</b> <code>{exc}</code>")
+        logger.exception("run_benchmark_task extended error")
+        await send_reply_fn(chat_id, f"💥 <b>Errore critico benchmark:</b> <code>{exc}</code>")
         return
 
     report_exists = await asyncio.to_thread(os.path.exists, _REPORT_V7)
     if not report_exists:
-        await send_reply_fn(chat_id, "⚠️ <b>Benchmark terminato ma report v7 non trovato.</b>")
+        await send_reply_fn(chat_id, "⚠️ <b>Benchmark Extended terminato ma report non trovato.</b>")
         return
-
     try:
-        # FIX-3: lettura file in thread — non blocca l'event loop
         report: dict[str, Any] = await asyncio.to_thread(_read_json, _REPORT_V7)
     except Exception as exc:
-        await send_reply_fn(chat_id, f"⚠️ <b>Report v7 non leggibile:</b> <code>{exc}</code>")
+        await send_reply_fn(chat_id, f"⚠️ <b>Report Extended non leggibile:</b> <code>{exc}</code>")
         return
 
+    categories = {str(task.get("cat", "")) for task in report.get("tasks", []) if task.get("cat")}
+    if len(categories) != 20:
+        await send_reply_fn(chat_id, f"⚠️ <b>Run incompleta:</b> <code>{len(categories)}/20</code> categorie nel report."
+                            " Nessun risultato incompleto viene presentato come benchmark completo.")
+        return
     await send_reply_fn(chat_id, _format_v7_report(report))
 
 
@@ -146,6 +145,8 @@ def _format_v7_report(report: dict[str, Any]) -> str:
             if isinstance(sc, (int, float)):
                 by_cat.setdefault(cat, []).append(float(sc))
         if by_cat:
+            coverage = len(by_cat)
+            lines.append(f"🧪 <b>Copertura:</b> <code>{coverage}/20 categorie · {len(tasks)} task</code>\n")
             lines.append("\n📂 <b>Per categoria:</b>\n")
             for cat, scores in sorted(by_cat.items()):
                 avg_cat = sum(scores) / len(scores)

api/telegram_webhook.py

@@ -1620,78 +1620,14 @@ def _format_live_quality_benchmark(report: dict) -> str:
 
 
 async def _cmd_bench(chat_id: int, mode: str = "default") -> None:
-    """Esegue il benchmark quality live del backend senza dipendere da GitHub Actions.
-
-    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.
-    """
-    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
-
-    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,
-    )
-
-    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:
-            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
-
-    _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)
+    """Avvia il benchmark Extended su tutte le 20 categorie in background."""
+    from .benchmark_handler import run_benchmark_task
+
+    _BENCH_CACHE[chat_id] = {"mode": "extended-20", "run_url": "", "started_at": time.time()}
+    task = asyncio.create_task(run_benchmark_task(chat_id, _tg_reply, mode="full"))
+    task.add_done_callback(lambda completed: _logger.error(
+        "[bench-extended] background task failed: %s", completed.exception()
+    ) if not completed.cancelled() and completed.exception() else None)
 
 
 

tests/test_telegram_benchmark_live.py

@@ -1,82 +1,20 @@
-import os
+import asyncio
 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):
+class TelegramExtendedBenchmarkTests(unittest.IsolatedAsyncioTestCase):
+    async def test_bench_starts_background_extended_run(self):
+        runner = AsyncMock()
+        with patch("api.benchmark_handler.run_benchmark_task", runner):
             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)
+            await asyncio.sleep(0)
+        runner.assert_awaited_once()
+        args, kwargs = runner.await_args
+        self.assertEqual(args[0], 123)
+        self.assertEqual(kwargs["mode"], "full")
 
 
 if __name__ == "__main__":

tests/test_telegram_extended_benchmark.py

@@ -0,0 +1,54 @@
+import asyncio
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import AsyncMock, patch
+
+from api import benchmark_handler as handler
+
+
+class _Process:
+    returncode = 0
+
+    async def communicate(self):
+        return b"", b""
+
+
+class ExtendedBenchmarkHandlerTests(unittest.IsolatedAsyncioTestCase):
+    async def test_extended_runner_uses_full_mode_and_reports_20_categories(self):
+        categories = [
+            "bug_fix", "refactor", "feature", "devops", "security", "performance",
+            "autonomy", "code_correct", "sql", "context_window", "adversarial", "mmlu",
+            "reasoning", "data_analysis", "technical_writing", "research_synthesis",
+            "orchestration", "memory_context", "recovery", "robustness",
+        ]
+        report = {
+            "timestamp": "2026-08-15T12:00:00Z",
+            "version": "extended-v5",
+            "summary": {"avgScore": 70, "avgReplit": 60, "avgCursor": 65, "avgDevin": 70, "avgManus": 75, "gapCount": 0, "verdict": "PARI_REPLIT"},
+            "tasks": [{"cat": category, "score": 70} for category in categories],
+            "gapCards": [],
+        }
+        replies = AsyncMock()
+        with tempfile.TemporaryDirectory() as directory:
+            script = Path(directory) / "benchmark-extended.mjs"
+            output = Path(directory) / "benchmark-v5-latest.json"
+            script.write_text("// runner")
+            output.write_text(json.dumps(report))
+            with patch.object(handler, "_BENCH_SCRIPT", str(script)), \
+                 patch.object(handler, "_REPORT_V7", str(output)), \
+                 patch("asyncio.create_subprocess_exec", AsyncMock(return_value=_Process())) as create_process:
+                await handler.run_benchmark_task(123, replies)
+
+        command = create_process.await_args.args
+        self.assertEqual(command[:2], ("node", str(script)))
+        self.assertIn("--full", command)
+        self.assertIn("--json", command)
+        self.assertIn("--gap-analysis", command)
+        final_text = replies.await_args_list[-1].args[1]
+        self.assertIn("20/20 categorie", final_text)
+
+
+if __name__ == "__main__":
+    unittest.main()