Update modules/api.py

modules/api.py

@@ -1,314 +1,263 @@
 """
-API wrapper for Akira service.
-Integração mínima e robusta: config → db → contexto → LLM → resposta.
+API wrapper para o serviço Akira - VERSÃO FINAL (11/2025)
+✅ Corrige erro 'str' object has no attribute get'
+✅ Tolerante a JSON malformado ou encoding incorreto (ex: Baileys)
+✅ Compatível com Mistral SDK novo e antigo
+✅ Logs detalhados
 """
+
+from typing import Any
 import time
 import re
 import datetime
-from typing import Dict, Optional, Any, List
+import random
+import json
 from flask import Flask, Blueprint, request, jsonify
 from loguru import logger
-
-# LLM PROVIDERS
-import google.generativeai as genai
-from mistralai.client import MistralClient
-from mistralai.types.chat import ChatMessage  # CORREÇÃO: Caminho atualizado para SDK Mistral v1.0.0+
-from .local_llm import LlamaLLM
-
-# LOCAL MODULES
+import modules.config as config
 from .contexto import Contexto
 from .database import Database
 from .treinamento import Treinamento
-from .exemplos_naturais import ExemplosNaturais
-import modules.config as config
+from .web_search import WebSearch
+from .local_llm import LlamaLLM
+
+
+# ================================
+# CONFIGURAÇÃO DE PROVEDORES
+# ================================
+
+try:
+    from mistralai import Mistral
+    try:
+        # Compatível com todas as versões do SDK
+        from mistralai.models.chat import ChatMessage
+    except ImportError:
+        from mistralai.types import ChatMessage
+    mistral_available = True
+except ImportError:
+    mistral_available = False
+    logger.warning("⚠️ Mistral SDK não instalado.")
+
+try:
+    import google.generativeai as genai
+    gemini_available = True
+except ImportError:
+    gemini_available = False
+    logger.warning("⚠️ google-generativeai não instalado.")
 
 
 class LLMManager:
-    def __init__(self, config_instance):
-        self.config = config_instance
-        self.mistral_client: Optional[MistralClient] = None
-        self.gemini_model: Optional[genai.GenerativeModel] = None
-        self.llama_llm = self._import_llama()
+    def __init__(self, config):
+        self.config = config
+        self.llama = LlamaLLM()
+        self.mistral_client = None
+        self.gemini_model = None
         self._setup_providers()
-        self.providers = []
-        if self.mistral_client: self.providers.append('mistral')
-        if self.gemini_model: self.providers.append('gemini')
-        if self.llama_llm and self.llama_llm.is_available(): self.providers.append('llama')
-        if not self.providers:
-            logger.error("Nenhum provedor LLM ativo.")
-        else:
-            logger.info(f"Provedores: {self.providers}")
-
-    def _import_llama(self):
-        try:
-            return LlamaLLM()
-        except:
-            return None
 
     def _setup_providers(self):
-        # MISTRAL
-        if getattr(self.config, 'MISTRAL_API_KEY', '').startswith('m-'):
+        if mistral_available and self.config.MISTRAL_API_KEY:
             try:
-                self.mistral_client = MistralClient(api_key=self.config.MISTRAL_API_KEY)
-                logger.info("Mistral API OK")
+                self.mistral_client = Mistral(api_key=self.config.MISTRAL_API_KEY)
+                logger.info("✅ Mistral API inicializada (principal)")
             except Exception as e:
-                logger.warning(f"Mistral falhou: {e}")
+                logger.warning(f"⚠️ Falha ao inicializar Mistral: {e}")
                 self.mistral_client = None
-        else:
-            logger.warning("Mistral desativado (chave inválida)")
 
-        # GEMINI
-        if getattr(self.config, 'GEMINI_API_KEY', '').startswith('AIza'):
+        if gemini_available and self.config.GEMINI_API_KEY:
             try:
                 genai.configure(api_key=self.config.GEMINI_API_KEY)
-                self.gemini_model = genai.GenerativeModel(
-                    model=self.config.GEMINI_MODEL,
-                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT + " (NLP/Transformers otimizado)"
-                )
-                logger.info(f"Gemini OK: {self.config.GEMINI_MODEL}")
+                self.gemini_model = genai.GenerativeModel(self.config.GEMINI_MODEL)
+                logger.info("✅ Gemini inicializado (fallback)")
             except Exception as e:
