Upload groq_client.py

llm/clients/groq_client.py

@@ -1,36 +1,24 @@
-"""Cliente Groq usando HTTP requests diretos (curl-style) - Compatível com LLMManager."""
+"""Cliente Groq usando HTTP requests diretos - Compatível com LLMManager do PARA.AI."""
 
 import os
 import json
 import logging
 from typing import Optional, Dict, AsyncGenerator
-from dataclasses import dataclass
-import requests
 import aiohttp
+import asyncio
 
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class GroqResponse:
-    """Resposta do Groq - compatível com interface existente."""
-    content: str
-    tokens_input: int
-    tokens_output: int
-    finish_reason: str
-
-    @property
-    def total_tokens(self) -> int:
-        """Total de tokens (input + output)."""
-        return self.tokens_input + self.tokens_output
-
-
 class GroqClient:
-    """Cliente Groq usando requests HTTP diretos (curl-style)."""
+    """
+    Cliente Groq usando requests HTTP diretos (curl-style).
+    Interface compatível com LLMManager do PARA.AI.
+    """
 
     def __init__(self, api_key: Optional[str] = None):
         """
-        Inicializa cliente Groq com requests.
+        Inicializa cliente Groq.
 
         Args:
             api_key: API key (se None, usa GROQ_API_KEY)
@@ -43,60 +31,53 @@ class GroqClient:
         self.default_timeout = int(os.getenv('GROQ_TIMEOUT', '120'))
         logger.info("✅ GroqClient inicializado (HTTP requests)")
 
-    async def generate(self,
-                      prompt: str,
-                      system_prompt: Optional[str] = None,
-                      model: str = "llama-3.3-70b-versatile",
-                      temperature: float = 0.7,
-                      max_tokens: Optional[int] = None,
-                      top_p: float = 0.9,
-                      response_format: Optional[Dict] = None) -> GroqResponse:
+    async def chat_completion(
+        self,
+        model: str,
+        messages: list,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        response_format: Optional[Dict] = None,
+        **kwargs
+    ) -> Dict:
         """
-        Gera resposta usando Groq via HTTP requests (curl-style).
-        Método assíncrono compatível com LLMManager.
+        Chat completion compatível com LLMManager.
 
         Args:
-            prompt: Prompt do usuário
-            system_prompt: Prompt do sistema (com schema JSON)
             model: Modelo a usar
+            messages: Lista de mensagens [{"role": "system", "content": "..."}, ...]
             temperature: Temperatura (0-2)
-            max_tokens: Máximo de tokens na resposta
-            top_p: Top-p sampling
-            response_format: Formato da resposta (ex: {"type": "json_object"})
+            max_tokens: Máximo de tokens
+            response_format: Formato resposta (ex: {"type": "json_object"})
+            **kwargs: Argumentos adicionais (top_p, etc)
 
         Returns:
-            GroqResponse com content, tokens e metadados
+            Dict com {'content': str, 'tokens_input': int, 'tokens_output': int, 'total_tokens': int}
         """
-        # Monta headers
         headers = {
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json"
         }
 
-        # Monta messages
-        messages = []
-        if system_prompt:
-            messages.append({"role": "system", "content": system_prompt})
-        messages.append({"role": "user", "content": prompt})
-
-        # Monta payload
         payload = {
             "model": model,
             "messages": messages,
             "temperature": temperature,
-            "top_p": top_p,
         }
 
         if max_tokens:
             payload["max_tokens"] = max_tokens
 
-        # Adiciona response_format se fornecido
         if response_format:
             payload["response_format"] = response_format
 
+        # Adiciona kwargs extras (top_p, frequency_penalty, etc)
+        for key, value in kwargs.items():
+            if key not in payload:
+                payload[key] = value
+
         try:
-            # Requisição HTTP POST assíncrona usando aiohttp
-            logger.debug(f"📤 Enviando request para Groq: model={model}, temp={temperature}")
+            logger.debug(f"📤 Groq request: model={model}, temp={temperature}, messages={len(messages)}")
 
             async with aiohttp.ClientSession() as session:
                 async with session.post(
@@ -105,28 +86,29 @@ class GroqClient:
                     json=payload,
                     timeout=aiohttp.ClientTimeout(total=self.default_timeout)
                 ) as response:
-                    # Verifica erros HTTP
                     response.raise_for_status()
-
-                    # Parse response JSON
                     data = await response.json()
 
-            # Extrai dados
+            # Extrai dados da resposta
             content = data['choices'][0]['message']['content']
             finish_reason = data['choices'][0]['finish_reason']
 
             usage = data.get('usage', {})
             tokens_input = usage.get('prompt_tokens', 0)
             tokens_output = usage.get('completion_tokens', 0)
+            total_tokens = usage.get('total_tokens', tokens_input + tokens_output)
 
-            logger.info(f"✅ Groq response: {tokens_input + tokens_output} tokens, finish={finish_reason}")
+            logger.info(f"✅ Groq response: {total_tokens} tokens, finish={finish_reason}")
 
-            return GroqResponse(
-                content=content,
-                tokens_input=tokens_input,
-                tokens_output=tokens_output,
-                finish_reason=finish_reason
-            )
+            # Retorna dict simples (compatível com LLMManager)
+            return {
+                'content': content,
+                'tokens_input': tokens_input,
+                'tokens_output': tokens_output,
+                'total_tokens': total_tokens,
+                'finish_reason': finish_reason,
+                'model': model
+            }
 
         except aiohttp.ClientResponseError as e:
             logger.error(f"❌ Groq HTTP Error {e.status}: {e.message}")
@@ -137,110 +119,65 @@ class GroqClient:
             raise
 
         except Exception as e:
-            logger.error(f"❌ Groq erro inesperado: {e}")
+            logger.error(f"❌ Groq erro: {e}")
             raise
 
-    def generate_sync(self,
-                     prompt: str,
-                     system_prompt: Optional[str] = None,
-                     model: str = "llama-3.3-70b-versatile",
-                     temperature: float = 0.7,
-                     max_tokens: Optional[int] = None,
-                     response_format: Optional[Dict] = None) -> GroqResponse:
+    async def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: str = "llama-3.3-70b-versatile",
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> Dict:
         """
