sync: 154 file da Baida98/AI@a284c7fa (2026-08-15 11:54 UTC) [deploy-all]

api/telegram_webhook.py

@@ -44,70 +44,89 @@ def _get_bot_token() -> str:
     return os.getenv("TELEGRAM_BOT_TOKEN", "").strip()
 
 
-async def _tg_reply(chat_id: str | int, text: str, token: str | None = None,
-                    keyboard: dict | None = None) -> None:
-    """Invia risposta al chat_id con HTML + opzionale inline keyboard."""
+def _get_reply_gateway() -> tuple[str, str]:
+    """Restituisce il gateway Pages autenticato, se configurato."""
+    return (
+        os.getenv("TELEGRAM_REPLY_PROXY_URL", "").strip(),
+        os.getenv("TELEGRAM_REPLY_PROXY_SECRET", "").strip(),
+    )
+
+
+async def _tg_api_call(
+    method: str,
+    payload: dict,
+    token: str | None = None,
+    *,
+    timeout: httpx.Timeout | float | None = None,
+) -> dict:
+    """Invia un metodo Bot API tramite il gateway Pages quando disponibile.
+
+    Hugging Face può bloccare l'egress TCP verso Telegram. Il gateway mantiene il
+    token del bot fuori dal runtime e inoltra solo metodi strettamente consentiti.
+    """
     bot_token = token or _get_bot_token()
     if not bot_token:
-        return
-    payload: dict = {
-        "chat_id": chat_id,
-        "text": text,
-        "parse_mode": "HTML",
-        "link_preview_options": {"is_disabled": True},
-    }
-    if keyboard:
-        payload["reply_markup"] = keyboard
+        _logger.warning("tg_api %s skipped: TELEGRAM_BOT_TOKEN missing", method)
+        return {}
+
+    gateway_url, gateway_secret = _get_reply_gateway()
+    if gateway_url and gateway_secret:
+        request_url = gateway_url
+        request_headers = {"Authorization": f"Bearer {gateway_secret}"}
+        request_payload = {"method": method, **payload}
+    else:
+        request_url = f"https://api.telegram.org/bot{bot_token}/{method}"
+        request_headers = {}
+        request_payload = payload
+
     try:
-        import httpx
-        timeout = httpx.Timeout(connect=5.0, read=15.0, write=10.0, pool=5.0)
-        gateway_url = os.getenv("TELEGRAM_REPLY_PROXY_URL", "").strip()
-        gateway_secret = os.getenv("TELEGRAM_REPLY_PROXY_SECRET", "").strip()
-        if gateway_url and gateway_secret:
-            request_url = gateway_url
-            request_headers = {"Authorization": f"Bearer {gateway_secret}"}
-        else:
-            # Compatibilità per ambienti che non hanno ancora il gateway Pages.
-            request_url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
-            request_headers = {}
-        # Il gateway isola l'egress Telegram dal runtime HF, dove la connessione
-        # diretta può scadere. trust_env evita proxy ambiente non necessari.
-        async with httpx.AsyncClient(timeout=timeout, trust_env=False) as c:
-            response = await c.post(request_url, headers=request_headers, json=payload)
+        client_timeout = timeout or httpx.Timeout(connect=5.0, read=15.0, write=10.0, pool=5.0)
+        async with httpx.AsyncClient(timeout=client_timeout, trust_env=False) as client:
+            response = await client.post(request_url, headers=request_headers, json=request_payload)
         try:
             data = response.json()
         except ValueError:
             data = {}
         if response.status_code >= 400 or not data.get("ok", False):
             detail = str(data.get("description") or data.get("error") or response.text[:160] or "unknown")
-            _logger.warning("tg_reply rejected: status=%s detail=%s", response.status_code, detail)
+            _logger.warning("tg_api rejected: method=%s status=%s detail=%s", method, response.status_code, detail)
+            return {}
+        return data
     except Exception as exc:
         detail = str(exc) or repr(exc)
-        _logger.warning("tg_reply error: %s: %s", type(exc).__name__, detail)
+        _logger.warning("tg_api error: method=%s %s: %s", method, type(exc).__name__, detail)
+        return {}
+
+
+async def _tg_reply(chat_id: str | int, text: str, token: str | None = None,
+                    keyboard: dict | None = None) -> None:
+    """Invia una risposta con HTML e opzionale inline keyboard."""
+    payload: dict = {
+        "chat_id": chat_id,
+        "text": text,
+        "parse_mode": "HTML",
+        "link_preview_options": {"is_disabled": True},
+    }
+    if keyboard:
+        payload["reply_markup"] = keyboard
+    await _tg_api_call("sendMessage", payload, token)
 
 
 async def _tg_answer_callback(callback_query_id: str, text: str = "", token: str | None = None) -> None:
