Update modules/api.py

modules/api.py

@@ -1,12 +1,12 @@
-# modules/api.py — AKIRA V21 FINAL CORRIGIDO
+# modules/api.py — AKIRA V21 FINAL ADAPTADO (DEZEMBRO 2025)
 """
-✅ TOTALMENTE ADAPTADO ao config.py BRUTAL
-✅ TOTALMENTE COMPATÍVEL com index.js otimizado
+✅ 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
-✅ Processa reply_info do index.js corretamente
-✅ CORREÇÃO: Instância correta sem parâmetros
+✅ 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)
 """
 import time
 import datetime
@@ -59,7 +59,7 @@ class SimpleTTLCache:
             return default
 
 # ============================================================================
-# 🧠 GERENCIADOR MULTI-API (OTIMIZADO)
+# 🧠 GERENCIADOR MULTI-API (OTIMIZADO PARA NOVO CONTEXTO)
 # ============================================================================
 class MultiAPIManager:
     def __init__(self):
@@ -90,11 +90,17 @@ class MultiAPIManager:
         reply_info: Optional[Dict] = None
     ) -> str:
         """
-        Constrói prompt usando a função do config.py BRUTAL
-        TOTALMENTE COMPATÍVEL com o index.js otimizado
+        Constrói prompt usando a função do config.py ATUALIZADO
+        TOTALMENTE COMPATÍVEL com o novo index.js (mensagem_citada completa)
         """
         try:
-            # Usa a função principal do config.py (construir_prompt_api)
+            # 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
             prompt = config.construir_prompt_api(
                 mensagem=mensagem,
                 historico=historico,
@@ -105,15 +111,21 @@ class MultiAPIManager:
                 reply_info=reply_info
             )
             
-            logger.debug(f"📝 Prompt construído: {len(prompt)} caracteres")
+            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
+            logger.error(f"❌ Erro ao construir prompt: {e}")
+            # Fallback para prompt simples (com mensagem citada)
             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}
 
@@ -124,7 +136,7 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
         emocao = analise.get("emocao_primaria", "neutral")
         modo = analise.get("modo_resposta", "normal_ironico")
         
