add tools

app.py

@@ -25,12 +25,19 @@ class AutismResearchApp:
     
     async def run(self):
         """Run the main application loop"""
+        
         self._setup_streamlit()
         
         # Initialize session state for papers
         if 'papers' not in st.session_state:
             st.session_state.papers = []
         
+        # Carregar modelos assincronamente
+        with st.status("Carregando modelos...") as status:
+            status.write("🔄 Inicializando modelos de linguagem...")
+            await self.model_handler._load_models_async()
+            status.write("✅ Modelos carregados com sucesso!")
+        
         # Get user query
         col1, col2 = st.columns(2, vertical_alignment="bottom", gap="small")
 

services/model_handler.py

@@ -106,6 +106,19 @@ class LocalHuggingFaceModel(Model):
             logging.error(f"[{self.model_name}] Error in ainvoke_stream: {str(e)}")
             yield Response(f"Error in ainvoke_stream: {str(e)}")
     
+    async def aresponse_stream(self, prompt: str, **kwargs):
+        """
+        Método abstrato necessário para implementar a interface Model da biblioteca agno.
+        Este método deve retornar um gerador assíncrono de objetos Response.
+        """
+        try:
+            logging.info(f"[{self.model_name}] aresponse_stream called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+            result = self.invoke(prompt, **kwargs)
+            yield result
+        except Exception as e:
+            logging.error(f"[{self.model_name}] Error in aresponse_stream: {str(e)}")
+            yield Response(f"Error in aresponse_stream: {str(e)}")
+    
     def invoke(self, prompt: str, **kwargs) -> str:
         """Synchronous invoke method"""
         try:
@@ -320,8 +333,8 @@ class ModelHandler:
         self.force_default_response = False
         self.models = {}
         
-        # Inicializar modelos
-        self._load_models()
+        # Os modelos serão carregados posteriormente de forma assíncrona
+        logging.info("ModelHandler initialized. Models will be loaded asynchronously.")
     
     def _extract_content(self, result):
         """
@@ -345,6 +358,14 @@ class ModelHandler:
             logging.error(f"Error extracting content: {str(e)}")
             return ""
     
+    async def _load_models_async(self):
+        """
+        Carrega os modelos de forma assíncrona.
+        """
+        logging.info("Loading models asynchronously...")
+        self._load_models()
+        logging.info("Models loaded asynchronously")
+    
     def _format_prompt(self, prompt_type, content):
         """
         Formata o prompt de acordo com o tipo.
@@ -706,9 +727,8 @@ Para informações mais detalhadas e específicas, recomendamos consultar litera
         """
         try:
             logging.info(f"Running agent {agent.name} with tools")
-            # O método arun retorna um gerador assíncrono que precisa ser awaited corretamente
-            response_generator = agent.arun(prompt, max_steps=max_steps)
-            result = await response_generator.__anext__()
+            # O método arun retorna um coroutine que precisa ser awaited
+            result = await agent.arun(prompt, max_steps=max_steps)
             logging.info(f"Agent {agent.name} execution complete")
             return result
         except Exception as e:
@@ -742,13 +762,12 @@ Para informações mais detalhadas e específicas, recomendamos consultar litera
             logging.info(f"Translation prompt: {translation_prompt}")
             
             try:
-                # O método arun retorna um gerador assíncrono que precisa ser awaited corretamente
-                response_generator = self.translator.arun(translation_prompt)
-                translation_result = await response_generator.__anext__()
-                logging.info(f"Translation result type: {type(translation_result)}")
+                # O método arun retorna um coroutine que precisa ser awaited
+                result = await self.translator.arun(translation_prompt)
+                logging.info(f"Translation result type: {type(result)}")
                 
                 # Extrair o conteúdo da resposta
-                translation_content = self._extract_content(translation_result)
+                translation_content = self._extract_content(result)
                 logging.info(f"Translation content: {translation_content}")
                 
                 if not translation_content or not translation_content.strip():
@@ -800,12 +819,11 @@ Para informações mais detalhadas e específicas, recomendamos consultar litera
                 presentation_prompt = self._format_prompt("presentation", research_content)
                 logging.info(f"Presentation prompt: {presentation_prompt}")
                 
-                # O método arun retorna um gerador assíncrono que precisa ser awaited corretamente
-                response_generator = self.presenter.arun(presentation_prompt)
-                presentation_result = await response_generator.__anext__()
-                logging.info(f"Presentation type: {type(presentation_result)}")
+                # O método arun retorna um coroutine que precisa ser awaited
+                result = await self.presenter.arun(presentation_prompt)
+                logging.info(f"Presentation type: {type(result)}")
                 
-                presentation_content = self._extract_content(presentation_result)
+                presentation_content = self._extract_content(result)
                 logging.info(f"Presentation content: {presentation_content}")
                 
                 presentation_length = len(presentation_content.strip()) if presentation_content and isinstance(presentation_content, str) else 0