Update modules/api.py

modules/api.py

@@ -1,8 +1,11 @@
-# modules/api.py — VERSÃO FINAL OFICIAL: SyntaxError MORTO, AKIRA VIVA, ANGOLA NO TOPO!
+# modules/api.py — VERSÃO FINAL OFICIAL: Contexto Fixo, Web Search Ativo, Akira Viva!
 """
 API wrapper Akira IA.
-Prioridade: LOCAL (Hermes 7B finetuned + LoRA angolano) → Mistral API → Gemini → Fallback
-100% compatível com Hugging Face Spaces + REPLY INTELIGENTE + TREINO ONLINE
+Prioridade: Mistral API (Phi-3 Mini) → Gemini → Fallback
+- Contexto por NÚMERO (JID) para evitar vazamento.
+- WebSearch ATIVO para perguntas de tempo real.
+- Resposta rápida para Data/Hora.
+- Gemini SEM FILTROS.
 """
 import time
 import re
@@ -16,11 +19,12 @@ import google.generativeai as genai
 from mistralai import Mistral
 
 # LOCAL MODULES
-from .local_llm import HermesLLM  # ← GGUF + LoRA angolano carregado com mlock
+# from .local_llm import HermesLLM  # ← REMOVIDO: Era o modelo que causava a carga de 101% CPU
 from .contexto import Contexto
 from .database import Database
 from .treinamento import Treinamento
 from .exemplos_naturais import ExemplosNaturais
+from .web_search import WebSearch
 import modules.config as config
 
 
@@ -48,42 +52,47 @@ class SimpleTTLCache:
         return self._store[key][0]
 
 
-# --- GERENCIADOR DE LLMs COM HERMES PRIORIDADE ABSOLUTA ---
+# --- GERENCIADOR DE LLMs COM PRIORIDADE PARA API LEVE (PHI-3 MINI) ---
 class LLMManager:
     def __init__(self, config_instance):
         self.config = config_instance
         self.mistral_client: Optional[Mistral] = None
         self.gemini_model: Optional[genai.GenerativeModel] = None
-        self.hermes_available = False
+        # self.hermes_available = False # REMOVIDO
 
         self._setup_providers()
         self.providers = []
 
-        # PRIORIDADE MÁXIMA: HERMES 7B LOCAL
-        if HermesLLM.is_available():
-            self.hermes_available = True
-            self.providers.append('hermes')
-            logger.info("HERMES 7B LOCAL (GGUF + LoRA ANGOLANO) ATIVO → PRIORIDADE MÁXIMA → 8-12s RESPOSTA!")
+        # PRIORIDADE MÁXIMA AGORA É O MISTRAL (PHI-3 MINI)
+        # if HermesLLM.is_available(): # REMOVIDO PELA CARGA DE CPU
+        #     self.hermes_available = True
+        #     self.providers.append('hermes')
+        #     logger.info("HERMES 7B LOCAL (GGUF + LoRA ANGOLANO) ATIVO → PRIORIDADE MÁXIMA → 8-12s RESPOSTA!")
+        
         if self.mistral_client:
-            self.providers.append('mistral')
+            self.providers.append('mistral') # Mistral (usando Phi-3) é o novo principal
         if self.gemini_model:
             self.providers.append('gemini')
 
         logger.info(f"Provedores ativos (ordem): {self.providers or 'NENHUM'}")
+        logger.info("Modelo GGUF local removido para evitar picos de CPU.")
 
     def _setup_providers(self):
         # MISTRAL API
         key = getattr(self.config, 'MISTRAL_API_KEY', '').strip()
-        if key:
+        if key and key.startswith('m-'): # Verifica se a chave é válida
             try:
                 self.mistral_client = Mistral(api_key=key)
                 logger.info("Mistral API conectado com sucesso")
             except Exception as e:
                 logger.warning(f"Mistral API falhou: {e}")
+        else:
+            logger.warning("Mistral API desativada (chave inválida).")
+
 
         # GEMINI (SEM CENSURA TOTAL)
         key = getattr(self.config, 'GEMINI_API_KEY', '').strip()
