Update modules/api.py

modules/api.py

@@ -1,257 +1,170 @@
-"""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).
 """
-
+API wrapper for Akira service.
+Integração mínima e robusta: config → db → contexto → LLM → resposta.
+"""
 import time
 import re
+import datetime
 from typing import Dict, Optional, Any, List
 from flask import Flask, Blueprint, request, jsonify
+from loguru import logger
 
-# Configurações de LLM e Logging (Loguru substitui o módulo logging padrão)
+# --- LLM PROVIDERS ---
 import google.generativeai as genai
 from mistralai.client import MistralClient
-# ============================================================================
-# CORREÇÃO: O caminho 'mistralai.models.chat_completion' não existe mais.
-# O caminho correto nas versões recentes é 'mistralai.models.chat'.
-from mistralai.models.chat import ChatMessage
-# ============================================================================
-from loguru import logger
+from mistralai.models.chat import ChatMessage  # ← CORRIGIDO: caminho novo
+from .local_llm import LlamaLLM
 
-# Importações de módulos locais
+# --- LOCAL MODULES ---
 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 
+import modules.config as config
 
-# --- LLM MANAGER (NOVO E CORRIGIDO) ---
 
+# --- LLM MANAGER ---
 class LLMManager:
-    """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.config = config_instance
         self.mistral_client: Optional[MistralClient] = None
         self.gemini_model: Optional[genai.GenerativeModel] = None
-        
-        # Tenta importar LlamaLLM. Não depende de exceção na importação inicial.
-        self.llama_llm = self._import_llama() 
-
+        self.llama_llm = self._import_llama()
         self._setup_providers()
-        
-        # Lista de provedores em ordem de prioridade (Mistral > Gemini > Llama)
         self.providers = []
-        
-        # PRIORIDADE 1: Mistral API (Principal)
-        if self.mistral_client:
-            self.providers.append('mistral')
-            
-        # PRIORIDADE 2: Gemini API (Fallback Principal)
-        if self.gemini_model:
-            self.providers.append('gemini')
-            
-        # Prioridade 3: Llama Local
-        if self.llama_llm and self.llama_llm.is_available():
-            self.providers.append('llama') 
-
+        if self.mistral_client: self.providers.append('mistral')
+        if self.gemini_model: self.providers.append('gemini')
+        if self.llama_llm and self.llama_llm.is_available(): self.providers.append('llama')
         if not self.providers:
-            logger.error("Nenhum provedor de LLM configurado ou operacional. O app responderá apenas com fallback.")
+            logger.error("Nenhum provedor LLM ativo.")
         else:
-            logger.info(f"Provedores ativos, ordem de prioridade: {self.providers}")
-
+            logger.info(f"Provedores: {self.providers}")
 
     def _import_llama(self):
-        """Importa o LlamaLLM se o arquivo existir e for funcional."""
         try:
-            from .local_llm import LlamaLLM
-            # O carregamento real é feito dentro de LlamaLLM.__init__
             return LlamaLLM()
-        except Exception as e:
-            # Não faz log de erro se o módulo local não existe ou não está configurado
-            return None
-
+        except: return None
 
-    def _setup_providers(self) -> None:
-        """Inicializa os clientes da API."""
-        
-        # 1. MISTRAL
-        mistral_available = getattr(self.config, 'MISTRAL_API_KEY', '').startswith('m-')
-        if mistral_available:
+    def _setup_providers(self):
+        # MISTRAL
+        if getattr(self.config, 'MISTRAL_API_KEY', '').startswith('m-'):
             try:
                 self.mistral_client = MistralClient(api_key=self.config.MISTRAL_API_KEY)
-                logger.info("Mistral API inicializada.")
+                logger.info("Mistral API OK")
             except Exception as e:
-                logger.warning(f"Falha ao inicializar Mistral Client: {e}. Desativando Mistral API.")
+                logger.warning(f"Mistral falhou: {e}")
                 self.mistral_client = None
         else:
-             logger.warning("Mistral API desativada (chave ausente ou inválida).")
+            logger.warning("Mistral desativado (chave inválida)")
 
-        # 2. GEMINI
-        gemini_available = getattr(self.config, 'GEMINI_API_KEY', '').startswith('AIza')
-        if gemini_available:
+        # GEMINI
+        if getattr(self.config, 'GEMINI_API_KEY', '').startswith('AIza'):
             try:
-                # Inicializa o cliente Gemini. A chave será RE-CONFIGURADA em .generate
                 genai.configure(api_key=self.config.GEMINI_API_KEY)
                 self.gemini_model = genai.GenerativeModel(
                     model=self.config.GEMINI_MODEL,
-                    # 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)"
+                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT + " (NLP/Transformers otimizado)"
                 )
-                logger.info(f"Gemini model inicializado: {self.config.GEMINI_MODEL}")
+                logger.info(f"Gemini OK: {self.config.GEMINI_MODEL}")
             except Exception as e:
-                logger.warning(f"Falha ao inicializar modelo Gemini: {e}. Desativando Gemini API.")
+                logger.warning(f"Gemini falhou: {e}")
                 self.gemini_model = None
         else:
