Update modules/api.py

modules/api.py

@@ -1,30 +1,60 @@
-# modules/api.py
-import os
+"""API wrapper for Akira service.
+
+This module provides a single AkiraAPI class which wires together the
+configuration (modules.config), database, context manager, training and
+LLM providers already present in this repository. The goal is to keep the
+integration layer minimal and robust so `main.py` can create the app with:
+
+    from modules.api import AkiraAPI
+    import modules.config as config
+    akira = AkiraAPI(config)
+    app = akira.app
+
+Atenção: O LLMManager abaixo foi adaptado para usar a Mistral como provedor primário,
+Gemini como fallback, e Llama/Local como última opção. A API da Mistral foi corrigida
+para usar a importação correta do ChatMessage e a ordem de prioridade segue a instrução
+de que as APIs externas são a principal fonte de 'Inteligência' treinada (NLP/Transformers).
+"""
+
 import time
-from typing import Optional, List, Any
+import re
+from typing import Dict, Optional, Any, List
+from flask import Flask, Blueprint, request, jsonify
+
+# Configurações de LLM e Logging (Loguru substitui o módulo logging padrão)
 import google.generativeai as genai
 from mistralai.client import MistralClient
-from mistralai.models.chat_models import ChatMessage
+from mistralai.models.chat_completion import ChatMessage
 from loguru import logger
 
-# Importa as configurações do seu arquivo config
-from modules import config
+# Importações de módulos locais
+from .contexto import Contexto
+from .database import Database
+from .treinamento import Treinamento
+from .exemplos_naturais import ExemplosNaturais
+# Importa o módulo config do pacote (assumindo a estrutura de módulos)
+from . import config 
+
+# --- LLM MANAGER (NOVO E CORRIGIDO) ---
 
 class LLMManager:
-    def __init__(self):
-        self.config = config
+    """Gerenciador de provedores LLM (Mistral -> Gemini -> Llama/Local como fallback)."""
+    
+    def __init__(self, config_instance):
+        # Usa a instância de configuração passada pela AkiraAPI
+        self.config = config_instance 
         self.mistral_client: Optional[MistralClient] = None
         self.gemini_model: Optional[genai.GenerativeModel] = None
-        self.llama_llm = self._import_llama()
+        
+        # Tenta importar LlamaLLM. Não depende de exceção na importação inicial.
+        self.llama_llm = self._import_llama() 
 
         self._setup_providers()
         
-        # Lista de provedores em ordem de prioridade (Mistral > Gemini)
-        # O LlamaLLM (local) será adicionado se for importado e disponível, 
-        # mas como esvaziamos o local_llm.py, ele será pulado.
+        # Lista de provedores em ordem de prioridade (Mistral > Gemini > Llama)
         self.providers = []
         
-        # PRIORIDADE 1: Mistral API
+        # PRIORIDADE 1: Mistral API (Principal)
         if self.mistral_client:
             self.providers.append('mistral')
             
@@ -32,9 +62,9 @@ class LLMManager:
         if self.gemini_model:
             self.providers.append('gemini')
             
-        # Prioridade 3: Llama Local (Se estiver configurado e disponível)
+        # Prioridade 3: Llama Local
         if self.llama_llm and self.llama_llm.is_available():
-            self.providers.append('llama') # Isso será sempre FALSO com o novo local_llm.py
+            self.providers.append('llama') 
 
         if not self.providers:
             logger.error("Nenhum provedor de LLM configurado ou operacional. O app responderá apenas com fallback.")
@@ -43,13 +73,13 @@ class LLMManager:
 
 
     def _import_llama(self):
-        """Importa o LlamaLLM se o arquivo existir."""
+        """Importa o LlamaLLM se o arquivo existir e for funcional."""
         try:
-            from modules.local_llm import LlamaLLM
+            from .local_llm import LlamaLLM
             # O carregamento real é feito dentro de LlamaLLM.__init__
             return LlamaLLM()
         except Exception as e:
-            logger.warning(f"Falha ao importar LlamaLLM (módulo ausente ou erro de importação): {e}")
+            # Não faz log de erro se o módulo local não existe ou não está configurado
             return None
 
 
@@ -57,7 +87,7 @@ class LLMManager:
         """Inicializa os clientes da API."""
         
         # 1. MISTRAL
-        mistral_available = self.config.MISTRAL_API_KEY.startswith('m-')
+        mistral_available = getattr(self.config, 'MISTRAL_API_KEY', '').startswith('m-')
         if mistral_available:
             try:
                 self.mistral_client = MistralClient(api_key=self.config.MISTRAL_API_KEY)
