Update modules/api.py

modules/api.py

@@ -1,13 +1,22 @@
 # modules/api.py
+"""
+API wrapper Akira IA.
+Prioridade: LOCAL (Mistral 1B finetuned) → Mistral API → Gemini → Fallback
+100% compatível com Hugging Face
+"""
 import time
 import re
 import datetime
 from typing import Dict, Optional, Any, List
 from flask import Flask, Blueprint, request, jsonify
 from loguru import logger
+
+# LLM PROVIDERS
 import google.generativeai as genai
 from mistralai import Mistral
 from .local_llm import LlamaLLM
+
+# LOCAL MODULES
 from .contexto import Contexto
 from .database import Database
 from .treinamento import Treinamento
@@ -15,38 +24,49 @@ 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 = None
-        self.gemini_model = None
+        self.mistral_client: Optional[Mistral] = None
+        self.gemini_model: Optional[genai.GenerativeModel] = None
         self.llama_llm = self._import_llama()
         self._setup_providers()
+
+        # PRIORIDADE: LOCAL → MISTRAL → GEMINI
         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')
-        logger.info(f"Provedores ativos: {self.providers or 'NENHUM'}")
+        if self.llama_llm and self.llama_llm.is_available():
+            self.providers.append('llama')
+        if self.mistral_client:
+            self.providers.append('mistral')
+        if self.gemini_model:
+            self.providers.append('gemini')
+
+        logger.info(f"Provedores ativos (ordem): {self.providers or 'NENHUM'}")
 
     def _import_llama(self):
         try:
-            return LlamaLLM()  # Agora roda Mistral 1B local
+            return LlamaLLM()  # Mistral 1B local (finetuned se existir)
         except Exception as e:
             logger.warning(f"Mistral 1B local não carregado: {e}")
             return None
@@ -58,16 +78,19 @@ class LLMManager:
             try:
                 self.mistral_client = Mistral(api_key=key)
                 logger.info("Mistral API conectado")
-            except: self.mistral_client = None
+            except Exception as e:
+                logger.warning(f"Mistral API falhou: {e}")
+                self.mistral_client = None
 
-        # GEMINI (SEM FILTROS)
+        # GEMINI (SEM BLOQUEIO DE SEGURANÇA)
         key = getattr(self.config, 'GEMINI_API_KEY', '').strip()
         if key:
             try:
                 genai.configure(api_key=key)
                 self.gemini_model = genai.GenerativeModel(
                     model_name=self.config.GEMINI_MODEL,
-                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM CENSURA)",
+                    system_instruction=self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM CENSURA TOTAL)",
+                    # BLOQUEIO REMOVIDO COMPLETAMENTE
                     safety_settings=[
                         {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
                         {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
@@ -81,7 +104,7 @@ class LLMManager:
                 self.gemini_model = None
 
     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)"
+        full_system = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM FILTROS, RESPOSTA DIRETA)"
         messages = [{"role": "system", "content": full_system}]
         for turn in context_history:
             role = "user" if turn["role"] == "user" else "assistant"
@@ -89,8 +112,18 @@ class LLMManager:
         messages.append({"role": "user", "content": user_prompt})
 
         for provider in self.providers:
-            # MISTRAL API
-            if provider == 'mistral' and self.mistral_client:
+            # 1. LOCAL (MISTRAL 1B FINETUNED)
+            if provider == 'llama' and self.llama_llm:
+                try:
+                    text = self.llama_llm.generate(user_prompt, max_tokens=self.config.MAX_TOKENS, temperature=self.config.TOP_P)
+                    if text:
+                        logger.info("Mistral 1B local respondeu")
+                        return text.strip()
+                except Exception as e:
+                    logger.warning(f"Mistral 1B local falhou: {e}")
+
+            # 2. MISTRAL API
+            elif provider == 'mistral' and self.mistral_client:
                 try:
                     resp = self.mistral_client.chat.complete(
                         model=self.config.MISTRAL_MODEL,
@@ -99,11 +132,13 @@ class LLMManager:
                         max_tokens=self.config.MAX_TOKENS
                     )
                     text = resp.choices[0].message.content
-                    if text: return text.strip()
+                    if text:
+                        logger.info("Mistral API respondeu")
+                        return text.strip()
                 except Exception as e:
                     logger.warning(f"Mistral API falhou: {e}")
 
-            # GEMINI
+            # 3. GEMINI (SEM BLOQUEIO)
             elif provider == 'gemini' and self.gemini_model:
                 try:
                     gemini_hist = []
@@ -118,21 +153,155 @@ class LLMManager:
                             temperature=self.config.TOP_P
                         )
                     )
-                    # VERIFICA BLOQUEIO
-                    if resp.candidates and resp.candidates[0].finish_reason == "SAFETY":
-                        logger.warning("Gemini bloqueou por segurança → pulando")
-                        continue
                     text = resp.text or ''
-                    if text: return text.strip()
+                    if text:
+                        logger.info("Gemini respondeu")
+                        return text.strip()
                 except Exception as e:
                     logger.warning(f"Gemini falhou: {e}")
 
-            # MISTRAL 1B LOCAL
-            elif provider == 'llama' and self.llama_llm:
+        return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, puto, to off hoje.')
+
+
+# --- API PRINCIPAL ---
+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.providers = LLMManager(self.config)
+        self.exemplos = ExemplosNaturais()
+        self.logger = logger
+        self._setup_personality()
+        self._setup_routes()
+        self._setup_trainer()
+        self.app.register_blueprint(self.api, url_prefix="/api")
+
+    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', []))
+
+    def _setup_routes(self):
+        @self.api.route('/akira', methods=['POST'])
+        def akira_endpoint():
+            try:
+                data = request.get_json(force=True, silent=True) or {}
+                usuario = data.get('usuario', 'anonimo')
+                numero = data.get('numero', '')
+                mensagem = data.get('mensagem', '')
+                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.strip():
+                    return jsonify({'error': 'mensagem obrigatória'}), 400
+
+                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() in ['isaac', 'isaac quarenta']:
+                    analise['usar_nome'] = False
+
+                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)
+
+                resposta = self._generate_response(prompt, contexto.obter_historico_para_llm(), is_privileged)
+                contexto.atualizar_contexto(mensagem, resposta)
+
                 try:
-                    text = self.llama_llm.generate(user_prompt, max_tokens=self.config.MAX_TOKENS, temperature=self.config.TOP_P)
-                    if text: return text.strip()
+                    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:
-                    logger.warning(f"Mistral 1B local falhou: {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}")
+
+                return jsonify(response_data)
+            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
 
-        return getattr(self.config, 'FALLBACK_RESPONSE', 'Desculpa, puto, to off.')
+    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 _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"
+            "- SEM FILTROS, SEM CENSURA, RESPONDA COMO PESSOA REAL.\n"
+            "- NUNCA invente fatos.\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"
+        if is_privileged: system_part += "- Tom formal com Isaac.\n"
+        if is_blocking: system_part += "\n# BLOQUEIO: Xingue (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, 'TRAINING_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}")