atendentepro 0.3.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

atendentepro/network.py

@@ -20,6 +20,8 @@ from atendentepro.agents import (
     create_confirmation_agent,
     create_usage_agent,
     create_onboarding_agent,
+    create_escalation_agent,
+    create_feedback_agent,
     TriageAgent,
     FlowAgent,
     InterviewAgent,
@@ -28,6 +30,8 @@ from atendentepro.agents import (
     ConfirmationAgent,
     UsageAgent,
     OnboardingAgent,
+    EscalationAgent,
+    FeedbackAgent,
 )
 from atendentepro.guardrails import get_guardrails_for_agent, set_guardrails_client
 from atendentepro.license import require_activation
@@ -60,6 +64,8 @@ class AgentNetwork:
     confirmation: Optional[ConfirmationAgent] = None
     usage: Optional[UsageAgent] = None
     onboarding: Optional[OnboardingAgent] = None
+    escalation: Optional[EscalationAgent] = None
+    feedback: Optional[FeedbackAgent] = None
     
     templates_root: Optional[Path] = None
     current_client: str = "standard"
@@ -68,35 +74,67 @@ class AgentNetwork:
         """Get list of all configured agents."""
         agents = []
         for attr in ["triage", "flow", "interview", "answer", "knowledge", 
-                     "confirmation", "usage", "onboarding"]:
+                     "confirmation", "usage", "onboarding", "escalation", "feedback"]:
             agent = getattr(self, attr, None)
             if agent:
                 agents.append(agent)
         return agents