-                logger.warning(f"Gemini falhou: {e}")
+                logger.warning(f"⚠️ Falha ao inicializar Gemini: {e}")
                 self.gemini_model = None
-        else:
-            logger.warning("Gemini desativado (chave inválida)")
-
-    def generate(self, user_prompt: str, context_history: List[dict] = [], is_privileged: bool = False) -> str:
-        full_system = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (NLP/Transformers otimizado)"
-        messages = [ChatMessage(role="system", content=full_system)]
-        for turn in context_history:
-            role = "user" if turn["role"] == "user" else "assistant"
-            messages.append(ChatMessage(role=role, content=turn["content"]))
-        messages.append(ChatMessage(role="user", content=user_prompt))
-
-        for provider in self.providers:
-            if provider == 'mistral' and self.mistral_client:
+
+    def _limpar_resposta(self, texto: str) -> str:
+        if not texto:
+            return ""
+        texto = re.sub(r'[\*\_\`\[\]\"]', '', texto)
+        texto = re.sub(r'\s+', ' ', texto.replace('\n', ' ')).strip()
+        if len(texto) > 280:
+            frases = [f.strip() for f in texto.split('. ') if f.strip()]
+            curto = ""
+            for f in frases:
+                if len(curto + f + ". ") <= 280:
+                    curto += f + ". "
+                else:
+                    break
+            texto = curto.strip()
+            if not texto.endswith(('.', '!', '?')):
+                texto += "..."
+        return texto.strip()
+
+    def generate(self, prompt: str, max_tokens: int = 500, temperature: float = 0.8) -> str:
+        max_attempts = 6
+        for attempt in range(1, max_attempts + 1):
+            if self.mistral_client:
                 try:
-                    resp = self.mistral_client.chat(
+                    resp = self.mistral_client.chat.complete(
                         model=self.config.MISTRAL_MODEL,
-                        messages=messages,
-                        temperature=self.config.TOP_P,
-                        max_tokens=self.config.MAX_TOKENS
+                        messages=[{"role": "user", "content": prompt}],
+                        max_tokens=max_tokens,
+                        temperature=temperature,
+                        top_p=self.config.TOP_P,
                     )
                     text = resp.choices[0].message.content
                     if text:
-                        logger.info("Mistral respondeu")
-                        return text.strip()
+                        logger.info(f"✅ Mistral OK (tentativa {attempt})")
+                        return self._limpar_resposta(text)
+                except Exception as e:
+                    if "401" in str(e) or "Unauthorized" in str(e):
+                        logger.error("❌ MISTRAL: Chave inválida!")
+                    elif "429" in str(e):
+                        time.sleep(2 ** (attempt % 3))
+                    logger.warning(f"Mistral erro {attempt}: {e}")
+
+            if self.llama.model:
+                try:
+                    resp = self.llama.generate(prompt, max_tokens)
+                    if resp.strip():
+                        logger.info(f"✅ Llama OK (tentativa {attempt})")
+                        return self._limpar_resposta(resp)
                 except Exception as e:
-                    logger.warning(f"Mistral falhou: {e}")
+                    logger.warning(f"Llama erro {attempt}: {e}")
 
-            elif provider == 'gemini' and self.gemini_model:
+            if self.gemini_model:
                 try:
-                    gemini_hist = []
-                    for msg in messages[1:]:
-                        # Note: ChatMessage from Mistral SDK doesn't have a direct 'role' attribute,
-                        # but we rely on the object's structure or convert it. Assuming 'role' and 'content' are present.
-                        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={"max_output_tokens": self.config.MAX_TOKENS, "temperature": self.config.TOP_P}
+                        prompt,
+                        generation_config={
+                            "max_output_tokens": max_tokens,
+                            "temperature": temperature,
+                            "top_p": self.config.TOP_P,
+                        }
                     )
                     text = resp.text
                     if text:
-                        logger.info("Gemini respondeu")
-                        return text.strip()
+                        logger.info(f"✅ Gemini OK (tentativa {attempt})")
+                        return self._limpar_resposta(text)
                 except Exception as e:
-                    logger.warning(f"Gemini falhou: {e}")
+                    if "429" in str(e) or "quota" in str(e):
+                        time.sleep(2 ** (attempt % 3))
+                    logger.warning(f"Gemini erro {attempt}: {e}")
 
