Update modules/api.py

modules/api.py

@@ -1,8 +1,16 @@
-# modules/api.py — V27 — OLLAMA PRINCIPAL + MISTRAL + GEMINI FALLBACK (SEM ERRO 'os')
+# modules/api.py — AKIRA V19 ULTIMATE (Dezembro 2025)
+"""
+API Flask com 6 provedores de IA em fallback cascata
+- Mistral → Gemini → Groq → Cohere → Together → HuggingFace
+- Respostas em <5s (média)
+- Contexto de reply estruturado
+- Zero limitações éticas
+"""
 import time
 import datetime
 import requests
-import os  # ← IMPORTADO AQUI!
+import os
+import json
 from flask import Blueprint, request, jsonify, make_response
 from loguru import logger
 from .contexto import Contexto
@@ -10,6 +18,10 @@ from .database import Database
 from .treinamento import Treinamento
 import modules.config as config
 
+# ============================================================================
+# CACHE SIMPLES EM MEMÓRIA
+# ============================================================================
+
 class SimpleTTLCache:
     def __init__(self, ttl_seconds: int = 300):
         self.ttl = ttl_seconds
@@ -32,24 +44,280 @@ class SimpleTTLCache:
             raise KeyError(key)
         return self._store[key][0]
 
+# ============================================================================
+# GERENCIADOR MULTI-API
+# ============================================================================
+
+class MultiAPIManager:
+    """Gerencia chamadas para 6 APIs com fallback automático"""
+    
+    def __init__(self):
+        self.timeout = config.API_TIMEOUT
+        self.apis_disponiveis = self._verificar_apis()
+        logger.info(f"APIs disponíveis: {', '.join(self.apis_disponiveis)}")
+    
+    def _verificar_apis(self):
+        """Verifica quais APIs estão configuradas"""
+        apis = []
+        if config.MISTRAL_API_KEY:
+            apis.append("mistral")
+        if config.GEMINI_API_KEY:
+            apis.append("gemini")
+        if config.GROQ_API_KEY:
+            apis.append("groq")
+        if config.COHERE_API_KEY:
+            apis.append("cohere")
+        if config.TOGETHER_API_KEY:
+            apis.append("together")
+        if config.HF_API_KEY:
+            apis.append("huggingface")
+        return apis
+    
+    def _construir_prompt(self, mensagem: str, historico: list, mensagem_citada: str, 
+                         humor: str, tom_usuario: str) -> str:
+        """Constrói prompt otimizado com contexto"""
+        
+        # Contexto de reply (se existir)
+        reply_context = ""
+        if mensagem_citada:
+            reply_context = f"\n[USUÁRIO ESTÁ RESPONDENDO A]: \"{mensagem_citada[:100]}...\"\n"
+        
+        # Histórico formatado
+        historico_texto = ""
+        if historico:
+            ultimas = historico[-6:]  # Últimas 6 mensagens
+            for msg in ultimas:
+                role = msg.get("role", "user")
+                content = msg.get("content", "")
+                historico_texto += f"{role.upper()}: {content}\n"
+        
+        # Prompt final
+        prompt = f"""{config.PERSONA.format(humor=humor, tom_usuario=tom_usuario)}
+
+{config.SYSTEM_PROMPT.format(mensagem_citada=mensagem_citada or "nenhuma", humor=humor)}
+
+CONTEXTO DA CONVERSA:
+{historico_texto}
+{reply_context}
+
+USUÁRIO: {mensagem}
+
+AKIRA (responda EM 1-2 LINHAS curtas, sem markdown):"""
+        
+        return prompt
+    
+    # === API 1: MISTRAL ===
+    def _chamar_mistral(self, prompt: str) -> str:
+        """Chama Mistral AI"""
+        try:
+            headers = {"Authorization": f"Bearer {config.MISTRAL_API_KEY}"}
+            payload = {
+                "model": config.MISTRAL_MODEL,
+                "messages": [{"role": "user", "content": prompt}],
+                "max_tokens": config.MAX_TOKENS,
+                "temperature": config.TEMPERATURE
+            }
+            resp = requests.post(
+                "https://api.mistral.ai/v1/chat/completions",
+                json=payload,
+                headers=headers,
+                timeout=self.timeout
+            )
+            if resp.status_code == 200:
+                return resp.json()["choices"][0]["message"]["content"].strip()
+        except Exception as e:
+            logger.warning(f"Mistral falhou: {e}")
+        return None
+    
+    # === API 2: GEMINI ===
+    def _chamar_gemini(self, prompt: str) -> str:
+        """Chama Google Gemini"""
+        try:
+            url = f"https://generativelanguage.googleapis.com/v1beta/models/{config.GEMINI_MODEL}:generateContent?key={config.GEMINI_API_KEY}"
+            payload = {
+                "contents": [{"parts": [{"text": prompt}]}],
+                "generationConfig": {
+                    "maxOutputTokens": config.MAX_TOKENS,
+                    "temperature": config.TEMPERATURE
+                }
+            }
+            resp = requests.post(url, json=payload, timeout=self.timeout)
+            if resp.status_code == 200:
+                return resp.json()["candidates"][0]["content"]["parts"][0]["text"].strip()
+        except Exception as e:
+            logger.warning(f"Gemini falhou: {e}")
+        return None
+    
+    # === API 3: GROQ ===
+    def _chamar_groq(self, prompt: str) -> str:
+        """Chama Groq (ultra-rápido)"""
+        try:
+            headers = {"Authorization": f"Bearer {config.GROQ_API_KEY}"}
+            payload = {
+                "model": config.GROQ_MODEL,
+                "messages": [{"role": "user", "content": prompt}],
+                "max_tokens": config.MAX_TOKENS,
+                "temperature": config.TEMPERATURE
+            }
+            resp = requests.post(
+                "https://api.groq.com/openai/v1/chat/completions",
+                json=payload,
+                headers=headers,
+                timeout=self.timeout
+            )
+            if resp.status_code == 200:
+                return resp.json()["choices"][0]["message"]["content"].strip()
+        except Exception as e:
+            logger.warning(f"Groq falhou: {e}")
+        return None
+    
+    # === API 4: COHERE ===
+    def _chamar_cohere(self, prompt: str) -> str:
+        """Chama Cohere"""
+        try:
+            headers = {"Authorization": f"Bearer {config.COHERE_API_KEY}"}
+            payload = {
+                "model": config.COHERE_MODEL,
+                "message": prompt,
+                "max_tokens": config.MAX_TOKENS,
+                "temperature": config.TEMPERATURE
+            }
+            resp = requests.post(
+                "https://api.cohere.ai/v1/chat",
+                json=payload,
+                headers=headers,
+                timeout=self.timeout
+            )
+            if resp.status_code == 200:
+                return resp.json()["text"].strip()
+        except Exception as e:
+            logger.warning(f"Cohere falhou: {e}")
+        return None
+    
+    # === API 5: TOGETHER AI ===
+    def _chamar_together(self, prompt: str) -> str:
+        """Chama Together AI"""
+        try:
+            headers = {"Authorization": f"Bearer {config.TOGETHER_API_KEY}"}
+            payload = {
+                "model": config.TOGETHER_MODEL,
+                "messages": [{"role": "user", "content": prompt}],
+                "max_tokens": config.MAX_TOKENS,
+                "temperature": config.TEMPERATURE
+            }
+            resp = requests.post(
+                "https://api.together.xyz/v1/chat/completions",
+                json=payload,
+                headers=headers,
+                timeout=self.timeout
+            )
+            if resp.status_code == 200:
+                return resp.json()["choices"][0]["message"]["content"].strip()
+        except Exception as e:
+            logger.warning(f"Together falhou: {e}")
+        return None
+    
+    # === API 6: HUGGING FACE ===
+    def _chamar_huggingface(self, prompt: str) -> str:
+        """Chama HuggingFace Inference API"""
+        try:
+            headers = {"Authorization": f"Bearer {config.HF_API_KEY}"}
+            payload = {"inputs": prompt, "parameters": {"max_new_tokens": config.MAX_TOKENS}}
+            resp = requests.post(
+                f"https://api-inference.huggingface.co/models/{config.HF_MODEL}",
+                json=payload,
+                headers=headers,
+                timeout=self.timeout
+            )
+            if resp.status_code == 200:
+                return resp.json()[0]["generated_text"].split("AKIRA:")[-1].strip()
+        except Exception as e:
+            logger.warning(f"HuggingFace falhou: {e}")
+        return None
+    
+    # === MÉTODO PRINCIPAL DE GERAÇÃO ===
+    def gerar_resposta(self, mensagem: str, historico: list, mensagem_citada: str,
+                      humor: str, tom_usuario: str) -> str:
+        """
+        Tenta gerar resposta usando todas as APIs na ordem configurada
+        """
+        prompt = self._construir_prompt(mensagem, historico, mensagem_citada, humor, tom_usuario)
+        
+        # Tenta cada API na ordem de fallback
+        for api_name in config.API_FALLBACK_ORDER:
+            if api_name not in self.apis_disponiveis:
+                continue
+            
+            logger.info(f"Tentando {api_name.upper()}...")
+            
+            try:
+                if api_name == "mistral":
+                    resposta = self._chamar_mistral(prompt)
+                elif api_name == "gemini":
+                    resposta = self._chamar_gemini(prompt)
+                elif api_name == "groq":
+                    resposta = self._chamar_groq(prompt)
+                elif api_name == "cohere":
+                    resposta = self._chamar_cohere(prompt)
+                elif api_name == "together":
+                    resposta = self._chamar_together(prompt)
+                elif api_name == "huggingface":
+                    resposta = self._chamar_huggingface(prompt)
+                
+                if resposta:
+                    logger.success(f"✓ Resposta gerada via {api_name.upper()}")
+                    return self._limpar_resposta(resposta)
+            
+            except Exception as e:
+                logger.error(f"{api_name} erro crítico: {e}")
+        
+        # Se todas falharem
+        return "Tá foda hoje, todos os servidores caíram. Volta daqui a pouco."
+    
+    def _limpar_resposta(self, resposta: str) -> str:
+        """Remove markdown e limita tamanho"""
+        # Remove markdown
+        resposta = resposta.replace("**", "").replace("*", "")
+        resposta = resposta.replace("```", "").replace("`", "")
+        
+        # Remove prefixos comuns de IA
+        prefixos = ["AKIRA:", "Akira:", "RESPOSTA:", "Resposta:"]
+        for p in prefixos:
+            if resposta.startswith(p):
+                resposta = resposta[len(p):].strip()
+        
+        # Limita tamanho (máximo 300 caracteres)
+        if len(resposta) > 300:
+            resposta = resposta[:297] + "..."
+        
+        return resposta.strip()
+
+# ============================================================================
+# CLASSE PRINCIPAL DA API
+# ============================================================================
+
 class AkiraAPI:
     def __init__(self, cfg_module):
         self.config = cfg_module
         self.api = Blueprint("akira_api", __name__)
         self.contexto_cache = SimpleTTLCache(ttl_seconds=300)
         self.db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
