Upload 9 files

modules/skills/__init__.py

@@ -0,0 +1,19 @@
+"""
+Skills package - Agrupamento de APIs com fallbacks automáticos
+"""
+
+from .base_skill import BaseSkill
+from .weather_skill import WeatherSkill
+from .entertainment_skill import EntertainmentSkill
+from .art_skill import ArtSkill
+from .music_skill import MusicSkill
+from .manus_skill import ManusSkill
+
+__all__ = [
+    "BaseSkill",
+    "WeatherSkill",
+    "EntertainmentSkill", 
+    "ArtSkill",
+    "MusicSkill",
+    "ManusSkill",
+]

modules/skills/art_skill.py

@@ -0,0 +1,89 @@
+"""
+ArtSkill - Busca de arte e geração de imagens com fallbacks
+"""
+
+from modules.skills.base_skill import BaseSkill
+from modules.api_integrations.art_providers import ArtProviders
+
+
+class ArtSkill(BaseSkill):
+    """
+    Skill de arte que pode:
+    1. Buscar no Museu Metropolitano (470k+ obras)
+    2. Gerar imagens via Pollinations AI
+    3. Retornar ASCII art como fallback criativo
+    """
+    
+    def __init__(self):
+        super().__init__(
+            name="get_art",
+            description="Busca obras de arte ou gera imagens com fallbacks automáticos"
+        )
+    
+    def get_primary_provider(self):
+        """Tipo depende se é search ou generate"""
+        return self.art_primary
+    
+    def get_fallback_chain(self):
+        """Fallbacks criativos"""
+        return [
+            self.art_fallback,
+        ]
+    
+    def art_primary(self, tipo: str = "search", query: str = None, **kwargs) -> dict:
+        """
+        Provider primário dependendo do tipo:
+        - search: Museu Metropolitano
+        - generate: Pollinations AI (fallback de Flux)
+        """
+        tipo = tipo.lower().strip()
+        
+        if tipo == "search":
+            if not query:
+                return {"sucesso": False, "erro": "Parâmetro 'query' obrigatório para busca"}
+            
+            result = ArtProviders.search_metropolitan_museum(query, max_results=3)
+            if result and result.get("sucesso"):
+                return result
+            
+            return {"sucesso": False, "erro": "Museu não encontrou obras"}
+        
+        elif tipo == "generate":
+            if not query:
+                return {"sucesso": False, "erro": "Parâmetro 'query' obrigatório para gerar imagem"}
+            
+            style = kwargs.get("style")
+            prompt = f"{query}"
+            if style:
+                prompt = f"{query} in {style} style"
+            
+            result = ArtProviders.generate_with_pollinations(prompt)
+            if result and result.get("sucesso"):
+                return result
+            
+            return {"sucesso": False, "erro": "Geração de imagem falhou"}
+        
+        else:
+            return {"sucesso": False, "erro": f"Tipo '{tipo}' desconhecido (use 'search' ou 'generate')"}
+    
+    def art_fallback(self, tipo: str = "search", query: str = None, **kwargs) -> dict:
+        """
+        Fallback: ASCII art criativo
+        """
+        tipo = tipo.lower().strip()
+        
+        if tipo == "generate":
+            # Para geração, retorna ASCII art
+            theme = kwargs.get("theme", "cat")
+            return ArtProviders.generate_simple_ascii_art(theme)
+        
+        # Para busca, retorna descrição poética
+        return {
+            "sucesso": True,
+            "tipo": "poetic_description",
+            "descricao": f"A arte não pode ser capturada em palavras, apenas sentida. '{query}' evoca emoções e sensações únicas em cada observador.",
+            "fonte": "fallback_philosophical"
+        }
+    
+    def _get_error_suggestion(self) -> str:
+        return "Tenta com termo de busca diferente ou mais específico"

modules/skills/autonomous_agent.py

