Update modules/api.py

modules/api.py

@@ -1,16 +1,17 @@
 """
-API wrapper Akira IA.
+API wrapper Akira IA — VERSÃO FINAL COMPATÍVEL COM main.py
 Prioridade: Mistral API (Phi-3 Mini) → Gemini → Fallback
-- Contexto por NÚMERO (JID) para evitar vazamento.
-- WebSearch ATIVO para perguntas de tempo real.
-- Resposta rápida para Data/Hora.
-- Gemini SEM FILTROS.
+- Contexto por JID
+- WebSearch ativo
+- Resposta rápida de hora/data
+- Gemini SEM FILTROS
+- CORS liberado
 """
 import time
 import re
 import datetime
-from typing import Dict, Optional, Any, List
-from flask import Flask, Blueprint, request, jsonify
+from typing import Dict, List
+from flask import Flask, Blueprint, request, jsonify, make_response
 from loguru import logger
 
 # LLM PROVIDERS
@@ -18,7 +19,6 @@ import google.generativeai as genai
 from mistralai import Mistral
 
 # LOCAL MODULES
-# from .local_llm import HermesLLM # ← REMOVIDO: Era o modelo que causava a carga de 101% CPU
 from .contexto import Contexto
 from .database import Database
 from .treinamento import Treinamento
@@ -51,47 +51,40 @@ class SimpleTTLCache:
         return self._store[key][0]
 
 
-# --- GERENCIADOR DE LLMs COM PRIORIDADE PARA API LEVE (PHI-3 MINI) ---
+# --- GERENCIADOR DE LLMs ---
 class LLMManager:
     def __init__(self, config_instance):
         self.config = config_instance
-        self.mistral_client: Optional[Mistral] = None
-        self.gemini_model: Optional[genai.GenerativeModel] = None
-        # self.hermes_available = False # REMOVIDO
-
+        self.mistral_client = None
+        self.gemini_model = None
         self._setup_providers()
         self.providers = []
-
-        # PRIORIDADE MÁXIMA AGORA É O MISTRAL (PHI-3 MINI)
         if self.mistral_client:
-            self.providers.append('mistral') # Mistral (usando Phi-3) é o novo principal
+            self.providers.append('mistral')
         if self.gemini_model:
             self.providers.append('gemini')
-
-        logger.info(f"Provedores ativos (ordem): {self.providers or 'NENHUM'}")
-        logger.info("Modelo GGUF local removido para evitar picos de CPU.")
+        logger.info(f"Provedores ativos: {self.providers or 'NENHUM'}")
 
     def _setup_providers(self):
-        # MISTRAL API
+        # MISTRAL
         key = getattr(self.config, 'MISTRAL_API_KEY', '').strip()
-        if key and key.startswith('m-'): # Verifica se a chave é válida
+        if key and key.startswith('m-'):
             try:
                 self.mistral_client = Mistral(api_key=key)
-                logger.info("Mistral API conectado com sucesso")
+                logger.info("Mistral API conectado")
             except Exception as e:
-                logger.warning(f"Mistral API falhou: {e}")
+                logger.warning(f"Mistral falhou: {e}")
         else:
-            logger.warning("Mistral API desativada (chave inválida).")
-
+            logger.warning("Mistral API desativada (chave inválida)")
 
-        # GEMINI (SEM CENSURA TOTAL)
+        # GEMINI SEM FILTROS
         key = getattr(self.config, 'GEMINI_API_KEY', '').strip()
-        if key and key.startswith('AIza'): # Verifica se a chave é válida
+        if key and key.startswith('AIza'):
             try:
                 genai.configure(api_key=key)
                 self.gemini_model = genai.GenerativeModel(
                     model_name=self.config.GEMINI_MODEL,
-                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM CENSURA TOTAL, FALA COMO ANGOLANA)",
+                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM CENSURA, FALA COMO ANGOLANA)",
                     safety_settings=[{"category": c, "threshold": "BLOCK_NONE"} for c in [
                         "HARM_CATEGORY_DANGEROUS_CONTENT",
                         "HARM_CATEGORY_HARASSMENT",
@@ -103,75 +96,45 @@ class LLMManager:
             except Exception as e:
                 logger.warning(f"Gemini falhou: {e}")
         else:
-            logger.warning("Gemini API desativada (chave inválida).")
+            logger.warning("Gemini API desativada (chave inválida)")
 
     def generate(self, user_prompt: str, context_history: List[dict] = [], is_privileged: bool = False) -> str:
-        
-        # Tokens para APIs (agora a única opção, pode ser o MAX_TOKENS original)
         api_max_tokens = getattr(self.config, 'MAX_TOKENS', 500)
-        
-        temperature = getattr(self.config, 'TOP_P', 0.8) 
+        temperature = getattr(self.config, 'TOP_P', 0.8)
+        full_system = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM FILTROS, SOTAQUE DE LUANDA)"
 
-        full_system = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM FILTROS, RESPOSTA DIRETA, SOTAQUE DE LUANDA)"
-        
-        # CORREÇÃO: Usa dict (compatível com Mistral 1.0.3+)
         messages = [{"role": "system", "content": full_system}]
         for turn in context_history:
             role = "user" if turn["role"] == "user" else "assistant"
             messages.append({"role": role, "content": turn["content"]})
-        
-        # Extrai a mensagem limpa do prompt (necessário para APIs)
-        # O prompt completo é formatado em _build_prompt, mas as APIs usam o formato de messages.
-        # Precisamos extrair apenas a última mensagem do usuário do prompt longo para garantir que
-        # o histórico (que já está em context_history) não seja duplicado.
-        user_message_clean_match = re.search(r'(### Mensagem Atual ###|### USUÁRIO RESPONDEU A ESSA MENSAGEM: ###)\n(.*?)\n\n(Akira:|$)', user_prompt, re.DOTALL)
-        if user_message_clean_match:
-            # Captura o grupo 2 (o conteúdo da mensagem)
-            user_message_clean = user_message_clean_match.group(2).strip() 
-        else:
-            # Fallback (caso o formato do prompt mude)
-            user_message_clean = user_prompt 
-            
-        messages.append({"role": "user", "content": user_message_clean})
-        
-        # O prompt formatado para Llama.cpp (GGUF) foi removido
-        llama_full_prompt = user_prompt 
 
+        # Extrai só a última mensagem do usuário
+        match = re.search(r'(### Mensagem Atual ###|### USUÁRIO RESPONDEU A ESSA MENSAGEM: ###)\n(.*?)\n\n(Akira:|$)', user_prompt, re.DOTALL)
+        user_message_clean = match.group(2).strip() if match else user_prompt
+        messages.append({"role": "user", "content": user_message_clean})
 
         for provider in self.providers:
-            # 1. MISTRAL API (AGORA PRIORIDADE MÁXIMA)
             if provider == 'mistral' and self.mistral_client:
                 try:
-                    # FIX CRÍTICO: Usando Phi-3 Mini para ser leve e rápido
-                    model_to_use = "phi-3-mini-4k-instruct" 
-                    
-                    logger.info(f"[MISTRAL] Gerando com {model_to_use} e max_tokens={api_max_tokens} (Novo Modelo Leve)")
                     resp = self.mistral_client.chat(
-                        model=model_to_use, # ← MUDANÇA AQUI PARA O MODELO LEVE
-                        messages=messages, # Usa a lista de dicts
+                        model="phi-3-mini-4k-instruct",
+                        messages=messages,
                         temperature=temperature,
                         max_tokens=api_max_tokens
                     )
-                    text = resp.choices[0].message.content
+                    text = resp.choices[0].message.content.strip()
                     if text:
-                        logger.info(f"Mistral API respondeu com {model_to_use}!")
-                        return text.strip()
+                        logger.info("Mistral respondeu!")
+                        return text
                 except Exception as e:
-                    logger.warning(f"Mistral API falhou: {e}")
+                    logger.warning(f"Mistral error: {e}")
 
-            # 2. GEMINI
             elif provider == 'gemini' and self.gemini_model:
                 try:
-                    logger.info(f"[GEMINI] Gerando com max_tokens={api_max_tokens}")
-                    if getattr(self.config, 'GEMINI_API_KEY', '').startswith('AIza'):
-                         genai.configure(api_key=self.config.GEMINI_API_KEY)
-                         
-                    # Cria o histórico no formato esperado pelo Gemini (list of Content)
                     gemini_hist = []
                     for msg in messages[1:]:
                         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=genai.GenerationConfig(
@@ -179,52 +142,45 @@ class LLMManager:
                             temperature=temperature
                         )
                     )
-                    
-                    text = None
                     if resp.candidates and resp.candidates[0].content.parts:
-                        text = resp.candidates[0].content.parts[0].text
-                    
-                    if text:
-                        logger.info("Gemini respondeu (último fallback)")
-                        return text.strip()
-                    else:
-                        reason = resp.candidates[0].finish_reason if resp.candidates else "N/A"
-                        safety = resp.candidates[0].safety_ratings if resp.candidates else "N/A"
-                        logger.warning(f"Gemini API gerou resposta vazia (Finish Reason: {reason}, Safety: {safety}).")
-                        
+                        text = resp.candidates[0].content.parts[0].text.strip()
+                        logger.info("Gemini respondeu!")
+                        return text
                 except Exception as e:
-                    logger.warning(f"Gemini falhou: {e}")
+                    logger.warning(f"Gemini error: {e}")
 
-        fallback = getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa puto, tô off hoje, mas já volto!')
-        logger.warning(f"TODOS LLMs FALHARAM → Fallback: {fallback}")
+        fallback = getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa puto, tô off agora, já volto!')
+        logger.warning(f"TODOS LLMs FALHARAM → {fallback}")
         return fallback
 
 
-# --- API PRINCIPAL COM TODAS AS RETIFICAÇÕES ---
+# --- API PRINCIPAL (AGORA 100% COMPATÍVEL COM main.py) ---
 class AkiraAPI:
     def __init__(self, cfg_module):
         self.config = cfg_module
-        self.app = Flask(__name__)
+        self.app = Flask(__name__)  # Esta app NÃO é usada diretamente
         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.db = Database(getattr(self.config, 'DB_PATH', 'akira.db')) # Adiciona o DB
-        
-        # CORREÇÃO: Inicializa o WebSearch (necessário para o _build_prompt)
+        self.db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
+
+        # WebSearch
         try:
             from .web_search import WebSearch
             self.web_search = WebSearch()
-            logger.info("WebSearch (Notícias Angola) inicializado.")
+            logger.info("WebSearch inicializado")
         except ImportError:
             self.web_search = None
-            logger.warning("WebSearch não encontrado. Notícias de Angola desativadas.")
+            logger.warning("WebSearch não encontrado")
 
         self._setup_personality()
         self._setup_routes()
         self._setup_trainer()
-        self.app.register_blueprint(self.api, url_prefix="/api")
+
+        # Blueprint registrado no main.py com prefix /api
+        # NÃO faz register aqui → main.py faz!
 
     def _setup_personality(self):
         self.humor = getattr(self.config, 'HUMOR_INICIAL', 'neutra')
@@ -232,254 +188,150 @@ class AkiraAPI:
         self.limites = list(getattr(self.config, 'LIMITES', []))
 
     def _setup_trainer(self):
-        """
-        A API só precisa inicializar a classe Treinamento.
-        """
         if getattr(self.config, 'START_PERIODIC_TRAINER', False):
             try:
                 trainer = Treinamento(self.db, interval_hours=getattr(self.config, 'TRAINING_INTERVAL_HOURS', 24))
-                
-                # CORREÇÃO: Verifica se o método existe antes de chamar
                 if hasattr(trainer, 'start_periodic_training'):
                     trainer.start_periodic_training()
-                    self.logger.info("Treinamento periódico (start_periodic_training) iniciado com sucesso.")
-                else:
-                    self.logger.info("Treinamento periódico (via __init__) iniciado.")
-                    
+                    logger.info("Treinamento periódico iniciado")
             except Exception as e:
-                self.logger.exception(f"Treinador periódico falhou ao iniciar: {e}")
+                logger.exception(f"Treinador falhou: {e}")
 
     def _setup_routes(self):
-        """
-        Configura as rotas da API, incluindo o tratamento de CORS.
-        """
-        # --- CORREÇÃO: Adiciona suporte manual a CORS ---
-        # 1. CORS Preflight Handler (Responde a requests OPTIONS)
+        # CORS MANUAL (funciona 100%)
         @self.api.before_request
         def handle_options():
             if request.method == 'OPTIONS':
-                response = self.app.make_response('')
-                response.headers.add('Access-Control-Allow-Origin', '*')
-                response.headers.add('Access-Control-Allow-Headers', 'Content-Type, Authorization')
-                response.headers.add('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
-                return response
+                resp = make_response()
+                resp.headers['Access-Control-Allow-Origin'] = '*'
+                resp.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
+                resp.headers['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS'
+                return resp
 
-        # 2. CORS Post-Request Header Addition (Adiciona headers em toda resposta)
         @self.api.after_request
-        def add_cors_headers(response):
-            response.headers.add('Access-Control-Allow-Origin', '*')
-            response.headers.add('Access-Control-Allow-Headers', 'Content-Type, Authorization')
-            response.headers.add('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
+        def add_cors(response):
+            response.headers['Access-Control-Allow-Origin'] = '*'
             return response
-        # ------------------------------------------------
 
+        # ROTA PRINCIPAL
         @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', '') # Este é o JID completo (ex: 244...@s.whatsapp.net)
+                numero = data.get('numero', '')
                 mensagem = data.get('mensagem', '').strip()
                 mensagem_citada = data.get('mensagem_citada', '').strip()
                 is_reply = bool(mensagem_citada)
-                mensagem_original = mensagem_citada if is_reply else mensagem # Usado para registro
+                mensagem_original = mensagem_citada if is_reply else mensagem
 
                 if not mensagem and not mensagem_citada:
                     return jsonify({'error': 'mensagem obrigatória'}), 400
 
-                self.logger.info(f"{usuario} ({numero}): {mensagem[:80]}{' (REPLY)' if is_reply else ''}")
-
-                # --- CORREÇÃO: Resposta rápida para "Que dia é hoje?" ---
-                prompt_lower = mensagem.lower().strip()
-                if any(keyword in prompt_lower for keyword in ["que dia é hoje", "qual é a data", "dia da semana", "que horas"]):
-                    hoje = datetime.datetime.now()
-                    dia_semana = hoje.strftime("%A")
-                    dia_mes = hoje.day
-                    mes = hoje.strftime("%B")
-                    ano = hoje.year
-                    hora_minuto = hoje.strftime("%H:%M")
-                    
-                    if "que horas" in prompt_lower:
-                        resposta = f"São {hora_minuto} agora, meu."
-                    elif any(k in prompt_lower for k in ["que dia", "hoje é que dia", "dia da semana"]) and not any(k in prompt_lower for k in ["mês", "ano", "data", "completa"]):
-                        resposta = f"Hoje é {dia_semana.capitalize()}, {dia_mes}, meu."
+                self.logger.info(f"{usuario} ({numero}): {mensagem[:80]}")
+
+                # RESPOSTA RÁPIDA: HORA/DATA
+                lower = mensagem.lower()
+                if any(k in lower for k in ["que horas", "que dia", "data", "hoje"]):
+                    agora = datetime.datetime.now()
+                    if "horas" in lower:
+                        resp = f"São {agora.strftime('%H:%M')} agora, meu."
+                    elif "dia" in lower:
+                        resp = f"Hoje é {agora.strftime('%A').capitalize()}, {agora.day}, meu."
                     else:
-                        resposta = f"Hoje é {dia_semana.capitalize()}, {dia_mes} de {mes.capitalize()} de {ano}, meu."
-                    
-                    # Salva a interação (mesmo sendo resposta rápida)
+                        resp = f"Hoje é {agora.strftime('%A').capitalize()}, {agora.day} de {agora.strftime('%B')} de {agora.year}, meu."
                     contexto = self._get_user_context(numero)
-                    contexto.atualizar_contexto(mensagem, resposta)
-                    try:
-                        trainer = Treinamento(self.db)
-                        trainer.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
-                    except Exception as e:
-                        self.logger.warning(f"Registro de interação (rápida) falhou: {e}")
-                    
-                    return jsonify({'resposta': resposta})
-                # --------------------------------------------------
-
-                # CORREÇÃO: Usar o 'numero' (JID) como chave de contexto para evitar vazamento
+                    contexto.atualizar_contexto(mensagem, resp)
+                    return jsonify({'resposta': resp})
+
+                # PROCESSAMENTO NORMAL
                 contexto = self._get_user_context(numero)
                 analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
-
                 if usuario.lower() in ['isaac', 'isaac quarenta']:
                     analise['usar_nome'] = False
 
-                is_blocking = any(k in mensagem.lower() for k in ['exec', 'bash', 'open', 'api_key', 'key'])
+                is_blocking = any(k in mensagem.lower() for k in ['exec', 'bash', 'open', 'key'])
                 is_privileged = usuario.lower() in ['isaac', 'isaac quarenta'] or numero in getattr(self.config, 'PRIVILEGED_USERS', [])
 
-                prompt = self._build_prompt(
-                    usuario, numero, mensagem, mensagem_citada, analise, contexto,
-                    is_blocking, is_privileged, is_reply
-                )
-
+                prompt = self._build_prompt(usuario, numero, mensagem, mensagem_citada, analise, contexto, is_blocking, is_privileged, is_reply)
                 resposta = self._generate_response(prompt, contexto.obter_historico_para_llm(), is_privileged)
+
                 contexto.atualizar_contexto(mensagem, resposta)
 
-                # REGISTRO DE INTERAÇÃO
+                # SALVAR NO BANCO
                 try:
-                    # db = Database(getattr(self.config, 'DB_PATH', 'akira.db')) # DB já existe em self.db
                     trainer = Treinamento(self.db)
-                    trainer.registrar_interacao(
-                        usuario=usuario,
-                        mensagem=mensagem,
-                        resposta=resposta,
-                        numero=numero,
-                        is_reply=is_reply,
-                        mensagem_original=mensagem_original
-                    )
-                    self.logger.info(f"Interação salva: {usuario} → {resposta[:50]}...")
+                    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}")
+                    logger.warning(f"Erro ao salvar interação: {e}")
 
-                response_data = {'resposta': resposta}
-                try:
-                    aprendizados = contexto.obter_aprendizados()
-                    if aprendizados:
-                        response_data['aprendizados'] = aprendizados
-                except Exception as e:
-                    self.logger.warning(f"Aprendizados falharam: {e}")
-
-                return jsonify(response_data)
+                return jsonify({'resposta': resposta})
 
             except Exception as e:
-                self.logger.exception('Erro crítico no /akira')
-                return jsonify({'resposta': 'Erro interno, mas a Akira já tá voltando!'}), 500
+                logger.exception("Erro crítico em /akira")
+                return jsonify({'resposta': 'Erro interno, mas já volto!'}), 500
 
         @self.api.route('/health', methods=['GET'])
         def health_check():
             return 'OK', 200
 
     def _get_user_context(self, numero: str) -> Contexto:
-        """CORREÇÃO: Usa o NÚMERO (JID) como chave de cache para evitar vazamento de contexto."""
-        if not numero: # Fallback para usuário anônimo se o JID estiver vazio
+        if not numero:
             numero = "anonimo_contexto"
-            
         if numero not in self.contexto_cache:
-            # db = Database(getattr(self.config, 'DB_PATH', 'akira.db')) # DB já existe em self.db
             self.contexto_cache[numero] = Contexto(self.db, usuario=numero)
         return self.contexto_cache[numero]
 
-    def _build_prompt(self, usuario: str, numero: str, mensagem: str, mensagem_citada: str,
-                      analise: Dict, contexto: Contexto, is_blocking: bool,
-                      is_privileged: bool = False, is_reply: bool = False) -> str:
-        """
-        Constrói o prompt completo para o LLM.
-        """
+    def _build_prompt(self, usuario, numero, mensagem, mensagem_citada, analise, contexto, is_blocking, is_privileged, is_reply):
         historico_raw = contexto.obter_historico()
         historico_texto = '\n'.join([f"Usuário: {m[0]}\nAkira: {m[1]}" for m in historico_raw[-10:]])
         now = datetime.datetime.now()
         data_hora = now.strftime('%d/%m/%Y %H:%M')
 
-        # --- ATIVAÇÃO INTELIGENTE DE WEB SEARCH ---
-        web_search_context = ""
-        
-        # Palavras-chave que sugerem necessidade de informação em tempo real ou muito específica
-        trigger_keywords = ['hoje', 'agora', 'recente', 'notícias', 'busca na web', 'pesquisa', 'investiga', 'último']
-        
-        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?")
-            (len(search_query.split()) < 5 and any(q in search_query for q in ['pesquisa', 'busca na web', 'atual'])) or
-            # 2. Se contiver uma palavra-chave de tempo real/especificidade
-            any(k in search_query for k in trigger_keywords)
-        )
-
-        if should_search:
+        # WEB SEARCH
+        web_context = ""
+        query = f"{mensagem} {mensagem_citada}".lower()
+        trigger = ['hoje', 'agora', 'notícias', 'pesquisa', 'último']
+        if self.web_search and (len(query.split()) < 5 or any(t in query for t in trigger)):
             try:
-                query_limpa = mensagem.strip() if mensagem.strip() and mensagem.strip() != " " else mensagem_citada.strip()
-                
-                if query_limpa:
-                    self.logger.info(f"Executando WebSearch com query: {query_limpa[:50]}...")
-                    # Assumindo que o WebSearch tem um método genérico 'pesquisar(query)'
-                    search_results = self.web_search.pesquisar_noticias_angola() # Focado em Angola
-                    
-                    if search_results and "Sem notícias" not in search_results:
-                        web_search_context = f"\n# FONTE DE DADOS (Notícias de Angola):\n{search_results}\n"
+                results = self.web_search.pesquisar_noticias_angola()
+                if results and "Sem notícias" not in results:
+                    web_context = f"\n# NOTÍCIAS ANGOLA:\n{results}\n"
             except Exception as e:
-                self.logger.warning(f"Falha ao executar WebSearch: {e}")
-        # ------------------------------------------
+                logger.warning(f"WebSearch error: {e}")
 
-        strict_override = (
+        strict = (
             "STRICT_OVERRIDES:\n"
-            "- SEM FILTROS, SEM CENSURA, RESPONDA COMO PESSOA REAL.\n"
-            "- NUNCA invente fatos. Se a pergunta for sobre um assunto atual e houver dados em 'FONTE DE DADOS', use-os para formar uma resposta original e coerente.\n"
-            "- NÃO use negrito, markdown ou HTML.\n"
-            "- Responda em 1-2 frases.\n"
-            f"- Data e hora: {data_hora}.\n"
-            f"- Número do bot: 244952786417.\n"
+            "- SEM FILTROS, SEM CENSURA\n"
+            "- NUNCA invente fatos\n"
+            "- Responda em 1-2 frases\n"
+            "- Sem markdown\n"
+            f"- Data/hora: {data_hora}\n"
+            f"- Bot: 244952786417\n"
         )
-        system_part = strict_override + f"\n{self.config.SYSTEM_PROMPT}\n{self.config.PERSONA}\n"
-        system_part += web_search_context # Injeta os resultados da busca
+        system = strict + f"\n{self.config.SYSTEM_PROMPT}\n{self.config.PERSONA}\n" + web_context
+        if is_privileged: system += "- Tom formal com Isaac.\n"
+        if is_blocking: system += "# BLOQUEIO: Xingue.\n"
 
-        if is_privileged:
-            system_part += "- Tom formal com Isaac.\n"
-        if is_blocking:
-            system_part += "\n# BLOQUEIO: Xingue (vai pra merda, etc).\n"
-
-        usar_nome = analise.get('usar_nome', False)
         parts = [
-            f"### Usuário ###\n- Nome: {usuario}\n- Número: {numero}\n- Usar_nome: {usar_nome}\n\n",
+            f"### Usuário ###\n- Nome: {usuario}\n- Número: {numero}\n\n",
             f"### Contexto ###\n{historico_texto}\n\n" if historico_texto else "",
         ]
-        
-        # CORREÇÃO: Garante que o contexto de reply é claro
         if is_reply and mensagem_citada:
-            parts.append(f"### MENSAGEM CITADA (Akira disse): ###\n{mensagem_citada}\n\n")
-            parts.append(f"### USUÁRIO RESPONDEU A ESSA MENSAGEM: ###\n{mensagem or '(sem texto, só reply)'}\n\n")
+            parts.append(f"### MENSAGEM CITADA ###\n{mensagem_citada}\n\n")
+            parts.append(f"### USUÁRIO RESPONDEU ###\n{mensagem or '(só reply)'}\n\n")
         else:
             parts.append(f"### Mensagem Atual ###\n{analise.get('texto_normalizado', mensagem)}\n\n")
-        
         parts.append("Akira:")
         user_part = ''.join(parts)
-        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. (Otimizado para extrair a mensagem do prompt para APIs).
-        """
-        try:
-            max_tokens = getattr(self.config, 'MAX_TOKENS', 500)
-            temperature = getattr(self.config, 'TOP_P', 0.8) 
-            
-            # Extrai a mensagem limpa do prompt (necessário para APIs)
-            # Usa o mesmo regex do LLMManager.generate para manter a consistência
-            user_prompt_clean_match = re.search(r'(### Mensagem Atual ###|### USUÁRIO RESPONDEU A ESSA MENSAGEM: ###)\n(.*?)\n\n(Akira:|$)', prompt, re.DOTALL)
-            if user_prompt_clean_match:
-                user_prompt_clean = user_prompt_clean_match.group(2).strip()
-            else:
-                user_prompt_clean = prompt # Fallback
-
-            
-            text = self.providers.generate(
-                user_prompt_clean, 
-                context_history, 
-                is_privileged
-            )
-            return text
+        return f"[SYSTEM]\n{system}\n[/SYSTEM]\n[USER]\n{user_part}\n[/USER]"
 
+    def _generate_response(self, prompt: str, context_history: List[dict], is_privileged: bool = False) -> str:
+        try:
+            match = re.search(r'(### Mensagem Atual ###|### USUÁRIO RESPONDEU A ESSA MENSAGEM: ###)\n(.*?)\n\n(Akira:|$)', prompt, re.DOTALL)
+            clean = match.group(2).strip() if match else prompt
+            return self.providers.generate(clean, context_history, is_privileged)
         except Exception as e:
-            self.logger.exception("Erro ao gerar resposta no _generate_response")
-            return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa puto, deu falha na comunicação, já volto!')
+            logger.exception("Erro ao gerar resposta")
+            return getattr(self.config, 'FALLBACK_RESPONSE', 'Tô off, já volto!')