pass prompt

services/model_handler.py

@@ -284,139 +284,6 @@ class LocalHuggingFaceModel(Model):
                 error_message = str(e)
             return f"Error during generation: {error_message}"
 
-class DummyModel(Model):
-    def __init__(self):
-        super().__init__(id="dummy-model")
-        
-    async def ainvoke(self, prompt: str, **kwargs) -> str:
-        """Async invoke method"""
-        return await self.invoke(prompt=prompt, **kwargs)
-    
-    async def ainvoke_stream(self, prompt: str, **kwargs):
-        """Async streaming invoke method"""
-        result = await self.invoke(prompt=prompt, **kwargs)
-        yield result
-    
-    def invoke(self, prompt: str, **kwargs) -> str:
-        """Synchronous invoke method"""
-        return Response("Sorry, the model is not available. Please try again later.")
-    
-    def invoke_stream(self, prompt: str, **kwargs):
-        """Synchronous streaming invoke method"""
-        result = self.invoke(prompt=prompt, **kwargs)
-        yield result
-    
-    def parse_provider_response(self, response: str) -> str:
-        """Parse the provider response"""
-        return response
-    
-    def parse_provider_response_delta(self, delta: str) -> str:
-        """Parse the provider response delta for streaming"""
-        return delta
-        
-    async def aresponse(self, prompt=None, **kwargs):
-        """Async response method - required abstract method"""
-        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)}")
-    
-    def response(self, prompt=None, **kwargs):
-        """Synchronous response method - required abstract method"""
-        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"""
-        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:
     """
     Classe para gerenciar modelos e gerar respostas.
@@ -609,10 +476,6 @@ Output:"""
         """Initialize local model as fallback"""
         model, tokenizer = self._load_model()
         
-        if model is None or tokenizer is None:
-            # Create a dummy model that returns a helpful message
-            return DummyModel()
-        
         return LocalHuggingFaceModel(model, tokenizer)
     
     def generate_answer(self, query: str) -> str:
@@ -653,30 +516,26 @@ Output:"""
                     logging.error("Empty translation result")
                     return "Desculpe, não foi possível processar sua consulta. Por favor, tente novamente com uma pergunta diferente."
                 
-                # Se forçar resposta padrão, pular a pesquisa e usar diretamente a resposta padrão
-                if self.force_default_response:
-                    logging.info("Forcing default response")
-                    research_content = self._get_default_research_content(translation_content)
-                else:
-                    # 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}")
-                    
-                    # Verificar se a resposta da pesquisa é muito curta
-                    research_length = len(research_content.strip()) if research_content and isinstance(research_content, str) else 0
-                    logging.info(f"Research content length: {research_length} characters")
-                    
-                    if not research_content or not research_content.strip() or research_length < 150:
-                        logging.warning(f"Research result too short ({research_length} chars), trying with a more specific prompt")
-                        # Tentar novamente com um prompt mais específico
-                        enhanced_prompt = f"""Task: Detailed Research
+
+                # 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}")
+                
+                # Verificar se a resposta da pesquisa é muito curta
+                research_length = len(research_content.strip()) if research_content and isinstance(research_content, str) else 0
+                logging.info(f"Research content length: {research_length} characters")
+                
+                if not research_content or not research_content.strip() or research_length < 150:
+                    logging.warning(f"Research result too short ({research_length} chars), trying with a more specific prompt")
+                    # Tentar novamente com um prompt mais específico
+                    enhanced_prompt = f"""Task: Detailed Research
 
 Instructions:
 Provide a comprehensive explanation about '{translation_content}'.