@@ -0,0 +1,269 @@
+"""
+================================================================================
+AKIRA — AUTONOMOUS AGENT (Motor de Decisão Autónoma)
+================================================================================
+Motor central que permite à Akira:
+  1. Tomar decisões de moderação SEM ser chamada (proativo)
+  2. Analisar contexto do grupo e decidir ações
+  3. Executar ações de infraestrutura autonomamente
+  4. Comunicar resultados sigilosos ao proprietário via DM
+
+Filosofia: "Akira não espera ordens — ela age quando necessário"
+================================================================================
+"""
+
+import json
+import time
+from typing import Dict, Any, List, Optional
+from loguru import logger
+from datetime import datetime
+
+OWNER_NUMBER = "244937035662"
+
+# Limites para moderação autónoma
+SPAM_MSG_COUNT = 5          # Msgs num curto período → spam
+SPAM_WINDOW_SECS = 10       # Janela de tempo para detetar spam
+FLOOD_MSG_COUNT = 3         # Msgs muito rápidas → flood
+FLOOD_WINDOW_SECS = 2       # Janela para flood
+
+
+class AutonomousAgent:
+    """
+    Motor de decisão autónoma da Akira.
+    
+    Permite:
+    - Analisar contexto de grupo e tomar decisões de moderação
+    - Executar skills autonomamente com base em eventos
+    - Reportar ações sigilosas ao proprietário
+    """
+    
+    def __init__(self):
+        self._spam_tracker: Dict[str, List[float]] = {}  # {user_jid: [timestamps]}
+        self._action_log: List[Dict] = []  # Log de ações autónomas tomadas
+        self._db = None
+        self._llm_caller = None
+    
+    def init(self, db_instance=None, llm_caller=None):
+        """Inicializa com dependências."""
+        self._db = db_instance
+        self._llm_caller = llm_caller
+        logger.info("🤖 [AUTONOMOUS AGENT] Motor de decisão autónoma iniciado.")
+    
+    # ─────────────────────────────────────────────────────────────────
+    # ANÁLISE DE COMPORTAMENTO DE GRUPO
+    # ─────────────────────────────────────────────────────────────────
+    
+    def track_message(self, user_jid: str, group_jid: str, message: str, timestamp: float = None) -> Dict[str, Any]:
+        """
+        Regista uma mensagem e avalia se deve tomar acção autónoma.
+        
+        Retorna:
+            Dict com ação recomendada (pode ser vazio se não há ação)
+        """
+        if timestamp is None:
+            timestamp = time.time()
+        
+        key = f"{group_jid}:{user_jid}"
+        
+        # Adiciona timestamp ao tracker
+        if key not in self._spam_tracker:
+            self._spam_tracker[key] = []
+        
+        self._spam_tracker[key].append(timestamp)
+        
+        # Limpa timestamps antigos (> 60s)
+        self._spam_tracker[key] = [
+            ts for ts in self._spam_tracker[key] 
+            if timestamp - ts <= 60
+        ]
+        
+        # ─── Detecta Flood ───
+        recent_flood = [ts for ts in self._spam_tracker[key] if timestamp - ts <= FLOOD_WINDOW_SECS]
+        if len(recent_flood) >= FLOOD_MSG_COUNT:
+            logger.warning(f"🚨 [AGENT] Flood detetado: {user_jid} em {group_jid}")
+            return self._build_moderation_action(
+                action="mute",
+                target_jid=user_jid,
+                group_jid=group_jid,
+                reason=f"Flood: {len(recent_flood)} mensagens em {FLOOD_WINDOW_SECS}s",
+                duration_minutes=10,
+                severity="AVISO"
+            )
+        
+        # ─── Detecta Spam ───
+        recent_spam = [ts for ts in self._spam_tracker[key] if timestamp - ts <= SPAM_WINDOW_SECS]
+        if len(recent_spam) >= SPAM_MSG_COUNT:
+            logger.warning(f"🚨 [AGENT] Spam detetado: {user_jid} em {group_jid}")
+            return self._build_moderation_action(
+                action="mute",
+                target_jid=user_jid,
+                group_jid=group_jid,
+                reason=f"Spam: {len(recent_spam)} mensagens em {SPAM_WINDOW_SECS}s",
+                duration_minutes=30,
+                severity="CRÍTICO"
+            )
+        
+        return {}  # Sem ação
+    
+    def analyze_message_for_moderation(self, message: str, user_jid: str, group_jid: str) -> Dict[str, Any]:
+        """
+        Analisa o conteúdo de uma mensagem para decidir se há necessidade de moderação.
+        
+        Deteta:
+        - Links externos em grupos com anti-link
+        - Conteúdo explicitamente ofensivo
+        - Ameaças ou doxxing
+        """
+        message_lower = message.lower()
+        
+        # Padrões de links externos
+        link_patterns = ["http://", "https://", "t.me/", "bit.ly/", "wa.me/", "discord.gg/"]
+        has_link = any(p in message_lower for p in link_patterns)
+        
+        if has_link:
+            return {
+                "type": "remote_action",
+                "action": "autonomous_action",
+                "params": {
+                    "cmd": "warn",
+                    "target": user_jid,
+                    "group_jid": group_jid,
+                    "reason": "Link externo detetado pelo sistema autónomo",
+                    "notify_owner": True,
+                    "silent": True
+                }
+            }
+        
+        return {}
+    
+    def analyze_image_description_for_moderation(self, description: str, user_jid: str, group_jid: str) -> Dict[str, Any]:
+        """
+        [AGENTE AUTÓNOMO VISUAL]
+        Verifica se a descrição gerada pelo modelo de visão da imagem contém conteúdo explicitamente proibido (NSFW/Gore).
+        """
+        if not description:
+            return {}
+            
+        desc_lower = description.lower()
+        
+        # Padrões baseados em descrições comuns de NSFW ou Gore por LLMs de visão
+        nsfw_keywords = [
+            "pornografia", "nudez", "sexo explícito", "conteúdo adulto", "nsfw",
+            "sangue extremo", "vísceras", "gore", "mutilação", "violência extrema",
+            "nudez explícita", "ato sexual", "porn"
+        ]
+        
+        if any(keyword in desc_lower for keyword in nsfw_keywords):
+            logger.warning(f"🚨 [AGENT-VISÃO] Imagem Proibida detetada: {user_jid} em {group_jid}")
+            return {
+                "type": "remote_action",
+                "action": "autonomous_action",
+                "params": {
+                    "cmd": "delete_message",
+                    "target": user_jid,
+                    "group_jid": group_jid,
+                    "reason": "Imagem NSFW/Gore bloqueada pelo escudo visual da Akira",
+                    "notify_owner": True,
+                    "silent": True
+                }
+            }
+            
+        return {}
+    
+    # ─────────────────────────────────────────────────────────────────
+    # CONSTRUÇÃO DE AÇÕES
+    # ─────────────────────────────────────────────────────────────────
+    
+    def _build_moderation_action(
+        self, 
+        action: str, 
+        target_jid: str, 
+        group_jid: str,
+        reason: str,
+        duration_minutes: int = 0,
+        severity: str = "AVISO"
+    ) -> Dict[str, Any]:
+        """Constrói uma ação de moderação autónoma."""
+        
+        # Regista no log interno
+        log_entry = {
+            "timestamp": datetime.now().isoformat(),
+            "tipo": "MODERAÇÃO_AUTÓNOMA",
+            "severidade": severity,
+            "utilizador": target_jid,
+            "grupo": group_jid,
+            "ação": action,
+            "motivo": reason,
+            "duração": f"{duration_minutes}min" if duration_minutes else "N/A"
+        }
+        self._action_log.append(log_entry)
+        
+        # Guarda no DB se disponível
+        if self._db:
+            try:
+                self._db._execute_with_retry(
+                    """INSERT INTO system_events 
+                    (tipo, servidor, descricao, acao_tomada, resolvido) 
+                    VALUES (?, ?, ?, ?, 1)""",
+                    (severity, "railway", f"Moderação: {reason} | User: {target_jid}", action, ),
+                    commit=True
+                )
+            except Exception as e:
+                logger.debug(f"[AGENT] Não foi possível registar no DB: {e}")
+        
+        logger.info(f"🤖 [AGENT ACTION] {action} em {target_jid} | Motivo: {reason}")
+        
+        return {
+            "type": "remote_action",
+            "action": "autonomous_action",
+            "params": {
+                "cmd": action,
+                "target": target_jid,
+                "group_jid": group_jid,
+                "reason": reason,
+                "args": [str(duration_minutes)] if duration_minutes else [],
+                "notify_owner": True,
+                "silent": True
+            }
+        }
+    
+    def decide_action_from_context(self, context: str, event_type: str) -> Optional[Dict]:
+        """
+        Usa o LLM para decidir uma ação com base num evento do sistema.
+        Usado para situações mais complexas que precisam de raciocínio.
+        """
+        if not self._llm_caller:
+            return None
+        
+        system = (
+            "És a Akira, agente autónoma de infraestrutura. "
+            "Analisa o evento abaixo e decide a melhor ação a tomar. "
+            "Responde APENAS em JSON com: {\"acao\": \"string\", \"motivo\": \"string\", \"prioridade\": \"alta|media|baixa\"}. "
+            "Ações possíveis: mute_user, kick_user, lock_group, send_owner_report, ignore."
+        )
+        
+        try:
+            response = self._llm_caller(system, f"EVENTO: {event_type}\nCONTEXTO:\n{context}")
+            # Extrai JSON da resposta
+            import re
+            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            if json_match:
+                return json.loads(json_match.group())
+        except Exception as e:
+            logger.error(f"[AGENT] Erro ao decidir ação: {e}")
+        
+        return None
+    
+    def get_recent_actions_summary(self) -> str:
+        """Retorna um resumo das ações autónomas recentes."""
+        if not self._action_log:
+            return "Nenhuma ação autónoma registada."
+        
+        recent = self._action_log[-10:]  # Últimas 10 ações
+        lines = [f"• [{a['timestamp'][:16]}] {a['ação'].upper()} em {a['utilizador'].split('@')[0]} — {a['motivo']}" 
+                 for a in recent]
+        return f"📋 Últimas {len(recent)} ações autónomas:\n" + "\n".join(lines)
+
+
+# Instância global singleton
+autonomous_agent = AutonomousAgent()