-        # Usa função do config.py
+        # Usa função do config.py atualizado
         return config.obter_parametros_api(emocao, modo)
 
     def gerar_resposta(
@@ -137,8 +149,16 @@ 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"""
-        # Construir prompt
+        """Gera resposta usando multi-API fallback (com contexto completo)"""
+        # Log do que está sendo processado
+        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
         prompt = self._construir_prompt(
             mensagem=mensagem,
             historico=historico,
@@ -160,25 +180,19 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
                 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.debug(f"✅ API {api_name} respondeu: {resposta_limpa[:100]}...")
+                    logger.info(f"✅ API {api_name} respondeu: {resposta_limpa[:100]}...")
                     return resposta_limpa
                     
             except Exception as e:
-                logger.debug(f"❌ API {api_name} falhou: {str(e)[:100]}")
+                logger.warning(f"❌ API {api_name} falhou: {str(e)[:100]}")
                 continue
         
-        # Fallback: respostas curtas e brutais
-        fallbacks = [
-            "Puto, nem ligo.",
-            "Foda-se.",
-            "Ya, tá bom.",
-            "Caralho.",
-            "Não quero saber.",
-            "Vai à merda."
-        ]
+        # Fallback: respostas curtas e brutais baseadas no contexto
+        fallbacks = self._gerar_fallback_contextual(mensagem, mensagem_citada, reply_info)
         return random.choice(fallbacks)
 
     def _chamar_api(self, api_name: str, prompt: str, parametros: Dict[str, Any]) -> str:
@@ -285,18 +299,66 @@ RESPONDA COMO AKIRA (IRÔNICA, SEM FILTRO, 1-2 LINHAS):"""
         # Remove prefixos como "Akira:" ou "AKIRA:"
         texto = re.sub(r'^(Akira|AKIRA)[:\s\-]+', '', texto, flags=re.IGNORECASE)
         
-        # Limita tamanho
+        # Remove "Resposta:" ou "Resposta de Akira:"
+        texto = re.sub(r'^(Resposta|Resposta de Akira)[:\s\-]+', '', texto, flags=re.IGNORECASE)
+        
+        # Remove múltiplos espaços
+        texto = re.sub(r'\s+', ' ', texto)
+        
+        # Limita tamanho (mas preserva contexto)
         if len(texto) > 400:
-            texto = texto[:397] + "..."
+            # Tenta encontrar um ponto final próximo
+            last_period = texto[:397].rfind('.')
+            if last_period > 300:
+                texto = texto[:last_period + 1]
+            else:
+                texto = texto[:397] + "..."
             
         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 = [
+            "Puto, nem ligo.",
+            "Foda-se.",
+            "Ya, tá bom.",
+            "Caralho.",
+            "Não quero saber.",
+            "Vai à merda.",
+            "Tás a brincar?",
+            "Ok.",
+            "Sim.",
+            "Não."
+        ]
+        
+        # Se há mensagem citada, adiciona fallbacks contextuais
+        if mensagem_citada:
+            contextual_fallbacks = [
+                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 = [
+                "Já disse isso, caralho.",
+                "Repito o que disse.",
+                "Ya, como eu disse.",
+                "Exactamente o que falei."
+            ]
+            base_fallbacks.extend(reply_fallbacks)
+        
+        return base_fallbacks
+
 # ============================================================================
-# 🎯 CLASSE PRINCIPAL AKIRA API
+# 🎯 CLASSE PRINCIPAL AKIRA API (ATUALIZADA)
 # ============================================================================
 class AkiraAPI:
     def __init__(self):
-        """CORREÇÃO: Não aceita parâmetros - usa config.py diretamente"""
+        """CORREÇÃO: Não aceita parâmetros - usa config.py atualizado diretamente"""
         self.api = Blueprint("akira_api", __name__)
         self.contexto_cache = SimpleTTLCache(ttl_seconds=300)
         self.db = Database(config.DB_PATH)
@@ -304,7 +366,7 @@ class AkiraAPI:
         self.web_search = get_web_search()
         self._setup_routes()
         self._setup_trainer()
-        logger.success("🚀 AKIRA V21 BRUTAL inicializada (compatível com index.js)")
+        logger.success("🚀 AKIRA V21 BRUTAL ATUALIZADA inicializada (compatível com novo index.js)")
 
     def _setup_trainer(self):
         """Inicializa treinamento periódico"""
@@ -361,7 +423,7 @@ class AkiraAPI:
         }
 
     def _extrair_payload_indexjs(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extrai e formata dados do payload do index.js"""
+        """Extrai e formata dados do payload do NOVO index.js (com mensagem_citada completa)"""
         payload = {
             'numero': str(data.get('numero', '')).strip(),
             'usuario': data.get('usuario', 'Anônimo').strip(),
@@ -371,15 +433,30 @@ class AkiraAPI:
             'grupo_id': data.get('grupo_id', ''),
             'grupo_nome': data.get('grupo_nome', ''),
             'is_reset': False,
-            'reply_info': data.get('reply_info'),
-            'mensagem_citada': ''
+            '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
         }
         
-        # Processa mensagem_citada do payload
-        if 'mensagem_citada' in data:
-            payload['mensagem_citada'] = data['mensagem_citada']
-        elif data.get('reply_info') and data['reply_info'].get('texto_mensagem_citada'):
-            payload['mensagem_citada'] = data['reply_info']['texto_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
         
         # Detecta /reset
         if payload['mensagem'].strip().lower() == '/reset':
@@ -424,7 +501,7 @@ class AkiraAPI:
         return ""
 
     def _setup_routes(self):
-        """Configura rotas da API"""
+        """Configura rotas da API ATUALIZADAS"""
         
         @self.api.before_request
         def handle_options():
@@ -444,17 +521,19 @@ class AkiraAPI:
 
         @self.api.route('/akira', methods=['POST'])
         def akira_endpoint():
-            """Endpoint principal - TOTALMENTE COMPATÍVEL com index.js"""
+            """Endpoint principal - TOTALMENTE COMPATÍVEL com NOVO index.js"""
             try:
                 # Recebe e processa payload
                 data = request.get_json() or {}
                 payload = self._extrair_payload_indexjs(data)
                 
-                # Log da requisição
+                # Log detalhado da requisição
                 logger.info(
                     f"📨 [{payload['usuario']}] ({payload['numero']}) "
                     f"[{payload['tipo_conversa']}]: {payload['mensagem'][:80]}..."
                 )
+                if payload['mensagem_citada']:
+                    logger.info(f"📝 Mensagem citada: {payload['mensagem_citada'][:80]}...")
                 
                 # Validação básica
                 if not payload['mensagem']:
@@ -489,19 +568,24 @@ class AkiraAPI:
                 # Verifica se usuário é privilegiado
                 usuario_privilegiado = self.db.is_usuario_privilegiado(payload['numero'])
                 
-                # Analisa a mensagem (com reply_info do payload)
+                # Analisa a mensagem (com mensagem_citada completa)
                 analise = contexto.analisar_intencao_e_normalizar(
                     payload['mensagem'], 
                     historico, 
                     payload['mensagem_citada']
                 )
                 
-                # Adiciona informações extras à análise
+                # 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)
                 analise.update({
                     'usuario_privilegiado': usuario_privilegiado,
                     'numero': payload['numero'],
                     'tipo_mensagem': payload['tipo_mensagem'],
-                    'reply_info': payload.get('reply_info')
+                    'reply_metadata': payload['reply_metadata'],  # ENVIA PARA CONFIG.PY
+                    'reply_info': reply_info_for_config  # Para compatibilidade
                 })
                 
                 # Adiciona contexto web ao histórico se houver
@@ -512,37 +596,39 @@ class AkiraAPI:
                         "content": f"[INFO WEB]: {contexto_web}"
                     })
                 
-                # Gera resposta (PASSA reply_info para o LLM)
+                # Gera resposta (PASSA mensagem_citada COMPLETA e reply_info)
                 resposta = self.llm_manager.gerar_resposta(
                     mensagem=payload['mensagem'],
                     historico=historico_com_web,
-                    mensagem_citada=payload['mensagem_citada'],
+                    mensagem_citada=payload['mensagem_citada'],  # ENVIA COMPLETA
                     analise=analise,
                     usuario=payload['usuario'],
                     tipo_conversa=payload['tipo_conversa'],
-                    reply_info=payload.get('reply_info')
+                    reply_info=reply_info_for_config  # PASSA PARA CONFIG.PY
                 )
                 
-                # Determina se é reply e reply_to_bot
-                is_reply = bool(payload['mensagem_citada']) or bool(payload.get('reply_info'))
+                # 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))
                 reply_to_bot = False
                 
-                if payload.get('reply_info'):
+                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
+                # Atualiza contexto (INCLUI mensagem_citada completa)
                 contexto.atualizar_contexto(
                     mensagem=payload['mensagem'],
                     resposta=resposta,
                     numero=payload['numero'],
                     is_reply=is_reply,
-                    mensagem_original=payload['mensagem_citada'],
+                    mensagem_original=payload['mensagem_citada'],  # GUARDA COMPLETA
                     reply_to_bot=reply_to_bot
                 )
                 
-                # Registra interação para treinamento
+                # Registra interação para treinamento (COM CONTEXTO COMPLETO)
                 try:
                     trainer = Treinamento(self.db)
                     trainer.registrar_interacao(
@@ -551,16 +637,17 @@ class AkiraAPI:
                         resposta=resposta,
                         numero=payload['numero'],
                         is_reply=is_reply,
-                        mensagem_original=payload['mensagem_citada'],
+                        mensagem_original=payload['mensagem_citada'],  # REGISTRA COMPLETA
                         contexto=analise,
                         tipo_conversa=payload['tipo_conversa'],
-                        tipo_mensagem=payload['tipo_mensagem']
+                        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}")
+                    logger.warning(f"⚠️ Erro ao registrar interação: {e}")
                 
                 # Log da resposta
-                logger.info(f"📤 Resposta: {resposta[:80]}...")
+                logger.info(f"📤 Resposta gerada: {resposta[:80]}...")
                 
                 return jsonify({"resposta": resposta})
                 
@@ -570,22 +657,28 @@ class AkiraAPI:
                 logger.error(traceback.format_exc())
                 return jsonify({
                     "error": "Erro interno",
-                    "details": str(e)[:100]
+                    "details": str(e)[:100],
+                    "resposta": "Barra no bardeado, puto. Erro interno."
                 }), 500
 
         @self.api.route('/health', methods=['GET'])
         def health():
-            """Endpoint de health check"""
+            """Endpoint de health check ATUALIZADO"""
             agora = datetime.datetime.now() + datetime.timedelta(hours=config.TIMEZONE_OFFSET_HOURS)
             return jsonify({
-                "status": "✅ AKIRA V21 BRUTAL ONLINE",
+                "status": "✅ AKIRA V21 BRUTAL ONLINE (ATUALIZADA)",
                 "hora_luanda": agora.strftime("%H:%M"),
-                "versao": "Dezembro 2025",
+                "versao": "Dezembro 2025 - Mensagem Citada Completa",
                 "apis_disponiveis": self.llm_manager.apis_disponiveis,
                 "compatibilidade": {
-                    "index_js": True,
-                    "reply_info": True,
-                    "contexto_otimizado": True
+                    "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)
                 }
             })
 
@@ -612,17 +705,26 @@ class AkiraAPI:
 
         @self.api.route('/info', methods=['GET'])
         def info():
-            """Informações sobre a API"""
+            """Informações sobre a API ATUALIZADA"""
             return jsonify({
-                "nome": "Akira V21",
-                "descricao": "IA com personalidade brutal e irônica",
+                "nome": "Akira V21 (ATUALIZADA)",
+                "descricao": "IA com personalidade brutal e irônica - COM CONTEXTO COMPLETO",
                 "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
+                    "timezone_offset": config.TIMEZONE_OFFSET_HOURS,
+                    "apis_suportadas": config.API_FALLBACK_ORDER
                 }
             })
 
@@ -631,7 +733,7 @@ class AkiraAPI:
         return self.api
 
 # ============================================================================
-# 🎯 FUNÇÃO PARA USO DIRETO
+# 🎯 FUNÇÃO PARA USO DIRETO (ATUALIZADA)
 # ============================================================================
 def gerar_resposta_direta(
     mensagem: str,
@@ -640,26 +742,32 @@ 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
 ) -> str:
     """
-    Função para uso direto (sem HTTP)
-    Útil para testes e integração direta
+    Função para uso direto (sem HTTP) - ATUALIZADA
+    Útil para testes e integração direta com contexto completo
     """
     try:
         # Cria instância
         api = AkiraAPI()
         
-        # Prepara análise básica
+        # Prepara análise básica com contexto
         analise = {
             "numero": numero,
             "usuario_privilegiado": api.db.is_usuario_privilegiado(numero),
             "emocao_primaria": "neutral",
             "modo_resposta": "normal_ironico",
-            "tipo_mensagem": tipo_mensagem
+            "tipo_mensagem": tipo_mensagem,
+            "reply_metadata": reply_metadata,
+            "reply_info": reply_info or reply_metadata
         }
         
-        # Gera resposta
+        # Prepara reply_info para config.py
+        reply_info_for_config = reply_metadata if reply_metadata else reply_info
+        
+        # Gera resposta com contexto completo
         resposta = api.llm_manager.gerar_resposta(
             mensagem=mensagem,
             historico=[],
@@ -667,39 +775,43 @@ def gerar_resposta_direta(
             analise=analise,
             usuario=usuario,
             tipo_conversa=tipo_conversa,
-            reply_info=reply_info
+            reply_info=reply_info_for_config
         )
         
+        logger.info(f"✅ Resposta direta gerada para {usuario}: {resposta[:80]}...")
         return resposta
         
     except Exception as e:
-        logger.error(f"Erro na resposta direta: {e}")
+        logger.error(f"❌ Erro na resposta direta: {e}")
         return "Erro ao processar mensagem."
 
 # ============================================================================
-# 🎯 TESTE RÁPIDO
+# 🎯 TESTE RÁPIDO - ATUALIZADO PARA NOVO CONTEXTO
 # ============================================================================
 if __name__ == "__main__":
     print("=" * 80)
-    print("TESTANDO API.PY - COMPATIBILIDADE COM INDEX.JS")
+    print("TESTANDO API.PY ATUALIZADA - COMPATIBILIDADE COM NOVO INDEX.JS")
     print("=" * 80)
     
-    # Teste com payload do index.js
+    # Teste com payload do NOVO index.js (com mensagem_citada completa)
     test_payload = {
         "numero": "244978787009",
         "usuario": "Isaac Quarenta",
-        "mensagem": "Você disse que gosta de futebol, né?",
+        "mensagem": "Você disse que gosta de futebol, né? O que acha do jogo de ontem?",
         "tipo_conversa": "pv",
         "tipo_mensagem": "texto",
-        "reply_info": {
+        "mensagem_citada": "Sim, gosto do Petro de Luanda. É o melhor time de Angola, sem discussão. Jogo de qualidade europeia.",
+        "reply_metadata": {
+            "is_reply": True,
             "reply_to_bot": True,
-            "quem_escreveu_citacao_nome": "Akira",
-            "texto_mensagem_citada": "Sim, gosto do Petro de Luanda"
+            "quoted_author_name": "Akira",
+            "quoted_type": "texto",
+            "context_hint": "(Usuário está respondendo à MINHA mensagem anterior: \"Sim, gosto do Petro de Luanda. É o me...\")"
         }
     }
     
     try:
-        # Testa função direta
+        # Testa função direta com contexto completo
         resposta = gerar_resposta_direta(
             mensagem=test_payload["mensagem"],
             usuario=test_payload["usuario"],