@@ -686,45 +545,34 @@ Be thorough and informative, covering all important aspects of the topic.
 Use clear and accessible language suitable for a general audience.
 
 Output:"""
-                        logging.info(f"Enhanced research prompt: {enhanced_prompt}")
-                        research_result = self.researcher.run(enhanced_prompt)
-                        research_content = self._extract_content(research_result)
-                        research_length = len(research_content.strip()) if research_content and isinstance(research_content, str) else 0
-                        logging.info(f"Enhanced research content: {research_content}")
-                        logging.info(f"Enhanced research content length: {research_length} characters")
-                    
-                    # Se ainda estiver vazio ou muito curto, usar uma resposta padrão
+                    logging.info(f"Enhanced research prompt: {enhanced_prompt}")
+                    research_result = self.researcher.run(enhanced_prompt)
+                    research_content = self._extract_content(research_result)
+                    research_length = len(research_content.strip()) if research_content and isinstance(research_content, str) else 0
+                    logging.info(f"Enhanced research content: {research_content}")
+                    logging.info(f"Enhanced research content length: {research_length} characters")
+                
                     if not research_content or not research_content.strip() or research_length < 150:
                         logging.warning(f"Research result still too short ({research_length} chars), using default response")
                         # Usar resposta padrão
                         logging.info("Using default research content")
                         research_content = self._get_default_research_content(translation_content)
                 
-                # Se forçar resposta padrão, pular a apresentação e usar diretamente a resposta padrão
-                if self.force_default_response:
-                    logging.info("Forcing default presentation")
-                    presentation_content = self._get_default_presentation_content()
-                else:
-                    # 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}")
-                    
-                    # Verificar se a apresentação é muito curta
-                    presentation_length = len(presentation_content.strip()) if presentation_content and isinstance(presentation_content, str) else 0
-                    logging.info(f"Presentation content length: {presentation_length} characters")
-                    
-                    if not presentation_content or not presentation_content.strip() or presentation_length < 150:
-                        logging.warning(f"Presentation result too short ({presentation_length} chars), using default presentation")
-                        # Usar apresentação padrão
-                        logging.info("Using default presentation content")
-                        presentation_content = self._get_default_presentation_content()
+
+                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)}")
+                
+                presentation_content = self._extract_content(presentation_result)
+                logging.info(f"Presentation content: {presentation_content}")
+                
+                presentation_length = len(presentation_content.strip()) if presentation_content and isinstance(presentation_content, str) else 0
+                logging.info(f"Presentation content length: {presentation_length} characters")
+                
+                if not presentation_content or not presentation_content.strip() or presentation_length < 150:
+                    logging.warning(f"Presentation result too short ({presentation_length} chars), using default presentation")
                 
                 logging.info("Answer generated successfully")
                 return presentation_content
@@ -736,59 +584,4 @@ Output:"""
         except Exception as e:
             logging.error(f"Unexpected error in generate_answer: {str(e)}")
             return "Desculpe, ocorreu um erro inesperado. Por favor, tente novamente mais tarde."
-    
-    def _get_default_research_content(self, topic: str) -> str:
-        """
-        Retorna um conteúdo de pesquisa padrão para o tópico.
-        
-        Args:
-            topic: O tópico da pesquisa
-            
-        Returns:
-            Conteúdo de pesquisa padrão
-        """
-        return f"""Information about {topic}:
-                    
-Autism is a complex neurodevelopmental disorder that affects communication, social interaction, and behavior. It is characterized by challenges with social skills, repetitive behaviors, speech, and nonverbal communication.
-
-The condition is part of a broader category called autism spectrum disorder (ASD), which reflects the wide variation in challenges and strengths possessed by each person with autism. Some individuals with autism may require significant support in their daily lives, while others may need less support and, in some cases, live entirely independently.
-
-Autism is believed to be caused by a combination of genetic and environmental factors. Research suggests that certain genetic mutations may increase the risk of autism, as well as various environmental factors that influence early brain development. There is no single cause for autism, making it a complex condition to understand and treat.
-
-Early diagnosis and intervention are important for improving outcomes for individuals with autism. Various therapies and support strategies can help people with autism develop skills and cope with challenges. These may include behavioral therapy, speech therapy, occupational therapy, and educational support.
-
-It's important to note that autism is not a disease to be cured but a different way of experiencing and interacting with the world. Many people with autism have exceptional abilities in visual skills, music, math, and art, among other areas."""
-    
-    def _get_default_presentation_content(self) -> str:
-        """
-        Retorna um conteúdo de apresentação padrão.
-        
-        Returns:
-            Conteúdo de apresentação padrão
-        """
-        return """🧠 **Autismo: Entendendo o Espectro** 🧠
-
-## O que é o Autismo?
-O autismo é uma condição neurológica complexa que afeta a comunicação, interação social e comportamento. É caracterizado por desafios com habilidades sociais, comportamentos repetitivos, fala e comunicação não verbal.
-
-## Características Principais:
-- 🔄 Comportamentos repetitivos e interesses restritos
-- 🗣️ Dificuldades na comunicação verbal e não verbal
-- 👥 Desafios nas interações sociais
-- 🎭 Dificuldade em entender expressões faciais e emoções
-- 🔊 Sensibilidade sensorial (sons, luzes, texturas)
-
-## Causas e Origens:
-O autismo é causado por uma combinação de fatores genéticos e ambientais. Pesquisas sugerem que certas mutações genéticas podem aumentar o risco, assim como vários fatores ambientais que influenciam o desenvolvimento inicial do cérebro.
-
-## Pontos Importantes:
-- 📊 O autismo afeta cada pessoa de maneira diferente (por isso é chamado de "espectro")
-- 🧩 Diagnóstico precoce e intervenção melhoram os resultados
-- 💪 Muitas pessoas com autismo têm habilidades excepcionais em áreas específicas
-- 🌈 O autismo não é uma doença a ser curada, mas uma forma diferente de experimentar o mundo
-
-## Conclusão:
-Compreender o autismo é essencial para criar uma sociedade mais inclusiva. Cada pessoa com autismo tem suas próprias forças e desafios únicos, e merece apoio e aceitação.
-
-*Fonte: Pesquisas científicas atuais sobre transtornos do espectro autista*
-"""
+