-            logger.warning("Gemini API desativada (chave ausente ou inválida).")
+            logger.warning("Gemini desativado (chave inválida)")
 
-        
     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 (Mistral > Gemini > Llama)."""
-        
-        # Formata o prompt para o LLM. As APIs usam ChatMessage/system_instruction.
-        # 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 em formato Mistral ChatMessage (que é universal)
-        messages: List[ChatMessage] = [
-            ChatMessage(role="system", content=full_system_prompt)
-        ]
-        
+        full_system = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (NLP/Transformers otimizado)"
+        messages = [ChatMessage(role="system", content=full_system)]
         for turn in context_history:
             role = "user" if turn["role"] == "user" else "assistant"
             messages.append(ChatMessage(role=role, content=turn["content"]))
-        
         messages.append(ChatMessage(role="user", content=user_prompt))
 
-        # Tenta provedores na ordem de prioridade
         for provider in self.providers:
-            
-            # -----------------------------------------------------------
-            # PRIORITY 1: MISTRAL API
-            # -----------------------------------------------------------
+            # MISTRAL
             if provider == 'mistral' and self.mistral_client:
                 try:
-                    response = self.mistral_client.chat(
+                    resp = self.mistral_client.chat(
                         model=self.config.MISTRAL_MODEL,
                         messages=messages,
-                        temperature=self.config.TOP_P, 
+                        temperature=self.config.TOP_P,
                         max_tokens=self.config.MAX_TOKENS
                     )
-                    text = response.choices[0].message.content
+                    text = resp.choices[0].message.content
                     if text:
-                        logger.info("Resposta gerada por: Mistral API (Principal)")
+                        logger.info("Mistral respondeu")
                         return text.strip()
                 except Exception as e:
-                    logger.warning(f"Mistral API falhou: {e}. Tentando fallback.")
+                    logger.warning(f"Mistral falhou: {e}")
 
-            # -----------------------------------------------------------
-            # PRIORITY 2: GEMINI API (FALLBACK)
-            # -----------------------------------------------------------
+            # GEMINI
             elif provider == 'gemini' and self.gemini_model:
                 try:
-                    # Gemini usa um formato de histórico que alterna 'user' e 'model'
-                    gemini_history = []
-                    # O primeiro item (system_instruction) já foi passado na inicialização
+                    gemini_hist = []
                     for msg in messages[1:]:
-                        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,
-                        config={"max_output_tokens": self.config.MAX_TOKENS, "temperature": self.config.TOP_P}
+                        role = "user" if msg.role == "user" else "model"
+                        gemini_hist.append({"role": role, "parts": [{"text": msg.content}]})
+                    resp = self.gemini_model.generate_content(
+                        gemini_hist,
+                        generation_config={"max_output_tokens": self.config.MAX_TOKENS, "temperature": self.config.TOP_P}
                     )
-                    text = response.text
-                    
+                    text = resp.text
                     if text:
-                        logger.info("Resposta gerada por: Gemini API (Fallback)")
+                        logger.info("Gemini respondeu")
                         return text.strip()
-                        
-                    logger.warning("Gemini API gerou resposta vazia, tentando fallback.")
-
                 except Exception as e:
-                    error_msg = str(e).lower()
-                    if "no api_key or adc found" in error_msg:
-                         logger.error("Gemini falhou por CHAVE INVÁLIDA/PERDIDA no ponto de uso.")
-                    logger.warning(f"Gemini API falhou: {e}. Tentando fallback.")
-                    
-            # -----------------------------------------------------------
-            # PRIORITY 3: LLAMA LOCAL 
-            # -----------------------------------------------------------
+                    logger.warning(f"Gemini falhou: {e}")
+
+            # LLAMA
             elif provider == 'llama' and self.llama_llm and self.llama_llm.is_available():
                 try:
-                    # A chamada LLAMA é diferente, ela precisa do prompt formatado
-                    local_response = self.llama_llm.generate(
-                        user_prompt, 
-                        max_tokens=self.config.MAX_TOKENS, 
+                    local = 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 (Último Fallback)")
-                        return local_response
+                    if local:
+                        logger.info("Llama respondeu")
+                        return local
                 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
+                    logger.warning(f"Llama falhou: {e}")
 
+        logger.error("Todos os LLMs falharam")
+        return self.config.FALLBACK_RESPONSE
 
-# --- RESTANTE DA CLASSE AKIRAAPI (PRESERVADO) ---
 
+# --- CACHE SIMPLES ---
 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 key not in self._store: return False
+        _, expires = self._store[key]
         if time.time() > expires:
             del self._store[key]
             return False
         return True
-
-    def __setitem__(self, key, value: Any):
+    def __setitem__(self, key, value):
         self._store[key] = (value, time.time() + self.ttl)
-
     def __getitem__(self, key):
-        if key in self:
-            return self._store[key][0]
-        raise KeyError(key)
+        if key not in self: raise KeyError(key)
+        return self._store[key][0]
 
 
+# --- AKIRA API ---
 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.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")
 
@@ -259,7 +172,6 @@ class AkiraAPI:
         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'])
@@ -269,54 +181,45 @@ class AkiraAPI:
                 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_privileged = bool(data.get('is_privileged_user', False)) or usuario.lower() == 'isaac'
                 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]}")
+                    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
-
+                is_blocking = len(mensagem) < 10 and any(k in mensagem.lower() for k in ['exec', 'bash', 'open', 'api_key', 'key'])
                 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)
+                                          is_privileged=is_privileged, is_reply=is_reply, mensagem_original=mensagem_original)
+
+                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}")
+                    self.logger.warning(f"Registro falhou: {e}")
 
-                response_data: Dict[str, Any] = {'resposta': resposta}
+                response_data = {'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}")
+                    self.logger.warning(f"Aprendizados falharam: {e}")
 
                 return jsonify(response_data)
+
             except Exception as e:
-                self.logger.exception('Erro no endpoint /akira')
+                self.logger.exception('Erro no /akira')
                 return jsonify({'resposta': getattr(self.config, 'FALLBACK_RESPONSE', 'Erro interno')}), 500
 
         @self.api.route('/health', methods=['GET'])
@@ -331,133 +234,66 @@ class AkiraAPI:
 
     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:
-        
-        # O histórico raw é mantido para o prompt do 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')
 
-        # As 'STRICT_OVERRIDES' são as instruções principais
         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"
+            "- NÃO use negrito, markdown ou HTML.\n"
+            "- Não quebre linhas desnecessariamente.\n"
+            "- Não repita o usuário.\n"
+            "- Para 'oi', 'olá', responda: 'Oi! Tudo bem?' ou 'Olá! Como vai?'\n"
+            "- Se is_privileged=true: tom formal, evite gírias.\n"
+            f"- Data e hora: {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 = []
+        system_part = strict_override + f"\n{self.config.SYSTEM_PROMPT}\n{self.config.PERSONA}\n"
+        system_part += "\n# Instruções adicionais:\n"
         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.")
+            system_part += "- Tom respeitoso, use Sr./Sra., evite gírias.\n"
         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"
+            system_part += "- Use nome só se fizer sentido. Prefira pronomes.\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"
+            system_part += "\n# BLOQUEIO: Responda com xingamentos (vai pra merda, etc).\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")
+        parts = [
+            f"### Usuário ###\n- Nome: {usuario}\n- Número: {numero}\n- Usar_nome: {usar_nome}\n\n",
+            f"### Contexto ###\n{historico_texto}\n\n",
+            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(f"### Mensagem original ###\n{mensagem_original}\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
+        return f"[SYSTEM]\n{system_part}\n[/SYSTEM]\n[USER]\n{user_part}\n[/USER]"
 
     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
-            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
-            )
+            text = self.providers.generate(prompt, context_history, 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.')
+            self.logger.exception('Falha ao gerar resposta')
+            return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, estou off.')
 
     def _clean_response(self, text: Optional[str], prompt: Optional[str] = None) -> str:
-        if not text:
-            return ''
+        if not text: return ''
         cleaned = text.strip()
-
         for prefix in ['akira:', 'Resposta:', 'resposta:']:
             if cleaned.lower().startswith(prefix.lower()):
                 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)
+        cleaned = re.sub(r'[\*\_`~\[\]<>]', '', cleaned)
         sentences = re.split(r'(?<=[.!?])\s+', cleaned)
-        
-        # A restrição de 2 sentenças não se aplica a usuários privilegiados
         if len(sentences) > 2 and 'is_privileged=true' not in (prompt or ''):
-             # Se for saudação simples, mantém a resposta curta original
-            if not any(k in prompt.lower() for k in ['oi', 'olá', 'akira', 'ola', 'bom dia', 'boa tarde', 'boa noite']) and len(prompt) > 20:
+            if not any(k in prompt.lower() for k in ['oi', 'olá', 'akira']) and len(prompt) > 20:
                 cleaned = ' '.join(sentences[:2]).strip()
-            # Se for privilegiado ou saudação, mantém a resposta completa (ou o LLM decidirá o comprimento)
-            
-        # Filtro de palavras-chave
-        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 = []
-                # Re-divide por sentenças para remover sentenças inteiras sobre o assunto
-                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 # Ignora erros de filtro
-
-        max_chars = getattr(self.config, 'MAX_RESPONSE_CHARS', None)
-        if not max_chars:
-            max_chars = getattr(self.config, 'MAX_TOKENS', 300) * 4
-            
+        max_chars = getattr(self.config, 'MAX_RESPONSE_CHARS', 280)
         return cleaned[:max_chars]
 
     def _setup_trainer(self):
@@ -466,18 +302,15 @@ class AkiraAPI:
                 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.")
+                self.logger.info("Treinamento periódico iniciado.")
             except Exception as e:
-                self.logger.exception(f"Falha ao iniciar treinador periódico: {e}")
+                self.logger.exception(f"Treinador falhou: {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