Upload 22 files

modules/api.py

@@ -287,7 +287,7 @@ class LLMManager:
                 logger.warning(f"Together AI falhou: {e}")
                 self.together_client = None
 
-    def generate(self, user_prompt: str, context_history: List[dict] = [], is_privileged: bool = False) -> str:
+    def generate(self, user_prompt: str, context_history: List[dict] = [], is_privileged: bool = False) -> Tuple[str, str]:
         """
         Gera resposta usando provedores LLM com fallback em loop.
         
@@ -727,19 +727,15 @@ class AkiraAPI:
                 # Captura robusta de JSON
                 raw_data = request.data
                 try:
-                    # silent=True impede que o Flask aborte com HTTP 400 em caso de erro
+                    # Tenta extrair o JSON perfeitamente
                     data = request.get_json(force=True, silent=True)
                     if data is None:
-                        raise ValueError("get_json retornou None")
+                        # Se falhou, tenta decodificar manualmente o bruto
+                        decoded = raw_data.decode('utf-8', errors='ignore').strip()
+                        data = json.loads(decoded) if decoded else {}
                 except Exception as e:
-                    self.logger.warning(f"[API] Falha no get_json padrão, tentando decodificação manual: {e}")
-                    try:
-                        # Tenta UTF-8 ignorando erros ou Latin-1 como fallback comum de terminais Windows
-                        decoded = raw_data.decode('utf-8', errors='ignore')
-                        data = json.loads(decoded)
-                    except Exception as e2:
-                        self.logger.error(f"[API] Falha crítica ao decodificar JSON: {e2} | Bruto: {raw_data[:200]}")
-                        data = {}
+                    self.logger.error(f"[API] Falha crítica ao decodificar JSON: {e} | Bruto: {raw_data[:200]}")
+                    data = {}
 
                 if not data:
                     raw_str = request.data.decode('latin-1', errors='replace') if request.data else "Vazio"
@@ -1362,7 +1358,7 @@ class AkiraAPI:
         context_hint: str = "",
         tipo_conversa: str = "pv",
         tem_imagem: bool = False,
-        analise_visao: Dict[str, Any] = None,
+        analise_visao: Optional[Dict[str, Any]] = None,
         analise_doc: str = "",
         unified_context = None
     ) -> str:

modules/local_llm.py

@@ -137,7 +137,8 @@ class LocalLLMFallback:
         if cls._instance is None:
             cls._instance = super().__new__(cls)
             cls._instance._initialized = False
-            cls._instance._model_lock = __import__('threading').Lock()
+            import threading as _threading
+            cls._instance._model_lock = _threading.Lock()
         return cls._instance
     
     def __init__(self):
@@ -147,7 +148,10 @@ class LocalLLMFallback:
         
         # Componentes do modelo
         self._model = None  # type: ignore
-        self._model_path = None  # type: ignore
+        self._model_path: Optional[str] = None
+        self._heavy_model: Optional[str] = None
+        self._portuguese_model: Optional[str] = None
+        self._multilingual_beast: Optional[str] = None
         self._is_loaded = False
         self._tokenizer = None # type: ignore
         self._pipeline = None # type: ignore
@@ -165,7 +169,7 @@ class LocalLLMFallback:
         self._hf_client = None
         
         # Estatísticas
-        self._stats = {
+        self._stats: Dict[str, Any] = {
             "total_calls": 0,
             "successful_calls": 0,
             "failed_calls": 0,
@@ -180,7 +184,13 @@ class LocalLLMFallback:
         """Configura o fallback via Cloud API (Hugging Face Inference)."""
         logger.info("Local LLM: Configurando fallback exclusivo via HuggingFace Cloud API.")
         
-        hf_token = os.getenv("HF_TOKEN") or getattr(__import__('modules.config', fromlist=['HF_TOKEN']), 'HF_TOKEN', None)
+        try:
+            import importlib as _iloc
+            _cfgloc = _iloc.import_module('modules.config')
+            _hf_fallback = getattr(_cfgloc, 'HF_TOKEN', None)
+        except Exception:
+            _hf_fallback = None
+        hf_token: Optional[str] = os.getenv("HF_TOKEN") or _hf_fallback
         
         if hf_token:
             self._is_hf_inference_mode = True
@@ -248,7 +258,13 @@ class LocalLLMFallback:
             formatted = f"<|system|>\n{sys_prompt}</s>\n<|user|>\n{prompt}</s>\n<|assistant|>\n"
             
             if getattr(self, '_is_hf_inference_mode', False):
-                hf_token = os.getenv("HF_TOKEN") or getattr(__import__('modules.config', fromlist=['HF_TOKEN']), 'HF_TOKEN', None)
+                try:
+                    import importlib as _il2
+                    _cfg2 = _il2.import_module('modules.config')
+                    _hf2 = getattr(_cfg2, 'HF_TOKEN', None)
+                except Exception:
+                    _hf2 = None
+                hf_token = os.getenv("HF_TOKEN") or _hf2
                 if not hf_token:
                     logger.error("❌ Token HF não encontrado para a requisição de inferência HF")
                     # Tentar prosseguir sem token se for modelo free (geralmente Llama 3 precisa)
@@ -284,22 +300,46 @@ class LocalLLMFallback:
                 candidate_models = []
                 
                 long_prompt = prompt.count('\n') >= 4 or len(prompt) > 800
-                trigger_keywords = [
-                    "analise", "refatore", "complexo", "angola", "explicar", "portugues",
-                    "explique", "resuma", "debate", "científico", "cientifi", "acadêmic", "academi",
-                    "religião", "religi", "polític", "politi", "filosof"
+                prompt_lower = prompt.lower()
+                
+                # Palavras-chave exclusivas para o modelo Pesado (Qwen Abliterated: debates, polêmicas, ciência, etc)
+                heavy_keywords = [
+                    "debate", "discuti", "ideia", "explica", "acadêmica", "religião", "científica", "ciência", "filosófico", "filosofia", 
+                    "ética", "etica", "moral", "radical", "polêmica", "polemica", "país", "analise", "fale sobre", "codigo", "programar",
+                    "política", "politi", "guerra", "mundo"
+                ]
+                # Palavras-chave exclusivas para Luna (Girias, cultura PT/AO/BR, informalidade)
+                luna_keywords = [
+                    "kkk", "mn", "informal", "foda", "lá ele", "puto", "mano", "porra", "fxe", "cassule"
                 ]
                 
-                # Se o prompt ou config indicar necessidade de alta capacidade, tentamos os pesados primeiro
-                prefer_heavy = getattr(__import__('modules.config', fromlist=['PREFER_HEAVY_MODEL']), 'PREFER_HEAVY_MODEL', False)
-                if prefer_heavy or long_prompt or any(x in prompt.lower() for x in trigger_keywords):
-                    candidate_models.extend([self._heavy_model, self._portuguese_model, self._multilingual_beast])
+                needs_heavy = long_prompt or any(x in prompt_lower for x in heavy_keywords)
+                needs_luna = any(x in prompt_lower for x in luna_keywords)
                 
-                candidate_models.append(base_model)
+                # Verifica a flag global de preferência por modelos pesados
+                try:
+                    import importlib as _il3
+                    _cfg3 = _il3.import_module('modules.config')
+                    prefer_heavy: bool = bool(getattr(_cfg3, 'PREFER_HEAVY_MODEL', False))
+                except Exception:
+                    prefer_heavy = False
                 
-                # Garantir que Llama 3.3 70B esteja na lista como fallback final de alta performance
-                if "Llama-3.3-70B" not in str(candidate_models):
-                    candidate_models.append("meta-llama/Llama-3.3-70B-Instruct")
+                if needs_heavy:
+                    # MENSAGEM COMPLEXA/SEM CENSURA/DEBATE: Qwen -> Llama 70B -> Luna -> Lexi
+                    candidate_models.extend([self._heavy_model, "meta-llama/Llama-3.3-70B-Instruct", self._portuguese_model, base_model])
+                elif needs_luna:
+                    # MENSAGEM CULTURAL/GÍRIA EM PT: Luna -> Lexi -> Qwen
+                    candidate_models.extend([self._portuguese_model, base_model, self._heavy_model])
+                else:
+                    # MENSAGEM SIMPLES (TROCA ADAPTATIVA):
+                    if prefer_heavy:
+                        candidate_models.extend([base_model, self._heavy_model, self._portuguese_model])
+                    else:
+                        candidate_models.extend([base_model, self._portuguese_model, self._heavy_model])
+
+                # Garantir apenas modelos únicos mantendo a ordem
+                seen = set()
+                candidate_models = [x for x in candidate_models if not (x in seen or seen.add(x))]
 
                 for current_model in candidate_models:
                     for provider in providers:
@@ -308,16 +348,23 @@ class LocalLLMFallback:
                         current_messages = messages.copy()
                         
                         # Se for modelo Luana ou Mistral, aplicamos o template [INST] conforme a documentação
-                        if "mistral" in current_model.lower() or "luana" in current_model.lower():
+                        _cm = str(current_model) if current_model else ""
+                        if "mistral" in _cm.lower() or "luana" in _cm.lower():
                             # Para Mistral via Chat API, geralmente o provedor já cuida da conversão, 
                             # mas podemos reforçar na primeira mensagem se necessário.
                             # No caso da Luana específica, ela gosta do formato "Abaixo está uma instrução..."
-                            if "luana" in current_model.lower():
+                            if "luana" in _cm.lower():
                                 instruction = f"Abaixo está uma instrução que descreve uma tarefa, juntamente com uma entrada que fornece mais contexto.\nEscreva uma resposta que complete adequadamente o pedido.\n### instrução: {sys_prompt}\n### entrada: {prompt}"
                                 current_messages = [{"role": "user", "content": instruction}]
                         
                         # Extrair parâmetros específicos do modelo injetando agressividade e coerência
-                        model_params = getattr(__import__('modules.config', fromlist=['MODEL_PARAMETERS']), 'MODEL_PARAMETERS', {}).get(current_model, {})
+                        try:
+                            import importlib as _il
+                            _cfg = _il.import_module('modules.config')
+                            _all_params: dict = getattr(_cfg, 'MODEL_PARAMETERS', {})
+                        except Exception:
+                            _all_params = {}
+                        model_params: Dict[str, Any] = dict(_all_params.get(current_model, {}))
                         
                         payload = {
                             "model": model_with_provider,

modules/persona_tracker.py

@@ -86,9 +86,15 @@ Retorne APENAS um JSON válido estruturado assim (e NADA de texto fora das chave
 """
             
             # Chama o LLM (garante formato json)
-            # O AkiraAPI tem o método .generate(prompt, context_history)
-            # Agora retorna (resposta, modelo_usado)
-            response_json_str = self.llm_client.generate(prompt, [])
+            # Agora retorna (resposta, modelo_usado) ou apenas resposta
+            response_raw = self.llm_client.generate(prompt, [])
+            if isinstance(response_raw, tuple):
+                response_json_str = response_raw[0]
+            else:
+                response_json_str = response_raw
+                
+            if not response_json_str:
+                return
             
             # Extrai o JSON (Robusto contra texto extra, markdown e quebras parciais)
             response_clean = response_json_str.strip()

modules/unified_context.py

@@ -185,6 +185,7 @@ class UnifiedMessageContext:
     # Mensagem atual
     current_message: str = ""
     current_emotion: str = "neutral"
+    system_override: str = ""
     
     def to_dict(self) -> Dict[str, Any]:
         """Serializa para dicionário."""
@@ -434,7 +435,7 @@ class ShortTermMemoryManager:
         content: str,
         emocao: str = "neutral",
         reply_info: Optional[Dict] = None,
-        importancia: float = None
+        importancia: Optional[float] = None
     ) -> MessageWithContext:
         """
         Adiciona mensagem à STM de uma conversa.