@danhachuel/prodmaker 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 Todas as versões seguem a etiqueta visual `MAJOR.MINOR.PATCH` com patch de dois dígitos
 (o registry NPM normaliza `0.1.00` → `0.1.0`).
 
+## 0.1.04 — 2026-10-25
+
+- Favicon 🚀 (SVG) nas guias do navegador: app (SPA), login e páginas `/legal`.
+
+## 0.1.03 — 2026-10-25
+
+- **Parte 3 — Motor LLM + Chaves de API + Análise de Produto por IA + Studio de PDF.**
+- **Motor LLM (`app/services/llm.py`):** pool NVIDIA NIM (compatível OpenAI) + Google Gemini
+  com prioridade (1 = primeiro) e failover apenas em erros transitórios (quota, timeout,
+  transporte, 429/5xx); erro de credencial/payload registrado com attribution e nunca
+  mascarado. Importações preguiçosas — o servidor sobe mesmo sem deps de LLM instaladas.
+- **Chaves de API funcional:** página com cards (AdsX api-grid) para NVIDIA, Gemini, Gamma,
+  GitHub, Cloudflare, Telegram, Pinterest, Google Ads, Meta, TikTok e Canva (em breve);
+  modais por card; LLMs com modelo/prioridade/ativo + **Testar chamada** (read-only, mostra
+  latência e modelo); demais integrações com campos por serviço salvos no storage local.
+- **Análise de produto por IA:** ao **✓ Aprovar**, se houver LLM ativo o produto recebe o
+  plano de ataque (resumo, ângulos de copy, palavras-chave, negativas, brief da presell,
+  público) via `seed/prompts/analise-produto.md`; modal 🧠 na listagem e regeneração via 🔬.
+  Sem LLM configurado a aprovação funciona normalmente (sem travas).
+- **Studio (Criar Infoproduto):** formulário completo (modo, formato, título, nicho, dor,
+  avatar, resultado, prompt) → Modo Rápido (LLM → Markdown → HTML A4 → PDF via xhtml2pdf,
+  sem dependências de sistema) e Modo Premium (Gamma AI: `POST /v1.0/generations` com
+  `exportAs: "pdf"`, polling e download); resultado com download direto do PDF.
+- **Biblioteca de Infoprodutos:** tabela (criado, título, formato, modo) com download de PDF,
+  visualização do Markdown e exclusão.
+- Backend reorganizado em módulos: `services/store.py` (settings), `services/database.py`
+  (SQLite + migração: coluna `analysis` em produtos + tabela `infoprodutos`),
+  `services/llm.py`, `services/pdf.py`, `services/gamma.py`, `api/llm.py`, `api/infoprodutos.py`.
+- requirements.txt: + openai, google-genai, markdown, xhtml2pdf.
+
 ## 0.1.02 — 2026-10-25
 
 - Launcher: caixa da URL em ASCII puro (evita mojibake de caracteres Unicode no CMD/Windows).

package/THIRD-PARTY-NOTICES.md

@@ -10,6 +10,14 @@ Esta lista cresce a cada fase conforme novas integrações são ativadas.
 - **Pydantic** — MIT License — https://github.com/pydantic/pydantic
 - **Node.js** — MIT License — https://nodejs.org
 
+## Runtime (Parte 3)
+
+- **openai (SDK Python)** — Apache-2.0 — https://github.com/openai/openai-python (usado no endpoint compatível com OpenAI da NVIDIA NIM)
+- **google-genai (SDK oficial Google Gemini)** — Apache-2.0 — https://github.com/googleapis/python-genai
+- **Markdown** — BSD-3-Clause — https://github.com/Python-Markdown/markdown
+- **xhtml2pdf** (inclui ReportLab) — MIT/Apache-2.0 — https://github.com/xhtml2pdf/xhtml2pdf
+- **httpx** (transitivo do openai; usado pelo cliente Gamma) — BSD-3-Clause — https://github.com/encode/httpx
+
 ## Integrações planejadas (fases futuras)
 
 - **google-ads-mcp-rw** — Google Ads MCP (write) — https://pypi.org/project/google-ads-mcp-rw

