Update modules/api.py

modules/api.py

@@ -1,13 +1,13 @@
-# modules/api.py — AKIRA V21 FINAL ADAPTADO (DEZEMBRO 2025)
+# modules/api.py — AKIRA V21 FINAL INTEGRADO (Dezembro 2025)
 """
-✅ TOTALMENTE ADAPTADO ao config.py BRUTAL ATUALIZADO
-✅ TOTALMENTE COMPATÍVEL com index.js otimizado (mensagem_citada completa)
-✅ Sistema emocional DistilBERT
-✅ Xingamento automático integrado
-✅ Usa prompts de ironia máxima com contexto completo
-✅ Processa reply_metadata e mensagem_citada do index.js corretamente
-✅ CORREÇÃO: Compatível com novo payload (reply_metadata + mensagem_citada)
+✅ TOTALMENTE INTEGRADO com config.py, database.py, contexto.py e treinamento.py atualizados
+✅ CORREÇÃO: Usa métodos corretos do Database
+✅ COMPATÍVEL com index.js e reply_metadata
+✅ Sistema multi-API com fallback
+✅ Cache de contexto otimizado
+✅ Treinamento automático integrado
 """
+
 import time
 import datetime
 import requests
@@ -19,12 +19,10 @@ from typing import Dict, Any, List, Optional
 from flask import Blueprint, request, jsonify, make_response
 from loguru import logger
 
-# Importa módulos locais
-from .contexto import Contexto
+# Importa módulos locais - CORRETAMENTE
+from .contexto import Contexto, criar_contexto
 from .database import Database
 from .treinamento import Treinamento
-from .web_search import get_web_search, WebSearch
-from .empresa_info import EmpresaInfo
 import modules.config as config
 
 # ============================================================================
@@ -59,7 +57,7 @@ class SimpleTTLCache:
             return default
 
 # ============================================================================
-# 🧠 GERENCIADOR MULTI-API (OTIMIZADO PARA NOVO CONTEXTO)
+# 🧠 GERENCIADOR MULTI-API (OTIMIZADO PARA CONFIG.PY)
 # ============================================================================
 class MultiAPIManager:
     def __init__(self):
@@ -68,6 +66,7 @@ class MultiAPIManager:
         logger.info(f"✅ APIs disponíveis: {', '.join(self.apis_disponiveis)}")
 
     def _verificar_apis(self):
+        """Verifica quais APIs estão disponíveis"""
         apis = []
         if config.MISTRAL_API_KEY and len(config.MISTRAL_API_KEY) > 10:
             apis.append("mistral")
@@ -90,17 +89,12 @@ class MultiAPIManager:
         reply_info: Optional[Dict] = None
     ) -> str:
         """
-        Constrói prompt usando a função do config.py ATUALIZADO
-        TOTALMENTE COMPATÍVEL com o novo index.js (mensagem_citada completa)
+        Constrói prompt usando config.py - CORRETAMENTE
         """
         try:
-            # Log do que estamos recebendo
             logger.debug(f"📝 Construindo prompt para: {usuario}")
-            logger.debug(f"📝 Mensagem: {mensagem[:100]}...")
-            logger.debug(f"📝 Mensagem citada: {mensagem_citada[:100] if mensagem_citada else '[Nenhuma]'}...")
-            logger.debug(f"📝 Reply info disponível: {bool(reply_info)}")
             
-            # Usa a função principal do config.py atualizado
+            # Usa a função do config.py
             prompt = config.construir_prompt_api(
                 mensagem=mensagem,
                 historico=historico,
@@ -112,31 +106,25 @@ class MultiAPIManager:
             )
             
             logger.debug(f"✅ Prompt construído: {len(prompt)} caracteres")
-            logger.debug(f"📄 Primeiras 3 linhas do prompt:")
-            for i, line in enumerate(prompt.split('\n')[:3]):
-                logger.debug(f"  {i}: {line[:100]}...")
-            
             return prompt
             
         except Exception as e:
             logger.error(f"❌ Erro ao construir prompt: {e}")