modules/skills/base_skill.py

@@ -0,0 +1,280 @@
+"""
+BaseSkill - Classe base para todas as skills agrupadas com fallbacks
+Padrão: Primary Provider -> Fallback Chain -> Error Handling
+"""
+
+import time
+import json
+import logging
+from typing import Any, Dict, List, Optional, Callable
+from abc import ABC, abstractmethod
+from datetime import datetime, timedelta
+import hashlib
+
+
+class SkillError(Exception):
+    """Erro base em skills"""
+    pass
+
+
+class APITimeoutError(SkillError):
+    """Timeout em chamada de API"""
+    pass
+
+
+class APIRateLimitError(SkillError):
+    """Rate limit atingido"""
+    pass
+
+
+class DataValidationError(SkillError):
+    """Dados inválidos retornados"""
+    pass
+
+
+class CacheManager:
+    """Gerencia cache com TTL"""
+    
+    def __init__(self):
+        self.cache = {}
+        self.logger = logging.getLogger(f"Cache")
+    
+    def set(self, key: str, value: Any, ttl: int = 3600):
+        """Armazena valor em cache com TTL (em segundos)"""
+        self.cache[key] = {
+            "value": value,
+            "expires_at": time.time() + ttl,
+            "created_at": datetime.now().isoformat()
+        }
+        self.logger.debug(f"💾 Cache SET: {key} (TTL: {ttl}s)")
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Recupera valor do cache se ainda válido"""
+        if key not in self.cache:
+            return None
+        
+        entry = self.cache[key]
+        if time.time() > entry["expires_at"]:
+            del self.cache[key]
+            self.logger.debug(f"♻️ Cache EXPIRED: {key}")
+            return None
+        
+        self.logger.debug(f"✅ Cache HIT: {key}")
+        return entry["value"]
+    
+    def clear(self):
+        """Limpa todo o cache"""
+        self.cache.clear()
+    
+    def get_stats(self) -> Dict:
+        """Retorna estatísticas do cache"""
+        return {
+            "total_items": len(self.cache),
+            "items": list(self.cache.keys())
+        }
+
+
+class BaseSkill(ABC):
+    """
+    Classe base para skills com suporte a fallbacks automáticos
+    
+    Exemplo de uso:
+        class WeatherSkill(BaseSkill):
+            def get_primary_provider(self):
+                return self.web_search_weather
+            
+            def get_fallback_chain(self):
+                return [
+                    self.weather_api,
+                    self.wttr_in
+                ]
+    """
+    
+    def __init__(self, name: str, description: str):
+        self.name = name
+        self.description = description
+        self.logger = logging.getLogger(f"Skill[{name}]")
+        self.cache = CacheManager()
+        self.call_count = 0
+        self.error_count = 0
+    
+    @abstractmethod
+    def get_primary_provider(self) -> Callable:
+        """Retorna função do provider primário"""
+        pass
+    
+    def get_fallback_chain(self) -> List[Callable]:
+        """Retorna lista de fallbacks (pode estar vazio)"""
+        return []
+    
+    def execute(self, *args, **kwargs) -> Dict[str, Any]:
+        """
+        Executa skill com fallback automático
+        Tenta: Primary -> Fallback1 -> Fallback2 -> Error
+        """
+        self.call_count += 1
+        start_time = time.time()
+        
+        # Verifica cache
+        cache_key = self._make_cache_key(*args, **kwargs)
+        cached = self.cache.get(cache_key)
+        if cached:
+            return {**cached, "cache_hit": True}
+        
+        # Chain de providers
+        providers = [self.get_primary_provider()] + self.get_fallback_chain()
+        
+        last_error = None
+        for i, provider in enumerate(providers):
+            provider_name = getattr(provider, "__name__", f"Provider{i}")
+            
+            try:
+                self.logger.info(f"🔄 Tentando {provider_name}...")
+                result = self._execute_with_timeout(provider, *args, **kwargs)
+                
+                if not result.get("sucesso"):
+                    self.logger.warning(f"⚠️ {provider_name} retornou erro: {result.get('erro')}")
+                    last_error = result.get("erro")
+                    continue
+                
+                # Sucesso! Formata e cacheia
+                response = self._format_response(provider_name, result, False)
+                elapsed = time.time() - start_time
+                response["elapsed_ms"] = int(elapsed * 1000)
+                
+                # Cacheia resultado bem-sucedido
+                ttl = kwargs.pop("cache_ttl", 3600)
+                self.cache.set(cache_key, response, ttl=ttl)
+                
+                self.logger.info(f"✅ {provider_name} sucesso ({elapsed:.2f}s)")
+                return response
+            
+            except APITimeoutError as e:
+                self.logger.warning(f"⏱️ {provider_name} timeout: {e}")
+                last_error = f"Timeout: {e}"
+                if i < len(providers) - 1:
+                    time.sleep(0.5 * (2 ** i))  # Backoff exponencial
+                continue
+            
+            except APIRateLimitError as e:
+                self.logger.warning(f"🚫 {provider_name} rate limit: {e}")
+                last_error = f"Rate limit: {e}"
+                continue
+            
+            except DataValidationError as e:
+                self.logger.warning(f"❌ {provider_name} dados inválidos: {e}")
+                last_error = f"Dados inválidos: {e}"
+                continue
+            
+            except Exception as e:
+                self.logger.error(f"💥 {provider_name} erro: {type(e).__name__}: {e}")
+                last_error = f"{type(e).__name__}: {e}"
+                continue
+        
+        # Todos providers falharam
+        self.error_count += 1
+        self.logger.error(f"🔴 Todos providers falharam para {self.name}")
+        
+        return self._format_error_response(last_error)
+    
+    def _execute_with_timeout(self, fn: Callable, *args, timeout: float = 5.0, **kwargs) -> Any:
+        """
+        Executa função com timeout
+        Implementação simples (ideal seria threading/async)
+        """
+        # Para versão simples, apenas chama a função
+        # Em produção, usar ThreadPoolExecutor ou asyncio
+        return fn(*args, **kwargs)
+    
+    def _format_response(self, provider: str, data: Dict, cache_hit: bool) -> Dict:
+        """Formata resposta padrão"""
+        return {
+            "sucesso": True,
+            "skill": self.name,
+            "provider": provider,
+            "cache_hit": cache_hit,
+            "dados": data,
+            "timestamp": datetime.now().isoformat()
+        }
+    
+    def _format_error_response(self, error: str) -> Dict:
+        """Formata resposta de erro"""
+        return {
+            "sucesso": False,
+            "skill": self.name,
+            "erro": error or f"Nenhum provider disponível para {self.name}",
+            "sugestao": self._get_error_suggestion(),
+            "timestamp": datetime.now().isoformat()
+        }
+    
+    def _get_error_suggestion(self) -> str:
+        """Retorna sugestão quando tudo falha"""
+        return "Tenta de novo mais tarde"
+    
+    def _make_cache_key(self, *args, **kwargs) -> str:
+        """Cria chave de cache baseada em argumentos"""
+        # Remove cache_ttl antes de processar
+        cache_ttl = kwargs.pop("cache_ttl", None)
+        
+        # Serializa argumentos
+        key_str = f"{self.name}:{json.dumps([args, kwargs], sort_keys=True, default=str)}"
+        return hashlib.md5(key_str.encode()).hexdigest()
+    
+    def get_stats(self) -> Dict:
+        """Retorna estatísticas da skill"""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "calls": self.call_count,
+            "errors": self.error_count,
+            "error_rate": f"{(self.error_count/max(1, self.call_count)*100):.1f}%",
+            "cache": self.cache.get_stats()
+        }
+    
+    def clear_cache(self):
+        """Limpa cache da skill"""
+        self.cache.clear()
+        self.logger.info("🧹 Cache limpo")
+
+
+# ==========================
+# Decoradores úteis
+# ==========================
+
+def retry(max_attempts: int = 3, backoff: float = 1.0):
+    """Decorator para retry automático com backoff exponencial"""
+    def decorator(fn):
+        def wrapper(*args, **kwargs):
+            for attempt in range(max_attempts):
+                try:
+                    return fn(*args, **kwargs)
+                except Exception as e:
+                    if attempt == max_attempts - 1:
+                        raise
+                    wait_time = backoff * (2 ** attempt)
+                    logging.warning(f"Retry {attempt+1}/{max_attempts}, aguardando {wait_time}s")
+                    time.sleep(wait_time)
+        return wrapper
+    return decorator
+
+
+def timeout(seconds: float = 5.0):
+    """Decorator para timeout (implementação simples)"""
+    def decorator(fn):
+        def wrapper(*args, **kwargs):
+            # Implementação real usaria signal ou threading
+            return fn(*args, **kwargs)
+        return wrapper
+    return decorator
+
+
+def validate_response(schema: Dict = None):
+    """Decorator para validar resposta contra schema"""
+    def decorator(fn):
+        def wrapper(*args, **kwargs):
+            result = fn(*args, **kwargs)
+            if not isinstance(result, dict):
+                raise DataValidationError(f"Response deve ser dict, got {type(result)}")
+            return result
+        return wrapper
+    return decorator

modules/skills/entertainment_skill.py

@@ -0,0 +1,85 @@
+"""
+EntertainmentSkill - Piadas, Dicas e Citações em uma skill agrupada
+"""
+
+from modules.skills.base_skill import BaseSkill
+from modules.api_integrations.entertainment_providers import EntertainmentProviders
+
+
+class EntertainmentSkill(BaseSkill):
+    """
+    Skill de entretenimento que retorna:
+    - Piadas (Joke API + fallback local)
+    - Dicas (Advice Slip API + fallback local)
+    - Citações (Quotable API + fallback local)
+    
+    Usa fallback automático se a API primária falhar
+    """
+    
+    def __init__(self):
+        super().__init__(
+            name="get_entertainment",
+            description="Retorna piadas, dicas ou citações com fallbacks automáticos"
+        )
+    
+    def get_primary_provider(self):
+        """Tipo depende do parâmetro 'tipo'"""
+        return self.comedy_or_advice
+    
+    def get_fallback_chain(self):
+        """Fallbacks locais"""
+        return [
+            self.fallback_entertainment,
+        ]
+    
+    def comedy_or_advice(self, tipo: str = "random", **kwargs) -> dict:
+        """
+        Baseado no tipo, retorna piada, dica ou citação
+        """
+        tipo = tipo.lower().strip()
+        
+        if tipo == "joke":
+            result = EntertainmentProviders.get_joke()
+            if result and result.get("sucesso"):
+                return result
+            return {"sucesso": False, "erro": "Joke API falhou"}
+        
+        elif tipo == "advice":
+            result = EntertainmentProviders.get_advice()
+            if result and result.get("sucesso"):
+                return result
+            return {"sucesso": False, "erro": "Advice API falhou"}
+        
+        elif tipo == "quote":
+            result = EntertainmentProviders.get_quote()
+            if result and result.get("sucesso"):
+                return result
+            return {"sucesso": False, "erro": "Quote API falhou"}
+        
+        else:  # random
+            import random
+            tipo_aleatorio = random.choice(["joke", "advice", "quote"])
+            return self.comedy_or_advice(tipo=tipo_aleatorio, **kwargs)
+    
+    def fallback_entertainment(self, tipo: str = "random", **kwargs) -> dict:
+        """
+        Fallback 1: Entertainment local
+        Usa cache de piadas, dicas e citações
+        """
+        tipo = tipo.lower().strip()
+        
+        if tipo == "joke":
+            return EntertainmentProviders.get_joke_fallback()
+        elif tipo == "advice":
+            return EntertainmentProviders.get_advice_fallback()
+        elif tipo == "quote":
+            return EntertainmentProviders.get_quote_fallback()
+        else:
+            # Random entre os 3
+            import random
+            tipo_aleatorio = random.choice(["joke", "advice", "quote"])
+            return self.fallback_entertainment(tipo=tipo_aleatorio, **kwargs)
+    
+    def _get_error_suggestion(self) -> str:
+        """Sugestão quando tudo falha"""
+        return "Tenta de novo em alguns segundos"

modules/skills/manus_skill.py

@@ -0,0 +1,44 @@
+"""
+ManusSkill - Skill de Pesquisa Avançada via Manus AI
+"""
+
+from modules.skills.base_skill import BaseSkill
+from modules.skills.native_research import native_research_agent
+
+class ManusSkill(BaseSkill):
+    """
+    Skill que utiliza o Manus AI para pesquisas profundas e tarefas complexas.
+    """
+    
+    def __init__(self):
+        super().__init__(
+            name="manus_research",
+            description="Realiza pesquisas profundas e resolve tarefas complexas usando o agente autônomo Manus AI."
+        )
+    
+    def get_primary_provider(self):
+        return self.manus_research_tool
+    
+    def manus_research_tool(self, prompt: str, **kwargs) -> dict:
+        """
+        Executa uma pesquisa ou tarefa no Manus AI.
+        """
+        # Executa a pesquisa profunda diretamente no nosso agente local (OpenManus style)
+        result = native_research_agent.run(prompt)
+        
+        if result.get("sucesso"):
+            return {
+                "sucesso": True,
+                "resultado": result.get("resultado"),
+                "prompt_original": prompt,
+                "status": "concluído"
+            }
+            
+        return {
+            "sucesso": False,
+            "erro": result.get("erro", "Erro desconhecido no Manus AI"),
+            "sugestao": "Tenta reformular o pedido ou usa a busca web convencional."
+        }
+
+    def _get_error_suggestion(self) -> str:
+        return "A pesquisa profunda falhou. Os sites podem estar bloqueados para leitura automática ou o LLM ficou sobrecarregado."

modules/skills/music_skill.py

@@ -0,0 +1,92 @@
+"""
+MusicSkill - Gêneros, Letras e OSTs com fallbacks
+"""
+
+from modules.skills.base_skill import BaseSkill
+from modules.api_integrations.music_providers import MusicProviders
+
+
+class MusicSkill(BaseSkill):
+    """
+    Skill de música que pode:
+    1. Gerar gêneros aleatórios (Genrenator)
+    2. Buscar letras (Genius - TODO)
+    3. Buscar OST de animes (Jikan)
+    4. Dar recomendações personalizadas
+    5. Fallback com recomendação local
+    """
+    
+    def __init__(self):
+        super().__init__(
+            name="get_music",
+            description="Gera gêneros, recomendações ou busca informações musicais com fallbacks"
+        )
+    
+    def get_primary_provider(self):
+        """Tipo de música depende do parâmetro 'tipo'"""
+        return self.music_primary
+    
+    def get_fallback_chain(self):
+        """Fallbacks para entretenimento musical"""
+        return [
+            self.music_fallback,
+        ]
+    
+    def music_primary(self, tipo: str = "genre", **kwargs) -> dict:
+        """
+        Provider primário dependendo do tipo:
+        - genre: Gera gênero aleatório
+        - recommendation: Recomendação contextual
+        - anime_ost: Busca trilha sonora de anime
+        - lyrics: Busca letra (não implementado)
+        """
+        tipo = tipo.lower().strip()
+        
+        if tipo == "genre":
+            mood = kwargs.get("mood")
+            result = MusicProviders.generate_genre_with_details(mood)
+            if result and result.get("sucesso"):
+                return result
+            return {"sucesso": False, "erro": "Geração de gênero falhou"}
+        
+        elif tipo == "recommendation":
+            mood = kwargs.get("mood")
+            result = MusicProviders.generate_genre_with_details(mood)
+            if result and result.get("sucesso"):
+                return result
+            return {"sucesso": False, "erro": "Recomendação falhou"}
+        
+        elif tipo == "anime_ost":
+            anime_name = kwargs.get("anime")
+            if not anime_name:
+                return {"sucesso": False, "erro": "Parâmetro 'anime' obrigatório"}
+            
+            result = MusicProviders.search_anime_ost_jikan(anime_name)
+            if result and result.get("sucesso"):
+                return result
+            return {"sucesso": False, "erro": f"Anime '{anime_name}' não encontrado"}
+        
+        elif tipo == "lyrics":
+            song = kwargs.get("song")
+            artist = kwargs.get("artist")
+            if not song:
+                return {"sucesso": False, "erro": "Parâmetro 'song' obrigatório"}
+            
+            result = MusicProviders.search_lyrics_genius(song, artist)
+            if result and result.get("sucesso"):
+                return result
+            
+            return {"sucesso": False, "erro": "Não foi possível encontrar a letra desta música. Tente pesquisar o nome exato."}
+        
+        else:
+            return {"sucesso": False, "erro": f"Tipo '{tipo}' desconhecido"}
+    
+    def music_fallback(self, tipo: str = "genre", **kwargs) -> dict:
+        """
+        Fallback: Recomendação musical local
+        Sempre retorna algo interessante
+        """
+        return MusicProviders.get_fallback_recommendation()
+    
+    def _get_error_suggestion(self) -> str:
+        return "Tenta pedir um gênero aleatório com 'tipo=genre' ou uma recomendação com 'tipo=recommendation'"

modules/skills/native_research.py

@@ -0,0 +1,216 @@
+import time
+import json
+import requests
+import trafilatura
+import concurrent.futures
+from typing import List, Dict, Any
+from urllib.parse import urlparse
+
+from loguru import logger
+try:
+    from ddgs import DDGS
+except ImportError:
+    try:
+        from duckduckgo_search import DDGS  # fallback: nome antigo do pacote
+    except ImportError:
+        DDGS = None
+from modules.config import OPENROUTER_API_KEY, GROQ_API_KEY, MISTRAL_API_KEY, OPENROUTER_MODEL
+
+class NativeDeepResearch:
+    """
+    Agente Nativo de Deep Research para Akira (OpenManus Clone).
+    Não depende de APIs pagas de pesquisa autônoma (como o Manus),
+    usa DDGS + Trafilatura + LLM para investigar e sintetizar relatórios completos.
+    """
+    
+    def __init__(self):
+        # Configuração de Sessão Robusta para evitar "Connection pool is full"
+        self.session = requests.Session()
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=20, 
+            pool_maxsize=20,
+            max_retries=3
+        )
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+        
+        # Prioridade: Mistral Direct -> OpenRouter -> Groq
+        if MISTRAL_API_KEY:
+            self.api_url = "https://api.mistral.ai/v1/chat/completions"
+            self.api_key = MISTRAL_API_KEY
+            self.model = "mistral-large-latest"
+        elif OPENROUTER_API_KEY:
+            self.api_url = "https://openrouter.ai/api/v1/chat/completions"
+            self.api_key = OPENROUTER_API_KEY
+            self.model = OPENROUTER_MODEL
+        elif GROQ_API_KEY:
+            self.api_url = "https://api.groq.com/openai/v1/chat/completions"
+            self.api_key = GROQ_API_KEY
+            self.model = "llama3-70b-8192"
+        else:
+            self.api_url = ""
+            self.api_key = ""
+            self.model = ""
+            
+    def _call_llm(self, system_prompt: str, user_prompt: str, json_mode: bool = False) -> str:
+        """Chamada direta ao LLM para evitar importações circulares com o LLMManager."""
+        if not self.api_key:
+            return ""
+            
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://akira.softedge.ai",
+            "X-Title": "Akira Native Research"
+        }
+        
+        model_to_use = self.model
+            
+        payload = {
+            "model": model_to_use,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            "temperature": 0.3,
+            "max_tokens": 3000
+        }
+        
+        if json_mode and "groq" not in self.api_url:
+            payload["response_format"] = {"type": "json_object"}
+            
+        response = None
+        try:
+            response = self.session.post(self.api_url, headers=headers, json=payload, timeout=60)
+            response.raise_for_status()
+            data = response.json()
+            return data["choices"][0]["message"]["content"]
+        except Exception as e:
+            logger.error(f"❌ [NATIVE RESEARCH] Erro no LLM: {e}")
+            if response is not None and hasattr(response, 'text'):
+                logger.error(f"Detalhes: {response.text[:500]}")
+            return ""
+
+    def brainstorm_queries(self, topic: str) -> List[str]:
+        """Gera 3 a 4 sub-pesquisas otimizadas para motores de busca."""
+        sys_prompt = "És um assistente de pesquisa especializado. Dada uma instrução complexa, gera 3 queries de pesquisa no Google para investigar o tema profundamente. Retorna APENAS as queries, uma por linha, sem numeração."
+        
+        res = self._call_llm(sys_prompt, topic)
+        if not res:
+            return [topic]
+            
+        queries = [q.strip().strip('-').strip('1234567890.').strip() for q in res.split('\n') if q.strip()]
+        # Evita demasiadas queries
+        return queries[:3] if queries else [topic]
+
+    def search_urls(self, queries: List[str]) -> List[str]:
+        """Procura na web usando o DuckDuckGo e extrai URLs únicos."""
+        urls = set()
+        
+        try:
+            with DDGS() as ddgs:
+                for q in queries:
+                    try:
+                        logger.info(f"🔍 [NATIVE RESEARCH] Procurando por: {q}")
+                        results = list(ddgs.text(q, max_results=3))
+                        for r in results:
+                            if isinstance(r, dict) and "href" in r:
+                                url = r["href"]
+                                # Filtra links inúteis
+                                if not any(x in url for x in ['youtube.com', 'facebook.com', 'instagram.com', 'tiktok.com']):
+                                    urls.add(url)
+                    except Exception as e:
+                        logger.warning(f"⚠️ Erro ao procurar '{q}': {e}")
+                        time.sleep(1) # Pequena pausa em caso de rate limit
+        except Exception as session_err:
+            logger.error(f"❌ [NATIVE RESEARCH] Erro na sessão DDGS: {session_err}")
+                
+        return list(urls)
+
+    def scrape_url(self, url: str) -> str:
+        """Saca o texto limpo do site usando requests + trafilatura."""
+        try:
+            # Uso da sessão com pool aumentado para estabilidade
+            response = self.session.get(url, timeout=15, headers={
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            })
+            response.raise_for_status()
+            
+            if response.text:
+                text = trafilatura.extract(response.text, include_comments=False, include_tables=True)
+                if text:
+                    return f"--- CONTEÚDO DE {url} ---\n{text[:5000]}\n"
+        except Exception as e:
+            logger.debug(f"Falha ao ler {url}: {e}")
+        return ""
+
+    def synthesize_report(self, prompt: str, context: str) -> str:
+        """Gera o relatório final baseado em todo o contexto lido."""
+        sys_prompt = (
+            "És a Akira, a IA incrivelmente inteligente do ecossistema SoftEdge.\n"
+            "Foi-te dada uma tarefa de pesquisa profunda (Deep Research). Tens abaixo as notas extraídas "
+            "da internet em bruto. O teu objectivo é ler tudo, sintetizar a verdade e redigir um "
+            "relatório detalhado, claro e fenomenal para o utilizador.\n"
+            "- Foca-te em dados precisos e atuais.\n"
+            "- Ignora informações redundantes ou não relacionadas com a pergunta original.\n"
+            "- O relatório DEVE ter parágrafos limpos, sem excesso de hashtags.\n"
+            "- Se as notas não tiverem informação suficiente, responde com o que sabes e avisa que a pesquisa web não encontrou tudo."
+        )
+        
+        user_prompt = f"TAREFA ORIGINAL DO UTILIZADOR: {prompt}\n\nNOTAS EXTRAÍDAS DA WEB:\n{context}"
+        
+        res = self._call_llm(sys_prompt, user_prompt)
+        return res
+
+    def run(self, prompt: str) -> Dict[str, Any]:
+        """Executa a rotina completa de pesquisa nativa (OpenManus flow)."""
+        if not self.api_key:
+            return {"sucesso": False, "erro": "Chave de API do LLM em falta para o Native Research."}
+            
+        start_time = time.time()
+        logger.info("🧠 [NATIVE RESEARCH] Iniciando pipeline autónoma...")
+        
+        # 1. Planeamento
+        queries = self.brainstorm_queries(prompt)
+        logger.info(f"📋 Sub-pesquisas geradas: {queries}")
+        
+        # 2. Pesquisa de URLs
+        urls = self.search_urls(queries)
+        if not urls:
+            return {"sucesso": False, "erro": "Não foi possível encontrar páginas web relevantes."}
+        
+        logger.info(f"🌐 URLs recolhidos ({len(urls)}). A extrair texto...")
+        
+        # 3. Scraping Paralelo (Velocidade)
+        scraped_texts = []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+            future_to_url = {executor.submit(self.scrape_url, url): url for url in urls}
+            for future in concurrent.futures.as_completed(future_to_url):
+                text = future.result()
+                if text:
+                    scraped_texts.append(text)
+                    
+        if not scraped_texts:
+            return {"sucesso": False, "erro": "Os sites bloqueadores a leitura dos dados. Não foi possível extrair texto."}
+            
+        full_context = "\n".join(scraped_texts)
+        logger.info(f"📚 Extraídos {len(full_context)} caracteres de conteúdo em bruto. A sintetizar...")
+        
+        # 4. Síntese Final
+        final_report = self.synthesize_report(prompt, full_context)
+        
+        elapsed = int(time.time() - start_time)
+        logger.info(f"✅ [NATIVE RESEARCH] Concluído com sucesso em {elapsed} segundos.")
+        
+        if final_report:
+            return {
+                "sucesso": True,
+                "resultado": final_report,
+                "prompt_original": prompt,
+                "status": "concluído"
+            }
+        else:
+            return {"sucesso": False, "erro": "Falha na síntese do relatório final."}
+
+# Instância partilhada
+native_research_agent = NativeDeepResearch()

modules/skills/weather_skill.py

@@ -0,0 +1,58 @@
+"""
+WeatherSkill - Informações de clima com fallbacks automáticos
+"""
+
+from modules.skills.base_skill import BaseSkill
+from modules.api_integrations.weather_providers import WeatherProviders
+
+
+class WeatherSkill(BaseSkill):
+    """
+    Skill de clima que tenta múltiplos provedores:
+    1. Web search (se tiver contexto)
+    2. Weather Data API (wttr.in)
+    3. Open-Meteo API
+    4. Mensagem de erro apropriada
+    """
+    
+    def __init__(self):
+        super().__init__(
+            name="get_weather",
+            description="Retorna previsão de clima para uma localização com fallbacks automáticos"
+        )
+    
+    def get_primary_provider(self):
+        """Weather Data API como provider primário"""
+        return self.weather_data_api
+    
+    def get_fallback_chain(self):
+        """Chain de fallbacks"""
+        return [
+            self.open_meteo_fallback,
+        ]
+    
+    def weather_data_api(self, location: str, **kwargs) -> dict:
+        """
+        Provider primário: wttr.in
+        """
+        result = WeatherProviders.from_weather_api(location)
+        
+        if result and result.get("sucesso"):
+            return result
+        
+        return {"sucesso": False, "erro": "Weather API falhou"}
+    
+    def open_meteo_fallback(self, location: str, **kwargs) -> dict:
+        """
+        Fallback 1: Open-Meteo (sem autenticação)
+        """
+        result = WeatherProviders.from_openweather_fallback(location)
+        
+        if result and result.get("sucesso"):
+            return result
+        
+        return {"sucesso": False, "erro": "Open-Meteo falhou"}
+    
+    def _get_error_suggestion(self) -> str:
+        """Sugestão customizada quando tudo falha"""
+        return "Tenta com o nome de uma cidade maior ou tenta de novo mais tarde"