pass prompt

services/model_handler.py

@@ -67,23 +67,41 @@ class LocalHuggingFaceModel(Model):
         
     async def ainvoke(self, prompt: str, **kwargs) -> str:
         """Async invoke method"""
-        return await self.invoke(prompt=prompt, **kwargs)
+        try:
+            logging.info(f"ainvoke called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+            return await self.invoke(prompt, **kwargs)
+        except Exception as e:
+            logging.error(f"Error in ainvoke: {str(e)}")
+            return Response(f"Error in ainvoke: {str(e)}")
     
     async def ainvoke_stream(self, prompt: str, **kwargs):
         """Async streaming invoke method"""
-        result = await self.invoke(prompt=prompt, **kwargs)
-        yield result
+        try:
+            logging.info(f"ainvoke_stream called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+            result = await self.invoke(prompt, **kwargs)
+            yield result
+        except Exception as e:
+            logging.error(f"Error in ainvoke_stream: {str(e)}")
+            yield Response(f"Error in ainvoke_stream: {str(e)}")
     
     def invoke(self, prompt: str, **kwargs) -> str:
         """Synchronous invoke method"""
         try:
-            logging.info(f"Invoking model with prompt: {prompt[:100] if prompt else 'None'}...")
+            logging.info(f"Invoking model with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
             
             # Check if prompt is None or empty
             if prompt is None:
                 logging.warning("None prompt provided to invoke method")
                 return Response("No input provided. Please provide a valid prompt.")
                 
+            if not isinstance(prompt, str):
+                logging.warning(f"Non-string prompt provided: {type(prompt)}")
+                try:
+                    prompt = str(prompt)
+                    logging.info(f"Converted prompt to string: {prompt[:100]}...")
+                except:
+                    return Response("Invalid input type. Please provide a string prompt.")
+                
             if not prompt.strip():
                 logging.warning("Empty prompt provided to invoke method")
                 return Response("No input provided. Please provide a non-empty prompt.")
@@ -120,8 +138,13 @@ class LocalHuggingFaceModel(Model):
     
     def invoke_stream(self, prompt: str, **kwargs):
         """Synchronous streaming invoke method"""
-        result = self.invoke(prompt=prompt, **kwargs)
-        yield result
+        try:
+            logging.info(f"invoke_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"Error in invoke_stream: {str(e)}")
+            yield Response(f"Error in invoke_stream: {str(e)}")
     
     def parse_provider_response(self, response: str) -> str:
         """Parse the provider response"""
@@ -133,32 +156,129 @@ class LocalHuggingFaceModel(Model):
         
     async def aresponse(self, prompt=None, **kwargs):
         """Async response method - required abstract method"""
-        if prompt is None:
-            prompt = kwargs.get('input', '')
-        content = await self.ainvoke(prompt=prompt, **kwargs)
-        return Response(content)
+        try:
+            # Log detalhado de todos os argumentos
+            logging.info(f"aresponse args: prompt={prompt}, kwargs keys={list(kwargs.keys())}")
+            
+            # Extrair o prompt das mensagens se estiverem disponíveis
+            if prompt is None and 'messages' in kwargs and kwargs['messages']:
+                messages = kwargs['messages']
+                # Procurar pela mensagem do usuário
+                for message in messages:
+                    if hasattr(message, 'role') and message.role == 'user' and hasattr(message, 'content'):
+                        prompt = message.content
+                        logging.info(f"Extracted prompt from user message: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+                        break
+            
+            # Verificar se o prompt está em kwargs['input']
+            if prompt is None:
+                if 'input' in kwargs:
+                    prompt = kwargs.get('input')
+                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+            
+            logging.info(f"aresponse called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+                
+            if not prompt or not isinstance(prompt, str) or not prompt.strip():
+                logging.warning("Empty or invalid prompt in aresponse")
+                return Response("No input provided. Please provide a valid prompt.")
+                
+            content = await self.ainvoke(prompt, **kwargs)
+            return content if isinstance(content, Response) else Response(content)
+        except Exception as e:
+            logging.error(f"Error in aresponse: {str(e)}")
+            return Response(f"Error in aresponse: {str(e)}")
     
     async def aresponse_stream(self, prompt=None, **kwargs):
         """Async streaming response method - required abstract method"""
-        if prompt is None:
-            prompt = kwargs.get('input', '')
-        async for chunk in self.ainvoke_stream(prompt=prompt, **kwargs):
-            yield Response(chunk)
+        try:
+            # Verificar se o prompt está em kwargs['input']
+            if prompt is None:
+                if 'input' in kwargs:
+                    prompt = kwargs.get('input')
+                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+            
+            logging.info(f"aresponse_stream called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+                
+            if not prompt or not isinstance(prompt, str) or not prompt.strip():
+                logging.warning("Empty or invalid prompt in aresponse_stream")
+                yield Response("No input provided. Please provide a valid prompt.")
+                return
+                
+            async for chunk in self.ainvoke_stream(prompt, **kwargs):
+                yield chunk if isinstance(chunk, Response) else Response(chunk)
+        except Exception as e:
+            logging.error(f"Error in aresponse_stream: {str(e)}")
+            yield Response(f"Error in aresponse_stream: {str(e)}")
     
     def response(self, prompt=None, **kwargs):
         """Synchronous response method - required abstract method"""
-        if prompt is None:
-            prompt = kwargs.get('input', '')
-        content = self.invoke(prompt=prompt, **kwargs)
-        return Response(content)
+        try:
+            # Log detalhado de todos os argumentos
+            logging.info(f"response args: prompt={prompt}, kwargs keys={list(kwargs.keys())}")
+            
+            # Extrair o prompt das mensagens se estiverem disponíveis
+            if prompt is None and 'messages' in kwargs and kwargs['messages']:
+                messages = kwargs['messages']
+                # Procurar pela mensagem do usuário
+                for message in messages:
+                    if hasattr(message, 'role') and message.role == 'user' and hasattr(message, 'content'):
+                        prompt = message.content
+                        logging.info(f"Extracted prompt from user message: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+                        break
+            
+            # Verificar se o prompt está em kwargs['input']
+            if prompt is None:
+                if 'input' in kwargs:
+                    prompt = kwargs.get('input')
+                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+            
+            logging.info(f"response called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+                
+            if not prompt or not isinstance(prompt, str) or not prompt.strip():
+                logging.warning("Empty or invalid prompt in response")
+                return Response("No input provided. Please provide a valid prompt.")
+                
+            content = self.invoke(prompt, **kwargs)
+            return content if isinstance(content, Response) else Response(content)
+        except Exception as e:
+            logging.error(f"Error in response: {str(e)}")
+            return Response(f"Error in response: {str(e)}")
     
     def response_stream(self, prompt=None, **kwargs):
         """Synchronous streaming response method - required abstract method"""
-        if prompt is None:
-            prompt = kwargs.get('input', '')
-        for chunk in self.invoke_stream(prompt=prompt, **kwargs):
-            yield Response(chunk)
-        
+        try:
+            # Log detalhado de todos os argumentos
+            logging.info(f"response_stream args: prompt={prompt}, kwargs keys={list(kwargs.keys())}")
+            
+            # Extrair o prompt das mensagens se estiverem disponíveis
+            if prompt is None and 'messages' in kwargs and kwargs['messages']:
+                messages = kwargs['messages']
+                # Procurar pela mensagem do usuário
+                for message in messages:
+                    if hasattr(message, 'role') and message.role == 'user' and hasattr(message, 'content'):
+                        prompt = message.content
+                        logging.info(f"Extracted prompt from user message: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+                        break
+            
+            # Verificar se o prompt está em kwargs['input']
+            if prompt is None:
+                if 'input' in kwargs:
+                    prompt = kwargs.get('input')
+                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+            
+            logging.info(f"response_stream called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+                
+            if not prompt or not isinstance(prompt, str) or not prompt.strip():
+                logging.warning("Empty or invalid prompt in response_stream")
+                yield Response("No input provided. Please provide a valid prompt.")
+                return
+                
+            for chunk in self.invoke_stream(prompt, **kwargs):
+                yield chunk if isinstance(chunk, Response) else Response(chunk)
+        except Exception as e:
+            logging.error(f"Error in response_stream: {str(e)}")
+            yield Response(f"Error in response_stream: {str(e)}")
+    
     def generate(self, prompt: str, **kwargs):
         try:
             inputs = self.tokenizer(prompt, return_tensors="pt", padding=True)
@@ -178,7 +298,7 @@ class LocalHuggingFaceModel(Model):
             
             return decoded_output
         except Exception as e:
-            logging.error(f"Error in local model generation: {str(e)}")
+            logging.error(f"Error in generate method: {str(e)}")
             if hasattr(e, 'args') and len(e.args) > 0:
                 error_message = e.args[0]
             else:
@@ -217,31 +337,128 @@ class DummyModel(Model):
         
     async def aresponse(self, prompt=None, **kwargs):
         """Async response method - required abstract method"""
-        if prompt is None:
-            prompt = kwargs.get('input', '')
-        content = await self.ainvoke(prompt=prompt, **kwargs)
-        return Response(content)
+        try:
+            # Log detalhado de todos os argumentos
+            logging.info(f"aresponse args: prompt={prompt}, kwargs keys={list(kwargs.keys())}")
+            
+            # Extrair o prompt das mensagens se estiverem disponíveis
+            if prompt is None and 'messages' in kwargs and kwargs['messages']:
+                messages = kwargs['messages']
+                # Procurar pela mensagem do usuário
+                for message in messages:
+                    if hasattr(message, 'role') and message.role == 'user' and hasattr(message, 'content'):
+                        prompt = message.content
+                        logging.info(f"Extracted prompt from user message: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+                        break
+            
+            # Verificar se o prompt está em kwargs['input']
+            if prompt is None:
+                if 'input' in kwargs:
+                    prompt = kwargs.get('input')
+                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+            
+            logging.info(f"aresponse called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+                
+            if not prompt or not isinstance(prompt, str) or not prompt.strip():
+                logging.warning("Empty or invalid prompt in aresponse")
+                return Response("No input provided. Please provide a valid prompt.")
+                
+            content = await self.ainvoke(prompt, **kwargs)
+            return content if isinstance(content, Response) else Response(content)
+        except Exception as e:
+            logging.error(f"Error in aresponse: {str(e)}")
+            return Response(f"Error in aresponse: {str(e)}")
     
     async def aresponse_stream(self, prompt=None, **kwargs):
         """Async streaming response method - required abstract method"""
-        if prompt is None:
-            prompt = kwargs.get('input', '')
-        async for chunk in self.ainvoke_stream(prompt=prompt, **kwargs):
-            yield Response(chunk)
+        try:
+            # Verificar se o prompt está em kwargs['input']
+            if prompt is None:
+                if 'input' in kwargs:
+                    prompt = kwargs.get('input')
+                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+            
+            logging.info(f"aresponse_stream called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+                
+            if not prompt or not isinstance(prompt, str) or not prompt.strip():
+                logging.warning("Empty or invalid prompt in aresponse_stream")
+                yield Response("No input provided. Please provide a valid prompt.")
+                return
+                
+            async for chunk in self.ainvoke_stream(prompt, **kwargs):
+                yield chunk if isinstance(chunk, Response) else Response(chunk)
+        except Exception as e:
+            logging.error(f"Error in aresponse_stream: {str(e)}")
+            yield Response(f"Error in aresponse_stream: {str(e)}")
     
     def response(self, prompt=None, **kwargs):
         """Synchronous response method - required abstract method"""
-        if prompt is None:
-            prompt = kwargs.get('input', '')
-        content = self.invoke(prompt=prompt, **kwargs)
-        return Response(content)
+        try:
+            # Log detalhado de todos os argumentos
+            logging.info(f"response args: prompt={prompt}, kwargs keys={list(kwargs.keys())}")
+            
+            # Extrair o prompt das mensagens se estiverem disponíveis
+            if prompt is None and 'messages' in kwargs and kwargs['messages']:
+                messages = kwargs['messages']
+                # Procurar pela mensagem do usuário
+                for message in messages:
+                    if hasattr(message, 'role') and message.role == 'user' and hasattr(message, 'content'):
+                        prompt = message.content
+                        logging.info(f"Extracted prompt from user message: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+                        break
+            
+            # Verificar se o prompt está em kwargs['input']
+            if prompt is None:
+                if 'input' in kwargs:
+                    prompt = kwargs.get('input')
+                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+            
+            logging.info(f"response called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+                
+            if not prompt or not isinstance(prompt, str) or not prompt.strip():
+                logging.warning("Empty or invalid prompt in response")
+                return Response("No input provided. Please provide a valid prompt.")
+                
+            content = self.invoke(prompt, **kwargs)
+            return content if isinstance(content, Response) else Response(content)
+        except Exception as e:
+            logging.error(f"Error in response: {str(e)}")
+            return Response(f"Error in response: {str(e)}")
     
     def response_stream(self, prompt=None, **kwargs):
         """Synchronous streaming response method - required abstract method"""
-        if prompt is None:
-            prompt = kwargs.get('input', '')
-        for chunk in self.invoke_stream(prompt=prompt, **kwargs):
-            yield Response(chunk)
+        try:
+            # Log detalhado de todos os argumentos
+            logging.info(f"response_stream args: prompt={prompt}, kwargs keys={list(kwargs.keys())}")
+            
+            # Extrair o prompt das mensagens se estiverem disponíveis
+            if prompt is None and 'messages' in kwargs and kwargs['messages']:
+                messages = kwargs['messages']
+                # Procurar pela mensagem do usuário
+                for message in messages:
+                    if hasattr(message, 'role') and message.role == 'user' and hasattr(message, 'content'):
+                        prompt = message.content
+                        logging.info(f"Extracted prompt from user message: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+                        break
+            
+            # Verificar se o prompt está em kwargs['input']
+            if prompt is None:
+                if 'input' in kwargs:
+                    prompt = kwargs.get('input')
+                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
+            
+            logging.info(f"response_stream called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
+                
+            if not prompt or not isinstance(prompt, str) or not prompt.strip():
+                logging.warning("Empty or invalid prompt in response_stream")
+                yield Response("No input provided. Please provide a valid prompt.")
+                return
+                
+            for chunk in self.invoke_stream(prompt, **kwargs):
+                yield chunk if isinstance(chunk, Response) else Response(chunk)
+        except Exception as e:
+            logging.error(f"Error in response_stream: {str(e)}")
+            yield Response(f"Error in response_stream: {str(e)}")
 
 class ModelHandler:
     def __init__(self):
@@ -329,37 +546,56 @@ class ModelHandler:
             add_references=True,
         )
     
-    def _format_prompt(self, role, instructions, query):
-        """Format the prompt for the model"""
-        # Validate inputs
-        if not role or not role.strip():
-            role = "Assistant"
-            logging.warning("Empty role provided to _format_prompt, using default: 'Assistant'")
-        
-        if not instructions or not instructions.strip():
-            instructions = "Please process the following input."
-            logging.warning("Empty instructions provided to _format_prompt, using default instructions")
+    def _extract_content(self, result):
+        """
+        Extrai o conteúdo de uma resposta do modelo.
         
-        if not query or not query.strip():
-            query = "No input provided."
-            logging.warning("Empty query provided to _format_prompt, using placeholder text")
-        
-        # Format the prompt
-        formatted_prompt = f"""Task: {role}
-
-Instructions:
-{instructions}
-
-Input: {query}
-
-Output:"""
-        
-        # Ensure the prompt is not empty
-        if not formatted_prompt or not formatted_prompt.strip():
-            logging.error("Generated an empty prompt despite validation")
-            formatted_prompt = "Please provide a response."
+        Args:
+            result: A resposta do modelo, que pode ser um objeto RunResponse ou uma string
+            
+        Returns:
+            O conteúdo da resposta como string
+        """
+        try:
+            if result is None:
+                return ""
+                
+            if hasattr(result, 'content'):
+                return result.content
+            
+            return str(result)
+        except Exception as e:
+            logging.error(f"Error extracting content: {str(e)}")
+            return ""
+    
+    def _format_prompt(self, prompt_type, query):
+        """
+        Formata um prompt para o modelo com base no tipo de prompt e na consulta.
         
-        return formatted_prompt
+        Args:
+            prompt_type: O tipo de prompt (translation, research, presentation)
+            query: A consulta do usuário ou o resultado de uma etapa anterior
+            
+        Returns:
+            Um prompt formatado
+        """
+        try:
+            if not query or not query.strip():
+                logging.warning(f"Empty query provided to _format_prompt for {prompt_type}")
+                return ""
+                
+            if prompt_type == "translation":
+                return f"Task: Translate the following text to English\n\nInstructions:\nProvide a direct English translation of the input text.\n\nInput: {query}\n\nOutput:"
+            elif prompt_type == "research":
+                return f"Task: Research Assistant\n\nInstructions:\nProvide a clear and concise answer based on scientific sources.\n\nInput: {query}\n\nOutput:"
+            elif prompt_type == "presentation":
+                return f"Task: Presentation Assistant\n\nInstructions:\nProvide a clear and concise presentation of the research results.\n\nInput: {query}\n\nOutput:"
+            else:
+                logging.warning(f"Unknown prompt type: {prompt_type}")
+                return ""
+        except Exception as e:
+            logging.error(f"Error formatting prompt: {str(e)}")
+            return ""
     
     @staticmethod
     @st.cache_resource
@@ -428,189 +664,80 @@ Output:"""
         return LocalHuggingFaceModel(self.model, self.tokenizer, max_length=512)
     
     def generate_answer(self, query: str) -> str:
-        try:
-            logging.info(f"Generating answer for query: {query}")
+        """
+        Gera uma resposta baseada na consulta do usuário.
+        
+        Args:
+            query: A consulta do usuário
             
-            # Validate input query
+        Returns:
+            Uma resposta formatada
+        """
+        try:
             if not query or not query.strip():
                 logging.error("Empty query provided")
-                return "Error: Please provide a non-empty query"
-                
-            # Check if models are available
-            if isinstance(self.translator, DummyModel) or isinstance(self.researcher, DummyModel) or \
-               isinstance(self.summarizer, DummyModel) or isinstance(self.presenter, DummyModel):
-                logging.error("One or more models are not available")
-                return """
-                # 🚨 Serviço Temporariamente Indisponível 🚨
-                
-                Desculpe, estamos enfrentando problemas de conexão com nossos serviços de modelo de linguagem.
-                
-                ## Possíveis causas:
-                - Problemas de conexão com a internet
-                - Servidores do Hugging Face podem estar sobrecarregados ou temporariamente indisponíveis
-                - Limitações de recursos do sistema
-                
-                ## O que você pode fazer:
-                - Tente novamente mais tarde
-                - Verifique sua conexão com a internet
-                - Entre em contato com o suporte se o problema persistir
-                
-                Agradecemos sua compreensão!
-                """
-                
-            # Format translation prompt
-            translation_prompt = self._format_prompt(
-                role="Translate the following text to English",
-                instructions="Provide a direct English translation of the input text.",
-                query=query
-            )
-            logging.info(f"Translation prompt: {translation_prompt}")
+                return "Erro: Por favor, forneça uma consulta não vazia."
             
-            # Validate translation prompt
-            if not translation_prompt or not translation_prompt.strip():
-                logging.error("Empty translation prompt generated")
-                return "Error: Unable to generate translation prompt"
+            logging.info(f"Generating answer for query: {query}")
             
-            # Get English translation
-            translation = self.translator.run(translation_prompt, stream=False)
-            logging.info(f"Translation result type: {type(translation)}")
-            logging.info(f"Translation result: {translation}")
+            # Verificar se os modelos estão disponíveis
+            if not self.translator or not self.researcher or not self.presenter:
+                logging.error("Models not available")
+                return "Desculpe, o serviço está temporariamente indisponível. Por favor, tente novamente mais tarde."
             
-            if not translation:
-                logging.error("Translation failed")
-                return "Error: Unable to translate the query"
+            # Traduzir a consulta para inglês
+            translation_prompt = self._format_prompt("translation", query)
+            logging.info(f"Translation prompt: {translation_prompt}")
             
-            if hasattr(translation, 'content'):
-                translation_content = translation.content
+            try:
+                translation_result = self.translator.run(translation_prompt)
+                logging.info(f"Translation result type: {type(translation_result)}")
+                
+                # Extrair o conteúdo da resposta
+                translation_content = self._extract_content(translation_result)
                 logging.info(f"Translation content: {translation_content}")
-            else:
-                translation_content = str(translation)
-                logging.info(f"Translation as string: {translation_content}")
-
-            # Validate translation content
-            if not translation_content or not translation_content.strip():
-                logging.error("Empty translation content")
-                return "Error: Empty translation result"
-            
-            # Format research prompt
-            research_prompt = self._format_prompt(
-                role="Research Assistant",
-                instructions="Provide a clear and concise answer based on scientific sources.",
-                query=translation_content
-            )
-            logging.info(f"Research prompt: {research_prompt}")
-            
-            # Validate research prompt
-            if not research_prompt or not research_prompt.strip():
-                logging.error("Empty research prompt generated")
-                return "Error: Unable to generate research prompt"
-            
-            # Get research results
-            research_results = self.researcher.run(research_prompt, stream=False)
-            logging.info(f"Research results type: {type(research_results)}")
-            logging.info(f"Research results: {research_results}")
-            
-            if not research_results:
-                logging.error("Research failed")
-                return "Error: Unable to perform research"
-
-            if hasattr(research_results, 'content'):
-                research_content = research_results.content
+                
+                if not translation_content or not translation_content.strip():
+                    logging.error("Empty translation result")
+                    return "Desculpe, não foi possível processar sua consulta. Por favor, tente novamente com uma pergunta diferente."
+                
+                # Realizar a pesquisa
+                research_prompt = self._format_prompt("research", translation_content)
+                logging.info(f"Research prompt: {research_prompt}")
+                
+                research_result = self.researcher.run(research_prompt)
+                logging.info(f"Research result type: {type(research_result)}")
+                
+                # Extrair o conteúdo da pesquisa
+                research_content = self._extract_content(research_result)
                 logging.info(f"Research content: {research_content}")
-            else:
-                research_content = str(research_results)
-                logging.info(f"Research as string: {research_content}")
-
-            # Validate research content
-            if not research_content or not research_content.strip():
-                logging.error("Empty research content")
-                return "Error: Empty research result"
-                
-            logging.info(f"Research results: {research_results}")
-            
-            # Format summary prompt
-            summary_prompt = self._format_prompt(
-                role="Summary Assistant",
-                instructions="Provide a clear and concise summary of the research results.",
-                query=research_content
-            )
-            logging.info(f"Summary prompt: {summary_prompt}")
-            
-            # Validate summary prompt
-            if not summary_prompt or not summary_prompt.strip():
-                logging.error("Empty summary prompt generated")
-                return "Error: Unable to generate summary prompt"
-            
-            # Get summary
-            summary = self.summarizer.run(summary_prompt, stream=False)
-            logging.info(f"Summary type: {type(summary)}")
-            logging.info(f"Summary: {summary}")
-            
-            if not summary:
-                logging.error("Summary failed")
-                return "Error: Unable to generate summary"
-
-            if hasattr(summary, 'content'):
-                summary_content = summary.content
-                logging.info(f"Summary content: {summary_content}")
-            else:
-                summary_content = str(summary)
-                logging.info(f"Summary as string: {summary_content}")
-
-            # Validate summary content
-            if not summary_content or not summary_content.strip():
-                logging.error("Empty summary content")
-                return "Error: Empty summary result"
-                
-            logging.info(f"Summary: {summary}")
-            
-            # Format presentation prompt
-            presentation_prompt = self._format_prompt(
-                role="Presentation Assistant",
-                instructions="Provide a clear and concise presentation of the research results.",
-                query=summary_content
-            )
-            logging.info(f"Presentation prompt: {presentation_prompt}")
-            
-            # Validate presentation prompt
-            if not presentation_prompt or not presentation_prompt.strip():
-                logging.error("Empty presentation prompt generated")
-                return "Error: Unable to generate presentation prompt"
-            
-            # Get presentation
-            presentation = self.presenter.run(presentation_prompt, stream=False)
-            logging.info(f"Presentation type: {type(presentation)}")
-            logging.info(f"Presentation: {presentation}")
-            
-            if not presentation:
-                logging.error("Presentation failed")
-                return "Error: Unable to generate presentation"
-
-            if hasattr(presentation, 'content'):
-                presentation_content = presentation.content
+                
+                if not research_content or not research_content.strip():
+                    logging.error("Empty research result")
+                    return "Desculpe, não foi possível encontrar informações sobre sua consulta. Por favor, tente novamente com uma pergunta diferente."
+                
+                # Apresentar os resultados
+                presentation_prompt = self._format_prompt("presentation", research_content)
+                logging.info(f"Presentation prompt: {presentation_prompt}")
+                
+                presentation_result = self.presenter.run(presentation_prompt)
+                logging.info(f"Presentation type: {type(presentation_result)}")
+                
+                # Extrair o conteúdo da apresentação
+                presentation_content = self._extract_content(presentation_result)
                 logging.info(f"Presentation content: {presentation_content}")
                 
-                # Check if content is empty or just whitespace
-                if not presentation_content.strip():
-                    logging.error("Presentation content is empty or whitespace")
-                    return "Error: Empty presentation content"
+                if not presentation_content or not presentation_content.strip():
+                    logging.error("Empty presentation result")
+                    return "Desculpe, não foi possível formatar a resposta. Por favor, tente novamente."
                 
+                logging.info("Answer generated successfully")
                 return presentation_content
-            else:
-                presentation_str = str(presentation)
-                logging.info(f"Presentation as string: {presentation_str}")
                 
-                # Check if content is empty or just whitespace
-                if not presentation_str.strip():
-                    logging.error("Presentation string is empty or whitespace")
-                    return "Error: Empty presentation string"
+            except Exception as e:
+                logging.error(f"Error during answer generation: {str(e)}")
+                return f"Desculpe, ocorreu um erro ao processar sua consulta: {str(e)}. Por favor, tente novamente mais tarde."
                 
-                return presentation_str
-
         except Exception as e:
-            logging.error(f"Error generating answer: {str(e)}")
-            if hasattr(e, 'args') and len(e.args) > 0:
-                error_message = e.args[0]
-            else:
-                error_message = str(e)
-            return f"Error: {error_message}"
+            logging.error(f"Unexpected error in generate_answer: {str(e)}")
+            return "Desculpe, ocorreu um erro inesperado. Por favor, tente novamente mais tarde."

test_model.py

@@ -0,0 +1,40 @@
+import logging
+import sys
+from services.model_handler import ModelHandler
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+def main():
+    """Test the model handler"""
+    try:
+        # Initialize the model handler
+        logging.info("Initializing model handler...")
+        model_handler = ModelHandler()
+        
+        # Test query
+        test_query = "O que é autismo?"
+        logging.info(f"Testing with query: {test_query}")
+        
+        # Generate answer
+        answer = model_handler.generate_answer(test_query)
+        
+        # Print the answer
+        logging.info("Answer generated successfully")
+        print("\n" + "="*50 + "\n")
+        print(answer)
+        print("\n" + "="*50 + "\n")
+        
+    except Exception as e:
+        logging.error(f"Error in test script: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()