@@ -66,17 +96,18 @@ class LLMManager:
                 logger.warning(f"Falha ao inicializar Mistral Client: {e}. Desativando Mistral API.")
                 self.mistral_client = None
         else:
-             logger.warning("Mistral API desativada (chave ausente ou inválida, como no log).")
+             logger.warning("Mistral API desativada (chave ausente ou inválida).")
 
         # 2. GEMINI
-        gemini_available = self.config.GEMINI_API_KEY.startswith('AIza')
+        gemini_available = getattr(self.config, 'GEMINI_API_KEY', '').startswith('AIza')
         if gemini_available:
             try:
                 # Inicializa o cliente Gemini. A chave será RE-CONFIGURADA em .generate
-                # para maior robustez, prevenindo o erro de chave perdida.
+                genai.configure(api_key=self.config.GEMINI_API_KEY)
                 self.gemini_model = genai.GenerativeModel(
                     model=self.config.GEMINI_MODEL,
-                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT
+                    # Adiciona uma nota conceitual sobre o treino NLP/Transformers na system_instruction
+                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT + " (Modelo otimizado com técnicas de NLP/Transformers)"
                 )
                 logger.info(f"Gemini model inicializado: {self.config.GEMINI_MODEL}")
             except Exception as e:
@@ -85,19 +116,16 @@ class LLMManager:
         else:
             logger.warning("Gemini API desativada (chave ausente ou inválida).")
 
-        # 3. LLAMA LOCAL
-        # O LlamaLLM já é importado e carregado em self.llama_llm, o que permite o 
-        # teste de disponibilidade no self.providers.
-
         
     def generate(self, user_prompt: str, context_history: List[dict] = [], is_privileged: bool = False) -> str:
-        """Gera a resposta, iterando pelos provedores na ordem de prioridade."""
+        """Gera a resposta, iterando pelos provedores na ordem de prioridade (Mistral > Gemini > Llama)."""
         
         # Formata o prompt para o LLM. As APIs usam ChatMessage/system_instruction.
-        full_system_prompt = self.config.PERSONA + self.config.SYSTEM_PROMPT
+        # Inclui a nota sobre otimização NLP/Transformers
+        full_system_prompt = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (Modelo otimizado com técnicas de NLP/Transformers)"
         