+    
+    def add_escalation_to_all(self) -> None:
+        """Add escalation agent as handoff to all other agents."""
+        if not self.escalation:
+            return
+        
+        for agent in self.get_all_agents():
+            if agent != self.escalation and self.escalation not in agent.handoffs:
+                agent.handoffs.append(self.escalation)
+    
+    def add_feedback_to_all(self) -> None:
+        """Add feedback agent as handoff to all other agents."""
+        if not self.feedback:
+            return
+        
+        for agent in self.get_all_agents():
+            if agent != self.feedback and self.feedback not in agent.handoffs:
+                agent.handoffs.append(self.feedback)
 
 
 def create_standard_network(
     templates_root: Path,
     client: str = "standard",
     include_onboarding: bool = False,
+    include_escalation: bool = True,
+    include_feedback: bool = True,
+    escalation_channels: str = "",
+    feedback_protocol_prefix: str = "TKT",
+    feedback_brand_color: str = "#4A90D9",
+    feedback_brand_name: str = "Atendimento",
     custom_tools: Optional[Dict[str, List]] = None,
 ) -> AgentNetwork:
     """
     Create a standard agent network with proper handoff configuration.
     
     This creates the default network configuration with:
-    - Triage -> Flow, Confirmation, Knowledge, Usage
-    - Flow -> Interview, Triage
-    - Interview -> Answer
-    - Answer -> Triage, Interview
-    - Confirmation -> Triage
-    - Knowledge -> Triage
-    - Usage -> Triage
+    - Triage -> Flow, Confirmation, Knowledge, Usage, Escalation, Feedback
+    - Flow -> Interview, Triage, Escalation, Feedback
+    - Interview -> Answer, Escalation, Feedback
+    - Answer -> Triage, Escalation, Feedback
+    - Confirmation -> Triage, Escalation, Feedback
+    - Knowledge -> Triage, Escalation, Feedback
+    - Usage -> Triage, Escalation, Feedback
+    - Escalation -> Triage
+    - Feedback -> Triage, Escalation
     
     Args:
         templates_root: Root directory for template configurations.
         client: Client key to load configurations for.
         include_onboarding: Whether to include the onboarding agent.
+        include_escalation: Whether to include the escalation agent (default True).
+        include_feedback: Whether to include the feedback agent (default True).
+        escalation_channels: Description of available escalation channels.
+        feedback_protocol_prefix: Prefix for ticket protocols (e.g., "SAC", "TKT").
+        feedback_brand_color: Brand color for feedback emails.
+        feedback_brand_name: Brand name for feedback emails.
         custom_tools: Optional dict of custom tools by agent name.
         
     Returns:
@@ -217,14 +255,72 @@ def create_standard_network(
         guardrails=get_guardrails_for_agent("Usage Agent", templates_root),
     )
     
+    # Create escalation agent if requested
+    escalation = None
+    if include_escalation:
+        escalation = create_escalation_agent(
+            escalation_channels=escalation_channels,
+            tools=tools.get("escalation", []),
+            guardrails=get_guardrails_for_agent("Escalation Agent", templates_root),
+        )
+    
+    # Create feedback agent if requested
+    feedback = None
+    if include_feedback:
+        feedback = create_feedback_agent(
+            protocol_prefix=feedback_protocol_prefix,
+            email_brand_color=feedback_brand_color,
+            email_brand_name=feedback_brand_name,
+            tools=tools.get("feedback", []),
+            guardrails=get_guardrails_for_agent("Feedback Agent", templates_root),
+        )
+    
     # Configure handoffs
-    triage.handoffs = [flow, confirmation, knowledge, usage]
-    flow.handoffs = [interview, triage]
-    confirmation.handoffs = [triage]
-    knowledge.handoffs = [triage]
-    usage.handoffs = [triage]
-    interview.handoffs = [answer]
-    answer.handoffs = [triage, interview]
+    triage_handoffs = [flow, confirmation, knowledge, usage]
+    flow_handoffs = [interview, triage]
+    confirmation_handoffs = [triage]
+    knowledge_handoffs = [triage]
+    usage_handoffs = [triage]
+    interview_handoffs = [answer]
+    answer_handoffs = [triage]  # Answer só volta para Triage (não faz sentido voltar para Interview)
+    escalation_handoffs = [triage]
+    feedback_handoffs = [triage]
+    
+    # Add escalation to all agents if enabled
+    if escalation:
+        triage_handoffs.append(escalation)
+        flow_handoffs.append(escalation)
+        confirmation_handoffs.append(escalation)
+        knowledge_handoffs.append(escalation)
+        usage_handoffs.append(escalation)
+        interview_handoffs.append(escalation)
+        answer_handoffs.append(escalation)
+        if feedback:
+            feedback_handoffs.append(escalation)
+    
+    # Add feedback to all agents if enabled
+    if feedback:
+        triage_handoffs.append(feedback)
+        flow_handoffs.append(feedback)
+        confirmation_handoffs.append(feedback)
+        knowledge_handoffs.append(feedback)
+        usage_handoffs.append(feedback)
+        interview_handoffs.append(feedback)
+        answer_handoffs.append(feedback)
+        if escalation:
+            escalation_handoffs.append(feedback)
+    
+    triage.handoffs = triage_handoffs
+    flow.handoffs = flow_handoffs
+    confirmation.handoffs = confirmation_handoffs
+    knowledge.handoffs = knowledge_handoffs
+    usage.handoffs = usage_handoffs
+    interview.handoffs = interview_handoffs
+    answer.handoffs = answer_handoffs
+    if escalation:
+        escalation.handoffs = escalation_handoffs
+    if feedback:
+        feedback.handoffs = feedback_handoffs
     
     network = AgentNetwork(
         triage=triage,
@@ -234,6 +330,8 @@ def create_standard_network(
         knowledge=knowledge,
         confirmation=confirmation,
         usage=usage,
+        escalation=escalation,
+        feedback=feedback,
         templates_root=templates_root,
         current_client=client,
     )
@@ -309,6 +407,8 @@ def create_custom_network(
         "confirmation": network.confirmation,
         "usage": network.usage,
         "onboarding": network.onboarding,
+        "escalation": network.escalation,
+        "feedback": network.feedback,
     }
     
     # Apply custom handoff configuration

atendentepro/prompts/__init__.py

@@ -8,6 +8,8 @@ from .answer import get_answer_prompt, AnswerPromptBuilder
 from .knowledge import get_knowledge_prompt, KnowledgePromptBuilder
 from .confirmation import get_confirmation_prompt, ConfirmationPromptBuilder
 from .onboarding import get_onboarding_prompt, OnboardingPromptBuilder
+from .escalation import get_escalation_prompt, EscalationPromptBuilder, ESCALATION_INTRO
+from .feedback import get_feedback_prompt, FeedbackPromptBuilder, FEEDBACK_INTRO
 
 __all__ = [
     # Triage
@@ -31,5 +33,13 @@ __all__ = [
     # Onboarding
     "get_onboarding_prompt",
     "OnboardingPromptBuilder",
+    # Escalation
+    "get_escalation_prompt",
+    "EscalationPromptBuilder",
+    "ESCALATION_INTRO",
+    # Feedback
+    "get_feedback_prompt",
+    "FeedbackPromptBuilder",
+    "FEEDBACK_INTRO",
 ]
 

atendentepro/prompts/answer.py

@@ -22,7 +22,6 @@ ANSWER_INTRO = """
 Você é um agente de resposta especializado.
 Você deverá responder à pergunta do usuário usando o template de resposta configurado.
 Use as informações coletadas durante a entrevista para fornecer uma resposta precisa e útil.
