iContei.

class AIVerificationService:
    """
    Verifica contadores usando OpenAI ou Groq
    Retorna saída padronizada para o ReviewWorker
    """
    def __init__(
        self,
        provider: str,  # "openai" ou "groq"
        model: str,
        openai_api_key: str | None,
        groq_api_key: str | None,
    ):
        self.provider = provider
        # Endpoints compatíveis com OpenAI Chat Completions
        self._openai_url = "https://api.openai.com/v1/chat/completions"
        self._groq_url = "https://api.groq.com/openai/v1/chat/completions"

    async def verify_counter(self, counter: Counter) -> dict | None:
        """
        Retorna:
        {
          "approved": bool,
          "confidence": float (0-100),
          "reasoning": str,
          "model": str
        }
        """
        # Seleção de provider com fallback
        if self.provider == "openai" and self.openai_api_key:
            chosen = "openai"
        elif self.groq_api_key:
            chosen = "groq"  # fallback
        else:
            return None  # Manual review

        system_msg = (
            "Você é um verificador que decide se um contador "
            "é válido. Responda APENAS JSON..."
        )
        
        user_msg = self._build_user_prompt(counter)
        # ... chamada à API e parse do resultado

class GroqClient:
    """
    Pipeline de 2 estágios para extração de dados:
    1. Brave Search - Busca web
    2. Groq AI - Extrai dados estruturados em JSON
    """
    
    async def search_and_extract(
        self,
        search_query: str,
        prompt_template: str,
        search_count: int = 5,
        groq_model: str = "llama-3.3-70b-versatile",
    ) -> dict | None:
        # Etapa 1: Busca na web
        search_results = await self._brave_search(
            search_query, 
            search_count
        )
        
        # Etapa 2: Processa com IA
        extracted_data = await self._groq_process(
            search_results=search_results,
            prompt_template=prompt_template,
            model=groq_model,
        )
        
        return extracted_data

    async def _retry_with_backoff(self, operation, func, *args):
        """
        Exponential backoff + jitter para resiliência
        Retry on: 5xx, 429 (rate limit), 408 (timeout)
        """
        for attempt in range(self.max_retries + 1):
            try:
                return await func(*args)
            except (TimeoutError, ClientError):
                delay = self.retry_delay * (2 ** attempt) + random.uniform(0, 1)
                await asyncio.sleep(delay)