-        # Constrói o histórico do chat
-        messages = [
+        # Constrói o histórico do chat em formato Mistral ChatMessage (que é universal)
+        messages: List[ChatMessage] = [
             ChatMessage(role="system", content=full_system_prompt)
         ]
         
@@ -115,16 +143,10 @@ class LLMManager:
             # -----------------------------------------------------------
             if provider == 'mistral' and self.mistral_client:
                 try:
-                    # Mistral usa seu próprio formato de mensagem/role
-                    mistral_messages = [
-                        ChatMessage(role=msg.role, content=msg.content)
-                        for msg in messages
-                    ]
-                    
                     response = self.mistral_client.chat(
                         model=self.config.MISTRAL_MODEL,
-                        messages=mistral_messages,
-                        temperature=self.config.TOP_P, # Mistral usa TOP_P para o temperature
+                        messages=messages,
+                        temperature=self.config.TOP_P, 
                         max_tokens=self.config.MAX_TOKENS
                     )
                     text = response.choices[0].message.content
@@ -139,17 +161,12 @@ class LLMManager:
             # -----------------------------------------------------------
             elif provider == 'gemini' and self.gemini_model:
                 try:
-                    # **SOLUÇÃO CRÍTICA**: Reconfigura a chave ANTES de chamar generate_content
-                    # Isso previne o erro de 'No API_KEY or ADC found'
-                    if self.config.GEMINI_API_KEY.startswith('AIza'):
-                         genai.configure(api_key=self.config.GEMINI_API_KEY)
-
                     # Gemini usa um formato de histórico que alterna 'user' e 'model'
                     gemini_history = []
-                    # O primeiro item é o system_instruction, que é passado na inicialização
+                    # O primeiro item (system_instruction) já foi passado na inicialização
                     for msg in messages[1:]:
-                        role = "user" if msg.role == "user" else "model"
-                        gemini_history.append({"role": role, "parts": [msg.content]})
+                        role = "user" if msg.role == "user" else "model" 
+                        gemini_history.append({"role": role, "parts": [{"text": msg.content}]})
                         
                     response = self.gemini_model.generate_content(
                         gemini_history,
@@ -160,7 +177,7 @@ class LLMManager:
                     if text:
                         logger.info("Resposta gerada por: Gemini API (Fallback)")
                         return text.strip()
-                    
+                        
                     logger.warning("Gemini API gerou resposta vazia, tentando fallback.")
 
                 except Exception as e:
@@ -170,22 +187,289 @@ class LLMManager:
                     logger.warning(f"Gemini API falhou: {e}. Tentando fallback.")
                     
             # -----------------------------------------------------------
-            # PRIORITY 3: LLAMA LOCAL (IGNORADO se local_llm.py estiver vazio)
+            # PRIORITY 3: LLAMA LOCAL 
             # -----------------------------------------------------------
             elif provider == 'llama' and self.llama_llm and self.llama_llm.is_available():
                 try:
                     # A chamada LLAMA é diferente, ela precisa do prompt formatado
-                    # Passar o prompt bruto aqui e o local_llm.py fará a formatação
                     local_response = self.llama_llm.generate(
                         user_prompt, 
                         max_tokens=self.config.MAX_TOKENS, 
                         temperature=self.config.TOP_P
                     )
                     if local_response:
-                        logger.info("Resposta gerada por: Llama 3.1 Local")
+                        logger.info("Resposta gerada por: Llama 3.1 Local (Último Fallback)")
                         return local_response
                 except Exception as e:
                     logger.warning(f"Llama Local falhou: {e}. Tentando fallback.")
             
         logger.error("Todos os provedores (Mistral, Gemini, Local) falharam")
-        return self.config.FALLBACK_RESPONSE
+        return self.config.FALLBACK_RESPONSE
+
+
+# --- RESTANTE DA CLASSE AKIRAAPI (PRESERVADO) ---
+
+class SimpleTTLCache:
+    def __init__(self, ttl_seconds: int = 300):
+        self.ttl = ttl_seconds
+        self._store = {}
+
+    def __contains__(self, key):
+        v = self._store.get(key)
+        if not v:
+            return False
+        value, expires = v
+        if time.time() > expires:
+            del self._store[key]
+            return False
+        return True
+
+    def __setitem__(self, key, value: Any):
+        self._store[key] = (value, time.time() + self.ttl)
+
+    def __getitem__(self, key):
+        if key in self:
+            return self._store[key][0]
+        raise KeyError(key)
+
+
+class AkiraAPI:
+    def __init__(self, cfg_module):
+        self.config = cfg_module
+        self.app = Flask(__name__)
+        self.api = Blueprint("akira_api", __name__)
+        self.contexto_cache = SimpleTTLCache(ttl_seconds=getattr(self.config, 'MEMORIA_MAX', 300))
+        # Passa a instância de config para o LLMManager
+        self.providers = LLMManager(self.config) 
+        self.exemplos = ExemplosNaturais()
+        self.logger = logger
+
+        self._setup_personality()
+        self._setup_routes()
+        self._setup_trainer()
+
+        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")
+
+    def _setup_personality(self):
+        self.humor = getattr(self.config, 'HUMOR_INICIAL', 'neutra')
+        self.interesses = list(getattr(self.config, 'INTERESSES', []))
+        self.limites = list(getattr(self.config, 'LIMITES', []))
+        self.persona = getattr(self.config, 'PERSONA', '')
+
+    def _setup_routes(self):
+        @self.api.route('/akira', methods=['POST'])
+        def akira_endpoint():
+            try:
+                data = request.get_json(force=True, silent=True) or {}
+                usuario = data.get('usuario', 'anonimo')
+                numero = data.get('numero', '')
+                mensagem = data.get('mensagem', '')
+                is_privileged = bool(data.get('is_privileged_user', False))
+                if usuario.lower() == 'isaac':
+                    is_privileged = True
+                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
+
+                
+                self.logger.info(f"📨 {usuario} ({numero}): {mensagem[:120]}")
+
+                contexto = self._get_user_context(usuario)
+                analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
+                if usuario.lower() == 'isaac':
+                    analise['usar_nome'] = False
+
+                is_blocking = False
+                if len(mensagem) < 10 and any(k in mensagem.lower() for k in ['exec', 'bash', 'open', 'api_key', 'key']):
+                    is_blocking = True
+
+                prompt = self._build_prompt(usuario, numero, mensagem, analise, contexto, is_blocking,
+                                             is_privileged=is_privileged, is_reply=is_reply,
+                                             mensagem_original=mensagem_original)
+                
+                # O novo _generate_response usa a nova assinatura do LLMManager.generate
+                resposta = self._generate_response(prompt, contexto.obter_historico_para_llm(), is_privileged) 
+                
+                contexto.atualizar_contexto(mensagem, resposta)
+
+                try:
+                    db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
+                    trainer = Treinamento(db)
+                    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}")
+
+                response_data: Dict[str, Any] = {'resposta': resposta}
+                try:
+                    aprendizados = contexto.obter_aprendizados()
+                    if aprendizados:
+                        response_data['aprendizados'] = aprendizados
+                except Exception as e:
+                    self.logger.warning(f"Falha ao obter aprendizados: {e}")
+
+                return jsonify(response_data)
+            except Exception as e:
+                self.logger.exception('Erro no endpoint /akira')
+                return jsonify({'resposta': getattr(self.config, 'FALLBACK_RESPONSE', 'Erro interno')}), 500
+
+        @self.api.route('/health', methods=['GET'])
+        def health_check():
+            return 'OK', 200
+
+    def _get_user_context(self, usuario: str) -> Contexto:
+        if usuario not in self.contexto_cache:
+            db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
+            self.contexto_cache[usuario] = Contexto(db, usuario=usuario)
+        return self.contexto_cache[usuario]
+
+    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_original: str = '') -> str:
+        import datetime
+        # REMOVIDO: A obtenção do histórico do contexto aqui, pois agora é passado
+        # diretamente para o LLMManager no formato de chat, não como texto no prompt.
+        # No entanto, a lógica abaixo é para o LLM local, então manteremos para Llama/Local.
+        
+        historico_raw = contexto.obter_historico()
+        historico_texto = '\n'.join([f"Usuário: {m[0]}\nAkira: {m[1]}" for m in historico_raw])
+
+        now = datetime.datetime.now()
+        data_hora = now.strftime('%d/%m/%Y %H:%M')
+
+        strict_override = (
+            "STRICT_OVERRIDES:\n"
+            "- NUNCA invente fatos ou mencione eventos/pessoas não presentes no contexto.\n"
+            "- NÃO use negrito, markdown ou HTML. Remova quaisquer formatações.\n"
+            "- Não quebre linhas desnecessariamente; mantenha respostas em parágrafos contínuos para parecer mais natural e menos robótico.\n"
+            "- Não repita o que o usuário disse; responda de forma original e relevante, sem copiar frases do usuário.\n"
+            "- Para saudações simples como 'oi', 'olá', 'akira', responda de forma conversacional perguntando como o usuário está, por exemplo 'Oi! Tudo bem com você?' ou 'Olá! Como vai?'.\n"
+            "- Se is_privileged=true: use tom respeitoso/mais formal; evite gírias; use pronomes formais como 'o senhor' ou 'a senhora'.\n"
+            "- Não introduza tópicos como futebol/partidas a menos que o usuário ou o contexto peça.\n"
+            "- Use linguagem natural, criativa e autônoma, como se fosse uma pessoa real, não um robô.\n"
+            "- Demonstre autonomia, personalidade e senso crítico.\n"
+            "- Considere o contexto, a data e hora atuais.\n"
+            f"- Data e hora atuais: {data_hora}.\n"
+            f"- Número do bot: 244952786417.\n"
+        )
+
+        system_part = strict_override + f"\n{getattr(self.config, 'SYSTEM_PROMPT', '')}\n{self.persona}\n"
+        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"
+
+        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.")
+        else:
+            extra_instructions.append("Mantenha a persona local quando apropriado, mas NÃO comece com textos longos. Para saudações simples, responda com uma frase curta ou até 2 frases no máximo. Use o nome do usuário apenas quando fizer sentido. Prefira pronomes para evitar repetição.")
+
+        extra_instructions.append("Não invente fatos, não mencione resultados de jogos, pessoas ou eventos que não estão no contexto. Não use negrito/markdown (**, __) nem formatação HTML por padrão. Evite mensagens muito longas; seja direto.")
+        system_part += "\n# Instruções adicionais:\n" + "\n".join(extra_instructions) + "\n"
+
+        if is_blocking:
+            system_part += "\n# BLOQUEIO: usuário possivelmente malicioso. Responda recusando a executar comandos sensíveis, com xingamentos como (vai pra merda, sou tua serva por acaso?, vai tomar no cu).\n"
+
+        usar_nome = analise.get('usar_nome', False)
+        parts = []
+        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")
+        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)
+
+        # O prompt completo é construído aqui, principalmente para ser usado pelo LLAMA/Local
+        # e como fallback no caso de falha da API
+        prompt = f"[SYSTEM]\n{system_part}\n[/SYSTEM]\n[USER]\n{user_part}\n[/USER]"
+        return prompt
+
+    def _generate_response(self, prompt: str, context_history: List[Dict], is_privileged: bool = False) -> str:
+        """
+        Gera a resposta. Para Mistral/Gemini, o histórico é passado separadamente.
+        Para Llama/Local, o 'prompt' completo é usado.
+        """
+        try:
+            max_tokens = getattr(self.config, 'MAX_TOKENS', 300)
+            temperature = getattr(self.config, 'TEMPERATURE', 0.8)
+            
+            # Chama o novo LLMManager.generate, passando o histórico e o prompt (que pode ser ignorado por APIs externas)
+            text = self.providers.generate(
+                user_prompt=prompt, # Usa o prompt completo, que o LLMManager.generate sabe como extrair a mensagem final
+                context_history=context_history,
+                is_privileged=is_privileged
+            )
+            return self._clean_response(text, prompt)
+        except Exception as e:
+            self.logger.exception('Falha ao gerar resposta com provedores LLM')
+            return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, o modelo está off.')
+
+    def _clean_response(self, text: Optional[str], prompt: Optional[str] = None) -> str:
+        if not text:
+            return ''
+        cleaned = text.strip()
+
+        for prefix in ['akira:', 'Resposta:', 'resposta:']:
+            if cleaned.startswith(prefix):
+                cleaned = cleaned[len(prefix):].strip()
+                break
+
+        # Remove formatação de Markdown/HTML (forte restrição)
+        cleaned = re.sub(r'\*+([^*]+)\*+', r'\1', cleaned)
+        cleaned = re.sub(r'_+([^_]+)_+', r'\1', cleaned)
+        cleaned = re.sub(r'`+([^`]+)`+', r'\1', cleaned)
+        cleaned = re.sub(r'~+([^~]+)~+', r'\1', cleaned)
+        cleaned = re.sub(r'\[([^\]]+)\]', r'\1', cleaned)
+        cleaned = re.sub(r'<[^>]+>', '', cleaned)
+        cleaned = re.sub(r"\*{0,2}([A-ZÀ-Ÿ][a-zà-ÿ]+\s+[A-ZÀ-Ÿ][a-zà-ÿ]+)\*{0,2}", r"\1", cleaned)
+
+        # Restrição de comprimento (máximo de 2 sentenças)
+        sentences = re.split(r'(?<=[.!?])\s+', cleaned)
+        if len(sentences) > 2 and 'is_privileged=true' not in (prompt or ''):
+            cleaned = ' '.join(sentences[:2]).strip()
+
+        # Filtro de palavras-chave (mantido da versão original)
+        sports_keywords = ['futebol', 'girabola', 'petro', 'jogo', 'partida', 'contrata', 'campeonato', 'liga']
+        try:
+            prompt_text = (prompt or '').lower()
+            # Só filtra se o prompt original NÃO mencionou palavras-chave de esporte
+            if prompt_text and not any(k in prompt_text for k in sports_keywords):
+                filtered = []
+                for s in re.split(r'(?<=[\.\!\?])\s+', cleaned):
+                    if not any(k in s.lower() for k in sports_keywords):
+                        filtered.append(s)
+                if filtered:
+                    cleaned = ' '.join(filtered).strip()
+        except Exception:
+            pass
+
+        max_chars = getattr(self.config, 'MAX_RESPONSE_CHARS', None)
+        if not max_chars:
+            max_chars = getattr(self.config, 'MAX_TOKENS', 300) * 4
+        
+        return cleaned[:max_chars]
+
+    def _setup_trainer(self):
+        if getattr(self.config, 'START_PERIODIC_TRAINER', False):
+            try:
+                db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
+                trainer = Treinamento(db, interval_hours=getattr(self.config, 'TRAIN_INTERVAL_HOURS', 24))
+                trainer.start_periodic_training()
+                self.logger.info("Treinamento periódico iniciado com sucesso.")
+            except Exception as e:
+                self.logger.exception(f"Falha ao iniciar treinador periódico: {e}")
+
+    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())
+        prompt = self._build_prompt(nome, numero, mensagem, analise, contexto, is_blocking=False)
+        
+        # Chama a nova assinatura de generate
+        resposta = self._generate_response(prompt, contexto.obter_historico_para_llm())
+        
+        contexto.atualizar_contexto(mensagem, resposta)
+        return resposta