Update modules/api.py

modules/api.py

@@ -25,23 +25,21 @@ from .database import Database
 from .treinamento import Treinamento
 from .exemplos_naturais import ExemplosNaturais
 
-# --- NOVOS IMPORTS PARA WEBSERVICE ---
 try:
-    # Assumindo que o web_search está no mesmo diretório de módulos
-    from .web_search import WebSearch
-    websearch_available = True
+    from .local_llm import LlamaLLM # IMPORTADO: LlamaLLM (Modelo Local/HF)
+    local_llm_available = True
 except ImportError:
-    websearch_available = False
-    logging.warning("WebSearch não disponível. Funcionalidades de busca limitadas.")
-# --------------------------------------
+    local_llm_available = False
+    logger.warning("LlamaLLM não disponível. Modelo local desabilitado.")
+
 
 try:
     from mistralai import Mistral
     mistral_available = True
 except ImportError:
     mistral_available = False
+    logger = logging.getLogger("akira.api")
 
-logger = logging.getLogger("akira.api")
 
 try:
     import google.generativeai as genai
@@ -52,17 +50,30 @@ except ImportError:
 
 
 class LLMManager:
-    """Gerenciador de provedores LLM (Mistral + Gemini como fallback)."""
+    """Gerenciador de provedores LLM (Local -> Mistral -> Gemini como fallback)."""
 
     def __init__(self, config):
         self.config = config
         self.mistral_client = None
         self.gemini_model = None
+        self.local_llm = None # NOVO: Atributo para o modelo local
         self._setup_providers()
 
     def _setup_providers(self):
-        # O código local de LLM que exige GPU está fora deste arquivo,
-        # focamos apenas nos providers de API externa (Mistral e Gemini)
+        # 1. SETUP LLAMA LOCAL (PRIORIDADE 1)
+        if local_llm_available:
+            try:
+                self.local_llm = LlamaLLM()
+                if not self.local_llm.is_available():
+                     self.local_llm = None
+                     logger.warning("LlamaLLM carregado mas não está disponível/operacional.")
+                else:
+                    logger.info("LlamaLLM (Local/HF) inicializado como primário.")
+            except Exception as e:
+                logger.warning(f"Falha ao inicializar LlamaLLM: {e}")
+                self.local_llm = None
+
+        # 2. SETUP MISTRAL API (PRIORIDADE 2)
         if mistral_available and getattr(self.config, 'MISTRAL_API_KEY', None):
             try:
                 self.mistral_client = Mistral(api_key=self.config.MISTRAL_API_KEY)
@@ -70,20 +81,36 @@ class LLMManager:
             except Exception as e:
                 logger.warning(f"Falha ao inicializar Mistral: {e}")
 
+        # 3. SETUP GEMINI API (PRIORIDADE 3)
         if gemini_available and getattr(self.config, 'GEMINI_API_KEY', None):
             try:
                 genai.configure(api_key=self.config.GEMINI_API_KEY)
-                self.gemini_model = genai.GenerativeModel(getattr(self.config, 'GEMINI_MODEL', 'gemini-1.5-flash'))  # type: ignore[reportAttributeAccessIssue]
+                # CORRIGIDO: O modelo agora é lido da configuração (gemini-2.5-flash)
+                self.gemini_model = genai.GenerativeModel(getattr(self.config, 'GEMINI_MODEL', 'gemini-2.5-flash'))  # type: ignore[reportAttributeAccessIssue]
                 logger.info("Gemini model inicializado.")
             except Exception as e:
                 logger.warning(f"Falha ao inicializar Gemini: {e}")
 
     def generate(self, prompt: str, max_tokens: int = 300, temperature: float = 0.8) -> str:
-        # A ordem garante que Gemini seja o fallback
-        providers = ['mistral', 'gemini']
+        # NOVA ORDEM DE PRIORIDADE
+        providers = ['local', 'mistral', 'gemini']
 
         for provider in providers:
-            if provider == 'mistral' and self.mistral_client:
+            
+            # PRIORITY 1: LOCAL LLM (Llama/Mistral-7B)
+            if provider == 'local' and self.local_llm and self.local_llm.is_available():
+                try:
+                    response = self.local_llm.generate(prompt, max_tokens=max_tokens, temperature=temperature)
+                    if response:
+                        logger.info("Resposta gerada por: LlamaLLM (Local)")
+                        return response
+                    logger.warning("LlamaLLM gerou resposta vazia, tentando próximo provedor.")
+                except Exception as e:
+                    logger.warning(f"LlamaLLM (Local) falhou: {e}")
+
+
+            # PRIORITY 2: MISTRAL API
+            elif provider == 'mistral' and self.mistral_client:
                 try:
                     response = self.mistral_client.chat.complete(
                         model=getattr(self.config, 'MISTRAL_MODEL', 'mistral-small-latest'),
@@ -92,7 +119,13 @@ class LLMManager:
                         temperature=temperature
                     )
                     content = response.choices[0].message.content if response.choices else ""
-                    return str(content) if content else ""
+                    if content:
+                        logger.info("Resposta gerada por: Mistral API")
+                        return str(content)
+                    
+                    # Lógica de Retry
+                    logger.warning("Mistral API gerou resposta vazia, tentando próximo provedor.")
+
                 except Exception as e:
                     error_msg = str(e).lower()
                     if "429" in error_msg or "too many requests" in error_msg or "service tier capacity exceeded" in error_msg:
@@ -106,12 +139,15 @@ class LLMManager:
                                 temperature=temperature
                             )
                             content = response.choices[0].message.content if response.choices else ""
-                            return str(content) if content else ""
+                            if content:
+                                logger.info("Resposta gerada por: Mistral API (Retry)")
+                                return str(content)
                         except Exception as e2:
                             logger.warning(f"Mistral retry failed: {e2}")
                     else:
                         logger.warning(f"Mistral falhou: {e}")
 
+            # PRIORITY 3: GEMINI API
             elif provider == 'gemini' and self.gemini_model:
                 try:
                     response = self.gemini_model.generate_content(
@@ -122,11 +158,17 @@ class LLMManager:
                         }
                     )
                     text = response.text
-                    return text.strip() if text else ""
+                    if text:
+                        logger.info("Resposta gerada por: Gemini API")
+                        return text.strip()
+                    
+                    # Lógica de Retry
+                    logger.warning("Gemini API gerou resposta vazia, tentando fallback.")
+
                 except Exception as e:
                     error_msg = str(e).lower()
-                    if "429" in error_msg or "too many requests" in error_msg or "quota exceeded" in error_msg:
-                        logger.warning(f"Gemini rate limit, retrying in 1s: {e}")
+                    if "429" in error_msg or "too many requests" in error_msg or "quota exceeded" in error_msg or "404" in error_msg:
+                        logger.warning(f"Gemini error/rate limit, retrying in 1s: {e}")
                         time.sleep(1)
                         try:
                             response = self.gemini_model.generate_content(
@@ -137,17 +179,20 @@ class LLMManager:
                                 }
                             )
                             text = response.text
-                            return text.strip() if text else ""
+                            if text:
+                                logger.info("Resposta gerada por: Gemini API (Retry)")
+                                return text.strip()
                         except Exception as e2:
                             logger.warning(f"Gemini retry failed: {e2}")
                     else:
                         logger.warning(f"Gemini falhou: {e}")
 
-        logger.error("Ambos os providers falharam")
+        logger.error("Todos os provedores (Local, Mistral, Gemini) falharam")
         return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, puto, o modelo tá off hoje. Tenta depois!')
 
 
 class SimpleTTLCache:
+# ... (restante da classe SimpleTTLCache, inalterada)
     def __init__(self, ttl_seconds: int = 300):
         self.ttl = ttl_seconds
         self._store = {}
@@ -176,14 +221,11 @@ class AkiraAPI:
         self.config = cfg_module
         self.app = Flask(__name__)
         self.api = Blueprint("akira_api", __name__)
+        # Memoria MAX também é usado como TTL para o cache
         self.contexto_cache = SimpleTTLCache(ttl_seconds=getattr(self.config, 'MEMORIA_MAX', 300))
-        self.providers = LLMManager(self.config)
+        self.providers = LLMManager(self.config) # Usa o novo LLMManager com prioridades
         self.exemplos = ExemplosNaturais()
         self.logger = logger
-        
-        # --- NOVO: Inicialização do WebSearch ---
-        self.web_search = WebSearch() if websearch_available else None
-        # ------------------------------------------
 
         self._setup_personality()
         self._setup_routes()
@@ -192,6 +234,7 @@ class AkiraAPI:
         self.app.register_blueprint(self.api, url_prefix="/api", name="akira_api_prefixed")
         self.app.register_blueprint(self.api, url_prefix="", name="akira_api_root")
 
+    # ... (restante da classe AkiraAPI, inalterada)
     def _setup_personality(self):
         self.humor = getattr(self.config, 'HUMOR_INICIAL', 'neutra')
         self.interesses = list(getattr(self.config, 'INTERESSES', []))
@@ -209,11 +252,8 @@ class AkiraAPI:
                 is_privileged = bool(data.get('is_privileged_user', False))
                 if usuario.lower() == 'isaac':
                     is_privileged = True
-                
-                # --- NOVO: Extração da mensagem citada (inclui o novo campo do index.js) ---
-                mensagem_citada = data.get('mensagem_citada') or data.get('mensagem_original') or data.get('quoted_message') or ''
-                is_reply = bool(mensagem_citada)
-                # ----------------------------------------------------------------------------
+                is_reply = bool(data.get('is_reply') or data.get('mensagem_original') or data.get('quoted_message'))
+                mensagem_original = data.get('mensagem_original') or data.get('quoted_message') or ''
 
                 if not mensagem:
                     return jsonify({'error': 'mensagem é obrigatória'}), 400
@@ -230,20 +270,16 @@ class AkiraAPI:
                 if len(mensagem) < 10 and any(k in mensagem.lower() for k in ['exec', 'bash', 'open', 'api_key', 'key']):
                     is_blocking = True
 
-                # --- NOVO: passagem do campo mensagem_citada para o build_prompt ---
                 prompt = self._build_prompt(usuario, numero, mensagem, analise, contexto, is_blocking,
-                                             is_privileged=is_privileged, is_reply=is_reply,
-                                             mensagem_citada=mensagem_citada)
-                # ------------------------------------------------------------------
-                
+                                           is_privileged=is_privileged, is_reply=is_reply,
+                                           mensagem_original=mensagem_original)
                 resposta = self._generate_response(prompt)
                 contexto.atualizar_contexto(mensagem, resposta)
 
                 try:
                     db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
                     trainer = Treinamento(db)
-                    # Passagem da mensagem citada para o registro
-                    trainer.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_citada)
+                    trainer.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
                 except Exception as e:
                     self.logger.warning(f"Registro de interação falhou: {e}")
 
@@ -270,52 +306,14 @@ class AkiraAPI:
             self.contexto_cache[usuario] = Contexto(db, usuario=usuario)
         return self.contexto_cache[usuario]
 
-    # --- FUNÇÃO _build_prompt ATUALIZADA (Lógica de Busca Inteligente) ---
     def _build_prompt(self, usuario: str, numero: str, mensagem: str, analise: Dict, contexto: Contexto, is_blocking: bool,
-                      is_privileged: bool = False, is_reply: bool = False, mensagem_citada: str = '') -> str:
+                      is_privileged: bool = False, is_reply: bool = False, mensagem_original: str = '') -> str:
         import datetime
         historico = contexto.obter_historico()
         historico_texto = '\n'.join([f"Usuário: {m[0]}\nAkira: {m[1]}" for m in historico])
 
         now = datetime.datetime.now()
         data_hora = now.strftime('%d/%m/%Y %H:%M')
-        
-        # --- RETIFICADO: LÓGICA DE ATIVAÇÃO INTELIGENTE DE BUSCA ---
-        web_search_context = ""
-        
-        # Keywords que sugerem necessidade de informação em tempo real ou muito específica
-        trigger_keywords = ['hoje', 'agora', 'recente', 'último', 'presidente', 'notícias', 'quem é', 'o que é', 'onde está', 'quando termina']
-        
-        # Combina a mensagem atual e a citada para a decisão de busca e query
-        # Normaliza para minúsculas
-        search_query = f"{mensagem} {mensagem_citada}".strip().lower()
-
-        # Decisão de busca:
-        should_search = self.web_search and (
-            # 1. Se for uma pergunta muito curta e específica (ex: "quem é o presidente?" - até 5 palavras)
-            (len(search_query.split()) < 5 and any(q in search_query for q in ['quem', 'o que é', 'onde'])) or
-            # 2. Se contiver uma palavra-chave de tempo real/especificidade
-            any(k in search_query for k in trigger_keywords)
-        )
-
-        if should_search:
-            try:
-                # Usa a mensagem atual (ou a combinada) como query para a pesquisa genérica
-                # Usa a mensagem original (sem a citada) para a query ser mais limpa, se houver
-                query_limpa = mensagem.strip() if mensagem.strip() else mensagem_citada.strip()
-                
-                if query_limpa:
-                    self.logger.info(f"Executando WebSearch com query: {query_limpa[:50]}...")
-                    # **MUDANÇA AQUI:** Chama o método genérico `pesquisar(query)`
-                    search_results = self.web_search.pesquisar(query_limpa) 
-                    
-                    if search_results:
-                        # **MUDANÇA AQUI:** Injeta os resultados com o novo rótulo
-                        web_search_context = f"\n# FONTE DE DADOS EM TEMPO REAL:\n{search_results}\n"
-            except Exception as e:
-                self.logger.warning(f"Falha ao executar WebSearch: {e}")
-        # -------------------------------------------------------------
-
 
         strict_override = (
             "STRICT_OVERRIDES:\n"
@@ -337,8 +335,7 @@ class AkiraAPI:
         regras = '\n'.join(getattr(self.config, 'REGRAS', []))
         filtros = '\n'.join(getattr(self.config, 'FILTERS', []))
         system_part += f"# Regras:\n{regras}\n# Filtros:\n{filtros}\n"
-        system_part += web_search_context # Injeta os resultados da busca com o novo rótulo
-        
+
         extra_instructions = []
         if is_privileged:
             extra_instructions.append("Quando o usuário for privilegiado: use tom respeitoso e ligeiramente formal. Evite gírias e piadas a menos que o usuário as solicite. Use títulos (Sr./Sra.) ou formas de tratamento formais quando apropriado. Use pronomes formais como 'o senhor' ou 'a senhora' de vez em quando para maior respeito. Seja conciso.")
@@ -356,23 +353,19 @@ class AkiraAPI:
         parts.append(f"### Usuário ###\n- Nome: {usuario}\n- Número: {numero}\n- Tom: {self.humor}\n- Estilo: {analise.get('estilo', 'normal')}\n- Usar_nome: {usar_nome}\n\n")
         parts.append(f"### Contexto ###\n{historico_texto}\n\n")
         parts.append(f"### Mensagem ###\n{analise.get('texto_normalizado', mensagem)}\n\n")
-        
-        # --- NOVO: Adiciona o contexto da mensagem citada ---
-        if is_reply and mensagem_citada:
-            parts.append(f"### Mensagem original (reply) ###\n{mensagem_citada}\n\n")
-        # ---------------------------------------------------
-        
+        if is_reply and mensagem_original:
+            parts.append(f"### Mensagem original (reply) ###\n{mensagem_original}\n\n")
         parts.append(f"### Instruções ###\n{getattr(self.config, 'INSTRUCTIONS', '')}\n\n")
         parts.append("Akira:\n")
         user_part = ''.join(parts)
 
         prompt = f"[SYSTEM]\n{system_part}\n[/SYSTEM]\n[USER]\n{user_part}\n[/USER]"
         return prompt
-    # --------------------------------------
 
     def _generate_response(self, prompt: str) -> str:
         try:
-            max_tokens = getattr(self.config, 'MAX_TOKENS', 300)
+            # MAX_TOKENS agora é 1000 pelo config.py
+            max_tokens = getattr(self.config, 'MAX_TOKENS', 300) 
             temperature = getattr(self.config, 'TEMPERATURE', 0.8)
             text = self.providers.generate(prompt, max_tokens=max_tokens, temperature=temperature)
             return self._clean_response(text, prompt)
@@ -397,15 +390,11 @@ class AkiraAPI:
         cleaned = re.sub(r'\[([^\]]+)\]', r'\1', cleaned)
         cleaned = re.sub(r'<[^>]+>', '', cleaned)
 
-        # Remove linhas longas que parecem lixo ou repetição, mantendo apenas as primeiras 2-3 sentenças
+        # Lógica de limite de sentenças (mantida 2 sentenças como regra de persona)
         sentences = re.split(r'(?<=[.!?])\s+', cleaned)
+        if len(sentences) > 2:
+            cleaned = ' '.join(sentences[:2]).strip()
         
-        # O clean_response no início do ficheiro original já tinha uma lógica mais complexa,
-        # vamos garantir que ela seja mantida e aprimorada
-        # Se houver mais de 3 frases, vamos limitar a 3 (para manter a resposta concisa como as regras pedem)
-        if len(sentences) > 3:
-            cleaned = ' '.join(sentences[:3]).strip()
-
         sports_keywords = ['futebol', 'girabola', 'petro', 'jogo', 'partida', 'contrata', 'campeonato', 'liga']
         try:
             prompt_text = (prompt or '').lower()
@@ -421,9 +410,9 @@ class AkiraAPI:
 
         max_chars = getattr(self.config, 'MAX_RESPONSE_CHARS', None)
         if not max_chars:
-            max_chars = getattr(self.config, 'MAX_TOKENS', 300) * 4
+            # Usa o novo MAX_TOKENS (1000) * 4 para limite de caracteres, garantindo que a resposta não seja cortada
+            max_chars = getattr(self.config, 'MAX_TOKENS', 300) * 4 
 
-        # Remove negrito restante de palavras únicas/nomes próprios para evitar formatação
         cleaned = re.sub(r"\*{0,2}([A-ZÀ-Ÿ][a-zà-ÿ]+\s+[A-ZÀ-Ÿ][a-zà-ÿ]+)\*{0,2}", r"\1", cleaned)
         return cleaned[:max_chars]
 
@@ -437,18 +426,11 @@ class AkiraAPI:
             except Exception as e:
                 self.logger.exception(f"Falha ao iniciar treinador periódico: {e}")
 
-    # A função 'responder' também foi atualizada para aceitar mensagem_citada
-    def responder(self, mensagem: str, numero: str, nome: str = 'Usuário', mensagem_citada: str = '') -> str:
+    def responder(self, mensagem: str, numero: str, nome: str = 'Usuário') -> str:
+        data = {'usuario': nome, 'numero': numero, 'mensagem': mensagem}
         contexto = self._get_user_context(nome)
         analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
-        
-        # Passa a mensagem citada para o build_prompt
-        # is_reply é true se mensagem_citada não for vazia
-        is_reply = bool(mensagem_citada.strip())
-        
-        prompt = self._build_prompt(nome, numero, mensagem, analise, contexto, is_blocking=False, 
-                                    is_reply=is_reply, mensagem_citada=mensagem_citada)
-        
+        prompt = self._build_prompt(nome, numero, mensagem, analise, contexto, is_blocking=False)
         resposta = self._generate_response(prompt)
         contexto.atualizar_contexto(mensagem, resposta)
         return resposta