Upload 12 files

app.py

@@ -95,7 +95,8 @@ async def handle_chat(request: UserRequest):
                 history=current_history,
                 user_input=final_user_input,
                 user_id=user_id,
-                vision_context=vision_context
+                vision_context=vision_context,
+                web_search=request.web_search  # Passa web search para Heavy Mode
             )
             user_sessions[user_id]["heavy"] = updated_history
             

jade/config.json

@@ -1,8 +1,8 @@
-{
-  "groq_model": "moonshotai/kimi-k2-instruct-0905",
-  "audio_model": "whisper-large-v3",
-  "caption_model": "microsoft/Florence-2-base-ft",
-  "max_context": 12,
-  "language": "pt",
-  "local_mode": false
+{
+  "groq_model": "meta-llama/llama-4-maverick-17b-128e-instruct",
+  "audio_model": "whisper-large-v3",
+  "caption_model": "microsoft/Florence-2-base-ft",
+  "max_context": 12,
+  "language": "pt",
+  "local_mode": false
 }

jade/core.py

@@ -1,168 +1,168 @@
-import json
-import logging
-import os
-import sys
-import time
-import uuid
-
-from groq import Groq
-
-# Importa nossos módulos customizados
-from .handlers import ImageHandler
-from .tts import TTSPlayer
-from .utils import slim_history
-from .shorestone import ShoreStoneMemory
-from .curator_heuristic import MemoryCuratorHeuristic
-from .web_search import WebSearchHandler
-
-# Configura o logger principal
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - JADE - %(levelname)s - %(message)s")
-
-class JadeAgent:
-    def __init__(self, config_path="jade/config.json"):
-        # Carrega configurações
-        # Try to load from absolute path first, then relative
-        try:
-            with open(config_path) as f:
-                self.cfg = json.load(f)
-        except FileNotFoundError:
-             # Fallback: try to find it relative to this file
-            base_dir = os.path.dirname(os.path.abspath(__file__))
-            config_path = os.path.join(base_dir, "config.json")
-            with open(config_path) as f:
-                self.cfg = json.load(f)
-
-        # --- Configuração da API Groq ---
-        logging.info("Iniciando J.A.D.E. em modo API (Groq)...")
-        self.api_key = self._get_api_key()
-        self.client = Groq(api_key=self.api_key)
-        self.model_name = self.cfg.get("groq_model", "moonshotai/kimi-k2-instruct-0905")
-
-        # System Prompt Base
-        self.system_prompt = {"role": "system", "content": "Você é J.A.D.E., uma IA multimodal calma e inteligente. Seja direta. Responda de forma concisa e natural. NÃO explique seu processo de pensamento. Apenas responda à pergunta."}
-        
-        # --- Inicialização dos Módulos ---
-        logging.info("Carregando módulos de percepção e memória...")
-        
-        # Visão e Fala
-        self.image_handler = ImageHandler(self.cfg.get("caption_model", "Salesforce/blip-image-captioning-large"))
-        self.tts = TTSPlayer(lang=self.cfg.get("language", "pt"))
-        
-        # 1. Memória ShoreStone (Persistente)
-        self.memory = ShoreStoneMemory()
-        # Inicializa com sessão padrão, mas será trocada dinamicamente no respond()
-        self.memory.load_or_create_session("sessao_padrao_gabriel")
-        
-        # 2. Curador Heurístico (Manutenção Automática)
-        self.curator = MemoryCuratorHeuristic(shorestone_memory=self.memory)
-        self.response_count = 0
-        self.maintenance_interval = 10 # Executar a manutenção a cada 10 interações
-
-        # 3. Web Search (Tavily)
-        self.web_search_handler = WebSearchHandler()
-
-        logging.info(f"J.A.D.E. pronta e conectada ao modelo {self.model_name}.")
-
-    def _get_api_key(self):
-        """Recupera a chave da API do ambiente de forma segura."""
-        key = os.getenv("GROQ_API_KEY")
-        if not key:
-            logging.error("Chave GROQ_API_KEY não encontrada nas variáveis de ambiente.")
-            # For development, try to warn but not crash if possible, but Groq needs it.
-            # raise RuntimeError("❌ GROQ_API_KEY não encontrada. Defina a variável de ambiente.")
-            print("WARNING: GROQ_API_KEY not found.")
-        return key
-
-    def _chat(self, messages):
-        """Envia as mensagens para a Groq e retorna a resposta."""
-        try:
-            chat = self.client.chat.completions.create(
-                messages=messages, 
-                model=self.model_name,
-                temperature=0.7, # Criatividade balanceada
-                max_tokens=1024  # Limite de resposta razoável
-            )
-            return chat.choices[0].message.content.strip()
-        except Exception as e:
-            logging.error(f"Erro na comunicação com a Groq: {e}")
-            return "Desculpe, tive um problema ao me conectar com meu cérebro na nuvem."
-
-    def respond(self, history, user_input, user_id="default", vision_context=None, web_search=False, thinking_mode=False):
-        """Processo principal de raciocínio: Buscar -> Lembrar -> Ver -> Pensar -> Responder -> Memorizar -> Manter."""
-        
-        # TROCA A SESSÃO DA MEMÓRIA PARA O USUÁRIO ATUAL
-        session_name = f"user_{user_id}"
-        self.memory.load_or_create_session(session_name)
-        
-        messages = history[:]
-        
-        # 0. Thinking Mode - Adiciona instrução de CoT
-        if thinking_mode:
-            thinking_prompt = {
-                "role": "system", 
-                "content": """MODO THINKING ATIVADO: Antes de dar sua resposta final, pense passo a passo.
-Coloque todo seu raciocínio dentro de tags <thinking>...</thinking>.
-Após fechar a tag </thinking>, dê sua resposta final de forma clara e direta.
-Exemplo:
-<thinking>
-1. Primeiro, vou analisar...
-2. Considerando que...
-3. Portanto...
-</thinking>
-
-[Sua resposta final aqui]"""
-            }
-            messages.append(thinking_prompt)
-
-        # 0. Buscar na Web (se habilitado)
-        if web_search and self.web_search_handler.is_available():
-            search_results = self.web_search_handler.search(user_input)
-            if search_results:
-                search_context = f"--- RESULTADOS DA BUSCA WEB ---\n{search_results}\n--- FIM DA BUSCA ---"
-                messages.append({"role": "system", "content": search_context})
-        
-        # 1. Lembrar (Recuperação de Contexto)
-        memories = self.memory.remember(user_input)
-        if memories:
-            memory_context = f"--- MEMÓRIAS RELEVANTES (ShoreStone) ---\n{memories}\n--- FIM DAS MEMÓRIAS ---"
-            # Inserimos as memórias como contexto de sistema para guiar a resposta
-            messages.append({"role": "system", "content": memory_context})
-
-        # 2. Ver (Contexto Visual)
-        if vision_context:
-            messages.append({"role": "system", "content": f"Contexto visual da imagem que o usuário enviou: {vision_context}"})
-
-        # Adiciona a pergunta atual ao histórico temporário e ao prompt
-        history.append({"role": "user", "content": user_input})
-        messages.append({"role": "user", "content": user_input})
-
-        # 3. Responder (Geração)
-        resposta = self._chat(messages)
-        
-        # Atualiza histórico
-        history.append({"role": "assistant", "content": resposta})
-        history = slim_history(history, keep=self.cfg.get("max_context", 12))
-        
-        # 4. Memorizar (Armazenamento Persistente)
-        self.memory.memorize(user_input, resposta)
-
-        print(f"\n🤖 J.A.D.E.: {resposta}")
-        
-        # Falar (TTS) - Modified for Backend compatibility
-        audio_path = None
-        try:
-            # Uses the TTSPlayer from tts.py which has save_audio_to_file
-            audio_path = self.tts.save_audio_to_file(resposta)
-        except Exception as e:
-            logging.warning(f"TTS falhou (silenciado): {e}")
-            
-        # 5. Manter (Ciclo de Curadoria Automática)
-        self.response_count += 1
-        if self.response_count % self.maintenance_interval == 0:
-            logging.info(f"Ciclo de manutenção agendado (interação {self.response_count}). Verificando saúde da memória...")
-            try:
-                self.curator.run_maintenance_cycle()
-            except Exception as e:
-                logging.error(f"Erro no Curador de Memória: {e}")
-        
-        return resposta, audio_path, history
+import json
+import logging
+import os
+import sys
+import time
+import uuid
+
+from groq import Groq
+
+# Importa nossos módulos customizados
+from .handlers import ImageHandler
+from .tts import TTSPlayer
+from .utils import slim_history
+from .shorestone import ShoreStoneMemory
+from .curator_heuristic import MemoryCuratorHeuristic
+from .web_search import WebSearchHandler
+
+# Configura o logger principal
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - JADE - %(levelname)s - %(message)s")
+
+class JadeAgent:
+    def __init__(self, config_path="jade/config.json"):
+        # Carrega configurações
+        # Try to load from absolute path first, then relative
+        try:
+            with open(config_path) as f:
+                self.cfg = json.load(f)
+        except FileNotFoundError:
+             # Fallback: try to find it relative to this file
+            base_dir = os.path.dirname(os.path.abspath(__file__))
+            config_path = os.path.join(base_dir, "config.json")
+            with open(config_path) as f:
+                self.cfg = json.load(f)
+
+        # --- Configuração da API Groq ---
+        logging.info("Iniciando J.A.D.E. em modo API (Groq)...")
+        self.api_key = self._get_api_key()
+        self.client = Groq(api_key=self.api_key)
+        self.model_name = self.cfg.get("groq_model", "meta-llama/llama-4-maverick-17b-128e-instruct")
+
+        # System Prompt Base
+        self.system_prompt = {"role": "system", "content": "Você é J.A.D.E., uma IA multimodal calma e inteligente. Seja direta. Responda de forma concisa e natural. NÃO explique seu processo de pensamento. Apenas responda à pergunta."}
+        
+        # --- Inicialização dos Módulos ---
+        logging.info("Carregando módulos de percepção e memória...")
+        
+        # Visão e Fala
+        self.image_handler = ImageHandler(self.cfg.get("caption_model", "Salesforce/blip-image-captioning-large"))
+        self.tts = TTSPlayer(lang=self.cfg.get("language", "pt"))
+        
+        # 1. Memória ShoreStone (Persistente)
+        self.memory = ShoreStoneMemory()
+        # Inicializa com sessão padrão, mas será trocada dinamicamente no respond()
+        self.memory.load_or_create_session("sessao_padrao_gabriel")
+        
+        # 2. Curador Heurístico (Manutenção Automática)
+        self.curator = MemoryCuratorHeuristic(shorestone_memory=self.memory)
+        self.response_count = 0
+        self.maintenance_interval = 10 # Executar a manutenção a cada 10 interações
+
+        # 3. Web Search (Tavily)
+        self.web_search_handler = WebSearchHandler()
+
+        logging.info(f"J.A.D.E. pronta e conectada ao modelo {self.model_name}.")
+
+    def _get_api_key(self):
+        """Recupera a chave da API do ambiente de forma segura."""
+        key = os.getenv("GROQ_API_KEY")
+        if not key:
+            logging.error("Chave GROQ_API_KEY não encontrada nas variáveis de ambiente.")
+            # For development, try to warn but not crash if possible, but Groq needs it.
+            # raise RuntimeError("❌ GROQ_API_KEY não encontrada. Defina a variável de ambiente.")
+            print("WARNING: GROQ_API_KEY not found.")
+        return key
+
+    def _chat(self, messages):
+        """Envia as mensagens para a Groq e retorna a resposta."""
+        try:
+            chat = self.client.chat.completions.create(
+                messages=messages, 
+                model=self.model_name,
+                temperature=0.7, # Criatividade balanceada
+                max_tokens=1024  # Limite de resposta razoável
+            )
+            return chat.choices[0].message.content.strip()
+        except Exception as e:
+            logging.error(f"Erro na comunicação com a Groq: {e}")
+            return "Desculpe, tive um problema ao me conectar com meu cérebro na nuvem."
+
+    def respond(self, history, user_input, user_id="default", vision_context=None, web_search=False, thinking_mode=False):
+        """Processo principal de raciocínio: Buscar -> Lembrar -> Ver -> Pensar -> Responder -> Memorizar -> Manter."""
+        
+        # TROCA A SESSÃO DA MEMÓRIA PARA O USUÁRIO ATUAL
+        session_name = f"user_{user_id}"
+        self.memory.load_or_create_session(session_name)
+        
+        messages = history[:]
+        
+        # 0. Thinking Mode - Adiciona instrução de CoT
+        if thinking_mode:
+            thinking_prompt = {
+                "role": "system", 
+                "content": """MODO THINKING ATIVADO: Antes de dar sua resposta final, pense passo a passo.
+Coloque todo seu raciocínio dentro de tags <thinking>...</thinking>.
+Após fechar a tag </thinking>, dê sua resposta final de forma clara e direta.
+Exemplo:
+<thinking>
+1. Primeiro, vou analisar...
+2. Considerando que...
+3. Portanto...
+</thinking>
+
+[Sua resposta final aqui]"""
+            }
+            messages.append(thinking_prompt)
+
+        # 0. Buscar na Web (se habilitado)
+        if web_search and self.web_search_handler.is_available():
+            search_results = self.web_search_handler.search(user_input)
+            if search_results:
+                search_context = f"--- RESULTADOS DA BUSCA WEB ---\n{search_results}\n--- FIM DA BUSCA ---"
+                messages.append({"role": "system", "content": search_context})
+        
+        # 1. Lembrar (Recuperação de Contexto)
+        memories = self.memory.remember(user_input)
+        if memories:
+            memory_context = f"--- MEMÓRIAS RELEVANTES (ShoreStone) ---\n{memories}\n--- FIM DAS MEMÓRIAS ---"
+            # Inserimos as memórias como contexto de sistema para guiar a resposta
+            messages.append({"role": "system", "content": memory_context})
+
+        # 2. Ver (Contexto Visual)
+        if vision_context:
+            messages.append({"role": "system", "content": f"Contexto visual da imagem que o usuário enviou: {vision_context}"})
+
+        # Adiciona a pergunta atual ao histórico temporário e ao prompt
+        history.append({"role": "user", "content": user_input})
+        messages.append({"role": "user", "content": user_input})
+
+        # 3. Responder (Geração)
+        resposta = self._chat(messages)
+        
+        # Atualiza histórico
+        history.append({"role": "assistant", "content": resposta})
+        history = slim_history(history, keep=self.cfg.get("max_context", 12))
+        
+        # 4. Memorizar (Armazenamento Persistente)
+        self.memory.memorize(user_input, resposta)
+
+        print(f"\n🤖 J.A.D.E.: {resposta}")
+        
+        # Falar (TTS) - Modified for Backend compatibility
+        audio_path = None
+        try:
+            # Uses the TTSPlayer from tts.py which has save_audio_to_file
+            audio_path = self.tts.save_audio_to_file(resposta)
+        except Exception as e:
+            logging.warning(f"TTS falhou (silenciado): {e}")
+            
+        # 5. Manter (Ciclo de Curadoria Automática)
+        self.response_count += 1
+        if self.response_count % self.maintenance_interval == 0:
+            logging.info(f"Ciclo de manutenção agendado (interação {self.response_count}). Verificando saúde da memória...")
+            try:
+                self.curator.run_maintenance_cycle()
+            except Exception as e:
+                logging.error(f"Erro no Curador de Memória: {e}")
+        
+        return resposta, audio_path, history

jade/heavy_mode.py

@@ -10,6 +10,7 @@ from groq import AsyncGroq, RateLimitError
 from mistralai import Mistral
 from openai import AsyncOpenAI
 import traceback
+from .web_search import WebSearchHandler
 
 # Configura logger local
 logger = logging.getLogger("JadeHeavy")
@@ -54,6 +55,9 @@ class JadeHeavyAgent:
         # Judge model (Groq is fast and cheap)
         self.judge_id = "moonshotai/kimi-k2-instruct-0905" 
 
+        # Web Search Handler
+        self.web_search_handler = WebSearchHandler()
+
     async def _safe_propose(self, model_name, history_text):
         """Phase 1: Strategic Planning"""
         # Staggering to avoid rate limits
@@ -138,7 +142,45 @@ class JadeHeavyAgent:
             return ""
         return ""
 
-    async def respond(self, history, user_input, user_id="default", vision_context=None):
+    async def _safe_criticize(self, model_name, draft, original_context):
+        """Phase 3.5: Self-Criticism - Each model reviews and improves its own draft"""
+        await asyncio.sleep(random.uniform(0.5, 1.5))  # Stagger
+        
+        sys_prompt = (
+            "You are a Critical Reviewer. You wrote the draft below. Now critically review it.\n"
+            "Fix any errors, add missing important information, improve clarity and flow.\n"
+            "Return the IMPROVED version of the response. Keep the same general structure.\n"
+            "Do not add meta-commentary, just return the improved text."
+        )
+        
+        user_prompt = f"Original Request Context:\n{original_context}\n\nYour Draft to Improve:\n{draft}"
+        messages = [{"role": "system", "content": sys_prompt}, {"role": "user", "content": user_prompt}]
+        
+        try:
+            content = ""
+            if model_name == "Mistral" and self.mistral:
+                resp = await self.mistral.chat.complete_async(model=self.models["Mistral"], messages=messages)
+                content = resp.choices[0].message.content
+            elif model_name == "Qwen" and self.openrouter:
+                resp = await self.openrouter.chat.completions.create(model="qwen/qwen3-coder:free", messages=messages)
+                content = resp.choices[0].message.content
+            else:
+                target_model = self.models.get(model_name, "openai/gpt-oss-120b")
+                resp = await self.groq_client.chat.completions.create(
+                    model=target_model, 
+                    messages=messages, 
+                    temperature=0.5
+                )
+                content = resp.choices[0].message.content
+            
+            if content:
+                return f"[{model_name} Refined]:\n{content}"
+        except Exception as e:
+            logger.error(f"Error in criticize ({model_name}): {e}")
+            return draft  # Return original draft if criticism fails
+        return draft
+
+    async def respond(self, history, user_input, user_id="default", vision_context=None, web_search=False):
         """
         Main entry point for the Heavy Agent.
         History is a list of dicts: [{"role": "user", "content": "..."}...]
@@ -151,6 +193,13 @@ class JadeHeavyAgent:
         
         if vision_context:
             full_context += f"SYSTEM (Vision): {vision_context}\n"
+        
+        # --- WEB SEARCH (if enabled) ---
+        if web_search and self.web_search_handler.is_available():
+            logger.info("Jade Heavy: Performing web search...")
+            search_results = self.web_search_handler.search(user_input)
+            if search_results:
+                full_context = f"[WEB SEARCH RESULTS]\n{search_results}\n\n" + full_context
             
         full_context += f"USER: {user_input}\n"
         
@@ -192,11 +241,22 @@ class JadeHeavyAgent:
         if not valid_sols:
              return "Failed to generate drafts.", None, history
 
+        # --- PHASE 3.5: SELF-CRITICISM (NEW!) ---
+        logger.info("Jade Heavy: Phase 3.5 - Self-Criticism...")
+        # Pair each agent with its draft for self-criticism
+        agent_draft_pairs = list(zip(agents[:len(valid_sols)], valid_sols))
+        tasks_crit = [self._safe_criticize(m, d, full_context) for m, d in agent_draft_pairs]
+        results_crit = await asyncio.gather(*tasks_crit)
+        refined_sols = [s for s in results_crit if s]
+        
+        # Use refined solutions if available, otherwise fallback to original drafts
+        final_drafts = refined_sols if refined_sols else valid_sols
+
         # --- PHASE 4: VERDICT (Synthesis) ---
         logger.info("Jade Heavy: Phase 4 - Verdict...")
         council_prompt = (
             f"User Request:\n{full_context}\n\nCandidate Responses:\n" + 
-            "\n".join(valid_sols) + 
+            "\n".join(final_drafts) + 
             "\n\nTASK: Synthesize the best parts of these drafts into a FINAL, PERFECT RESPONSE."
             "The response should be natural, helpful, and high-quality. Do not mention the agents or the process."
         )
@@ -211,16 +271,10 @@ class JadeHeavyAgent:
             final_answer = resp.choices[0].message.content
         except Exception as e:
             logger.error(f"Verdict failed: {e}")
-            final_answer = valid_sols[0].replace(f"[{agents[0]} Draft]:\n", "") # Fallback
+            final_answer = final_drafts[0].split(":\n", 1)[-1] if final_drafts else "Error generating response."
 
         # Update History
         history.append({"role": "user", "content": user_input})
         history.append({"role": "assistant", "content": final_answer})
         
-        # Audio (Optional/Placeholder - returning None for now or use TTS if needed)
-        # The user said "backend focuses on request", so we can skip TTS generation here 
-        # or implement it if JadeAgent does it. The original code uses `jade_agent.tts`.
-        # For Heavy mode, maybe we skip audio for speed, or add it later.
-        # I'll return None for audio path.
-        
         return final_answer, None, history