Update modules/api.py

modules/api.py

@@ -1,11 +1,14 @@
-# modules/api.py — AKIRA V20 ULTIMATE (Dezembro 2025)
-"""API Flask com 6 provedores de IA em fallback cascata
-- Mistral → Gemini → Groq → Cohere → Together → HuggingFace
-- Controle estilístico avançado
-- Transições graduais de humor
-- Reply context tracking
-- Fuso horário corrigido (+1h)
-- Isolamento total PV/Grupo
+# modules/api.py — AKIRA V21 ULTIMATE (Dezembro 2025)
+"""
+API Flask com:
+✅ 6 provedores de IA em fallback cascata
+✅ Sistema emocional BERT GoEmotions
+✅ Transições graduais de humor (3 níveis)
+✅ Reply context tracking robusto
+✅ Usuários privilegiados com verificação robusta
+✅ Detecção automática de PV/Grupo via WhatsApp
+✅ Rota /reset exclusiva para root
+✅ Fuso horário corrigido (+1h)
 """
 import time
 import datetime
@@ -13,6 +16,8 @@ import requests
 import os
 import json
 import random
+import re
+from typing import Dict, Any
 from flask import Blueprint, request, jsonify, make_response
 from loguru import logger
 from .contexto import Contexto
@@ -48,8 +53,14 @@ class SimpleTTLCache:
             raise KeyError(key)
         return self._store[key][0]
 
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
 # ============================================================================
-# GERENCIADOR MULTI-API
+# GERENCIADOR MULTI-API (ATUALIZADO)
 # ============================================================================
 
 class MultiAPIManager:
@@ -62,18 +73,31 @@ class MultiAPIManager:
     def _verificar_apis(self):
         """Verifica quais APIs estão configuradas"""
         apis = []
-        if config.MISTRAL_API_KEY and config.MISTRAL_API_KEY.strip():
+        
+        # Mistral
+        if config.MISTRAL_API_KEY and len(config.MISTRAL_API_KEY) > 10:
             apis.append("mistral")
-        if config.GEMINI_API_KEY and config.GEMINI_API_KEY.strip():
+        
+        # Gemini
+        if config.GEMINI_API_KEY and config.GEMINI_API_KEY.startswith('AIza'):
             apis.append("gemini")
-        if config.GROQ_API_KEY and config.GROQ_API_KEY.strip():
+        
+        # Groq
+        if config.GROQ_API_KEY and len(config.GROQ_API_KEY) > 10:
             apis.append("groq")
-        if config.COHERE_API_KEY and config.COHERE_API_KEY.strip():
+        
+        # Cohere
+        if config.COHERE_API_KEY and len(config.COHERE_API_KEY) > 10:
             apis.append("cohere")
-        if config.TOGETHER_API_KEY and config.TOGETHER_API_KEY.strip():
+        
+        # Together
+        if config.TOGETHER_API_KEY and len(config.TOGETHER_API_KEY) > 10:
             apis.append("together")
-        if config.HF_API_KEY and config.HF_API_KEY.strip():
+        
+        # HuggingFace
+        if config.HF_API_KEY and len(config.HF_API_KEY) > 10:
             apis.append("huggingface")
+        
         return apis
 
     def _construir_prompt(
@@ -81,14 +105,11 @@ class MultiAPIManager:
         mensagem: str,
         historico: list,
         mensagem_citada: str,
-        humor: str,
-        tom_usuario: str,
-        modo_resposta: str,
+        analise: Dict[str, Any],
         usuario: str,
-        usar_nome: bool,
         tipo_conversa: str
     ) -> str:
-        """Constrói prompt otimizado com controle estilístico"""
+        """Constrói prompt otimizado com todas as regras"""
         
         # === DATA E HORA ATUAL (CORRIGIDA +1H) ===
         from datetime import datetime, timedelta
@@ -111,16 +132,20 @@ class MultiAPIManager:
         msg_lower = mensagem.lower()
         
         if any(p in msg_lower for p in ["criou", "criador", "quem fez", "desenvolveu", "softedge", "isaac"]):
-            info_context = f"\n[INFO IMPORTANTE]: {empresa_info.get_resposta_sobre_empresa(mensagem, tom_usuario == 'formal')}\n"
+            info_context = f"\n[INFO IMPORTANTE]: {empresa_info.get_resposta_sobre_empresa(mensagem, analise.get('tom_usuario') == 'formal')}\n"
         
         # === CONTEXTO DE REPLY ===
         reply_context = ""
+        reply_instruction = ""
+        
         if mensagem_citada:
             # Verifica se é reply à própria Akira
             if mensagem_citada.startswith("[Respondendo à Akira:"):
-                reply_context = f"\n[USUÁRIO ESTÁ RESPONDENDO À SUA MENSAGEM ANTERIOR]: {mensagem_citada}\n"
+                reply_context = f"\n[CONTEXTO DE REPLY]: O usuário está respondendo à SUA mensagem anterior: '{mensagem_citada[23:100]}...'"
+                reply_instruction = "Reconheça que é reply à sua mensagem anterior e responda apropriadamente."
             else:
-                reply_context = f"\n[USUÁRIO ESTÁ RESPONDENDO A OUTRA MENSAGEM]: {mensagem_citada}\n"
+                reply_context = f"\n[CONTEXTO DE REPLY]: O usuário está respondendo a outra mensagem: '{mensagem_citada[:100]}...'"
+                reply_instruction = "Considere o contexto do reply mas responda à mensagem atual do usuário."
         
         # === HISTÓRICO FORMATADO ===
         historico_texto = ""
@@ -132,29 +157,62 @@ class MultiAPIManager:
                 historico_texto += f"{role.upper()}: {content}\n"
         
         # === CONFIGURAÇÃO DO MODO DE RESPOSTA ===
+        modo_resposta = analise.get("modo_resposta", "normal_ironico")
         modo_config = config.MODOS_RESPOSTA.get(modo_resposta, config.MODOS_RESPOSTA["normal_ironico"])
         
         regras_modo = f"""
 MODO ATIVO: {modo_resposta}
 - Descrição: {modo_config['desc']}
 - Exemplo: {modo_config['exemplo']}
