@danhachuel/pandanews 0.4.4 → 0.4.5

package/CHANGELOG.md

@@ -14,6 +14,14 @@ Todas as versões publicadas são registradas aqui antes do publish (regra em AG
 - **Guard verificado por mutação**: com a flag removida do `pip`, com um `subprocess.run` direto no backend e com `--reload` no uvicorn, o teste falha em todos os casos (exit 1) — não é carimbo de borracha
 - Nota de transparência: a colisão de versão com o 0.4.03 já publicado no registry foi resolvida por renumeração, conforme a regra de sessões simultâneas do AGENTS.md
 
+## 0.4.05 (2026-11-08)
+
+- **HOTFIX — fallback à prova de falhas no LLM Router** (crítico): roteamento reescrito em `backend/core/llm_router.py`, agora explícito provedor por provedor na ordem configurada. Qualquer erro HTTP (4xx/5xx, incluindo **404/410** da NVIDIA) é interceptado, registrado (`Modelo nvidia indisponível (Status {status}). Acionando fallback para {próximo}.`) e o próximo provedor é acionado imediatamente — a geração não trava mais. A função devolve qual provedor respondeu (`noticias.llm_provider`) e o incidente fica em `backend.log`
+- **HOTFIX — janelas de CMD na instalação**: os spawns de `tar` (extração do Python portátil), `python -m venv` e `pip install` em `scripts/install.js` nasciam sem `windowsHide` no Windows — origem das múltiplas janelas de terminal. Todos agora usam `SILENT_WINDOWS` (CREATE_NO_WINDOW), com `stdio: 'inherit'` (progresso continua visível no console que o usuário já abriu, sem janela extra). `scripts/build.js` (npm) e o helper `backend/core/proc.py` (subprocessos Python) seguem a mesma regra
+- **Teste de conexão real**: `/api/v1/llm/test` dispara POST `/chat/completions` de verdade; 404/410 devolvem estado **`degraded`** com a mensagem "Sua chave da NVIDIA retornou erro 404. O sistema usará o Gemini (fallback) para gerar as notícias."
+- Frontend: badge âmbar `degraded` no resultado do teste + tag vermelha **[Indisponível]** ao lado do select de modelos — destacada mas mantida selecionável
+- Validado em E2E com mock servers: NVIDIA → 404 → Gemini → 200 → notícia gerada com `llm_provider='google'` e logs do incidente em `backend.log`
+
 ## 0.4.03 (2026-11-08)
 
 - **Regra permanente no AGENTS.md**: é PROIBIDO criar/publicar versões que abram janelas de terminal (CMD/PowerShell/console Python) no computador do usuário — todo processo filho deve nascer com `windowsHide: true` + grupo isolado, rodar em background com saída apenas em log e ser encerrado por código; versão que exiba janela de console é inválida (hotfix + CHANGELOG)

package/backend/app/main.py

@@ -31,7 +31,7 @@ async def lifespan(_: FastAPI):
     scheduler.parar()
 
 
-app = FastAPI(title="PandaNews API", version="0.4.4", lifespan=lifespan)
+app = FastAPI(title="PandaNews API", version="0.4.5", lifespan=lifespan)
 
 app.add_middleware(
     CORSMiddleware,

package/backend/core/llm_router.py

@@ -1,20 +1,27 @@
-"""Router de LLM do PandaNews: fallback ordenado NVIDIA NIM -> Google Gemini.
+"""Router de LLM do PandaNews: fallback ordenado e à prova de falhas.
 
-Roteamento por prioridade com llmswitch-client (circuit breaker embutido).
-O provedor que responde é devolvido junto com o texto para registrar em
-noticias.llm_provider. Teste por provedor via httpx direto no endpoint
-chat/completions (compatível com OpenAI) dos dois provedores.
+Roteamento explícito, provedor por provedor, na ordem configurada
+(padrão: NVIDIA NIM → Google Gemini). Qualquer erro HTTP do provedor atual
+(4xx/5xx — incluindo 404/410 de modelos descontinuados) é registrado e o
+próximo provedor é acionado imediatamente. A função devolve (texto, provedor)
+para registrar em noticias.llm_provider.
 """
 from __future__ import annotations
 
+import logging
 import time
 
 import httpx
+from openai import APIStatusError, OpenAI
 
 from backend.core.config import DEFAULT_LLM_BASE_URLS, DEFAULT_LLM_MODELS
 
 PROVEDORES = ("nvidia", "google")
 
+# Logger filho do uvicorn.error: mensagens vão para o backend.log (e stderr),
+# com a disciplina de logs do servidor.
+logger = logging.getLogger("uvicorn.error.pandanews")
+
 
 def get_config(db, chave: str, padrao: str = "") -> str:
     from backend.core.database import Configuracao
@@ -31,8 +38,64 @@ def provider_config(db, provider: str) -> dict:
     }
 
 
+def _chamar_provedor(db, provider: str, prompt: str, max_tokens: int) -> tuple[str, str]:
+    """Uma chamada de chat completion no provedor. Levanta em caso de erro."""
+    cfg = provider_config(db, provider)
+    client = OpenAI(api_key=cfg["api_key"], base_url=cfg["base_url"], timeout=60.0)
+    resposta = client.chat.completions.create(
+        model=cfg["model"],
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=max_tokens,
+    )
+    texto = resposta.choices[0].message.content or ""
+    modelo = str(getattr(resposta, "model", "") or cfg["model"])
+    return texto, modelo
+
+
+def gerar_texto(db, prompt: str, max_tokens: int = 1024) -> tuple[str, str]:
+    """Gera texto com fallback ordenado. Retorna (texto, provedor_que_respondeu).
+
+    Se um provedor falhar por qualquer erro HTTP, registra o incidente e
+    aciona o próximo da lista. Só levanta erro quando TODOS falham.
+    """
+    ordem = [p.strip() for p in get_config(db, "llm_fallback_ordem", "nvidia,google").split(",") if p.strip()]
+    disponiveis = [p for p in ordem if p in PROVEDORES and provider_config(db, p)["api_key"]]
+    if not disponiveis:
+        raise RuntimeError("Nenhum provedor de LLM configurado. Adicione uma API key em Configurações.")
+
+    ultimo_erro: Exception | None = None
+    for indice, provider in enumerate(disponiveis):
+        proximo = disponiveis[indice + 1] if indice + 1 < len(disponiveis) else None
+        try:
+            texto, modelo = _chamar_provedor(db, provider, prompt, max_tokens)
+            logger.info("LLM: %s respondeu (modelo %s)", provider, modelo)
+            return texto, provider
+        except APIStatusError as exc:
+            status = exc.status_code
+            ultimo_erro = exc
+            logger.warning("LLM: %s falhou com HTTP %s (%s)", provider, status, str(exc)[:300])
+            if status in (404, 410):
+                destino = proximo or "nenhum"
+                logger.warning(
+                    "Modelo %s indisponível (Status %s). Acionando fallback para %s.",
+                    provider,
+                    status,
+                    destino,
+                )
+        except Exception as exc:  # noqa: BLE001 — timeouts, rede, auth: tenta o próximo
+            ultimo_erro = exc
+            logger.warning("LLM: %s falhou (%s): %s", provider, type(exc).__name__, str(exc)[:300])
+        if proximo:
+            continue
+    raise RuntimeError(f"Todos os provedores de LLM falharam ({', '.join(disponiveis)}). Último erro: {ultimo_erro}")
+
+
 def test_provider(db, provider: str) -> dict:
-    """Ping real ao endpoint chat/completions do provedor (1 token)."""
+    """Chamada real e curta (POST /chat/completions) para validar a chave.
+
+    404/410 → 'degraded': a chave pode funcionar, mas o modelo endpoint está
+    indisponível — o pipeline segue pelo fallback. A UI distingue os estados.
+    """
     if provider not in PROVEDORES:
         return {"ok": False, "detail": f"Provedor desconhecido: {provider}"}
     cfg = provider_config(db, provider)
@@ -51,41 +114,18 @@ def test_provider(db, provider: str) -> dict:
         elapsed_ms = int((time.perf_counter() - started) * 1000)
         if resp.status_code == 200:
             return {"ok": True, "status": 200, "latency_ms": elapsed_ms, "model": cfg["model"], "base_url": cfg["base_url"]}
+        if resp.status_code in (404, 410):
+            return {
+                "ok": False,
+                "degraded": True,
+                "status": resp.status_code,
+                "detail": (
+                    f"Sua chave da NVIDIA retornou erro {resp.status_code}. "
+                    "O sistema usará o Gemini (fallback) para gerar as notícias."
+                    if provider == "nvidia"
+                    else f"Endpoint do Gemini retornou {resp.status_code}. O sistema usará a NVIDIA (primário) para gerar as notícias."
+                ),
+            }
         return {"ok": False, "status": resp.status_code, "detail": resp.text[:400]}
     except Exception as exc:  # noqa: BLE001
         return {"ok": False, "detail": f"{type(exc).__name__}: {exc}"}
-
-
-def gerar_texto(db, prompt: str, max_tokens: int = 1024) -> tuple[str, str]:
-    """Gera texto com fallback ordenado. Retorna (texto, provedor_que_respondeu)."""
-    from llmswitch import Client, Endpoint, LLMSwitchConfig
-
-    ordem = [p.strip() for p in get_config(db, "llm_fallback_ordem", "nvidia,google").split(",") if p.strip()]
-    endpoints = []
-    for provider in ordem:
-        if provider not in PROVEDORES:
-            continue
-        cfg = provider_config(db, provider)
-        if cfg["api_key"]:
-            endpoints.append(
-                Endpoint(provider=provider, base_url=cfg["base_url"], api_key=cfg["api_key"], model=cfg["model"])
-            )
-    if not endpoints:
-        raise RuntimeError("Nenhum provedor de LLM configurado. Adicione uma API key em Configurações.")
-
-    config = LLMSwitchConfig(alias="pandanews", endpoints=endpoints)
-    client = Client(configs=config)
-    resp = client.chat.completions.create(
-        model="pandanews",
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=max_tokens,
-    )
-    texto = resp.choices[0].message.content or ""
-    model = getattr(resp, "model", "") or ""
-    if "llama" in model or "nvidia" in model:
-        provedor = "nvidia"
-    elif "gemini" in model:
-        provedor = "google"
-    else:
-        provedor = endpoints[0].provider if endpoints else "desconhecido"
-    return texto, provedor