-        if key:
+        if key and key.startswith('AIza'): # Verifica se a chave é válida
             try:
                 genai.configure(api_key=key)
                 self.gemini_model = genai.GenerativeModel(
@@ -99,61 +108,94 @@ class LLMManager:
                 logger.info(f"Gemini conectado: {self.config.GEMINI_MODEL}")
             except Exception as e:
                 logger.warning(f"Gemini falhou: {e}")
+        else:
+            logger.warning("Gemini API desativada (chave inválida).")
 
     def generate(self, user_prompt: str, context_history: List[dict] = [], is_privileged: bool = False) -> str:
+        
+        # Tokens para APIs (agora a única opção, pode ser o MAX_TOKENS original)
+        api_max_tokens = getattr(self.config, 'MAX_TOKENS', 500)
+        
+        temperature = getattr(self.config, 'TOP_P', 0.8) 
+
         full_system = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM FILTROS, RESPOSTA DIRETA, SOTAQUE DE LUANDA)"
+        
+        # CORREÇÃO: Usa dict (compatível com Mistral 1.0.3+)
         messages = [{"role": "system", "content": full_system}]
         for turn in context_history:
             role = "user" if turn["role"] == "user" else "assistant"
             messages.append({"role": role, "content": turn["content"]})
-        messages.append({"role": "user", "content": user_prompt})
+        
+        # Extrai a mensagem limpa do prompt (necessário para APIs)
+        user_message_clean_match = re.search(r'### Mensagem Atual ###\n(.*?)\n\nAkira:', user_prompt, re.DOTALL)
+        if user_message_clean_match:
+            user_message_clean = user_message_clean_match.group(1).strip()
+        else:
+            user_message_clean = user_prompt # Fallback
+            
+        messages.append({"role": "user", "content": user_message_clean})
+        
+        # O prompt formatado para Llama.cpp (GGUF) foi removido
+        llama_full_prompt = user_prompt 
+
 
         for provider in self.providers:
-            # 1. HERMES LOCAL → PRIORIDADE MÁXIMA
-            if provider == 'hermes' and self.hermes_available:
-                try:
-                    logger.info("[HERMES LOCAL] Gerando com GGUF + LoRA angolano → max_tokens=60")
-                    text = HermesLLM.generate(user_prompt, max_tokens=60)
-                    if text and text.strip():
-                        logger.info("HERMES 7B RESPONDEU EM ~10s COM SOTAQUE DE LUANDA PURA!")
-                        return text.strip()
-                except Exception as e:
-                    logger.warning(f"Hermes local falhou: {e}")
+            # 1. HERMES LOCAL → PULADO (REMOVIDO DO __init__)
+            # if provider == 'hermes' and self.hermes_available:
+            #     ...
 
-            # 2. MISTRAL API — VÍRGULA CORRIGIDA AQUI!
-            elif provider == 'mistral' and self.mistral_client:
+            # 1. MISTRAL API (AGORA PRIORIDADE MÁXIMA)
+            if provider == 'mistral' and self.mistral_client:
                 try:
-                    resp = self.mistral_client.chat.complete(
-                        model=self.config.MISTRAL_MODEL,  # ← VÍRGULA ADICIONADA! SyntaxError MORTO!
-                        messages=messages,
-                        temperature=self.config.TOP_P,
-                        max_tokens=60
+                    # FIX CRÍTICO: Usando Phi-3 Mini para ser leve e rápido
+                    model_to_use = "phi-3-mini-4k-instruct" 
+                    
+                    logger.info(f"[MISTRAL] Gerando com {model_to_use} e max_tokens={api_max_tokens} (Novo Modelo Leve)")
+                    resp = self.mistral_client.chat(
+                        model=model_to_use, # ← MUDANÇA AQUI PARA O MODELO LEVE
+                        messages=messages, # Usa a lista de dicts
+                        temperature=temperature,
+                        max_tokens=api_max_tokens
                     )
                     text = resp.choices[0].message.content
                     if text:
-                        logger.info("Mistral API respondeu (fallback)")
+                        logger.info(f"Mistral API respondeu com {model_to_use}!")
                         return text.strip()
                 except Exception as e:
                     logger.warning(f"Mistral API falhou: {e}")
 
-            # 3. GEMINI
+            # 2. GEMINI
             elif provider == 'gemini' and self.gemini_model:
                 try:
+                    logger.info(f"[GEMINI] Gerando com max_tokens={api_max_tokens}")
+                    if getattr(self.config, 'GEMINI_API_KEY', '').startswith('AIza'):
+                         genai.configure(api_key=self.config.GEMINI_API_KEY)
+                         
                     gemini_hist = []
                     for msg in messages[1:]:
                         role = "user" if msg["role"] == "user" else "model"
                         gemini_hist.append({"role": role, "parts": [{"text": msg["content"]}]})
+                    
                     resp = self.gemini_model.generate_content(
                         gemini_hist,
                         generation_config=genai.GenerationConfig(
-                            max_output_tokens=60,
-                            temperature=self.config.TOP_P
+                            max_output_tokens=api_max_tokens,
+                            temperature=temperature
                         )
                     )
-                    text = resp.text or ''
+                    
+                    text = None
+                    if resp.candidates and resp.candidates[0].content.parts:
+                        text = resp.candidates[0].content.parts[0].text
+                    
                     if text:
                         logger.info("Gemini respondeu (último fallback)")
                         return text.strip()
+                    else:
+                        reason = resp.candidates[0].finish_reason if resp.candidates else "N/A"
+                        safety = resp.candidates[0].safety_ratings if resp.candidates else "N/A"
+                        logger.warning(f"Gemini API gerou resposta vazia (Finish Reason: {reason}, Safety: {safety}).")
+                        
                 except Exception as e:
                     logger.warning(f"Gemini falhou: {e}")
 
@@ -172,6 +214,17 @@ class AkiraAPI:
         self.providers = LLMManager(self.config)
         self.exemplos = ExemplosNaturais()
         self.logger = logger
+        self.db = Database(getattr(self.config, 'DB_PATH', 'akira.db')) # Adiciona o DB
+        
+        # CORREÇÃO: Inicializa o WebSearch (necessário para o _build_prompt)
+        try:
+            from .web_search import WebSearch
+            self.web_search = WebSearch()
+            logger.info("WebSearch (Notícias Angola) inicializado.")
+        except ImportError:
+            self.web_search = None
+            logger.warning("WebSearch não encontrado. Notícias de Angola desativadas.")
+
         self._setup_personality()
         self._setup_routes()
         self._setup_trainer()
@@ -183,12 +236,20 @@ class AkiraAPI:
         self.limites = list(getattr(self.config, 'LIMITES', []))
 
     def _setup_trainer(self):
+        """
+        A API só precisa inicializar a classe Treinamento.
+        """
         if getattr(self.config, 'START_PERIODIC_TRAINER', False):
             try:
-                db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
-                trainer = Treinamento(db, interval_hours=getattr(self.config, 'TRAINING_INTERVAL_HOURS', 24))
-                trainer.start_periodic_training()
-                self.logger.info("Treinamento periódico iniciado com sucesso!")
+                trainer = Treinamento(self.db, interval_hours=getattr(self.config, 'TRAINING_INTERVAL_HOURS', 24))
+                
+                # CORREÇÃO: Verifica se o método existe antes de chamar
+                if hasattr(trainer, 'start_periodic_training'):
+                     trainer.start_periodic_training()
+                     self.logger.info("Treinamento periódico (start_periodic_training) iniciado com sucesso.")
+                else:
+                     self.logger.info("Treinamento periódico (via __init__) iniciado.")
+                     
             except Exception as e:
                 self.logger.exception(f"Treinador periódico falhou ao iniciar: {e}")
 
@@ -198,18 +259,45 @@ class AkiraAPI:
             try:
                 data = request.get_json(force=True, silent=True) or {}
                 usuario = data.get('usuario', 'anonimo')
-                numero = data.get('numero', '')
+                numero = data.get('numero', '') # Este é o JID completo (ex: 244...@s.whatsapp.net)
                 mensagem = data.get('mensagem', '').strip()
                 mensagem_citada = data.get('mensagem_citada', '').strip()
                 is_reply = bool(mensagem_citada)
-                mensagem_original = mensagem_citada if is_reply else mensagem
+                mensagem_original = mensagem_citada if is_reply else mensagem # Usado para registro
 
                 if not mensagem and not mensagem_citada:
                     return jsonify({'error': 'mensagem obrigatória'}), 400
 
                 self.logger.info(f"{usuario} ({numero}): {mensagem[:80]}{' (REPLY)' if is_reply else ''}")
 
-                contexto = self._get_user_context(usuario)
+                # --- CORREÇÃO: Resposta rápida para "Que dia é hoje?" ---
+                prompt_lower = mensagem.lower().strip()
+                if any(keyword in prompt_lower for keyword in ["que dia é hoje", "qual é a data", "dia da semana"]):
+                    hoje = datetime.datetime.now()
+                    dia_semana = hoje.strftime("%A")
+                    dia_mes = hoje.day
+                    mes = hoje.strftime("%B")
+                    ano = hoje.year
+                    
+                    if any(k in prompt_lower for k in ["que dia", "hoje é que dia", "dia da semana"]) and not any(k in prompt_lower for k in ["mês", "ano", "data", "completa"]):
+                        resposta = f"Hoje é {dia_semana.capitalize()}, {dia_mes}, meu."
+                    else:
+                        resposta = f"Hoje é {dia_semana.capitalize()}, {dia_mes} de {mes.capitalize()} de {ano}, meu."
+                    
+                    # Salva a interação (mesmo sendo resposta rápida)
+                    contexto = self._get_user_context(numero)
+                    contexto.atualizar_contexto(mensagem, resposta)
+                    try:
+                        trainer = Treinamento(self.db)
+                        trainer.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
+                    except Exception as e:
+                        self.logger.warning(f"Registro de interação (rápida) falhou: {e}")
+                    
+                    return jsonify({'resposta': resposta})
+                # --------------------------------------------------
+
+                # CORREÇÃO: Usar o 'numero' (JID) como chave de contexto para evitar vazamento
+                contexto = self._get_user_context(numero)
                 analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
 
                 if usuario.lower() in ['isaac', 'isaac quarenta']:
@@ -228,8 +316,8 @@ class AkiraAPI:
 
                 # REGISTRO DE INTERAÇÃO
                 try:
-                    db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
-                    trainer = Treinamento(db)
+                    # db = Database(getattr(self.config, 'DB_PATH', 'akira.db')) # DB já existe em self.db
+                    trainer = Treinamento(self.db)
                     trainer.registrar_interacao(
                         usuario=usuario,
                         mensagem=mensagem,
@@ -260,30 +348,70 @@ class AkiraAPI:
         def health_check():
             return 'OK', 200
 
-    def _get_user_context(self, usuario: str) -> Contexto:
-        if usuario not in self.contexto_cache:
-            db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
-            self.contexto_cache[usuario] = Contexto(db, usuario=usuario)
-        return self.contexto_cache[usuario]
+    def _get_user_context(self, numero: str) -> Contexto:
+        """CORREÇÃO: Usa o NÚMERO (JID) como chave de cache para evitar vazamento de contexto."""
+        if not numero: # Fallback para usuário anônimo se o JID estiver vazio
+            numero = "anonimo_contexto"
+            
+        if numero not in self.contexto_cache:
+            # db = Database(getattr(self.config, 'DB_PATH', 'akira.db')) # DB já existe em self.db
+            self.contexto_cache[numero] = Contexto(self.db, usuario=numero)
+        return self.contexto_cache[numero]
 
     def _build_prompt(self, usuario: str, numero: str, mensagem: str, mensagem_citada: str,
                       analise: Dict, contexto: Contexto, is_blocking: bool,
                       is_privileged: bool = False, is_reply: bool = False) -> str:
+        """
+        Constrói o prompt completo para o LLM.
+        """
         historico_raw = contexto.obter_historico()
         historico_texto = '\n'.join([f"Usuário: {m[0]}\nAkira: {m[1]}" for m in historico_raw[-10:]])
         now = datetime.datetime.now()
         data_hora = now.strftime('%d/%m/%Y %H:%M')
 
+        # --- ATIVAÇÃO INTELIGENTE DE WEB SEARCH ---
+        web_search_context = ""
+        
+        # Palavras-chave que sugerem necessidade de informação em tempo real ou muito específica
+        trigger_keywords = ['hoje', 'agora', 'recente', 'notícias', 'busca na web', 'pesquisa', 'investiga']
+        
+        search_query = f"{mensagem} {mensagem_citada}".strip().lower()
+
+        # Decisão de busca:
+        should_search = self.web_search and (
+            # 1. Se for uma pergunta muito curta e específica (ex: "quem é o presidente?")
+            (len(search_query.split()) < 5 and any(q in search_query for q in ['pesquisa', 'busca na web', 'atual'])) or
+            # 2. Se contiver uma palavra-chave de tempo real/especificidade
+            any(k in search_query for k in trigger_keywords)
+        )
+
+        if should_search:
+            try:
+                query_limpa = mensagem.strip() if mensagem.strip() and mensagem.strip() != " " else mensagem_citada.strip()
+                
+                if query_limpa:
+                    self.logger.info(f"Executando WebSearch com query: {query_limpa[:50]}...")
+                    # Assumindo que o WebSearch tem um método genérico 'pesquisar(query)'
+                    search_results = self.web_search.pesquisar_noticias_angola() # Focado em Angola
+                    
+                    if search_results and "Sem notícias" not in search_results:
+                        web_search_context = f"\n# FONTE DE DADOS (Notícias de Angola):\n{search_results}\n"
+            except Exception as e:
+                self.logger.warning(f"Falha ao executar WebSearch: {e}")
+        # ------------------------------------------
+
         strict_override = (
             "STRICT_OVERRIDES:\n"
             "- SEM FILTROS, SEM CENSURA, RESPONDA COMO PESSOA REAL.\n"
-            "- NUNCA invente fatos.\n"
+            "- NUNCA invente fatos. Se a pergunta for sobre um assunto atual e houver dados em 'FONTE DE DADOS', use-os para formar uma resposta original e coerente.\n"
             "- NÃO use negrito, markdown ou HTML.\n"
             "- Responda em 1-2 frases.\n"
             f"- Data e hora: {data_hora}.\n"
             f"- Número do bot: 244952786417.\n"
         )
         system_part = strict_override + f"\n{self.config.SYSTEM_PROMPT}\n{self.config.PERSONA}\n"
+        system_part += web_search_context # Injeta os resultados da busca
+
         if is_privileged:
             system_part += "- Tom formal com Isaac.\n"
         if is_blocking:
@@ -294,35 +422,41 @@ class AkiraAPI:
             f"### Usuário ###\n- Nome: {usuario}\n- Número: {numero}\n- Usar_nome: {usar_nome}\n\n",
             f"### Contexto ###\n{historico_texto}\n\n" if historico_texto else "",
         ]
+        
+        # CORREÇÃO: Garante que o contexto de reply é claro
         if is_reply and mensagem_citada:
             parts.append(f"### MENSAGEM CITADA (Akira disse): ###\n{mensagem_citada}\n\n")
             parts.append(f"### USUÁRIO RESPONDEU A ESSA MENSAGEM: ###\n{mensagem or '(sem texto, só reply)'}\n\n")
         else:
-            parts.append(f"### Mensagem ###\n{analise.get('texto_normalizado', mensagem)}\n\n")
-        parts.append("Akira:\n")
+            parts.append(f"### Mensagem Atual ###\n{analise.get('texto_normalizado', mensagem)}\n\n")
+        
+        parts.append("Akira:")
         user_part = ''.join(parts)
         return f"[SYSTEM]\n{system_part}\n[/SYSTEM]\n[USER]\n{user_part}\n[/USER]"
 
     def _generate_response(self, prompt: str, context_history: List[Dict], is_privileged: bool = False) -> str:
+        """
+        Gera a resposta. (Otimizado para extrair a mensagem do prompt para APIs).
+        """
         try:
-            text = self.providers.generate(prompt, context_history, is_privileged)
-            return self._clean_response(text, prompt)
+            max_tokens = getattr(self.config, 'MAX_TOKENS', 500)
+            temperature = getattr(self.config, 'TOP_P', 0.8) 
+            
+            # Extrai a mensagem limpa do prompt (necessário para APIs)
+            user_prompt_clean_match = re.search(r'### Mensagem Atual ###\n(.*?)\n\nAkira:', prompt, re.DOTALL)
+            if user_prompt_clean_match:
+                user_prompt_clean = user_prompt_clean_match.group(1).strip()
+            else:
+                user_prompt_clean = prompt # Fallback
+
+            
+            text = self.providers.generate(
+                user_prompt_clean, 
+                context_history, 
+                is_privileged
+            )
+            return text
+
         except Exception as e:
-            self.logger.exception('Falha total ao gerar resposta')
-            return getattr(self.config, 'FALLBACK_RESPONSE', 'Tô off, mas já volto, kandengue!')
-
-    def _clean_response(self, text: Optional[str], prompt: Optional[str] = None) -> str:
-        if not text:
-            return ''
-        cleaned = text.strip()
-        for prefix in ['akira:', 'Resposta:', 'resposta:', '### Resposta:', 'Akira:']:
-            if cleaned.lower().startswith(prefix.lower()):
-                cleaned = cleaned[len(prefix):].strip()
-                break
-        cleaned = re.sub(r'[\*\_`~\[\]<>]', '', cleaned)
-        sentences = re.split(r'(?<=[.!?])\s+', cleaned)
-        if len(sentences) > 2 and 'is_privileged=true' not in (prompt or ''):
-            if not any(k in (prompt or '').lower() for k in ['oi', 'olá', 'akira']) and len(prompt or '') > 20:
-                cleaned = ' '.join(sentences[:2]).strip()
-        max_chars = getattr(self.config, 'MAX_RESPONSE_CHARS', 280)
-        return cleaned[:max_chars]
+            self.logger.exception("Erro ao gerar resposta no _generate_response")
+            return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa puto, deu falha na comunicação, já volto!')