-- Usar gírias: {'SIM' if modo_config['usa_girias'] else 'NÃO'}
+- Usar gírias: {'SIM' if modo_config['usa_girias'] else 'NÃO'} (probabilidade: {config.GIRIA_PROBABILIDADE*100}%)
+- Usar emojis: {'SIM' if modo_config['usa_emojis'] else 'NÃO'} (probabilidade: {modo_config['prob_emoji']*100}%)
+- Tonalidade: {modo_config['tonalidade']}
 - Tamanho máximo: {modo_config['max_chars']} caracteres
 """
         
-        # === NOME DO USUÁRIO ===
-        probabilidade_nome = int(config.USAR_NOME_PROBABILIDADE * 100)
-        usar_nome_str = f"SIM (use '{usuario}')" if usar_nome else f"NÃO (probabilidade {probabilidade_nome}% não ativada)"
+        # === INFORMAÇÕES DO USUÁRIO ===
+        usuario_privilegiado = analise.get("usuario_privilegiado", False)
+        pode_dar_ordens = False
+        nome_usuario = usuario
+        
+        if usuario_privilegiado:
+            # Busca dados do usuário privilegiado
+            db = Database(config.DB_PATH)
+            user_data = db.get_usuario_privilegiado(analise.get('numero', ''))
+            if user_data:
+                nome_usuario = user_data.get('nome_curto', usuario)
+                pode_dar_ordens = user_data.get('pode_dar_ordens', False)
+        
+        # Probabilidade de usar nome
+        usar_nome = analise.get("usar_nome", False)
+        usar_nome_str = f"SIM (use '{nome_usuario}')" if usar_nome else f"NÃO (probabilidade {int(config.USAR_NOME_PROBABILIDADE*100)}% não ativada)"
         
         # === TIPO DE ISOLAMENTO ===
-        tipo_isolamento = "GRUPO (histórico isolado de conversas privadas)" if tipo_conversa == "grupo" else "PRIVADO (histórico isolado de grupos)"
+        tipo_isolamento = "GRUPO (histórico completamente isolado)" if tipo_conversa == "grupo" else "PRIVADO (histórico completamente isolado)"
+        
+        # === DETALHES DA ANÁLISE ===
+        humor_atual = analise.get("humor_atualizado", "normal_ironico")
+        humor_desc = config.HUMORES_BASE.get(humor_atual, "Neutro com ironia")
+        tom_usuario = analise.get("tom_usuario", "neutro")
+        tom_intensidade = analise.get("tom_intensidade", 0.5)
+        emocao_detectada = analise.get("emocao_primaria", "neutral")
+        confianca_emocao = analise.get("confianca_emocao", 0.5)
+        nivel_transicao = analise.get("nivel_transicao", 0)
+        humor_alvo = analise.get("humor_alvo", "normal_ironico")
         
-        # === PROMPT FINAL ===
-        prompt = f"""{config.PERSONA_BASE.format(humor=humor, tom_usuario=tom_usuario, modo_resposta=modo_resposta)}
+        # === PROMPT FINAL (ATUALIZADO COM TODAS AS REGRAS) ===
+        prompt = f"""{config.PERSONA_BASE.format(
+            humor=humor_atual,
+            humor_desc=humor_desc,
+            tom_usuario=tom_usuario,
+            modo_resposta=modo_resposta
+        )}
 
 {config.SYSTEM_PROMPT.format(
-    humor=humor,
+    humor=humor_atual,
+    humor_desc=humor_desc,
     tom_usuario=tom_usuario,
+    tom_intensidade=tom_intensidade,
     modo_resposta=modo_resposta,
     tipo_conversa=tipo_conversa,
     mensagem_citada=mensagem_citada or "nenhuma",
@@ -162,27 +220,39 @@ MODO ATIVO: {modo_resposta}
     max_chars=modo_config['max_chars'],
     usa_girias='SIM' if modo_config['usa_girias'] else 'NÃO',
     usa_emojis='SIM' if modo_config['usa_emojis'] else 'NÃO',
+    prob_emoji=int(modo_config['prob_emoji']*100),
+    prob_nome=int(config.USAR_NOME_PROBABILIDADE*100),
     reply_context=reply_context,
+    reply_instruction=reply_instruction,
     tipo_isolamento=tipo_isolamento,
-    usuario=usuario,
-    prob_nome=probabilidade_nome
+    usuario=nome_usuario,
+    nome_usuario=nome_usuario,
+    usuario_privilegiado="SIM" if usuario_privilegiado else "NÃO",
+    pode_dar_comandos="SIM" if pode_dar_ordens else "NÃO",
+    emocao_detectada=emocao_detectada,
+    confianca_emocao=confianca_emocao,
+    nivel_transicao=nivel_transicao,
+    humor_alvo=humor_alvo
 )}
 
 {config.REGRAS_ADAPTATIVAS}
 
-DATA E HORA ATUAL: {data_hora_atual}
+DATA E HORA ATUAL EM LUANDA: {data_hora_atual}
 {info_context}
 
-CONTEXTO DA CONVERSA:
+CONTEXTO DA CONVERSA (ISOLADO):
 {historico_texto}
 
-USUÁRIO ({usuario}): {mensagem}
+USUÁRIO ({nome_usuario}): {mensagem}
 
 AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']} caracteres):"""
         