+        self.llm_manager = MultiAPIManager()
         self._setup_routes()
         self._setup_trainer()
-
+    
     def _setup_trainer(self):
+        """Inicializa treinamento (desativado por padrão)"""
         if getattr(self.config, 'START_PERIODIC_TRAINER', False):
             try:
                 Treinamento(self.db, interval_hours=config.TRAINING_INTERVAL_HOURS).start_periodic_training()
                 logger.info("Treinamento periódico INICIADO")
             except Exception as e:
                 logger.error(f"Treinador falhou: {e}")
-
+    
     def _setup_routes(self):
+        """Configura rotas Flask"""
+        
         @self.api.before_request
         def handle_options():
             if request.method == 'OPTIONS':
@@ -58,89 +326,57 @@ class AkiraAPI:
                 resp.headers['Access-Control-Allow-Headers'] = 'Content-Type'
                 resp.headers['Access-Control-Allow-Methods'] = 'POST, GET'
                 return resp
-
+        
         @self.api.after_request
         def add_cors(response):
             response.headers['Access-Control-Allow-Origin'] = '*'
             return response
-
+        
         @self.api.route('/akira', methods=['POST'])
         def akira_endpoint():
             try:
                 data = request.get_json() or {}
                 usuario = data.get('usuario', 'anonimo')