-            # Fallback para prompt simples (com mensagem citada)
+            # Fallback simples
             return f"""AKIRA V21 — PERSONALIDADE REAL SEM FILTRO
 Você é Akira, angolana de 18 anos de Luanda.
 
-CONTEXTO: {f'O usuário está respondendo a uma mensagem: "{mensagem_citada[:150]}{"..." if len(mensagem_citada) > 150 else ""}"' if mensagem_citada else 'Conversa normal'}
-
 USUÁRIO: {usuario}
 MENSAGEM: {mensagem}
+MENSAGEM CITADA: {mensagem_citada if mensagem_citada else 'Nenhuma'}
 
 RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
 
     def _obter_parametros_api(self, analise: Dict[str, Any]) -> Dict[str, Any]:
-        """Obtém parâmetros otimizados para API baseado na emoção e modo"""
+        """Obtém parâmetros usando config.py"""
         emocao = analise.get("emocao_primaria", "neutral")
         modo = analise.get("modo_resposta", "normal_ironico")
         
-        # Usa função do config.py atualizado
         return config.obter_parametros_api(emocao, modo)
 
     def gerar_resposta(
@@ -149,16 +137,10 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
         tipo_conversa: str,
         reply_info: Optional[Dict] = None
     ) -> str:
-        """Gera resposta usando multi-API fallback (com contexto completo)"""
-        # Log do que está sendo processado
+        """Gera resposta usando multi-API fallback"""
         logger.info(f"🎯 Gerando resposta para {usuario}")
-        logger.info(f"📤 Mensagem: {mensagem[:80]}...")
-        if mensagem_citada:
-            logger.info(f"📝 Mensagem citada disponível: {mensagem_citada[:80]}...")
-        if reply_info:
-            logger.info(f"🔍 Reply metadata: reply_to_bot={reply_info.get('reply_to_bot', False)}")
         
-        # Construir prompt com contexto completo
+        # Construir prompt
         prompt = self._construir_prompt(
             mensagem=mensagem,
             historico=historico,
@@ -172,42 +154,41 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
         # Obter parâmetros
         parametros = self._obter_parametros_api(analise)
         
-        logger.debug(f"🔧 Parâmetros: {parametros}")
-        
-        # Tentar APIs em ordem de fallback
+        # Tentar APIs em ordem
         for api_name in config.API_FALLBACK_ORDER:
             if api_name not in self.apis_disponiveis:
                 continue
                 
             try:
-                logger.debug(f"🔄 Tentando API: {api_name}")
                 resposta = self._chamar_api(api_name, prompt, parametros)
                 if resposta:
                     resposta_limpa = self._limpar_resposta(resposta)
-                    logger.info(f"✅ API {api_name} respondeu: {resposta_limpa[:100]}...")
+                    logger.info(f"✅ API {api_name} respondeu: {resposta_limpa[:80]}...")
                     return resposta_limpa
-                    
             except Exception as e:
-                logger.warning(f"❌ API {api_name} falhou: {str(e)[:100]}")
+                logger.warning(f"❌ API {api_name} falhou: {e}")
                 continue
         
-        # Fallback: respostas curtas e brutais baseadas no contexto
-        fallbacks = self._gerar_fallback_contextual(mensagem, mensagem_citada, reply_info)
-        return random.choice(fallbacks)
+        # Fallback contextual
+        return self._gerar_fallback_contextual(mensagem, mensagem_citada, reply_info)
 
-    def _chamar_api(self, api_name: str, prompt: str, parametros: Dict[str, Any]) -> str:
-        """Chama API específica com tratamento de erros"""
-        if api_name == "mistral":
-            return self._chamar_mistral(prompt, parametros)
-        elif api_name == "gemini":
-            return self._chamar_gemini(prompt, parametros)
-        elif api_name == "groq":
-            return self._chamar_groq(prompt, parametros)
-        elif api_name == "cohere":
-            return self._chamar_cohere(prompt, parametros)
-        return ""
+    def _chamar_api(self, api_name: str, prompt: str, params: Dict[str, Any]) -> str:
+        """Chama API específica"""
+        try:
+            if api_name == "mistral":
+                return self._chamar_mistral(prompt, params)
+            elif api_name == "gemini":
+                return self._chamar_gemini(prompt, params)
+            elif api_name == "groq":
+                return self._chamar_groq(prompt, params)
+            elif api_name == "cohere":
+                return self._chamar_cohere(prompt, params)
+        except Exception as e:
+            logger.error(f"Erro ao chamar {api_name}: {e}")
+            return ""
 
     def _chamar_mistral(self, prompt: str, params: Dict[str, Any]) -> str:
+        """Chama Mistral API"""
         try:
             response = requests.post(
                 "https://api.mistral.ai/v1/chat/completions",
@@ -226,10 +207,11 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
             response.raise_for_status()
             return response.json()["choices"][0]["message"]["content"].strip()
         except Exception as e:
-            logger.debug(f"Mistral falhou: {e}")
+            logger.error(f"Mistral falhou: {e}")
             return ""
 
     def _chamar_gemini(self, prompt: str, params: Dict[str, Any]) -> str:
+        """Chama Gemini API"""
         try:
             response = requests.post(
                 f"https://generativelanguage.googleapis.com/v1beta/models/{config.GEMINI_MODEL}:generateContent?key={config.GEMINI_API_KEY}",
@@ -245,10 +227,11 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
             response.raise_for_status()
             return response.json()["candidates"][0]["content"]["parts"][0]["text"].strip()
         except Exception as e:
-            logger.debug(f"Gemini falhou: {e}")
+            logger.error(f"Gemini falhou: {e}")
             return ""
 
     def _chamar_groq(self, prompt: str, params: Dict[str, Any]) -> str:
+        """Chama Groq API"""
         try:
             response = requests.post(
                 "https://api.groq.com/openai/v1/chat/completions",
@@ -264,10 +247,11 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
             response.raise_for_status()
             return response.json()["choices"][0]["message"]["content"].strip()
         except Exception as e:
-            logger.debug(f"Groq falhou: {e}")
+            logger.error(f"Groq falhou: {e}")
             return ""
 
     def _chamar_cohere(self, prompt: str, params: Dict[str, Any]) -> str:
+        """Chama Cohere API"""
         try:
             response = requests.post(
                 "https://api.cohere.ai/v1/generate",
@@ -282,32 +266,28 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
             response.raise_for_status()
             return response.json()["generations"][0]["text"].strip()
         except Exception as e:
-            logger.debug(f"Cohere falhou: {e}")
+            logger.error(f"Cohere falhou: {e}")
             return ""
 
     def _limpar_resposta(self, texto: str) -> str:
-        """Limpa a resposta removendo formatação indesejada"""
+        """Limpa a resposta"""
         if not texto:
             return "…"
         
         # Remove markdown
         texto = re.sub(r'[\*`_]+', '', texto)
         
-        # Remove aspas desnecessárias no início/fim
+        # Remove aspas
         texto = texto.strip('"\'')
         
-        # Remove prefixos como "Akira:" ou "AKIRA:"
+        # Remove prefixos
         texto = re.sub(r'^(Akira|AKIRA)[:\s\-]+', '', texto, flags=re.IGNORECASE)
         
-        # Remove "Resposta:" ou "Resposta de Akira:"
-        texto = re.sub(r'^(Resposta|Resposta de Akira)[:\s\-]+', '', texto, flags=re.IGNORECASE)
-        
-        # Remove múltiplos espaços
+        # Remove espaços extras
         texto = re.sub(r'\s+', ' ', texto)
         
-        # Limita tamanho (mas preserva contexto)
+        # Limita tamanho
         if len(texto) > 400:
-            # Tenta encontrar um ponto final próximo
             last_period = texto[:397].rfind('.')
             if last_period > 300:
                 texto = texto[:last_period + 1]
@@ -316,9 +296,9 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
             
         return texto.strip()
 
-    def _gerar_fallback_contextual(self, mensagem: str, mensagem_citada: str, reply_info: Optional[Dict]) -> List[str]:
-        """Gera fallbacks contextuais baseados na mensagem e contexto"""
-        base_fallbacks = [
+    def _gerar_fallback_contextual(self, mensagem: str, mensagem_citada: str, reply_info: Optional[Dict]) -> str:
+        """Gera fallback contextual"""
+        fallbacks = [
             "Puto, nem ligo.",
             "Foda-se.",
             "Ya, tá bom.",
@@ -331,80 +311,78 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
             "Não."
         ]
         
-        # Se há mensagem citada, adiciona fallbacks contextuais
+        # Adiciona contextuais se há mensagem citada
         if mensagem_citada:
-            contextual_fallbacks = [
+            fallbacks.extend([
                 f"Já disse isso.",
                 f"Repito: {mensagem_citada[:50]}...",
                 f"Ya, como disse.",
                 f"Exactamente isso."
-            ]
-            base_fallbacks.extend(contextual_fallbacks)
+            ])
         
         # Se é reply ao bot
         if reply_info and reply_info.get('reply_to_bot'):
-            reply_fallbacks = [
+            fallbacks.extend([
                 "Já disse isso, caralho.",
                 "Repito o que disse.",
                 "Ya, como eu disse.",
                 "Exactamente o que falei."
-            ]
-            base_fallbacks.extend(reply_fallbacks)
+            ])
         
-        return base_fallbacks
+        return random.choice(fallbacks)
 
 # ============================================================================
-# 🎯 CLASSE PRINCIPAL AKIRA API (ATUALIZADA)
+# 🎯 CLASSE PRINCIPAL AKIRA API (CORRIGIDA E INTEGRADA)
 # ============================================================================
 class AkiraAPI:
     def __init__(self):
-        """CORREÇÃO: Não aceita parâmetros - usa config.py atualizado diretamente"""
+        """Inicializa API totalmente integrada"""
         self.api = Blueprint("akira_api", __name__)
         self.contexto_cache = SimpleTTLCache(ttl_seconds=300)
+        
+        # Inicializa Database com caminho CORRETO
         self.db = Database(config.DB_PATH)
         self.llm_manager = MultiAPIManager()
-        self.web_search = get_web_search()
-        self._setup_routes()
-        self._setup_trainer()
-        logger.success("🚀 AKIRA V21 BRUTAL ATUALIZADA inicializada (compatível com novo index.js)")
-
-    def _setup_trainer(self):
-        """Inicializa treinamento periódico"""
+        
+        # Configura treinamento se habilitado
         if config.START_PERIODIC_TRAINER:
             try:
-                treinador = Treinamento(
+                self.treinador = Treinamento(
                     self.db, 
                     interval_hours=config.TRAINING_INTERVAL_HOURS
                 )
-                treinador.start_periodic_training()
+                self.treinador.start_periodic_training()
                 logger.info("✅ Treinamento periódico iniciado")
             except Exception as e:
                 logger.error(f"❌ Erro no treinador: {e}")
+                self.treinador = None
+        
+        self._setup_routes()
+        logger.success("🚀 AKIRA V21 FINAL inicializada")
 
     def _get_user_context(self, numero: str, tipo_conversa: str, grupo_id: str = "") -> Contexto:
-        """Obtém contexto isolado por usuário/grupo"""
-        # Chave única para cache
+        """Obtém contexto isolado"""
         if tipo_conversa == "grupo" and grupo_id:
             key = f"grupo_{grupo_id}"
         else:
             key = f"pv_{numero}"
         
-        # Retorna do cache se disponível
+        # Cache
         if key in self.contexto_cache:
             return self.contexto_cache[key]
         
-        # Cria novo contexto
-        ctx = Contexto(db=self.db, usuario=key)
+        # Cria novo contexto usando a função correta
+        ctx = criar_contexto(self.db, key, tipo_conversa)
         self.contexto_cache[key] = ctx
         return ctx
 
     def _processar_reset(self, numero: str, usuario: str, confirmacao: bool = False) -> Dict[str, Any]:
         """Processa comando /reset"""
-        # Verifica permissão
+        # Verifica permissão usando método CORRETO
         if not self.db.pode_usar_reset(numero):
             return {
                 "error": "COMANDO RESTRITO",
-                "resposta": "Só o boss pode usar /reset, puto. Vai sonhar."
+                "resposta": "Só o boss pode usar /reset, puto."
             }
         
         if not confirmacao:
@@ -423,7 +401,7 @@ class AkiraAPI:
         }
 
     def _extrair_payload_indexjs(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extrai e formata dados do payload do NOVO index.js (com mensagem_citada completa)"""
+        """Extrai dados do payload do index.js"""
         payload = {
             'numero': str(data.get('numero', '')).strip(),
             'usuario': data.get('usuario', 'Anônimo').strip(),
@@ -433,30 +411,12 @@ class AkiraAPI:
             'grupo_id': data.get('grupo_id', ''),
             'grupo_nome': data.get('grupo_nome', ''),
             'is_reset': False,
-            'reply_metadata': data.get('reply_metadata', {}),  # AGORA É reply_metadata
-            'reply_info': data.get('reply_info', {}),  # Mantém para compatibilidade
-            'mensagem_citada': data.get('mensagem_citada', '')  # AGORA RECEBE DIRETO DO PAYLOAD
+            'reply_metadata': data.get('reply_metadata', {}),
+            'mensagem_citada': data.get('mensagem_citada', '')
         }
         
-        # Log do que foi recebido
-        logger.debug(f"📦 Payload recebido:")
-        logger.debug(f"  Usuário: {payload['usuario']}")
-        logger.debug(f"  Mensagem: {payload['mensagem'][:80]}...")
-        logger.debug(f"  Mensagem citada: {payload['mensagem_citada'][:80] if payload['mensagem_citada'] else '[Nenhuma]'}...")
-        logger.debug(f"  Reply metadata: {payload['reply_metadata']}")
-        logger.debug(f"  É reply: {payload['reply_metadata'].get('is_reply', False) if payload['reply_metadata'] else False}")
-        
-        # CORREÇÃO: Preferir reply_metadata, mas manter compatibilidade com reply_info
-        reply_data = payload['reply_metadata'] if payload['reply_metadata'] else payload['reply_info']
-        
-        # Se não tem mensagem_citada diretamente, tenta extrair do reply_data
-        if not payload['mensagem_citada'] and reply_data:
-            # Tenta várias chaves possíveis
-            for key in ['texto_mensagem_citada', 'texto', 'mensagem_citada', 'quoted_text']:
-                if key in reply_data and reply_data[key]:
-                    payload['mensagem_citada'] = reply_data[key]
-                    logger.debug(f"  Extraído mensagem_citada de {key}")
-                    break
+        # Log básico
+        logger.debug(f"📦 Payload recebido de {payload['usuario']}")
         
         # Detecta /reset
         if payload['mensagem'].strip().lower() == '/reset':
@@ -464,48 +424,12 @@ class AkiraAPI:
             
         return payload
 
-    def _buscar_informacao_web(self, mensagem: str) -> str:
-        """Executa busca web se necessário"""
-        try:
-            intencao_busca = WebSearch.detectar_intencao_busca(mensagem)
-            
-            if not intencao_busca:
-                return ""
-            
-            if intencao_busca == "noticias":
-                return self.web_search.pesquisar_noticias_angola()
-            elif intencao_busca == "clima":
-                # Extrai cidade da mensagem
-                cidade_match = re.search(r'(clima|tempo)(?: em| de)?\s+([A-Za-zÀ-ÿ\s]+)', mensagem, re.I)
-                cidade = cidade_match.group(2).strip() if cidade_match else "Luanda"
-                return self.web_search.buscar_clima(cidade)
-            elif intencao_busca == "busca_geral":
-                # Limpa termos de busca
-                termos = mensagem.lower()
-                palavras_remover = [
-                    "busca", "pesquisa", "pesquisar", "procurar", "procura",
-                    "web", "internet", "google", "wikipedia", "site",
-                    "informações", "dados", "saber", "conhecer", "descobrir",
-                    "me diz", "me fala", "diz", "fala", "explica"
-                ]
-                for palavra in palavras_remover:
-                    termos = re.sub(rf'\b{re.escape(palavra)}\b', '', termos, flags=re.I)
-                termos = termos.strip()
-                
-                if termos and len(termos) > 2:
-                    return self.web_search.buscar_geral(termos)
-                    
-        except Exception as e:
-            logger.warning(f"Erro na busca web: {e}")
-            
-        return ""
-
     def _setup_routes(self):
-        """Configura rotas da API ATUALIZADAS"""
+        """Configura rotas da API"""
         
         @self.api.before_request
         def handle_options():
-            """Lida com requisições OPTIONS para CORS"""
+            """Lida com CORS preflight"""
             if request.method == 'OPTIONS':
                 resp = make_response()
                 resp.headers['Access-Control-Allow-Origin'] = '*'
@@ -515,27 +439,24 @@ class AkiraAPI:
 
         @self.api.after_request
         def add_cors(resp):
-            """Adiciona headers CORS a todas as respostas"""
+            """Adiciona headers CORS"""
             resp.headers['Access-Control-Allow-Origin'] = '*'
             return resp
 
         @self.api.route('/akira', methods=['POST'])
         def akira_endpoint():
-            """Endpoint principal - TOTALMENTE COMPATÍVEL com NOVO index.js"""
+            """Endpoint principal"""
             try:
-                # Recebe e processa payload
+                # Recebe payload
                 data = request.get_json() or {}
                 payload = self._extrair_payload_indexjs(data)
                 
-                # Log detalhado da requisição
                 logger.info(
-                    f"📨 [{payload['usuario']}] ({payload['numero']}) "
-                    f"[{payload['tipo_conversa']}]: {payload['mensagem'][:80]}..."
+                    f"📨 [{payload['usuario']}] ({payload['numero']}): "
+                    f"{payload['mensagem'][:80]}..."
                 )
-                if payload['mensagem_citada']:
-                    logger.info(f"📝 Mensagem citada: {payload['mensagem_citada'][:80]}...")
                 
-                # Validação básica
+                # Validação
                 if not payload['mensagem']:
                     return jsonify({'error': 'Mensagem obrigatória'}), 400
                 
@@ -550,141 +471,124 @@ class AkiraAPI:
                         return jsonify(resultado), 403
                     return jsonify(resultado)
                 
-                # Busca web (se necessário)
-                contexto_web = ""
-                if len(payload['mensagem']) > 10:  # Só busca para mensagens mais longas
-                    contexto_web = self._buscar_informacao_web(payload['mensagem'])
-                
-                # Obtém contexto isolado
+                # Obtém contexto
                 contexto = self._get_user_context(
                     numero=payload['numero'],
                     tipo_conversa=payload['tipo_conversa'],
                     grupo_id=payload['grupo_id']
                 )
                 
+                # Atualiza informações do usuário
+                contexto.atualizar_informacoes_usuario(
+                    nome=payload['usuario'],
+                    numero=payload['numero'],
+                    grupo_id=payload['grupo_id'],
+                    grupo_nome=payload['grupo_nome'],
+                    tipo_conversa=payload['tipo_conversa']
+                )
+                
                 # Obtém histórico
                 historico = contexto.obter_historico_para_llm()
                 
-                # Verifica se usuário é privilegiado
+                # Verifica usuário privilegiado
                 usuario_privilegiado = self.db.is_usuario_privilegiado(payload['numero'])
                 
-                # Analisa a mensagem (com mensagem_citada completa)
+                # Analisa a mensagem
                 analise = contexto.analisar_intencao_e_normalizar(
-                    payload['mensagem'], 
-                    historico, 
-                    payload['mensagem_citada']
+                    mensagem=payload['mensagem'],
+                    historico=historico,
+                    mensagem_citada=payload['mensagem_citada'],
+                    reply_metadata=payload['reply_metadata']
                 )
                 
-                # ADAPTAÇÃO: Prepara reply_info para passar ao config.py
-                # Preferir reply_metadata, mas manter compatibilidade
-                reply_info_for_config = payload['reply_metadata'] if payload['reply_metadata'] else payload['reply_info']
-                
-                # Adiciona informações extras à análise (INCLUI reply_metadata)
+                # Adiciona informações extras
                 analise.update({
                     'usuario_privilegiado': usuario_privilegiado,
                     'numero': payload['numero'],
                     'tipo_mensagem': payload['tipo_mensagem'],
-                    'reply_metadata': payload['reply_metadata'],  # ENVIA PARA CONFIG.PY
-                    'reply_info': reply_info_for_config  # Para compatibilidade
+                    'reply_metadata': payload['reply_metadata']
                 })
                 
-                # Adiciona contexto web ao histórico se houver
-                historico_com_web = historico.copy()
-                if contexto_web:
-                    historico_com_web.append({
-                        "role": "system", 
-                        "content": f"[INFO WEB]: {contexto_web}"
-                    })
+                # Prepara reply_info para config.py
+                reply_info_for_config = payload['reply_metadata']
                 
-                # Gera resposta (PASSA mensagem_citada COMPLETA e reply_info)
+                # Gera resposta
                 resposta = self.llm_manager.gerar_resposta(
                     mensagem=payload['mensagem'],
-                    historico=historico_com_web,
-                    mensagem_citada=payload['mensagem_citada'],  # ENVIA COMPLETA
+                    historico=historico,
+                    mensagem_citada=payload['mensagem_citada'],
                     analise=analise,
                     usuario=payload['usuario'],
                     tipo_conversa=payload['tipo_conversa'],
-                    reply_info=reply_info_for_config  # PASSA PARA CONFIG.PY
+                    reply_info=reply_info_for_config
                 )
                 
-                # Determina se é reply e reply_to_bot (USANDO reply_metadata)
-                is_reply = bool(payload['mensagem_citada']) or (payload['reply_metadata'] and payload['reply_metadata'].get('is_reply', False))
+                # Determina se é reply
+                is_reply = bool(payload['mensagem_citada']) or (
+                    payload['reply_metadata'] and payload['reply_metadata'].get('is_reply', False)
+                )
                 reply_to_bot = False
                 
                 if payload['reply_metadata']:
                     reply_to_bot = payload['reply_metadata'].get('reply_to_bot', False)
-                elif payload['reply_info']:
-                    reply_to_bot = payload['reply_info'].get('reply_to_bot', False)
-                elif payload['mensagem_citada'] and payload['mensagem_citada'].startswith("[Respondendo à Akira:"):
-                    reply_to_bot = True
                 
-                # Atualiza contexto (INCLUI mensagem_citada completa)
+                # Atualiza contexto
                 contexto.atualizar_contexto(
                     mensagem=payload['mensagem'],
                     resposta=resposta,
                     numero=payload['numero'],
                     is_reply=is_reply,
-                    mensagem_original=payload['mensagem_citada'],  # GUARDA COMPLETA
+                    mensagem_original=payload['mensagem_citada'],
                     reply_to_bot=reply_to_bot
                 )
                 
-                # Registra interação para treinamento (COM CONTEXTO COMPLETO)
-                try:
-                    trainer = Treinamento(self.db)
-                    trainer.registrar_interacao(
-                        usuario=payload['usuario'],
-                        mensagem=payload['mensagem'],
-                        resposta=resposta,
-                        numero=payload['numero'],
-                        is_reply=is_reply,
-                        mensagem_original=payload['mensagem_citada'],  # REGISTRA COMPLETA
-                        contexto=analise,
-                        tipo_conversa=payload['tipo_conversa'],
-                        tipo_mensagem=payload['tipo_mensagem'],
-                        reply_metadata=payload['reply_metadata']  # REGISTRA METADATA
-                    )
-                except Exception as e:
-                    logger.warning(f"⚠️ Erro ao registrar interação: {e}")
+                # Registra interação para treinamento
+                if hasattr(self, 'treinador') and self.treinador:
+                    try:
+                        self.treinador.registrar_interacao(
+                            usuario=payload['usuario'],
+                            mensagem=payload['mensagem'],
+                            resposta=resposta,
+                            numero=payload['numero'],
+                            is_reply=is_reply,
+                            mensagem_original=payload['mensagem_citada'],
+                            contexto=analise,
+                            tipo_conversa=payload['tipo_conversa'],
+                            tipo_mensagem=payload['tipo_mensagem'],
+                            reply_to_bot=reply_to_bot,
+                            reply_metadata=payload['reply_metadata']
+                        )
+                    except Exception as e:
+                        logger.warning(f"⚠️ Erro ao registrar interação: {e}")
                 
-                # Log da resposta
-                logger.info(f"📤 Resposta gerada: {resposta[:80]}...")
+                logger.info(f"📤 Resposta: {resposta[:80]}...")
                 
                 return jsonify({"resposta": resposta})
                 
             except Exception as e:
-                logger.error(f"❌ Erro crítico em /akira: {e}")
+                logger.error(f"❌ Erro em /akira: {e}")
                 import traceback
-                logger.error(traceback.format_exc())
+                traceback.print_exc()
                 return jsonify({
                     "error": "Erro interno",
-                    "details": str(e)[:100],
-                    "resposta": "Barra no bardeado, puto. Erro interno."
+                    "resposta": "Erro interno, puto. Tenta de novo."
                 }), 500
 
         @self.api.route('/health', methods=['GET'])
         def health():
-            """Endpoint de health check ATUALIZADO"""
+            """Health check"""
             agora = datetime.datetime.now() + datetime.timedelta(hours=config.TIMEZONE_OFFSET_HOURS)
             return jsonify({
-                "status": "✅ AKIRA V21 BRUTAL ONLINE (ATUALIZADA)",
+                "status": "✅ AKIRA V21 ONLINE",
                 "hora_luanda": agora.strftime("%H:%M"),
-                "versao": "Dezembro 2025 - Mensagem Citada Completa",
+                "versao": config.VERSAO,
                 "apis_disponiveis": self.llm_manager.apis_disponiveis,
-                "compatibilidade": {
-                    "index_js_atualizado": True,
-                    "mensagem_citada_completa": True,
-                    "reply_metadata": True,
-                    "contexto_completo": True
-                },
-                "estatisticas": {
-                    "cache_size": len(self.contexto_cache._store),
-                    "apis_ativas": len(self.llm_manager.apis_disponiveis)
-                }
+                "cache_size": len(self.contexto_cache._store)
             })
 
         @self.api.route('/reset', methods=['POST'])
         def reset_endpoint():
-            """Endpoint dedicado para reset"""
+            """Endpoint de reset dedicado"""
             try:
                 data = request.get_json() or {}
                 numero = str(data.get('numero', '')).strip()
@@ -705,35 +609,27 @@ class AkiraAPI:
 
         @self.api.route('/info', methods=['GET'])
         def info():
-            """Informações sobre a API ATUALIZADA"""
+            """Informações da API"""
             return jsonify({
-                "nome": "Akira V21 (ATUALIZADA)",
-                "descricao": "IA com personalidade brutal e irônica - COM CONTEXTO COMPLETO",
+                "nome": "Akira V21",
+                "descricao": "IA com personalidade brutal e irônica",
                 "desenvolvedor": "Isaac Quarenta",
                 "empresa": "Softedge",
                 "versao": config.VERSAO,
                 "endpoints": ["/akira", "/health", "/reset", "/info"],
-                "caracteristicas": [
-                    "Mensagem citada completa",
-                    "Contexto de reply otimizado",
-                    "Xingamento automático",
-                    "Respostas curtas e brutais",
-                    "Compatível com novo index.js"
-                ],
                 "configuracoes": {
                     "temperatura_padrao": config.TEMPERATURE,
                     "max_tokens": config.MAX_TOKENS,
-                    "timezone_offset": config.TIMEZONE_OFFSET_HOURS,
-                    "apis_suportadas": config.API_FALLBACK_ORDER
+                    "timezone_offset": config.TIMEZONE_OFFSET_HOURS
                 }
             })
 
     def get_blueprint(self):
-        """Retorna o blueprint para registro no Flask"""
+        """Retorna o blueprint para Flask"""
         return self.api
 
 # ============================================================================
-# 🎯 FUNÇÃO PARA USO DIRETO (ATUALIZADA)
+# 🎯 FUNÇÃO PARA USO DIRETO
 # ============================================================================
 def gerar_resposta_direta(
     mensagem: str,
@@ -742,32 +638,38 @@ def gerar_resposta_direta(
     tipo_conversa: str = "pv",
     tipo_mensagem: str = "texto",
     mensagem_citada: str = "",
-    reply_metadata: Optional[Dict] = None,
-    reply_info: Optional[Dict] = None
+    reply_metadata: Optional[Dict] = None
 ) -> str:
     """
-    Função para uso direto (sem HTTP) - ATUALIZADA
-    Útil para testes e integração direta com contexto completo
+    Função para uso direto (sem HTTP)
+    
+    Args:
+        mensagem: Mensagem do usuário
+        usuario: Nome do usuário
+        numero: Número do usuário
+        tipo_conversa: Tipo da conversa
+        tipo_mensagem: Tipo da mensagem
+        mensagem_citada: Mensagem citada
+        reply_metadata: Metadata do reply
+        
+    Returns:
+        Resposta gerada
     """
     try:
         # Cria instância
         api = AkiraAPI()
         
-        # Prepara análise básica com contexto
+        # Prepara análise
         analise = {
             "numero": numero,
             "usuario_privilegiado": api.db.is_usuario_privilegiado(numero),
             "emocao_primaria": "neutral",
             "modo_resposta": "normal_ironico",
             "tipo_mensagem": tipo_mensagem,
-            "reply_metadata": reply_metadata,
-            "reply_info": reply_info or reply_metadata
+            "reply_metadata": reply_metadata
         }
         
-        # Prepara reply_info para config.py
-        reply_info_for_config = reply_metadata if reply_metadata else reply_info
-        
-        # Gera resposta com contexto completo
+        # Gera resposta
         resposta = api.llm_manager.gerar_resposta(
             mensagem=mensagem,
             historico=[],
@@ -775,49 +677,46 @@ def gerar_resposta_direta(
             analise=analise,
             usuario=usuario,
             tipo_conversa=tipo_conversa,
-            reply_info=reply_info_for_config
+            reply_info=reply_metadata
         )
         
-        logger.info(f"✅ Resposta direta gerada para {usuario}: {resposta[:80]}...")
+        logger.info(f"✅ Resposta direta para {usuario}: {resposta[:80]}...")
         return resposta
         
     except Exception as e:
         logger.error(f"❌ Erro na resposta direta: {e}")
-        return "Erro ao processar mensagem."
+        return "Erro ao processar."
 
 # ============================================================================
-# 🎯 TESTE RÁPIDO - ATUALIZADO PARA NOVO CONTEXTO
+# 🎯 TESTE
 # ============================================================================
 if __name__ == "__main__":
     print("=" * 80)
-    print("TESTANDO API.PY ATUALIZADA - COMPATIBILIDADE COM NOVO INDEX.JS")
+    print("TESTANDO API.PY - FINAL INTEGRADO")
     print("=" * 80)
     
-    # Teste com payload do NOVO index.js (com mensagem_citada completa)
+    # Teste simples
     test_payload = {
         "numero": "244978787009",
         "usuario": "Isaac Quarenta",
-        "mensagem": "Você disse que gosta de futebol, né? O que acha do jogo de ontem?",
+        "mensagem": "Oi Akira, tudo bem?",
         "tipo_conversa": "pv",
         "tipo_mensagem": "texto",
-        "mensagem_citada": "Sim, gosto do Petro de Luanda. É o melhor time de Angola, sem discussão. Jogo de qualidade europeia.",
+        "mensagem_citada": "",
         "reply_metadata": {
-            "is_reply": True,
-            "reply_to_bot": True,
-            "quoted_author_name": "Akira",
-            "quoted_type": "texto",
-            "context_hint": "(Usuário está respondendo à MINHA mensagem anterior: \"Sim, gosto do Petro de Luanda. É o me...\")"
+            "is_reply": False,
+            "reply_to_bot": False
         }
     }
     
     try:
-        # Testa função direta com contexto completo
+        # Usa função direta
         resposta = gerar_resposta_direta(
             mensagem=test_payload["mensagem"],
             usuario=test_payload["usuario"],
             numero=test_payload["numero"],
             tipo_conversa=test_payload["tipo_conversa"],
-            reply_info=test_payload["reply_info"]
+            reply_metadata=test_payload["reply_metadata"]
         )
         
         print(f"✅ Teste OK")
@@ -830,5 +729,5 @@ if __name__ == "__main__":
         traceback.print_exc()
     
     print("\n" + "=" * 80)
-    print("API.PY - PRONTO PARA USO")
+    print("API.PY - INTEGRADO E PRONTO PARA USO")
     print("=" * 80)