-            elif provider == 'llama' and self.llama_llm and self.llama_llm.is_available():
-                try:
-                    local = self.llama_llm.generate(user_prompt, max_tokens=self.config.MAX_TOKENS, temperature=self.config.TOP_P)
-                    if local:
-                        logger.info("Llama respondeu")
-                        return local
-                except Exception as e:
-                    logger.warning(f"Llama falhou: {e}")
-
-        logger.error("Todos os LLMs falharam")
+        logger.error("❌ Todos os provedores falharam.")
         return self.config.FALLBACK_RESPONSE
 
 
-# --- CACHE ---
-class SimpleTTLCache:
-    def __init__(self, ttl_seconds: int = 300):
-        self.ttl = ttl_seconds
-        self._store = {}
-
-    def __contains__(self, key):
-        if key not in self._store: return False
-        _, expires = self._store[key]
-        if time.time() > expires:
-            del self._store[key]
-            return False
-        return True
-
-    def __setitem__(self, key, value):
-        self._store[key] = (value, time.time() + self.ttl)
-
-    def __getitem__(self, key):
-        if key not in self: raise KeyError(key)
-        return self._store[key][0]
-
+# ================================
+# CLASSE PRINCIPAL AKIRA API
+# ================================
 
-# --- AKIRA API ---
 class AkiraAPI:
     def __init__(self, cfg_module):
         self.config = cfg_module
         self.app = Flask(__name__)
         self.api = Blueprint("akira_api", __name__)
-        self.contexto_cache = SimpleTTLCache(ttl_seconds=getattr(self.config, 'MEMORIA_MAX', 300))
+        self.db = Database(getattr(self.config, 'DB_PATH', '/app/data/akira.db'))
+        self.contexto_cache = {}
         self.providers = LLMManager(self.config)
-        self.exemplos = ExemplosNaturais()
-        self.logger = logger
-        self._setup_personality()
+        self.treinador = Treinamento(self.db)
+        self.web_search = WebSearch()
         self._setup_routes()
-        self._setup_trainer()
-        self.app.register_blueprint(self.api, url_prefix="/api", name="akira_api_prefixed")
-        self.app.register_blueprint(self.api, url_prefix="", name="akira_api_root")
+        self.app.register_blueprint(self.api, url_prefix="/api")
+        if getattr(self.config, 'START_PERIODIC_TRAINER', False):
+            self.treinador.start_periodic_training()
+
+    def _get_user_context(self, usuario: str, numero: str) -> Contexto:
+        key = numero or usuario
+        if key not in self.contexto_cache:
+            ctx = Contexto(self.db, key)
+            ctx.atualizar_aprendizados_do_banco()
+            self.contexto_cache[key] = ctx
+        return self.contexto_cache[key]
+
+    def _get_pronomes_por_tom(self, tom: str) -> str:
+        result = self.db._execute_with_retry(
+            "SELECT pronomes FROM pronomes_por_tom WHERE tom=?", (tom.lower(),)
+        )
+        return result[0][0] if result else ""
+
+    def _build_prompt(self, usuario, numero, mensagem, emocao, contexto, is_privileged, is_reply, mensagem_original):
+        data_hora = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
+        noticias = self.web_search.pesquisar_noticias_angola()
+        tom_usuario = contexto.ton_predominante or "neutro"
+        pronomes = self._get_pronomes_por_tom(tom_usuario)
+
+        regras = f"""
+REGRAS:
+- Fale como pessoa real de Luanda
+- 1 a 2 frases
+- Pode usar gírias (bué, fixe, oroh, kota, puto)
+- Pode usar sarcasmo leve e risadas (kkk, rsrs)
+- Nada de markdown
+- Data atual: {data_hora}
+"""
 
-    def _setup_personality(self):
-        self.humor = getattr(self.config, 'HUMOR_INICIAL', 'neutra')
-        self.interesses = list(getattr(self.config, 'INTERESSES', []))
-        self.limites = list(getattr(self.config, 'LIMITES', []))
+        hist = contexto.obter_historico()[-3:]
+        hist_txt = "\n".join([f"U: {h[0]}\nA: {h[1]}" for h in hist]) if hist else ""
+
+        user_info = f"Usuário: {usuario} ({numero})\nTom: {tom_usuario}\nEmoção: {emocao}"
+
+        prompt = f"[SYSTEM]\n{regras}\n{self.config.SYSTEM_PROMPT}\n{self.config.PERSONA}\n[/SYSTEM]\n"
+        prompt += f"[CONTEXTO]\n{hist_txt}\n{user_info}\n[/CONTEXTO]\n[MENSAGEM]\n{mensagem}\n[/MENSAGEM]\nAkira:"
+        return prompt
 
     def _setup_routes(self):
         @self.api.route('/akira', methods=['POST'])
+        @self.api.route('/', methods=['POST'])
         def akira_endpoint():
             try:
-                data = request.get_json(force=True, silent=True) or {}
-                usuario = data.get('usuario', 'anonimo')
+                raw_data = request.get_data(as_text=True)
+                logger.info(f"📩 RAW recebido ({len(raw_data)} bytes): {raw_data[:500]}")
+
+                # Decodificação robusta
+                try:
+                    if isinstance(request.json, dict):
+                        data = request.json
+                    else:
+                        data = json.loads(raw_data)
+                except Exception as e:
+                    logger.warning(f"⚠️ JSON inválido: {e}")
+                    data = {}
+
+                if not isinstance(data, dict):
+                    logger.warning(f"🚨 Corpo não é dict: {type(data)}")
+                    data = {}
+
+                usuario = data.get('usuario', 'Anônimo')
                 numero = data.get('numero', '')
                 mensagem = data.get('mensagem', '')
-                is_privileged = bool(data.get('is_privileged_user', False)) or usuario.lower() == 'isaac'
-                is_reply = bool(data.get('is_reply') or data.get('mensagem_original') or data.get('quoted_message'))
+                is_privileged = (usuario.lower() == 'isaac' or '244937035662' in numero)
+                is_reply = bool(data.get('is_reply') or data.get('mensagem_original'))
                 mensagem_original = data.get('mensagem_original') or data.get('quoted_message') or ''
 
-                if not mensagem:
-                    return jsonify({'error': 'mensagem obrigatória'}), 400
+                logger.info(f"👤 {usuario} ({numero}) disse: {mensagem}")
 
-                self.logger.info(f"{usuario} ({numero}): {mensagem[:120]}")
-                contexto = self._get_user_context(usuario)
-                analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
-                if usuario.lower() == 'isaac':
-                    analise['usar_nome'] = False
+                if not isinstance(mensagem, str) or not mensagem.strip():
+                    return jsonify({'error': 'mensagem obrigatória'}), 400
 
-                is_blocking = len(mensagem) < 10 and any(k in mensagem.lower() for k in ['exec', 'bash', 'open', 'api_key', 'key'])
-                prompt = self._build_prompt(usuario, numero, mensagem, analise, contexto, is_blocking,
-                                            is_privileged=is_privileged, is_reply=is_reply, mensagem_original=mensagem_original)
+                contexto = self._get_user_context(usuario, numero)
+                emocao = contexto.analisar_emocoes_mensagem(mensagem)
+                prompt = self._build_prompt(usuario, numero, mensagem, emocao, contexto, is_privileged, is_reply, mensagem_original)
 
-                resposta = self._generate_response(prompt, contexto.obter_historico_para_llm(), is_privileged)
+                resposta = self.providers.generate(prompt, max_tokens=500, temperature=0.8)
+                logger.info(f"💬 Resposta: {resposta}")
 
                 contexto.atualizar_contexto(mensagem, resposta)
-                try:
-                    db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
-                    trainer = Treinamento(db)
-                    trainer.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
-                except Exception as e:
-                    self.logger.warning(f"Registro falhou: {e}")
-
-                response_data = {'resposta': resposta}
-                try:
-                    aprendizados = contexto.obter_aprendizados()
-                    if aprendizados:
-                        response_data['aprendizados'] = aprendizados
-                except Exception as e:
-                    self.logger.warning(f"Aprendizados falharam: {e}")
+                self.treinador.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
 
-                return jsonify(response_data)
+                return jsonify({
+                    'resposta': resposta,
+                    'emocao': emocao,
+                    'usuario': usuario,
+                    'numero': numero
+                })
 
             except Exception as e:
-                self.logger.exception('Erro no /akira')
-                return jsonify({'resposta': getattr(self.config, 'FALLBACK_RESPONSE', 'Erro interno')}), 500
-
-        @self.api.route('/health', methods=['GET'])
-        def health_check():
-            return 'OK', 200
-
-    def _get_user_context(self, usuario: str) -> Contexto:
-        if usuario not in self.contexto_cache:
-            db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
-            self.contexto_cache[usuario] = Contexto(db, user_key=usuario)
-        return self.contexto_cache[usuario]
-
-    def _build_prompt(self, usuario: str, numero: str, mensagem: str, analise: Dict, contexto: Contexto, is_blocking: bool,
-                      is_privileged: bool = False, is_reply: bool = False, mensagem_original: str = '') -> str:
-        historico_raw = contexto.obter_historico()
-        historico_texto = '\n'.join([f"Usuário: {m[0]}\nAkira: {m[1]}" for m in historico_raw])
-        now = datetime.datetime.now()
-        data_hora = now.strftime('%d/%m/%Y %H:%M')
-
-        strict_override = (
-            "STRICT_OVERRIDES:\n"
-            "- NUNCA invente fatos ou mencione eventos/pessoas não presentes no contexto.\n"
-            "- NÃO use negrito, markdown ou HTML.\n"
-            "- Não quebre linhas desnecessariamente.\n"
-            "- Não repita o usuário.\n"
-            "- Para 'oi', 'olá', responda: 'Oi! Tudo bem?' ou 'Olá! Como vai?'\n"
-            "- Se is_privileged=true: tom formal, evite gírias.\n"
-            f"- Data e hora: {data_hora}.\n"
-            f"- Número do bot: 244952786417.\n"
-        )
+                logger.error(f"❌ Erro fatal: {e}", exc_info=True)
+                return jsonify({'resposta': 'deu um erro interno, puto 😅'}), 500
 
-        system_part = strict_override + f"\n{self.config.SYSTEM_PROMPT}\n{self.config.PERSONA}\n"
-        system_part += "\n# Instruções adicionais:\n"
-        if is_privileged:
-            system_part += "- Tom respeitoso, use Sr./Sra., evite gírias.\n"
-        else:
-            system_part += "- Use nome só se fizer sentido. Prefira pronomes.\n"
-
-        if is_blocking:
-            system_part += "\n# BLOQUEIO: Responda com xingamentos (vai pra merda, etc).\n"
-
-        usar_nome = analise.get('usar_nome', False)
-        parts = [
-            f"### Usuário ###\n- Nome: {usuario}\n- Número: {numero}\n- Usar_nome: {usar_nome}\n\n",
-            f"### Contexto ###\n{historico_texto}\n\n",
-            f"### Mensagem ###\n{analise.get('texto_normalizado', mensagem)}\n\n"
-        ]
-        if is_reply and mensagem_original:
-            parts.append(f"### Mensagem original ###\n{mensagem_original}\n\n")
-        parts.append("Akira:\n")
-        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:
-        try:
-            text = self.providers.generate(prompt, context_history, is_privileged)
-            return self._clean_response(text, prompt)
-        except Exception as e:
-            self.logger.exception('Falha ao gerar resposta')
-            return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, estou off.')
-
-    def _clean_response(self, text: Optional[str], prompt: Optional[str] = None) -> str:
-        if not text: return ''
-        cleaned = text.strip()
-        for prefix in ['akira:', 'Resposta:', 'resposta:']:
-            if cleaned.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.lower() for k in ['oi', 'olá', 'akira']) and len(prompt) > 20:
-                cleaned = ' '.join(sentences[:2]).strip()
-        max_chars = getattr(self.config, 'MAX_RESPONSE_CHARS', 280)
-        return cleaned[:max_chars]
-
-    def _setup_trainer(self):
-        if getattr(self.config, 'START_PERIODIC_TRAINER', False):
-            try:
-                db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
-                trainer = Treinamento(db, interval_hours=getattr(self.config, 'TRAIN_INTERVAL_HOURS', 24))
-                trainer.start_periodic_training()
-                self.logger.info("Treinamento periódico iniciado.")
-            except Exception as e:
-                self.logger.exception(f"Treinador falhou: {e}")
-
-    def responder(self, mensagem: str, numero: str, nome: str = 'Usuário') -> str:
-        data = {'usuario': nome, 'numero': numero, 'mensagem': mensagem}
-        contexto = self._get_user_context(nome)
-        analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
-        prompt = self._build_prompt(nome, numero, mensagem, analise, contexto, is_blocking=False)
-        resposta = self._generate_response(prompt, contexto.obter_historico_para_llm())
-        contexto.atualizar_contexto(mensagem, resposta)
-        return resposta
+    def run(self, host='0.0.0.0', port=7860, debug=False):
+        logger.info(f"🚀 Iniciando servidor Flask na porta {port}")
+        self.app.run(host=host, port=port, debug=debug, threaded=True)