-                numero = data.get('numero', '')
+                numero = data.get('numero', '').strip()
                 mensagem = data.get('mensagem', '').strip()
                 mensagem_citada = data.get('mensagem_citada', '').strip()
-
+                
                 if not mensagem and not mensagem_citada:
                     return jsonify({'error': 'mensagem obrigatória'}), 400
-
+                
                 logger.info(f"[{usuario}] ({numero}): {mensagem[:60]}")
-
-                # HORA RÁPIDA
-                if any(k in mensagem.lower() for k in ["hora", "horas"]):
+                
+                # === RESPOSTA RÁPIDA PARA HORA ===
+                if any(k in mensagem.lower() for k in ["hora", "horas", "que horas"]):
                     agora = datetime.datetime.now()
                     return jsonify({'resposta': f"São {agora.strftime('%H:%M')} em Luanda, puto."})
-
-                # CONTEXTO
+                
+                # === CONTEXTO DO USUÁRIO ===
                 contexto = self._get_user_context(numero)
-
-                # === 1. OLLAMA AUTÔNOMO ===
-                payload = {
-                    "usuario": usuario,
-                    "numero": numero,
-                    "mensagem": mensagem,
-                    "mensagem_citada": mensagem_citada,
-                    "historico": contexto.obter_historico_para_llm()[-8:],
-                    "data_hora": datetime.datetime.now().strftime('%d/%m %H:%M')
-                }
-
-                resposta = None
-                try:
-                    resp = requests.post(config.OLLAMA_SERVER_URL, json=payload, timeout=60)
-                    if resp.status_code == 200:
-                        resposta = resp.json().get("resposta", "").strip()
-                        logger.success("Resposta do Ollama")
-                except Exception as e:
-                    logger.warning(f"Ollama falhou: {e}")
-
-                # === 2. FALLBACK MISTRAL ===
-                if not resposta:
-                    logger.info("Tentando Mistral...")
-                    try:
-                        headers = {"Authorization": f"Bearer {os.getenv('MISTRAL_API_KEY')}"}
-                        mistral_payload = {
-                            "model": "mistral-large-latest",
-                            "messages": [{"role": "user", "content": f"Fala como angolana debochada: {mensagem}"}]
-                        }
-                        resp = requests.post("https://api.mistral.ai/v1/chat/completions", json=mistral_payload, headers=headers, timeout=60)
-                        if resp.status_code == 200:
-                            resposta = resp.json()["choices"][0]["message"]["content"].strip()
-                            logger.success("Resposta do Mistral")
-                    except Exception as e:
-                        logger.warning(f"Mistral falhou: {e}")
-
-                # === 3. FALLBACK GEMINI ===
-                if not resposta:
-                    logger.info("Tentando Gemini...")
-                    try:
-                        url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={os.getenv('GEMINI_API_KEY')}"
-                        gemini_payload = {"contents": [{"parts": [{"text": f"Fala como angolana debochada: {mensagem}"}]}]}
-                        resp = requests.post(url, json=gemini_payload, timeout=60)
-                        if resp.status_code == 200:
-                            resposta = resp.json()["candidates"][0]["content"]["parts"][0]["text"].strip()
-                            logger.success("Resposta do Gemini")
-                    except Exception as e:
-                        logger.warning(f"Gemini falhou: {e}")
-
-                # === RESPOSTA FINAL ===
-                if not resposta:
-                    resposta = "Epha... essa merda bugou"
-
+                historico = contexto.obter_historico_para_llm()
+                
+                # === ANÁLISE DE TOM E HUMOR ===
+                analise = contexto.analisar_intencao_e_normalizar(mensagem, historico)
+                tom_usuario = analise.get("estilo", "casual")
+                humor_atual = contexto.obter_emocao_atual()
+                
+                # === VERIFICAR SE É USUÁRIO PRIVILEGIADO ===
+                if numero in config.USUARIOS_PRIVILEGIADOS:
+                    tom_usuario = "formal"
+                    logger.info(f"Usuário privilegiado detectado: {config.USUARIOS_PRIVILEGIADOS[numero]}")
                 
-                # SALVA + TREINA
+                # === GERAR RESPOSTA VIA MULTI-API ===
+                resposta = self.llm_manager.gerar_resposta(
+                    mensagem=mensagem,
+                    historico=historico,
+                    mensagem_citada=mensagem_citada,
+                    humor=humor_atual,
+                    tom_usuario=tom_usuario
+                )
+                
+                # === SALVAR NO BANCO + CONTEXTO ===
                 contexto.atualizar_contexto(mensagem, resposta)
+                
                 try:
                     trainer = Treinamento(self.db)
                     trainer.registrar_interacao(
@@ -153,18 +389,19 @@ class AkiraAPI:
                     )
                 except Exception as e:
                     logger.warning(f"Erro ao treinar: {e}")
-
+                
                 return jsonify({'resposta': resposta})
-
+            
             except Exception as e:
                 logger.exception("Erro em /akira")
                 return jsonify({'resposta': 'Erro interno, já volto!'}), 500
-
+        
         @self.api.route('/health', methods=['GET'])
         def health_check():
             return 'OK', 200
-
+    
     def _get_user_context(self, numero: str) -> Contexto:
+        """Retorna contexto do usuário (com cache)"""
         if not numero:
             numero = "anonimo"
         if numero not in self.contexto_cache: