Update modules/api.py

modules/api.py

@@ -1,433 +1,191 @@
-"""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
-
-The implementation below avoids depending on missing modules and normalizes
-the config names to the existing `config.py` constants.
-"""
-
-from typing import Dict, Optional, Any
+# modules/api.py
+import os
 import time
-import logging
-import re
-from flask import Flask, Blueprint, request, jsonify
-
-# Importações de módulos locais
-from .contexto import Contexto
-from .database import Database
-from .treinamento import Treinamento
-from .exemplos_naturais import ExemplosNaturais
-
-# Tenta importar provedores de LLM
-try:
-    from .local_llm import LlamaLLM # NOVO: IMPORTAÇÃO DO MODELO LOCAL
-    local_llm_available = True
-except ImportError:
-    local_llm_available = False
-    logging.getLogger("akira.api").warning("LlamaLLM não disponível. Modelo local desabilitado.")
+from typing import Optional, List, Any
+import google.generativeai as genai
+from mistralai.client import MistralClient
+from mistralai.models.chat_models import ChatMessage
+from loguru import logger
 
+# Importa as configurações do seu arquivo config
+from modules import config
 
-try:
-    from mistralai import Mistral
-    mistral_available = True
-except ImportError:
-    mistral_available = False
-    logger = logging.getLogger("akira.api")
-
-
-try:
-    import google.generativeai as genai
-    gemini_available = True
-except ImportError:
-    gemini_available = False
-    logging.getLogger("akira.api").warning("google.generativeai não disponível. Gemini desabilitado.")
+class LLMManager:
+    def __init__(self):
+        self.config = config
+        self.mistral_client: Optional[MistralClient] = None
+        self.gemini_model: Optional[genai.GenerativeModel] = None
+        self.llama_llm = self._import_llama()
 
-logger = logging.getLogger("akira.api")
+        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.
+        self.providers = []
+        
+        # PRIORIDADE 1: Mistral API
+        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 (Se estiver configurado e disponível)
+        if self.llama_llm and self.llama_llm.is_available():
+            self.providers.append('llama') # Isso será sempre FALSO com o novo local_llm.py
 
+        if not self.providers:
+            logger.error("Nenhum provedor de LLM configurado ou operacional. O app responderá apenas com fallback.")
+        else:
+            logger.info(f"Provedores ativos, ordem de prioridade: {self.providers}")
 
-class LLMManager:
-    """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 _import_llama(self):
+        """Importa o LlamaLLM se o arquivo existir."""
+        try:
+            from modules.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}")
+            return None
 
-    def _setup_providers(self):
-        # 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. Passando para API.")
-                else:
-                    logger.info("LlamaLLM (Local/HF) inicializado como primário.")
-            except Exception as e:
-                logger.warning(f"Falha ao inicializar LlamaLLM: {e}. Passando para API.")
-                self.local_llm = None
 
-        # 2. SETUP MISTRAL API (PRIORIDADE 2)
-        # Adicionada verificação de 'm-' para evitar a tentativa de inicialização com chave inválida
-        if mistral_available and getattr(self.config, 'MISTRAL_API_KEY', None) and getattr(self.config, 'MISTRAL_API_KEY', '').startswith('m-'):
+    def _setup_providers(self) -> None:
+        """Inicializa os clientes da API."""
+        
+        # 1. MISTRAL
+        mistral_available = self.config.MISTRAL_API_KEY.startswith('m-')
+        if mistral_available:
             try:
-                self.mistral_client = Mistral(api_key=self.config.MISTRAL_API_KEY)
-                logger.info("Mistral client inicializado.")
+                self.mistral_client = MistralClient(api_key=self.config.MISTRAL_API_KEY)
+                logger.info("Mistral API inicializada.")
             except Exception as e:
-                logger.warning(f"Falha ao inicializar Mistral: {e}")
+                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, como no log).")
 
-        # 3. SETUP GEMINI API (PRIORIDADE 3)
-        if gemini_available and getattr(self.config, 'GEMINI_API_KEY', None):
+        # 2. GEMINI
+        gemini_available = self.config.GEMINI_API_KEY.startswith('AIza')
+        if gemini_available:
             try:
-                self.gemini_model = genai.GenerativeModel(getattr(self.config, 'GEMINI_MODEL', 'gemini-2.5-flash'))
-                logger.info("Gemini model inicializado.")
+                # Inicializa o cliente Gemini. A chave será RE-CONFIGURADA em .generate
+                # para maior robustez, prevenindo o erro de chave perdida.
+                self.gemini_model = genai.GenerativeModel(
+                    model=self.config.GEMINI_MODEL,
+                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT
+                )
+                logger.info(f"Gemini model inicializado: {self.config.GEMINI_MODEL}")
             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:
-        # NOVA ORDEM DE PRIORIDADE: Local -> Mistral API -> Gemini API
-        providers = ['local', 'mistral', 'gemini']
-
-        for provider in providers:
+                logger.warning(f"Falha ao inicializar modelo Gemini: {e}. Desativando Gemini API.")
+                self.gemini_model = None
+        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."""
+        
+        # Formata o prompt para o LLM. As APIs usam ChatMessage/system_instruction.
+        full_system_prompt = self.config.PERSONA + self.config.SYSTEM_PROMPT
+        
+        # Constrói o histórico do chat
+        messages = [
+            ChatMessage(role="system", content=full_system_prompt)
+        ]
+        
+        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: LOCAL LLM
-            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/HF)")
-                        return response
-                    logger.warning("LlamaLLM gerou resposta vazia, tentando próximo provedor.")
-                except Exception as e:
-                    logger.warning(f"LlamaLLM (Local/HF) falhou: {e}. Próximo provedor.")
-
-
-            # PRIORITY 2: MISTRAL API
-            elif provider == 'mistral' and self.mistral_client:
+            # -----------------------------------------------------------
+            # PRIORITY 1: MISTRAL API
+            # -----------------------------------------------------------
+            if provider == 'mistral' and self.mistral_client:
                 try:
-                    response = self.mistral_client.chat.complete(
-                        model=getattr(self.config, 'MISTRAL_MODEL', 'mistral-small-latest'),
-                        messages=[{"role": "user", "content": prompt}],
-                        max_tokens=max_tokens,
-                        temperature=temperature
-                    )
-                    content = response.choices[0].message.content if response.choices else ""
-                    if content:
-                        logger.info("Resposta gerada por: Mistral API")
-                        return str(content)
+                    # Mistral usa seu próprio formato de mensagem/role
+                    mistral_messages = [
+                        ChatMessage(role=msg.role, content=msg.content)
+                        for msg in messages
+                    ]
                     
-                    logger.warning("Mistral API gerou resposta vazia, tentando próximo provedor.")
-
+                    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
+                        max_tokens=self.config.MAX_TOKENS
+                    )
+                    text = response.choices[0].message.content
+                    if text:
+                        logger.info("Resposta gerada por: Mistral API (Principal)")
+                        return text.strip()
                 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:
-                        logger.warning(f"Mistral rate limit, retrying in 1s: {e}")
-                        time.sleep(1)
-                        try:
-                            response = self.mistral_client.chat.complete(
-                                model=getattr(self.config, 'MISTRAL_MODEL', 'mistral-small-latest'),
-                                messages=[{"role": "user", "content": prompt}],
-                                max_tokens=max_tokens,
-                                temperature=temperature
-                            )
-                            content = response.choices[0].message.content if response.choices 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}. Próximo provedor.")
+                    logger.warning(f"Mistral API falhou: {e}. Tentando fallback.")
 
-            # PRIORITY 3: GEMINI API
+            # -----------------------------------------------------------
+            # PRIORITY 2: GEMINI API (FALLBACK)
+            # -----------------------------------------------------------
             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
+                    for msg in messages[1:]:
+                        role = "user" if msg.role == "user" else "model"
+                        gemini_history.append({"role": role, "parts": [msg.content]})
+                        
                     response = self.gemini_model.generate_content(
-                        prompt,
-                        generation_config={
-                            "max_output_tokens": max_tokens,
-                            "temperature": temperature
-                        }
+                        gemini_history,
+                        config={"max_output_tokens": self.config.MAX_TOKENS, "temperature": self.config.TOP_P}
                     )
                     text = response.text
+                    
                     if text:
-                        logger.info("Resposta gerada por: Gemini API")
+                        logger.info("Resposta gerada por: Gemini API (Fallback)")
                         return text.strip()
                     
                     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 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(
-                                prompt,
-                                generation_config={
-                                    "max_output_tokens": max_tokens,
-                                    "temperature": temperature
-                                }
-                            )
-                            text = response.text
-                            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("Todos os provedores (Local, Mistral, Gemini) falharam")
-        return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, puto, o modelo tá off hoje. Tenta depois!')
-
-
-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))
-        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)
-                resposta = self._generate_response(prompt)
-                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}
+                    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 (IGNORADO se local_llm.py estiver vazio)
+            # -----------------------------------------------------------
+            elif provider == 'llama' and self.llama_llm and self.llama_llm.is_available():
                 try:
-                    aprendizados = contexto.obter_aprendizados()
-                    if aprendizados:
-                        response_data['aprendizados'] = aprendizados
+                    # 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")
+                        return local_response
                 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
-        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')
-
-        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)
-
-        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)
-            temperature = getattr(self.config, 'TEMPERATURE', 0.8)
-            text = self.providers.generate(prompt, max_tokens=max_tokens, temperature=temperature)
-            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
-
-        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)
-
-        sentences = re.split(r'(?<=[.!?])\s+', cleaned)
-        if len(sentences) > 2:
-            cleaned = ' '.join(sentences[:2]).strip()
-
-        sports_keywords = ['futebol', 'girabola', 'petro', 'jogo', 'partida', 'contrata', 'campeonato', 'liga']
-        try:
-            prompt_text = (prompt or '').lower()
-            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
-
-        cleaned = re.sub(r"\*{0,2}([A-ZÀ-Ÿ][a-zà-ÿ]+\s+[A-ZÀ-Ÿ][a-zà-ÿ]+)\*{0,2}", r"\1", cleaned)
-        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)
-        resposta = self._generate_response(prompt)
-        contexto.atualizar_contexto(mensagem, resposta)
-        return resposta
+                    logger.warning(f"Llama Local falhou: {e}. Tentando fallback.")
+            
+        logger.error("Todos os provedores (Mistral, Gemini, Local) falharam")
+        return self.config.FALLBACK_RESPONSE