-    """Risponde a un callback_query (obbligatorio per chiudere il loading sui buttons)."""
-    bot_token = token or _get_bot_token()
-    if not bot_token:
+    """Chiude il caricamento dei pulsanti inline tramite il gateway."""
+    if not callback_query_id:
         return
-    try:
-        import httpx
-        async with httpx.AsyncClient(timeout=5.0) as c:
-            await c.post(
-                f"https://api.telegram.org/bot{bot_token}/answerCallbackQuery",
-                json={"callback_query_id": callback_query_id, "text": text, "show_alert": False},
-            )
-    except Exception as exc:
-        _logger.debug("answer_callback error: %s", exc)
+    await _tg_api_call(
+        "answerCallbackQuery",
+        {"callback_query_id": callback_query_id, "text": text, "show_alert": False},
+        token,
+        timeout=5.0,
+    )
 
 
 async def _tg_send(chat_id: str | int, text: str, token: str | None = None,
                    keyboard: dict | None = None) -> str | None:
-    """Invia messaggio e ritorna il message_id (per editMessageText streaming)."""
-    bot_token = token or _get_bot_token()
-    if not bot_token:
-        return None
+    """Invia un messaggio e restituisce l'identificativo per gli edit streaming."""
     payload: dict = {
         "chat_id": chat_id,
         "text": text,
@@ -116,26 +135,15 @@ async def _tg_send(chat_id: str | int, text: str, token: str | None = None,
     }
     if keyboard:
         payload["reply_markup"] = keyboard
-    try:
-        import httpx
-        async with httpx.AsyncClient(timeout=8.0) as c:
-            r = await c.post(
-                f"https://api.telegram.org/bot{bot_token}/sendMessage",
-                json=payload,
-            )
-            j = r.json()
-            return str(j.get("result", {}).get("message_id", "")) if j.get("ok") else None
-    except Exception as exc:
-        _logger.warning("tg_send error: %s", exc)
-        return None
+    data = await _tg_api_call("sendMessage", payload, token, timeout=8.0)
+    message_id = (data.get("result") or {}).get("message_id")
+    return str(message_id) if message_id is not None else None
 
 
 async def _tg_edit(chat_id: str | int, message_id: str, text: str,
                    token: str | None = None, keyboard: dict | None = None) -> bool:
-    """Aggiorna messaggio esistente — streaming live via editMessageText.
-    Ritorna True se successo. Rate-limit: max 20 edit/min per chat Telegram."""
-    bot_token = token or _get_bot_token()
-    if not bot_token or not message_id:
+    """Aggiorna un messaggio streaming attraverso il gateway."""
+    if not message_id:
         return False
     payload: dict = {
         "chat_id": chat_id,
@@ -146,17 +154,7 @@ async def _tg_edit(chat_id: str | int, message_id: str, text: str,
     }
     if keyboard:
         payload["reply_markup"] = keyboard
-    try:
-        import httpx
-        async with httpx.AsyncClient(timeout=8.0) as c:
-            r = await c.post(
-                f"https://api.telegram.org/bot{bot_token}/editMessageText",
-                json=payload,
-            )
-            return r.json().get("ok", False)
-    except Exception as exc:
-        _logger.debug("tg_edit error: %s", exc)
-        return False
+    return bool(await _tg_api_call("editMessageText", payload, token, timeout=8.0))
 
 
 async def _tg_photo(
@@ -166,78 +164,66 @@ async def _tg_photo(
     token: str | None = None,
     keyboard: dict | None = None,
 ) -> None:
-    """Invia foto/chart via sendPhoto Telegram.
-
-    Strategia anti URL-lungo:
-    1. POST a quickchart.io → scarica PNG bytes → multipart sendPhoto (no limite URL).
-    2. Fallback: invia URL direttamente (funziona se URL < ~2000 chars).
-    """
+    """Invia grafici tramite gateway; conserva il fallback multipart per ambienti legacy."""
     bot_token = token or _get_bot_token()
     if not bot_token:
         return
     caption_safe = (caption or "")[:1024]
+    gateway_url, gateway_secret = _get_reply_gateway()
+    if gateway_url and gateway_secret:
+        payload: dict = {"chat_id": chat_id, "photo": photo_url, "parse_mode": "HTML"}
+        if caption_safe:
+            payload["caption"] = caption_safe
+        if keyboard:
+            payload["reply_markup"] = keyboard
+        await _tg_api_call("sendPhoto", payload, bot_token, timeout=20.0)
+        return
 
     import httpx as _hx_p, json as _j_p, urllib.parse as _ul_p, re as _re_p
-
     png_bytes: bytes | None = None
     if "quickchart.io/chart" in photo_url:
         try:
-            m = _re_p.search(r"[?&]c=([^&]+)", photo_url)
-            if m:
-                cfg_dict = _j_p.loads(_ul_p.unquote(m.group(1)))
-                async with _hx_p.AsyncClient(timeout=20.0) as c:
-                    qr = await c.post(
+            match = _re_p.search(r"[?&]c=([^&]+)", photo_url)
+            if match:
+                cfg_dict = _j_p.loads(_ul_p.unquote(match.group(1)))
+                async with _hx_p.AsyncClient(timeout=20.0, trust_env=False) as client:
+                    response = await client.post(
                         "https://quickchart.io/chart",
                         json={"chart": cfg_dict, "width": 720, "height": 420,
                               "backgroundColor": "white", "format": "png"},
                     )
-                    if qr.status_code == 200 and qr.headers.get("content-type", "").startswith("image/"):
-                        png_bytes = qr.content
-                        _logger.debug("tg_photo: quickchart POST ok, %d bytes", len(png_bytes))
+                if response.status_code == 200 and response.headers.get("content-type", "").startswith("image/"):
+                    png_bytes = response.content
         except Exception as exc:
-            _logger.debug("tg_photo: quickchart POST fallback: %s", exc)
+            _logger.debug("tg_photo quickchart fallback: %s", exc)
 
     try:
-        import httpx as _hx_s
-        async with _hx_s.AsyncClient(timeout=15.0) as c:
+        async with httpx.AsyncClient(timeout=15.0, trust_env=False) as client:
             if png_bytes:
-                import json as _j_s
+                import json as _json
                 data: dict = {"chat_id": str(chat_id), "parse_mode": "HTML"}
                 if caption_safe:
                     data["caption"] = caption_safe
                 if keyboard:
-                    data["reply_markup"] = _j_s.dumps(keyboard)
-                files = {"photo": ("chart.png", png_bytes, "image/png")}
-                await c.post(f"https://api.telegram.org/bot{bot_token}/sendPhoto",
-                             data=data, files=files)
+                    data["reply_markup"] = _json.dumps(keyboard)
+                await client.post(
+                    f"https://api.telegram.org/bot{bot_token}/sendPhoto",
+                    data=data,
+                    files={"photo": ("chart.png", png_bytes, "image/png")},
+                )
             else:
-                payload: dict = {"chat_id": chat_id, "photo": photo_url, "parse_mode": "HTML"}
+                payload = {"chat_id": chat_id, "photo": photo_url, "parse_mode": "HTML"}
                 if caption_safe:
                     payload["caption"] = caption_safe
                 if keyboard:
                     payload["reply_markup"] = keyboard
-                await c.post(f"https://api.telegram.org/bot{bot_token}/sendPhoto", json=payload)
+                await client.post(f"https://api.telegram.org/bot{bot_token}/sendPhoto", json=payload)
     except Exception as exc:
         _logger.warning("tg_photo error: %s", exc)
 
 
 async def _tg_typing(chat_id: str | int, action: str = "typing", token: str | None = None) -> None:
-    """Invia sendChatAction — mostra '⌨️ digitando…' prima di operazioni pesanti.
-
-    Dura 5 secondi o fino al prossimo messaggio del bot.
-    Azioni: typing, upload_photo, upload_document, find_location, record_video_note.
-    """
-    bot_token = token or _get_bot_token()
-    if not bot_token:
-        return
-    try:
-        async with httpx.AsyncClient(timeout=3.0) as c:
-            await c.post(
-                f"https://api.telegram.org/bot{bot_token}/sendChatAction",
-                json={"chat_id": chat_id, "action": action},
-            )
-    except Exception:
-        pass
+    await _tg_api_call("sendChatAction", {"chat_id": chat_id, "action": action}, token, timeout=5.0)
 
 
 async def _tg_react(
@@ -246,26 +232,19 @@ async def _tg_react(
     emoji: str = "👍",
     token: str | None = None,
 ) -> None:
-    """Aggiunge reazione emoji a un messaggio (Bot API 7.1+, Feb 2024).
-
-    Emoji supportate: 👍 👎 ❤ 🔥 🥰 👏 😁 🤔 🤯 😱 🎉 🤩 🏆 ✅ 💯 ⚡ 🚀 🎯
-    """
-    bot_token = token or _get_bot_token()
-    if not bot_token or not message_id:
+    if not message_id:
         return
-    try:
-        async with httpx.AsyncClient(timeout=3.0) as c:
-            await c.post(
-                f"https://api.telegram.org/bot{bot_token}/setMessageReaction",
-                json={
-                    "chat_id": chat_id,
-                    "message_id": int(message_id),
-                    "reaction": [{"type": "emoji", "emoji": emoji}],
-                    "is_big": False,
-                },
-            )
-    except Exception:
-        pass
+    await _tg_api_call(
+        "setMessageReaction",
+        {
+            "chat_id": chat_id,
+            "message_id": int(message_id),
+            "reaction": [{"type": "emoji", "emoji": emoji}],
+            "is_big": False,
+        },
+        token,
+        timeout=5.0,
+    )
 
 
 def _fmt_elapsed(created_at_ms: int) -> str:
@@ -1411,8 +1390,9 @@ async def _cmd_score(chat_id: int) -> None:
     """🏆 Score card dettagliata — chart + ranking 4 competitor + nodes + gaps + runtime telemetry."""
     import httpx as _hx_sc, base64 as _b64_sc, json as _j_sc, urllib.parse as _ul_sc
     gh_token = os.getenv("GITHUB_TOKEN", "").strip()
-    rw_url   = os.getenv("RAILWAY_URL", "https://baida-a-terminal.hf.space").rstrip("/")
-    await _tg_reply(chat_id, "⏳ <b>Score</b> — carico report + metriche runtime…")
+    runtime_url = (os.getenv("TELEMETRY_URL") or os.getenv("BACKEND_URL") or os.getenv("RAILWAY_URL") or "https://baida07-terminal.hf.space").rstrip("/")
+    machine_token = os.getenv("INTERNAL_TOKEN", "").strip()
+    await _tg_reply(chat_id, "⏳ <b>Score</b> — carico benchmark archiviato + telemetria runtime…")
 
     report: dict | None = None
     if gh_token:
@@ -1460,7 +1440,8 @@ async def _cmd_score(chat_id: int) -> None:
     rt_repair: dict = {}
     try:
         async with _hx_sc.AsyncClient(timeout=5.0) as _c:
-            _tr = await _c.get(f"{rw_url}/api/telemetry")
+            _headers = {"X-Machine-Token": machine_token} if machine_token else {}
+            _tr = await _c.get(f"{runtime_url}/api/telemetry", headers=_headers)
             if _tr.status_code == 200:
                 _td = _tr.json()
                 rt_timing = _td.get("timing", {})
@@ -1507,7 +1488,8 @@ async def _cmd_score(chat_id: int) -> None:
     d_dev   = round(avg_ai - avg_dev);  s_dev = ("+" if d_dev >= 0 else "") + str(d_dev)
     d_mns   = round(avg_ai - avg_mns);  s_mns = ("+" if d_mns >= 0 else "") + str(d_mns)
     d_cur   = round(avg_ai - avg_cur);  s_cur = ("+" if d_cur >= 0 else "") + str(d_cur)
-    caption  = f"🏆 <b>Score</b> — {ts} UTC  <code>v{ver}</code>\n"
+    caption  = f"🏆 <b>Score snapshot</b> — {ts} UTC  <code>v{ver}</code>\n"
+    caption += "<i>Report archiviato: non è una valutazione live del runtime.</i>\n"
     caption += f"<code>{bar_g}</code> <b>{avg_ai}%</b>  {verdict}\n\n"
     caption += f"<code>{'Modello':<10} {'Score':>5}  {'Δ':>4}  Wins</code>\n"
     caption += f"<code>{'Agente AI':<10} {str(avg_ai)+'%':>5}  {'─':>4}    ─</code>\n"
@@ -1528,13 +1510,13 @@ async def _cmd_score(chat_id: int) -> None:
     await _tg_photo(chat_id, chart_url, caption=caption[:1024], keyboard=_BENCH_ACTION_KB)
 
     # ── Messaggio 2 — dettaglio completo ─────────────────────────
-    det = "📊 <b>Score — Dettaglio</b>\n\n"
+    det = "📊 <b>Score — Dettaglio</b>\n<i>Benchmark archiviato del " + (ts or "timestamp non disponibile") + " UTC; non rappresenta una misura live.</i>\n\n"
 
     # Orchestration nodes
     NODE_ICONS = {"planner":"🧠","executor":"⚙️","reasoner":"🔬",
                   "recovery_manager":"🛡","robustness_layer":"🔒","memory_module":"💾"}
     if nodes:
-        det += "<b>⚡ Orchestration Nodes:</b>\n<code>"
+        det += "<b>⚡ Proxy benchmark per nodo (non telemetria live):</b>\n<code>"
         for nk, nv in nodes.items():
             sr  = str(nv.get("success_rate", "?"))
             lat = nv.get("avg_latency_s")
@@ -1562,7 +1544,7 @@ async def _cmd_score(chat_id: int) -> None:
                 det += f"  {k[:20]:<20} {v}\n"
             det += "</code>\n"
     else:
-        det += "<i>ℹ️ Telemetria runtime non disponibile (Railway idle)</i>\n"
+        det += "<i>ℹ️ Telemetria runtime non disponibile o non autorizzata.</i>\n"
 
     # Top 3 best + Top 3 worst
     sorted_tasks = sorted([t for t in tasks if t.get("score") is not None], key=lambda t: -t["score"])
@@ -1918,13 +1900,12 @@ async def _handle_inline(iq: dict, token: str) -> None:
              "description":f"/autofix {q60}",
              "input_message_content":{"message_text":f"/autofix {query}"}},
         ]
-    try:
-        import httpx as _hx
-        async with _hx.AsyncClient(timeout=5.0) as c:
-            await c.post(f"https://api.telegram.org/bot{bot_token}/answerInlineQuery",
-                         json={"inline_query_id":iq_id,"results":results,"cache_time":30,"is_personal":True})
-    except Exception as exc:
-        _logger.debug("inline answer error: %s", exc)
+    await _tg_api_call(
+        "answerInlineQuery",
+        {"inline_query_id": iq_id, "results": results, "cache_time": 30, "is_personal": True},
+        bot_token,
+        timeout=5.0,
+    )
 
 
 async def _handle_callback(callback_query: dict, token: str) -> None:

tests/test_telegram_reply_transport.py

@@ -4,7 +4,7 @@ from unittest.mock import patch
 
 import httpx
 
-from api.telegram_webhook import _tg_reply
+from api.telegram_webhook import _handle_inline, _tg_answer_callback, _tg_reply, _tg_send
 
 
 class _Response:
@@ -70,6 +70,42 @@ class TelegramReplyTransportTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(args[0], "https://tma-agente.pages.dev/api/telegram/send")
         self.assertEqual(kwargs["headers"], {"Authorization": "Bearer gateway-secret"})
 
+    async def test_stream_message_uses_gateway_and_returns_message_id(self):
+        _Client.response = _Response(payload={"ok": True, "result": {"message_id": 77}})
+        with patch.dict(
+            os.environ,
+            {
+                "TELEGRAM_REPLY_PROXY_URL": "https://tma-agente.pages.dev/api/telegram/send",
+                "TELEGRAM_REPLY_PROXY_SECRET": "gateway-secret",
+            },
+            clear=False,
+        ), patch("httpx.AsyncClient", _Client):
+            message_id = await _tg_send(123, "stream", token="test-token")
+
+        args, kwargs = _Client.last_post
+        self.assertEqual(message_id, "77")
+        self.assertEqual(args[0], "https://tma-agente.pages.dev/api/telegram/send")
+        self.assertEqual(kwargs["json"]["method"], "sendMessage")
+
+    async def test_callback_and_inline_answer_use_gateway(self):
+        with patch.dict(
+            os.environ,
+            {
+                "TELEGRAM_REPLY_PROXY_URL": "https://tma-agente.pages.dev/api/telegram/send",
+                "TELEGRAM_REPLY_PROXY_SECRET": "gateway-secret",
+            },
+            clear=False,
+        ), patch("httpx.AsyncClient", _Client):
+            await _tg_answer_callback("callback-id", token="test-token")
+            args, kwargs = _Client.last_post
+            self.assertEqual(args[0], "https://tma-agente.pages.dev/api/telegram/send")
+            self.assertEqual(kwargs["json"]["method"], "answerCallbackQuery")
+
+            await _handle_inline({"id": "inline-id", "query": "ciao"}, "test-token")
+
+        _args, kwargs = _Client.last_post
+        self.assertEqual(kwargs["json"]["method"], "answerInlineQuery")
+
     async def test_reply_logs_rejected_telegram_response(self):
         _Client.response = _Response(
             status_code=429,