Update modules/api.py

modules/api.py

@@ -1,293 +1,422 @@
+"""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.
 """
-API wrapper for Akira service - VERSÃO FINAL INDESTRUTÍVEL
-- SEM request.json
-- SEM data.get em string
-- Usa form + args + get_data → 100% seguro
-- Contexto(usuario=key)
-"""
-from typing import Any, Tuple, Dict
+
+from typing import Dict, Optional, Any
 import time
+import logging
 import re
-import datetime
-import random
-import json
-from flask import Flask, Blueprint, request
-from loguru import logger
-
-# Importa as classes auxiliares e a configuração
-import modules.config as config
+from flask import Flask, Blueprint, request, jsonify
+
 from .contexto import Contexto
 from .database import Database
 from .treinamento import Treinamento
-from .web_search import WebSearch
-from .local_llm import LlamaLLM
+from .exemplos_naturais import ExemplosNaturais
+
+# --- NOVOS IMPORTS PARA WEBSERVICE ---
+try:
+    # Assumindo que o web_search está no mesmo diretório de módulos
+    from .web_search import WebSearch
+    websearch_available = True
+except ImportError:
+    websearch_available = False
+    logging.warning("WebSearch não disponível. Funcionalidades de busca limitadas.")
+# --------------------------------------
 
-# Módulos LLMs (Verificando disponibilidade)
 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
+    logger.warning("google.generativeai não disponível. Gemini desabilitado.")
 
 
 class LLMManager:
-    """Gerencia a chamada aos modelos LLM na ordem: Mistral > LlamaLLM > Gemini."""
-    def __init__(self, cfg):
-        self.config = cfg
-        self.llama = LlamaLLM()
+    """Gerenciador de provedores LLM (Mistral + Gemini como fallback)."""
+
+    def __init__(self, config):
+        self.config = config
         self.mistral_client = None
         self.gemini_model = None
-        self._setup()
+        self._setup_providers()
 
-    def _setup(self):
-        # TENTA 1: MISTRAL (Principal)
-        if mistral_available and self.config.MISTRAL_API_KEY:
+    def _setup_providers(self):
+        # O código local de LLM que exige GPU está fora deste arquivo,
+        # focamos apenas nos providers de API externa (Mistral e Gemini)
+        if mistral_available and getattr(self.config, 'MISTRAL_API_KEY', None):
             try:
                 self.mistral_client = Mistral(api_key=self.config.MISTRAL_API_KEY)
-                logger.info("Mistral OK")
-            except: self.mistral_client = None
+                logger.info("Mistral client inicializado.")
+            except Exception as e:
+                logger.warning(f"Falha ao inicializar Mistral: {e}")
 
-        # TENTA 3: GEMINI (Último Fallback)
-        if gemini_available and self.config.GEMINI_API_KEY:
+        if gemini_available and getattr(self.config, 'GEMINI_API_KEY', None):
             try:
                 genai.configure(api_key=self.config.GEMINI_API_KEY)
-                self.gemini_model = genai.GenerativeModel(self.config.GEMINI_MODEL)
-                logger.info("Gemini OK")
-            except: self.gemini_model = None
-
-    def _limpar(self, t: str) -> str:
-        """Limpa a formatação (markdown) e limita o tamanho da resposta."""
-        if not t: return ""
-        # Limpa formatação comum do LLM
-        t = re.sub(r'[\*\_\`\[\]\"\<\>]', '', t)
-        t = re.sub(r'\s+', ' ', t.replace('\n', ' ')).strip()
-        
-        # Lógica de limite de frases para garantir 1-2 frases
-        if len(t) > 280:
-            s = [f.strip() for f in re.split(r'(\.|\!|\?)', t) if f.strip() not in ('.', '!', '?')]
-            c = ""
-            for f in s:
-                # Reconstroi a frase com pontuação no final se possível
-                sentence = f + t[len(c + f):].split(f)[1].split(' ')[0] if t[len(c + f):].split(f)[1].split(' ')[0] in ('.', '!', '?') else f
-                if len(c + sentence + " ") <= 280: 
-                    c += sentence + " "
-                else: 
-                    break
-            t = c.strip()
-            if not t.endswith(('.', '!', '?')): t += "..."
-        return t
-
-    def generate(self, p: str, mx: int = 500, tp: float = 0.8) -> str:
-        """Tenta gerar a resposta na ordem: Mistral -> Llama -> Gemini."""
-        # Se 6 tentativas falharem em todos, retorna fallback
-        for _ in range(6): 
-            # TENTA 1: MISTRAL
-            if self.mistral_client:
-                try:
-                    r = self.mistral_client.chat.complete(
-                        model=self.config.MISTRAL_MODEL,
-                        messages=[{"role": "user", "content": p}],
-                        max_tokens=mx, temperature=tp, top_p=self.config.TOP_P
-                    )
-                    t = r.choices[0].message.content
-                    if t: return self._limpar(t)
-                except: pass
+                self.gemini_model = genai.GenerativeModel(getattr(self.config, 'GEMINI_MODEL', 'gemini-1.5-flash'))  # type: ignore[reportAttributeAccessIssue]
+                logger.info("Gemini model inicializado.")
+            except Exception as e:
+                logger.warning(f"Falha ao inicializar Gemini: {e}")
 
-            # TENTA 2: LLAMA (Local - se o modelo estiver carregado)
-            if self.llama.model:
+    def generate(self, prompt: str, max_tokens: int = 300, temperature: float = 0.8) -> str:
+        # A ordem garante que Gemini seja o fallback
+        providers = ['mistral', 'gemini']
+
+        for provider in providers:
+            if provider == 'mistral' and self.mistral_client:
                 try:
-                    r = self.llama.generate(p, mx)
-                    if r.strip(): return self._limpar(r)
-                except: pass
+                    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 ""
+                    return str(content) if content else ""
+                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 ""
+                            return str(content) if content else ""
+                        except Exception as e2:
+                            logger.warning(f"Mistral retry failed: {e2}")
+                    else:
+                        logger.warning(f"Mistral falhou: {e}")
 
-            # TENTA 3: GEMINI
-            if self.gemini_model:
+            elif provider == 'gemini' and self.gemini_model:
                 try:
-                    r = self.gemini_model.generate_content(
-                        p,
-                        generation_config={"max_output_tokens": mx, "temperature": tp, "top_p": self.config.TOP_P}
+                    response = self.gemini_model.generate_content(
+                        prompt,
+                        generation_config={
+                            "max_output_tokens": max_tokens,
+                            "temperature": temperature
+                        }
                     )
-                    t = r.text
-                    if t: return self._limpar(t)
-                except: pass
+                    text = response.text
+                    return text.strip() if text else ""
+                except Exception as e:
+                    error_msg = str(e).lower()
+                    if "429" in error_msg or "too many requests" in error_msg or "quota exceeded" in error_msg:
+                        logger.warning(f"Gemini rate limit, retrying in 1s: {e}")
+                        time.sleep(1)
+                        try:
+                            response = self.gemini_model.generate_content(
+                                prompt,
+                                generation_config={
+                                    "max_output_tokens": max_tokens,
+                                    "temperature": temperature
+                                }
+                            )
+                            text = response.text
+                            return text.strip() if text else ""
+                        except Exception as e2:
+                            logger.warning(f"Gemini retry failed: {e2}")
+                    else:
+                        logger.warning(f"Gemini falhou: {e}")
+
+        logger.error("Ambos os providers falharam")
+        return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, puto, o modelo tá off hoje. Tenta depois!')
 
-        return self.config.FALLBACK_RESPONSE
+
+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:
-    """API principal com toda a lógica de contexto e roteamento."""
-    def __init__(self, cfg):
-        self.config = cfg
+    def __init__(self, cfg_module):
+        self.config = cfg_module
         self.app = Flask(__name__)
         self.api = Blueprint("akira_api", __name__)
-        self.db = Database(getattr(cfg, 'DB_PATH', '/app/data/akira.db'))
-        self.cache = {} # Cache para Contexto
-        self.llm = LLMManager(cfg)
-        self.treinador = Treinamento(self.db)
-        self.web = WebSearch()
+        self.contexto_cache = SimpleTTLCache(ttl_seconds=getattr(self.config, 'MEMORIA_MAX', 300))
+        self.providers = LLMManager(self.config)
+        self.exemplos = ExemplosNaturais()
+        self.logger = logger
+        
+        # --- NOVO: Inicialização do WebSearch ---
+        self.web_search = WebSearch() if websearch_available else None
+        # ------------------------------------------
+
+        self._setup_personality()
         self._setup_routes()
+        self._setup_trainer()
 
-        self.app.register_blueprint(self.api, url_prefix="/api", name="api1")
-        self.app.register_blueprint(self.api, url_prefix="", name="api2")
-
-        if getattr(cfg, 'START_PERIODIC_TRAINER', False):
-            self.treinador.start_periodic_training()
-
-    def _ctx(self, u: str, n: str) -> Contexto:
-        """Obtém ou cria o Contexto do usuário. (CORRIGIDO)"""
-        k = n or u
-        if k not in self.cache:
-            # CORREÇÃO CRÍTICA: Argumento mudado de 'user_key' para 'usuario'
-            c = Contexto(self.db, usuario=k) 
-            c.atualizar_aprendizados_do_banco()
-            self.cache[k] = c
-        return self.cache[k]
-
-    def _pronomes(self, t: str) -> str:
-        """Busca pronomes adequados ao tom no banco de dados."""
-        # Supondo que 'obter_pronomes_por_tom' existe na classe Database (ou usando um fallback)
-        try:
-            r = self.db._execute_with_retry("SELECT pronomes FROM pronomes_por_tom WHERE tom=?", (t.lower(),))
-            return r[0][0] if r and r[0] else ""
-        except Exception:
-            return ""
-
-
-    def _prompt(self, u: str, n: str, m: str, e: str, c: Contexto, p: bool, r: bool, o: str) -> str:
-        """Constrói o prompt completo, buscando notícias (self.web)."""
-        d = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
-        news = self.web.pesquisar_noticias_angola()
-        tom = c.ton_predominante or "neutro"
-        pro = self._pronomes(tom)
-
-        s = f"""
-REGRAS:
-- FALE COMO GENTE (Tom Angolano, informal)
-- SEJA DIRETO, NÃO ENROLE: Responda a pergunta EXATAMENTE. MÁXIMO 1-2 FRASES.
-- PRIORIDADE DE INFORMAÇÃO: Se a pergunta exigir dados atuais (Ex: "Que dia é hoje?", "Vai chover?"), use as #NOTÍCIAS ou a DATA.
-- GÍRIAS: bué, fixe, puto, mano, ya (use naturalmente)
-- SARCASMO OK
-- USE kkk, rsrs
-- SEM markdown
-- NOME ~10% (Use APENAS o primeiro nome)
-- DATA: {d}
-# NOTÍCIAS (Angola):
-{news}
-# PRONOMES ({tom}):
-{pro}
-# EMOÇÃO: {e}
-"""
-        if p: s += "- TOM FORMAL: Sr., boss\n"
-        else: s += "- TOM NORMAL: Luanda\n"
-
-        h = c.obter_historico()[-3:]
-        ht = "\n".join([f"U: {x[0]}\nA: {x[1]}" for x in h]) if h else ""
-
-        ui = f"""
-USUÁRIO:
-- Nome: {u}
-- Número: {n}
-- Tom: {tom}
-- VIP: {'sim' if p else 'não'}
-"""
-        
-        # config.SYSTEM_PROMPT e config.PERSONA vêm do módulo importado
-        return f"[SYSTEM]\n{s}\n{config.SYSTEM_PROMPT}\n{config.PERSONA}\n[/SYSTEM]\n[CONTEXTO]\n{ht}\n{ui}\n[/CONTEXTO]\n[MENSAGEM]\n{m}\n[/MENSAGEM]\nAkira:"
+        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):
-        """Configura os endpoints da API (usando 'endpoint' como nome da função)."""
         @self.api.route('/akira', methods=['POST'])
-        @self.api.route('/', methods=['POST'])
-        def endpoint() -> Tuple[Any, int]:
+        def akira_endpoint():
             try:
-                # 1. TENTA OBTER DE FORM/ARGS
-                usuario = request.form.get('usuario', '').strip() or request.args.get('usuario', '').strip() or 'anonimo'
-                numero = request.form.get('numero', '').strip() or request.args.get('numero', '').strip()
-                mensagem = request.form.get('mensagem', '').strip() or request.args.get('mensagem', '').strip()
-
-                # 2. SE VEIO JSON NO BODY, TENTA EXTRAIR
-                if request.content_type and 'json' in request.content_type.lower():
-                    try:
-                        raw = request.get_data(as_text=True)
-                        body = json.loads(raw)
-                        if isinstance(body, dict):
-                            usuario = body.get('usuario') or usuario
-                            numero = body.get('numero') or numero
-                            mensagem = body.get('mensagem') or mensagem
-                    except: pass
+                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
+                
+                # --- NOVO: Extração da mensagem citada (inclui o novo campo do index.js) ---
+                mensagem_citada = data.get('mensagem_citada') or data.get('mensagem_original') or data.get('quoted_message') or ''
+                is_reply = bool(mensagem_citada)
+                # ----------------------------------------------------------------------------
 
                 if not mensagem:
-                    return {"resposta": "mensagem obrigatória"}, 400
+                    return jsonify({'error': 'mensagem é obrigatória'}), 400
 
-                # Normalização e checagem de privilégios
-                is_priv = usuario.lower() in [u.lower() for u in config.PRIVILEGED_USERS] or numero in config.PRIVILEGED_USERS
-                is_reply = bool(request.form.get('is_reply') or request.form.get('mensagem_original') or request.args.get('is_reply') or request.args.get('mensagem_original'))
-                orig = request.form.get('mensagem_original', '') or request.form.get('quoted_message', '') or request.args.get('mensagem_original', '') or request.args.get('quoted_message', '')
+                
+                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
+
+                # --- NOVO: passagem do campo mensagem_citada para o build_prompt ---
+                prompt = self._build_prompt(usuario, numero, mensagem, analise, contexto, is_blocking,
+                                           is_privileged=is_privileged, is_reply=is_reply,
+                                           mensagem_citada=mensagem_citada)
+                # ------------------------------------------------------------------
+                
+                resposta = self._generate_response(prompt)
+                contexto.atualizar_contexto(mensagem, resposta)
 
-                logger.info(f"{usuario} ({numero}): {mensagem[:120]}")
+                try:
+                    db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
+                    trainer = Treinamento(db)
+                    # Passagem da mensagem citada para o registro
+                    trainer.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_citada)
+                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}")
 
-                # --- PROCESSAMENTO ---
-                ctx = self._ctx(usuario, numero)
-                
-                emo = ctx.analisar_emocoes_mensagem(mensagem) 
-                emocao_str = emo.get('emocao', 'neutra') if isinstance(emo, dict) else 'neutra'
-
-                prompt = self._prompt(usuario, numero, mensagem, emocao_str, ctx, is_priv, is_reply, orig)
-                resp = self.llm.generate(prompt)
-
-                # Aplica probabilidade de uso do nome
-                first_name = usuario.split(' ')[0].strip()
-                # Reduz probabilidade de 0.4 para 0.1 (muito raramente) e usa o primeiro nome
-                if random.random() < getattr(self.config, 'USAR_NOME_PROBABILIDADE', 0.1): 
-                    if random.random() < 0.5:
-                        # Coloca nome na frente (ex: "Isaac, estás bem?")
-                        resp = f"{first_name}, {resp[0].lower() + resp[1:]}"
-                    else:
-                        # Coloca nome atrás (ex: "Tudo fixe, Isaac")
-                        resp = f"{resp}, {first_name}"
+                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]
+
+    # --- FUNÇÃO _build_prompt ATUALIZADA ---
+    def _build_prompt(self, usuario: str, numero: str, mensagem: str, analise: Dict, contexto: Contexto, is_blocking: bool,
+                      is_privileged: bool = False, is_reply: bool = False, mensagem_citada: str = '') -> str:
+        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')
+        
+        # --- NOVO: INJEÇÃO DE BUSCA/NOTÍCIAS ---
+        web_search_context = ""
+        try:
+            # Simple check for Angola news keywords
+            news_keywords = ['notícias', 'noticias', 'notícia', 'noticia', 'o que aconteceu', 'angola', 'novojornal', 'angop']
+            if self.web_search and any(k in mensagem.lower() for k in news_keywords):
+                logger.info("Executando WebSearch para notícias de Angola...")
+                news_text = self.web_search.pesquisar_noticias_angola()
+                if news_text and "Sem notícias" not in news_text:
+                    web_search_context = f"\n# BUSCA RECENTE:\n{news_text}\n"
+        except Exception as e:
+            logger.warning(f"Falha ao executar WebSearch: {e}")
+        # ------------------------------------------
+
+
+        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"
+        system_part += web_search_context # Injeta os resultados da busca
+        
+        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")
+        
+        # --- NOVO: Adiciona o contexto da mensagem citada ---
+        if is_reply and mensagem_citada:
+            parts.append(f"### Mensagem original (reply) ###\n{mensagem_citada}\n\n")
+        # ---------------------------------------------------
+        
+        parts.append(f"### Instruções ###\n{getattr(self.config, 'INSTRUCTIONS', '')}\n\n")
+        parts.append("Akira:\n")
+        user_part = ''.join(parts)
 
-                # Atualiza
-                ctx.atualizar_contexto(mensagem, resp)
-                self.treinador.registrar_interacao(usuario, mensagem, resp, numero, is_reply, orig)
+        prompt = f"[SYSTEM]\n{system_part}\n[/SYSTEM]\n[USER]\n{user_part}\n[/USER]"
+        return prompt
+    # --------------------------------------
 
-                # Retorno dos aprendizados
-                termos = []
-                girias = []
-                try:
-                    t = getattr(ctx, 'termo_contexto', [])
-                    if isinstance(t, str):
-                        t = json.loads(t)
-                    if isinstance(t, list): termos = t
-
-                    g = getattr(ctx, 'girias_aprendidas', [])
-                    if isinstance(g, str):
-                        g = json.loads(g)
-                    if isinstance(g, list):
-                        girias = [x.get('giria', '') for x in g[:3] if isinstance(x, dict)]
-                except: pass
-
-                return {
-                    "resposta": resp,
-                    "aprendizados": {
-                        "emocao_atual": getattr(ctx, 'emocao_atual', 'neutra'),
-                        "termos": termos,
-                        "gírias": girias
-                    }
-                }, 200
+    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:
-                logger.error(f"Erro: {e}", exc_info=True)
-                return {"resposta": getattr(self.config, 'FALLBACK_RESPONSE', 'erro, puto. tenta depois.')}, 500
-
-    def run(self, h='0.0.0.0', p=7860, d=False):
-        """Inicia o servidor Flask."""
-        host = getattr(self.config, 'API_HOST', h)
-        port = getattr(self.config, 'API_PORT', p)
-        logger.info(f"Rodando na porta {port}")
-        self.app.run(host=host, port=port, debug=d, threaded=True)
+                self.logger.exception(f"Falha ao iniciar treinador periódico: {e}")
+
+    # A função 'responder' também foi atualizada para aceitar mensagem_citada
+    def responder(self, mensagem: str, numero: str, nome: str = 'Usuário', mensagem_citada: str = '') -> str:
+        contexto = self._get_user_context(nome)
+        analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
+        
+        # Passa a mensagem citada para o build_prompt
+        prompt = self._build_prompt(nome, numero, mensagem, analise, contexto, is_blocking=False, mensagem_citada=mensagem_citada)
+        
+        resposta = self._generate_response(prompt)
+        contexto.atualizar_contexto(mensagem, resposta)
+        return resposta