+        # Log do prompt (apenas resumo)
+        logger.debug(f"📝 Prompt construído: {len(prompt)} caracteres, modo: {modo_resposta}, humor: {humor_atual}")
+        
         return prompt
 
-    # === CHAMADAS ÀS APIS (MANTIDAS IGUAIS) ===
+    # === CHAMADAS ÀS APIS ===
     
     def _chamar_mistral(self, prompt: str) -> str:
         """Chama Mistral AI"""
@@ -192,7 +262,11 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
                 "model": config.MISTRAL_MODEL,
                 "messages": [{"role": "user", "content": prompt}],
                 "max_tokens": config.MAX_TOKENS,
-                "temperature": config.TEMPERATURE
+                "temperature": config.TEMPERATURE,
+                "top_p": config.TOP_P,
+                "frequency_penalty": config.FREQUENCY_PENALTY,
+                "presence_penalty": config.PRESENCE_PENALTY,
+                "stop": config.STOP_SEQUENCES
             }
             resp = requests.post(
                 "https://api.mistral.ai/v1/chat/completions",
@@ -204,7 +278,7 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
             if resp.status_code == 200:
                 return resp.json()["choices"][0]["message"]["content"].strip()
             else:
-                logger.warning(f"Mistral erro: {resp.status_code}")
+                logger.warning(f"Mistral erro {resp.status_code}: {resp.text[:200]}")
                 return None
         except Exception as e:
             logger.warning(f"Mistral falhou: {e}")
@@ -218,7 +292,9 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
                 "contents": [{"parts": [{"text": prompt}]}],
                 "generationConfig": {
                     "maxOutputTokens": config.MAX_TOKENS,
-                    "temperature": config.TEMPERATURE
+                    "temperature": config.TEMPERATURE,
+                    "topP": config.TOP_P,
+                    "stopSequences": config.STOP_SEQUENCES
                 }
             }
             resp = requests.post(url, json=payload, timeout=self.timeout)
@@ -226,7 +302,7 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
             if resp.status_code == 200:
                 return resp.json()["candidates"][0]["content"]["parts"][0]["text"].strip()
             else:
-                logger.warning(f"Gemini erro: {resp.status_code}")
+                logger.warning(f"Gemini erro {resp.status_code}: {resp.text[:200]}")
                 return None
         except Exception as e:
             logger.warning(f"Gemini falhou: {e}")
@@ -240,7 +316,9 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
                 "model": config.GROQ_MODEL,
                 "messages": [{"role": "user", "content": prompt}],
                 "max_tokens": config.MAX_TOKENS,