-        Versão síncrona do generate (usando requests).
+        Método generate simplificado (wrapper para chat_completion).
 
         Args:
             prompt: Prompt do usuário
-            system_prompt: System prompt
+            system_prompt: Prompt do sistema (opcional)
             model: Modelo
             temperature: Temperatura
             max_tokens: Max tokens
-            response_format: Formato resposta
+            **kwargs: Argumentos extras
 
         Returns:
-            GroqResponse
+            Dict com content e tokens
         """
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        }
-
         messages = []
         if system_prompt:
             messages.append({"role": "system", "content": system_prompt})
         messages.append({"role": "user", "content": prompt})
 
-        payload = {
-            "model": model,
-            "messages": messages,
-            "temperature": temperature,
-        }
-
-        if max_tokens:
-            payload["max_tokens"] = max_tokens
-        if response_format:
-            payload["response_format"] = response_format
-
-        try:
-            response = requests.post(
-                self.base_url,
-                headers=headers,
-                json=payload,
-                timeout=self.default_timeout
-            )
-
-            response.raise_for_status()
-            data = response.json()
-
-            content = data['choices'][0]['message']['content']
-            finish_reason = data['choices'][0]['finish_reason']
-
-            usage = data.get('usage', {})
-            tokens_input = usage.get('prompt_tokens', 0)
-            tokens_output = usage.get('completion_tokens', 0)
-
-            return GroqResponse(
-                content=content,
-                tokens_input=tokens_input,
-                tokens_output=tokens_output,
-                finish_reason=finish_reason
-            )
-
-        except requests.exceptions.HTTPError as e:
-            status_code = e.response.status_code if e.response else 0
-            error_body = e.response.text if e.response else str(e)
-            logger.error(f"❌ Groq HTTP Error {status_code}: {error_body}")
-            raise
-
-        except requests.exceptions.Timeout:
-            logger.error(f"❌ Groq timeout após {self.default_timeout}s")
-            raise
-
-        except Exception as e:
-            logger.error(f"❌ Groq erro inesperado: {e}")
-            raise
-
-    async def generate_stream(self,
-                             prompt: str,
-                             system_prompt: Optional[str] = None,
-                             model: str = "llama-3.3-70b-versatile",
-                             temperature: float = 0.7,
-                             max_tokens: Optional[int] = None,
-                             top_p: float = 0.9) -> AsyncGenerator[str, None]:
+        return await self.chat_completion(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            **kwargs
+        )
+
+    async def generate_stream(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: str = "llama-3.3-70b-versatile",
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None
+    ) -> AsyncGenerator[str, None]:
         """
-        Gera resposta em streaming usando Groq.
+        Gera resposta em streaming.
 
         Args:
-            prompt: Prompt para gerar
+            prompt: Prompt do usuário
             system_prompt: System prompt
-            model: Modelo a usar
-            temperature: Criatividade
-            max_tokens: Tokens máximos
-            top_p: Top-p sampling
+            model: Modelo
+            temperature: Temperatura
+            max_tokens: Max tokens
 
         Yields:
-            Chunks de texto da resposta
+            Chunks de texto
         """
         headers = {
             "Authorization": f"Bearer {self.api_key}",
@@ -256,7 +193,6 @@ class GroqClient:
             "model": model,
             "messages": messages,
             "temperature": temperature,
-            "top_p": top_p,
             "stream": True,
         }
 
@@ -291,7 +227,3 @@ class GroqClient:
         except Exception as e:
             logger.error(f"❌ Erro no streaming: {e}")
             raise
-
-
-# Alias para compatibilidade
-AsyncGroq = GroqClient