Update modules/api.py

modules/api.py

@@ -1,6 +1,7 @@
 """
 API wrapper for Akira service.
 Integração mínima e robusta: config → db → contexto → LLM → resposta.
+Prioridade: Mistral → Gemini → Llama Local
 """
 import time
 import re
@@ -11,8 +12,7 @@ from loguru import logger
 
 # LLM PROVIDERS
 import google.generativeai as genai
-from mistralai.client import MistralClient
-from mistralai.models.chat_completion import ChatMessage  # ← v1.0.3: CAMINHO CORRETO
+from mistralai import Mistral  # v1.0.3
 from .local_llm import LlamaLLM
 
 # LOCAL MODULES
@@ -23,10 +23,35 @@ from .exemplos_naturais import ExemplosNaturais
 import modules.config as config
 
 
+# --- CACHE SIMPLES COM TTL ---
+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]
+
+
+# --- GERENCIADOR DE LLMs ---
 class LLMManager:
     def __init__(self, config_instance):
         self.config = config_instance
-        self.mistral_client: Optional[MistralClient] = None
+        self.mistral_client: Optional[Mistral] = None
         self.gemini_model: Optional[genai.GenerativeModel] = None
         self.llama_llm = self._import_llama()
         self._setup_providers()
@@ -37,27 +62,26 @@ class LLMManager:
         if not self.providers:
             logger.error("Nenhum provedor LLM ativo.")
         else:
-            logger.info(f"Provedores: {self.providers}")
+            logger.info(f"Provedores ativos: {self.providers}")
 
     def _import_llama(self):
         try:
             return LlamaLLM()
-        except:
+        except Exception as e:
+            logger.warning(f"Llama local não carregado: {e}")
             return None
 
     def _setup_providers(self):
-        # MISTRAL
         if getattr(self.config, 'MISTRAL_API_KEY', '').startswith('m-'):
             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 conectado")
             except Exception as e:
                 logger.warning(f"Mistral falhou: {e}")
                 self.mistral_client = None
         else:
-            logger.warning("Mistral desativado (chave inválida)")
+            logger.warning("MISTRAL_API_KEY inválida")
 
-        # GEMINI - SEM FILTROS
         if getattr(self.config, 'GEMINI_API_KEY', '').startswith('AIza'):
             try:
                 genai.configure(api_key=self.config.GEMINI_API_KEY)
@@ -71,25 +95,25 @@ class LLMManager:
                         {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
                     ]
                 )
-                logger.info(f"Gemini OK: {self.config.GEMINI_MODEL} (FILTROS DESATIVADOS)")
+                logger.info(f"Gemini conectado: {self.config.GEMINI_MODEL}")
             except Exception as e:
                 logger.warning(f"Gemini falhou: {e}")
                 self.gemini_model = None
         else:
-            logger.warning("Gemini desativado (chave inválida)")
+            logger.warning("GEMINI_API_KEY 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 + " (SEM FILTROS, RESPOSTA DIRETA)"
-        messages = [ChatMessage(role="system", content=full_system)]
+        messages = [{"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))
+            messages.append({"role": role, "content": turn["content"]})
+        messages.append({"role": "user", "content": user_prompt})
 
         for provider in self.providers:
             if provider == 'mistral' and 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,
@@ -106,8 +130,8 @@ class LLMManager:
                 try:
                     gemini_hist = []
                     for msg in messages[1:]:
-                        role = "user" if msg.role == "user" else "model"
-                        gemini_hist.append({"role": role, "parts": [{"text": msg.content}]})
+                        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={
@@ -115,55 +139,29 @@ class LLMManager:
                             "temperature": self.config.TOP_P
                         }
                     )
-                    if resp.text:
-                        text = resp.text
-                    elif resp.candidates and resp.candidates[0].content.parts:
-                        text = resp.candidates[0].content.parts[0].text
-                    else:
-                        logger.warning("Gemini bloqueado ou vazio")
-                        continue
+                    text = resp.text or (
+                        resp.candidates[0].content.parts[0].text
+                        if resp.candidates and resp.candidates[0].content.parts else ''
+                    )
                     if text:
                         logger.info("Gemini respondeu")
                         return text.strip()
                 except Exception as e:
                     logger.warning(f"Gemini falhou: {e}")
 
-            elif provider == 'llama' and self.llama_llm and self.llama_llm.is_available():
+            elif provider == 'llama' and self.llama_llm:
                 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
+                    text = self.llama_llm.generate(user_prompt, max_tokens=self.config.MAX_TOKENS, temperature=self.config.TOP_P)
+                    if text:
+                        logger.info("Llama local respondeu")
+                        return text.strip()
                 except Exception as e:
                     logger.warning(f"Llama falhou: {e}")
 
-        logger.error("Todos os LLMs 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)
+        return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, puto, to off hoje.')
 
-    def __getitem__(self, key):
-        if key not in self: raise KeyError(key)
-        return self._store[key][0]
 
-
-# --- AKIRA API ---
+# --- API PRINCIPAL ---
 class AkiraAPI:
     def __init__(self, cfg_module):
         self.config = cfg_module
@@ -176,8 +174,8 @@ class AkiraAPI:
         self._setup_personality()
         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")
+        self.app.register_blueprint(self.api, url_prefix="")
 
     def _setup_personality(self):
         self.humor = getattr(self.config, 'HUMOR_INICIAL', 'neutra')
@@ -192,20 +190,22 @@ class AkiraAPI:
                 usuario = data.get('usuario', 'anonimo')
                 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'))
-                mensagem_original = data.get('mensagem_original') or data.get('quoted_message') or ''
+                is_privileged = usuario.lower() in ['isaac', 'isaac quarenta'] or numero in self.config.PRIVILEGED_USERS
+                is_reply = bool(data.get('is_reply') or data.get('mensagem_original'))
+                mensagem_original = data.get('mensagem_original', '')
 
-                if not mensagem:
+                if not mensagem.strip():
                     return jsonify({'error': 'mensagem obrigatória'}), 400
 
                 self.logger.info(f"{usuario} ({numero}): {mensagem[:120]}")
                 contexto = self._get_user_context(usuario)
+
+                # MÉTODOS AGORA EXISTEM
                 analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
-                if usuario.lower() == 'isaac':
+                if usuario.lower() in ['isaac', 'isaac quarenta']:
                     analise['usar_nome'] = False
 
-                is_blocking = len(mensagem) < 10 and any(k in mensagem.lower() for k in ['exec', 'bash', 'open', 'api_key', 'key'])
+                is_blocking = 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)
 
@@ -287,7 +287,8 @@ class AkiraAPI:
             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 ''
+        if not text:
+            return ''
         cleaned = text.strip()
         for prefix in ['akira:', 'Resposta:', 'resposta:']:
             if cleaned.lower().startswith(prefix.lower()):