package/app/api/__init__.py

@@ -0,0 +1 @@
+# Torna `app.api` um pacote Python.

package/app/api/infoprodutos.py

@@ -0,0 +1,141 @@
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+from ..services.database import get_db, now_str, row_to_dict
+from ..services.llm import LLMError, generate
+from ..services.pdf import markdown_para_pdf
+from ..services.store import STORAGE
+from ..services import gamma as gamma_service
+
+router = APIRouter(prefix="/api/infoprodutos", tags=["infoprodutos"])
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+
+
+class InfoprodutoBody(BaseModel):
+    titulo: str
+    prompt: str
+    formato: str = "E-book"
+    nicho: str = ""
+    dor: str = ""
+    avatar: str = ""
+    resultado: str = ""
+    modo: str = "rapido"  # rapido (LLM+PDF local) | gamma (API premium)
+
+
+def _build_prompt(body: InfoprodutoBody) -> str:
+    template_path = SEED_DIR / "prompts" / "infoproduto.md"
+    template = template_path.read_text(encoding="utf-8") if template_path.exists() else ""
+    return (
+        template.replace("{FORMATO}", body.formato)
+        .replace("{NICHO}", body.nicho)
+        .replace("{DOR}", body.dor)
+        .replace("{AVATAR}", body.avatar)
+        .replace("{RESULTADO}", body.resultado)
+        + f"\n\n**Título desejado:** {body.titulo}\n**Instrução adicional do usuário:** {body.prompt}\n"
+    )
+
+
+@router.post("")
+def create_infoproduto(body: InfoprodutoBody):
+    if not body.titulo.strip():
+        raise HTTPException(status_code=400, detail="Informe o título do infoproduto.")
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO infoprodutos (titulo, formato, nicho, modo, provider, created_at) VALUES (?, ?, ?, ?, '', ?)",
+            (body.titulo.strip(), body.formato, body.nicho.strip(), body.modo, timestamp),
+        )
+        record_id = cursor.lastrowid
+
+    folder = STORAGE / "produtos" / str(record_id)
+    try:
+        if body.modo == "gamma":
+            from ..services.store import get_settings
+
+            gamma_keys = (get_settings().get("api_keys") or {}).get("gamma") or {}
+            api_key = (gamma_keys.get("api_key") or "").strip()
+            base_url = (gamma_keys.get("base_url") or "").strip()
+            if not api_key:
+                raise LLMError("Modo Premium (Gamma) requer a API key da Gamma — configure em Chaves de API.")
+            pdf_bytes = gamma_service.gerar_pdf_gamma(api_key, base_url, body.titulo.strip(), _build_prompt(body))
+            folder.mkdir(parents=True, exist_ok=True)
+            pdf_path = folder / "infoproduto.pdf"
+            pdf_path.write_bytes(pdf_bytes)
+            md_path = None
+            provider = "gamma"
+        else:
+            result = generate(
+                _build_prompt(body),
+                system="Você é um especialista em criação de infoprodutos low-ticket. Gere conteúdo prático e direto em Markdown.",
+                max_tokens=8000,
+            )
+            md_text = result["text"]
+            folder.mkdir(parents=True, exist_ok=True)
+            md_path = folder / "infoproduto.md"
+            md_path.write_text(md_text, encoding="utf-8")
+            pdf_path = markdown_para_pdf(md_text, folder / "infoproduto.pdf")
+            provider = result["provider"]
+
+        rel_pdf = pdf_path.relative_to(STORAGE).as_posix()
+        rel_md = md_path.relative_to(STORAGE).as_posix() if md_path else ""
+        with get_db() as conn:
+            conn.execute(
+                "UPDATE infoprodutos SET provider = ?, pdf_path = ?, md_path = ? WHERE id = ?",
+                (provider, rel_pdf, rel_md, record_id),
+            )
+            row = conn.execute("SELECT * FROM infoprodutos WHERE id = ?", (record_id,)).fetchone()
+        return row_to_dict(row)
+    except (LLMError, gamma_service.GammaError, RuntimeError) as exc:
+        with get_db() as conn:
+            conn.execute("DELETE FROM infoprodutos WHERE id = ?", (record_id,))
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.get("")
+def list_infoprodutos():
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM infoprodutos ORDER BY id DESC").fetchall()
+    return [row_to_dict(row) for row in rows]
+
+
+@router.get("/{infoproduto_id}/download")
+def download_infoproduto(infoproduto_id: int):
+    row = _get_or_404(infoproduto_id)
+    pdf_path = STORAGE / row["pdf_path"]
+    if not row["pdf_path"] or not pdf_path.exists():
+        raise HTTPException(status_code=404, detail="PDF não encontrado.")
+    return FileResponse(pdf_path, filename=f"{row['titulo']}.pdf", media_type="application/pdf")
+
+
+@router.get("/{infoproduto_id}/markdown")
+def infoproduto_markdown(infoproduto_id: int):
+    row = _get_or_404(infoproduto_id)
+    md_path = STORAGE / row["md_path"] if row["md_path"] else None
+    if not md_path or not md_path.exists():
+        raise HTTPException(status_code=404, detail="Markdown não disponível para este infoproduto.")
+    return {"markdown": md_path.read_text(encoding="utf-8")}
+
+
+@router.delete("/{infoproduto_id}")
+def delete_infoproduto(infoproduto_id: int):
+    row = _get_or_404(infoproduto_id)
+    for rel in (row["pdf_path"], row["md_path"]):
+        if rel:
+            path = STORAGE / rel
+            if path.exists():
+                path.unlink(missing_ok=True)
+    with get_db() as conn:
+        conn.execute("DELETE FROM infoprodutos WHERE id = ?", (infoproduto_id,))
+    return {"ok": True}
+
+
+def _get_or_404(infoproduto_id: int):
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM infoprodutos WHERE id = ?", (infoproduto_id,)).fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Infoproduto não encontrado.")
+    return row