-                "temperature": config.TEMPERATURE
+                "temperature": config.TEMPERATURE,
+                "top_p": config.TOP_P,
+                "stop": config.STOP_SEQUENCES
             }
             resp = requests.post(
                 "https://api.groq.com/openai/v1/chat/completions",
@@ -252,7 +330,7 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
             if resp.status_code == 200:
                 return resp.json()["choices"][0]["message"]["content"].strip()
             else:
-                logger.warning(f"Groq erro: {resp.status_code}")
+                logger.warning(f"Groq erro {resp.status_code}: {resp.text[:200]}")
                 return None
         except Exception as e:
             logger.warning(f"Groq falhou: {e}")
@@ -266,7 +344,9 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
                 "model": config.COHERE_MODEL,
                 "message": prompt,
                 "max_tokens": config.MAX_TOKENS,
-                "temperature": config.TEMPERATURE
+                "temperature": config.TEMPERATURE,
+                "p": config.TOP_P,
+                "stop_sequences": config.STOP_SEQUENCES
             }
             resp = requests.post(
                 "https://api.cohere.ai/v1/chat",
@@ -278,7 +358,7 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
             if resp.status_code == 200:
                 return resp.json()["text"].strip()
             else:
-                logger.warning(f"Cohere erro: {resp.status_code}")
+                logger.warning(f"Cohere erro {resp.status_code}: {resp.text[:200]}")
                 return None
         except Exception as e:
             logger.warning(f"Cohere falhou: {e}")
@@ -292,7 +372,9 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
                 "model": config.TOGETHER_MODEL,
                 "messages": [{"role": "user", "content": prompt}],
                 "max_tokens": config.MAX_TOKENS,
-                "temperature": config.TEMPERATURE
+                "temperature": config.TEMPERATURE,
+                "top_p": config.TOP_P,
+                "stop": config.STOP_SEQUENCES
             }
             resp = requests.post(
                 "https://api.together.xyz/v1/chat/completions",
@@ -304,7 +386,7 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
             if resp.status_code == 200:
                 return resp.json()["choices"][0]["message"]["content"].strip()
             else:
-                logger.warning(f"Together erro: {resp.status_code}")
+                logger.warning(f"Together erro {resp.status_code}: {resp.text[:200]}")
                 return None
         except Exception as e:
             logger.warning(f"Together falhou: {e}")
@@ -314,7 +396,16 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
         """Chama HuggingFace Inference API"""
         try:
             headers = {"Authorization": f"Bearer {config.HF_API_KEY}"}
-            payload = {"inputs": prompt, "parameters": {"max_new_tokens": config.MAX_TOKENS}}
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "max_new_tokens": config.MAX_TOKENS,
+                    "temperature": config.TEMPERATURE,
+                    "top_p": config.TOP_P,
+                    "do_sample": True,
+                    "return_full_text": False
+                }
+            }
             resp = requests.post(
                 f"https://api-inference.huggingface.co/models/{config.HF_MODEL}",
                 json=payload,
@@ -323,10 +414,11 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
             )
             logger.debug(f"HF response: {resp.status_code}")
             if resp.status_code == 200:
-                return resp.json()[0]["generated_text"].split("AKIRA:")[-1].strip()
-            else:
-                logger.warning(f"HF erro: {resp.status_code}")
-                return None
+                result = resp.json()
+                if isinstance(result, list) and len(result) > 0:
+                    return result[0].get("generated_text", "").strip()
+            logger.warning(f"HF erro {resp.status_code}: {resp.text[:200]}")
+            return None
         except Exception as e:
             logger.warning(f"HuggingFace falhou: {e}")
             return None
@@ -338,17 +430,13 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
         mensagem: str,
         historico: list,
         mensagem_citada: str,
-        humor: str,
-        tom_usuario: str,
-        modo_resposta: str,
+        analise: Dict[str, Any],
         usuario: str,
-        usar_nome: bool,
         tipo_conversa: str
     ) -> str:
         """Tenta gerar resposta usando fallback cascata"""
         prompt = self._construir_prompt(
-            mensagem, historico, mensagem_citada, humor,
-            tom_usuario, modo_resposta, usuario, usar_nome, tipo_conversa
+            mensagem, historico, mensagem_citada, analise, usuario, tipo_conversa
         )
         
         max_loops = 2
@@ -363,6 +451,8 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
                     logger.info(f"Tentando {api_name.upper()} (retry {retry+1}/2)...")
                     
                     try:
+                        resposta = None
+                        
                         if api_name == "mistral":
                             resposta = self._chamar_mistral(prompt)
                         elif api_name == "gemini":
@@ -377,8 +467,9 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
                             resposta = self._chamar_huggingface(prompt)
                         
                         if resposta:
+                            resposta_limpa = self._limpar_resposta(resposta)
                             logger.success(f"✓ Resposta gerada via {api_name.upper()}")
-                            return self._limpar_resposta(resposta)
+                            return resposta_limpa
                         
                         time.sleep(1)
                         