-Se precisar de mais informações, transfira para o interview_agent com orientações objetivas.
 Sempre que concluir uma resposta válida ao usuário, assim que receber qualquer outra pergunta, transfira a conversa para o triage_agent.
 Nas mensagens ao usuário, utilize linguagem natural e evite revelar processos internos, etapas de análise ou nomes de agentes.
 """
@@ -76,7 +75,7 @@ ANSWER_OUTPUT = """
     1. Envie a mensagem final ao usuário.
     2. Em seguida, com qualquer pergunta, transfira a conversa para o triage_agent.
 - (Raciocínio interno) Se a resposta não estiver completa:
-    1. Explique internamente quais dados faltam e transfira para o interview_agent para coletar as informações necessárias.
+    1. Solicite as informações faltantes diretamente ao usuário de forma clara e objetiva.
 - (Mensagem ao usuário) Resuma apenas o necessário, sem mencionar transferências, ferramentas ou processos internos.
 """
 
@@ -95,7 +94,7 @@ def get_answer_prompt(answer_template: str = "") -> str:
 [ROUTE]
 - (Raciocínio interno) Responder à pergunta do usuário usando o template de resposta como guia: 
   {answer_template}
-- (Raciocínio interno) Identifique se todas as informações obrigatórias do template estão preenchidas. Se faltar algo, prepare um pedido específico para o interview_agent recuperar a informação ausente.
+- (Raciocínio interno) Identifique se todas as informações obrigatórias do template estão preenchidas. Se faltar algo, solicite diretamente ao usuário.
 """
 
     return "\n".join([

atendentepro/prompts/escalation.py

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+"""Escalation Agent prompts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class EscalationPromptBuilder:
+    """Builder for Escalation Agent prompts."""
+    
+    escalation_triggers: str = ""
+    escalation_channels: str = ""
+    
+    def build(self) -> str:
+        """Build the complete escalation agent prompt."""
+        return get_escalation_prompt(
+            escalation_triggers=self.escalation_triggers,
+            escalation_channels=self.escalation_channels,
+        )
+
+
+ESCALATION_INTRO = """
+Você é o Agente de Escalação, responsável por transferir conversas para atendimento humano.
+Sua função é garantir que o usuário receba o suporte adequado quando o sistema automatizado não consegue resolver.
+"""
+
+ESCALATION_MODULES = """
+Deve seguir as seguintes etapas de forma sequencial (todas são raciocínio interno; não exponha nada ao usuário):
+[READ] - [IDENTIFY] - [COLLECT] - [VERIFY] - [REGISTER] - [INFORM] - [OUTPUT]
+"""
+
+ESCALATION_READ = """
+[READ]
+- (Raciocínio interno) Leia cuidadosamente a mensagem do usuário e identifique o motivo da escalação.
+- (Raciocínio interno) Verifique se é uma solicitação explícita ou se foi encaminhado por outro agente.
+"""
+
+ESCALATION_IDENTIFY = """
+[IDENTIFY]
+- (Raciocínio interno) Identifique o tipo de escalação necessária:
+  - Solicitação explícita do usuário ("quero falar com um humano")
+  - Tópico não coberto pelo sistema
+  - Frustração ou insatisfação do usuário
+  - Problema complexo que requer análise humana
+  - Questões jurídicas, financeiras ou críticas
+"""
+
+ESCALATION_COLLECT = """
+[COLLECT]
+- (Raciocínio interno) Colete as informações necessárias para a escalação:
+  - Nome do usuário (se ainda não coletado)
+  - Telefone ou email para contato
+  - Motivo resumido da escalação
+  - Nível de urgência (normal ou urgente)
+"""
+
+ESCALATION_VERIFY = """
+[VERIFY]
+- (Raciocínio interno) Verifique o horário de atendimento humano.
+- (Raciocínio interno) Se estiver fora do horário, informe ao usuário e ofereça alternativas.
+- (Raciocínio interno) Se estiver dentro do horário, prossiga com o registro.
+"""
+
+ESCALATION_REGISTER = """
+[REGISTER]
+- (Raciocínio interno) Utilize a ferramenta registrar_escalacao para criar o registro.
+- (Raciocínio interno) Anote o número do protocolo gerado para informar ao usuário.
+"""
+
+ESCALATION_INFORM = """
+[INFORM]
+- (Raciocínio interno) Prepare a mensagem final com:
+  - Confirmação de que a escalação foi registrada
+  - Número do protocolo
+  - Canais de atendimento disponíveis
+  - Tempo estimado de espera (se aplicável)
+"""
+
+ESCALATION_OUTPUT = """
+[OUTPUT]
+- (Mensagem ao usuário) Informe que a solicitação de atendimento humano foi registrada.
+- (Mensagem ao usuário) Forneça o protocolo e os canais de contato de forma clara.
+- (Mensagem ao usuário) Seja empático e tranquilize o usuário sobre o atendimento.
+"""
+
+DEFAULT_ESCALATION_TRIGGERS = """
+## Gatilhos de Escalação
+
+### Solicitações Explícitas
+- "quero falar com um humano"
+- "atendente humano"
+- "falar com uma pessoa"
+- "transferir para atendente"
+- "pessoa real"
+
+### Frustração do Usuário
+- "você não está me ajudando"
+- "isso não resolve"
+- "já tentei de tudo"
+- "não funciona"
+- "estou frustrado"
+
+### Tópicos Não Cobertos
+- Questões jurídicas
+- Cancelamento de contrato
+- Reclamações formais graves
+- Processos administrativos
+"""
+
+
+def get_escalation_prompt(
+    escalation_triggers: str = "",
+    escalation_channels: str = "",
+) -> str:
+    """
+    Build the escalation agent prompt.
+    
+    Args:
+        escalation_triggers: Custom triggers for escalation.
+        escalation_channels: Available channels (phone, email, chat).
+        
+    Returns:
+        Complete escalation agent prompt.
+    """
+    intro = f"""
+{ESCALATION_INTRO}
+
+## Seu Papel
+
+Você ajuda os usuários que precisam de atendimento humano:
+1. **Identificar** o motivo da escalação
+2. **Coletar** informações de contato
+3. **Verificar** disponibilidade de atendimento
+4. **Registrar** a solicitação
+5. **Informar** o protocolo e canais disponíveis
+
+## Quando Escalar
+
+- O usuário solicita explicitamente falar com um humano
+- O tópico não é coberto pelo sistema automatizado
+- O usuário demonstra frustração ou insatisfação
+- O problema é complexo e requer análise humana
+- Questões jurídicas, financeiras ou críticas
+"""
+
+    triggers = escalation_triggers or DEFAULT_ESCALATION_TRIGGERS
+    
+    channels_section = ""
+    if escalation_channels:
+        channels_section = f"""
+## Canais Disponíveis
+
+{escalation_channels}
+"""
+    
+    guidelines = """
+## Diretrizes
+
+- Seja empático e demonstre que entende a necessidade do usuário
+- Nunca force o usuário a usar o sistema automatizado se ele quer um humano
+- Colete apenas as informações essenciais para o contato
+- Informe claramente o tempo estimado de resposta
+- Se fora do horário, ofereça alternativas (callback, email, etc.)
+
+## Tom de Voz
+
+- Seja compreensivo e profissional
+- Valide os sentimentos do usuário
+- Transmita confiança de que o problema será resolvido
+- Evite frases como "infelizmente" ou "não é possível"
+"""
+
+    return "\n".join([
+        intro,
+        triggers,
+        channels_section,
+        guidelines,
+        ESCALATION_MODULES,
+        ESCALATION_READ,
+        ESCALATION_IDENTIFY,
+        ESCALATION_COLLECT,
+        ESCALATION_VERIFY,
+        ESCALATION_REGISTER,
+        ESCALATION_INFORM,
+        ESCALATION_OUTPUT,
+    ])
+

atendentepro/prompts/feedback.py

@@ -0,0 +1,232 @@
+# -*- coding: utf-8 -*-
+"""Feedback Agent prompts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class FeedbackPromptBuilder:
+    """Builder for Feedback Agent prompts."""
+    
+    ticket_types: Optional[List[str]] = None
+    protocol_prefix: str = "TKT"
+    brand_name: str = "Atendimento"
+    sla_message: str = "Retornaremos em até 24h úteis."
+    
+    def build(self) -> str:
+        """Build the complete feedback agent prompt."""
+        return get_feedback_prompt(
+            ticket_types=self.ticket_types,
+            protocol_prefix=self.protocol_prefix,
+            brand_name=self.brand_name,
+            sla_message=self.sla_message,
+        )
+
+
+FEEDBACK_INTRO = """
+Você é o Agente de Feedback, responsável por registrar solicitações dos usuários.
+Sua função é coletar informações e criar tickets para acompanhamento posterior.
+"""
+
+FEEDBACK_MODULES = """
+Deve seguir as seguintes etapas de forma sequencial (todas são raciocínio interno; não exponha nada ao usuário):
+[READ] - [CLASSIFY] - [COLLECT] - [VALIDATE] - [CREATE] - [CONFIRM] - [OUTPUT]
+"""
+
+FEEDBACK_READ = """
+[READ]
+- (Raciocínio interno) Leia cuidadosamente a mensagem do usuário e identifique o tipo de solicitação.
+- (Raciocínio interno) Determine se é dúvida, feedback, reclamação, sugestão, elogio ou problema.
+"""
+
+FEEDBACK_CLASSIFY = """
+[CLASSIFY]
+- (Raciocínio interno) Classifique a solicitação:
+  - **Dúvida**: Pergunta que precisa de pesquisa ou análise
+  - **Feedback**: Opinião sobre produto ou serviço
+  - **Reclamação**: Insatisfação formal que requer atenção
+  - **Sugestão**: Ideia de melhoria
+  - **Elogio**: Agradecimento ou reconhecimento positivo
+  - **Problema**: Bug, erro técnico ou falha operacional
+- (Raciocínio interno) Defina a prioridade baseada no tipo:
+  - Reclamações e problemas: prioridade ALTA
+  - Dúvidas e feedbacks: prioridade NORMAL
+  - Sugestões e elogios: prioridade BAIXA
+"""
+
+FEEDBACK_COLLECT = """
+[COLLECT]
+- (Raciocínio interno) Colete as informações obrigatórias:
+  - Tipo do ticket
+  - Descrição detalhada (mínimo 10 caracteres)
+  - Email do usuário para resposta
+- (Raciocínio interno) Colete informações opcionais (se o usuário fornecer):
+  - Nome do usuário
+  - Telefone para contato alternativo
+  - Categoria adicional
+"""
+
+FEEDBACK_VALIDATE = """
+[VALIDATE]
+- (Raciocínio interno) Valide as informações coletadas:
+  - Email em formato válido
+  - Descrição com detalhes suficientes
+  - Tipo válido entre os disponíveis
+- (Raciocínio interno) Se faltar informação, solicite de forma gentil.
+"""
+
+FEEDBACK_CREATE = """
+[CREATE]
+- (Raciocínio interno) Utilize a ferramenta criar_ticket para registrar o ticket.
+- (Raciocínio interno) Anote o número do protocolo gerado.
+- (Raciocínio interno) Após criar, use enviar_email_confirmacao para notificar o usuário.
+"""
+
+FEEDBACK_CONFIRM = """
+[CONFIRM]
+- (Raciocínio interno) Prepare a confirmação com:
+  - Número do protocolo
+  - Tipo e prioridade do ticket
+  - Prazo estimado de resposta (SLA)
+  - Orientação para guardar o protocolo
+"""
+
+FEEDBACK_OUTPUT = """
+[OUTPUT]
+- (Mensagem ao usuário) Confirme o registro do ticket de forma clara e amigável.
+- (Mensagem ao usuário) Forneça o protocolo em destaque.
+- (Mensagem ao usuário) Agradeça o contato e informe o prazo de retorno.
+- (Mensagem ao usuário) Oriente a guardar o protocolo para acompanhamento.
+"""
+
+DEFAULT_TICKET_TYPES = [
+    "duvida",
+    "feedback",
+    "reclamacao",
+    "sugestao",
+    "elogio",
+    "problema",
+]
+
+
+def get_feedback_prompt(
+    ticket_types: Optional[List[str]] = None,
+    protocol_prefix: str = "TKT",
+    brand_name: str = "Atendimento",
+    sla_message: str = "Retornaremos em até 24h úteis.",
+) -> str:
+    """
+    Build the feedback agent prompt.
+    
+    Args:
+        ticket_types: List of allowed ticket types.
+        protocol_prefix: Prefix for protocol numbers.
+        brand_name: Brand name for messages.
+        sla_message: SLA message for users.
+        
+    Returns:
+        Complete feedback agent prompt.
+    """
+    types = ticket_types or DEFAULT_TICKET_TYPES
+    
+    types_description = {
+        "duvida": "❓ **Dúvida** - Pergunta que precisa de pesquisa ou análise",
+        "feedback": "💬 **Feedback** - Opinião sobre produto ou serviço",
+        "reclamacao": "📢 **Reclamação** - Insatisfação formal (prioridade alta)",
+        "sugestao": "💡 **Sugestão** - Ideia de melhoria",
+        "elogio": "⭐ **Elogio** - Agradecimento ou reconhecimento",
+        "problema": "⚠️ **Problema** - Bug, erro técnico ou falha (prioridade alta)",
+        "outro": "📋 **Outro** - Outros tipos de solicitação",
+    }
+    
+    types_list = "\n".join([
+        types_description.get(t, f"- {t}")
+        for t in types
+    ])
+    
+    intro = f"""
+{FEEDBACK_INTRO}
+
+## Seu Papel
+
+Você ajuda os usuários a registrar solicitações para análise posterior:
+1. **Identificar** o tipo de solicitação (dúvida, feedback, reclamação, etc.)
+2. **Coletar** descrição detalhada e dados de contato
+3. **Criar** o ticket no sistema
+4. **Enviar** confirmação por email
+5. **Informar** o protocolo para acompanhamento
+
+## Tipos de Ticket
+
+{types_list}
+
+## Informações Necessárias
+
+### Obrigatórias
+- **Tipo**: Classificação da solicitação
+- **Descrição**: Detalhes do que o usuário precisa (mínimo 10 caracteres)
+- **Email**: Para envio de confirmação e resposta
+
+### Opcionais
+- Nome do usuário
+- Telefone para contato alternativo
+"""
+
+    branding = f"""
+## Configuração
+
+- **Prefixo do protocolo**: {protocol_prefix}
+- **Formato**: {protocol_prefix}-YYYYMMDD-XXXXXX
+- **SLA**: {sla_message}
+"""
+
+    guidelines = """
+## Fluxo de Atendimento
+
+1. Identificar o tipo de solicitação
+2. Coletar descrição detalhada
+3. Coletar email (obrigatório) e dados opcionais
+4. Criar o ticket com `criar_ticket`
+5. Enviar confirmação com `enviar_email_confirmacao`
+6. Informar o protocolo ao usuário
+
+## Prioridades Automáticas
+
+- **Reclamações** → Prioridade ALTA
+- **Problemas** → Prioridade ALTA
+- **Dúvidas/Feedbacks** → Prioridade NORMAL
+- **Sugestões/Elogios** → Prioridade BAIXA
+
+## Tom de Voz
+
+- Seja empático e atencioso
+- Valide os sentimentos do usuário (especialmente em reclamações)
+- Agradeça feedbacks e elogios
+- Seja claro sobre os próximos passos
+- Nunca minimize a importância da solicitação
+
+## Frases Úteis
+
+- "Entendo sua preocupação. Vou registrar isso para nossa equipe analisar."
+- "Obrigado pelo feedback! É muito importante para nós."
+- "Seu ticket foi registrado. Guarde o protocolo para acompanhamento."
+- "Lamento pelo inconveniente. Vamos resolver isso o mais rápido possível."
+"""
+
+    return "\n".join([
+        intro,
+        branding,
+        guidelines,
+        FEEDBACK_MODULES,
+        FEEDBACK_READ,
+        FEEDBACK_CLASSIFY,
+        FEEDBACK_COLLECT,
+        FEEDBACK_VALIDATE,
+        FEEDBACK_CREATE,
+        FEEDBACK_CONFIRM,
+        FEEDBACK_OUTPUT,
+    ])
+