package/app/api/llm.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services.llm import LLMError, generate, list_providers, test_provider
+from ..services.store import get_settings, save_settings
+
+router = APIRouter(prefix="/api/llm", tags=["llm"])
+
+
+class TestBody(BaseModel):
+    id: str
+
+
+class GenerateBody(BaseModel):
+    prompt: str
+    system: str | None = None
+    max_tokens: int = 4000
+
+
+@router.get("/providers")
+def providers():
+    """Provedores LLM salvos (cartões de Chaves de API)."""
+    return list_providers(active_only=False)
+
+
+@router.put("/providers")
+def save_providers(payload: dict):
+    """Salva a lista de cartões de provedor LLM (substitui settings.llm.providers)."""
+    if not isinstance(payload, dict) or not isinstance(payload.get("providers"), list):
+        raise HTTPException(status_code=400, detail="Envie { 'providers': [ ... ] }.")
+    settings = get_settings()
+    settings["llm"] = {"providers": payload["providers"]}
+    save_settings(settings)
+    return {"ok": True, "providers": settings["llm"]["providers"]}
+
+
+@router.post("/test")
+def test(body: TestBody):
+    """Teste de chamada read-only — valida credencial/modelo no momento da ação."""
+    try:
+        return test_provider(body.id)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/generate")
+def generate_text(body: GenerateBody):
+    """Geração pelo pool com failover — usada por Produtos, Studio, AdsPages etc."""
+    try:
+        return generate(body.prompt, system=body.system, max_tokens=body.max_tokens)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))

package/app/main.py

@@ -3,7 +3,6 @@ import hashlib
 import hmac
 import json
 import os
-import sqlite3
 import time
 from pathlib import Path
 
@@ -12,50 +11,30 @@ from fastapi.responses import FileResponse, HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
-APP_VERSION = "0.1.02"
+from .services.database import ensure_db, get_db, now_str, row_to_dict
+from .services.llm import LLMError, analyze_product, list_providers
+from .services.store import PRODMAKER_HOME, STORAGE, STATE, ensure_state_dir, get_settings, save_settings
+
+APP_VERSION = "0.1.04"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 
-PRODMAKER_HOME = Path(os.environ.get("PRODMAKER_HOME", str(Path.home() / "ProdMaker")))
-STORAGE = PRODMAKER_HOME / "storage"
-STATE = STORAGE / "state"
 DIST_DIR = Path(__file__).resolve().parent.parent / "frontend" / "dist"
 LEGAL_DIR = Path(__file__).resolve().parent.parent / "legal"
 
 app = FastAPI(title="ProdMaker", version=APP_VERSION)
 
+from .api import infoprodutos as infoprodutos_router  # noqa: E402
+from .api import llm as llm_router  # noqa: E402
 
-# ---------------------------------------------------------------------------
-# Storage helpers (leitura protegida: nunca sobrescrever dados corrompidos)
-# ---------------------------------------------------------------------------
-
-
-def ensure_state_dir() -> None:
-    STATE.mkdir(parents=True, exist_ok=True)
-
-
-def get_settings() -> dict:
-    settings_path = STATE / "settings.json"
-    if not settings_path.exists():
-        return {"schema": 1, "port": 8188, "language": "pt-BR", "theme": "light", "api_keys": {}, "llm": {"providers": []}}
-    try:
-        return json.loads(settings_path.read_text(encoding="utf-8"))
-    except json.JSONDecodeError:
-        raise HTTPException(status_code=500, detail="settings.json corrompido — leitura protegida. Restaure o arquivo manualmente.")
+app.include_router(llm_router.router)
+app.include_router(infoprodutos_router.router)
 
+ensure_db()
 
-def save_settings(data: dict) -> dict:
-    ensure_state_dir()
-    settings_path = STATE / "settings.json"
-    if settings_path.exists():
-        try:
-            json.loads(settings_path.read_text(encoding="utf-8"))
-        except json.JSONDecodeError:
-            backup = STATE / "settings.corrupt.json"
-            backup.write_text(settings_path.read_text(encoding="utf-8", errors="replace"), encoding="utf-8")
-            raise HTTPException(status_code=500, detail="settings.json corrompido — cópia preservada em settings.corrupt.json.")
-    settings_path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
-    return data
+# ---------------------------------------------------------------------------
+# Auth local (v1: validação simulada; estrutura pronta para validação remota)
+# ---------------------------------------------------------------------------
 
 
 def get_secret() -> bytes:
@@ -66,54 +45,6 @@ def get_secret() -> bytes:
     return secret_path.read_bytes()
 
 
-# ---------------------------------------------------------------------------
-# Banco de dados local (SQLite via stdlib)
-# ---------------------------------------------------------------------------
-
-
-def get_db():
-    ensure_state_dir()
-    conn = sqlite3.connect(STATE / "prodmaker.db")
-    conn.row_factory = sqlite3.Row
-    return conn
-
-
-def ensure_db() -> None:
-    with get_db() as conn:
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS produtos (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                nome TEXT NOT NULL,
-                plataforma TEXT NOT NULL DEFAULT 'Outro',
-                link_afiliado TEXT NOT NULL DEFAULT '',
-                comissao REAL NOT NULL DEFAULT 0,
-                preco REAL NOT NULL DEFAULT 0,
-                nicho TEXT NOT NULL DEFAULT '',
-                status TEXT NOT NULL DEFAULT 'em_analise',
-                created_at TEXT NOT NULL,
-                updated_at TEXT NOT NULL
-            )
-            """
-        )
-
-
-ensure_db()
-
-
-def now_str() -> str:
-    return time.strftime("%Y-%m-%d %H:%M:%S")
-
-
-def row_to_dict(row) -> dict:
-    return {key: row[key] for key in row.keys()}
-
-
-# ---------------------------------------------------------------------------
-# Auth local (v1: validação simulada; estrutura pronta para validação remota)
-# ---------------------------------------------------------------------------
-
-
 def make_token(email: str) -> str:
     payload = base64.urlsafe_b64encode(json.dumps({"email": email, "exp": int(time.time()) + SESSION_DAYS * 86400}).encode()).decode()
     signature = hmac.new(get_secret(), payload.encode(), hashlib.sha256).hexdigest()
@@ -180,7 +111,7 @@ def auth_session(request: Request):
 
 
 # ---------------------------------------------------------------------------
-# Produtos (Seus Produtos — em análise / aprovados)
+# Produtos (Seus Produtos — em análise / aprovados, com análise por IA)
 # ---------------------------------------------------------------------------
 
 
@@ -241,12 +172,45 @@ def delete_produto(produto_id: int):
 
 @app.post("/api/produtos/{produto_id}/aprovar")
 def aprovar_produto(produto_id: int):
+    """Aprova o produto e, se houver LLM ativo, gera a análise (plano de ataque).
+
+    Sem LLM configurado a aprovação acontece normalmente (sem travas de pré-registo);
+    a análise fica pendente e pode ser gerada depois via /api/produtos/{id}/analisar.
+    """
     with get_db() as conn:
         cursor = conn.execute("UPDATE produtos SET status = 'aprovado', updated_at = ? WHERE id = ?", (now_str(), produto_id))
         if cursor.rowcount == 0:
             raise HTTPException(status_code=404, detail="Produto não encontrado.")
         row = conn.execute("SELECT * FROM produtos WHERE id = ?", (produto_id,)).fetchone()
-    return row_to_dict(row)
+    produto = row_to_dict(row)
+    analysis = None
+    if list_providers():
+        try:
+            analysis = analyze_product(produto)
+            with get_db() as conn:
+                conn.execute("UPDATE produtos SET analysis = ? WHERE id = ?", (json.dumps(analysis, ensure_ascii=False), produto_id))
+            produto["analysis"] = analysis
+        except LLMError as exc:
+            produto["analysis_error"] = str(exc)
+    return produto
+
+
+@app.post("/api/produtos/{produto_id}/analisar")
+def analisar_produto(produto_id: int):
+    """Gera (ou regenera) a análise de IA de um produto aprovado."""
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM produtos WHERE id = ?", (produto_id,)).fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Produto não encontrado.")
+    produto = row_to_dict(row)
+    try:
+        analysis = analyze_product(produto)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    with get_db() as conn:
+        conn.execute("UPDATE produtos SET analysis = ?, updated_at = ? WHERE id = ?", (json.dumps(analysis, ensure_ascii=False), now_str(), produto_id))
+    produto["analysis"] = analysis
+    return produto
 
 
 # ---------------------------------------------------------------------------
@@ -261,7 +225,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.2"}
+    return {"version": APP_VERSION, "canonical": "0.1.4"}
 
 
 @app.get("/api/settings")
@@ -304,8 +268,7 @@ def _spa_index():
 .box{max-width:520px;padding:40px;text-align:center}h1{color:#7C3AED}.muted{color:#64748b}</style></head>
 <body><div class="box"><h1>🚀 ProdMaker</h1>
 <p>O backend está rodando.</p>
-<p class="muted">O frontend (React + Vite + Tailwind) será publicado na Parte 2.</p>
-<p class="muted">API: <code>/api/health</code> · Legal: <code>/legal/</code></p></div></body></html>"""
+<p class="muted">Frontend build pendente — rode <code>npm run build</code> em frontend/.</p></div></body></html>"""
     )
 
 

package/app/services/__init__.py

@@ -0,0 +1 @@
+# Torna `app.services` um pacote Python.

package/app/services/database.py

@@ -0,0 +1,61 @@
+"""Banco SQLite local (stdlib) — helpers compartilhados."""
+import sqlite3
+import time
+from pathlib import Path
+
+from .store import STATE
+
+DB_PATH = STATE / "prodmaker.db"
+
+
+def get_db():
+    STATE.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def ensure_db() -> None:
+    with get_db() as conn:
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS produtos (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                nome TEXT NOT NULL,
+                plataforma TEXT NOT NULL DEFAULT 'Outro',
+                link_afiliado TEXT NOT NULL DEFAULT '',
+                comissao REAL NOT NULL DEFAULT 0,
+                preco REAL NOT NULL DEFAULT 0,
+                nicho TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'em_analise',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS infoprodutos (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                titulo TEXT NOT NULL,
+                formato TEXT NOT NULL DEFAULT 'E-book',
+                nicho TEXT NOT NULL DEFAULT '',
+                modo TEXT NOT NULL DEFAULT 'rapido',
+                provider TEXT NOT NULL DEFAULT '',
+                pdf_path TEXT NOT NULL DEFAULT '',
+                md_path TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        columns = [row["name"] for row in conn.execute("PRAGMA table_info(produtos)")]
+        if "analysis" not in columns:
+            conn.execute("ALTER TABLE produtos ADD COLUMN analysis TEXT NOT NULL DEFAULT ''")
+
+
+def now_str() -> str:
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def row_to_dict(row) -> dict:
+    return {key: row[key] for key in row.keys()}

package/app/services/gamma.py

@@ -0,0 +1,64 @@
+"""Cliente Gamma AI (modo Premium) — melhor esforço conforme contrato do prompt mestre:
+POST {base}/v1.0/generations (exportAs: "pdf") -> polling -> download do PDF.
+Base URL configurável em Chaves de API (padrão https://api.gamma.app).
+"""
+import time
+
+import httpx
+
+
+class GammaError(Exception):
+    pass
+
+
+def _headers(api_key: str) -> dict:
+    return {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+
+def gerar_pdf_gamma(api_key: str, base_url: str, titulo: str, prompt: str, total_timeout: float = 600.0) -> bytes:
+    base = (base_url or "https://api.app.gamma").rstrip("/")
+    started = time.time()
+    with httpx.Client(timeout=60.0) as client:
+        try:
+            response = client.post(
+                f"{base}/v1.0/generations",
+                headers=_headers(api_key),
+                json={"title": titulo, "prompt": prompt, "exportAs": "pdf"},
+            )
+        except httpx.HTTPError as exc:
+            raise GammaError(f"Falha de conexão com a Gamma API: {exc}") from exc
+        if response.status_code in (401, 403):
+            raise GammaError("Gamma API rejeitou a chave (401/403). Confira a API key em Chaves de API.")
+        if response.status_code != 200:
+            raise GammaError(f"Gamma API respondeu {response.status_code}: {response.text[:300]}")
+        data = response.json()
+        generation_id = data.get("id") or data.get("generationId") or (data.get("data") or {}).get("id")
+        if not generation_id:
+            raise GammaError(f"Resposta inesperada da Gamma API (sem id): {str(data)[:300]}")
+
+        while time.time() - started < total_timeout:
+            try:
+                poll = client.get(f"{base}/v1.0/generations/{generation_id}", headers=_headers(api_key))
+            except httpx.HTTPError as exc:
+                raise GammaError(f"Falha de conexão no polling da Gamma API: {exc}") from exc
+            if poll.status_code != 200:
+                raise GammaError(f"Polling Gamma API respondeu {poll.status_code}: {poll.text[:300]}")
+            info = poll.json()
+            status = str(info.get("status") or (info.get("data") or {}).get("status") or "").lower()
+            if status in ("ready", "completed", "succeeded", "done"):
+                pdf_url = (
+                    info.get("pdfUrl")
+                    or info.get("pdf_url")
+                    or (info.get("data") or {}).get("pdfUrl")
+                    or info.get("exportUrl")
+                )
+                if not pdf_url:
+                    raise GammaError(f"Geração concluída sem URL de PDF: {str(info)[:300]}")
+                file_response = client.get(pdf_url)
+                if file_response.status_code != 200:
+                    raise GammaError(f"Download do PDF falhou ({file_response.status_code}).")
+                return file_response.content
+            if status in ("failed", "error", "cancelled"):
+                raise GammaError(f"Geração Gamma falhou: {str(info)[:300]}")
+            time.sleep(5)
+    raise GammaError("Tempo limite aguardando a Gamma API concluir a geração.")