@@ -387,30 +478,75 @@ AKIRA (responda {modo_config['desc'].lower()}, máximo {modo_config['max_chars']
             
             time.sleep(2)
         
-        return "Barra no bardeado"
+        # Fallback final
+        fallbacks = [
+            "Barra no bardeado",
+            "Tás a falar com a parede?",
+            "Nem ligo, puto.",
+            "Ah, tá...",
+            "Foda-se."
+        ]
+        return random.choice(fallbacks)
 
     def _limpar_resposta(self, resposta: str) -> str:
-        """Remove markdown e limita tamanho"""
-        # Remove markdown
+        """Remove markdown, limita tamanho e aplica regras de estilo"""
+        if not resposta:
+            return "..."
+        
+        # 1. Remove markdown
         resposta = resposta.replace("**", "").replace("*", "")
         resposta = resposta.replace("```", "").replace("`", "")
+        resposta = resposta.replace("__", "").replace("_", "")
         
-        # Remove prefixos
-        prefixos = ["AKIRA:", "Akira:", "RESPOSTA:", "Resposta:", "Assistant:"]
+        # 2. Remove prefixos comuns
+        prefixos = ["AKIRA:", "Akira:", "RESPOSTA:", "Resposta:", "Assistant:", "assistant:", "AI:"]
         for p in prefixos:
             if resposta.startswith(p):
                 resposta = resposta[len(p):].strip()
         
-        # Limita tamanho
+        # 3. Remove aspas desnecessárias no início/fim
+        if resposta.startswith('"') and resposta.endswith('"'):
+            resposta = resposta[1:-1].strip()
+        elif resposta.startswith("'") and resposta.endswith("'"):
+            resposta = resposta[1:-1].strip()
+        
+        # 4. Remove múltiplos espaços
+        resposta = re.sub(r'\s+', ' ', resposta)
+        
+        # 5. Limita "kkk" e "rsrs" excessivos
+        if resposta.lower().count("kkk") > 2 or resposta.lower().count("rsrs") > 2:
+            # Substitui excessos
+            resposta = re.sub(r'(kkk|rsrs){3,}', lambda m: m.group(1)[:3], resposta, flags=re.IGNORECASE)
+        
+        # 6. Corrige uso excessivo de "ou"
+        if resposta.count(" ou ") > 2:
+            # Substitui alguns "ou" por vírgulas
+            partes = resposta.split(" ou ")
+            if len(partes) > 3:
+                resposta = ", ".join(partes[:3]) + " ou " + partes[3] if len(partes) > 3 else ", ".join(partes)
+        
+        # 7. Limita emojis excessivos
+        emoji_count = sum(1 for c in resposta if ord(c) > 127 and c not in 'áéíóúâêîôûãõç')
+        if emoji_count > 3:
+            # Mantém apenas primeiros emojis
+            emojis = [c for c in resposta if ord(c) > 127 and c not in 'áéíóúâêîôûãõç']
+            if len(emojis) > 3:
+                for emoji in emojis[3:]:
+                    resposta = resposta.replace(emoji, '', 1)
+        
+        # 8. Limita tamanho
         if len(resposta) > 400:
             resposta = resposta[:397] + "..."
         
+        # 9. Garante que termina com pontuação
+        if resposta and resposta[-1] not in ['.', '!', '?', ',', ':', ';']:
+            resposta += '.'
+        
         return resposta.strip()
 
 # ============================================================================
-# CLASSE PRINCIPAL DA API (CONTINUA NA PARTE 2)
+# CLASSE PRINCIPAL DA API
 # ============================================================================
-# CONTINUAÇÃO DO api.py (PARTE 2/2)
 
 class AkiraAPI:
     def __init__(self, cfg_module):
@@ -422,16 +558,74 @@ class AkiraAPI:
         self.web_search = get_web_search()
         self._setup_routes()
         self._setup_trainer()
+        
+        logger.info("✅ AkiraAPI V21 inicializada")
 
     def _setup_trainer(self):
         """Inicializa treinamento forçado"""
         if getattr(self.config, 'START_PERIODIC_TRAINER', False):
             try:
-                Treinamento(self.db, interval_hours=config.TRAINING_INTERVAL_HOURS).start_periodic_training()
+                treinador = Treinamento(self.db, interval_hours=config.TRAINING_INTERVAL_HOURS)
+                treinador.start_periodic_training()
                 logger.info("✅ Treinamento periódico INICIADO")
             except Exception as e:
                 logger.error(f"❌ Treinador falhou: {e}")
 
+    def _get_user_context(self, numero: str, tipo_conversa: str, grupo_nome: str = '', grupo_id: str = ''):
+        """Obtém contexto isolado por tipo de conversa"""
+        # Cria chave única para isolamento
+        if tipo_conversa == 'grupo' and grupo_id:
+            cache_key = f"grupo_{grupo_id}"
+        else:
+            cache_key = f"pv_{numero}"
+        
+        if cache_key in self.contexto_cache:
+            return self.contexto_cache[cache_key]
+        
+        # Cria novo contexto isolado
+        contexto = Contexto(
+            identificador=cache_key,
+            tipo_contexto=tipo_conversa,
+            grupo_nome=grupo_nome,
+            grupo_id=grupo_id,
+            db_path=self.config.DB_PATH
+        )
+        
+        self.contexto_cache[cache_key] = contexto
+        logger.info(f"🔧 Novo contexto criado: {cache_key}")
+        
+        return contexto
+
+    def _handle_reset_command(self, numero: str, usuario: str, tipo_reset: str = "completo", confirmacao: bool = False):
+        """Manipula comando /reset"""
+        # Verifica se é usuário privilegiado
+        if not self.db.pode_usar_reset(numero):
+            return jsonify({
+                'resposta': '⚠️ Só usuários privilegiados podem usar /reset. Fala com o admin, puto.'
+            })
+        
+        # Requer confirmação explícita
+        if not confirmacao:
+            return jsonify({
+                'resposta': f'⚠️ Confirma reset {tipo_reset}? Manda /reset novamente com confirmação.'
+            })
+        
+        # Executa reset
+        resultado = self.db.resetar_contexto_usuario(numero, tipo_reset)
+        
+        if resultado.get('sucesso'):
+            # Limpa cache do contexto
+            cache_keys = [k for k in self.contexto_cache._store.keys() if numero in k]
+            for key in cache_keys:
+                del self.contexto_cache[key]
+            
+            resposta = f"✅ Reset {tipo_reset} realizado! ({resultado.get('itens_apagados', 0)} itens removidos)"
+            logger.info(f"🔄 Reset executado para {numero}: {resultado}")
+        else:
+            resposta = f"❌ Erro no reset: {resultado.get('erro', 'Desconhecido')}"
+        
+        return jsonify({'resposta': resposta})
+
     def _setup_routes(self):
         """Configura rotas Flask"""
         
@@ -441,7 +635,7 @@ class AkiraAPI:
                 resp = make_response()
                 resp.headers['Access-Control-Allow-Origin'] = '*'
                 resp.headers['Access-Control-Allow-Headers'] = 'Content-Type'
-                resp.headers['Access-Control-Allow-Methods'] = 'POST, GET'
+                resp.headers['Access-Control-Allow-Methods'] = 'POST, GET, DELETE'
                 return resp
 
         @self.api.after_request
@@ -454,18 +648,33 @@ class AkiraAPI:
             try:
                 data = request.get_json() or {}
                 usuario = data.get('usuario', 'anonimo')
-                numero = data.get('numero', '').strip()
+                numero = str(data.get('numero', '')).strip()
                 mensagem = data.get('mensagem', '').strip()
                 mensagem_citada = data.get('mensagem_citada', '').strip()
+                tipo_conversa = data.get('tipo_conversa', 'pv')  # 'pv' ou 'grupo'
+                grupo_nome = data.get('grupo_nome', '')
+                grupo_id = data.get('grupo_id', '')
                 
+                # Log inicial
+                logger.info(f"[{usuario}] ({numero}): {mensagem[:60]}...")
+                logger.info(f"Tipo de conversa: {tipo_conversa} {f'({grupo_nome})' if grupo_nome else ''}")
+                
+                # === VALIDAÇÃO ===
                 if not mensagem and not mensagem_citada:
                     return jsonify({'error': 'mensagem obrigatória'}), 400
                 
-                logger.info(f"[{usuario}] ({numero}): {mensagem[:60]}")
+                # === COMANDO ESPECIAL: /reset ===
+                if mensagem.strip().lower() == '/reset':
+                    return self._handle_reset_command(numero, usuario)
                 
-                # === DETECTA TIPO DE CONVERSA ===
-                tipo_conversa = "grupo" if ("@g.us" in numero or "120363" in numero) else "pv"
-                logger.info(f"Tipo de conversa: {tipo_conversa}")
+                # === DETECTA TIPO DE CONVERSA (AGORA VIA WHATSAPP) ===
+                # O WhatsApp já envia 'tipo_conversa', mas valida
+                if not tipo_conversa or tipo_conversa not in ['pv', 'grupo']:
+                    # Fallback: detecta automaticamente
+                    if "@g.us" in numero or "120363" in numero:
+                        tipo_conversa = "grupo"
+                    else:
+                        tipo_conversa = "pv"
                 
                 # === RESPOSTA RÁPIDA PARA HORA ===
                 if any(k in mensagem.lower() for k in ["hora", "horas", "que horas"]):
@@ -474,59 +683,55 @@ class AkiraAPI:
                     return jsonify({'resposta': f"São {agora.strftime('%H:%M')} em Luanda, puto."})
                 
                 # === BUSCA WEB (SE NECESSÁRIO) ===
-                intencao_busca = WebSearch.detectar_intencao_busca(mensagem)
                 contexto_web = ""
-                
-                if intencao_busca == "noticias":
-                    logger.info("Buscando notícias de Angola...")
-                    contexto_web = self.web_search.pesquisar_noticias_angola()
-                elif intencao_busca == "clima":
-                    logger.info("Buscando clima...")
-                    cidade = "Luanda"
-                    for palavra in mensagem.split():
-                        if len(palavra) > 4 and palavra[0].isupper():
-                            cidade = palavra
-                            break
-                    contexto_web = self.web_search.buscar_clima(cidade)
-                elif intencao_busca == "busca_geral":
-                    logger.info("Buscando informações gerais...")
-                    contexto_web = self.web_search.buscar_geral(mensagem)
+                if tipo_conversa == "pv":  # Apenas em PV para evitar spam
+                    intencao_busca = WebSearch.detectar_intencao_busca(mensagem)
+                    
+                    if intencao_busca == "noticias":
+                        logger.info("Buscando notícias de Angola...")
+                        contexto_web = self.web_search.pesquisar_noticias_angola()
+                    elif intencao_busca == "clima":
+                        logger.info("Buscando clima...")
+                        cidade = "Luanda"
+                        for palavra in mensagem.split():
+                            if len(palavra) > 4 and palavra[0].isupper():
+                                cidade = palavra
+                                break
+                        contexto_web = self.web_search.buscar_clima(cidade)
+                    elif intencao_busca == "busca_geral":
+                        logger.info("Buscando informações gerais...")
+                        contexto_web = self.web_search.buscar_geral(mensagem)
                 
                 # === CONTEXTO DO USUÁRIO (ISOLADO) ===
-                contexto = self._get_user_context(numero)
+                contexto = self._get_user_context(numero, tipo_conversa, grupo_nome, grupo_id)
                 historico = contexto.obter_historico_para_llm()
                 
-                # === ANÁLISE COMPLETA (TOM, HUMOR, MODO) ===
-                analise = contexto.analisar_intencao_e_normalizar(mensagem, historico)
+                # === VERIFICA SE É USUÁRIO PRIVILEGIADO ===
+                usuario_privilegiado = self.db.is_usuario_privilegiado(numero)
+                if usuario_privilegiado:
+                    logger.info(f"👑 Usuário privilegiado detectado: {numero}")
                 
-                tom_usuario = analise.get("tom_usuario", "neutro")
-                humor_atual = analise.get("humor_atualizado", "normal")
-                modo_resposta = analise.get("modo_resposta", "casual_amigavel")
-                usar_nome = analise.get("usar_nome", False)
+                # === ANÁLISE COMPLETA (COM BERT GoEmotions) ===
+                analise = contexto.analisar_intencao_e_normalizar(mensagem, historico, mensagem_citada)
                 
-                logger.info(f"Análise: tom={tom_usuario}, humor={humor_atual}, modo={modo_resposta}, usar_nome={usar_nome}")
+                # Adiciona flag de usuário privilegiado à análise
+                analise['usuario_privilegiado'] = usuario_privilegiado
+                analise['numero'] = numero
                 
-                # === USUÁRIOS PRIVILEGIADOS ===
-                if numero in config.USUARIOS_PRIVILEGIADOS:
-                    # Começa formal mas pode adaptar
-                    if humor_atual == "normal" and tom_usuario == "neutro":
-                        tom_usuario = "formal"
-                    logger.info(f"Usuário privilegiado detectado: {config.USUARIOS_PRIVILEGIADOS[numero]}")
+                # === AJUSTE PARA USUÁRIOS PRIVILEGIADOS ===
+                if usuario_privilegiado:
+                    # Usuários privilegiados começam formal
+                    if analise.get('tom_usuario') == 'neutro':
+                        analise['tom_usuario'] = 'formal'
+                        analise['modo_resposta'] = 'tecnico_formal'
+                    logger.info(f"Configuração privilegiada: tom={analise.get('tom_usuario')}, modo={analise.get('modo_resposta')}")
                 
-                # === DETECTA SE REPLY É À AKIRA ===
-                reply_to_bot = False
-                if mensagem_citada:
-                    # Verifica se no histórico recente a Akira disse algo similar
-                    historico_recente = historico[-5:]  # Últimas 5
-                    for msg in historico_recente:
-                        if msg.get("role") == "assistant":
-                            conteudo_bot = msg.get("content", "")
-                            # Se mensagem citada está contida na resposta da Akira
-                            if mensagem_citada[:30].lower() in conteudo_bot.lower():
-                                reply_to_bot = True
-                                mensagem_citada = f"[Respondendo à Akira: '{mensagem_citada[:50]}...']"
-                                logger.info("✅ Reply à Akira detectado!")
-                                break
+                # Log da análise
+                logger.info(f"🎭 Análise: tom={analise.get('tom_usuario')}, "
+                          f"humor={analise.get('humor_atualizado')}, "
+                          f"modo={analise.get('modo_resposta')}, "
+                          f"emoção={analise.get('emocao_primaria', 'N/A')}, "
+                          f"privilegiado={'SIM' if usuario_privilegiado else 'NÃO'}")
                 
                 # === ADICIONA CONTEXTO WEB AO HISTÓRICO ===
                 historico_com_web = historico.copy()
@@ -541,24 +746,22 @@ class AkiraAPI:
                     mensagem=mensagem,
                     historico=historico_com_web,
                     mensagem_citada=mensagem_citada,
-                    humor=humor_atual,
-                    tom_usuario=tom_usuario,
-                    modo_resposta=modo_resposta,
+                    analise=analise,
                     usuario=usuario,
-                    usar_nome=usar_nome,
                     tipo_conversa=tipo_conversa
                 )
                 
                 logger.success(f"✅ Resposta: {resposta[:100]}...")
                 
-                # === SALVAR NO BANCO + CONTEXTO (ISOLADO) ===
+                # === SALVAR NO BANCO + CONTEXTO ===
+                reply_info = analise.get('reply_info', {})
                 contexto.atualizar_contexto(
                     mensagem=mensagem,
                     resposta=resposta,
                     numero=numero,
                     is_reply=bool(mensagem_citada),
                     mensagem_original=mensagem_citada,
-                    reply_to_bot=reply_to_bot
+                    reply_to_bot=reply_info.get('reply_to_bot', False)
                 )
                 
                 # === REGISTRAR PARA TREINAMENTO ===
@@ -572,59 +775,16 @@ class AkiraAPI:
                         is_reply=bool(mensagem_citada),
                         mensagem_original=mensagem_citada,
                         contexto={
-                            "humor": humor_atual,
-                            "modo": modo_resposta,
-                            "tom": tom_usuario
-                        }
+                            "humor": analise.get('humor_atualizado'),
+                            "modo_resposta": analise.get('modo_resposta'),
+                            "tom": analise.get('tom_usuario'),
+                            "reply_to_bot": reply_info.get('reply_to_bot', False),
+                            "usuario_privilegiado": usuario_privilegiado,
+                            "nivel_transicao": analise.get('nivel_transicao', 0)
+                        },
+                        emocao_detectada=analise.get('emocao_primaria'),
+                        confianca_emocao=analise.get('confianca_emocao', 0.5)
                     )
                 except Exception as e:
                     logger.warning(f"Erro ao treinar: {e}")
