@danhachuel/prodmaker 0.1.7 → 0.1.9

package/app/services/campaigns.py

@@ -0,0 +1,166 @@
+"""AdsCreator — construtor de planos de campanha (defaults do seed + produto vinculado)."""
+import json
+from pathlib import Path
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+PLATAFORMAS = ("google", "meta", "tiktok")
+
+
+def _defaults(plataforma: str) -> dict:
+    aliases = {"google": "google", "meta": "meta", "tiktok": "tiktok"}
+    path = SEED_DIR / "campaign-defaults" / f"{aliases[plataforma]}.json"
+    if path.exists():
+        return json.loads(path.read_text(encoding="utf-8"))
+    return {}
+
+
+def construir(produto: dict, plataforma: str, form: dict) -> dict:
+    """Monta o plano da campanha com defaults do seed + dados do produto."""
+    if plataforma not in PLATAFORMAS:
+        raise LLMError(f"Plataforma inválida: {plataforma}. Use: google, meta, tiktok.")
+    comissao = float(produto.get("comissao") or 0)
+    preco = float(produto.get("preco") or 0)
+    receita = comissao or preco * 0.5
+    defaults = _defaults(plataforma)
+
+    if plataforma == "google":
+        cpa_alvo = round(receita * 0.7, 2) if receita else 120.0
+        orcamento = float(form.get("orcamento_diario") or 110)
+        plano = {
+            "rede": "Pesquisa (Search)",
+            "objetivo": "Vendas — conversões",
+            "lance": f"Manual CPC com lance = CPA alvo (R$ {cpa_alvo}) — troque para CPA automático quando a conversão estiver ativa",
+            "cpa_alvo": cpa_alvo,
+            "orcamento_diario": orcamento,
+            "localizacao": "Presença (apenas): Estados Unidos, Canadá, Austrália, Reino Unido",
+            "idiomas": "Inglês e Francês",
+            "correspondencia": "frase",
+            "anuncio": defaults.get("anuncio", {}),
+        }
+    elif plataforma == "meta":
+        ticket = preco or (receita / 0.5 if receita else 0)
+        criativos = max(5, int(form.get("quantidade_criativos") or 5))
+        orcamento = round(criativos * (ticket / 2), 2) if ticket else 300.0
+        plano = {
+            "estrutura": f"1 campanha → 1 conjunto → {criativos} criativos",
+            "objetivo": "Vendas (Conversões)",
+            "publico": "Aberto + Advantage+",
+            "orcamento_diario": orcamento,
+            "regra_budget": "criativos × metade do ticket",
+            "criativos": criativos,
+        }
+    else:
+        plano = {
+            "formato": "Vídeo vertical 9:16, 15–30s, estilo UGC",
+            "objetivo": "Conversões",
+            "publico": "Idade 18–45 (EUA/UK/CA/AU)",
+            "orcamento_diario": float(form.get("orcamento_diario") or 15),
+            "moeda": "USD",
+            "teste": "US$10–20/dia por criativo; escala US$50–100/dia no vencedor",
+        }
+
+    positivas = form.get("keywords") or []
+    negativas = form.get("negativas") or []
+    criativos = form.get("criativos") or []
+    return {
+        "plataforma": plataforma,
+        "nome": form.get("nome") or f"{produto.get('nome') or 'Produto'} — {plataforma.title()}",
+        "produto_id": produto.get("id"),
+        "cpa_alvo": float(plano.get("cpa_alvo") or 0),
+        "orcamento_diario": float(plano.get("orcamento_diario") or 0),
+        "keywords": positivas,
+        "negativas": negativas,
+        "criativos": criativos,
+        "plano": plano,
+        "manual": plataforma == "tiktok",
+    }
+
+
+def salvar(campanha: dict) -> dict:
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO campanhas (produto_id, plataforma, nome, objetivo, cpa_alvo, orcamento_diario, keywords_json, negativas_json, criativos_json, plano_json, status, created_at, updated_at) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'rascunho', ?, ?)",
+            (
+                campanha.get("produto_id"),
+                campanha["plataforma"],
+                campanha["nome"],
+                json.dumps(campanha["plano"].get("objetivo", ""), ensure_ascii=False),
+                campanha.get("cpa_alvo") or 0,
+                campanha.get("orcamento_diario") or 0,
+                json.dumps(campanha["keywords"], ensure_ascii=False),
+                json.dumps(campanha["negativas"], ensure_ascii=False),
+                json.dumps(campanha["criativos"], ensure_ascii=False),
+                json.dumps(campanha["plano"], ensure_ascii=False),
+                timestamp,
+                timestamp,
+            ),
+        )
+        row = conn.execute("SELECT * FROM campanhas WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return row_to_dict(row)
+
+
+def listar(produto_id: int | None = None) -> list[dict]:
+    query = "SELECT * FROM campanhas"
+    params: tuple = ()
+    if produto_id:
+        query += " WHERE produto_id = ?"
+        params = (produto_id,)
+    query += " ORDER BY id DESC"
+    with get_db() as conn:
+        rows = conn.execute(query, params).fetchall()
+    return [row_to_dict(row) for row in rows]
+
+
+def get(campanha_id: int) -> dict:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM campanhas WHERE id = ?", (campanha_id,)).fetchone()
+    if not row:
+        raise LLMError("Campanha não encontrada.")
+    record = row_to_dict(row)
+    for field in ("keywords_json", "negativas_json", "criativos_json", "plano_json", "resultado_json"):
+        if record.get(field):
+            try:
+                record[field.replace("_json", "")] = json.loads(record[field])
+            except Exception:  # noqa: BLE001
+                record[field.replace("_json", "")] = record[field]
+    return record
+
+
+def remover(campanha_id: int) -> None:
+    with get_db() as conn:
+        cursor = conn.execute("DELETE FROM campanhas WHERE id = ?", (campanha_id,))
+        if cursor.rowcount == 0:
+            raise LLMError("Campanha não encontrada.")
+
+
+def marcar_publicada(campanha_id: int, resultado: dict, status: str = "publicada", erro: str = "") -> dict:
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE campanhas SET status = ?, resultado_json = ?, erro = ?, updated_at = ? WHERE id = ?",
+            (status, json.dumps(resultado, ensure_ascii=False), erro[:2000], now_str(), campanha_id),
+        )
+    return get(campanha_id)
+
+
+def atualizar(campanha_id: int, campanha: dict) -> dict:
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE campanhas SET nome = ?, cpa_alvo = ?, orcamento_diario = ?, keywords_json = ?, negativas_json = ?, criativos_json = ?, plano_json = ?, updated_at = ? WHERE id = ?",
+            (
+                campanha["nome"],
+                campanha.get("cpa_alvo") or 0,
+                campanha.get("orcamento_diario") or 0,
+                json.dumps(campanha["keywords"], ensure_ascii=False),
+                json.dumps(campanha["negativas"], ensure_ascii=False),
+                json.dumps(campanha["criativos"], ensure_ascii=False),
+                json.dumps(campanha["plano"], ensure_ascii=False),
+                now_str(),
+                campanha_id,
+            ),
+        )
+    return get(campanha_id)

package/app/services/database.py

@@ -97,6 +97,69 @@ def ensure_db() -> None:
             )
             """
         )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS vendas (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                fonte TEXT NOT NULL DEFAULT 'manual',
+                produto_id INTEGER,
+                produto_nome TEXT NOT NULL DEFAULT '',
+                transacao_id TEXT NOT NULL DEFAULT '',
+                comprador_email TEXT NOT NULL DEFAULT '',
+                valor REAL NOT NULL DEFAULT 0,
+                comissao REAL NOT NULL DEFAULT 0,
+                gclid TEXT NOT NULL DEFAULT '',
+                utm_source TEXT NOT NULL DEFAULT '',
+                utm_medium TEXT NOT NULL DEFAULT '',
+                utm_campaign TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'aprovada',
+                conversao_status TEXT NOT NULL DEFAULT 'pendente',
+                conversao_erro TEXT NOT NULL DEFAULT '',
+                gclid_match TEXT NOT NULL DEFAULT '',
+                raw TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_gclid ON vendas (gclid)")
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_created ON vendas (created_at)")
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_visitas_gclid ON visitas (gclid)")
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS palavras (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                produto_nome TEXT NOT NULL DEFAULT '',
+                tipo TEXT NOT NULL DEFAULT 'positiva',
+                texto TEXT NOT NULL,
+                correspondencia TEXT NOT NULL DEFAULT 'frase',
+                origem TEXT NOT NULL DEFAULT 'ia',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS campanhas (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                plataforma TEXT NOT NULL DEFAULT 'google',
+                nome TEXT NOT NULL,
+                objetivo TEXT NOT NULL DEFAULT '',
+                cpa_alvo REAL NOT NULL DEFAULT 0,
+                orcamento_diario REAL NOT NULL DEFAULT 0,
+                keywords_json TEXT NOT NULL DEFAULT '[]',
+                negativas_json TEXT NOT NULL DEFAULT '[]',
+                criativos_json TEXT NOT NULL DEFAULT '[]',
+                plano_json TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'rascunho',
+                resultado_json TEXT NOT NULL DEFAULT '',
+                erro TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL,
+                updated_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 ''")

package/app/services/gads.py

@@ -0,0 +1,109 @@
+"""Google Ads — upload de conversões offline (click conversions via GCLID).
+
+Implementação enxuta via REST (httpx), sem SDK pesado:
+1. refresh_token -> access_token (OAuth2)
+2. POST /{version}/customers/{customer_id}:uploadClickConversions
+
+Best-effort: a versão da API é configurável (settings.api_keys['google-ads'].api_version,
+default v22) e erros da API são devolvidos com attribution clara.
+"""
+import time
+
+import httpx
+
+from .llm import LLMError
+from .store import get_settings
+
+DEFAULT_API_VERSION = "v22"
+TOKEN_URL = "https://oauth2.googleapis.com/token"
+ADS_BASE = "https://googleads.googleapis.com"
+
+
+def _google_ads_config() -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("google-ads") or {}
+    return {
+        "developer_token": (keys.get("developer_token") or "").strip(),
+        "client_id": (keys.get("client_id") or "").strip(),
+        "client_secret": (keys.get("client_secret") or "").strip(),
+        "refresh_token": (keys.get("refresh_token") or "").strip(),
+        "customer_id": (keys.get("customer_id") or "").strip().replace("-", ""),
+        "conversion_action": (keys.get("conversion_action") or "").strip(),
+        "api_version": (keys.get("api_version") or "").strip() or DEFAULT_API_VERSION,
+    }
+
+
+def _access_token(client_id: str, client_secret: str, refresh_token: str) -> str:
+    try:
+        response = httpx.post(
+            TOKEN_URL,
+            data={
+                "client_id": client_id,
+                "client_secret": client_secret,
+                "refresh_token": refresh_token,
+                "grant_type": "refresh_token",
+            },
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o OAuth do Google: {exc}", provider="google-ads", transient=True) from exc
+    if response.status_code != 200:
+        raise LLMError(
+            f"Google OAuth rejeitou as credenciais ({response.status_code}): {response.text[:200]} — confira client_id/client_secret/refresh_token em Chaves de API.",
+            provider="google-ads",
+        )
+    return (response.json() or {}).get("access_token", "")
+
+
+def upload_conversao(gclid: str, valor: float, ocorrido_em: str | None = None, currency: str = "BRL") -> dict:
+    """Envia uma conversão offline (GCLID) ao Google Ads. Retorna dict de resultado."""
+    config = _google_ads_config()
+    missing = [field for field in ("developer_token", "client_id", "client_secret", "refresh_token", "customer_id", "conversion_action") if not config[field]]
+    if missing:
+        raise LLMError(
+            "Conversões GCLID requerem Google Ads configurado em Chaves de API: " + ", ".join(missing) + ".",
+            provider="google-ads",
+        )
+    if not gclid:
+        raise LLMError("Venda sem GCLID — não é possível enviar conversão offline.", provider="google-ads")
+
+    try:
+        access_token = _access_token(config["client_id"], config["client_secret"], config["refresh_token"])
+    except LLMError:
+        raise
+    if not access_token:
+        raise LLMError("OAuth do Google não devolveu access_token.", provider="google-ads")
+
+    ocorrido_em = ocorrido_em or time.strftime("%Y-%m-%d %H:%M:%S%z")
+    if "%z" in ocorrido_em:
+        # Formato esperado pelo Google Ads: yyyy-mm-dd hh:mm:ss+|-hh:mm
+        ocorrido_em = ocorrido_em.replace("+0000", "+00:00")
+        if len(ocorrido_em) >= 5 and ocorrido_em[-5] in "+-":
+            ocorrido_em = ocorrido_em[:-2] + ":" + ocorrido_em[-2:]
+    url = f"{ADS_BASE}/{config['api_version']}/customers/{config['customer_id']}:uploadClickConversions"
+    body = {
+        "conversions": [
+            {
+                "gclid": gclid,
+                "conversionAction": config["conversion_action"],
+                "conversionDateTime": ocorrido_em,
+                "conversionValue": valor,
+                "currencyCode": currency,
+            }
+        ],
+        "partialFailure": True,
+    }
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "developer-token": config["developer_token"],
+        "Content-Type": "application/json",
+    }
+    try:
+        response = httpx.post(url, headers=headers, json=body, timeout=60.0)
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com a Google Ads API: {exc}", provider="google-ads", transient=True) from exc
+    if response.status_code == 200:
+        return {"ok": True, "resultado": response.json()}
+    raise LLMError(
+        f"Google Ads API respondeu {response.status_code}: {response.text[:300]} (API {config['api_version']}).",
+        provider="google-ads",
+    )

package/app/services/publish_ads.py

@@ -0,0 +1,273 @@
+"""Engines de publicação de campanhas — Google Ads (REST mutates) e Meta Ads (Marketing API).
+
+Best-effort com erros atribuídos por etapa. TikTok permanece manual (guia no plano).
+"""
+import httpx
+
+from .llm import LLMError
+from .store import get_settings
+
+ADS_BASE = "https://googleads.googleapis.com"
+GRAPH_BASE = "https://graph.facebook.com/v19.0"
+
+
+# ---------------------------------------------------------------------------
+# Google Ads — cadeia de mutates
+# ---------------------------------------------------------------------------
+
+
+def _google_config() -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("google-ads") or {}
+    return {
+        "developer_token": (keys.get("developer_token") or "").strip(),
+        "client_id": (keys.get("client_id") or "").strip(),
+        "client_secret": (keys.get("client_secret") or "").strip(),
+        "refresh_token": (keys.get("refresh_token") or "").strip(),
+        "customer_id": (keys.get("customer_id") or "").strip().replace("-", ""),
+        "api_version": (keys.get("api_version") or "").strip() or "v22",
+    }
+
+
+def _access_token() -> str:
+    from .gads import _access_token as token
+
+    config = _google_config()
+    missing = [field for field in ("client_id", "client_secret", "refresh_token") if not config[field]]
+    if missing:
+        raise LLMError("Google Ads: faltam " + ", ".join(missing) + " em Chaves de API.", provider="google")
+    return token(config["client_id"], config["client_secret"], config["refresh_token"])
+
+
+def _mutate(client, config, headers, operations: list, label: str) -> dict:
+    url = f"{ADS_BASE}/{config['api_version']}/customers/{config['customer_id']}/googleAds:mutate"
+    response = client.post(url, headers=headers, json={"operations": operations, "partialFailure": True})
+    if response.status_code != 200:
+        raise LLMError(f"[Google:{label}] HTTP {response.status_code}: {response.text[:300]}", provider="google")
+    payload = response.json()
+    errors = []
+    for detail in (payload.get("partialFailureError") or {}).get("details", []):
+        errors.append(detail.get("message") or str(detail)[:200])
+    names = []
+    for result in payload.get("results", []):
+        names.append(result.get("resourceName", ""))
+    return {"names": names, "errors": errors}
+
+
+def publicar_google(campanha: dict) -> dict:
+    config = _google_config()
+    missing = [field for field in ("developer_token", "client_id", "client_secret", "refresh_token", "customer_id") if not config[field]]
+    if missing:
+        raise LLMError(
+            "Publicação Google Ads requer: " + ", ".join(missing) + " (em Chaves de API).",
+            provider="google",
+        )
+    keywords = [item.get("texto") or item.get("palavra") or "" for item in campanha.get("keywords", [])]
+    negativas = [item.get("texto") or item.get("palavra") or "" for item in campanha.get("negativas", [])]
+    keywords = [text for text in keywords if text.strip()]
+    negativas = [text for text in negativas if text.strip()]
+
+    cpa_micro = int((campanha.get("cpa_alvo") or 0) * 1_000_000)
+    budget_micro = int((campanha.get("orcamento_diario") or 0) * 1_000_000)
+    nome = campanha["nome"]
+
+    access = _access_token()
+    headers = {
+        "Authorization": f"Bearer {access}",
+        "developer-token": config["developer_token"],
+        "Content-Type": "application/json",
+    }
+    etapas = []
+    try:
+        with httpx.Client(timeout=60.0) as client:
+            # 1) Orçamento
+            budget = _mutate(
+                client,
+                config,
+                headers,
+                [{"create": {"name": f"{nome} — Orçamento", "amountMicros": budget_micro, "deliveryMethod": "STANDARD"}}],
+                "orçamento",
+            )
+            etapas.append({"etapa": "orçamento", **budget})
+            if budget["errors"]:
+                raise LLMError("[Google:orçamento] " + "; ".join(budget["errors"]), provider="google")
+            budget_name = budget["names"][0]
+
+            # 2) Campanha (pausada para revisão segura)
+            campaign = _mutate(
+                client,
+                config,
+                headers,
+                [{
+                    "create": {
+                        "name": nome,
+                        "status": "PAUSED",
+                        "advertisingChannelType": "SEARCH",
+                        "campaignBudget": budget_name,
+                        "manualCpc": {},
+                        "networkSettings": {"targetGoogleSearch": True, "targetSearchNetwork": True},
+                        "startDate": None,
+                        "endDate": None,
+                    }
+                }],
+                "campanha",
+            )
+            etapas.append({"etapa": "campanha", **campaign})
+            if campaign["errors"]:
+                raise LLMError("[Google:campanha] " + "; ".join(campaign["errors"]), provider="google")
+            campaign_name = campaign["names"][0]
+
+            # 3) Grupo de anúncios
+            ad_group = _mutate(
+                client,
+                config,
+                headers,
+                [{"create": {"name": f"{nome} — Grupo 1", "campaign": campaign_name, "status": "PAUSED", "type": "SEARCH_STANDARD", "cpcBidMicros": cpa_micro or 1_000_000}}],
+                "grupo de anúncios",
+            )
+            etapas.append({"etapa": "grupo de anúncios", **ad_group})
+            if ad_group["errors"]:
+                raise LLMError("[Google:grupo de anúncios] " + "; ".join(ad_group["errors"]), provider="google")
+            ad_group_name = ad_group["names"][0]
+
+            # 4) Palavras-chave positivas (frase) + negativas (campanha)
+            criterion_ops = []
+            for text in keywords:
+                criterion_ops.append({
+                    "create": {
+                        "adGroup": ad_group_name,
+                        "keyword": {"text": text, "matchType": "PHRASE"},
+                        "status": "PAUSED",
+                    }
+                })
+            for text in negativas:
+                criterion_ops.append({
+                    "create": {
+                        "campaign": campaign_name,
+                        "keyword": {"text": text, "matchType": "PHRASE"},
+                        "negative": True,
+                    }
+                })
+            if criterion_ops:
+                criteria = _mutate(client, config, headers, criterion_ops, "palavras-chave")
+                etapas.append({"etapa": "palavras-chave", **criteria})
+                if criteria["errors"]:
+                    raise LLMError("[Google:palavras-chave] " + "; ".join(criteria["errors"]), provider="google")
+
+            # 5) Anúncio RSA responsivo
+            headlines = [
+                {"text": f"{campanha['nome'].split(' — ')[0]}"},
+                {"text": "Compre Agora com Desconto"},
+                {"text": "Oferta por Tempo Limitado"},
+            ]
+            descriptions = [
+                {"text": f"Garantia e entrega rápida. Lance R$ {campanha.get('cpa_alvo') or 0} alvo."},
+                {"text": "Acesse o site oficial e aproveite."},
+            ]
+            ad = _mutate(
+                client,
+                config,
+                headers,
+                [{
+                    "create": {
+                        "adGroup": ad_group_name,
+                        "status": "PAUSED",
+                        "ad": {
+                            "responsiveSearchAd": {
+                                "headlines": headlines,
+                                "descriptions": descriptions,
+                                "finalUrls": (campanha.get("plano") or {}).get("final_urls", []) or [],
+                            }
+                        },
+                    }
+                }],
+                "anúncio",
+            )
+            etapas.append({"etapa": "anúncio", **ad})
+            if ad["errors"]:
+                raise LLMError("[Google:anúncio] " + "; ".join(ad["errors"]), provider="google")
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com a Google Ads API: {exc}", provider="google", transient=True) from exc
+
+    return {
+        "plataforma": "google",
+        "etapas": etapas,
+        "campaign": campaign_name,
+        "observacao": "Campanha e recursos criados PAUSADOS para revisão — ative manualmente quando aprovar.",
+    }
+
+
+# ---------------------------------------------------------------------------
+# Meta Ads — 4 POSTs simples (campanha -> conjunto -> criativo -> anúncio)
+# ---------------------------------------------------------------------------
+
+
+def publicar_meta(campanha: dict) -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("meta") or {}
+    access_token = (keys.get("access_token") or "").strip()
+    ad_account_id = (keys.get("ad_account_id") or "").strip()
+    missing = [name for name, value in (("access_token", access_token), ("ad_account_id", ad_account_id)) if not value]
+    if missing:
+        raise LLMError("Publicação Meta Ads requer: " + ", ".join(missing) + " (em Chaves de API).", provider="meta")
+    account = ad_account_id if ad_account_id.startswith("act_") else f"act_{ad_account_id}"
+    plano = campanha.get("plano") or {}
+    budget_cents = int((campanha.get("orcamento_diario") or 0) * 100)
+    criativos = campanha.get("criativos") or []
+    roteiro_base = (criativos[0].get("roteiro") if criativos else "") or f"Conheça {campanha['nome']}!"
+    link = plano.get("final_urls", [""])[0] if plano.get("final_urls") else ""
+
+    etapas = []
+    try:
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(
+                f"{GRAPH_BASE}/{account}/campaigns",
+                data={"name": campanha["nome"], "objective": "OUTCOME_SALES", "status": "PAUSED", "special_ad_categories": "[]", "access_token": access_token},
+            )
+            campaign_id = (response.json() or {}).get("id")
+            if not campaign_id:
+                raise LLMError(f"[Meta:campanha] {response.status_code}: {response.text[:300]}", provider="meta")
+            etapas.append({"etapa": "campanha", "id": campaign_id})
+
+            response = client.post(
+                f"{GRAPH_BASE}/{account}/adsets",
+                data={
+                    "name": f"{campanha['nome']} — Conjunto",
+                    "campaign_id": campaign_id,
+                    "daily_budget": budget_cents,
+                    "billing_event": "IMPRESSIONS",
+                    "optimization_goal": "CONVERSIONS",
+                    "bid_strategy": "LOWEST_COST_WITHOUT_CAP",
+                    "status": "PAUSED",
+                    "targeting": "{}",
+                    "access_token": access_token,
+                },
+            )
+            adset_id = (response.json() or {}).get("id")
+            if not adset_id:
+                raise LLMError(f"[Meta:conjunto] {response.status_code}: {response.text[:300]}", provider="meta")
+            etapas.append({"etapa": "conjunto", "id": adset_id})
+
+            response = client.post(
+                f"{GRAPH_BASE}/{account}/adcreatives",
+                data={"name": f"{campanha['nome']} — Criativo", "message": roteiro_base[:2000], "link": link, "access_token": access_token},
+            )
+            creative_id = (response.json() or {}).get("id")
+            if not creative_id:
+                raise LLMError(f"[Meta:criativo] {response.status_code}: {response.text[:300]}", provider="meta")
+            etapas.append({"etapa": "criativo", "id": creative_id})
+
+            response = client.post(
+                f"{GRAPH_BASE}/{account}/ads",
+                data={"name": campanha["nome"], "adset_id": adset_id, "creative": {"creative_id": creative_id}, "status": "PAUSED", "access_token": access_token},
+            )
+            ad_id = (response.json() or {}).get("id")
+            if not ad_id:
+                raise LLMError(f"[Meta:anúncio] {response.status_code}: {response.text[:300]}", provider="meta")
+            etapas.append({"etapa": "anúncio", "id": ad_id})
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com a Meta API: {exc}", provider="meta", transient=True) from exc
+
+    return {
+        "plataforma": "meta",
+        "etapas": etapas,
+        "observacao": "Criado PAUSADO para revisão — ative manualmente quando aprovar.",
+    }