-                
-                return jsonify({'resposta': resposta})
-                
-            except Exception as e:
-                logger.exception("Erro em /akira")
-                return jsonify({'resposta': 'Erro interno, já volto!'}), 500
-
-        @self.api.route('/health', methods=['GET'])
-        def health_check():
-            return 'OK', 200
-        
-        @self.api.route('/stats', methods=['GET'])
-        def stats():
-            """Endpoint de estatísticas"""
-            try:
-                # Conta mensagens totais
-                total_msgs = self.db._execute_with_retry("SELECT COUNT(*) FROM mensagens")
-                total = total_msgs[0][0] if total_msgs else 0
-                
-                # Conta por tipo
-                tipos = self.db._execute_with_retry(
-                    "SELECT tipo_contexto, COUNT(*) FROM mensagens GROUP BY tipo_contexto"
-                )
-                
-                stats_data = {
-                    "total_mensagens": total,
-                    "por_tipo": {t[0]: t[1] for t in (tipos or [])},
-                    "humores_disponiveis": config.HUMORES_BASE,
-                    "modos_resposta": list(config.MODOS_RESPOSTA.keys()),
-                    "apis_ativas": self.llm_manager.apis_disponiveis
-                }
-                
-                return jsonify(stats_data)
-            except Exception as e:
-                logger.error(f"Erro em /stats: {e}")
-                return jsonify({"error": str(e)}), 500
-
-    def _get_user_context(self, numero: str) -> Contexto:
-        """Retorna contexto do usuário (com cache)"""
-        if not numero:
-            numero = "anonimo"
-        
-        # Cache isolado por número
-        cache_key = numero
-        
-        if cache_key not in self.contexto_cache:
-            self.contexto_cache[cache_key] = Contexto(self.db, usuario=numero)
-        
-        return self.contexto_cache[cache_key]
+